/home/leaf/crossfire/server/branches/1.12/include/map.h

Go to the documentation of this file.

/*
 * static char *rcsid_define_h =
 *   "$Id: map.h 11578 2009-02-23 22:02:27Z lalo $";
 */

/*
    CrossFire, A Multiplayer game for X-windows

    Copyright (C) 2002-2005 Mark Wedel & Crossfire Development Team
    Copyright (C) 1992 Frank Tore Johansen

    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 authors can be reached via e-mail at crossfire-devel@real-time.com
*/

/*
 * 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 *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_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)             ((m)->width*(m)->height)

#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_BLOCK           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  
#define SAVE_ERROR_RRENAME          -7  
#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   


typedef struct MapSpace {
    object      *bottom;        
    object      *top;           
    object      *faces_obj[MAP_LAYERS]; 
    uint8       flags;          
    sint8       light;          
    MoveType    move_block;     
    MoveType    move_slow;      
    MoveType    move_on;        
    MoveType    move_off;       
    object      *pl;            /* Player that is on this space */
} MapSpace;

typedef struct regiondef {
    struct regiondef *next;      
    const char  *name;           
    const char  *parent_name;    
    struct regiondef *parent;   
    const char  *longname;       
    const char  *msg;            
    uint32      counter;         
    sint8       fallback;        
    char        *jailmap;        
    sint16      jailx, jaily;    
} region;

typedef struct shopitem {
    const char *name;     
    const char *name_pl;  
    int typenum;    
    sint8 strength; 
    int index;      
} shopitems;

typedef struct mapdef {
    struct mapdef *next;        
    char    *tmpname;           
    char    *name;              
    struct regiondef *region;   
    uint32  reset_time;         
    uint32  reset_timeout;      
    uint32  fixed_resettime:1;  
    uint32  unique:1;           
    uint32  is_template:1;         
    uint32  nosmooth:1;         
    uint32  outdoor:1;          
    sint32  timeout;            
    sint32  swap_time;          
    uint16  difficulty;         
    sint16  players;            
    uint32  in_memory;          
    uint8   compressed;         
    uint8   darkness;           
    uint16  width, height;      
    uint16  enter_x;            
    uint16  enter_y;            
    oblinkpt *buttons;          
    MapSpace *spaces;           
    struct shopitem *shopitems;     
    char    *shoprace;          
    double  shopgreed;          
    uint64  shopmin;            
    uint64  shopmax;            
    char    *msg;               
    char    *maplore;           
    char    *tile_path[4];      
    struct mapdef *tile_map[4]; 
    char    path[HUGE_BUF];     
    struct timeval last_reset_time; 
    char    *background_music;  
} mapstruct;

typedef struct rv_vector {
    unsigned int distance;  
    int     distance_x;     
    int     distance_y;     
    int     direction;      
    object  *part;          
} rv_vector;

#endif /* MAP_H */

---