include/map.h

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                        *
************************************************************************/

#ifndef MAP_H
#define MAP_H

#define MAX_DARKNESS 7

int global_darkness_table[MAX_DARKNESS + 1];
int map_tiled_reverse[TILED_MAPS];

#define MAP_PLAYER_MAP 1

#define LAYER_SYS 0

#define LAYER_FLOOR 1

#define LAYER_FMASK 2

#define LAYER_ITEM 3

#define LAYER_ITEM2 4

#define LAYER_WALL 5

#define LAYER_LIVING 6

#define LAYER_EFFECT 7

#define NUM_LAYERS 7

#define MAP_WHEN_RESET(m)      ((m)->reset_time)

#define MAP_RESET_TIMEOUT(m)   ((m)->reset_timeout)

#define MAP_DIFFICULTY(m)      ((m)->difficulty)

#define MAP_TIMEOUT(m)         ((m)->timeout)

#define MAP_SWAP_TIME(m)       ((m)->swap_time)

#define MAP_OUTDOORS(m)        ((m)->map_flags & MAP_FLAG_OUTDOOR)

#define MAP_UNIQUE(m)          ((m)->map_flags & MAP_FLAG_UNIQUE)

#define MAP_FIXED_RESETTIME(m) ((m)->map_flags & MAP_FLAG_FIXED_RTIME)

#define MAP_NOSAVE(m)          ((m)->map_flags & MAP_FLAG_NO_SAVE)

#define MAP_NOMAGIC(m)         ((m)->map_flags & MAP_FLAG_NOMAGIC)

#define MAP_NOPRIEST(m)        ((m)->map_flags & MAP_FLAG_NOPRIEST)

#define MAP_NOHARM(m)          ((m)->map_flags & MAP_FLAG_NOHARM)

#define MAP_NOSUMMON(m)        ((m)->map_flags & MAP_FLAG_NOSUMMON)

#define MAP_FIXEDLOGIN(m)      ((m)->map_flags & MAP_FLAG_FIXED_LOGIN)

#define MAP_PLAYER_NO_SAVE(m) ((m)->map_flags & MAP_FLAG_PLAYER_NO_SAVE)

#define MAP_PVP(m)             ((m)->map_flags & MAP_FLAG_PVP)

#define MAP_DARKNESS(m)        (m)->darkness

#define MAP_WIDTH(m)           (m)->width

#define MAP_HEIGHT(m)          (m)->height

#define MAP_SIZE(m)            ((m)->width * (m)->height)

#define MAP_ENTER_X(m)         (m)->enter_x

#define MAP_ENTER_Y(m)         (m)->enter_y

#define MAP_FLUSH         0x1

#define MAP_PLAYER_UNIQUE 0x2

#define MAP_BLOCK         0x4

#define MAP_STYLE         0x8

#define MAP_ARTIFACT      0x20

#define MAP_NAME_SHARED   0x40

#define MAP_ORIGINAL      0x80

#define MAP_IN_MEMORY   1

#define MAP_SWAPPED     2

#define MAP_LOADING     3

#define MAP_SAVING      4

/* new macros for map layer system */
#define GET_MAP_SPACE_PTR(M_, X_, Y_) \
    (&((M_)->spaces[(X_) + (M_)->width * (Y_)]))

#define GET_MAP_SPACE_FIRST(M_) \
    ((M_)->first)
#define GET_MAP_SPACE_LAST(M_) \
    ((M_)->last)
#define GET_MAP_SPACE_LAYER(M_, L_) \
    ((M_)->layer[L_])

#define SET_MAP_SPACE_FIRST(M_, O_) \
    ((M_)->first = (O_))
#define SET_MAP_SPACE_LAST(M_, O_) \
    ((M_)->last = (O_))
#define SET_MAP_SPACE_LAYER(M_, L_, O_) \
    ((M_)->layer[L_] = (O_))

#define GET_MAP_UPDATE_COUNTER(M, X, Y) \
    ((M)->spaces[(X) + (M)->width * (Y)].update_tile)

#define INC_MAP_UPDATE_COUNTER(M, X, Y) \
    ((M)->spaces[((X) + (M)->width * (Y))].update_tile++)

#define GET_MAP_MOVE_FLAGS(M, X, Y) \
    ((M)->spaces[(X) + (M)->width * (Y)].move_flags)
#define SET_MAP_MOVE_FLAGS(M, X, Y, C) \
    ((M)->spaces[(X) + (M)->width * (Y)].move_flags = C)
#define GET_MAP_FLAGS(M, X, Y) \
    ((M)->spaces[(X) + (M)->width * (Y)].flags)
#define SET_MAP_FLAGS(M, X, Y, C) \
    ((M)->spaces[(X) + (M)->width * (Y)].flags = C)
#define GET_MAP_LIGHT(M, X, Y) \
    ((M)->spaces[(X) + (M)->width * (Y)].light)
#define SET_MAP_LIGHT(M, X, Y, L) \
    ((M)->spaces[(X) + (M)->width * (Y)].light = (sint8) L)

#define GET_MAP_OB(M, X, Y) \
    ((M)->spaces[(X) + (M)->width * (Y)].first)
#define GET_MAP_OB_LAST(M, X, Y) \
    ((M)->spaces[(X) + (M)->width * (Y)].last)
#define GET_MAP_OB_LAYER(_M_, _X_, _Y_, _Z_) \
    ((_M_)->spaces[(_X_) + (_M_)->width * (_Y_)].layer[_Z_])
#define get_map_ob GET_MAP_OB

#define SET_MAP_OB(M, X, Y, tmp) \
    ((M)->spaces[(X) + (M)->width * (Y)].first = (tmp))
#define SET_MAP_OB_LAST(M, X, Y, tmp) \
    ((M)->spaces[(X) + (M)->width * (Y)].last = (tmp))
#define SET_MAP_OB_LAYER(_M_, _X_, _Y_, _Z_, tmp) \
    ((_M_)->spaces[(_X_) + (_M_)->width * (_Y_)].layer[_Z_] = (tmp))
#define set_map_ob SET_MAP_OB

#define SET_MAP_DAMAGE(M, X, Y, tmp) \
    ((M)->spaces[(X) + (M)->width * (Y)].last_damage = (uint16) (tmp))
#define GET_MAP_DAMAGE(M, X, Y) \
    ((M)->spaces[(X) + (M)->width * (Y)].last_damage)

#define SET_MAP_RTAG(M, X, Y, tmp) \
    ((M)->spaces[(X) + (M)->width * (Y)].round_tag = (uint32) (tmp))
#define GET_MAP_RTAG(M, X, Y) \
    ((M)->spaces[(X) + (M)->width * (Y)].round_tag)

#define GET_BOTTOM_MAP_OB(O) ((O)->map ? GET_MAP_OB((O)->map, (O)->x, (O)->y) : NULL)

#define FFLAG_SLEEP     0x01

#define FFLAG_CONFUSED  0x02

#define FFLAG_PARALYZED 0x04

#define FFLAG_SCARED    0x08

#define FFLAG_BLINDED   0x10

#define FFLAG_INVISIBLE 0x20

#define FFLAG_ETHEREAL  0x40

#define FFLAG_PROBE     0x80

#define OUT_OF_REAL_MAP(M, X, Y) \
    ((X) < 0 || (Y) < 0 || (X) >= (M)->width || (Y) >= (M)->height)

#define P_BLOCKSVIEW          0x01

#define P_NO_MAGIC            0x02

#define P_NO_PASS             0x04

#define P_IS_PLAYER           0x08

#define P_IS_ALIVE            0x10

#define P_NO_CLERIC           0x20

#define P_PLAYER_ONLY         0x40

#define P_DOOR_CLOSED         0x80

#define P_CHECK_INV           0x100

#define P_NO_PVP              0x200

#define P_PASS_THRU           0x400

#define P_MAGIC_EAR           0x800

#define P_WALK_ON             0x1000

#define P_WALK_OFF            0x2000

#define P_FLY_OFF             0x4000

#define P_FLY_ON              0x8000

#define P_MAGIC_MIRROR 0x10000

#define P_OUTDOOR 0x20000

#define P_OUT_OF_MAP          0x4000000

#define P_FLAGS_ONLY          0x8000000

#define P_FLAGS_UPDATE        0x10000000

#define P_NEED_UPDATE         0x20000000

#define P_NO_ERROR            0x40000000

#define P_NO_TERRAIN          0x80000000

#define MSP_EXTRA_NO_HARM 1

#define MSP_EXTRA_NO_PVP 2

#define MSP_EXTRA_NO_MAGIC 4

#define MSP_EXTRA_NO_CLERIC 8

