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

Comparing deliantra/server/common/map.C (file contents):
Revision 1.54 by root, Wed Dec 27 13:13:46 2006 UTC vs.
Revision 1.175 by root, Tue Nov 10 05:06:02 2009 UTC

1/* 1/*
2 CrossFire, A Multiplayer game for X-windows 2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 3 *
4 * Copyright (©) 2005,2006,2007,2008,2009 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
4 Copyright (C) 2001-2003 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2001-2003,2007 Mark Wedel & Crossfire Development Team
5 Copyright (C) 1992 Frank Tore Johansen 6 * Copyright (©) 1992,2007 Frank Tore Johansen
6 7 *
7 This program is free software; you can redistribute it and/or modify 8 * Deliantra is free software: you can redistribute it and/or modify it under
8 it under the terms of the GNU General Public License as published by 9 * the terms of the Affero GNU General Public License as published by the
9 the Free Software Foundation; either version 2 of the License, or 10 * Free Software Foundation, either version 3 of the License, or (at your
10 (at your option) any later version. 11 * option) any later version.
11 12 *
12 This program is distributed in the hope that it will be useful, 13 * This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details. 16 * GNU General Public License for more details.
16 17 *
17 You should have received a copy of the GNU General Public License 18 * You should have received a copy of the Affero GNU General Public License
18 along with this program; if not, write to the Free Software 19 * and the GNU General Public License along with this program. If not, see
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 * <http://www.gnu.org/licenses/>.
20 21 *
21 The authors can be reached via e-mail at <crossfire@schmorp.de> 22 * The authors can be reached via e-mail to <support@deliantra.net>
22*/ 23 */
23 24
24#include <global.h>
25#include <funcpoint.h>
26
27#include <loader.h>
28#include <unistd.h> 25#include <unistd.h>
29 26
27#include "global.h"
28#include "loader.h"
30#include "path.h" 29#include "path.h"
31 30
32/* 31//+GPL
33 * Returns the maptile which has a name matching the given argument.
34 * return NULL if no match is found.
35 */
36maptile *
37has_been_loaded (const char *name)
38{
39 if (!name || !*name)
40 return 0;
41 32
42 for_all_maps (map) 33sint8 maptile::outdoor_darkness;
43 if (!strcmp (name, map->path))
44 return map;
45
46 return 0;
47}
48
49/*
50 * This makes a path absolute outside the world of Crossfire.
51 * In other words, it prepends LIBDIR/MAPDIR/ to the given path
52 * and returns the pointer to a static array containing the result.
53 * it really should be called create_mapname
54 */
55
56const char *
57create_pathname (const char *name)
58{
59 static char buf[MAX_BUF];
60
61 /* Why? having extra / doesn't confuse unix anyplace? Dependancies
62 * someplace else in the code? msw 2-17-97
63 */
64 if (*name == '/')
65 sprintf (buf, "%s/%s%s", settings.datadir, settings.mapdir, name);
66 else
67 sprintf (buf, "%s/%s/%s", settings.datadir, settings.mapdir, name);
68 return (buf);
69}
70
71/*
72 * same as create_pathname, but for the overlay maps.
73 */
74
75const char *
76create_overlay_pathname (const char *name)
77{
78 static char buf[MAX_BUF];
79
80 /* Why? having extra / doesn't confuse unix anyplace? Dependancies
81 * someplace else in the code? msw 2-17-97
82 */
83 if (*name == '/')
84 sprintf (buf, "%s/%s%s", settings.localdir, settings.mapdir, name);
85 else
86 sprintf (buf, "%s/%s/%s", settings.localdir, settings.mapdir, name);
87 return (buf);
88}
89
90/*
91 * same as create_pathname, but for the template maps.
92 */
93
94const char *
95create_template_pathname (const char *name)
96{
97 static char buf[MAX_BUF];
98
99 /* Why? having extra / doesn't confuse unix anyplace? Dependancies
100 * someplace else in the code? msw 2-17-97
101 */
102 if (*name == '/')
103 sprintf (buf, "%s/%s%s", settings.localdir, settings.templatedir, name);
104 else
105 sprintf (buf, "%s/%s/%s", settings.localdir, settings.templatedir, name);
106 return (buf);
107}
108
109/*
110 * This makes absolute path to the itemfile where unique objects
111 * will be saved. Converts '/' to '@'. I think it's essier maintain
112 * files than full directory structure, but if this is problem it can
113 * be changed.
114 */
115static const char *
116create_items_path (const char *s)
117{
118 static char buf[MAX_BUF];
119 char *t;
120
121 if (*s == '/')
122 s++;
123
124 sprintf (buf, "%s/%s/", settings.localdir, settings.uniquedir);
125
126 for (t = buf + strlen (buf); *s; s++, t++)
127 if (*s == '/')
128 *t = '@';
129 else
130 *t = *s;
131 *t = 0;
132 return (buf);
133}
134
135
136/*
137 * This function checks if a file with the given path exists.
138 * -1 is returned if it fails, otherwise the mode of the file
139 * is returned.
140 * It tries out all the compression suffixes listed in the uncomp[] array.
141 *
142 * If prepend_dir is set, then we call create_pathname (which prepends
143 * libdir & mapdir). Otherwise, we assume the name given is fully
144 * complete.
145 * Only the editor actually cares about the writablity of this -
146 * the rest of the code only cares that the file is readable.
147 * when the editor goes away, the call to stat should probably be
148 * replaced by an access instead (similar to the windows one, but
149 * that seems to be missing the prepend_dir processing
150 */
151
152int
153check_path (const char *name, int prepend_dir)
154{
155 char buf[MAX_BUF];
156
157 char *endbuf;
158 struct stat statbuf;
159 int mode = 0;
160
161 if (prepend_dir)
162 strcpy (buf, create_pathname (name));
163 else
164 strcpy (buf, name);
165
166 /* old method (strchr(buf, '\0')) seemd very odd to me -
167 * this method should be equivalant and is clearer.
168 * Can not use strcat because we need to cycle through
169 * all the names.
170 */
171 endbuf = buf + strlen (buf);
172
173 if (stat (buf, &statbuf))
174 return -1;
175 if (!S_ISREG (statbuf.st_mode))
176 return (-1);
177
178 if (((statbuf.st_mode & S_IRGRP) && getegid () == statbuf.st_gid) ||
179 ((statbuf.st_mode & S_IRUSR) && geteuid () == statbuf.st_uid) || (statbuf.st_mode & S_IROTH))
180 mode |= 4;
181
182 if ((statbuf.st_mode & S_IWGRP && getegid () == statbuf.st_gid) ||
183 (statbuf.st_mode & S_IWUSR && geteuid () == statbuf.st_uid) || (statbuf.st_mode & S_IWOTH))
184 mode |= 2;
185
186 return (mode);
187}
188
189/*
190 * Prints out debug-information about a map.
191 * Dumping these at llevError doesn't seem right, but is
192 * necessary to make sure the information is in fact logged.
193 */
194
195void
196dump_map (const maptile *m)
197{
198 LOG (llevError, "Map %s status: %d.\n", m->path, m->in_memory);
199 LOG (llevError, "Size: %dx%d Start: %d,%d\n", m->width, m->height, m->enter_x, m->enter_y);
200
201 if (m->msg != NULL)
202 LOG (llevError, "Message:\n%s", m->msg);
203
204 if (m->maplore != NULL)
205 LOG (llevError, "Lore:\n%s", m->maplore);
206
207 if (m->tmpname != NULL)
208 LOG (llevError, "Tmpname: %s\n", m->tmpname);
209
210 LOG (llevError, "Difficulty: %d\n", m->difficulty);
211 LOG (llevError, "Darkness: %d\n", m->darkness);
212}
213
214/*
215 * Prints out debug-information about all maps.
216 * This basically just goes through all the maps and calls
217 * dump_map on each one.
218 */
219
220void
221dump_all_maps (void)
222{
223 for_all_maps (m)
224 dump_map (m);
225}
226 34
227/* This rolls up wall, blocks_magic, blocks_view, etc, all into 35/* This rolls up wall, blocks_magic, blocks_view, etc, all into
228 * one function that just returns a P_.. value (see map.h) 36 * one function that just returns a P_.. value (see map.h)
229 * it will also do map translation for tiled maps, returning 37 * it will also do map translation for tiled maps, returning
230 * new values into newmap, nx, and ny. Any and all of those 38 * new values into newmap, nx, and ny. Any and all of those
… …
235 * don't expect to insert/remove anything from those spaces. 43 * don't expect to insert/remove anything from those spaces.
236 */ 44 */
237int 45int
238get_map_flags (maptile *oldmap, maptile **newmap, sint16 x, sint16 y, sint16 *nx, sint16 *ny) 46get_map_flags (maptile *oldmap, maptile **newmap, sint16 x, sint16 y, sint16 *nx, sint16 *ny)
239{ 47{
240 sint16 newx, newy;
241 int retval = 0;
242 maptile *mp;
243
244 newx = x; 48 sint16 newx = x;
245 newy = y; 49 sint16 newy = y;
246 50
247 mp = get_map_from_coord (oldmap, &newx, &newy); 51 maptile *mp = get_map_from_coord (oldmap, &newx, &newy);
248 52
249 if (!mp) 53 if (!mp)
250 return P_OUT_OF_MAP; 54 return P_OUT_OF_MAP;
251
252 if (mp != oldmap)
253 retval |= P_NEW_MAP;
254 55
255 if (newmap) *newmap = mp; 56 if (newmap) *newmap = mp;
256 if (nx) *nx = newx; 57 if (nx) *nx = newx;
257 if (ny) *ny = newy; 58 if (ny) *ny = newy;
258 59
259 return retval | mp->at (newx, newy).flags (); 60 return mp->at (newx, newy).flags () | (mp != oldmap ? P_NEW_MAP : 0);
260} 61}
261 62
262/* 63/*
263 * Returns true if the given coordinate is blocked except by the 64 * Returns true if the given coordinate is blocked except by the
264 * object passed is not blocking. This is used with 65 * object passed is not blocking. This is used with
… …
272 * by the caller. 73 * by the caller.
273 */ 74 */
274int 75int
275blocked_link (object *ob, maptile *m, int sx, int sy) 76blocked_link (object *ob, maptile *m, int sx, int sy)
276{ 77{
277 object *tmp;
278 int mflags, blocked;
279
280 /* Make sure the coordinates are valid - they should be, as caller should 78 /* Make sure the coordinates are valid - they should be, as caller should
281 * have already checked this. 79 * have already checked this.
282 */ 80 */
283 if (OUT_OF_REAL_MAP (m, sx, sy)) 81 if (OUT_OF_REAL_MAP (m, sx, sy))
284 { 82 {
285 LOG (llevError, "blocked_link: Passed map, x, y coordinates outside of map\n"); 83 LOG (llevError, "blocked_link: Passed map, x, y coordinates outside of map\n");
286 return 1; 84 return 1;
287 } 85 }
288 86
289 /* Save some cycles - instead of calling get_map_flags(), just get the value 87 mapspace &ms = m->at (sx, sy);
290 * directly.
291 */
292 mflags = m->at (sx, sy).flags ();
293 88
294 blocked = GET_MAP_MOVE_BLOCK (m, sx, sy); 89 int mflags = ms.flags ();
90 int blocked = ms.move_block;
295 91
296 /* If space is currently not blocked by anything, no need to 92 /* If space is currently not blocked by anything, no need to
297 * go further. Not true for players - all sorts of special 93 * go further. Not true for players - all sorts of special
298 * things we need to do for players. 94 * things we need to do for players.
299 */ 95 */
300 if (ob->type != PLAYER && !(mflags & P_IS_ALIVE) && (blocked == 0)) 96 if (ob->type != PLAYER && !(mflags & P_IS_ALIVE) && (blocked == 0))
301 return 0; 97 return 0;
302 98
303 /* if there isn't anytyhing alive on this space, and this space isn't 99 /* if there isn't anything alive on this space, and this space isn't
304 * otherwise blocked, we can return now. Only if there is a living 100 * otherwise blocked, we can return now. Only if there is a living
305 * creature do we need to investigate if it is part of this creature 101 * creature do we need to investigate if it is part of this creature
306 * or another. Likewise, only if something is blocking us do we 102 * or another. Likewise, only if something is blocking us do we
307 * need to investigate if there is a special circumstance that would 103 * need to investigate if there is a special circumstance that would
308 * let the player through (inventory checkers for example) 104 * let the player through (inventory checkers for example)
309 */ 105 */
310 if (!(mflags & P_IS_ALIVE) && !OB_TYPE_MOVE_BLOCK (ob, blocked)) 106 if (!(mflags & P_IS_ALIVE) && !OB_TYPE_MOVE_BLOCK (ob, blocked))
311 return 0; 107 return 0;
312 108
313 if (ob->head != NULL)
314 ob = ob->head; 109 ob = ob->head_ ();
315 110
316 /* We basically go through the stack of objects, and if there is 111 /* We basically go through the stack of objects, and if there is
317 * some other object that has NO_PASS or FLAG_ALIVE set, return 112 * some other object that has NO_PASS or FLAG_ALIVE set, return
318 * true. If we get through the entire stack, that must mean 113 * true. If we get through the entire stack, that must mean
319 * ob is blocking it, so return 0. 114 * ob is blocking it, so return 0.
320 */ 115 */
321 for (tmp = GET_MAP_OB (m, sx, sy); tmp; tmp = tmp->above) 116 for (object *tmp = ms.bot; tmp; tmp = tmp->above)
322 { 117 {
323 118 if (OB_MOVE_BLOCK (ob, tmp))
324 /* This must be before the checks below. Code for inventory checkers. */
325 if (tmp->type == CHECK_INV && OB_MOVE_BLOCK (ob, tmp))
326 { 119 {
327 /* If last_sp is set, the player/monster needs an object, 120 if (INVOKE_OBJECT (BLOCKED_MOVE, tmp, ob))
328 * so we check for it. If they don't have it, they can't 121 if (RESULT_INT (0))
329 * pass through this space. 122 return 1;
330 */ 123 else
331 if (tmp->last_sp) 124 continue;
125
126 if (tmp->type == CHECK_INV)
332 { 127 {
333 if (check_inv_recursive (ob, tmp) == NULL) 128 bool have = check_inv_recursive (ob, tmp);
129
130 // last_sp set means we block if we don't have.
131 if (logical_xor (have, tmp->last_sp))
334 return 1; 132 return 1;
335 else 133 }
336 continue; 134 else if (tmp->type == T_MATCH)
135 {
136 // T_MATCH allows "entrance" iff the match is true
137 // == blocks if the match fails
138
139 // we could have used an INVOKE_OBJECT, but decided against it, as we
140 // assume that T_MATCH is relatively common.
141 if (!match (tmp->slaying, ob, tmp, ob))
142 return 1;
337 } 143 }
338 else 144 else
339 { 145 return 1; // unconditional block
340 /* In this case, the player must not have the object - 146
341 * if they do, they can't pass through.
342 */
343 if (check_inv_recursive (ob, tmp) != NULL) /* player has object */
344 return 1;
345 else
346 continue;
347 }
348 } /* if check_inv */
349 else 147 } else {
350 { 148 // space does not block the ob, directly, but
351 /* Broke apart a big nasty if into several here to make 149 // anything alive that is not a door still
352 * this more readable. first check - if the space blocks 150 // blocks anything but wizards.
353 * movement, can't move here. 151
354 * second - if a monster, can't move there, unles it is a 152 if (tmp->flag [FLAG_ALIVE]
355 * hidden dm 153 && tmp->head_ () != ob
356 */ 154 && tmp != ob
357 if (OB_MOVE_BLOCK (ob, tmp)) 155 && tmp->type != DOOR
358 return 1; 156 && !tmp->flag [FLAG_WIZPASS])
359 if (QUERY_FLAG (tmp, FLAG_ALIVE) && tmp->head != ob && tmp != ob &&
360 tmp->type != DOOR && !(QUERY_FLAG (tmp, FLAG_WIZ) && tmp->contr->hidden))
361 return 1; 157 return 1;
362 } 158 }
363
364 } 159 }
160
365 return 0; 161 return 0;
366} 162}
367 163
368
369/* 164/*
370 * Returns true if the given object can't fit in the given spot. 165 * Returns qthe blocking object if the given object can't fit in the given
371 * This is meant for multi space objects - for single space objecs, 166 * spot. This is meant for multi space objects - for single space objecs,
372 * just calling get_map_blocked and checking that against movement type 167 * just calling get_map_blocked and checking that against movement type
373 * of object. This function goes through all the parts of the 168 * of object. This function goes through all the parts of the multipart
374 * multipart object and makes sure they can be inserted. 169 * object and makes sure they can be inserted.
375 * 170 *
376 * While this doesn't call out of map, the get_map_flags does. 171 * While this doesn't call out of map, the get_map_flags does.
377 * 172 *
378 * This function has been used to deprecate arch_out_of_map - 173 * This function has been used to deprecate arch_out_of_map -
379 * this function also does that check, and since in most cases, 174 * this function also does that check, and since in most cases,
… …
390 * 185 *
391 * Note this used to be arch_blocked, but with new movement 186 * Note this used to be arch_blocked, but with new movement
392 * code, we need to have actual object to check its move_type 187 * code, we need to have actual object to check its move_type
393 * against the move_block values. 188 * against the move_block values.
394 */ 189 */
395int 190bool
396ob_blocked (const object *ob, maptile *m, sint16 x, sint16 y) 191object::blocked (maptile *m, int x, int y) const
397{ 192{
398 archetype *tmp; 193 for (archetype *tmp = arch; tmp; tmp = (archetype *)tmp->more)
399 int flag;
400 maptile *m1;
401 sint16 sx, sy;
402
403 if (ob == NULL)
404 {
405 flag = get_map_flags (m, &m1, x, y, &sx, &sy);
406 if (flag & P_OUT_OF_MAP)
407 return P_OUT_OF_MAP;
408
409 /* don't have object, so don't know what types would block */
410 return m1->at (sx, sy).move_block;
411 } 194 {
195 mapxy pos (m, x + tmp->x, y + tmp->y);
412 196
413 for (tmp = ob->arch; tmp; tmp = tmp->more) 197 if (!pos.normalise ())
414 { 198 return 1;
415 flag = get_map_flags (m, &m1, x + tmp->clone.x, y + tmp->clone.y, &sx, &sy);
416 199
417 if (flag & P_OUT_OF_MAP) 200 mapspace &ms = *pos;
418 return P_OUT_OF_MAP; 201
419 if (flag & P_IS_ALIVE) 202 if (ms.flags () & P_IS_ALIVE)
420 return P_IS_ALIVE; 203 return 1;
421 204
422 mapspace &ms = m1->at (sx, sy); 205 /* However, often ob doesn't have any move type
423 206 * (signifying non-moving objects)
424
425 /* find_first_free_spot() calls this function. However, often
426 * ob doesn't have any move type (when used to place exits)
427 * so the AND operation in OB_TYPE_MOVE_BLOCK doesn't work. 207 * so the AND operation in OB_TYPE_MOVE_BLOCK doesn't work.
428 */ 208 */
429
430 if (ob->move_type == 0 && ms.move_block != MOVE_ALL) 209 if (!move_type && ms.move_block != MOVE_ALL)
431 continue; 210 continue;
432 211
433 /* Note it is intentional that we check ob - the movement type of the 212 /* Note it is intentional that we check ob - the movement type of the
434 * head of the object should correspond for the entire object. 213 * head of the object should correspond for the entire object.
435 */ 214 */
436 if (OB_TYPE_MOVE_BLOCK (ob, ms.move_block)) 215 if (ms.blocks (move_type))
437 return P_NO_PASS; 216 return 1;
438 } 217 }
439 218
440 return 0; 219 return 0;
441} 220}
442 221
443/* When the map is loaded, load_object does not actually insert objects 222//-GPL
444 * into inventory, but just links them. What this does is go through
445 * and insert them properly.
446 * The object 'container' is the object that contains the inventory.
447 * This is needed so that we can update the containers weight.
448 */
449 223
450void 224void
451fix_container (object *container) 225maptile::set_object_flag (int flag, int value)
452{ 226{
453 object *tmp = container->inv, *next; 227 if (!spaces)
228 return;
454 229
455 container->inv = NULL; 230 for (mapspace *ms = spaces + size (); ms-- > spaces; )
456 while (tmp != NULL) 231 for (object *tmp = ms->bot; tmp; tmp = tmp->above)
457 { 232 tmp->flag [flag] = value;
458 next = tmp->below;
459 if (tmp->inv)
460 fix_container (tmp);
461 (void) insert_ob_in_ob (tmp, container);
462 tmp = next;
463 }
464 /* sum_weight will go through and calculate what all the containers are
465 * carrying.
466 */
467 sum_weight (container);
468} 233}
234
235void
236maptile::post_load_original ()
237{
238 if (!spaces)
239 return;
240
241 set_object_flag (FLAG_OBJ_ORIGINAL);
242
243 for (mapspace *ms = spaces + size (); ms-- > spaces; )
244 for (object *tmp = ms->bot; tmp; tmp = tmp->above)
245 INVOKE_OBJECT (RESET, tmp);
246}
247
248//+GPL
469 249
470/* link_multipart_objects go through all the objects on the map looking 250/* link_multipart_objects go through all the objects on the map looking
471 * for objects whose arch says they are multipart yet according to the 251 * for objects whose arch says they are multipart yet according to the
472 * info we have, they only have the head (as would be expected when 252 * info we have, they only have the head (as would be expected when
473 * they are saved). We do have to look for the old maps that did save 253 * they are saved).
474 * the more sections and not re-add sections for them.
475 */ 254 */
476static void 255void
477link_multipart_objects (maptile *m) 256maptile::link_multipart_objects ()
478{ 257{
479 int x, y; 258 if (!spaces)
480 object *tmp, *op, *last, *above; 259 return;
481 archetype *at;
482 260
483 for (x = 0; x < m->width; x++) 261 for (mapspace *ms = spaces + size (); ms-- > spaces; )
484 for (y = 0; y < m->height; y++) 262 {
485 for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = above) 263 object *op = ms->bot;
264 while (op)
486 { 265 {
487 above = tmp->above;
488
489 /* already multipart - don't do anything more */ 266 /* already multipart - don't do anything more */
490 if (tmp->head || tmp->more) 267 if (op->head_ () == op && !op->more && op->arch->more)
491 continue;
492
493 /* If there is nothing more to this object, this for loop
494 * won't do anything.
495 */
496 for (at = tmp->arch->more, last = tmp; at != NULL; at = at->more, last = op)
497 { 268 {
498 op = arch_to_object (at); 269 op->remove ();
270 op->expand_tail ();
499 271
500 /* update x,y coordinates */ 272 // FIXME: INS_ON_TOP is just a workaround for the pentagram vs.
501 op->x += tmp->x; 273 // multi-tile monster bug, where INS_ABOVE_FLOOR_ONLY put the monsters
502 op->y += tmp->y; 274 // below the pentagrams... hopefully INS_ON_TOP doesn't break anything
503 op->head = tmp; 275 insert (op, op->x, op->y, 0, INS_NO_MERGE | INS_ON_TOP | INS_NO_WALK_ON);
504 op->map = m; 276
505 last->more = op; 277 op = ms->bot; // we are mutating the mapspace too much with INS_ON_TOP
506 op->name = tmp->name; 278 // so we have to reset the iteration through the mapspace
507 op->title = tmp->title;
508 /* we could link all the parts onto tmp, and then just
509 * call insert_ob_in_map once, but the effect is the same,
510 * as insert_ob_in_map will call itself with each part, and
511 * the coding is simpler to just to it here with each part.
512 */ 279 }
513 insert_ob_in_map (op, op->map, tmp, INS_NO_MERGE | INS_ABOVE_FLOOR_ONLY | INS_NO_WALK_ON); 280 else
514 } /* for at = tmp->arch->more */ 281 op = op->above;
515 } /* for objects on this space */ 282 }
283 }
516} 284}
285
286//-GPL
517 287
518/* 288/*
519 * Loads (ands parses) the objects into a given map from the specified 289 * Loads (ands parses) the objects into a given map from the specified
520 * file pointer. 290 * file pointer.
521 * mapflags is the same as we get with load_original_map
522 */ 291 */
523void 292bool
524load_objects (maptile *m, object_thawer & fp, int mapflags) 293maptile::_load_objects (object_thawer &f)
525{ 294{
526 int i, j; 295 for (;;)
527 int unique;
528 object *op, *prev = NULL, *last_more = NULL, *otmp;
529
530 op = object::create ();
531 op->map = m; /* To handle buttons correctly */
532
533 while ((i = load_object (fp, op, mapflags)))
534 { 296 {
535 /* if the archetype for the object is null, means that we 297 coroapi::cede_to_tick (); // cede once in a while
536 * got an invalid object. Don't do anything with it - the game 298
537 * or editor will not be able to do anything with it either. 299 switch (f.kw)
538 */
539 if (op->arch == NULL)
540 { 300 {
541 LOG (llevDebug, "Discarding object without arch: %s\n", op->name ? (const char *) op->name : "(null)"); 301 case KW_arch:
302 if (object *op = object::read (f, this))
303 {
304 // TODO: why?
305 if (op->inv)
306 op->update_weight ();
307
308 if (IN_RANGE_EXC (op->x, 0, width) && IN_RANGE_EXC (op->y, 0, height))
309 {
310 // we insert manually because
311 // a) its way faster
312 // b) we remove manually, too, and there are good reasons for that
313 // c) it's correct
314 mapspace &ms = at (op->x, op->y);
315
316 op->flag [FLAG_REMOVED] = false;
317
318 op->above = 0;
319 op->below = ms.top;
320
321 *(ms.top ? &ms.top->above : &ms.bot) = op;
322
323 ms.top = op;
324 ms.flags_ = 0;
325 }
326 else
327 {
328 f.parse_warn (format ("object %s out of range", op->debug_desc ()));
329 op->destroy ();
330 }
331 }
332
542 continue; 333 continue;
543 }
544 334
545 switch (i)
546 {
547 case LL_NORMAL:
548 /* if we are loading an overlay, put the floors on the bottom */
549 if ((QUERY_FLAG (op, FLAG_IS_FLOOR) || QUERY_FLAG (op, FLAG_OVERLAY_FLOOR)) && mapflags & MAP_OVERLAY)
550 insert_ob_in_map (op, m, op, INS_NO_MERGE | INS_NO_WALK_ON | INS_ABOVE_FLOOR_ONLY | INS_MAP_LOAD);
551 else
552 insert_ob_in_map (op, m, op, INS_NO_MERGE | INS_NO_WALK_ON | INS_ON_TOP | INS_MAP_LOAD);
553
554 if (op->inv)
555 sum_weight (op);
556
557 prev = op, last_more = op;
558 break;
559
560 case LL_MORE: 335 case KW_EOF:
561 insert_ob_in_map (op, m, op, INS_NO_MERGE | INS_NO_WALK_ON | INS_ABOVE_FLOOR_ONLY); 336 return true;
562 op->head = prev, last_more->more = op, last_more = op; 337
338 default:
339 if (!f.parse_error ("map file"))
340 return false;
563 break; 341 break;
564 } 342 }
565 343
566 if (mapflags & MAP_STYLE) 344 f.next ();
567 remove_from_active_list (op);
568
569 op = object::create ();
570 op->map = m;
571 }
572
573 for (i = 0; i < m->width; i++)
574 { 345 }
575 for (j = 0; j < m->height; j++) 346
347 return true;
348}
349
350void
351maptile::activate ()
352{
353 if (spaces)
354 for (mapspace *ms = spaces + size (); ms-- > spaces; )
355 for (object *op = ms->bot; op; op = op->above)
356 op->activate_recursive ();
357}
358
359void
360maptile::deactivate ()
361{
362 if (spaces)
363 for (mapspace *ms = spaces + size (); ms-- > spaces; )
364 for (object *op = ms->bot; op; op = op->above)
365 op->deactivate_recursive ();
366}
367
368bool
369maptile::_save_objects (object_freezer &f, int flags)
370{
371 coroapi::cede_to_tick ();
372
373 if (flags & IO_HEADER)
374 _save_header (f);
375
376 if (!spaces)
377 return false;
378
379 for (int i = 0; i < size (); ++i)
380 {
381 bool unique = 0;
382
383 for (object *op = spaces [i].bot; op; op = op->above)
576 { 384 {
577 unique = 0; 385 unique |= op->flag [FLAG_UNIQUE] && op->flag [FLAG_IS_FLOOR];
578 /* check for unique items, or unique squares */ 386
579 for (otmp = GET_MAP_OB (m, i, j); otmp; otmp = otmp->above) 387 if (expect_false (!op->can_map_save ()))
388 continue;
389
390 if (expect_false (unique || op->flag [FLAG_UNIQUE]))
580 { 391 {
581 if (QUERY_FLAG (otmp, FLAG_UNIQUE) || QUERY_FLAG (otmp, FLAG_OBJ_SAVE_ON_OVL)) 392 if (flags & IO_UNIQUES)
582 unique = 1; 393 op->write (f);
583
584 if (!(mapflags & (MAP_OVERLAY | MAP_PLAYER_UNIQUE) || unique))
585 SET_FLAG (otmp, FLAG_OBJ_ORIGINAL);
586 } 394 }
395 else if (expect_true (flags & IO_OBJECTS))
396 op->write (f);
587 } 397 }
588 } 398 }
589 399
590 op->destroy (); 400 coroapi::cede_to_tick ();
591 link_multipart_objects (m);
592}
593 401
594/* This saves all the objects on the map in a non destructive fashion. 402 return true;
595 * Modified by MSW 2001-07-01 to do in a single pass - reduces code, 403}
596 * and we only save the head of multi part objects - this is needed
597 * in order to do map tiling properly.
598 */
599void
600save_objects (maptile *m, object_freezer &fp, object_freezer &fp2, int flag)
601{
602 int i, j = 0, unique = 0;
603 object *op;
604 404
605 /* first pass - save one-part objects */ 405bool
606 for (i = 0; i < m->width; i++) 406maptile::_save_objects (const char *path, int flags)
607 for (j = 0; j < m->height; j++) 407{
608 { 408 object_freezer freezer;
609 unique = 0;
610 409
611 for (op = m->at (i, j).bot; op; op = op->above) 410 if (!_save_objects (freezer, flags))
612 { 411 return false;
613 if (op->flag [FLAG_UNIQUE] && op->flag [FLAG_IS_FLOOR])
614 unique = 1;
615 412
616 if (!op->can_map_save ()) 413 return freezer.save (path);
617 continue;
618
619 if (unique || op->flag [FLAG_UNIQUE])
620 save_object (fp2, op, 1);
621 else if (flag == 0 || (flag == 2 && (!op->flag [FLAG_OBJ_ORIGINAL] && !op->flag [FLAG_UNPAID])))
622 save_object (fp, op, 1);
623 }
624 }
625} 414}
626 415
627maptile::maptile () 416maptile::maptile ()
628{ 417{
629 in_memory = MAP_SWAPPED; 418 in_memory = MAP_SWAPPED;
630 419
631 /* The maps used to pick up default x and y values from the 420 /* The maps used to pick up default x and y values from the
632 * map archetype. Mimic that behaviour. 421 * map archetype. Mimic that behaviour.
633 */ 422 */
423 width = 16;
424 height = 16;
425 timeout = 300;
426 max_items = MAX_ITEM_PER_ACTION;
427 max_volume = 2000000; // 2m³
428}
429
430maptile::maptile (int w, int h)
431{
432 in_memory = MAP_SWAPPED;
433
634 width = 16; 434 width = w;
635 height = 16; 435 height = h;
636 reset_timeout = 0; 436 reset_timeout = 0;
637 timeout = 300; 437 timeout = 300;
638 enter_x = 0; 438 enter_x = 0;
639 enter_y = 0; 439 enter_y = 0;
640 /*set part to -1 indicating conversion to weather map not yet done */
641 worldpartx = -1;
642 worldparty = -1;
643}
644 440
645void 441 alloc ();
646maptile::link ()
647{
648 next = first_map;
649 first_map = this;
650}
651
652void
653maptile::unlink ()
654{
655 if (first_map == this)
656 first_map = next;
657 else
658 for_all_maps (m)
659 if (m->next = this)
660 {
661 m->next = next;
662 break;
663 }
664}
665
666/*
667 * Allocates, initialises, and returns a pointer to a maptile.
668 * Modified to no longer take a path option which was not being
669 * used anyways. MSW 2001-07-01
670 */
671maptile *
672get_linked_map (void)
673{
674 maptile *map = new maptile;
675 map->link ();
676 return map;
677} 442}
678 443
679/* 444/*
680 * Allocates the arrays contained in a maptile. 445 * Allocates the arrays contained in a maptile.
681 * This basically allocates the dynamic array of spaces for the 446 * This basically allocates the dynamic array of spaces for the
682 * map. 447 * map.
683 */ 448 */
684void 449void
685maptile::allocate () 450maptile::alloc ()
686{ 451{
687 in_memory = MAP_IN_MEMORY;
688
689 /* Log this condition and free the storage. We could I suppose
690 * realloc, but if the caller is presuming the data will be intact,
691 * that is their poor assumption.
692 */
693 if (spaces) 452 if (spaces)
694 { 453 return;
695 LOG (llevError, "allocate_map called with already allocated map (%s)\n", path);
696 sfree (spaces, size ());
697 }
698 454
699 spaces = salloc0<mapspace> (size ()); 455 spaces = salloc0<mapspace> (size ());
700} 456}
701 457
702/* Create and returns a map of the specific size. Used 458//+GPL
703 * in random map code and the editor.
704 */
705maptile *
706get_empty_map (int sizex, int sizey)
707{
708 maptile *m = get_linked_map ();
709
710 m->width = sizex;
711 m->height = sizey;
712 m->in_memory = MAP_SWAPPED;
713 m->allocate ();
714
715 return m;
716}
717 459
718/* Takes a string from a map definition and outputs a pointer to the array of shopitems 460/* Takes a string from a map definition and outputs a pointer to the array of shopitems
719 * corresponding to that string. Memory is allocated for this, it must be freed 461 * corresponding to that string. Memory is allocated for this, it must be freed
720 * at a later date. 462 * at a later date.
721 * Called by parse_map_headers below. 463 * Called by parse_map_headers below.
722 */ 464 */
723
724static shopitems * 465static shopitems *
725parse_shop_string (const char *input_string) 466parse_shop_string (const char *input_string)
726{ 467{
727 char *shop_string, *p, *q, *next_semicolon, *next_colon; 468 char *shop_string, *p, *q, *next_semicolon, *next_colon;
728 shopitems *items = NULL; 469 shopitems *items = NULL;
… …
799 return items; 540 return items;
800} 541}
801 542
802/* opposite of parse string, this puts the string that was originally fed in to 543/* opposite of parse string, this puts the string that was originally fed in to
803 * the map (or something equivilent) into output_string. */ 544 * the map (or something equivilent) into output_string. */
804static void 545static const char *
805print_shop_string (maptile *m, char *output_string) 546print_shop_string (maptile *m)
806{ 547{
807 int i; 548 static dynbuf_text buf; buf.clear ();
808 char tmp[MAX_BUF];
809 549
810 strcpy (output_string, "");
811 for (i = 0; i < m->shopitems[0].index; i++) 550 for (int i = 0; i < m->shopitems[0].index; i++)
812 { 551 {
813 if (m->shopitems[i].typenum) 552 if (m->shopitems[i].typenum)
814 { 553 {
815 if (m->shopitems[i].strength) 554 if (m->shopitems[i].strength)
816 sprintf (tmp, "%s:%d;", m->shopitems[i].name, m->shopitems[i].strength); 555 buf.printf ("%s:%d;", m->shopitems[i].name, m->shopitems[i].strength);
817 else 556 else
818 sprintf (tmp, "%s;", m->shopitems[i].name); 557 buf.printf ("%s;", m->shopitems[i].name);
819 } 558 }
820 else 559 else
821 { 560 {
822 if (m->shopitems[i].strength) 561 if (m->shopitems[i].strength)
823 sprintf (tmp, "*:%d;", m->shopitems[i].strength); 562 buf.printf ("*:%d;", m->shopitems[i].strength);
824 else 563 else
825 sprintf (tmp, "*"); 564 buf.printf ("*");
826 } 565 }
827
828 strcat (output_string, tmp);
829 } 566 }
567
568 return buf;
830} 569}
570
571//-GPL
831 572
832/* This loads the header information of the map. The header 573/* This loads the header information of the map. The header
833 * contains things like difficulty, size, timeout, etc. 574 * contains things like difficulty, size, timeout, etc.
834 * this used to be stored in the map object, but with the 575 * this used to be stored in the map object, but with the
835 * addition of tiling, fields beyond that easily named in an 576 * addition of tiling, fields beyond that easily named in an
… …
837 * put all the stuff in the map object so that names actually make 578 * put all the stuff in the map object so that names actually make
838 * sense. 579 * sense.
839 * This could be done in lex (like the object loader), but I think 580 * This could be done in lex (like the object loader), but I think
840 * currently, there are few enough fields this is not a big deal. 581 * currently, there are few enough fields this is not a big deal.
841 * MSW 2001-07-01 582 * MSW 2001-07-01
842 * return 0 on success, 1 on failure.
843 */ 583 */
844 584bool
845static int 585maptile::_load_header (object_thawer &thawer)
846load_map_header (object_thawer & fp, maptile *m)
847{ 586{
848 char buf[HUGE_BUF], msgbuf[HUGE_BUF], maplorebuf[HUGE_BUF], *key = NULL, *value, *end; 587 for (;;)
849 int msgpos = 0;
850 int maplorepos = 0;
851
852 while (fgets (buf, HUGE_BUF, fp) != NULL)
853 { 588 {
854 buf[HUGE_BUF - 1] = 0; 589 switch (thawer.kw)
855 key = buf;
856
857 while (isspace (*key))
858 key++;
859
860 if (*key == 0)
861 continue; /* empty line */
862
863 value = strchr (key, ' ');
864
865 if (!value)
866 { 590 {
867 if ((end = strchr (key, '\n'))) 591 case KW_msg:
868 *end = 0; 592 thawer.get_ml (KW_endmsg, msg);
593 break;
594
595 case KW_lore: // CF+ extension
596 thawer.get_ml (KW_endlore, maplore);
597 break;
598
599 case KW_maplore:
600 thawer.get_ml (KW_endmaplore, maplore);
601 break;
602
603 case KW_arch:
604 if (strcmp (thawer.get_str (), "map"))
605 LOG (llevError, "%s: loading map and got a non 'arch map' line (arch %s), skipping.\n", &path, thawer.get_str ());
606 break;
607
608 case KW_oid:
609 thawer.get (this, thawer.get_sint32 ());
610 break;
611
612 case KW_file_format_version: break; // nop
613
614 case KW_name: thawer.get (name); break;
615 case KW_attach: thawer.get (attach); break;
616 case KW_reset_time: thawer.get (reset_time); break;
617 case KW_shopgreed: thawer.get (shopgreed); break;
618 case KW_shopmin: thawer.get (shopmin); break;
619 case KW_shopmax: thawer.get (shopmax); break;
620 case KW_shoprace: thawer.get (shoprace); break;
621 case KW_outdoor: thawer.get (outdoor); break;
622 case KW_temp: thawer.get (temp); break;
623 case KW_pressure: thawer.get (pressure); break;
624 case KW_humid: thawer.get (humid); break;
625 case KW_windspeed: thawer.get (windspeed); break;
626 case KW_winddir: thawer.get (winddir); break;
627 case KW_sky: thawer.get (sky); break;
628
629 case KW_per_player: thawer.get (per_player); break;
630 case KW_per_party: thawer.get (per_party); break;
631 case KW_no_reset: thawer.get (no_reset); break;
632 case KW_no_drop: thawer.get (no_drop); break;
633
634 case KW_region: default_region = region::find (thawer.get_str ()); break;
635 case KW_shopitems: shopitems = parse_shop_string (thawer.get_str ()); break;
636
637 // old names new names
638 case KW_hp: case KW_enter_x: thawer.get (enter_x); break;
639 case KW_sp: case KW_enter_y: thawer.get (enter_y); break;
640 case KW_x: case KW_width: thawer.get (width); break;
641 case KW_y: case KW_height: thawer.get (height); break;
642 case KW_weight: case KW_reset_timeout: thawer.get (reset_timeout); break;
643 case KW_value: case KW_swap_time: thawer.get (timeout); break;
644 case KW_level: case KW_difficulty: thawer.get (difficulty); difficulty = clamp (difficulty, 1, settings.max_level); break;
645 case KW_invisible: case KW_darkness: thawer.get (darkness); break;
646 case KW_stand_still: case KW_fixed_resettime: thawer.get (fixed_resettime); break;
647
648 case KW_tile_path_1: thawer.get (tile_path [0]); break;
649 case KW_tile_path_2: thawer.get (tile_path [1]); break;
650 case KW_tile_path_3: thawer.get (tile_path [2]); break;
651 case KW_tile_path_4: thawer.get (tile_path [3]); break;
652
653 case KW_ERROR:
654 set_key_text (thawer.kw_str, thawer.value);
655 break;
656
657 case KW_end:
658 thawer.next ();
659 return true;
660
661 default:
662 if (!thawer.parse_error ("map", 0))
663 return false;
664 break;
869 } 665 }
870 else
871 {
872 *value = 0;
873 value++;
874 end = strchr (value, '\n');
875 666
876 while (isspace (*value)) 667 thawer.next ();
877 {
878 value++;
879
880 if (*value == '\0' || value == end)
881 {
882 /* Nothing but spaces. */
883 value = NULL;
884 break;
885 }
886 }
887 }
888
889 if (!end)
890 {
891 LOG (llevError, "Error loading map header - did not find a newline - perhaps file is truncated? Buf=%s\n", buf);
892 return 1;
893 }
894
895 /* key is the field name, value is what it should be set
896 * to. We've already done the work to null terminate key,
897 * and strip off any leading spaces for both of these.
898 * We have not touched the newline at the end of the line -
899 * these are needed for some values. the end pointer
900 * points to the first of the newlines.
901 * value could be NULL! It would be easy enough to just point
902 * this to "" to prevent cores, but that would let more errors slide
903 * through.
904 *
905 * First check for entries that do not use the value parameter, then
906 * validate that value is given and check for the remaining entries
907 * that use the parameter.
908 */
909
910 if (!strcmp (key, "msg"))
911 {
912 while (fgets (buf, HUGE_BUF, fp) != NULL)
913 {
914 if (!strcmp (buf, "endmsg\n"))
915 break;
916 else
917 {
918 /* slightly more efficient than strcat */
919 strcpy (msgbuf + msgpos, buf);
920 msgpos += strlen (buf);
921 }
922 }
923 /* There are lots of maps that have empty messages (eg, msg/endmsg
924 * with nothing between). There is no reason in those cases to
925 * keep the empty message. Also, msgbuf contains garbage data
926 * when msgpos is zero, so copying it results in crashes
927 */
928 if (msgpos != 0)
929 m->msg = strdup (msgbuf);
930 }
931 else if (!strcmp (key, "maplore"))
932 {
933 while (fgets (buf, HUGE_BUF, fp) != NULL)
934 {
935 if (!strcmp (buf, "endmaplore\n"))
936 break;
937 else
938 {
939 /* slightly more efficient than strcat */
940 strcpy (maplorebuf + maplorepos, buf);
941 maplorepos += strlen (buf);
942 }
943 }
944 if (maplorepos != 0)
945 m->maplore = strdup (maplorebuf);
946 }
947 else if (!strcmp (key, "end"))
948 {
949 break;
950 }
951 else if (value == NULL)
952 {
953 LOG (llevError, "Got '%s' line without parameter in map header\n", key);
954 }
955 else if (!strcmp (key, "arch"))
956 {
957 /* This is an oddity, but not something we care about much. */
958 if (strcmp (value, "map\n"))
959 LOG (llevError, "loading map and got a non 'arch map' line(%s %s)?\n", key, value);
960 }
961 else if (!strcmp (key, "name"))
962 {
963 *end = 0;
964 m->name = strdup (value);
965 }
966 /* first strcmp value on these are old names supported
967 * for compatibility reasons. The new values (second) are
968 * what really should be used.
969 */
970 else if (!strcmp (key, "oid"))
971 fp.get (m, atoi (value));
972 else if (!strcmp (key, "attach"))
973 m->attach = value;
974 else if (!strcmp (key, "hp") || !strcmp (key, "enter_x"))
975 m->enter_x = atoi (value);
976 else if (!strcmp (key, "sp") || !strcmp (key, "enter_y"))
977 m->enter_y = atoi (value);
978 else if (!strcmp (key, "x") || !strcmp (key, "width"))
979 m->width = atoi (value);
980 else if (!strcmp (key, "y") || !strcmp (key, "height"))
981 m->height = atoi (value);
982 else if (!strcmp (key, "weight") || !strcmp (key, "reset_timeout"))
983 m->reset_timeout = atoi (value);
984 else if (!strcmp (key, "value") || !strcmp (key, "swap_time"))
985 m->timeout = atoi (value);
986 else if (!strcmp (key, "level") || !strcmp (key, "difficulty"))
987 m->difficulty = clamp (atoi (value), 1, settings.max_level);
988 else if (!strcmp (key, "invisible") || !strcmp (key, "darkness"))
989 m->darkness = atoi (value);
990 else if (!strcmp (key, "stand_still") || !strcmp (key, "fixed_resettime"))
991 m->fixed_resettime = atoi (value);
992 else if (!strcmp (key, "unique"))
993 m->unique = atoi (value);
994 else if (!strcmp (key, "template"))
995 m->templatemap = atoi (value);
996 else if (!strcmp (key, "region"))
997 m->region = get_region_by_name (value);
998 else if (!strcmp (key, "shopitems"))
999 {
1000 *end = 0;
1001 m->shopitems = parse_shop_string (value);
1002 }
1003 else if (!strcmp (key, "shopgreed"))
1004 m->shopgreed = atof (value);
1005 else if (!strcmp (key, "shopmin"))
1006 m->shopmin = atol (value);
1007 else if (!strcmp (key, "shopmax"))
1008 m->shopmax = atol (value);
1009 else if (!strcmp (key, "shoprace"))
1010 {
1011 *end = 0;
1012 m->shoprace = strdup (value);
1013 }
1014 else if (!strcmp (key, "outdoor"))
1015 m->outdoor = atoi (value);
1016 else if (!strcmp (key, "temp"))
1017 m->temp = atoi (value);
1018 else if (!strcmp (key, "pressure"))
1019 m->pressure = atoi (value);
1020 else if (!strcmp (key, "humid"))
1021 m->humid = atoi (value);
1022 else if (!strcmp (key, "windspeed"))
1023 m->windspeed = atoi (value);
1024 else if (!strcmp (key, "winddir"))
1025 m->winddir = atoi (value);
1026 else if (!strcmp (key, "sky"))
1027 m->sky = atoi (value);
1028 else if (!strcmp (key, "nosmooth"))
1029 m->nosmooth = atoi (value);
1030 else if (!strncmp (key, "tile_path_", 10))
1031 {
1032 int tile = atoi (key + 10);
1033
1034 if (tile < 1 || tile > 4)
1035 {
1036 LOG (llevError, "load_map_header: tile location %d out of bounds (%s)\n", tile, m->path);
1037 }
1038 else
1039 {
1040 char *path;
1041
1042 *end = 0;
1043
1044 if (m->tile_path[tile - 1])
1045 {
1046 LOG (llevError, "load_map_header: tile location %d duplicated (%s)\n", tile, m->path);
1047 free (m->tile_path[tile - 1]);
1048 m->tile_path[tile - 1] = NULL;
1049 }
1050
1051 if (check_path (value, 1) != -1)
1052 {
1053 /* The unadorned path works. */
1054 path = value;
1055 }
1056 else
1057 {
1058 /* Try again; it could be a relative exit. */
1059
1060 path = path_combine_and_normalize (m->path, value);
1061
1062 if (check_path (path, 1) == -1)
1063 {
1064 LOG (llevError, "get_map_header: Bad tile path %s %s\n", m->path, value);
1065 path = NULL;
1066 }
1067 }
1068
1069 if (editor)
1070 {
1071 /* Use the value as in the file. */
1072 m->tile_path[tile - 1] = strdup (value);
1073 }
1074 else if (path != NULL)
1075 {
1076 /* Use the normalized value. */
1077 m->tile_path[tile - 1] = strdup (path);
1078 }
1079 } /* end if tile direction (in)valid */
1080 }
1081 else
1082 LOG (llevError, "Got unknown value in map header: %s %s\n", key, value);
1083 }
1084
1085 if (!key || strcmp (key, "end"))
1086 { 668 }
1087 LOG (llevError, "Got premature eof on map header!\n");
1088 return 1;
1089 }
1090 669
1091 return 0; 670 abort ();
1092} 671}
1093 672
1094/* 673//+GPL
1095 * Opens the file "filename" and reads information about the map
1096 * from the given file, and stores it in a newly allocated
1097 * maptile. A pointer to this structure is returned, or NULL on failure.
1098 * flags correspond to those in map.h. Main ones used are
1099 * MAP_PLAYER_UNIQUE, in which case we don't do any name changes, and
1100 * MAP_BLOCK, in which case we block on this load. This happens in all
1101 * cases, no matter if this flag is set or not.
1102 * MAP_STYLE: style map - don't add active objects, don't add to server
1103 * managed map list.
1104 */
1105maptile *
1106load_original_map (const char *filename, int flags)
1107{
1108 maptile *m;
1109 char pathname[MAX_BUF];
1110
1111 if (flags & MAP_PLAYER_UNIQUE)
1112 strcpy (pathname, filename);
1113 else if (flags & MAP_OVERLAY)
1114 strcpy (pathname, create_overlay_pathname (filename));
1115 else
1116 strcpy (pathname, create_pathname (filename));
1117
1118 LOG (llevDebug, "load_original_map(%x): %s (%s)\n", flags, filename, pathname);
1119
1120 object_thawer thawer (pathname);
1121
1122 if (!thawer)
1123 return 0;
1124
1125 m = get_linked_map ();
1126
1127 strcpy (m->path, filename);
1128 if (load_map_header (thawer, m))
1129 {
1130 LOG (llevError, "Error loading map header for %s, flags=%d\n", filename, flags);
1131 delete_map (m);
1132 return 0;
1133 }
1134
1135 m->allocate ();
1136
1137 m->in_memory = MAP_LOADING;
1138 load_objects (m, thawer, flags & (MAP_BLOCK | MAP_STYLE));
1139
1140 m->in_memory = MAP_IN_MEMORY;
1141 if (!m->difficulty)
1142 m->difficulty = calculate_difficulty (m);
1143 set_map_reset_time (m);
1144 m->instantiate ();
1145 return (m);
1146}
1147
1148/*
1149 * Loads a map, which has been loaded earlier, from file.
1150 * Return the map object we load into (this can change from the passed
1151 * option if we can't find the original map)
1152 */
1153static maptile *
1154load_temporary_map (maptile *m)
1155{
1156 char buf[MAX_BUF];
1157
1158 if (!m->tmpname)
1159 {
1160 LOG (llevError, "No temporary filename for map %s\n", m->path);
1161 strcpy (buf, m->path);
1162 delete_map (m);
1163 m = load_original_map (buf, 0);
1164 if (m == NULL)
1165 return NULL;
1166 fix_auto_apply (m); /* Chests which open as default */
1167 return m;
1168 }
1169
1170 object_thawer thawer (m->tmpname);
1171
1172 if (!thawer)
1173 {
1174 strcpy (buf, m->path);
1175 delete_map (m);
1176 m = load_original_map (buf, 0);
1177 if (!m)
1178 return NULL;
1179 fix_auto_apply (m); /* Chests which open as default */
1180 return m;
1181 }
1182
1183 if (load_map_header (thawer, m))
1184 {
1185 LOG (llevError, "Error loading map header for %s (%s)\n", m->path, m->tmpname);
1186 delete_map (m);
1187 m = load_original_map (m->path, 0);
1188 return NULL;
1189 }
1190
1191 m->allocate ();
1192
1193 m->in_memory = MAP_LOADING;
1194 load_objects (m, thawer, 0);
1195
1196 m->in_memory = MAP_IN_MEMORY;
1197 INVOKE_MAP (SWAPIN, m);
1198 return m;
1199}
1200
1201/*
1202 * Loads a map, which has been loaded earlier, from file.
1203 * Return the map object we load into (this can change from the passed
1204 * option if we can't find the original map)
1205 */
1206maptile *
1207load_overlay_map (const char *filename, maptile *m)
1208{
1209 char pathname[MAX_BUF];
1210
1211 strcpy (pathname, create_overlay_pathname (filename));
1212
1213 object_thawer thawer (pathname);
1214
1215 if (!thawer)
1216 return m;
1217
1218 if (load_map_header (thawer, m))
1219 {
1220 LOG (llevError, "Error loading map header for overlay %s (%s)\n", m->path, pathname);
1221 delete_map (m);
1222 m = load_original_map (m->path, 0);
1223 return 0;
1224 }
1225 /*m->allocate ();*/
1226
1227 m->in_memory = MAP_LOADING;
1228 load_objects (m, thawer, MAP_OVERLAY);
1229
1230 m->in_memory = MAP_IN_MEMORY;
1231 return m;
1232}
1233 674
1234/****************************************************************************** 675/******************************************************************************
1235 * This is the start of unique map handling code 676 * This is the start of unique map handling code
1236 *****************************************************************************/ 677 *****************************************************************************/
1237 678
1238/* This goes through map 'm' and removed any unique items on the map. */ 679/* This goes through the maptile and removed any unique items on the map. */
1239static void 680void
1240delete_unique_items (maptile *m) 681maptile::clear_unique_items ()
1241{ 682{
1242 int i, j, unique; 683 for (int i = 0; i < size (); ++i)
1243 object *op, *next;
1244
1245 for (i = 0; i < m->width; i++)
1246 for (j = 0; j < m->height; j++)
1247 { 684 {
1248 unique = 0; 685 int unique = 0;
686 for (object *op = spaces [i].bot; op; )
687 {
688 object *above = op->above;
1249 689
1250 for (op = GET_MAP_OB (m, i, j); op; op = next) 690 if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE))
691 unique = 1;
692
693 if (op->head_ () == op && (QUERY_FLAG (op, FLAG_UNIQUE) || unique))
694 op->destroy ();
695
696 op = above;
697 }
698 }
699}
700
701//-GPL
702
703bool
704maptile::_save_header (object_freezer &freezer)
705{
706#define MAP_OUT(k) freezer.put (KW_ ## k, k)
707#define MAP_OUT2(k,v) freezer.put (KW_ ## k, v)
708
709 MAP_OUT2 (arch, "map");
710
711 if (name) MAP_OUT (name);
712 MAP_OUT (swap_time);
713 MAP_OUT (reset_time);
714 MAP_OUT (reset_timeout);
715 MAP_OUT (fixed_resettime);
716 MAP_OUT (no_reset);
717 MAP_OUT (no_drop);
718 MAP_OUT (difficulty);
719 if (default_region) MAP_OUT2 (region, default_region->name);
720
721 if (shopitems) MAP_OUT2 (shopitems, print_shop_string (this));
722 MAP_OUT (shopgreed);
723 MAP_OUT (shopmin);
724 MAP_OUT (shopmax);
725 if (shoprace) MAP_OUT (shoprace);
726
727 MAP_OUT (darkness);
728 MAP_OUT (width);
729 MAP_OUT (height);
730 MAP_OUT (enter_x);
731 MAP_OUT (enter_y);
732
733 if (msg) freezer.put (KW_msg , KW_endmsg , msg);
734 if (maplore) freezer.put (KW_maplore, KW_endmaplore, maplore);
735
736 MAP_OUT (outdoor);
737 MAP_OUT (temp);
738 MAP_OUT (pressure);
739 MAP_OUT (humid);
740 MAP_OUT (windspeed);
741 MAP_OUT (winddir);
742 MAP_OUT (sky);
743
744 MAP_OUT (per_player);
745 MAP_OUT (per_party);
746
747 if (tile_path [0]) MAP_OUT2 (tile_path_1, tile_path [0]);
748 if (tile_path [1]) MAP_OUT2 (tile_path_2, tile_path [1]);
749 if (tile_path [2]) MAP_OUT2 (tile_path_3, tile_path [2]);
750 if (tile_path [3]) MAP_OUT2 (tile_path_4, tile_path [3]);
751
752 freezer.put (this);
753 freezer.put (KW_end);
754
755 return true;
756}
757
758bool
759maptile::_save_header (const char *path)
760{
761 object_freezer freezer;
762
763 if (!_save_header (freezer))
764 return false;
765
766 return freezer.save (path);
767}
768
769//+GPL
770
771/*
772 * Remove and free all objects in the given map.
773 */
774void
775maptile::clear ()
776{
777 if (spaces)
778 {
779 for (mapspace *ms = spaces + size (); ms-- > spaces; )
780 while (object *op = ms->bot)
1251 { 781 {
782 // manually remove, as to not trigger anything
1252 next = op->above; 783 if (ms->bot = op->above)
784 ms->bot->below = 0;
1253 785
1254 if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE)) 786 op->flag [FLAG_REMOVED] = true;
1255 unique = 1;
1256 787
1257 if (op->head == NULL && (QUERY_FLAG (op, FLAG_UNIQUE) || unique)) 788 object *head = op->head_ ();
789 if (op == head)
790 op->destroy ();
791 else if (head->map != op->map)
1258 { 792 {
1259 op->destroy_inv (false); 793 LOG (llevDebug, "bad luck for object crossing map borders: %s", head->debug_desc ());
1260 op->destroy (); 794 head->destroy ();
1261 } 795 }
1262 } 796 }
797
798 sfree0 (spaces, size ());
1263 } 799 }
1264}
1265 800
1266/* 801 if (buttons)
1267 * Loads unique objects from file(s) into the map which is in memory 802 free_objectlinkpt (buttons), buttons = 0;
1268 * m is the map to load unique items into.
1269 */
1270static void
1271load_unique_objects (maptile *m)
1272{
1273 int count;
1274 char firstname[MAX_BUF];
1275 803
1276 for (count = 0; count < 10; count++) 804 sfree0 (regions, size ());
1277 { 805 delete [] regionmap; regionmap = 0;
1278 sprintf (firstname, "%s.v%02d", create_items_path (m->path), count);
1279 if (!access (firstname, R_OK))
1280 break;
1281 }
1282 /* If we get here, we did not find any map */
1283 if (count == 10)
1284 return;
1285
1286 object_thawer thawer (firstname);
1287
1288 if (!thawer)
1289 return;
1290
1291 m->in_memory = MAP_LOADING;
1292 if (m->tmpname == NULL) /* if we have loaded unique items from */
1293 delete_unique_items (m); /* original map before, don't duplicate them */
1294
1295 load_objects (m, thawer, 0);
1296
1297 m->in_memory = MAP_IN_MEMORY;
1298} 806}
1299 807
1300/*
1301 * Saves a map to file. If flag is set, it is saved into the same
1302 * file it was (originally) loaded from. Otherwise a temporary
1303 * filename will be genarated, and the file will be stored there.
1304 * The temporary filename will be stored in the maptileure.
1305 * If the map is unique, we also save to the filename in the map
1306 * (this should have been updated when first loaded)
1307 */
1308int
1309new_save_map (maptile *m, int flag)
1310{
1311 char filename[MAX_BUF], buf[MAX_BUF], shop[MAX_BUF];
1312 int i;
1313
1314 if (flag && !*m->path)
1315 {
1316 LOG (llevError, "Tried to save map without path.\n");
1317 return -1;
1318 }
1319
1320 if (flag || (m->unique) || (m->templatemap))
1321 {
1322 if (!m->unique && !m->templatemap)
1323 { /* flag is set */
1324 if (flag == 2)
1325 strcpy (filename, create_overlay_pathname (m->path));
1326 else
1327 strcpy (filename, create_pathname (m->path));
1328 }
1329 else
1330 strcpy (filename, m->path);
1331
1332 make_path_to_file (filename);
1333 }
1334 else
1335 {
1336 if (!m->tmpname)
1337 m->tmpname = tempnam (settings.tmpdir, NULL);
1338
1339 strcpy (filename, m->tmpname);
1340 }
1341
1342 LOG (llevDebug, "Saving map %s to %s\n", m->path, filename);
1343 m->in_memory = MAP_SAVING;
1344
1345 object_freezer freezer;
1346
1347 /* legacy */
1348 fprintf (freezer, "arch map\n");
1349 if (m->name)
1350 fprintf (freezer, "name %s\n", m->name);
1351 if (!flag)
1352 fprintf (freezer, "swap_time %d\n", m->swap_time);
1353 if (m->reset_timeout)
1354 fprintf (freezer, "reset_timeout %d\n", m->reset_timeout);
1355 if (m->fixed_resettime)
1356 fprintf (freezer, "fixed_resettime %d\n", m->fixed_resettime);
1357 /* we unfortunately have no idea if this is a value the creator set
1358 * or a difficulty value we generated when the map was first loaded
1359 */
1360 if (m->difficulty)
1361 fprintf (freezer, "difficulty %d\n", m->difficulty);
1362 if (m->region)
1363 fprintf (freezer, "region %s\n", m->region->name);
1364 if (m->shopitems)
1365 {
1366 print_shop_string (m, shop);
1367 fprintf (freezer, "shopitems %s\n", shop);
1368 }
1369 if (m->shopgreed)
1370 fprintf (freezer, "shopgreed %f\n", m->shopgreed);
1371 if (m->shopmin)
1372 fprintf (freezer, "shopmin %llu\n", m->shopmin);
1373 if (m->shopmax)
1374 fprintf (freezer, "shopmax %llu\n", m->shopmax);
1375 if (m->shoprace)
1376 fprintf (freezer, "shoprace %s\n", m->shoprace);
1377 if (m->darkness)
1378 fprintf (freezer, "darkness %d\n", m->darkness);
1379 if (m->width)
1380 fprintf (freezer, "width %d\n", m->width);
1381 if (m->height)
1382 fprintf (freezer, "height %d\n", m->height);
1383 if (m->enter_x)
1384 fprintf (freezer, "enter_x %d\n", m->enter_x);
1385 if (m->enter_y)
1386 fprintf (freezer, "enter_y %d\n", m->enter_y);
1387 if (m->msg)
1388 fprintf (freezer, "msg\n%sendmsg\n", m->msg);
1389 if (m->maplore)
1390 fprintf (freezer, "maplore\n%sendmaplore\n", m->maplore);
1391 if (m->unique)
1392 fprintf (freezer, "unique %d\n", m->unique);
1393 if (m->templatemap)
1394 fprintf (freezer, "template %d\n", m->templatemap);
1395 if (m->outdoor)
1396 fprintf (freezer, "outdoor %d\n", m->outdoor);
1397 if (m->temp)
1398 fprintf (freezer, "temp %d\n", m->temp);
1399 if (m->pressure)
1400 fprintf (freezer, "pressure %d\n", m->pressure);
1401 if (m->humid)
1402 fprintf (freezer, "humid %d\n", m->humid);
1403 if (m->windspeed)
1404 fprintf (freezer, "windspeed %d\n", m->windspeed);
1405 if (m->winddir)
1406 fprintf (freezer, "winddir %d\n", m->winddir);
1407 if (m->sky)
1408 fprintf (freezer, "sky %d\n", m->sky);
1409 if (m->nosmooth)
1410 fprintf (freezer, "nosmooth %d\n", m->nosmooth);
1411
1412 /* Save any tiling information, except on overlays */
1413 if (flag != 2)
1414 for (i = 0; i < 4; i++)
1415 if (m->tile_path[i])
1416 fprintf (freezer, "tile_path_%d %s\n", i + 1, m->tile_path[i]);
1417
1418 freezer.put (m);
1419 fprintf (freezer, "end\n");
1420
1421 /* In the game save unique items in the different file, but
1422 * in the editor save them to the normal map file.
1423 * If unique map, save files in the proper destination (set by
1424 * player)
1425 */
1426 if ((flag == 0 || flag == 2) && !m->unique && !m->templatemap)
1427 {
1428 object_freezer unique;
1429
1430 if (flag == 2)
1431 save_objects (m, freezer, unique, 2);
1432 else
1433 save_objects (m, freezer, unique, 0);
1434
1435 sprintf (buf, "%s.v00", create_items_path (m->path));
1436
1437 unique.save (buf);
1438 }
1439 else
1440 { /* save same file when not playing, like in editor */
1441 save_objects (m, freezer, freezer, 0);
1442 }
1443
1444 freezer.save (filename);
1445
1446 return 0;
1447}
1448
1449/*
1450 * Remove and free all objects in the given map.
1451 */
1452void 808void
1453free_all_objects (maptile *m) 809maptile::clear_header ()
1454{ 810{
1455 if (!m->spaces) 811 name = 0;
1456 return; 812 msg = 0;
813 maplore = 0;
814 shoprace = 0;
815 delete [] shopitems, shopitems = 0;
1457 816
1458 for (int i = 0; i < m->width; i++) 817 for (int i = 0; i < 4; i++)
1459 for (int j = 0; j < m->height; j++) 818 tile_path [i] = 0;
1460 {
1461 mapspace &ms = m->at (i, j);
1462
1463 while (object *op = ms.bot)
1464 {
1465 if (op->head)
1466 op = op->head;
1467
1468 op->destroy_inv (false);
1469 op->destroy ();
1470 }
1471 }
1472} 819}
1473 820
1474/* 821maptile::~maptile ()
1475 * Frees everything allocated by the given maptileure. 822{
1476 * don't free tmpname - our caller is left to do that 823 assert (destroyed ());
1477 */ 824}
825
1478void 826void
1479free_map (maptile *m, int flag) 827maptile::clear_links_to (maptile *m)
1480{ 828{
1481 if (!m->in_memory) //TODO: makes no sense to me?
1482 return;
1483
1484 m->in_memory = MAP_SAVING;
1485
1486 // TODO: use new/delete
1487
1488 if (flag && m->spaces)
1489 free_all_objects (m);
1490
1491 sfree (m->spaces, m->size ()), m->spaces = 0;
1492
1493 free (m->name), m->name = 0;
1494 free (m->msg), m->msg = 0;
1495 free (m->maplore), m->maplore = 0;
1496 free (m->shoprace), m->shoprace = 0;
1497 delete [] m->shopitems, m->shopitems = 0;
1498
1499 if (m->buttons)
1500 free_objectlinkpt (m->buttons), m->buttons = 0;
1501
1502 for (int i = 0; i < 4; i++)
1503 free (m->tile_path[i]), m->tile_path[i] = 0;
1504
1505 m->in_memory = MAP_SWAPPED;
1506}
1507
1508maptile::~maptile ()
1509{
1510 assert (destroyed ());
1511}
1512
1513void
1514maptile::do_destroy ()
1515{
1516 attachable::do_destroy ();
1517
1518 unlink ();
1519
1520 free_map (this, 1);
1521 free (tmpname), tmpname = 0;
1522
1523 /* We need to look through all the maps and see if any maps 829 /* We need to look through all the maps and see if any maps
1524 * are pointing at this one for tiling information. Since 830 * are pointing at this one for tiling information. Since
1525 * tiling can be asymetric, we just can not look to see which 831 * tiling can be asymetric, we just can not look to see which
1526 * maps this map tiles with and clears those. 832 * maps this map tiles with and clears those.
1527 */ 833 */
1528 //TODO: non-euclidean-tiling MUST GO
1529 for_all_maps (m)
1530 for (int i = 0; i < 4; i++) 834 for (int i = 0; i < 4; i++)
1531 if (m->tile_map[i] == this) 835 if (tile_map[i] == m)
1532 m->tile_map[i] = 0; 836 tile_map[i] = 0;
1533} 837}
1534 838
1535//TODO: must go
1536void 839void
1537delete_map (maptile *m) 840maptile::do_destroy ()
1538{ 841{
1539 if (m) 842 attachable::do_destroy ();
1540 m->destroy ();
1541}
1542 843
1543/* 844 clear ();
1544 * Makes sure the given map is loaded and swapped in. 845}
1545 * name is path name of the map. 846
1546 * flags meaning: 847/* decay and destroy perishable items in a map */
1547 * 0x1 (MAP_FLUSH): flush the map - always load from the map directory, 848void
1548 * and don't do unique items or the like. 849maptile::do_decay_objects ()
1549 * 0x2 (MAP_PLAYER_UNIQUE) - this is a unique map for each player.
1550 * dont do any more name translation on it.
1551 *
1552 * Returns a pointer to the given map.
1553 */
1554maptile *
1555ready_map_name (const char *name, int flags)
1556{ 850{
1557 if (!name) 851 if (!spaces)
1558 return 0; 852 return;
1559 853
1560 /* Have we been at this level before? */ 854 for (mapspace *ms = spaces + size (); ms-- > spaces; )
1561 maptile *m = has_been_loaded (name); 855 for (object *above, *op = ms->bot; op; op = above)
1562
1563 /* Map is good to go, so just return it */
1564 if (m && (m->in_memory == MAP_LOADING || m->in_memory == MAP_IN_MEMORY))
1565 return m;
1566
1567 /* unique maps always get loaded from their original location, and never
1568 * a temp location. Likewise, if map_flush is set, or we have never loaded
1569 * this map, load it now. I removed the reset checking from here -
1570 * it seems the probability of a player trying to enter a map that should
1571 * reset but hasn't yet is quite low, and removing that makes this function
1572 * a bit cleaner (and players probably shouldn't rely on exact timing for
1573 * resets in any case - if they really care, they should use the 'maps command.
1574 */
1575 if ((flags & (MAP_FLUSH | MAP_PLAYER_UNIQUE)) || !m)
1576 { 856 {
1577 /* first visit or time to reset */ 857 above = op->above;
1578 if (m) 858
859 bool destroy = 0;
860
861 // do not decay anything above unique floor tiles (yet :)
862 if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE))
863 break;
864
865 if (QUERY_FLAG (op, FLAG_IS_FLOOR)
866 || QUERY_FLAG (op, FLAG_OBJ_ORIGINAL)
867 || QUERY_FLAG (op, FLAG_UNIQUE)
868 || QUERY_FLAG (op, FLAG_OVERLAY_FLOOR)
869 || QUERY_FLAG (op, FLAG_UNPAID)
870 || op->is_alive ())
871 ; // do not decay
872 else if (op->is_weapon ())
1579 { 873 {
1580 clean_tmp_map (m); /* Doesn't make much difference */ 874 op->stats.dam--;
1581 delete_map (m); 875 if (op->stats.dam < 0)
876 destroy = 1;
1582 } 877 }
1583 878 else if (op->is_armor ())
1584 /* create and load a map */ 879 {
1585 if (flags & MAP_PLAYER_UNIQUE) 880 op->stats.ac--;
1586 LOG (llevDebug, "Trying to load map %s.\n", name); 881 if (op->stats.ac < 0)
882 destroy = 1;
883 }
884 else if (op->type == FOOD)
885 {
886 op->stats.food -= rndm (5, 20);
887 if (op->stats.food < 0)
888 destroy = 1;
889 }
1587 else 890 else
1588 LOG (llevDebug, "Trying to load map %s.\n", create_pathname (name));
1589
1590 if (!(m = load_original_map (name, (flags & MAP_PLAYER_UNIQUE))))
1591 return (NULL);
1592
1593 fix_auto_apply (m); /* Chests which open as default */
1594
1595 /* If a player unique map, no extra unique object file to load.
1596 * if from the editor, likewise.
1597 */
1598 if (!(flags & (MAP_FLUSH | MAP_PLAYER_UNIQUE)))
1599 load_unique_objects (m);
1600
1601 if (!(flags & (MAP_FLUSH | MAP_PLAYER_UNIQUE | MAP_OVERLAY)))
1602 { 891 {
1603 m = load_overlay_map (name, m); 892 int mat = op->materials;
1604 if (m == NULL) 893
1605 return NULL; 894 if (mat & M_PAPER
895 || mat & M_LEATHER
896 || mat & M_WOOD
897 || mat & M_ORGANIC
898 || mat & M_CLOTH
899 || mat & M_LIQUID
900 || (mat & M_IRON && rndm (1, 5) == 1)
901 || (mat & M_GLASS && rndm (1, 2) == 1)
902 || ((mat & M_STONE || mat & M_ADAMANT) && rndm (1, 10) == 1)
903 || ((mat & M_SOFT_METAL || mat & M_BONE) && rndm (1, 3) == 1)
904 || (mat & M_ICE && temp > 32))
905 destroy = 1;
1606 } 906 }
1607 907
1608 if (flags & MAP_PLAYER_UNIQUE) 908 /* adjust overall chance below */
1609 INVOKE_MAP (SWAPIN, m); 909 if (destroy && rndm (0, 1))
1610 910 op->destroy ();
1611 } 911 }
1612 else
1613 {
1614 /* If in this loop, we found a temporary map, so load it up. */
1615
1616 m = load_temporary_map (m);
1617 if (m == NULL)
1618 return NULL;
1619 load_unique_objects (m);
1620
1621 clean_tmp_map (m);
1622 m->in_memory = MAP_IN_MEMORY;
1623 /* tempnam() on sun systems (probably others) uses malloc
1624 * to allocated space for the string. Free it here.
1625 * In some cases, load_temporary_map above won't find the
1626 * temporary map, and so has reloaded a new map. If that
1627 * is the case, tmpname is now null
1628 */
1629 if (m->tmpname)
1630 free (m->tmpname);
1631 m->tmpname = NULL;
1632 /* It's going to be saved anew anyway */
1633 }
1634
1635 /* Below here is stuff common to both first time loaded maps and
1636 * temp maps.
1637 */
1638
1639 decay_objects (m); /* start the decay */
1640 /* In case other objects press some buttons down */
1641 update_buttons (m);
1642 if (m->outdoor)
1643 set_darkness_map (m);
1644 /* run the weather over this map */
1645 weather_effect (name);
1646 return m;
1647} 912}
1648
1649 913
1650/* 914/*
1651 * This routine is supposed to find out the difficulty of the map. 915 * This routine is supposed to find out the difficulty of the map.
1652 * difficulty does not have a lot to do with character level, 916 * difficulty does not have a lot to do with character level,
1653 * but does have a lot to do with treasure on the map. 917 * but does have a lot to do with treasure on the map.
1654 * 918 *
1655 * Difficulty can now be set by the map creature. If the value stored 919 * Difficulty can now be set by the map creator. If the value stored
1656 * in the map is zero, then use this routine. Maps should really 920 * in the map is zero, then use this routine. Maps should really
1657 * have a difficulty set than using this function - human calculation 921 * have a difficulty set rather than using this function - human calculation
1658 * is much better than this functions guesswork. 922 * is much better than this function's guesswork.
1659 */ 923 */
1660
1661int 924int
1662calculate_difficulty (maptile *m) 925maptile::estimate_difficulty () const
1663{ 926{
1664 object *op;
1665 archetype *at;
1666 int x, y, i;
1667 long monster_cnt = 0; 927 long monster_cnt = 0;
1668 double avgexp = 0; 928 double avgexp = 0;
1669 sint64 total_exp = 0; 929 sint64 total_exp = 0;
1670 930
1671 if (m->difficulty) 931 for (mapspace *ms = spaces + size (); ms-- > spaces; )
1672 { 932 for (object *op = ms->bot; op; op = op->above)
1673 LOG (llevDebug, "Using stored map difficulty: %d\n", m->difficulty);
1674 return m->difficulty;
1675 }
1676
1677 for (x = 0; x < m->width; x++)
1678 for (y = 0; y < m->height; y++)
1679 for (op = GET_MAP_OB (m, x, y); op != NULL; op = op->above)
1680 { 933 {
1681 if (QUERY_FLAG (op, FLAG_MONSTER)) 934 if (QUERY_FLAG (op, FLAG_MONSTER))
1682 { 935 {
1683 total_exp += op->stats.exp; 936 total_exp += op->stats.exp;
1684 monster_cnt++; 937 monster_cnt++;
1685 } 938 }
1686 939
1687 if (QUERY_FLAG (op, FLAG_GENERATOR)) 940 if (QUERY_FLAG (op, FLAG_GENERATOR))
1688 { 941 {
1689 total_exp += op->stats.exp; 942 total_exp += op->stats.exp;
1690 at = type_to_archetype (GENERATE_TYPE (op));
1691 943
1692 if (at != NULL) 944 if (archetype *at = op->other_arch)
945 {
1693 total_exp += at->clone.stats.exp * 8; 946 total_exp += at->stats.exp * 8;
1694
1695 monster_cnt++; 947 monster_cnt++;
1696 } 948 }
949
950 for (object *inv = op->inv; inv; inv = inv->below)
951 {
952 total_exp += op->stats.exp * 8;
953 monster_cnt++;
954 }
1697 } 955 }
956 }
1698 957
1699 avgexp = (double) total_exp / monster_cnt; 958 avgexp = (double) total_exp / monster_cnt;
1700 959
1701 for (i = 1; i <= settings.max_level; i++) 960 for (int i = 1; i <= settings.max_level; i++)
1702 {
1703 if ((level_exp (i, 1) - level_exp (i - 1, 1)) > (100 * avgexp)) 961 if ((level_exp (i, 1) - level_exp (i - 1, 1)) > (100 * avgexp))
1704 {
1705 /* LOG(llevDebug, "Calculated difficulty for map: %s: %d\n", m->name, i); */
1706 return i; 962 return i;
1707 }
1708 }
1709 963
1710 return 1; 964 return 1;
1711}
1712
1713void
1714clean_tmp_map (maptile *m)
1715{
1716 if (m->tmpname == NULL)
1717 return;
1718 INVOKE_MAP (CLEAN, m);
1719 (void) unlink (m->tmpname);
1720}
1721
1722void
1723free_all_maps (void)
1724{
1725 int real_maps = 0;
1726
1727 while (first_map)
1728 {
1729 /* I think some of the callers above before it gets here set this to be
1730 * saving, but we still want to free this data
1731 */
1732 if (first_map->in_memory == MAP_SAVING)
1733 first_map->in_memory = MAP_IN_MEMORY;
1734 delete_map (first_map);
1735 real_maps++;
1736 }
1737
1738 LOG (llevDebug, "free_all_maps: Freed %d maps\n", real_maps);
1739} 965}
1740 966
1741/* change_map_light() - used to change map light level (darkness) 967/* change_map_light() - used to change map light level (darkness)
1742 * up or down. Returns true if successful. It should now be 968 * up or down. Returns true if successful. It should now be
1743 * possible to change a value by more than 1. 969 * possible to change a value by more than 1.
1744 * Move this from los.c to map.c since this is more related 970 * Move this from los.c to map.c since this is more related
1745 * to maps than los. 971 * to maps than los.
1746 * postive values make it darker, negative make it brighter 972 * postive values make it darker, negative make it brighter
1747 */ 973 */
1748
1749int 974int
1750change_map_light (maptile *m, int change) 975maptile::change_map_light (int change)
1751{ 976{
1752 int new_level = m->darkness + change;
1753
1754 /* Nothing to do */ 977 /* Nothing to do */
1755 if (!change || (new_level <= 0 && m->darkness == 0) || (new_level >= MAX_DARKNESS && m->darkness >= MAX_DARKNESS)) 978 if (!change)
1756 {
1757 return 0; 979 return 0;
1758 }
1759 980
1760 /* inform all players on the map */ 981 /* inform all players on the map */
1761 if (change > 0) 982 if (change > 0)
1762 new_info_map (NDI_BLACK | NDI_UNIQUE, m, "It becomes darker."); 983 new_info_map (NDI_BLACK | NDI_UNIQUE, this, "It becomes darker.");
1763 else 984 else
1764 new_info_map (NDI_BLACK | NDI_UNIQUE, m, "It becomes brighter."); 985 new_info_map (NDI_BLACK | NDI_UNIQUE, this, "It becomes brighter.");
1765 986
1766 /* Do extra checking. since m->darkness is a unsigned value, 987 darkness = clamp (darkness + change, -MAX_DARKNESS, MAX_DARKNESS);
1767 * we need to be extra careful about negative values.
1768 * In general, the checks below are only needed if change
1769 * is not +/-1
1770 */
1771 if (new_level < 0)
1772 m->darkness = 0;
1773 else if (new_level >= MAX_DARKNESS)
1774 m->darkness = MAX_DARKNESS;
1775 else
1776 m->darkness = new_level;
1777 988
1778 /* All clients need to get re-updated for the change */ 989 /* All clients need to get re-updated for the change */
1779 update_all_map_los (m); 990 update_all_map_los (this);
991
1780 return 1; 992 return 1;
1781} 993}
1782 994
1783/* 995/*
1784 * This function updates various attributes about a specific space 996 * This function updates various attributes about a specific space
… …
1787 * through, etc) 999 * through, etc)
1788 */ 1000 */
1789void 1001void
1790mapspace::update_ () 1002mapspace::update_ ()
1791{ 1003{
1792 object *tmp, *last = 0; 1004 object *last = 0;
1793 uint8 flags = 0, light = 0, anywhere = 0; 1005 uint8 flags = P_UPTODATE;
1794 New_Face *top, *floor, *middle; 1006 sint8 light = 0;
1795 object *top_obj, *floor_obj, *middle_obj;
1796 MoveType move_block = 0, move_slow = 0, move_on = 0, move_off = 0, move_allow = 0; 1007 MoveType move_block = 0, move_slow = 0, move_on = 0, move_off = 0, move_allow = 0;
1008 uint64_t volume = 0;
1009 uint32_t items = 0;
1010 object *anywhere = 0;
1011 uint8_t middle_visibility = 0;
1797 1012
1798 middle = blank_face; 1013 //object *middle = 0;
1799 top = blank_face; 1014 //object *top = 0;
1800 floor = blank_face; 1015 //object *floor = 0;
1016 // this seems to generate better code than using locals, above
1017 object *&top = faces_obj[0] = 0;
1018 object *&middle = faces_obj[1] = 0;
1019 object *&floor = faces_obj[2] = 0;
1801 1020
1802 middle_obj = 0; 1021 object::flags_t allflags; // all flags of all objects or'ed together
1803 top_obj = 0;
1804 floor_obj = 0;
1805 1022
1806 for (tmp = bot; tmp; last = tmp, tmp = tmp->above) 1023 for (object *tmp = bot; tmp; last = tmp, tmp = tmp->above)
1807 { 1024 {
1808 /* This could be made additive I guess (two lights better than 1025 // Lights are additive, up to MAX_LIGHT_RADIUS, see los.C)
1809 * one). But if so, it shouldn't be a simple additive - 2
1810 * light bulbs do not illuminate twice as far as once since
1811 * it is a dissapation factor that is cubed.
1812 */
1813 if (tmp->glow_radius > light)
1814 light = tmp->glow_radius; 1026 light += tmp->glow_radius;
1815 1027
1816 /* This call is needed in order to update objects the player 1028 /* This call is needed in order to update objects the player
1817 * is standing in that have animations (ie, grass, fire, etc). 1029 * is standing in that have animations (ie, grass, fire, etc).
1818 * However, it also causes the look window to be re-drawn 1030 * However, it also causes the look window to be re-drawn
1819 * 3 times each time the player moves, because many of the 1031 * 3 times each time the player moves, because many of the
1820 * functions the move_player calls eventualy call this. 1032 * functions the move_player calls eventualy call this.
1821 * 1033 *
1822 * Always put the player down for drawing. 1034 * Always put the player down for drawing.
1823 */ 1035 */
1824 if (!tmp->invisible) 1036 if (expect_true (!tmp->invisible))
1825 { 1037 {
1826 if ((tmp->type == PLAYER || QUERY_FLAG (tmp, FLAG_MONSTER))) 1038 if (expect_false (tmp->type == PLAYER || tmp->flag [FLAG_MONSTER]))
1827 {
1828 top = tmp->face;
1829 top_obj = tmp; 1039 top = tmp;
1830 } 1040 else if (expect_false (tmp->flag [FLAG_IS_FLOOR]))
1831 else if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
1832 { 1041 {
1833 /* If we got a floor, that means middle and top were below it, 1042 /* If we got a floor, that means middle and top were below it,
1834 * so should not be visible, so we clear them. 1043 * so should not be visible, so we clear them.
1835 */ 1044 */
1836 middle = blank_face; 1045 middle = 0;
1837 top = blank_face; 1046 top = 0;
1838 floor = tmp->face;
1839 floor_obj = tmp; 1047 floor = tmp;
1048 volume = 0;
1049 items = 0;
1840 } 1050 }
1841 /* Flag anywhere have high priority */ 1051 else
1842 else if (QUERY_FLAG (tmp, FLAG_SEE_ANYWHERE))
1843 { 1052 {
1844 middle = tmp->face; 1053 if (expect_true (!tmp->flag [FLAG_NO_PICK]))
1054 {
1055 ++items;
1056 volume += tmp->volume ();
1057 }
1845 1058
1846 middle_obj = tmp; 1059 /* Flag anywhere have high priority */
1060 if (expect_false (tmp->flag [FLAG_SEE_ANYWHERE]))
1847 anywhere = 1; 1061 anywhere = tmp;
1062
1063 /* Find the highest visible face around. If equal
1064 * visibilities, we still want the one nearer to the
1065 * top
1066 */
1067 if (expect_false (::faces [tmp->face].visibility >= middle_visibility))
1068 {
1069 middle_visibility = ::faces [tmp->face].visibility;
1070 middle = tmp;
1071 }
1848 } 1072 }
1849 /* Find the highest visible face around. If equal
1850 * visibilities, we still want the one nearer to the
1851 * top
1852 */
1853 else if (middle == blank_face || (tmp->face->visibility > middle->visibility && !anywhere))
1854 {
1855 middle = tmp->face;
1856 middle_obj = tmp;
1857 }
1858 }
1859
1860 if (tmp == tmp->above)
1861 {
1862 LOG (llevError, "Error in structure of map\n");
1863 exit (-1);
1864 } 1073 }
1865 1074
1866 move_slow |= tmp->move_slow; 1075 move_slow |= tmp->move_slow;
1867 move_block |= tmp->move_block; 1076 move_block |= tmp->move_block;
1868 move_on |= tmp->move_on; 1077 move_on |= tmp->move_on;
1869 move_off |= tmp->move_off; 1078 move_off |= tmp->move_off;
1870 move_allow |= tmp->move_allow; 1079 move_allow |= tmp->move_allow;
1871 1080
1872 if (QUERY_FLAG (tmp, FLAG_BLOCKSVIEW)) flags |= P_BLOCKSVIEW; 1081 allflags |= tmp->flag;
1873 if (QUERY_FLAG (tmp, FLAG_NO_MAGIC)) flags |= P_NO_MAGIC; 1082
1874 if (tmp->type == PLAYER) flags |= P_PLAYER; 1083 if (tmp->type == PLAYER) flags |= P_PLAYER;
1875 if (tmp->type == SAFE_GROUND) flags |= P_SAFE; 1084 if (tmp->type == SAFE_GROUND) flags |= P_SAFE;
1876 if (QUERY_FLAG (tmp, FLAG_ALIVE)) flags |= P_IS_ALIVE;
1877 if (QUERY_FLAG (tmp, FLAG_DAMNED)) flags |= P_NO_CLERIC;
1878 } 1085 }
1879 1086
1880 this->light = light; 1087 // FLAG_SEE_ANYWHERE takes precedence
1088 if (anywhere)
1089 middle = anywhere;
1090
1091 // ORing all flags together and checking them here is much faster
1092 if (allflags [FLAG_BLOCKSVIEW]) flags |= P_BLOCKSVIEW;
1093 if (allflags [FLAG_NO_MAGIC] ) flags |= P_NO_MAGIC;
1094 if (allflags [FLAG_ALIVE] ) flags |= P_IS_ALIVE;
1095 if (allflags [FLAG_DAMNED] ) flags |= P_NO_CLERIC;
1096
1097 this->light = min (light, MAX_LIGHT_RADIUS);
1881 this->flags_ = flags; 1098 this->flags_ = flags;
1882 this->move_block = move_block & ~move_allow; 1099 this->move_block = move_block & ~move_allow;
1883 this->move_on = move_on; 1100 this->move_on = move_on;
1884 this->move_off = move_off; 1101 this->move_off = move_off;
1885 this->move_slow = move_slow; 1102 this->move_slow = move_slow;
1103 this->volume_ = (volume + 1023) / 1024;
1104 this->items_ = upos_min (items, 65535); // assume nrof <= 2**31
1886 1105
1887 /* At this point, we have a floor face (if there is a floor), 1106 /* At this point, we have a floor face (if there is a floor),
1888 * and the floor is set - we are not going to touch it at 1107 * and the floor is set - we are not going to touch it at
1889 * this point. 1108 * this point.
1890 * middle contains the highest visibility face. 1109 * middle contains the highest visibility face.
… …
1897 * middle face. This should not happen, as we already have the 1116 * middle face. This should not happen, as we already have the
1898 * else statement above so middle should not get set. OTOH, it 1117 * else statement above so middle should not get set. OTOH, it
1899 * may be possible for the faces to match but be different objects. 1118 * may be possible for the faces to match but be different objects.
1900 */ 1119 */
1901 if (top == middle) 1120 if (top == middle)
1902 middle = blank_face; 1121 middle = 0;
1903 1122
1904 /* There are three posibilities at this point: 1123 /* There are three posibilities at this point:
1905 * 1) top face is set, need middle to be set. 1124 * 1) top face is set, need middle to be set.
1906 * 2) middle is set, need to set top. 1125 * 2) middle is set, need to set top.
1907 * 3) neither middle or top is set - need to set both. 1126 * 3) neither middle or top is set - need to set both.
1908 */ 1127 */
1909 1128
1910 for (tmp = last; tmp; tmp = tmp->below) 1129 for (object *tmp = last; tmp; tmp = tmp->below)
1911 { 1130 {
1912 /* Once we get to a floor, stop, since we already have a floor object */ 1131 /* Once we get to a floor, stop, since we already have a floor object */
1913 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR)) 1132 if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
1914 break; 1133 break;
1915 1134
1916 /* If two top faces are already set, quit processing */ 1135 /* If two top faces are already set, quit processing */
1917 if ((top != blank_face) && (middle != blank_face)) 1136 if (top && middle)
1918 break; 1137 break;
1919 1138
1920 /* Only show visible faces, unless its the editor - show all */ 1139 /* Only show visible faces */
1921 if (!tmp->invisible || editor) 1140 if (!tmp->invisible)
1922 { 1141 {
1923 /* Fill in top if needed */ 1142 /* Fill in top if needed */
1924 if (top == blank_face) 1143 if (!top)
1925 { 1144 {
1926 top = tmp->face;
1927 top_obj = tmp; 1145 top = tmp;
1928 if (top == middle) 1146 if (top == middle)
1929 middle = blank_face; 1147 middle = 0;
1930 } 1148 }
1931 else 1149 else
1932 { 1150 {
1933 /* top is already set - we should only get here if 1151 /* top is already set - we should only get here if
1934 * middle is not set 1152 * middle is not set
1935 * 1153 *
1936 * Set the middle face and break out, since there is nothing 1154 * Set the middle face and break out, since there is nothing
1937 * more to fill in. We don't check visiblity here, since 1155 * more to fill in. We don't check visiblity here, since
1938 * 1156 *
1939 */ 1157 */
1940 if (tmp->face != top) 1158 if (tmp != top)
1941 { 1159 {
1942 middle = tmp->face;
1943 middle_obj = tmp; 1160 middle = tmp;
1944 break; 1161 break;
1945 } 1162 }
1946 } 1163 }
1947 } 1164 }
1948 } 1165 }
1949 1166
1950 if (middle == floor) 1167 if (middle == floor)
1951 middle = blank_face; 1168 middle = 0;
1952 1169
1953 if (top == middle) 1170 if (top == middle)
1954 middle = blank_face; 1171 middle = 0;
1955 1172
1956 faces [0] = top; faces_obj [0] = top != blank_face ? top_obj : 0; 1173#if 0
1957 faces [1] = middle; faces_obj [1] = middle != blank_face ? middle_obj : 0; 1174 faces_obj [0] = top;
1958 faces [2] = floor; faces_obj [2] = floor != blank_face ? floor_obj : 0; 1175 faces_obj [1] = middle;
1176 faces_obj [2] = floor;
1177#endif
1959} 1178}
1960 1179
1961void 1180maptile *
1962set_map_reset_time (maptile *map) 1181maptile::tile_available (int dir, bool load)
1963{ 1182{
1964 int timeout; 1183 if (tile_path[dir])
1184 {
1185 if (tile_map[dir] && (!load || tile_map[dir]->in_memory == MAP_ACTIVE))
1186 return tile_map[dir];
1965 1187
1966 timeout = map->reset_timeout; 1188 if ((tile_map[dir] = find_async (tile_path[dir], this, load)))
1967 if (timeout <= 0) 1189 return tile_map[dir];
1968 timeout = MAP_DEFAULTRESET; 1190 }
1969 if (timeout >= MAP_MAXRESET)
1970 timeout = MAP_MAXRESET;
1971 map->reset_time = time (0) + timeout;
1972}
1973 1191
1974/* this updates the orig_map->tile_map[tile_num] value after loading 1192 return 0;
1975 * the map. It also takes care of linking back the freshly loaded
1976 * maps tile_map values if it tiles back to this one. It returns
1977 * the value of orig_map->tile_map[tile_num]. It really only does this
1978 * so that it is easier for calling functions to verify success.
1979 */
1980
1981static maptile *
1982load_and_link_tiled_map (maptile *orig_map, int tile_num)
1983{
1984 int dest_tile = (tile_num + 2) % 4;
1985 char *path = path_combine_and_normalize (orig_map->path, orig_map->tile_path[tile_num]);
1986
1987 orig_map->tile_map[tile_num] = ready_map_name (path, 0);
1988
1989 /* need to do a strcmp here as the orig_map->path is not a shared string */
1990 if (orig_map->tile_map[tile_num]->tile_path[dest_tile] && !strcmp (orig_map->tile_map[tile_num]->tile_path[dest_tile], orig_map->path))
1991 orig_map->tile_map[tile_num]->tile_map[dest_tile] = orig_map;
1992
1993 return orig_map->tile_map[tile_num];
1994} 1193}
1995 1194
1996/* this returns TRUE if the coordinates (x,y) are out of 1195/* this returns TRUE if the coordinates (x,y) are out of
1997 * map m. This function also takes into account any 1196 * map m. This function also takes into account any
1998 * tiling considerations, loading adjacant maps as needed. 1197 * tiling considerations, loading adjacant maps as needed.
1999 * This is the function should always be used when it 1198 * This is the function should always be used when it
2000 * necessary to check for valid coordinates. 1199 * necessary to check for valid coordinates.
2001 * This function will recursively call itself for the 1200 * This function will recursively call itself for the
2002 * tiled maps. 1201 * tiled maps.
2003 *
2004 *
2005 */ 1202 */
2006int 1203int
2007out_of_map (maptile *m, int x, int y) 1204out_of_map (maptile *m, int x, int y)
2008{ 1205{
2009 /* If we get passed a null map, this is obviously the 1206 /* If we get passed a null map, this is obviously the
… …
2013 if (!m) 1210 if (!m)
2014 return 0; 1211 return 0;
2015 1212
2016 if (x < 0) 1213 if (x < 0)
2017 { 1214 {
2018 if (!m->tile_path[3]) 1215 if (!m->tile_available (3))
2019 return 1; 1216 return 1;
2020 1217
2021 if (!m->tile_map[3] || m->tile_map[3]->in_memory != MAP_IN_MEMORY)
2022 load_and_link_tiled_map (m, 3);
2023
2024 return (out_of_map (m->tile_map[3], x + m->tile_map[3]->width, y)); 1218 return out_of_map (m->tile_map[3], x + m->tile_map[3]->width, y);
2025 } 1219 }
2026 1220
2027 if (x >= m->width) 1221 if (x >= m->width)
2028 { 1222 {
2029 if (!m->tile_path[1]) 1223 if (!m->tile_available (1))
2030 return 1; 1224 return 1;
2031 1225
2032 if (!m->tile_map[1] || m->tile_map[1]->in_memory != MAP_IN_MEMORY)
2033 load_and_link_tiled_map (m, 1);
2034
2035 return (out_of_map (m->tile_map[1], x - m->width, y)); 1226 return out_of_map (m->tile_map[1], x - m->width, y);
2036 } 1227 }
2037 1228
2038 if (y < 0) 1229 if (y < 0)
2039 { 1230 {
2040 if (!m->tile_path[0]) 1231 if (!m->tile_available (0))
2041 return 1; 1232 return 1;
2042 1233
2043 if (!m->tile_map[0] || m->tile_map[0]->in_memory != MAP_IN_MEMORY)
2044 load_and_link_tiled_map (m, 0);
2045
2046 return (out_of_map (m->tile_map[0], x, y + m->tile_map[0]->height)); 1234 return out_of_map (m->tile_map[0], x, y + m->tile_map[0]->height);
2047 } 1235 }
2048 1236
2049 if (y >= m->height) 1237 if (y >= m->height)
2050 { 1238 {
2051 if (!m->tile_path[2]) 1239 if (!m->tile_available (2))
2052 return 1; 1240 return 1;
2053 1241
2054 if (!m->tile_map[2] || m->tile_map[2]->in_memory != MAP_IN_MEMORY)
2055 load_and_link_tiled_map (m, 2);
2056
2057 return (out_of_map (m->tile_map[2], x, y - m->height)); 1242 return out_of_map (m->tile_map[2], x, y - m->height);
2058 } 1243 }
2059 1244
2060 /* Simple case - coordinates are within this local 1245 /* Simple case - coordinates are within this local
2061 * map. 1246 * map.
2062 */ 1247 */
… …
2065 1250
2066/* This is basically the same as out_of_map above, but 1251/* This is basically the same as out_of_map above, but
2067 * instead we return NULL if no map is valid (coordinates 1252 * instead we return NULL if no map is valid (coordinates
2068 * out of bounds and no tiled map), otherwise it returns 1253 * out of bounds and no tiled map), otherwise it returns
2069 * the map as that the coordinates are really on, and 1254 * the map as that the coordinates are really on, and
2070 * updates x and y to be the localized coordinates. 1255 * updates x and y to be the localised coordinates.
2071 * Using this is more efficient of calling out_of_map 1256 * Using this is more efficient of calling out_of_map
2072 * and then figuring out what the real map is 1257 * and then figuring out what the real map is
2073 */ 1258 */
2074maptile * 1259maptile *
2075get_map_from_coord (maptile *m, sint16 * x, sint16 * y) 1260maptile::xy_find (sint16 &x, sint16 &y)
2076{ 1261{
2077
2078 if (*x < 0) 1262 if (x < 0)
2079 { 1263 {
2080 if (!m->tile_path[3]) 1264 if (!tile_available (3))
2081 return 0; 1265 return 0;
2082 if (!m->tile_map[3] || m->tile_map[3]->in_memory != MAP_IN_MEMORY)
2083 load_and_link_tiled_map (m, 3);
2084 1266
2085 *x += m->tile_map[3]->width; 1267 x += tile_map[3]->width;
2086 return (get_map_from_coord (m->tile_map[3], x, y)); 1268 return tile_map[3]->xy_find (x, y);
2087 } 1269 }
2088 1270
2089 if (*x >= m->width) 1271 if (x >= width)
2090 { 1272 {
2091 if (!m->tile_path[1]) 1273 if (!tile_available (1))
2092 return 0; 1274 return 0;
2093 1275
2094 if (!m->tile_map[1] || m->tile_map[1]->in_memory != MAP_IN_MEMORY)
2095 load_and_link_tiled_map (m, 1);
2096
2097 *x -= m->width; 1276 x -= width;
2098 return (get_map_from_coord (m->tile_map[1], x, y)); 1277 return tile_map[1]->xy_find (x, y);
2099 } 1278 }
2100 1279
2101 if (*y < 0) 1280 if (y < 0)
2102 { 1281 {
2103 if (!m->tile_path[0]) 1282 if (!tile_available (0))
2104 return 0; 1283 return 0;
2105 1284
2106 if (!m->tile_map[0] || m->tile_map[0]->in_memory != MAP_IN_MEMORY)
2107 load_and_link_tiled_map (m, 0);
2108
2109 *y += m->tile_map[0]->height; 1285 y += tile_map[0]->height;
2110 return (get_map_from_coord (m->tile_map[0], x, y)); 1286 return tile_map[0]->xy_find (x, y);
2111 } 1287 }
2112 1288
2113 if (*y >= m->height) 1289 if (y >= height)
2114 { 1290 {
2115 if (!m->tile_path[2]) 1291 if (!tile_available (2))
2116 return 0; 1292 return 0;
2117 1293
2118 if (!m->tile_map[2] || m->tile_map[2]->in_memory != MAP_IN_MEMORY)
2119 load_and_link_tiled_map (m, 2);
2120
2121 *y -= m->height; 1294 y -= height;
2122 return (get_map_from_coord (m->tile_map[2], x, y)); 1295 return tile_map[2]->xy_find (x, y);
2123 } 1296 }
2124 1297
2125 /* Simple case - coordinates are within this local 1298 /* Simple case - coordinates are within this local
2126 * map. 1299 * map.
2127 */ 1300 */
2128
2129 return m; 1301 return this;
2130} 1302}
2131 1303
2132/** 1304/**
2133 * Return whether map2 is adjacent to map1. If so, store the distance from 1305 * Return whether map2 is adjacent to map1. If so, store the distance from
2134 * map1 to map2 in dx/dy. 1306 * map1 to map2 in dx/dy.
2135 */ 1307 */
2136static int 1308int
2137adjacent_map (const maptile *map1, const maptile *map2, int *dx, int *dy) 1309adjacent_map (const maptile *map1, const maptile *map2, int *dx, int *dy)
2138{ 1310{
2139 if (!map1 || !map2) 1311 if (!map1 || !map2)
2140 return 0; 1312 return 0;
2141 1313
1314 //TODO: this doesn't actually check correctly when intermediate maps are not loaded
1315 //fix: compare paths instead (this is likely faster, too!)
2142 if (map1 == map2) 1316 if (map1 == map2)
2143 { 1317 {
2144 *dx = 0; 1318 *dx = 0;
2145 *dy = 0; 1319 *dy = 0;
2146
2147 } 1320 }
2148 else if (map1->tile_map[0] == map2) 1321 else if (map1->tile_map[0] == map2)
2149 { /* up */ 1322 { /* up */
2150 *dx = 0; 1323 *dx = 0;
2151 *dy = -map2->height; 1324 *dy = -map2->height;
… …
2162 } 1335 }
2163 else if (map1->tile_map[3] == map2) 1336 else if (map1->tile_map[3] == map2)
2164 { /* left */ 1337 { /* left */
2165 *dx = -map2->width; 1338 *dx = -map2->width;
2166 *dy = 0; 1339 *dy = 0;
2167
2168 } 1340 }
2169 else if (map1->tile_map[0] && map1->tile_map[0]->tile_map[1] == map2) 1341 else if (map1->tile_map[0] && map1->tile_map[0]->tile_map[1] == map2)
2170 { /* up right */ 1342 { /* up right */
2171 *dx = map1->tile_map[0]->width; 1343 *dx = map1->tile_map[0]->width;
2172 *dy = -map1->tile_map[0]->height; 1344 *dy = -map1->tile_map[0]->height;
… …
2203 } 1375 }
2204 else if (map1->tile_map[3] && map1->tile_map[3]->tile_map[2] == map2) 1376 else if (map1->tile_map[3] && map1->tile_map[3]->tile_map[2] == map2)
2205 { /* left down */ 1377 { /* left down */
2206 *dx = -map1->tile_map[3]->width; 1378 *dx = -map1->tile_map[3]->width;
2207 *dy = map1->tile_map[3]->height; 1379 *dy = map1->tile_map[3]->height;
2208
2209 } 1380 }
2210 else 1381 else
2211 { /* not "adjacent" enough */
2212 return 0; 1382 return 0;
2213 }
2214 1383
2215 return 1; 1384 return 1;
1385}
1386
1387maptile *
1388maptile::xy_load (sint16 &x, sint16 &y)
1389{
1390 maptile *map = xy_find (x, y);
1391
1392 if (map)
1393 map->load_sync ();
1394
1395 return map;
1396}
1397
1398maptile *
1399get_map_from_coord (maptile *m, sint16 *x, sint16 *y)
1400{
1401 return m->xy_load (*x, *y);
2216} 1402}
2217 1403
2218/* From map.c 1404/* From map.c
2219 * This is used by get_player to determine where the other 1405 * This is used by get_player to determine where the other
2220 * creature is. get_rangevector takes into account map tiling, 1406 * creature is. get_rangevector takes into account map tiling,
2221 * so you just can not look the the map coordinates and get the 1407 * so you just can not look the the map coordinates and get the
2222 * righte value. distance_x/y are distance away, which 1408 * righte value. distance_x/y are distance away, which
2223 * can be negativbe. direction is the crossfire direction scheme 1409 * can be negative. direction is the crossfire direction scheme
2224 * that the creature should head. part is the part of the 1410 * that the creature should head. part is the part of the
2225 * monster that is closest. 1411 * monster that is closest.
2226 * 1412 *
2227 * get_rangevector looks at op1 and op2, and fills in the 1413 * get_rangevector looks at op1 and op2, and fills in the
2228 * structure for op1 to get to op2. 1414 * structure for op1 to get to op2.
… …
2233 * be unexpected 1419 * be unexpected
2234 * 1420 *
2235 * currently, the only flag supported (0x1) is don't translate for 1421 * currently, the only flag supported (0x1) is don't translate for
2236 * closest body part of 'op1' 1422 * closest body part of 'op1'
2237 */ 1423 */
2238
2239void 1424void
2240get_rangevector (object *op1, object *op2, rv_vector * retval, int flags) 1425get_rangevector (object *op1, object *op2, rv_vector * retval, int flags)
2241{ 1426{
2242 if (!adjacent_map (op1->map, op2->map, &retval->distance_x, &retval->distance_y)) 1427 if (!adjacent_map (op1->map, op2->map, &retval->distance_x, &retval->distance_y))
2243 { 1428 {
2244 /* be conservative and fill in _some_ data */ 1429 /* be conservative and fill in _some_ data */
2245 retval->distance = 100000; 1430 retval->distance = 10000;
2246 retval->distance_x = 32767; 1431 retval->distance_x = 10000;
2247 retval->distance_y = 32767; 1432 retval->distance_y = 10000;
2248 retval->direction = 0; 1433 retval->direction = 0;
2249 retval->part = 0; 1434 retval->part = 0;
2250 } 1435 }
2251 else 1436 else
2252 { 1437 {
… …
2257 1442
2258 best = op1; 1443 best = op1;
2259 /* If this is multipart, find the closest part now */ 1444 /* If this is multipart, find the closest part now */
2260 if (!(flags & 0x1) && op1->more) 1445 if (!(flags & 0x1) && op1->more)
2261 { 1446 {
2262 object *tmp;
2263 int best_distance = retval->distance_x * retval->distance_x + retval->distance_y * retval->distance_y, tmpi; 1447 int best_distance = retval->distance_x * retval->distance_x + retval->distance_y * retval->distance_y, tmpi;
2264 1448
2265 /* we just take the offset of the piece to head to figure 1449 /* we just take the offset of the piece to head to figure
2266 * distance instead of doing all that work above again 1450 * distance instead of doing all that work above again
2267 * since the distance fields we set above are positive in the 1451 * since the distance fields we set above are positive in the
2268 * same axis as is used for multipart objects, the simply arithmetic 1452 * same axis as is used for multipart objects, the simply arithmetic
2269 * below works. 1453 * below works.
2270 */ 1454 */
2271 for (tmp = op1->more; tmp != NULL; tmp = tmp->more) 1455 for (object *tmp = op1->more; tmp; tmp = tmp->more)
2272 { 1456 {
2273 tmpi = (op1->x - tmp->x + retval->distance_x) * (op1->x - tmp->x + retval->distance_x) + 1457 tmpi = (op1->x - tmp->x + retval->distance_x) * (op1->x - tmp->x + retval->distance_x) +
2274 (op1->y - tmp->y + retval->distance_y) * (op1->y - tmp->y + retval->distance_y); 1458 (op1->y - tmp->y + retval->distance_y) * (op1->y - tmp->y + retval->distance_y);
2275 if (tmpi < best_distance) 1459 if (tmpi < best_distance)
2276 { 1460 {
2277 best_distance = tmpi; 1461 best_distance = tmpi;
2278 best = tmp; 1462 best = tmp;
2279 } 1463 }
2280 } 1464 }
1465
2281 if (best != op1) 1466 if (best != op1)
2282 { 1467 {
2283 retval->distance_x += op1->x - best->x; 1468 retval->distance_x += op1->x - best->x;
2284 retval->distance_y += op1->y - best->y; 1469 retval->distance_y += op1->y - best->y;
2285 } 1470 }
2286 } 1471 }
1472
2287 retval->part = best; 1473 retval->part = best;
2288 retval->distance = isqrt (retval->distance_x * retval->distance_x + retval->distance_y * retval->distance_y); 1474 retval->distance = upos_max (abs (retval->distance_x), abs (retval->distance_y));
2289 retval->direction = find_dir_2 (-retval->distance_x, -retval->distance_y); 1475 retval->direction = find_dir_2 (-retval->distance_x, -retval->distance_y);
2290 } 1476 }
2291} 1477}
2292 1478
2293/* this is basically the same as get_rangevector above, but instead of 1479/* this is basically the same as get_rangevector above, but instead of
… …
2298 * flags has no meaning for this function at this time - I kept it in to 1484 * flags has no meaning for this function at this time - I kept it in to
2299 * be more consistant with the above function and also in case they are needed 1485 * be more consistant with the above function and also in case they are needed
2300 * for something in the future. Also, since no object is pasted, the best 1486 * for something in the future. Also, since no object is pasted, the best
2301 * field of the rv_vector is set to NULL. 1487 * field of the rv_vector is set to NULL.
2302 */ 1488 */
2303
2304void 1489void
2305get_rangevector_from_mapcoord (const maptile *m, int x, int y, const object *op2, rv_vector * retval, int flags) 1490get_rangevector_from_mapcoord (const maptile *m, int x, int y, const object *op2, rv_vector *retval, int flags)
2306{ 1491{
2307 if (!adjacent_map (m, op2->map, &retval->distance_x, &retval->distance_y)) 1492 if (!adjacent_map (m, op2->map, &retval->distance_x, &retval->distance_y))
2308 { 1493 {
2309 /* be conservative and fill in _some_ data */ 1494 /* be conservative and fill in _some_ data */
2310 retval->distance = 100000; 1495 retval->distance = 100000;
… …
2316 else 1501 else
2317 { 1502 {
2318 retval->distance_x += op2->x - x; 1503 retval->distance_x += op2->x - x;
2319 retval->distance_y += op2->y - y; 1504 retval->distance_y += op2->y - y;
2320 1505
2321 retval->part = NULL; 1506 retval->part = 0;
2322 retval->distance = isqrt (retval->distance_x * retval->distance_x + retval->distance_y * retval->distance_y); 1507 retval->distance = upos_max (abs (retval->distance_x), abs (retval->distance_y));
2323 retval->direction = find_dir_2 (-retval->distance_x, -retval->distance_y); 1508 retval->direction = find_dir_2 (-retval->distance_x, -retval->distance_y);
2324 } 1509 }
2325} 1510}
2326 1511
2327/* Returns true of op1 and op2 are effectively on the same map 1512/* Returns true of op1 and op2 are effectively on the same map
2328 * (as related to map tiling). Note that this looks for a path from 1513 * (as related to map tiling). Note that this looks for a path from
2329 * op1 to op2, so if the tiled maps are assymetric and op2 has a path 1514 * op1 to op2, so if the tiled maps are asymetric and op2 has a path
2330 * to op1, this will still return false. 1515 * to op1, this will still return false.
2331 * Note we only look one map out to keep the processing simple 1516 * Note we only look one map out to keep the processing simple
2332 * and efficient. This could probably be a macro. 1517 * and efficient. This could probably be a macro.
2333 * MSW 2001-08-05 1518 * MSW 2001-08-05
2334 */ 1519 */
… …
2338 int dx, dy; 1523 int dx, dy;
2339 1524
2340 return adjacent_map (op1->map, op2->map, &dx, &dy); 1525 return adjacent_map (op1->map, op2->map, &dx, &dy);
2341} 1526}
2342 1527
1528//-GPL
1529
2343object * 1530object *
2344maptile::insert (object *op, int x, int y, object *originator, int flags) 1531maptile::insert (object *op, int x, int y, object *originator, int flags)
2345{ 1532{
2346 if (!op->flag [FLAG_REMOVED])
2347 op->remove ();
2348
2349 return insert_ob_in_map_at (op, this, originator, flags, x, y); 1533 return insert_ob_in_map_at (op, this, originator, flags, x, y);
2350} 1534}
2351 1535
1536region *
1537maptile::region (int x, int y) const
1538{
1539 if (regions
1540 && regionmap
1541 && !OUT_OF_REAL_MAP (this, x, y))
1542 if (struct region *reg = regionmap [regions [y * width + x]])
1543 return reg;
1544
1545 if (default_region)
1546 return default_region;
1547
1548 return ::region::default_region ();
1549}
1550
1551//+GPL
1552
1553/* picks a random object from a style map.
1554 */
1555object *
1556maptile::pick_random_object (rand_gen &gen) const
1557{
1558 /* while returning a null object will result in a crash, that
1559 * is actually preferable to an infinite loop. That is because
1560 * most servers will automatically restart in case of crash.
1561 * Change the logic on getting the random space - shouldn't make
1562 * any difference, but this seems clearer to me.
1563 */
1564 for (int i = 1000; --i;)
1565 {
1566 object *pick = at (gen (width), gen (height)).bot;
1567
1568 // do not prefer big monsters just because they are big.
1569 if (pick && pick->is_head ())
1570 return pick->head_ ();
1571 }
1572
1573 // instead of crashing in the unlikely(?) case, try to return *something*
1574 return archetype::find (shstr_bug);
1575}
1576
1577//-GPL
1578
1579void
1580maptile::play_sound (faceidx sound, int x, int y) const
1581{
1582 if (!sound)
1583 return;
1584
1585 for_all_players_on_map (pl, this)
1586 if (client *ns = pl->ns)
1587 {
1588 int dx = x - pl->ob->x;
1589 int dy = y - pl->ob->y;
1590
1591 int distance = idistance (dx, dy);
1592
1593 if (distance <= MAX_SOUND_DISTANCE)
1594 ns->play_sound (sound, dx, dy);
1595 }
1596}
1597
1598void
1599maptile::say_msg (const char *msg, int x, int y) const
1600{
1601 for_all_players (pl)
1602 if (client *ns = pl->ns)
1603 {
1604 int dx = x - pl->ob->x;
1605 int dy = y - pl->ob->y;
1606
1607 int distance = idistance (dx, dy);
1608
1609 if (distance <= MAX_SOUND_DISTANCE)
1610 ns->send_msg (NDI_GREY | NDI_DEF, SAY_CHANNEL, msg);
1611 }
1612}
1613
1614static void
1615split_to_tiles (dynbuf &buf, maptile *m, int x0, int y0, int x1, int y1, int dx, int dy)
1616{
1617 // clip to map to the left
1618 if (x0 < 0)
1619 {
1620 if (maptile *tile = m->tile_available (TILE_LEFT, 1))
1621 split_to_tiles (buf, tile, x0 + tile->width, y0, min (x1 + tile->width, tile->width), y1, dx - tile->width, dy);
1622
1623 if (x1 < 0) // entirely to the left
1624 return;
1625
1626 x0 = 0;
1627 }
1628
1629 // clip to map to the right
1630 if (x1 > m->width)
1631 {
1632 if (maptile *tile = m->tile_available (TILE_RIGHT, 1))
1633 split_to_tiles (buf, tile, max (x0 - m->width, 0), y0, x1 - m->width, y1, dx + m->width, dy);
1634
1635 if (x0 > m->width) // entirely to the right
1636 return;
1637
1638 x1 = m->width;
1639 }
1640
1641 // clip to map above
1642 if (y0 < 0)
1643 {
1644 if (maptile *tile = m->tile_available (TILE_UP, 1))
1645 split_to_tiles (buf, tile, x0, y0 + tile->height, x1, min (y1 + tile->height, tile->height), dx, dy - tile->height);
1646
1647 if (y1 < 0) // entirely above
1648 return;
1649
1650 y0 = 0;
1651 }
1652
1653 // clip to map below
1654 if (y1 > m->height)
1655 {
1656 if (maptile *tile = m->tile_available (TILE_DOWN, 1))
1657 split_to_tiles (buf, tile, x0, max (y0 - m->height, 0), x1, y1 - m->height, dx, dy + m->height);
1658
1659 if (y0 > m->height) // entirely below
1660 return;
1661
1662 y1 = m->height;
1663 }
1664
1665 // if we get here, the rect is within the current map
1666 maprect *r = (maprect *)buf.alloc (sizeof (maprect));
1667
1668 r->m = m;
1669 r->x0 = x0;
1670 r->y0 = y0;
1671 r->x1 = x1;
1672 r->y1 = y1;
1673 r->dx = dx;
1674 r->dy = dy;
1675}
1676
1677maprect *
1678maptile::split_to_tiles (int x0, int y0, int x1, int y1)
1679{
1680 static dynbuf buf (sizeof (maprect) * 8, sizeof (maprect) * 8);
1681 buf.clear ();
1682
1683 ::split_to_tiles (buf, this, x0, y0, x1, y1, 0, 0);
1684
1685 // add end marker
1686 maprect *r = (maprect *)buf.alloc (sizeof (maprect));
1687 r->m = 0;
1688
1689 return (maprect *)buf.linearise ();
1690}
1691

Diff Legend

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