trunk/html/map_8h_source.html

/*

 * The mapstruct is allocated each time a new map is opened.

 * It contains pointers (very indirectly) to all objects on the map.

 */


#ifndef MAP_H

#define MAP_H


/* We set this size - this is to make magic map work properly on

 * tiled maps.  There is no requirement that this matches the

 * tiled maps size - it just seemed like a reasonable value.

 * Magic map code now always starts out putting the player in the

 * center of the map - this makes the most sense when dealing

 * with tiled maps.

 * We also figure out the magicmap color to use as we process the

 * spaces - this is more efficient as we already have up to date

 * map pointers.

 */

#define MAGIC_MAP_SIZE 50

#define MAGIC_MAP_HALF MAGIC_MAP_SIZE/2


/* This correspondes to the map layers in the map2 protocol.

 * The MAP_LAYER_... correspond to what goes on what layer -

 * this removes the need for hardcoding, and also makes sure

 * we don't overstep the number of layers.

 */

#define MAP_LAYERS 10


extern const char *const map_layer_name[MAP_LAYERS];


#define MAP_LAYER_FLOOR         0

#define MAP_LAYER_NO_PICK1      1

#define MAP_LAYER_NO_PICK2      2

#define MAP_LAYER_ITEM1         3

#define MAP_LAYER_ITEM2         4

#define MAP_LAYER_ITEM3         5

#define MAP_LAYER_LIVING1       6

#define MAP_LAYER_LIVING2       7

#define MAP_LAYER_FLY1          8

#define MAP_LAYER_FLY2          9


#define MAP_TYPE_LEGACY         1

#define MAP_TYPE_DEFAULT        2

#define MAP_TYPE_CHOICE         3

#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_OUTDOORS(m)         ((m)->outdoor)


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


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


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


#define MAP_SIZE(m)             map_size(m)


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


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


#define MAP_NOSMOOTH(m)         (m)->nosmooth


#define MAP_FLUSH           0x1

#define MAP_PLAYER_UNIQUE   0x2

#define MAP_NO_DIFFICULTY   0x4

#define MAP_STYLE           0x8

#define MAP_OVERLAY         0x10


#define SAVE_FLAG_SAVE_UNPAID   1

#define SAVE_FLAG_NO_REMOVE     2


#define SAVE_MODE_NORMAL    0

#define SAVE_MODE_INPLACE   1

#define SAVE_MODE_OVERLAY   2


#define MAP_IN_MEMORY   1

#define MAP_SWAPPED     2

#define MAP_LOADING     3

#define MAP_SAVING      4


#define SAVE_ERROR_OK                0

#define SAVE_ERROR_RCREATION        -1

#define SAVE_ERROR_UCREATION        -2

#define SAVE_ERROR_WRITE            -3

#define SAVE_ERROR_NO_PATH          -4

#define SAVE_ERROR_URENAME          -5

#define SAVE_ERROR_CLOSE            -6

/*                                  -7  (no longer used) */

#define SAVE_ERROR_NOT_IN_MEMORY    -10

#define SAVE_ERROR_PLAYER           -11


/* GET_MAP_FLAGS really shouldn't be used very often - get_map_flags should

 * really be used, as it is multi tile aware.  However, there are some cases

 * where it is known the map is not tiled or the values are known

 * consistent (eg, op->map, op->x, op->y)

 */

#define GET_MAP_FLAGS(M, X, Y)  (map_space(M, X, Y)->flags)


#define SET_MAP_FLAGS(M, X, Y, C) (map_space(M, X, Y)->flags = C)


#define GET_MAP_LIGHT(M, X, Y)  (map_space(M, X, Y)->light)


#define SET_MAP_LIGHT(M, X, Y, L) (map_space(M, X, Y)->light = L)


#define GET_MAP_PLAYER(M, X, Y) (map_space(M, X, Y)->pl)

#define SET_MAP_PLAYER(M, X, Y, C) (map_space(M, X, Y)->pl = C)


#define GET_MAP_OB(M, X, Y)     (map_space(M, X, Y)->bottom)


#define GET_MAP_TOP(M, X, Y)    (map_space(M, X, Y)->top)


#define SET_MAP_OB(M, X, Y, tmp) (map_space(M, X, Y)->bottom = (tmp))


#define SET_MAP_TOP(M, X, Y, tmp) (map_space(M, X, Y)->top = (tmp))


