ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/include/map.h
Revision: 1.65
Committed: Wed Feb 7 02:04:46 2007 UTC (17 years, 3 months ago) by root
Content type: text/plain
Branch: MAIN
Changes since 1.64: +3 -0 lines
Log Message:
rework material code in preparation for nuking object->materials, also add some useful object methods in preparation of the mapspace limiting

File Contents

# User Rev Content
1 root 1.1 /*
2 pippijn 1.53 * CrossFire, A Multiplayer game for X-windows
3     *
4     * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
5     * Copyright (C) 2002-2005 Mark Wedel & Crossfire Development Team
6     * Copyright (C) 1992 Frank Tore Johansen
7     *
8     * This program is free software; you can redistribute it and/or modify
9     * it under the terms of the GNU General Public License as published by
10     * the Free Software Foundation; either version 2 of the License, or
11     * (at your option) any later version.
12     *
13     * This program is distributed in the hope that it will be useful,
14     * but WITHOUT ANY WARRANTY; without even the implied warranty of
15     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16     * GNU General Public License for more details.
17     *
18     * You should have received a copy of the GNU General Public License
19     * along with this program; if not, write to the Free Software
20     * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21     *
22     * The authors can be reached via e-mail at crossfire@schmorp.de
23     */
24 root 1.1
25     /*
26 root 1.21 * The maptile is allocated each time a new map is opened.
27 root 1.1 * It contains pointers (very indirectly) to all objects on the map.
28     */
29    
30     #ifndef MAP_H
31     #define MAP_H
32    
33 root 1.40 #include <tr1/unordered_map>
34    
35 root 1.9 #include "cfperl.h"
36    
37 root 1.1 /* We set this size - this is to make magic map work properly on
38 root 1.34 * tiled maps. There is no requirement that this matches the
39 root 1.1 * tiled maps size - it just seemed like a reasonable value.
40     * Magic map code now always starts out putting the player in the
41     * center of the map - this makes the most sense when dealing
42     * with tiled maps.
43     * We also figure out the magicmap color to use as we process the
44     * spaces - this is more efficient as we already have up to date
45     * map pointers.
46     */
47     #define MAGIC_MAP_SIZE 50
48     #define MAGIC_MAP_HALF MAGIC_MAP_SIZE/2
49    
50 root 1.31 #define MAP_LAYERS 3
51 root 1.1
52     /* Values for in_memory below. Should probably be an enumerations */
53 root 1.47 enum {
54     MAP_IN_MEMORY,
55     MAP_SWAPPED,
56     MAP_LOADING,
57     MAP_SAVING,
58     };
59 root 1.1
60     /* GET_MAP_FLAGS really shouldn't be used very often - get_map_flags should
61     * really be used, as it is multi tile aware. However, there are some cases
62     * where it is known the map is not tiled or the values are known
63     * consistent (eg, op->map, op->x, op->y)
64     */
65 root 1.29 // all those macros are herewith declared legacy
66 root 1.30 #define GET_MAP_FLAGS(M,X,Y) (M)->at((X),(Y)).flags ()
67 root 1.29 #define GET_MAP_LIGHT(M,X,Y) (M)->at((X),(Y)).light
68 root 1.34 #define GET_MAP_OB(M,X,Y) (M)->at((X),(Y)).bot
69 root 1.29 #define GET_MAP_TOP(M,X,Y) (M)->at((X),(Y)).top
70     #define GET_MAP_FACE(M,X,Y,L) (M)->at((X),(Y)).faces[L]
71     #define GET_MAP_FACE_OBJ(M,X,Y,L) (M)->at((X),(Y)).faces_obj[L]
72     #define GET_MAP_MOVE_BLOCK(M,X,Y) (M)->at((X),(Y)).move_block
73     #define GET_MAP_MOVE_SLOW(M,X,Y) (M)->at((X),(Y)).move_slow
74     #define GET_MAP_MOVE_ON(M,X,Y) (M)->at((X),(Y)).move_on
75     #define GET_MAP_MOVE_OFF(M,X,Y) (M)->at((X),(Y)).move_off
76 root 1.1
77     /* You should really know what you are doing before using this - you
78     * should almost always be using out_of_map instead, which takes into account
79     * map tiling.
80     */
81 root 1.56 #define OUT_OF_REAL_MAP(M,X,Y) (!(IN_RANGE_EXC ((X), 0, (M)->width) && IN_RANGE_EXC ((Y), 0, (M)->height)))
82 root 1.1
83     /* These are used in the MapLook flags element. They are not used in
84     * in the object flags structure.
85     */
86     #define P_BLOCKSVIEW 0x01
87 root 1.20 #define P_NO_MAGIC 0x02 /* Spells (some) can't pass this object */
88 root 1.29 #define P_PLAYER 0x04 /* a player (or something seeing these objects) is on this mapspace */
89     #define P_SAFE 0x08 /* If this is set the map tile is a safe space,
90     * that means, nothing harmful can be done,
91     * such as: bombs, potion usage, alchemy, spells
92     * this was introduced to make shops safer
93     * but is useful in other situations */
94 root 1.20 #define P_IS_ALIVE 0x10 /* something alive is on this space */
95     #define P_NO_CLERIC 0x20 /* no clerical spells cast here */
96 root 1.30
97 root 1.45 #define P_UPTODATE 0x80 /* this space is up to date */
98 root 1.20
99 root 1.1 /* The following two values are not stored in the MapLook flags, but instead
100     * used in the get_map_flags value - that function is used to return
101     * the flag value, as well as other conditions - using a more general
102     * function that does more of the work can hopefully be used to replace
103     * lots of duplicate checks currently in the code.
104     */
105 root 1.29 #define P_OUT_OF_MAP 0x10000 /* This space is outside the map */
106     #define P_NEW_MAP 0x20000
107 root 1.20 /* Coordinates passed result in a new tiled map */
108 root 1.1
109 root 1.29 /* P_NO_PASS is used for ob_blocked() return value. It needs
110     * to be here to make sure the bits don't match with anything.
111     */
112     #define P_NO_PASS 0x80000
113    
114     /* Instead of having numerous arrays that have information on a
115 root 1.1 * particular space (was map, floor, floor2, map_ob),
116     * have this structure take care of that information.
117     * This puts it all in one place, and should also make it easier
118     * to extend information about a space.
119     */
120 root 1.29 struct mapspace
121 root 1.20 {
122 root 1.34 object *bot, *top; /* lowest/highest object on this space */
123 root 1.55 facetile *faces[MAP_LAYERS]; /* faces for the 3 layers */
124 root 1.30 object *faces_obj[MAP_LAYERS];/* face objects for the 3 layers */
125     uint8 flags_; /* flags about this space (see the P_ values above) */
126 root 1.20 sint8 light; /* How much light this space provides */
127 root 1.30 MoveType move_block; /* What movement types this space blocks */
128     MoveType move_slow; /* What movement types this space slows */
129     MoveType move_on; /* What movement types are activated */
130     MoveType move_off; /* What movement types are activated */
131    
132     void update_ ();
133     void update ()
134     {
135 root 1.45 if (!(flags_ & P_UPTODATE))
136 root 1.30 update_ ();
137     }
138    
139     uint8 flags ()
140     {
141     update ();
142     return flags_;
143     }
144    
145     // maybe only inline quick flags_ checking?
146     object *player ()
147     {
148 root 1.31 // search from the top, because players are usually on top
149     // make usually == always and this non-amortized O(1)
150     // could gte rid of P_PLAYER, too, then
151 root 1.30 if (flags () & P_PLAYER)
152 root 1.31 for (object *op = top; op; op = op->below)
153 root 1.30 if (op->type == PLAYER)
154     return op;
155    
156     return 0;
157     }
158 root 1.65
159     // return the item volume on this mapspace in kg/m³
160     uint64 volume ();
161 elmex 1.6 };
162 root 1.1
163     /*
164     * Each map is in a given region of the game world and links to a region definiton, so
165     * they have to appear here in the headers, before the mapdef
166     */
167 root 1.43 INTERFACE_CLASS (region)
168 root 1.26 struct region : zero_initialised
169 root 1.20 {
170 root 1.61 shstr ACC (RW, name); /* Shortend name of the region as maps refer to it */
171 root 1.60 region *ACC (RW, parent); /*
172 root 1.43 * Pointer to the region that is a parent of the current
173     * region, if a value isn't defined in the current region
174     * we traverse this series of pointers until it is.
175     */
176 root 1.64 shstr ACC (RW, longname); /* Official title of the region, this might be defined
177 root 1.43 * to be the same as name*/
178 root 1.62 shstr ACC (RW, msg); /* the description of the region */
179 root 1.64 shstr ACC (RW, jailmap); /*where a player that is arrested in this region should be imprisoned. */
180     int ACC (RW, index);
181 root 1.43 uint32 ACC (RW, counter); /* A generic counter for holding temporary data. */
182 root 1.64 sint16 ACC (RW, jailx), ACC (RW, jaily); /* The coodinates in jailmap to which the player should be sent. */
183     bool ACC (RW, fallback); /* whether, in the event of a region not existing,
184 root 1.43 * this should be the one we fall back on as the default */
185 root 1.60
186     static region *default_region ();
187     static region *find (const char *name);
188 root 1.61 static region *find_fuzzy (const char *name);
189 elmex 1.6 };
190 root 1.1
191 root 1.64 typedef object_vector<region, &region::index> regionvec;
192    
193     extern regionvec regions;
194    
195     #define for_all_regions(var) \
196     for (int _i = 0; _i < regions.size (); ++_i) \
197     declvar (region *, var, regions [_i])
198    
199 root 1.18 struct shopitems : zero_initialised
200     {
201 root 1.20 const char *name; /* name of the item in question, null if it is the default item */
202     const char *name_pl; /* plural name */
203     int typenum; /* itemtype number we need to match 0 if it is the default price */
204     sint8 strength; /* the degree of specialisation the shop has in this item,
205     * as a percentage from -100 to 100 */
206     int index; /* being the size of the shopitems array. */
207 elmex 1.6 };
208 root 1.1
209 root 1.40 // map I/O, what to load/save
210     enum {
211     IO_HEADER = 0x01, // the "arch map" pseudo object
212     IO_OBJECTS = 0x02, // the non-unique objects
213     IO_UNIQUES = 0x04, // unique objects
214     };
215    
216 root 1.1 /* In general, code should always use the macros
217     * above (or functions in map.c) to access many of the
218     * values in the map structure. Failure to do this will
219     * almost certainly break various features. You may think
220     * it is safe to look at width and height values directly
221     * (or even through the macros), but doing so will completely
222     * break map tiling.
223     */
224 root 1.32 INTERFACE_CLASS (maptile)
225     struct maptile : zero_initialised, attachable
226 root 1.19 {
227 root 1.40 sint32 ACC (RW, width), ACC (RW, height); /* Width and height of map. */
228     struct mapspace *spaces; /* Array of spaces on this map */
229 root 1.60 uint8 *regions; /* region index per mapspace, if != 0 */
230     struct region **regionmap; /* index to region */
231 root 1.40
232     tstamp ACC (RW, last_access); /* last time this map was accessed somehow */
233 root 1.29
234 root 1.40 shstr ACC (RW, name); /* Name of map as given by its creator */
235 root 1.59 struct region *ACC (RW, default_region); /* What jurisdiction in the game world this map is ruled by
236 root 1.20 * points to the struct containing all the properties of
237     * the region */
238 root 1.40 double ACC (RW, reset_time);
239 root 1.19 uint32 ACC (RW, reset_timeout); /* How many seconds must elapse before this map
240 root 1.20 * should be reset
241     */
242 root 1.44 bool ACC (RW, dirty); /* if true, something was inserted or removed */
243 root 1.20 bool ACC (RW, fixed_resettime); /* if true, reset time is not affected by
244     * players entering/exiting map
245     */
246     sint32 ACC (RW, timeout); /* swapout is set to this */
247     sint32 ACC (RW, swap_time); /* When it reaches 0, the map will be swapped out */
248     uint32 ACC (RW, in_memory); /* If not true, the map has been freed and must
249     * be loaded before used. The map,omap and map_ob
250     * arrays will be allocated when the map is loaded */
251 root 1.42 sint16 players; /* How many players are on this map right now */
252 root 1.20 uint16 ACC (RW, difficulty); /* What level the player should be to play here */
253    
254 root 1.40 bool ACC (RW, per_player);
255     bool ACC (RW, per_party);
256     bool ACC (RW, outdoor); /* True if an outdoor map */
257 root 1.58 bool ACC (RW, nodrop); /* avoid dropping anything on this map */
258 root 1.20 uint8 ACC (RW, darkness); /* indicates level of darkness of map */
259 root 1.40
260 root 1.20 uint16 ACC (RW, enter_x); /* enter_x and enter_y are default entrance location */
261     uint16 ACC (RW, enter_y); /* on the map if none are set in the exit */
262     oblinkpt *buttons; /* Linked list of linked lists of buttons */
263     sint16 ACC (RW, temp); /* base temperature of this tile (F) */
264     sint16 ACC (RW, pressure); /* barometric pressure (mb) */
265     sint8 ACC (RW, humid); /* humitidy of this tile */
266     sint8 ACC (RW, windspeed); /* windspeed of this tile */
267     sint8 ACC (RW, winddir); /* direction of wind */
268     sint8 ACC (RW, sky); /* sky conditions */
269 root 1.34 int ACC (RW, worldpartx), ACC (RW, worldparty); /*Highly fasten conversion between worldmap and weathermap */
270 root 1.20 struct shopitems *shopitems; /* a semi-colon seperated list of item-types the map's shop will trade in */
271 root 1.40 shstr ACC (RW, shoprace); /* the preffered race of the local shopkeeper */
272 root 1.20 double ACC (RW, shopgreed); /* how much our shopkeeper overcharges */
273 pippijn 1.24 sint64 ACC (RW, shopmin); /* minimum price a shop will trade for */
274 pippijn 1.25 sint64 ACC (RW, shopmax); /* maximum price a shop will offer */
275 root 1.40 shstr ACC (RW, msg); /* Message map creator may have left */
276     shstr ACC (RW, maplore); /* Map lore information */
277     shstr ACC (RW, tile_path[4]); /* path to adjoining maps */
278     maptile *ACC (RW, tile_map[4]); /* Next map, linked list */
279     shstr ACC (RW, path); /* Filename of the map */
280    
281     MTH void activate ();
282     MTH void deactivate ();
283    
284     // allocates all (empty) mapspace
285     MTH void alloc ();
286     // deallocates the mapspaces (and destroys all objects)
287     MTH void clear ();
288    
289     MTH void fix_auto_apply ();
290     MTH void decay_objects ();
291     MTH void update_buttons ();
292     MTH int change_map_light (int change);
293     static void change_all_map_light (int change); //PERL
294     MTH void set_darkness_map ();
295     MTH int estimate_difficulty () const;
296    
297 root 1.46 // set the given flag on all objects in the map
298     MTH void set_object_flag (int flag, int value = 1);
299    
300 root 1.40 MTH void link_multipart_objects ();
301     MTH void clear_unique_items ();
302    
303     MTH void clear_header ();
304     MTH void clear_links_to (maptile *m);
305    
306 root 1.60 MTH struct region *region (int x, int y) const;
307 root 1.59
308 root 1.40 // loas the header pseudo-object
309 root 1.51 bool _load_header (object_thawer &thawer);
310     MTH bool _load_header (const char *path);
311 root 1.40
312     // load objects into the map
313 root 1.51 bool _load_objects (object_thawer &thawer);
314     MTH bool _load_objects (const char *path, bool skip_header = true);
315 root 1.40
316     // save objects into the given file (uses IO_ flags)
317 root 1.51 bool _save_objects (object_freezer &freezer, int flags);
318     MTH bool _save_objects (const char *path, int flags);
319 root 1.40
320     // save the header pseudo object _only_
321 root 1.51 bool _save_header (object_freezer &freezer);
322     MTH bool _save_header (const char *path);
323 root 1.23
324     maptile ();
325 root 1.40 maptile (int w, int h);
326 root 1.32 ~maptile ();
327 root 1.40
328 root 1.32 void do_destroy ();
329     void gather_callbacks (AV *&callbacks, event_type event) const;
330    
331 root 1.36 MTH int size () const { return width * height; }
332 root 1.29
333 root 1.36 MTH object *insert (object *op, int x, int y, object *originator = 0, int flags = 0);
334 root 1.34
335 root 1.46 MTH void touch () { last_access = runtime; }
336    
337 root 1.47 // find the map that is at coordinate x|y relative to this map
338     // TODO: need a better way than passing by reference
339     // TODO: make perl interface
340     maptile *xy_find (sint16 &x, sint16 &y);
341    
342     // like xy_find, but also loads the map
343     maptile *xy_load (sint16 &x, sint16 &y);
344    
345     void do_load_sync ();//PERL
346    
347     // make sure the map is loaded
348     MTH void load_sync ()
349     {
350     if (!spaces)
351     do_load_sync ();
352     }
353 root 1.40
354 root 1.51 void make_map_floor (char **layout, char *floorstyle, random_map_params *RP);
355     bool generate_random_map (random_map_params *RP);
356    
357 root 1.47 static maptile *find_sync (const char *path, maptile *original = 0);//PERL
358 root 1.50 // async prefetch
359     static maptile *find_async (const char *path, maptile *original = 0);//PERL
360 root 1.39
361 root 1.37 mapspace const &at (uint32 x, uint32 y) const { return spaces [x * height + y]; }
362     mapspace &at (uint32 x, uint32 y) { return spaces [x * height + y]; }
363 elmex 1.6 };
364 root 1.1
365     /* This is used by get_rangevector to determine where the other
366     * creature is. get_rangevector takes into account map tiling,
367     * so you just can not look the the map coordinates and get the
368     * righte value. distance_x/y are distance away, which
369 root 1.29 * can be negative. direction is the crossfire direction scheme
370 root 1.1 * that the creature should head. part is the part of the
371     * monster that is closest.
372     * Note: distance should be always >=0. I changed it to UINT. MT
373     */
374 root 1.20 struct rv_vector
375     {
376     unsigned int distance;
377     int distance_x;
378     int distance_y;
379     int direction;
380     object *part;
381 elmex 1.6 };
382 root 1.1
383 root 1.52 //TODO: these should be refactored into things like xy_normalise
384     // and so on.
385 root 1.63 int get_map_flags (maptile *oldmap, maptile **newmap, sint16 x, sint16 y, sint16 *nx, sint16 *ny);
386     int ob_blocked (const object *ob, maptile *m, sint16 x, sint16 y);
387     int out_of_map (maptile *m, int x, int y);
388     maptile *get_map_from_coord (maptile *m, sint16 *x, sint16 *y);
389     void get_rangevector (object *op1, object *op2, rv_vector *retval, int flags);
390     void get_rangevector_from_mapcoord (const maptile *m, int x, int y, const object *op2, rv_vector *retval, int flags);
391     int on_same_map (const object *op1, const object *op2);
392     int adjacent_map (const maptile *map1, const maptile *map2, int *dx, int *dy);
393 root 1.52
394     // adjust map, x and y for tiled maps and return true if the position is valid at all
395     inline bool
396     xy_normalise (maptile *&map, sint16 &x, sint16 &y)
397     {
398     // when in range, do a quick return, otherwise go the slow route
399     return
400     (IN_RANGE_EXC (x, 0, map->width) && IN_RANGE_EXC (y, 0, map->height))
401     || !(get_map_flags (map, &map, x, y, &x, &y) & P_OUT_OF_MAP);
402     }
403    
404 root 1.31 inline mapspace &
405     object::ms () const
406     {
407     return map->at (x, y);
408     }
409    
410 root 1.1 #endif
411 root 1.22