ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/common/map.C
Revision: 1.27
Committed: Fri Sep 8 12:56:42 2006 UTC (17 years, 9 months ago) by root
Content type: text/plain
Branch: MAIN
Changes since 1.26: +3 -4 lines
Log Message:
c++ification

File Contents

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