#define SET_MAP_FACE_OBJ(M, X, Y, C, L) (map_space(M, X, Y)->faces_obj[L] = C)


#define GET_MAP_FACE_OBJ(M, X, Y, L) (map_space(M, X, Y)->faces_obj[L])


#define GET_MAP_FACE_OBJS(M, X, Y) (map_space(M, X, Y)->faces_obj)


extern bool ob_move_block(object *ob1, object *ob2);


#define GET_MAP_MOVE_BLOCK(M, X, Y) (map_space(M, X, Y)->move_block)


#define SET_MAP_MOVE_BLOCK(M, X, Y, C) (map_space(M, X, Y)->move_block = C)


#define GET_MAP_MOVE_SLOW(M, X, Y)  (map_space(M, X, Y)->move_slow)


#define SET_MAP_MOVE_SLOW(M, X, Y, C) (map_space(M, X, Y)->move_slow = C)


#define GET_MAP_MOVE_ON(M, X, Y)    (map_space(M, X, Y)->move_on)


#define SET_MAP_MOVE_ON(M, X, Y, C) (map_space(M, X, Y)->move_on = C)


#define GET_MAP_MOVE_OFF(M, X, Y)    (map_space(M, X, Y)->move_off)


#define SET_MAP_MOVE_OFF(M, X, Y, C) (map_space(M, X, Y)->move_off = C)


#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

/* AB_NO_PASS is used for arch_blocked() return value.  It needs

 * to be here to make sure the bits don't match with anything.

 * Changed name to have AB_ prefix just to make sure no one

 * is using the P_NO_PASS.  AB_.. should only be used for

 * arch_blocked and functions that examine the return value.

 */

#define AB_NO_PASS      0x04

#define P_PLAYER        0x08

#define P_IS_ALIVE      0x10

#define P_NO_CLERIC     0x20

#define P_NEED_UPDATE   0x40

#define P_NO_ERROR      0x80

/* The following two values are not stored in the MapLook flags, but instead

 * used in the get_map_flags value - that function is used to return

 * the flag value, as well as other conditions - using a more general

 * function that does more of the work can hopefully be used to replace

 * lots of duplicate checks currently in the code.

 */

#define P_OUT_OF_MAP    0x100

#define P_NEW_MAP       0x200


struct MapSpace {

    object      *bottom;

    object      *top;

    object      *faces_obj[MAP_LAYERS];

    uint8_t       flags;

    int8_t       light;

    MoveType    move_block;

    MoveType    move_slow;

    MoveType    move_on;

    MoveType    move_off;

    object      *pl;

};


struct region {

    char  *name;

    region *parent;

    char  *longname;

    char  *msg;

    uint32_t      counter;

    int8_t       fallback;

    char        *jailmap;

    int16_t      jailx, jaily;

};


struct shopitems {

    const char *name;

    const char *name_pl;

    int typenum;

    int8_t strength;

    int index;

};


struct mapstruct {

    mapstruct *next;

    char    *tmpname;

    char    *name;

    struct region *region;

    uint32_t  reset_time;

    uint32_t  reset_timeout;

    uint32_t  fixed_resettime:1;

    sstring reset_group;

    uint32_t  unique:1;

    uint32_t  is_template:1;

    uint32_t  nosmooth:1;

    uint32_t  outdoor:1;

    int32_t  timeout;

    uint16_t  difficulty;

    int16_t  players;

    uint32_t  in_memory;

    uint8_t   darkness;

    uint16_t  width, height;

    int16_t  enter_x, enter_y;

    oblinkpt *buttons;

    MapSpace *spaces;

    struct shopitems *shopitems;

    char    *shoprace;

    double  shopgreed;

    uint64_t  shopmin;

    uint64_t  shopmax;

    char    *msg;

    char    *maplore;

    char    *tile_path[4];

    mapstruct *tile_map[4];

    char    path[HUGE_BUF];

    long last_reset_time;

    char    *background_music;

};


struct rv_vector {

    unsigned int distance;

    int     distance_x;

    int     distance_y;

    int     direction;

    object  *part;

};


uint32_t map_size(mapstruct *m);


extern bool map_path_unique(const char *name);


extern MapSpace *map_space(const mapstruct *m, int x, int y);


extern void map_reset_swap(mapstruct *m);


extern int map_light_on(mapstruct *m, int x, int y);


#endif /* MAP_H */