plugins/plugin_python/atrinik_map.c

Go to the documentation of this file.

/************************************************************************
*            Atrinik, a Multiplayer Online Role Playing Game            *
*                                                                       *
*    Copyright (C) 2009-2011 Alex Tokar and Atrinik Development Team    *
*                                                                       *
* Fork from Daimonin (Massive Multiplayer Online Role Playing Game)     *
* and Crossfire (Multiplayer game for X-windows).                       *
*                                                                       *
* This program is free software; you can redistribute it and/or modify  *
* it under the terms of the GNU General Public License as published by  *
* the Free Software Foundation; either version 2 of the License, or     *
* (at your option) any later version.                                   *
*                                                                       *
* This program is distributed in the hope that it will be useful,       *
* but WITHOUT ANY WARRANTY; without even the implied warranty of        *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
* GNU General Public License for more details.                          *
*                                                                       *
* You should have received a copy of the GNU General Public License     *
* along with this program; if not, write to the Free Software           *
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.             *
*                                                                       *
* The author can be reached at admin@atrinik.org                        *
************************************************************************/

#include <plugin_python.h>

/* @cparser
 * @page plugin_python_map_fields Python map fields
 * <h2>Python map fields</h2>
 * List of the map fields and their meaning. */
static fields_struct fields[] =
{
    {"next", FIELDTYPE_MAP, offsetof(mapstruct, next), FIELDFLAG_READONLY, 0},
    {"previous", FIELDTYPE_MAP, offsetof(mapstruct, previous), FIELDFLAG_READONLY, 0},

    {"name", FIELDTYPE_CSTR, offsetof(mapstruct, name), 0, 0},
    {"msg", FIELDTYPE_CSTR, offsetof(mapstruct, msg), 0, 0},
    {"reset_timeout", FIELDTYPE_UINT32, offsetof(mapstruct, reset_timeout), 0, 0},
    {"timeout", FIELDTYPE_SINT32, offsetof(mapstruct, timeout), 0, 0},
    {"difficulty", FIELDTYPE_UINT16, offsetof(mapstruct, difficulty), 0, 0},
    {"height", FIELDTYPE_UINT16, offsetof(mapstruct, height), FIELDFLAG_READONLY, 0},
    {"width", FIELDTYPE_UINT16, offsetof(mapstruct, width), FIELDFLAG_READONLY, 0},
    {"darkness", FIELDTYPE_UINT8, offsetof(mapstruct, darkness), 0, 0},
    {"path", FIELDTYPE_SHSTR, offsetof(mapstruct, path), FIELDFLAG_READONLY, 0},
    {"enter_x", FIELDTYPE_UINT8, offsetof(mapstruct, enter_x), 0, 0},
    {"enter_y", FIELDTYPE_UINT8, offsetof(mapstruct, enter_y), 0, 0},
    {"region", FIELDTYPE_REGION, offsetof(mapstruct, region), FIELDFLAG_READONLY, 0},
    {"bg_music", FIELDTYPE_CSTR, offsetof(mapstruct, bg_music), 0, 0},
    {"weather", FIELDTYPE_CSTR, offsetof(mapstruct, weather), 0, 0}
};
/* @endcparser */

/* @cparser MAP_FLAG_(.*)
 * @page plugin_python_map_flags Python map flags
 * <h2>Python map flags</h2>
 * List of the map flags and their meaning. */
static char *mapflag_names[] =
{
    "f_outdoor", "f_unique", "f_fixed_rtime", "f_nomagic",
    "f_nopriest", "f_noharm", "f_nosummon", "f_fixed_login",
    "f_player_no_save", "f_unused2", "f_unused3", "f_pvp",
    "f_no_save"
};
/* @endcparser */

#define NUM_MAPFLAGS (sizeof(mapflag_names) / sizeof(mapflag_names[0]))

static PyObject *Atrinik_Map_GetFirstObject(Atrinik_Map *map, PyObject *args)
{
    int x, y;
    object *val = NULL;
    mapstruct *m = map->map;

    if (!PyArg_ParseTuple(args, "ii", &x, &y))
    {
        return NULL;
    }

    if ((m = hooks->get_map_from_coord(m, &x, &y)))
    {
        /* Since map objects are loaded in reverse mode, the last one in
         * in the list is actually the first. */
        val = GET_MAP_OB_LAST(m, x, y);
    }

    return wrap_object(val);
}

static PyObject *Atrinik_Map_GetLastObject(Atrinik_Map *map, PyObject *args)
{
    int x, y;
    object *val = NULL;
    mapstruct *m = map->map;

    if (!PyArg_ParseTuple(args, "ii", &x, &y))
    {
        return NULL;
    }

    if ((m = hooks->get_map_from_coord(m, &x, &y)))
    {
        /* Since map objects are loaded in reverse mode, the first one in
         * in the list is actually the last. */
        val = GET_MAP_OB(m, x, y);
    }

    return wrap_object(val);
}

static PyObject *Atrinik_Map_GetLayer(Atrinik_Map *map, PyObject *args)
{
    int x, y;
    uint8 layer;
    mapstruct *m;
    PyObject *list;
    object *tmp;

    if (!PyArg_ParseTuple(args, "iiB", &x, &y, &layer))
    {
        return NULL;
    }

    /* Validate the layer ID. */
    if (layer > NUM_LAYERS)
    {
        PyErr_SetString(PyExc_ValueError, "map.GetLayer(): Invalid layer ID.");
        return NULL;
    }

    if (!(m = hooks->get_map_from_coord(map->map, &x, &y)))
    {
        RAISE("map.GetLayer(): Unable to get map using get_map_from_coord().");
    }

    list = PyList_New(0);

    /* Handle layer 0 specially: it's always at the start. */
    if (layer == 0)
    {
        for (tmp = GET_MAP_OB(m, x, y); tmp && tmp->layer == layer; tmp = tmp->above)
        {
            PyList_Append(list, wrap_object(tmp));
        }
    }
    else
    {
        for (tmp = GET_MAP_OB_LAYER(m, x, y, layer - 1); tmp && tmp->layer == layer; tmp = tmp->above)
        {
            PyList_Append(list, wrap_object(tmp));
        }
    }

    return list;
}

static PyObject *Atrinik_Map_GetMapFromCoord(Atrinik_Map *map, PyObject *args)
{
    int x, y;
    mapstruct *m;
    PyObject *tuple;

    if (!PyArg_ParseTuple(args, "ii", &x, &y))
    {
        return NULL;
    }

    m = hooks->get_map_from_coord(map->map, &x, &y);
    tuple = PyTuple_New(3);
    PyTuple_SET_ITEM(tuple, 0, wrap_map(m));
    PyTuple_SET_ITEM(tuple, 1, Py_BuildValue("i", x));
    PyTuple_SET_ITEM(tuple, 2, Py_BuildValue("i", y));

    return tuple;
}

static PyObject *Atrinik_Map_PlaySound(Atrinik_Map *map, PyObject *args, PyObject *keywds)
{
    static char *kwlist[] = {"filename", "x", "y", "type", "loop", "volume", NULL};
    const char *filename;
    int x, y, type = CMD_SOUND_EFFECT, loop = 0, volume = 0;

    if (!PyArg_ParseTupleAndKeywords(args, keywds, "sii|iii", kwlist, &filename, &x, &y, &type, &loop, &volume))
    {
        return NULL;
    }

    hooks->play_sound_map(map->map, type, filename, x, y, loop, volume);

    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *Atrinik_Map_Message(Atrinik_Map *map, PyObject *args, PyObject *keywds)
{
    static char *kwlist[] = {"x", "y", "distance", "message", "color", "flags", NULL};
    int flags = 0, x, y, d;
    const char *message, *color = COLOR_BLUE;

    if (!PyArg_ParseTupleAndKeywords(args, keywds, "iiis|si", kwlist, &x, &y, &d, &message, &color, &flags))
    {
        return NULL;
    }

    hooks->new_info_map(flags, color, map->map, x, y, d, message);

    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *Atrinik_Map_CreateObject(Atrinik_Map *map, PyObject *args)
{
    const char *archname;
    int x, y;
    archetype *arch;
    object *newobj;

    if (!PyArg_ParseTuple(args, "sii", &archname, &x, &y))
    {
        return NULL;
    }

    if (!(arch = hooks->find_archetype(archname)) || !(newobj = hooks->arch_to_object(arch)))
    {
        RAISE("map.CreateObject(): Invalid archetype.");
        return NULL;
    }

    newobj->x = x;
    newobj->y = y;
    newobj = hooks->insert_ob_in_map(newobj, map->map, NULL, 0);

    return wrap_object(newobj);
}

static PyObject *Atrinik_Map_CountPlayers(Atrinik_Map *map, PyObject *args)
{
    (void) args;

    return Py_BuildValue("i", hooks->players_on_map(map->map));
}

static PyObject *Atrinik_Map_GetPlayers(Atrinik_Map *map, PyObject *args)
{
    PyObject *list = PyList_New(0);
    object *tmp;

    (void) args;

    for (tmp = map->map->player_first; tmp; tmp = CONTR(tmp)->map_above)
    {
        PyList_Append(list, wrap_object(tmp));
    }

    return list;
}

static PyObject *Atrinik_Map_Insert(Atrinik_Map *map, PyObject *args)
{
    Atrinik_Object *obj;
    sint16 x, y;

    if (!PyArg_ParseTuple(args, "O!hh", &Atrinik_ObjectType, &obj, &x, &y))
    {
        return NULL;
    }

    OBJEXISTCHECK(obj);

    if (!QUERY_FLAG(obj->obj, FLAG_REMOVED))
    {
        hooks->object_remove_esrv_update(obj->obj);
    }

    obj->obj->x = x;
    obj->obj->y = y;
    hooks->insert_ob_in_map(obj->obj, map->map, NULL, 0);

    Py_INCREF(Py_None);
    return Py_None;
}

static PyObject *Atrinik_Map_Wall(Atrinik_Map *map, PyObject *args)
{
    sint16 x, y;

    if (!PyArg_ParseTuple(args, "hh", &x, &y))
    {
        return NULL;
    }

    return Py_BuildValue("i", hooks->wall(map->map, x, y));
}

static PyObject *Atrinik_Map_Blocked(Atrinik_Map *map, PyObject *args)
{
    Atrinik_Object *ob;
    int x, y, terrain;
    mapstruct *m;

    if (!PyArg_ParseTuple(args, "O!iii", &Atrinik_ObjectType, &ob, &x, &y, &terrain))
    {
        return NULL;
    }

    OBJEXISTCHECK(ob);

    if (!(m = hooks->get_map_from_coord(map->map, &x, &y)))
    {
        RAISE("Unable to get map using get_map_from_coord().");
    }

    return Py_BuildValue("i", hooks->blocked(ob->obj, m, x, y, terrain));
}

static PyObject *Atrinik_Map_FreeSpot(Atrinik_Map *map, PyObject *args)
{
    Atrinik_Object *ob;
    int x, y, start, stop;
    mapstruct *m;

    if (!PyArg_ParseTuple(args, "O!iiii", &Atrinik_ObjectType, &ob, &x, &y, &start, &stop))
    {
        return NULL;
    }

    OBJEXISTCHECK(ob);

    if (start < 0 || stop < 0)
    {
        PyErr_SetString(PyExc_ValueError, "map.FreeSpot(): 'start' and 'stop' cannot be negative.");
        return NULL;
    }

    if (stop > SIZEOFFREE)
    {
        PyErr_SetString(PyExc_ValueError, "map.FreeSpot(): 'stop' cannot be higher than SIZEOFFREE.");
        return NULL;
    }

    if (!(m = hooks->get_map_from_coord(map->map, &x, &y)))
    {
        return Py_BuildValue("i", -1);
    }

    return Py_BuildValue("i", hooks->find_free_spot(ob->obj->arch, ob->obj, m, x, y, start, stop + 1));
}

static PyMethodDef MapMethods[] =
{
    {"GetFirstObject", (PyCFunction) Atrinik_Map_GetFirstObject, METH_VARARGS, 0},
    {"GetLastObject", (PyCFunction) Atrinik_Map_GetLastObject, METH_VARARGS, 0},
    {"GetLayer", (PyCFunction) Atrinik_Map_GetLayer, METH_VARARGS, 0},
    {"GetMapFromCoord", (PyCFunction) Atrinik_Map_GetMapFromCoord, METH_VARARGS, 0},
    {"PlaySound", (PyCFunction) Atrinik_Map_PlaySound, METH_VARARGS | METH_KEYWORDS, 0},
    {"Message", (PyCFunction) Atrinik_Map_Message, METH_VARARGS | METH_KEYWORDS, 0},
    {"CreateObject", (PyCFunction) Atrinik_Map_CreateObject, METH_VARARGS, 0},
    {"CountPlayers", (PyCFunction) Atrinik_Map_CountPlayers, METH_NOARGS, 0},
    {"GetPlayers", (PyCFunction) Atrinik_Map_GetPlayers, METH_NOARGS, 0},
    {"Insert", (PyCFunction) Atrinik_Map_Insert, METH_VARARGS, 0},
    {"Wall", (PyCFunction) Atrinik_Map_Wall, METH_VARARGS, 0},
    {"Blocked", (PyCFunction) Atrinik_Map_Blocked, METH_VARARGS, 0},
    {"FreeSpot", (PyCFunction) Atrinik_Map_FreeSpot, METH_VARARGS, 0},
    {NULL, NULL, 0, 0}
};

static PyObject *get_attribute(Atrinik_Map *map, void *context)
{
    return generic_field_getter((fields_struct *) context, map->map);
}

static int set_attribute(Atrinik_Map *map, PyObject *value, void *context)
{
    if (generic_field_setter((fields_struct *) context, map->map, value) == -1)
    {
        return -1;
    }

    if (((fields_struct *) context)->offset == offsetof(mapstruct, darkness))
    {
        hooks->set_map_darkness(map->map, map->map->darkness);
    }

    return 0;
}

static PyObject *Map_GetFlag(Atrinik_Map *map, void *context)
{
    size_t flagno = (size_t) context;

    /* Should not happen. */
    if (flagno >= NUM_MAPFLAGS)
    {
        PyErr_SetString(PyExc_OverflowError, "Invalid flag ID.");
        return NULL;
    }

    Py_ReturnBoolean(map->map->map_flags & (1 << flagno));
}

static int Map_SetFlag(Atrinik_Map *map, PyObject *val, void *context)
{
    size_t flagno = (size_t) context;

    /* Should not happen. */
    if (flagno >= NUM_MAPFLAGS)
    {
        PyErr_SetString(PyExc_OverflowError, "Invalid flag ID.");
        return -1;
    }

    if (val == Py_True)
    {
        map->map->map_flags |= (1U << flagno);
    }
    else if (val == Py_False)
    {
        map->map->map_flags &= ~(1U << flagno);
    }
    else
    {
        PyErr_SetString(PyExc_TypeError, "Flag value must be either True or False.");
        return -1;
    }

    return 0;
}

static PyObject *Atrinik_Map_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
    Atrinik_Map *self;

    (void) args;
    (void) kwds;

    self = (Atrinik_Map *) type->tp_alloc(type, 0);

    if (self)
    {
        self->map = NULL;
    }

    return (PyObject *) self;
}

static void Atrinik_Map_dealloc(Atrinik_Map *self)
{
    self->map = NULL;
#ifndef IS_PY_LEGACY
    Py_TYPE(self)->tp_free((PyObject *) self);
#else
    self->ob_type->tp_free((PyObject *) self);
#endif
}

static PyObject *Atrinik_Map_str(Atrinik_Map *self)
{
    char buf[HUGE_BUF];

    snprintf(buf, sizeof(buf), "[%s \"%s\"]", self->map->path, self->map->name);
    return Py_BuildValue("s", buf);
}

static int Atrinik_Map_InternalCompare(Atrinik_Map *left, Atrinik_Map *right)
{
    return left->map < right->map ? -1 : (left->map == right->map ? 0 : 1);
}

static PyObject *Atrinik_Map_RichCompare(Atrinik_Map *left, Atrinik_Map *right, int op)
{
    if (!left || !right || !PyObject_TypeCheck((PyObject *) left, &Atrinik_MapType) || !PyObject_TypeCheck((PyObject *) right, &Atrinik_MapType))
    {
        Py_INCREF(Py_NotImplemented);
        return Py_NotImplemented;
    }

    return generic_rich_compare(op, Atrinik_Map_InternalCompare(left, right));
}

static PyGetSetDef getseters[NUM_FIELDS + NUM_MAPFLAGS + 1];

PyTypeObject Atrinik_MapType =
{
#ifdef IS_PY3K
    PyVarObject_HEAD_INIT(NULL, 0)
#else
    PyObject_HEAD_INIT(NULL)
    0,
#endif
    "Atrinik.Map",
    sizeof(Atrinik_Map),
    0,
    (destructor) Atrinik_Map_dealloc,
    NULL, NULL, NULL,
#ifdef IS_PY3K
    NULL,
#else
    (cmpfunc) Atrinik_Map_InternalCompare,
#endif
    0, 0, 0, 0, 0, 0,
    (reprfunc) Atrinik_Map_str,
    0, 0, 0,
    Py_TPFLAGS_DEFAULT,
    "Atrinik maps",
    NULL, NULL,
    (richcmpfunc) Atrinik_Map_RichCompare,
    0, 0, 0,
    MapMethods,
    0,
    getseters,
    0, 0, 0, 0, 0, 0, 0,
    Atrinik_Map_new,
    0, 0, 0, 0, 0, 0, 0, 0
#ifndef IS_PY_LEGACY
    , 0
#endif
};

int Atrinik_Map_init(PyObject *module)
{
    size_t i, flagno;

    /* Field getters */
    for (i = 0; i < NUM_FIELDS; i++)
    {
        PyGetSetDef *def = &getseters[i];

        def->name = fields[i].name;
        def->get = (getter) get_attribute;
        def->set = (setter) set_attribute;
        def->doc = NULL;
        def->closure = (void *) &fields[i];
    }

    /* Flag getters */
    for (flagno = 0; flagno < NUM_MAPFLAGS; flagno++)
    {
        PyGetSetDef *def = &getseters[i++];

        def->name = mapflag_names[flagno];
        def->get = (getter) Map_GetFlag;
        def->set = (setter) Map_SetFlag;
        def->doc = NULL;
        def->closure = (void *) flagno;
    }

    getseters[i].name = NULL;

    Atrinik_MapType.tp_new = PyType_GenericNew;

    if (PyType_Ready(&Atrinik_MapType) < 0)
    {
        return 0;
    }

    Py_INCREF(&Atrinik_MapType);
    PyModule_AddObject(module, "Map", (PyObject *) &Atrinik_MapType);

    return 1;
}

PyObject *wrap_map(mapstruct *what)
{
    Atrinik_Map *wrapper;

    /* Return None if no map was to be wrapped. */
    if (!what)
    {
        Py_INCREF(Py_None);
        return Py_None;
    }

    wrapper = PyObject_NEW(Atrinik_Map, &Atrinik_MapType);

    if (wrapper)
    {
        wrapper->map = what;
    }

    return (PyObject *) wrapper;
}