map.h

Go to the documentation of this file.

 
/*
 * 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_SWAP_TIME(m)        ((m)->swap_time)
#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)  ((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 = L)
#define GET_MAP_PLAYER(M, X, Y) ((M)->spaces[(X)+(M)->width*(Y)].pl)
#define SET_MAP_PLAYER(M, X, Y, C) ((M)->spaces[(X)+(M)->width*(Y)].pl = C)
 
#define GET_MAP_OB(M, X, Y)     ((M)->spaces[(X)+(M)->width*(Y)].bottom)
 
#define GET_MAP_TOP(M, X, Y)    ((M)->spaces[(X)+(M)->width*(Y)].top)
 
#define SET_MAP_OB(M, X, Y, tmp) ((M)->spaces[(X)+(M)->width*(Y)].bottom = (tmp))
 
#define SET_MAP_TOP(M, X, Y, tmp) ((M)->spaces[(X)+(M)->width*(Y)].top = (tmp))
 
#define SET_MAP_FACE_OBJ(M, X, Y, C, L) ((M)->spaces[(X)+(M)->width*(Y)].faces_obj[L] = C)
 
#define GET_MAP_FACE_OBJ(M, X, Y, L) ((M)->spaces[(X)+(M)->width*(Y)].faces_obj[L])
 
#define GET_MAP_FACE_OBJS(M, X, Y) ((M)->spaces[(X)+(M)->width*(Y)].faces_obj)
 
#define GET_MAP_MOVE_BLOCK(M, X, Y) ((M)->spaces[(X)+(M)->width*(Y)].move_block)
 
#define SET_MAP_MOVE_BLOCK(M, X, Y, C) ((M)->spaces[(X)+(M)->width*(Y)].move_block = C)
 
#define GET_MAP_MOVE_SLOW(M, X, Y)  ((M)->spaces[(X)+(M)->width*(Y)].move_slow)
 
#define SET_MAP_MOVE_SLOW(M, X, Y, C) ((M)->spaces[(X)+(M)->width*(Y)].move_slow = C)
 
#define GET_MAP_MOVE_ON(M, X, Y)    ((M)->spaces[(X)+(M)->width*(Y)].move_on)
 
#define SET_MAP_MOVE_ON(M, X, Y, C) ((M)->spaces[(X)+(M)->width*(Y)].move_on = C)
 
#define GET_MAP_MOVE_OFF(M, X, Y)    ((M)->spaces[(X)+(M)->width*(Y)].move_off)
 
#define SET_MAP_MOVE_OFF(M, X, Y, C) ((M)->spaces[(X)+(M)->width*(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;            
    int32_t  swap_time;          
    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);
 
#endif /* MAP_H */