typedef struct MapSpace_s
{
    object *first;

    object *layer[NUM_LAYERS * 2];

    object *last;

    object *map_info;

    struct MapSpace_s *prev_light;

    struct MapSpace_s *next_light;

    uint32 round_tag;

    tag_t map_info_count;

    uint32 update_tile;

    sint32 light_source;

    sint32 light_value;

    int flags;

    uint16 last_damage;

    uint16 move_flags;

    uint8 light;

    uint8 extra_flags;
} MapSpace;

#define MAP_FLAG_OUTDOOR 1

#define MAP_FLAG_UNIQUE 2

#define MAP_FLAG_FIXED_RTIME 4

#define MAP_FLAG_NOMAGIC 8

#define MAP_FLAG_NOPRIEST 16

#define MAP_FLAG_NOHARM 32

#define MAP_FLAG_NOSUMMON 64

#define MAP_FLAG_FIXED_LOGIN 128

#define MAP_FLAG_PLAYER_NO_SAVE 256

#define MAP_FLAG_UNUSED2 1024

#define MAP_FLAG_UNUSED3 2048

#define MAP_FLAG_PVP 4096

#define MAP_FLAG_NO_SAVE 8192

#define MAP_DEFAULT_DARKNESS    0

#define SET_MAP_TILE_VISITED(m, x, y, id)                                                    \
{                                                                                            \
    if ((m)->pathfinding_id != (id))                                                         \
    {                                                                                        \
        (m)->pathfinding_id = (id);                                                          \
        memset((m)->bitmap, 0, ((MAP_WIDTH(m) + 31) / 32) * MAP_HEIGHT(m) * sizeof(uint32)); \
    }                                                                                        \
                                                                                             \
    (m)->bitmap[(x) / 32 + ((MAP_WIDTH(m) + 31) / 32) * (y)] |= (1U << ((x) % 32));          \
}

#define QUERY_MAP_TILE_VISITED(m, x, y, id) \
    ((m)->pathfinding_id == (id) && ((m)->bitmap[(x) / 32 + ((MAP_WIDTH(m) + 31) / 32) * (y)] & (1U << ((x) % 32))))

typedef struct regiondef
{
    struct regiondef *next;

    struct regiondef *parent;

    char *name;

    char *parent_name;

    char *longname;

    char *msg;

    char *jailmap;

    char *map_first;

    char *map_bg;

    sint16 jailx;

    sint16 jaily;
} region;

typedef struct map_event
{
    struct map_event *next;

    object *event;

    struct atrinik_plugin *plugin;
} map_event;

typedef struct mapdef
{
    struct mapdef *previous;

    struct mapdef *next;

    struct mapdef *tile_map[TILED_MAPS];

    char *name;

    char *bg_music;

    char *weather;

    char *tmpname;

    char *msg;

    shstr *path;

    shstr *tile_path[TILED_MAPS];

    MapSpace *spaces;

    MapSpace *first_light;

    struct regiondef *region;

    struct map_event *events;

    objectlink *buttons;

    object *player_first;

    uint32 *bitmap;

    uint32 pathfinding_id;

    uint32 map_flags;

    uint32 reset_time;

    uint32 reset_timeout;

    sint32 timeout;

    uint32 swap_time;

    uint32 in_memory;

    uint32 traversed;

    int darkness;

    int light_value;

    int difficulty;

    int height;

    int width;

    int enter_x;

    int enter_y;

    int compressed;
} mapstruct;

typedef struct rv_vector_s
{
    unsigned int distance;

    int distance_x;

    int distance_y;

    int direction;

    object *part;
} rv_vector;

#define RV_IGNORE_MULTIPART    0x01
#define RV_RECURSIVE_SEARCH    0x02

#define RV_MANHATTAN_DISTANCE  0x00
#define RV_EUCLIDIAN_DISTANCE  0x04
#define RV_DIAGONAL_DISTANCE   0x08
#define RV_NO_DISTANCE         (0x08 | 0x04)

#define NORTH 1

#define NORTHEAST 2

#define EAST 3

#define SOUTHEAST 4

#define SOUTH 5

#define SOUTHWEST 6

#define WEST 7

#define NORTHWEST 8

#define OBJECT_IS_HIDDEN(pl, ob) (HAS_EVENT((ob), EVENT_ASK_SHOW) && trigger_event(EVENT_ASK_SHOW, (pl), (ob), NULL, NULL, 0, 0, 0, 0) == 1)

region *first_region;

#endif