ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/include/map.h
(Generate patch)

Comparing deliantra/server/include/map.h (file contents):
Revision 1.23 by root, Sun Dec 3 02:04:57 2006 UTC vs.
Revision 1.50 by root, Wed Jan 10 01:16:54 2007 UTC

1/* 1/*
2 CrossFire, A Multiplayer game for X-windows 2 CrossFire, A Multiplayer game for X-windows
3 3
4 Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
4 Copyright (C) 2002-2005 Mark Wedel & Crossfire Development Team 5 Copyright (C) 2002-2005 Mark Wedel & Crossfire Development Team
5 Copyright (C) 1992 Frank Tore Johansen 6 Copyright (C) 1992 Frank Tore Johansen
6 7
7 This program is free software; you can redistribute it and/or modify 8 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by 9 it under the terms of the GNU General Public License as published by
… …
16 17
17 You should have received a copy of the GNU General Public License 18 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software 19 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 21
21 The authors can be reached via e-mail at crossfire-devel@real-time.com 22 The authors can be reached via e-mail at crossfire@schmorp.de
22*/ 23*/
23 24
24/* 25/*
25 * The maptile is allocated each time a new map is opened. 26 * The maptile is allocated each time a new map is opened.
26 * It contains pointers (very indirectly) to all objects on the map. 27 * It contains pointers (very indirectly) to all objects on the map.
27 */ 28 */
28 29
29#ifndef MAP_H 30#ifndef MAP_H
30#define MAP_H 31#define MAP_H
31 32
33#include <tr1/unordered_map>
34
32#include "cfperl.h" 35#include "cfperl.h"
33 36
34/* We set this size - this is to make magic map work properly on 37/* We set this size - this is to make magic map work properly on
35 * tiled maps. There is no requirement that this matches the 38 * tiled maps. There is no requirement that this matches the
36 * tiled maps size - it just seemed like a reasonable value. 39 * tiled maps size - it just seemed like a reasonable value.
37 * Magic map code now always starts out putting the player in the 40 * Magic map code now always starts out putting the player in the
38 * center of the map - this makes the most sense when dealing 41 * center of the map - this makes the most sense when dealing
39 * with tiled maps. 42 * with tiled maps.
40 * We also figure out the magicmap color to use as we process the 43 * We also figure out the magicmap color to use as we process the
… …
42 * map pointers. 45 * map pointers.
43 */ 46 */
44#define MAGIC_MAP_SIZE 50 47#define MAGIC_MAP_SIZE 50
45#define MAGIC_MAP_HALF MAGIC_MAP_SIZE/2 48#define MAGIC_MAP_HALF MAGIC_MAP_SIZE/2
46 49
47
48#define MAP_LAYERS 4 50#define MAP_LAYERS 3
49
50/* This is when the map will reset */
51#define MAP_WHEN_RESET(m) ((m)->reset_time)
52
53#define MAP_RESET_TIMEOUT(m) ((m)->reset_timeout)
54#define MAP_DIFFICULTY(m) ((m)->difficulty)
55#define MAP_TIMEOUT(m) ((m)->timeout)
56#define MAP_SWAP_TIME(m) ((m)->swap_time)
57#define MAP_OUTDOORS(m) ((m)->outdoor)
58
59/* mape darkness used to enforce the MAX_DARKNESS value.
60 * but IMO, if it is beyond max value, that should be fixed
61 * on the map or in the code.
62 */
63#define MAP_DARKNESS(m) (m)->darkness
64
65#define MAP_WIDTH(m) (m)->width
66#define MAP_HEIGHT(m) (m)->height
67
68/* Convenient function - total number of spaces is used
69 * in many places.
70 */
71#define MAP_SIZE(m) ((m)->width * (m)->height)
72
73#define MAP_ENTER_X(m) (m)->enter_x
74#define MAP_ENTER_Y(m) (m)->enter_y
75
76#define MAP_TEMP(m) (m)->temp
77#define MAP_PRESSURE(m) (m)->pressure
78#define MAP_HUMID(m) (m)->humid
79#define MAP_WINDSPEED(m) (m)->windspeed
80#define MAP_WINDDIRECTION(m) (m)->winddir
81#define MAP_SKYCOND(m) (m)->sky
82#define MAP_WORLDPARTX(m) (m)->wpartx
83#define MAP_WORLDPARTY(m) (m)->wparty
84#define MAP_NOSMOOTH(m) (m)->nosmooth
85 51
86/* options passed to ready_map_name and load_original_map */ 52/* options passed to ready_map_name and load_original_map */
87#define MAP_FLUSH 0x1 53#define MAP_FLUSH 0x01
88#define MAP_PLAYER_UNIQUE 0x2 54#define MAP_PLAYER_UNIQUE 0x02
89#define MAP_BLOCK 0x4 55#define MAP_BLOCK 0x04
90#define MAP_STYLE 0x8 56#define MAP_STYLE 0x08
91#define MAP_OVERLAY 0x10 57#define MAP_OVERLAY 0x10
92 58
93/* Values for in_memory below. Should probably be an enumerations */ 59/* Values for in_memory below. Should probably be an enumerations */
94#define MAP_IN_MEMORY 1 60enum {
95#define MAP_SWAPPED 2 61 MAP_IN_MEMORY,
96#define MAP_LOADING 3 62 MAP_SWAPPED,
97#define MAP_SAVING 4 63 MAP_LOADING,
64 MAP_SAVING,
65};
98 66
99/* GET_MAP_FLAGS really shouldn't be used very often - get_map_flags should 67/* GET_MAP_FLAGS really shouldn't be used very often - get_map_flags should
100 * really be used, as it is multi tile aware. However, there are some cases 68 * really be used, as it is multi tile aware. However, there are some cases
101 * where it is known the map is not tiled or the values are known 69 * where it is known the map is not tiled or the values are known
102 * consistent (eg, op->map, op->x, op->y) 70 * consistent (eg, op->map, op->x, op->y)
103 */ 71 */
104#define GET_MAP_FLAGS(M,X,Y) ( (M)->spaces[(X) + (M)->width * (Y)].flags ) 72// all those macros are herewith declared legacy
105#define SET_MAP_FLAGS(M,X,Y,C) ( (M)->spaces[(X) + (M)->width * (Y)].flags = C ) 73#define GET_MAP_FLAGS(M,X,Y) (M)->at((X),(Y)).flags ()
106#define GET_MAP_LIGHT(M,X,Y) ( (M)->spaces[(X) + (M)->width * (Y)].light ) 74#define GET_MAP_LIGHT(M,X,Y) (M)->at((X),(Y)).light
107#define SET_MAP_LIGHT(M,X,Y,L) ( (M)->spaces[(X) + (M)->width * (Y)].light = L ) 75#define GET_MAP_OB(M,X,Y) (M)->at((X),(Y)).bot
108 76#define GET_MAP_TOP(M,X,Y) (M)->at((X),(Y)).top
109#define GET_MAP_OB(M,X,Y) ( (M)->spaces[(X) + (M)->width * (Y)].bottom ) 77#define GET_MAP_FACE(M,X,Y,L) (M)->at((X),(Y)).faces[L]
110#define GET_MAP_TOP(M,X,Y) ( (M)->spaces[(X) + (M)->width * (Y)].top )
111
112/* legacy */
113#define get_map_ob GET_MAP_OB
114
115#define SET_MAP_OB(M,X,Y,tmp) ( (M)->spaces[(X) + (M)->width * (Y)].bottom = (tmp) )
116#define SET_MAP_TOP(M,X,Y,tmp) ( (M)->spaces[(X) + (M)->width * (Y)].top = (tmp) )
117#define set_map_ob SET_MAP_OB
118
119#define SET_MAP_FACE(M,X,Y,C,L) ( (M)->spaces[(X) + (M)->width * (Y)].faces[L] = C )
120#define GET_MAP_FACE(M,X,Y,L) ( (M)->spaces[(X) + (M)->width * (Y)].faces[L] )
121
122#define SET_MAP_FACE_OBJ(M,X,Y,C,L) ( (M)->spaces[(X) + (M)->width * (Y)].faces_obj[L] = C )
123#define GET_MAP_FACE_OBJ(M,X,Y,L) ( (M)->spaces[(X) + (M)->width * (Y)].faces_obj[L] ) 78#define GET_MAP_FACE_OBJ(M,X,Y,L) (M)->at((X),(Y)).faces_obj[L]
124
125#define GET_MAP_MOVE_BLOCK(M,X,Y) ( (M)->spaces[(X) + (M)->width * (Y)].move_block ) 79#define GET_MAP_MOVE_BLOCK(M,X,Y) (M)->at((X),(Y)).move_block
126#define SET_MAP_MOVE_BLOCK(M,X,Y,C) ( (M)->spaces[(X) + (M)->width * (Y)].move_block = C )
127
128#define GET_MAP_MOVE_SLOW(M,X,Y) ( (M)->spaces[(X) + (M)->width * (Y)].move_slow ) 80#define GET_MAP_MOVE_SLOW(M,X,Y) (M)->at((X),(Y)).move_slow
129#define SET_MAP_MOVE_SLOW(M,X,Y,C) ( (M)->spaces[(X) + (M)->width * (Y)].move_slow = C )
130
131#define GET_MAP_MOVE_ON(M,X,Y) ( (M)->spaces[(X) + (M)->width * (Y)].move_on ) 81#define GET_MAP_MOVE_ON(M,X,Y) (M)->at((X),(Y)).move_on
132#define SET_MAP_MOVE_ON(M,X,Y,C) ( (M)->spaces[(X) + (M)->width * (Y)].move_on = C )
133
134#define GET_MAP_MOVE_OFF(M,X,Y) ( (M)->spaces[(X) + (M)->width * (Y)].move_off ) 82#define GET_MAP_MOVE_OFF(M,X,Y) (M)->at((X),(Y)).move_off
135#define SET_MAP_MOVE_OFF(M,X,Y,C) ( (M)->spaces[(X) + (M)->width * (Y)].move_off = C )
136 83
137/* You should really know what you are doing before using this - you 84/* You should really know what you are doing before using this - you
138 * should almost always be using out_of_map instead, which takes into account 85 * should almost always be using out_of_map instead, which takes into account
139 * map tiling. 86 * map tiling.
140 */ 87 */
141#define OUT_OF_REAL_MAP(M,X,Y) ((X)<0 || (Y)<0 || (X)>=(M)->width || (Y)>=(M)->height) 88#define OUT_OF_REAL_MAP(M,X,Y) ((X)<0 || (Y)<0 || (X)>=(M)->width || (Y)>=(M)->height)
142 89
143/* These are used in the MapLook flags element. They are not used in 90/* These are used in the MapLook flags element. They are not used in
144 * in the object flags structure. 91 * in the object flags structure.
145 */ 92 */
146
147#define P_BLOCKSVIEW 0x01 93#define P_BLOCKSVIEW 0x01
148#define P_NO_MAGIC 0x02 /* Spells (some) can't pass this object */ 94#define P_NO_MAGIC 0x02 /* Spells (some) can't pass this object */
149 95#define P_PLAYER 0x04 /* a player (or something seeing these objects) is on this mapspace */
150/* AB_NO_PASS is used for arch_blocked() return value. It needs 96#define P_SAFE 0x08 /* If this is set the map tile is a safe space,
151 * to be here to make sure the bits don't match with anything.
152 * Changed name to have AB_ prefix just to make sure no one
153 * is using the P_NO_PASS. AB_.. should only be used for
154 * arch_blocked and functions that examine the return value.
155 */
156
157#define AB_NO_PASS 0x04
158
159 /*#define P_PASS_THRU 0x08 *//* */
160#define P_SAFE 0x08
161 /* If this is set the map tile is a safe map,
162 * that means, nothing harmful there will be done, 97 * that means, nothing harmful can be done,
163 * like: bombs, potion usage, alchemy, spells 98 * such as: bombs, potion usage, alchemy, spells
164 * this was introduced to make shops more safe 99 * this was introduced to make shops safer
165 * and propably other maps */ 100 * but is useful in other situations */
166#define P_IS_ALIVE 0x10 /* something alive is on this space */ 101#define P_IS_ALIVE 0x10 /* something alive is on this space */
167#define P_NO_CLERIC 0x20 /* no clerical spells cast here */ 102#define P_NO_CLERIC 0x20 /* no clerical spells cast here */
103
168#define P_NEED_UPDATE 0x40 /* this space is out of date */ 104#define P_UPTODATE 0x80 /* this space is up to date */
169#define P_NO_ERROR 0x80 /* Purely temporary - if set, update_position
170 * does not complain if the flags are different.
171 */
172 105
173/* The following two values are not stored in the MapLook flags, but instead 106/* The following two values are not stored in the MapLook flags, but instead
174 * used in the get_map_flags value - that function is used to return 107 * used in the get_map_flags value - that function is used to return
175 * the flag value, as well as other conditions - using a more general 108 * the flag value, as well as other conditions - using a more general
176 * function that does more of the work can hopefully be used to replace 109 * function that does more of the work can hopefully be used to replace
177 * lots of duplicate checks currently in the code. 110 * lots of duplicate checks currently in the code.
178 */ 111 */
179#define P_OUT_OF_MAP 0x100 /* This space is outside the map */ 112#define P_OUT_OF_MAP 0x10000 /* This space is outside the map */
180#define P_NEW_MAP 0x200 113#define P_NEW_MAP 0x20000
181 /* Coordinates passed result in a new tiled map */ 114 /* Coordinates passed result in a new tiled map */
182 115
183/* Can't use MapCell as that is used in newserver.h 116/* P_NO_PASS is used for ob_blocked() return value. It needs
117 * to be here to make sure the bits don't match with anything.
118 */
119#define P_NO_PASS 0x80000
120
184 * Instead of having numerous arrays that have information on a 121/* Instead of having numerous arrays that have information on a
185 * particular space (was map, floor, floor2, map_ob), 122 * particular space (was map, floor, floor2, map_ob),
186 * have this structure take care of that information. 123 * have this structure take care of that information.
187 * This puts it all in one place, and should also make it easier 124 * This puts it all in one place, and should also make it easier
188 * to extend information about a space. 125 * to extend information about a space.
189 */ 126 */
190
191struct MapSpace 127struct mapspace
192{ 128{
193 object *bottom; /* lowest object on this space */ 129 object *bot, *top; /* lowest/highest object on this space */
194 object *top; /* Highest object on this space */
195 New_Face *faces[MAP_LAYERS]; /* faces for the 3 layers */ 130 New_Face *faces[MAP_LAYERS]; /* faces for the 3 layers */
196 object *faces_obj[MAP_LAYERS]; /* face objects for the 3 layers */ 131 object *faces_obj[MAP_LAYERS];/* face objects for the 3 layers */
197 uint8 flags; /* flags about this space (see the P_ values above) */ 132 uint8 flags_; /* flags about this space (see the P_ values above) */
198 sint8 light; /* How much light this space provides */ 133 sint8 light; /* How much light this space provides */
199 MoveType move_block; /* What movement types this space blocks */ 134 MoveType move_block; /* What movement types this space blocks */
200 MoveType move_slow; /* What movement types this space slows */ 135 MoveType move_slow; /* What movement types this space slows */
201 MoveType move_on; /* What movement types are activated */ 136 MoveType move_on; /* What movement types are activated */
202 MoveType move_off; /* What movement types are activated */ 137 MoveType move_off; /* What movement types are activated */
203};
204 138
205/* 139 void update_ ();
206 * this is an overlay structure of the whole world. It exists as a simple 140 void update ()
207 * high level map, which doesn't contain the full data of the underlying map. 141 {
208 * in this map, only things such as weather are recorded. By doing so, we 142 if (!(flags_ & P_UPTODATE))
209 * can keep the entire world parameters in memory, and act as a whole on 143 update_ ();
210 * them at once. We can then, in a separate loop, update the actual world 144 }
211 * with the new values we have assigned.
212 */
213 145
214struct weathermap_t 146 uint8 flags ()
215{ 147 {
216 sint16 temp; /* base temperature of this tile (F) */ 148 update ();
217 sint16 pressure; /* barometric pressure (mb) */ 149 return flags_;
218 sint8 humid; /* humitidy of this tile */ 150 }
219 sint8 windspeed; /* windspeed of this tile */ 151
220 sint8 winddir; /* direction of wind */ 152 // maybe only inline quick flags_ checking?
221 sint8 sky; /* sky conditions */ 153 object *player ()
222 sint32 avgelev; /* average elevation */ 154 {
223 uint32 rainfall; /* cumulative rainfall */ 155 // search from the top, because players are usually on top
224 uint8 darkness; /* indicates level of darkness of map */ 156 // make usually == always and this non-amortized O(1)
225 uint8 water; /* 0-100 percentage of water tiles */ 157 // could gte rid of P_PLAYER, too, then
226 /*Dynamic parts */ 158 if (flags () & P_PLAYER)
227 sint16 realtemp; /* temperature at a given calculation step for this tile */ 159 for (object *op = top; op; op = op->below)
160 if (op->type == PLAYER)
161 return op;
162
163 return 0;
164 }
228}; 165};
229 166
230/* 167/*
231 * Each map is in a given region of the game world and links to a region definiton, so 168 * Each map is in a given region of the game world and links to a region definiton, so
232 * they have to appear here in the headers, before the mapdef 169 * they have to appear here in the headers, before the mapdef
233 */ 170 */
234struct region 171INTERFACE_CLASS (region)
172struct region : zero_initialised
235{ 173{
236 struct region *next; /* pointer to next region, NULL for the last one */ 174 struct region *ACC (RW, next); /* pointer to next region, NULL for the last one */
237 const char *name; /* Shortend name of the region as maps refer to it */ 175 char *ACC (RW, name); /* Shortend name of the region as maps refer to it */
238 const char *parent_name; /* 176 char *ACC (RW, parent_name); /*
239 * So that parent and child regions can be defined in 177 * So that parent and child regions can be defined in
240 * any order, we keep hold of the parent_name during 178 * any order, we keep hold of the parent_name during
241 * initialisation, and the children get assigned to their 179 * initialisation, and the children get assigned to their
242 * parents later. (before runtime on the server though) 180 * parents later. (before runtime on the server though)
243 * nothing outside the init code should ever use this value. 181 * nothing outside the init code should ever use this value.
244 */ 182 */
245 struct region *parent; /* 183 struct region *ACC (RW, parent); /*
246 * Pointer to the region that is a parent of the current 184 * Pointer to the region that is a parent of the current
247 * region, if a value isn't defined in the current region 185 * region, if a value isn't defined in the current region
248 * we traverse this series of pointers until it is. 186 * we traverse this series of pointers until it is.
249 */ 187 */
250 const char *longname; /* Official title of the region, this might be defined 188 char *ACC (RW, longname); /* Official title of the region, this might be defined
251 * to be the same as name*/ 189 * to be the same as name*/
252 const char *msg; /* the description of the region */ 190 char *ACC (RW, msg); /* the description of the region */
253 uint32 counter; /* A generic counter for holding temporary data. */ 191 uint32 ACC (RW, counter); /* A generic counter for holding temporary data. */
254 sint8 fallback; /* whether, in the event of a region not existing, 192 sint8 ACC (RW, fallback); /* whether, in the event of a region not existing,
255 * this should be the one we fall back on as the default */ 193 * this should be the one we fall back on as the default */
256 char *jailmap; /*where a player that is arrested in this region should be imprisoned. */ 194 char *ACC (RW, jailmap); /*where a player that is arrested in this region should be imprisoned. */
257 sint16 jailx, jaily; /* The coodinates in jailmap to which the player should be sent. */ 195 sint16 ACC (RW, jailx), ACC (RW, jaily); /* The coodinates in jailmap to which the player should be sent. */
258}; 196};
259
260 197
261struct shopitems : zero_initialised 198struct shopitems : zero_initialised
262{ 199{
263 const char *name; /* name of the item in question, null if it is the default item */ 200 const char *name; /* name of the item in question, null if it is the default item */
264 const char *name_pl; /* plural name */ 201 const char *name_pl; /* plural name */
265 int typenum; /* itemtype number we need to match 0 if it is the default price */ 202 int typenum; /* itemtype number we need to match 0 if it is the default price */
266 sint8 strength; /* the degree of specialisation the shop has in this item, 203 sint8 strength; /* the degree of specialisation the shop has in this item,
267 * as a percentage from -100 to 100 */ 204 * as a percentage from -100 to 100 */
268 int index; /* being the size of the shopitems array. */ 205 int index; /* being the size of the shopitems array. */
206};
207
208// map I/O, what to load/save
209enum {
210 IO_HEADER = 0x01, // the "arch map" pseudo object
211 IO_OBJECTS = 0x02, // the non-unique objects
212 IO_UNIQUES = 0x04, // unique objects
269}; 213};
270 214
271/* In general, code should always use the macros 215/* In general, code should always use the macros
272 * above (or functions in map.c) to access many of the 216 * above (or functions in map.c) to access many of the
273 * values in the map structure. Failure to do this will 217 * values in the map structure. Failure to do this will
274 * almost certainly break various features. You may think 218 * almost certainly break various features. You may think
275 * it is safe to look at width and height values directly 219 * it is safe to look at width and height values directly
276 * (or even through the macros), but doing so will completely 220 * (or even through the macros), but doing so will completely
277 * break map tiling. 221 * break map tiling.
278 */ 222 */
279ACC_CLASS (maptile) 223INTERFACE_CLASS (maptile)
280struct maptile : zero_initialised, attachable<maptile> 224struct maptile : zero_initialised, attachable
281{ 225{
282 maptile *ACC (RW, next); /* Next map, linked list */ 226 sint32 ACC (RW, width), ACC (RW, height); /* Width and height of map. */
283 char *ACC (RO, tmpname); /* Name of temporary file */ 227 struct mapspace *spaces; /* Array of spaces on this map */
228
229 tstamp ACC (RW, last_access); /* last time this map was accessed somehow */
230
284 char *ACC (RO, name); /* Name of map as given by its creator */ 231 shstr ACC (RW, name); /* Name of map as given by its creator */
285 struct region *ACC (RW, region); /* What jurisdiction in the game world this map is ruled by 232 struct region *ACC (RW, region); /* What jurisdiction in the game world this map is ruled by
286 * points to the struct containing all the properties of 233 * points to the struct containing all the properties of
287 * the region */ 234 * the region */
288 uint32 ACC (RW, reset_time); /* when this map should reset */ 235 double ACC (RW, reset_time);
289 uint32 ACC (RW, reset_timeout); /* How many seconds must elapse before this map 236 uint32 ACC (RW, reset_timeout); /* How many seconds must elapse before this map
290 * should be reset 237 * should be reset
291 */ 238 */
239 bool ACC (RW, dirty); /* if true, something was inserted or removed */
292 bool ACC (RW, fixed_resettime); /* if true, reset time is not affected by 240 bool ACC (RW, fixed_resettime); /* if true, reset time is not affected by
293 * players entering/exiting map 241 * players entering/exiting map
294 */ 242 */
295 bool ACC (RW, unique); /* if set, this is a per player unique map */
296 bool ACC (RW, templatemap); /* if set, this is a template map */
297 bool ACC (RW, nosmooth); /* if set the content of this map has smoothlevel=0 forced */
298 sint32 ACC (RW, timeout); /* swapout is set to this */ 243 sint32 ACC (RW, timeout); /* swapout is set to this */
299 sint32 ACC (RW, swap_time); /* When it reaches 0, the map will be swapped out */ 244 sint32 ACC (RW, swap_time); /* When it reaches 0, the map will be swapped out */
300 sint16 ACC (RW, players); /* How many players are on this level right now */
301 uint32 ACC (RW, in_memory); /* If not true, the map has been freed and must 245 uint32 ACC (RW, in_memory); /* If not true, the map has been freed and must
302 * be loaded before used. The map,omap and map_ob 246 * be loaded before used. The map,omap and map_ob
303 * arrays will be allocated when the map is loaded */ 247 * arrays will be allocated when the map is loaded */
248 sint16 players; /* How many players are on this map right now */
304 uint16 ACC (RW, difficulty); /* What level the player should be to play here */ 249 uint16 ACC (RW, difficulty); /* What level the player should be to play here */
305 250
251 bool ACC (RW, per_player);
252 bool ACC (RW, per_party);
253 bool ACC (RW, outdoor); /* True if an outdoor map */
306 uint8 ACC (RW, darkness); /* indicates level of darkness of map */ 254 uint8 ACC (RW, darkness); /* indicates level of darkness of map */
307 uint16 ACC (RO, width), ACC (RO, height); /* Width and height of map. */ 255
308 uint16 ACC (RW, enter_x); /* enter_x and enter_y are default entrance location */ 256 uint16 ACC (RW, enter_x); /* enter_x and enter_y are default entrance location */
309 uint16 ACC (RW, enter_y); /* on the map if none are set in the exit */ 257 uint16 ACC (RW, enter_y); /* on the map if none are set in the exit */
310 bool ACC (RW, outdoor); /* True if an outdoor map */
311 oblinkpt *buttons; /* Linked list of linked lists of buttons */ 258 oblinkpt *buttons; /* Linked list of linked lists of buttons */
312 struct MapSpace *spaces; /* Array of spaces on this map */
313 sint16 ACC (RW, temp); /* base temperature of this tile (F) */ 259 sint16 ACC (RW, temp); /* base temperature of this tile (F) */
314 sint16 ACC (RW, pressure); /* barometric pressure (mb) */ 260 sint16 ACC (RW, pressure); /* barometric pressure (mb) */
315 sint8 ACC (RW, humid); /* humitidy of this tile */ 261 sint8 ACC (RW, humid); /* humitidy of this tile */
316 sint8 ACC (RW, windspeed); /* windspeed of this tile */ 262 sint8 ACC (RW, windspeed); /* windspeed of this tile */
317 sint8 ACC (RW, winddir); /* direction of wind */ 263 sint8 ACC (RW, winddir); /* direction of wind */
318 sint8 ACC (RW, sky); /* sky conditions */ 264 sint8 ACC (RW, sky); /* sky conditions */
319 int ACC (RW, wpartx), ACC (RW, wparty); /*Highly fasten conversion between worldmap and weathermap */ 265 int ACC (RW, worldpartx), ACC (RW, worldparty); /*Highly fasten conversion between worldmap and weathermap */
320 struct shopitems *shopitems; /* a semi-colon seperated list of item-types the map's shop will trade in */ 266 struct shopitems *shopitems; /* a semi-colon seperated list of item-types the map's shop will trade in */
321 char *ACC (RO, shoprace); /* the preffered race of the local shopkeeper */ 267 shstr ACC (RW, shoprace); /* the preffered race of the local shopkeeper */
322 double ACC (RW, shopgreed); /* how much our shopkeeper overcharges */ 268 double ACC (RW, shopgreed); /* how much our shopkeeper overcharges */
323 uint64 ACC (RW, shopmin); /* minimum price a shop will trade for */ 269 sint64 ACC (RW, shopmin); /* minimum price a shop will trade for */
324 uint64 ACC (RW, shopmax); /* maximum price a shop will offer */ 270 sint64 ACC (RW, shopmax); /* maximum price a shop will offer */
325 char *ACC (RO, msg); /* Message map creator may have left */ 271 shstr ACC (RW, msg); /* Message map creator may have left */
326 char *ACC (RO, maplore); /* Map lore information */ 272 shstr ACC (RW, maplore); /* Map lore information */
327 char *tile_path[4]; /* path to adjoining maps */ 273 shstr ACC (RW, tile_path[4]); /* path to adjoining maps */
328 maptile *tile_map[4]; /* Next map, linked list */ 274 maptile *ACC (RW, tile_map[4]); /* Next map, linked list */
329 char ACC (RW, path)[HUGE_BUF]; /* Filename of the map */ 275 shstr ACC (RW, path); /* Filename of the map */
276
277 MTH void activate ();
278 MTH void deactivate ();
279
280 // allocates all (empty) mapspace
281 MTH void alloc ();
282 // deallocates the mapspaces (and destroys all objects)
283 MTH void clear ();
284
285 MTH void fix_auto_apply ();
286 MTH void decay_objects ();
287 MTH void update_buttons ();
288 MTH int change_map_light (int change);
289 static void change_all_map_light (int change); //PERL
290 MTH void set_darkness_map ();
291 MTH int estimate_difficulty () const;
292
293 // set the given flag on all objects in the map
294 MTH void set_object_flag (int flag, int value = 1);
295
296 MTH void link_multipart_objects ();
297 MTH void clear_unique_items ();
298
299 MTH void clear_header ();
300 MTH void clear_links_to (maptile *m);
301
302 // loas the header pseudo-object
303 bool load_header (object_thawer &thawer);
304 MTH bool load_header (const char *path);
305
306 // load objects into the map
307 bool load_objects (object_thawer &thawer);
308 MTH bool load_objects (const char *path, bool skip_header = true);
309
310 // save objects into the given file (uses IO_ flags)
311 bool save_objects (object_freezer &freezer, int flags);
312 MTH bool save_objects (const char *path, int flags);
313
314 // save the header pseudo object _only_
315 bool save_header (object_freezer &freezer);
316 MTH bool save_header (const char *path);
330 317
331 maptile (); 318 maptile ();
332 void allocate (); 319 maptile (int w, int h);
320 ~maptile ();
321
322 void do_destroy ();
323 void gather_callbacks (AV *&callbacks, event_type event) const;
324
325 MTH int size () const { return width * height; }
326
327 MTH object *insert (object *op, int x, int y, object *originator = 0, int flags = 0);
328
329 MTH void touch () { last_access = runtime; }
330
331 // find the map that is at coordinate x|y relative to this map
332 // TODO: need a better way than passing by reference
333 // TODO: make perl interface
334 maptile *xy_find (sint16 &x, sint16 &y);
335
336 // like xy_find, but also loads the map
337 maptile *xy_load (sint16 &x, sint16 &y);
338
339 void do_load_sync ();//PERL
340
341 // make sure the map is loaded
342 MTH void load_sync ()
343 {
344 if (!spaces)
345 do_load_sync ();
346 }
347
348 static maptile *find_sync (const char *path, maptile *original = 0);//PERL
349 // async prefetch
350 static maptile *find_async (const char *path, maptile *original = 0);//PERL
351
352 mapspace const &at (uint32 x, uint32 y) const { return spaces [x * height + y]; }
353 mapspace &at (uint32 x, uint32 y) { return spaces [x * height + y]; }
333}; 354};
334 355
335/* This is used by get_rangevector to determine where the other 356/* This is used by get_rangevector to determine where the other
336 * creature is. get_rangevector takes into account map tiling, 357 * creature is. get_rangevector takes into account map tiling,
337 * so you just can not look the the map coordinates and get the 358 * so you just can not look the the map coordinates and get the
338 * righte value. distance_x/y are distance away, which 359 * righte value. distance_x/y are distance away, which
339 * can be negativbe. direction is the crossfire direction scheme 360 * can be negative. direction is the crossfire direction scheme
340 * that the creature should head. part is the part of the 361 * that the creature should head. part is the part of the
341 * monster that is closest. 362 * monster that is closest.
342 * Note: distance should be always >=0. I changed it to UINT. MT 363 * Note: distance should be always >=0. I changed it to UINT. MT
343 */ 364 */
344struct rv_vector 365struct rv_vector
… …
348 int distance_y; 369 int distance_y;
349 int direction; 370 int direction;
350 object *part; 371 object *part;
351}; 372};
352 373
374inline mapspace &
375object::ms () const
376{
377 return map->at (x, y);
378}
379
353#endif 380#endif
354 381

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines