Crossfire Server, Trunk  1.75.0
map.cpp
Go to the documentation of this file.
1 /*
2  * Crossfire -- cooperative multi-player graphical RPG and adventure game
3  *
4  * Copyright (c) 1999-2014 Mark Wedel and the Crossfire Development Team
5  * Copyright (c) 1992 Frank Tore Johansen
6  *
7  * Crossfire is free software and comes with ABSOLUTELY NO WARRANTY. You are
8  * welcome to redistribute it under certain conditions. For details, please
9  * see COPYING and LICENSE.
10  *
11  * The authors can be reached via e-mail at <crossfire@metalforge.org>.
12  */
13 
19 #include "global.h"
20 
21 #include <ctype.h>
22 #include <errno.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <sys/stat.h>
27 #include <math.h>
28 
29 #ifndef WIN32 /* ---win32 exclude header */
30 #include <unistd.h>
31 #endif /* win32 */
32 
33 #include "sproto.h"
34 #include "loader.h"
35 #include "output_file.h"
36 #include "path.h"
37 #include "stats.h"
38 
39 static void free_all_objects(mapstruct *m);
40 
46 const char *const map_layer_name[MAP_LAYERS] = {
47  "floor", "no_pick", "no_pick", "item", "item",
48  "item", "living", "living", "fly", "fly"
49 };
50 
53  uint8_t high_layer;
54  uint8_t honor_visibility;
55 };
56 
64  { MAP_LAYER_FLOOR, 1 },
66  { MAP_LAYER_ITEM3, 1 }, { MAP_LAYER_ITEM3, 1 }, { MAP_LAYER_ITEM3, 1 },
67  { MAP_LAYER_LIVING2, 1 }, { MAP_LAYER_LIVING2, 1 },
68  { MAP_LAYER_FLY2, 1 }, { MAP_LAYER_FLY2, 1 }
69 };
70 
80  mapstruct *map;
81 
82  if (!name || !*name)
83  return NULL;
84 
85  for (map = first_map; map; map = map->next)
86  if (!strcmp(name, map->path))
87  break;
88  return (map);
89 }
90 
104 char *create_pathname(const char *name, char *buf, size_t size) {
105  /* Why? having extra / doesn't confuse unix anyplace? Dependancies
106  * someplace else in the code? msw 2-17-97
107  */
108  if (*name == '/')
109  snprintf(buf, size, "%s/%s%s", settings.datadir, settings.mapdir, name);
110  else
111  snprintf(buf, size, "%s/%s/%s", settings.datadir, settings.mapdir, name);
112  return buf;
113 }
114 
125 void create_overlay_pathname(const char *name, char *buf, size_t size) {
126  /* Why? having extra / doesn't confuse unix anyplace? Dependancies
127  * someplace else in the code? msw 2-17-97
128  */
129  if (*name == '/')
130  snprintf(buf, size, "%s/%s%s", settings.localdir, settings.mapdir, name);
131  else
132  snprintf(buf, size, "%s/%s/%s", settings.localdir, settings.mapdir, name);
133 }
134 
145 void create_template_pathname(const char *name, char *buf, size_t size) {
146  /* Why? having extra / doesn't confuse unix anyplace? Dependancies
147  * someplace else in the code? msw 2-17-97
148  */
149  if (*name == '/')
150  snprintf(buf, size, "%s/%s%s", settings.localdir, settings.templatedir, name);
151  else
152  snprintf(buf, size, "%s/%s/%s", settings.localdir, settings.templatedir, name);
153 }
154 
166 static void create_items_path(const char *s, char *buf, size_t size) {
167  char *t;
168 
169  if (*s == '/')
170  s++;
171 
172  snprintf(buf, size, "%s/%s/", settings.localdir, settings.uniquedir);
173  t = buf+strlen(buf);
174  snprintf(t, buf+size-t, "%s", s);
175 
176  while (*t != '\0') {
177  if (*t == '/')
178  *t = '@';
179  t++;
180  }
181 }
182 
201 int check_path(const char *name, int prepend_dir) {
202  char buf[MAX_BUF];
203 #ifndef WIN32
204  struct stat statbuf;
205  int mode = 0;
206 #endif
207 
208  if (prepend_dir)
210  else
211  strlcpy(buf, name, sizeof(buf));
212 #ifdef WIN32 /* ***win32: check this sucker in windows style. */
213  return(_access(buf, 0));
214 #else
215 
216  if (stat(buf, &statbuf) != 0)
217  return -1;
218 
219  if (!S_ISREG(statbuf.st_mode))
220  return (-1);
221 
222  if (((statbuf.st_mode&S_IRGRP) && getegid() == statbuf.st_gid)
223  || ((statbuf.st_mode&S_IRUSR) && geteuid() == statbuf.st_uid)
224  || (statbuf.st_mode&S_IROTH))
225  mode |= 4;
226 
227  if ((statbuf.st_mode&S_IWGRP && getegid() == statbuf.st_gid)
228  || (statbuf.st_mode&S_IWUSR && geteuid() == statbuf.st_uid)
229  || (statbuf.st_mode&S_IWOTH))
230  mode |= 2;
231 
232  return (mode);
233 #endif
234 }
235 
245 void dump_map(const mapstruct *m) {
246  LOG(llevError, "Map %s status: %d.\n", m->path, m->in_memory);
247  LOG(llevError, "Size: %dx%d Start: %d,%d\n", MAP_WIDTH(m), MAP_HEIGHT(m), MAP_ENTER_X(m), MAP_ENTER_Y(m));
248 
249  if (m->msg != NULL)
250  LOG(llevError, "Message:\n%s", m->msg);
251 
252  if (m->maplore != NULL)
253  LOG(llevError, "Lore:\n%s", m->maplore);
254 
255  if (m->tmpname != NULL)
256  LOG(llevError, "Tmpname: %s\n", m->tmpname);
257 
258  LOG(llevError, "Difficulty: %d\n", m->difficulty);
259  LOG(llevError, "Darkness: %d\n", m->darkness);
260 }
261 
268 void dump_all_maps(void) {
269  mapstruct *m;
270 
271  for (m = first_map; m != NULL; m = m->next) {
272  dump_map(m);
273  }
274 }
275 
300 int get_map_flags(mapstruct *oldmap, mapstruct **newmap, int16_t x, int16_t y, int16_t *nx, int16_t *ny) {
301  int retval = 0;
302  mapstruct *mp;
303 
304  /*
305  * Since x and y are copies of the original values, we can directly
306  * mess with them here.
307  */
308  mp = get_map_from_coord(oldmap, &x, &y);
309  if (!mp)
310  return P_OUT_OF_MAP;
311  if (mp != oldmap)
312  retval |= P_NEW_MAP;
313  if (newmap)
314  *newmap = mp;
315  if (nx)
316  *nx = x;
317  if (ny)
318  *ny = y;
319  retval |= mp->spaces[x+mp->width*y].flags;
320  return retval;
321 }
322 
327 bool ob_move_block(object *ob1, object *ob2) {
328  // Special case: if ob1 has no move type, but we're here, then we're being
329  // pushed by something. Assume "walk".
330  return ((ob1->move_type ? ob1->move_type : MOVE_WALK) & ~ob2->move_block) == 0;
331 }
332 
354 int blocked_link(object *ob, mapstruct *m, int16_t sx, int16_t sy) {
355  object *tmp_head;
356  int mflags, blocked;
357 
358  /* Make sure the coordinates are valid - they should be, as caller should
359  * have already checked this.
360  */
361  if (OUT_OF_REAL_MAP(m, sx, sy)) {
362  LOG(llevError, "blocked_link: Passed map, x, y coordinates outside of map\n");
363  return 1;
364  }
365 
366  /* special hack for transports: if it's a transport with a move_type of 0, it can do on the space anyway */
367  if (ob->type == TRANSPORT && ob->move_type == 0)
368  return 0;
369 
370  mflags = m->spaces[sx+m->width*sy].flags;
371 
372  blocked = GET_MAP_MOVE_BLOCK(m, sx, sy);
373 
374  /* If space is currently not blocked by anything, no need to
375  * go further. Not true for players - all sorts of special
376  * things we need to do for players.
377  */
378  if (ob->type != PLAYER && !(mflags&P_IS_ALIVE) && (blocked == 0))
379  return 0;
380 
381  /* if there isn't anytyhing alive on this space, and this space isn't
382  * otherwise blocked, we can return now. Only if there is a living
383  * creature do we need to investigate if it is part of this creature
384  * or another. Likewise, only if something is blocking us do we
385  * need to investigate if there is a special circumstance that would
386  * let the player through (inventory checkers for example)
387  */
388  if (!(mflags&P_IS_ALIVE) && !OB_TYPE_MOVE_BLOCK(ob, blocked))
389  return 0;
390 
391  ob = HEAD(ob);
392 
393  /* We basically go through the stack of objects, and if there is
394  * some other object that has NO_PASS or FLAG_ALIVE set, return
395  * true. If we get through the entire stack, that must mean
396  * ob is blocking it, so return 0.
397  */
398  FOR_MAP_PREPARE(m, sx, sy, tmp) {
399  /* Never block part of self. */
400  tmp_head = HEAD(tmp);
401  if (tmp_head == ob)
402  continue;
403  /* This must be before the checks below. Code for inventory checkers. */
404  if (tmp->type == CHECK_INV && OB_MOVE_BLOCK(ob, tmp)) {
405  /* If last_sp is set, the player/monster needs an object,
406  * so we check for it. If they don't have it, they can't
407  * pass through this space.
408  */
409  if (tmp->last_sp) {
410  if (check_inv_recursive(ob, tmp) == NULL) {
411  if (tmp->msg) {
412  /* Optionally display the reason why one cannot move
413  * there. Note: emitting a message from this function
414  * is not very elegant. Ideally, this should be done
415  * somewhere in server/player.c, but this is difficult
416  * for objects of type CHECK_INV that are not alive.
417  */
420  tmp->msg);
421  }
422  return 1;
423  }
424  } else {
425  /* In this case, the player must not have the object -
426  * if they do, they can't pass through.
427  */
428  if (check_inv_recursive(ob, tmp) != NULL) {
429  if (tmp->msg) {
432  tmp->msg);
433  }
434  return 1;
435  }
436  }
437  } /* if check_inv */
438  else {
439  /* Broke apart a big nasty if into several here to make
440  * this more readable. first check - if the space blocks
441  * movement, can't move here.
442  * second - if a monster, can't move there, unless it is a
443  * hidden dm
444  */
445  if (OB_MOVE_BLOCK(ob, tmp))
446  return 1;
447  if (QUERY_FLAG(tmp, FLAG_ALIVE)
448  && tmp->head != ob
449  && tmp != ob
450  && tmp->type != DOOR
451  && !(QUERY_FLAG(tmp, FLAG_WIZ) && tmp->contr->hidden))
452  return 1;
453  }
454  } FOR_MAP_FINISH();
455  return 0;
456 }
457 
489 int ob_blocked(const object *ob, mapstruct *m, int16_t x, int16_t y) {
490  archetype *tmp;
491  int flag;
492  mapstruct *m1;
493  int16_t sx, sy;
494  const object *part;
495 
496  if (ob == NULL) {
497  flag = get_map_flags(m, &m1, x, y, &sx, &sy);
498  if (flag&P_OUT_OF_MAP)
499  return P_OUT_OF_MAP;
500 
501  /* don't have object, so don't know what types would block */
502  return(GET_MAP_MOVE_BLOCK(m1, sx, sy));
503  }
504 
505  for (tmp = ob->arch, part = ob; tmp != NULL; tmp = tmp->more, part = part->more) {
506  flag = get_map_flags(m, &m1, x+tmp->clone.x, y+tmp->clone.y, &sx, &sy);
507 
508  if (flag&P_OUT_OF_MAP)
509  return P_OUT_OF_MAP;
510  if (flag&P_IS_ALIVE)
511  return P_IS_ALIVE;
512 
513  /* object_find_first_free_spot() calls this function. However, often
514  * ob doesn't have any move type (when used to place exits)
515  * so the AND operation in OB_TYPE_MOVE_BLOCK doesn't work.
516  */
517 
518  if (ob->move_type == 0 && GET_MAP_MOVE_BLOCK(m1, sx, sy) != MOVE_ALL)
519  continue;
520 
521  /* A transport without move_type for a part should go through everything for that part. */
522  if (ob->type == TRANSPORT && part->move_type == 0)
523  continue;
524 
525  /* Note it is intentional that we check ob - the movement type of the
526  * head of the object should correspond for the entire object.
527  */
528  if (OB_TYPE_MOVE_BLOCK(ob, GET_MAP_MOVE_BLOCK(m1, sx, sy)))
529  return AB_NO_PASS;
530  }
531  return 0;
532 }
533 
544 static void fix_container_multipart(object *container) {
545  FOR_INV_PREPARE(container, tmp) {
546  archetype *at;
547  object *op, *last;
548 
549  if (tmp->inv)
551  /* already multipart, or non-multipart arch - don't do anything more */
552  for (at = tmp->arch->more, last = tmp; at != NULL; at = at->more, last = op) {
553  /* FIXME: We can't reuse object_fix_multipart() since that only
554  * works for items directly on maps. Maybe factor out common code?
555  */
556  op = arch_to_object(at);
557  op->head = tmp;
558  op->env = tmp->env;
559  last->more = op;
560  if (tmp->name != op->name) {
561  if (op->name)
562  free_string(op->name);
563  op->name = add_string(tmp->name);
564  }
565  if (tmp->title != op->title) {
566  if (op->title)
567  free_string(op->title);
568  op->title = add_string(tmp->title);
569  }
571  }
572  } FOR_INV_FINISH();
573 }
574 
586  int x, y;
587 
588  for (x = 0; x < MAP_WIDTH(m); x++)
589  for (y = 0; y < MAP_HEIGHT(m); y++)
590  FOR_MAP_PREPARE(m, x, y, tmp) {
591  if (tmp->inv)
593 
594  /* already multipart - don't do anything more */
595  if (tmp->head || tmp->more)
596  continue;
597 
599  } FOR_MAP_FINISH(); /* for objects on this space */
600 }
601 
613 void load_objects(mapstruct *m, FILE *fp, int mapflags) {
614  int i, j, bufstate = LO_NEWFILE;
615  int unique;
616  object *op, *prev = NULL, *last_more = NULL;
617 
618  op = object_new();
619  op->map = m; /* To handle buttons correctly */
620 
621  PROFILE_BEGIN();
622  while ((i = load_object(fp, op, bufstate, mapflags, false))) {
623  /* Since the loading of the map header does not load an object
624  * anymore, we need to pass LO_NEWFILE for the first object loaded,
625  * and then switch to LO_REPEAT for faster loading.
626  */
627  bufstate = LO_REPEAT;
628 
629  /* if the archetype for the object is null, means that we
630  * got an invalid object. Don't do anything with it - the game
631  * or editor will not be able to do anything with it either.
632  */
633  if (op->arch == NULL) {
634  LOG(llevDebug, "Discarding object without arch: %s\n", op->name ? op->name : "(null)");
635  continue;
636  }
637 
638  /*
639  * You can NOT have players on a map being loaded.
640  * Trying to use such a type leads to crashes everywhere as op->contr is NULL.
641  */
642  if (op->type == PLAYER) {
643  LOG(llevError, "Discarding invalid item with type PLAYER in map %s\n", m->path);
644  continue;
645  }
646 
647  /* don't use out_of_map because we don't want to consider tiling properties, we're loading a single map */
648  if (OUT_OF_REAL_MAP(m, op->x, op->y)) {
649  LOG(llevError, " object %s not on valid map position %s:%d:%d\n", op->name ? op->name : "(null)", m->path, op->x, op->y);
650  if (op->x < 0) {
651  op->x = 0;
652  } else if (op->x >= MAP_WIDTH(m)) {
653  op->x = MAP_WIDTH(m) - 1;
654  }
655  if (op->y < 0) {
656  op->y = 0;
657  } else if (op->y >= MAP_HEIGHT(m)) {
658  op->y = MAP_HEIGHT(m) - 1;
659  }
660  }
661 
662  switch (i) {
663  case LL_NORMAL:
664  /* if we are loading an overlay, put the floors on the bottom */
666  && mapflags&MAP_OVERLAY)
668  else
670 
671  if (op->inv)
672  object_sum_weight(op);
673 
674  prev = op,
675  last_more = op;
676  break;
677 
678  case LL_MORE:
680  op->head = prev,
681  last_more->more = op,
682  last_more = op;
683  break;
684  }
685  if (mapflags&MAP_STYLE) {
687  }
688  op = object_new();
689  op->map = m;
690  }
691  PROFILE_END(diff, LOG(llevDebug,
692  "load_objects on %s took %ld us\n", m->path, diff));
693  for (i = 0; i < m->width; i++) {
694  for (j = 0; j < m->height; j++) {
695  unique = 0;
696  /* check for unique items, or unique squares */
697  FOR_MAP_PREPARE(m, i, j, otmp) {
698  if (QUERY_FLAG(otmp, FLAG_UNIQUE))
699  unique = 1;
700  if (!(mapflags&(MAP_OVERLAY|MAP_PLAYER_UNIQUE) || unique))
702  } FOR_MAP_FINISH();
703  }
704  }
707 }
708 
725 int save_objects(mapstruct *m, FILE *fp, FILE *fp2, int flag) {
726  int i, j = 0, unique = 0;
727  unsigned int count = 0;
728 
731 
732  long serialize_time, write_time;
733 
734  PROFILE_BEGIN();
735 
736  for (i = 0; i < MAP_WIDTH(m); i++) {
737  for (j = 0; j < MAP_HEIGHT(m); j++) {
738  unique = 0;
739  FOR_MAP_PREPARE(m, i, j, op) {
741  unique = 1;
742 
743  if (op->type == PLAYER) {
744  LOG(llevDebug, "Player on map that is being saved\n");
745  continue;
746  }
747 
748  if (op->head || object_get_owner(op) != NULL)
749  continue;
750 
751  if (unique || QUERY_FLAG(op, FLAG_UNIQUE)) {
753  count++ ;
754  } else if (flag == 0
755  || (flag == SAVE_FLAG_NO_REMOVE && (!QUERY_FLAG(op, FLAG_OBJ_ORIGINAL) && !QUERY_FLAG(op, FLAG_UNPAID)))) {
757  count++;
758  }
759  } FOR_MAP_FINISH(); /* for this space */
760  } /* for this j */
761  }
762  PROFILE_END(diff, serialize_time = diff);
763 
764  PROFILE_BEGIN();
765  char *cp = stringbuffer_finish(sb);
766  char *cp2 = stringbuffer_finish(sb2);
767  fputs(cp, fp);
768  fputs(cp2, fp2);
769  free(cp);
770  free(cp2);
771  PROFILE_END(diff, write_time = diff);
772 
773  LOG(llevDebug, "saved %d objects on %s (%ld us serializing, %ld us writing)\n", count, m->path, serialize_time, write_time);
774  return 0;
775 }
776 
787  mapstruct *map = static_cast<mapstruct *>(calloc(1, sizeof(mapstruct)));
788  /* mapstruct *mp;*/
789 
790  if (map == NULL)
792 
793  map->next = first_map;
794  first_map = map;
795 
796  map->in_memory = MAP_SWAPPED;
797 
798  MAP_WIDTH(map) = 16;
799  MAP_HEIGHT(map) = 16;
800  MAP_RESET_TIMEOUT(map) = 0;
801  MAP_ENTER_X(map) = 0;
802  MAP_ENTER_Y(map) = 0;
803  map->last_reset_time = 0;
804  return map;
805 }
806 
808 uint32_t map_size(mapstruct *m) {
809  return (uint32_t)m->width * (uint32_t)m->height;
810 }
811 
823  m->in_memory = MAP_IN_MEMORY;
824  /* Log this condition and free the storage. We could I suppose
825  * realloc, but if the caller is presuming the data will be intact,
826  * that is their poor assumption.
827  */
828  if (m->spaces) {
829  LOG(llevError, "allocate_map called with already allocated map (%s)\n", m->path);
830  free(m->spaces);
831  }
832 
833  m->spaces = static_cast<MapSpace *>(calloc(map_size(m), sizeof(MapSpace)));
834 
835  if (m->spaces == NULL)
837 }
838 
852 mapstruct *get_empty_map(int sizex, int sizey) {
854  m->width = sizex;
855  m->height = sizey;
856  m->in_memory = MAP_SWAPPED;
857  allocate_map(m);
858  return m;
859 }
860 
874 static shopitems *parse_shop_string(const char *input_string, const mapstruct *map) {
875  char *shop_string, *p, *q, *next_semicolon, *next_colon;
876  shopitems *items = NULL;
877  int i = 0, number_of_entries = 0;
878  const typedata *current_type;
879 
880  shop_string = strdup_local(input_string);
881  p = shop_string;
882  /* first we'll count the entries, we'll need that for allocating the array shortly */
883  while (p) {
884  p = strchr(p, ';');
885  number_of_entries++;
886  if (p)
887  p++;
888  }
889  p = shop_string;
890  strip_endline(p);
891  items = static_cast<shopitems *>(CALLOC(number_of_entries+1, sizeof(shopitems)));
892  /*
893  * The memset would always set at least one byte to zero,
894  * so a failed calloc would have segfaulted the program.
895  * Instead, check for a null and fail more gracefully.
896  */
897  if (!items)
899 
900  for (i = 0; i < number_of_entries; i++) {
901  if (!p) {
902  LOG(llevError, "parse_shop_string: I seem to have run out of string, that shouldn't happen.\n");
903  break;
904  }
905  next_semicolon = strchr(p, ';');
906  next_colon = strchr(p, ':');
907  /* if there is a stregth specified, figure out what it is, we'll need it soon. */
908  if (next_colon && (!next_semicolon || next_colon < next_semicolon))
909  items[i].strength = atoi(strchr(p, ':')+1);
910 
911  if (isdigit(*p) || *p == '*') {
912  items[i].typenum = *p == '*' ? -1 : atoi(p);
913  current_type = get_typedata(items[i].typenum);
914  if (current_type) {
915  items[i].name = current_type->name;
916  items[i].name_pl = current_type->name_pl;
917  }
918  } else { /*we have a named type, let's figure out what it is */
919  q = strpbrk(p, ";:");
920  if (q)
921  *q = '\0';
922 
923  current_type = get_typedata_by_name(p);
924  if (current_type) {
925  items[i].name = current_type->name;
926  items[i].typenum = current_type->number;
927  items[i].name_pl = current_type->name_pl;
928  } else {
929  /* oh uh, something's wrong, let's free up this one, and try
930  * the next entry while we're at it, better print a warning */
931  LOG(llevError, "invalid type %s defined in shopitems for %s in string %s\n", p, map->name, input_string);
932  }
933  }
934  items[i].index = number_of_entries;
935  if (next_semicolon)
936  p = ++next_semicolon;
937  else
938  p = NULL;
939  }
940  free(shop_string);
941  return items;
942 }
943 
955 static void print_shop_string(mapstruct *m, char *output_string, int size) {
956  int i;
957  char tmp[MAX_BUF];
958 
959  output_string[0] = '\0';
960  for (i = 0; i < m->shopitems[0].index; i++) {
961  if (m->shopitems[i].typenum != -1) {
962  if (m->shopitems[i].strength) {
963  snprintf(tmp, sizeof(tmp), "%s:%d;", m->shopitems[i].name, m->shopitems[i].strength);
964  } else
965  snprintf(tmp, sizeof(tmp), "%s;", m->shopitems[i].name);
966  } else {
967  if (m->shopitems[i].strength) {
968  snprintf(tmp, sizeof(tmp), "*:%d;", m->shopitems[i].strength);
969  } else
970  snprintf(tmp, sizeof(tmp), "*;");
971  }
972  snprintf(output_string+strlen(output_string), size-strlen(output_string), "%s", tmp);
973  }
974 
975  /* erase final ; else parsing back will lead to issues */
976  if (strlen(output_string) > 0) {
977  output_string[strlen(output_string) - 1] = '\0';
978  }
979 }
980 
997 static int load_map_header(FILE *fp, mapstruct *m) {
998  char buf[HUGE_BUF], *key = NULL, *value;
999 
1000  m->width = m->height = 0;
1001  while (fgets(buf, sizeof(buf), fp) != NULL) {
1002  char *p;
1003 
1004  p = strchr(buf, '\n');
1005  if (p == NULL) {
1006  LOG(llevError, "Error loading map header - did not find a newline - perhaps file is truncated? Buf=%s\n", buf);
1007  return 1;
1008  }
1009  *p = '\0';
1010 
1011  key = buf;
1012  while (isspace(*key))
1013  key++;
1014  if (*key == 0)
1015  continue; /* empty line */
1016  value = strchr(key, ' ');
1017  if (value) {
1018  *value = 0;
1019  value++;
1020  while (isspace(*value)) {
1021  value++;
1022  if (*value == '\0') {
1023  /* Nothing but spaces. */
1024  value = NULL;
1025  break;
1026  }
1027  }
1028  }
1029 
1030  /* key is the field name, value is what it should be set
1031  * to. We've already done the work to null terminate key,
1032  * and strip off any leading spaces for both of these.
1033  * We have not touched the newline at the end of the line -
1034  * these are needed for some values. the end pointer
1035  * points to the first of the newlines.
1036  * value could be NULL! It would be easy enough to just point
1037  * this to "" to prevent cores, but that would let more errors slide
1038  * through.
1039  *
1040  * First check for entries that do not use the value parameter, then
1041  * validate that value is given and check for the remaining entries
1042  * that use the parameter.
1043  */
1044 
1045  if (!strcmp(key, "msg")) {
1046  char msgbuf[HUGE_BUF];
1047  int msgpos = 0;
1048 
1049  while (fgets(buf, sizeof(buf), fp) != NULL) {
1050  if (!strcmp(buf, "endmsg\n"))
1051  break;
1052  else {
1053  snprintf(msgbuf+msgpos, sizeof(msgbuf)-msgpos, "%s", buf);
1054  msgpos += strlen(buf);
1055  }
1056  }
1057  /* There are lots of maps that have empty messages (eg, msg/endmsg
1058  * with nothing between). There is no reason in those cases to
1059  * keep the empty message. Also, msgbuf contains garbage data
1060  * when msgpos is zero, so copying it results in crashes
1061  */
1062  if (msgpos != 0) {
1063  /* When loading eg an overlay, message is already set, so free() current one. */
1064  free(m->msg);
1065  m->msg = strdup_local(msgbuf);
1066  }
1067  } else if (!strcmp(key, "maplore")) {
1068  char maplorebuf[HUGE_BUF];
1069  size_t maplorepos = 0;
1070 
1071  while (fgets(buf, HUGE_BUF-1, fp) != NULL) {
1072  if (!strcmp(buf, "endmaplore\n"))
1073  break;
1074  else {
1075  if (maplorepos >= sizeof(maplorebuf)) {
1076  LOG(llevError, "Map lore exceeds buffer length\n");
1077  return 1;
1078  }
1079  snprintf(maplorebuf+maplorepos, sizeof(maplorebuf)-maplorepos, "%s", buf);
1080  maplorepos += strlen(buf);
1081  }
1082  }
1083  if (maplorepos != 0)
1084  m->maplore = strdup_local(maplorebuf);
1085  } else if (!strcmp(key, "end")) {
1086  break;
1087  } else if (value == NULL) {
1088  LOG(llevError, "Got '%s' line without parameter in map header\n", key);
1089  } else if (!strcmp(key, "arch")) {
1090  /* This is an oddity, but not something we care about much. */
1091  if (strcmp(value, "map")) {
1092  LOG(llevError, "load_map_header: expected 'arch map': check line endings?\n");
1093  return 1;
1094  }
1095  } else if (!strcmp(key, "name")) {
1096  /* When loading eg an overlay, the name is already set, so free() current one. */
1097  free(m->name);
1098  m->name = strdup_local(value);
1099  /* first strcmp value on these are old names supported
1100  * for compatibility reasons. The new values (second) are
1101  * what really should be used.
1102  */
1103  } else if (!strcmp(key, "enter_x")) {
1104  m->enter_x = atoi(value);
1105  } else if (!strcmp(key, "enter_y")) {
1106  m->enter_y = atoi(value);
1107  } else if (!strcmp(key, "width")) {
1108  m->width = atoi(value);
1109  } else if (!strcmp(key, "height")) {
1110  m->height = atoi(value);
1111  } else if (!strcmp(key, "reset_timeout")) {
1112  m->reset_timeout = atoi(value);
1113  } else if (!strcmp(key, "swap_time")) {
1114  // deprecated and ignored
1115  } else if (!strcmp(key, "difficulty")) {
1116  m->difficulty = atoi(value);
1117  } else if (!strcmp(key, "darkness")) {
1118  m->darkness = atoi(value);
1119  } else if (!strcmp(key, "fixed_resettime")) {
1120  m->fixed_resettime = atoi(value);
1121  } else if (!strcmp(key, "unique")) {
1122  m->unique = atoi(value);
1123  } else if (!strcmp(key, "template")) {
1124  m->is_template = atoi(value);
1125  } else if (!strcmp(key, "region")) {
1126  m->region = get_region_by_name(value);
1127  } else if (!strcmp(key, "shopitems")) {
1128  m->shopitems = parse_shop_string(value, m);
1129  } else if (!strcmp(key, "shopgreed")) {
1130  m->shopgreed = atof(value);
1131  } else if (!strcmp(key, "shopmin")) {
1132  m->shopmin = atol(value);
1133  } else if (!strcmp(key, "shopmax")) {
1134  m->shopmax = atol(value);
1135  } else if (!strcmp(key, "shoprace")) {
1136  m->shoprace = strdup_local(value);
1137  } else if (!strcmp(key, "outdoor")) {
1138  m->outdoor = atoi(value);
1139  } else if (!strcmp(key, "nosmooth")) {
1140  m->nosmooth = atoi(value);
1141  } else if (!strcmp(key, "first_load")) {
1142  m->last_reset_time = atoi(value);
1143  } else if (!strncmp(key, "tile_path_", 10)) {
1144  int tile = atoi(key+10);
1145 
1146  if (tile < 1 || tile > 4) {
1147  LOG(llevError, "load_map_header: tile location %d out of bounds (%s)\n", tile, m->path);
1148  } else {
1149  if (m->tile_path[tile-1]) {
1150  LOG(llevError, "load_map_header: tile location %d duplicated (%s)\n", tile, m->path);
1151  free(m->tile_path[tile-1]);
1152  }
1153  m->tile_path[tile-1] = strdup_local(value);
1154  } /* end if tile direction (in)valid */
1155  } else if (!strcmp(key, "background_music")) {
1156  m->background_music = strdup_local(value);
1157  } else if (!strcmp(key, "reset_group")) {
1158  m->reset_group = add_string(value);
1159  } else {
1160  LOG(llevError, "Got unknown value in map header: %s %s\n", key, value);
1161  }
1162  }
1163  if ((m->width == 0) || (m->height == 0)) {
1164  LOG(llevError, "Map width or height not specified\n");
1165  return 1;
1166  }
1167  if (!key || strcmp(key, "end")) {
1168  LOG(llevError, "Got premature eof on map header!\n");
1169  return 1;
1170  }
1171  return 0;
1172 }
1173 
1174 void map_path(const char *map, int flags, char *pathname, size_t bufsize) {
1175  if (flags&MAP_PLAYER_UNIQUE) {
1176  snprintf(pathname, bufsize, "%s/%s/%s", settings.localdir, settings.playerdir, map+1);
1177  }
1178  else if (flags&MAP_OVERLAY)
1179  create_overlay_pathname(map, pathname, bufsize);
1180  else
1181  create_pathname(map, pathname, bufsize);
1182 }
1183 
1184 mapstruct *mapfile_load_lowlevel(const char *map, const char *pathname, int flags) {
1185  FILE *fp;
1186  if ((fp = fopen(pathname, "r")) == NULL) {
1188  "Can't open %s: %s\n", pathname, strerror(errno));
1189  return NULL;
1190  }
1191 
1192  mapstruct *m = get_linked_map();
1193  safe_strncpy(m->path, map, HUGE_BUF);
1194  if (load_map_header(fp, m)) {
1195  LOG(llevError, "Error loading map header for %s, flags=%d\n", map, flags);
1196  delete_map(m);
1197  fclose(fp);
1198  return NULL;
1199  }
1200 
1201  allocate_map(m);
1202 
1203  m->in_memory = MAP_LOADING;
1204  load_objects(m, fp, flags & MAP_STYLE);
1205  fclose(fp);
1206  m->in_memory = MAP_IN_MEMORY;
1207  return m;
1208 }
1209 
1225 mapstruct *mapfile_load(const char *map, int flags) {
1226  mapstruct *m;
1227  PROFILE_BEGIN();
1228  char pathname[MAX_BUF];
1229  map_path(map, flags, pathname, sizeof(pathname));
1230  m = mapfile_load_lowlevel(map, pathname, flags);
1231  if (!m) {
1232  return NULL;
1233  }
1234  if (!MAP_DIFFICULTY(m) && (!(flags & MAP_NO_DIFFICULTY)))
1237 
1238  /* In case other objects press some buttons down */
1239  update_buttons(m);
1240 
1242 
1243  if (!(flags & MAP_STYLE))
1244  apply_auto_fix(m); /* Chests which open as default */
1245 
1246  PROFILE_END(diff,
1247  LOG(llevDebug, "mapfile_load on %s" " took %ld us\n", map, diff));
1248 
1250  return (m);
1251 }
1252 
1262  FILE *fp;
1263 
1264  if (!m->tmpname) {
1265  LOG(llevError, "No temporary filename for map %s\n", m->path);
1266  return 1;
1267  }
1268 
1269  if ((fp = fopen(m->tmpname, "r")) == NULL) {
1270  LOG(llevError, "Cannot open %s: %s\n", m->tmpname, strerror(errno));
1271  return 2;
1272  }
1273 
1274  if (load_map_header(fp, m)) {
1275  LOG(llevError, "Error loading map header for %s (%s)\n", m->path, m->tmpname);
1276  fclose(fp);
1277  return 3;
1278  }
1279  allocate_map(m);
1280 
1281  m->in_memory = MAP_LOADING;
1282  load_objects(m, fp, 0);
1283  fclose(fp);
1284  m->in_memory = MAP_IN_MEMORY;
1285  return 0;
1286 }
1287 
1297 static int load_overlay_map(const char *filename, mapstruct *m) {
1298  FILE *fp;
1299  char pathname[MAX_BUF];
1300 
1301  create_overlay_pathname(filename, pathname, MAX_BUF);
1302 
1303  if ((fp = fopen(pathname, "r")) == NULL) {
1304  /* nothing bad to not having an overlay */
1305  return 0;
1306  }
1307 
1308  if (load_map_header(fp, m)) {
1309  LOG(llevError, "Error loading map header for overlay %s (%s)\n", m->path, pathname);
1310  fclose(fp);
1311  return 1;
1312  }
1313  /*allocate_map(m);*/
1314 
1315  m->in_memory = MAP_LOADING;
1316  load_objects(m, fp, MAP_OVERLAY);
1317  fclose(fp);
1318  m->in_memory = MAP_IN_MEMORY;
1319  return 0;
1320 }
1321 
1322 /******************************************************************************
1323  * This is the start of unique map handling code
1324  *****************************************************************************/
1325 
1333  int i, j, unique = 0;
1334 
1335  for (i = 0; i < MAP_WIDTH(m); i++)
1336  for (j = 0; j < MAP_HEIGHT(m); j++) {
1337  unique = 0;
1338  FOR_MAP_PREPARE(m, i, j, op) {
1340  unique = 1;
1341  if (op->head == NULL && (QUERY_FLAG(op, FLAG_UNIQUE) || unique)) {
1342  clean_object(op);
1343  if (QUERY_FLAG(op, FLAG_IS_LINKED))
1344  remove_button_link(op);
1345  object_remove(op);
1347  }
1348  } FOR_MAP_FINISH();
1349  }
1350 }
1351 
1358  FILE *fp;
1359  int count;
1360  char name[MAX_BUF], firstname[sizeof(name) + 4];
1361 
1362  create_items_path(m->path, name, MAX_BUF);
1363  for (count = 0; count < 10; count++) {
1364  snprintf(firstname, sizeof(firstname), "%s.v%02d", name, count);
1365  if (!access(firstname, R_OK))
1366  break;
1367  }
1368  /* If we get here, we did not find any map */
1369  if (count == 10)
1370  return;
1371 
1372  if ((fp = fopen(firstname, "r")) == NULL) {
1373  /* There is no expectation that every map will have unique items, but this
1374  * is debug output, so leave it in.
1375  */
1376  LOG(llevDebug, "Can't open unique items file for %s\n", name);
1377  return;
1378  }
1379 
1380  m->in_memory = MAP_LOADING;
1381  if (m->tmpname == NULL) /* if we have loaded unique items from */
1382  delete_unique_items(m); /* original map before, don't duplicate them */
1383  load_object(fp, NULL, LO_NOREAD, 0, false);
1384  load_objects(m, fp, 0);
1385  fclose(fp);
1386  m->in_memory = MAP_IN_MEMORY;
1387 }
1388 
1404 int save_map(mapstruct *m, int flag) {
1405  FILE *fp, *fp2;
1406  OutputFile of, of2;
1407  char filename[MAX_BUF], shop[MAX_BUF];
1408  int i, res;
1409 
1410  if (flag && !*m->path) {
1411  LOG(llevError, "Tried to save map without path.\n");
1412  return SAVE_ERROR_NO_PATH;
1413  }
1414 
1415  PROFILE_BEGIN();
1416 
1417  if (flag != SAVE_MODE_NORMAL || (m->unique) || (m->is_template)) {
1418  if (!m->unique && !m->is_template) { /* flag is set */
1419  if (flag == SAVE_MODE_OVERLAY)
1420  create_overlay_pathname(m->path, filename, MAX_BUF);
1421  else
1422  create_pathname(m->path, filename, MAX_BUF);
1423  } else {
1424  if (m->path[0] != '~') {
1425  LOG(llevError,
1426  "Cannot save unique map '%s' outside of LOCALDIR. Check "
1427  "that all exits to '%s' have FLAG_UNIQUE set correctly.\n",
1428  m->path, m->path);
1429  return SAVE_ERROR_UCREATION;
1430  }
1431  snprintf(filename, sizeof(filename), "%s/%s/%s", settings.localdir, settings.playerdir, m->path+1);
1432  }
1433 
1434  make_path_to_file(filename);
1435  } else {
1436  if (!m->tmpname)
1437  m->tmpname = tempnam(settings.tmpdir, NULL);
1438  strlcpy(filename, m->tmpname, sizeof(filename));
1439  }
1440  m->in_memory = MAP_SAVING;
1441 
1442  fp = of_open(&of, filename);
1443  if (fp == NULL)
1444  return SAVE_ERROR_RCREATION;
1445 
1446  /* legacy */
1447  fprintf(fp, "arch map\n");
1448  if (m->name)
1449  fprintf(fp, "name %s\n", m->name);
1450  if (m->reset_timeout)
1451  fprintf(fp, "reset_timeout %u\n", m->reset_timeout);
1452  if (m->fixed_resettime)
1453  fprintf(fp, "fixed_resettime %d\n", m->fixed_resettime);
1454  /* we unfortunately have no idea if this is a value the creator set
1455  * or a difficulty value we generated when the map was first loaded
1456  */
1457  if (m->difficulty)
1458  fprintf(fp, "difficulty %d\n", m->difficulty);
1459  if (m->region)
1460  fprintf(fp, "region %s\n", m->region->name);
1461  if (m->shopitems) {
1462  print_shop_string(m, shop, sizeof(shop));
1463  fprintf(fp, "shopitems %s\n", shop);
1464  }
1465  if (m->shopgreed)
1466  fprintf(fp, "shopgreed %f\n", m->shopgreed);
1467  if (m->shopmin)
1468  fprintf(fp, "shopmin %" FMT64U "\n", m->shopmin);
1469  if (m->shopmax)
1470  fprintf(fp, "shopmax %" FMT64U "\n", m->shopmax);
1471  if (m->shoprace)
1472  fprintf(fp, "shoprace %s\n", m->shoprace);
1473  if (m->darkness)
1474  fprintf(fp, "darkness %d\n", m->darkness);
1475  if (m->width)
1476  fprintf(fp, "width %d\n", m->width);
1477  if (m->height)
1478  fprintf(fp, "height %d\n", m->height);
1479  if (m->enter_x)
1480  fprintf(fp, "enter_x %d\n", m->enter_x);
1481  if (m->enter_y)
1482  fprintf(fp, "enter_y %d\n", m->enter_y);
1483  if (m->msg)
1484  fprintf(fp, "msg\n%sendmsg\n", m->msg);
1485  if (m->maplore)
1486  fprintf(fp, "maplore\n%sendmaplore\n", m->maplore);
1487  if (m->unique)
1488  fprintf(fp, "unique %d\n", m->unique);
1489  if (m->is_template)
1490  fprintf(fp, "template %d\n", m->is_template);
1491  if (m->outdoor)
1492  fprintf(fp, "outdoor %d\n", m->outdoor);
1493  if (m->nosmooth)
1494  fprintf(fp, "nosmooth %d\n", m->nosmooth);
1495  if (m->last_reset_time)
1496  fprintf(fp, "first_load %ld\n", m->last_reset_time);
1497  if (m->background_music)
1498  fprintf(fp, "background_music %s\n", m->background_music);
1499  if (m->reset_group)
1500  fprintf(fp, "reset_group %s\n", m->reset_group);
1501 
1502  /* Save any tiling information, except on overlays */
1503  if (flag != SAVE_MODE_OVERLAY)
1504  for (i = 0; i < 4; i++)
1505  if (m->tile_path[i])
1506  fprintf(fp, "tile_path_%d %s\n", i+1, m->tile_path[i]);
1507 
1508  fprintf(fp, "end\n");
1509 
1510  /* In the game save unique items in the different file, but
1511  * in the editor save them to the normal map file.
1512  * If unique map, save files in the proper destination (set by
1513  * player)
1514  */
1515  if ((flag == SAVE_MODE_NORMAL || flag == SAVE_MODE_OVERLAY) && !m->unique && !m->is_template) {
1516  char name[MAX_BUF], final_unique[sizeof(name) + 4];
1517 
1518  create_items_path(m->path, name, MAX_BUF);
1519  snprintf(final_unique, sizeof(final_unique), "%s.v00", name);
1520  fp2 = of_open(&of2, final_unique);
1521  if (fp2 == NULL) {
1522  of_cancel(&of);
1523  return SAVE_ERROR_UCREATION;
1524  }
1525  if (flag == SAVE_MODE_OVERLAY) {
1526  /* SO_FLAG_NO_REMOVE is non destructive save, so map is still valid. */
1527  res = save_objects(m, fp, fp2, SAVE_FLAG_NO_REMOVE);
1528  if (res < 0) {
1529  LOG(llevError, "Save error during object save: %d\n", res);
1530  of_cancel(&of);
1531  of_cancel(&of2);
1532  return res;
1533  }
1534  m->in_memory = MAP_IN_MEMORY;
1535  } else {
1536  res = save_objects(m, fp, fp2, 0);
1537  if (res < 0) {
1538  LOG(llevError, "Save error during object save: %d\n", res);
1539  of_cancel(&of);
1540  of_cancel(&of2);
1541  return res;
1542  }
1544  }
1545  if (ftell(fp2) == 0) {
1546  of_cancel(&of2);
1547  /* If there are no unique items left on the map, we need to
1548  * unlink the original unique map so that the unique
1549  * items don't show up again.
1550  */
1551  unlink(final_unique);
1552  } else {
1553  if (!of_close(&of2)) {
1554  of_cancel(&of);
1555  return SAVE_ERROR_URENAME;
1556  }
1557 
1558  if (chmod(final_unique, SAVE_MODE) != 0) {
1559  LOG(llevError, "Could not set permissions on '%s'\n",
1560  final_unique);
1561  }
1562  }
1563  } else { /* save same file when not playing, like in editor */
1564  res = save_objects(m, fp, fp, 0);
1565  if (res < 0) {
1566  LOG(llevError, "Save error during object save: %d\n", res);
1567  of_cancel(&of);
1568  return res;
1569  }
1571  }
1572 
1573  if (!of_close(&of))
1574  return SAVE_ERROR_CLOSE;
1575 
1576  if (chmod(filename, SAVE_MODE) != 0) {
1577  LOG(llevError, "Could not set permissions on '%s'\n", filename);
1578  }
1579 
1580  PROFILE_END(diff,
1581  LOG(llevDebug, "save_map on %s" " took %ld us\n", m->path, diff));
1582 
1583  maps_saved_total++;
1584  return SAVE_ERROR_OK;
1585 }
1586 
1596 void clean_object(object *op) {
1597  FOR_INV_PREPARE(op, tmp) {
1598  clean_object(tmp);
1599  if (QUERY_FLAG(tmp, FLAG_IS_LINKED))
1600  remove_button_link(tmp);
1601  object_remove(tmp);
1603  } FOR_INV_FINISH();
1604 }
1605 
1613  int i, j;
1614  object *op;
1615 
1616  for (i = 0; i < MAP_WIDTH(m); i++)
1617  for (j = 0; j < MAP_HEIGHT(m); j++) {
1618  object *previous_obj = NULL;
1619 
1620  while ((op = GET_MAP_OB(m, i, j)) != NULL) {
1621  if (op == previous_obj) {
1622  LOG(llevDebug, "free_all_objects: Link error, bailing out.\n");
1623  break;
1624  }
1625  previous_obj = op;
1626  op = HEAD(op);
1627 
1628  /* If the map isn't in memory, object_free_drop_inventory() will remove and
1629  * free objects in op's inventory. So let it do the job.
1630  */
1631  if (m->in_memory == MAP_IN_MEMORY)
1632  clean_object(op);
1633  object_remove(op);
1635  }
1636  }
1637 #ifdef MANY_CORES
1638  /* I see periodic cores on metalforge where a map has been swapped out, but apparantly
1639  * an item on that map was not saved - look for that condition and die as appropriate -
1640  * this leaves more of the map data intact for better debugging.
1641  */
1642  for (op = objects; op != NULL; op = op->next) {
1643  if (!QUERY_FLAG(op, FLAG_REMOVED) && op->map == m) {
1644  LOG(llevError, "free_all_objects: object %s still on map after it should have been freed\n", op->name);
1645  abort();
1646  }
1647  }
1648 #endif
1649 }
1650 
1660  int i;
1661 
1662  if (!m->in_memory) {
1663  LOG(llevError, "Trying to free freed map.\n");
1664  return;
1665  }
1666 
1668 
1669  if (m->spaces)
1671  if (m->name)
1672  FREE_AND_CLEAR(m->name);
1673  if (m->spaces)
1674  FREE_AND_CLEAR(m->spaces);
1675  if (m->msg)
1676  FREE_AND_CLEAR(m->msg);
1677  if (m->maplore)
1678  FREE_AND_CLEAR(m->maplore);
1679  if (m->shopitems)
1680  FREE_AND_CLEAR(m->shopitems);
1681  if (m->shoprace)
1682  FREE_AND_CLEAR(m->shoprace);
1683  if (m->background_music)
1684  FREE_AND_CLEAR(m->background_music);
1685  if (m->buttons)
1686  free_objectlinkpt(m->buttons);
1687  m->buttons = NULL;
1688  for (i = 0; i < 4; i++) {
1689  if (m->tile_path[i])
1690  FREE_AND_CLEAR(m->tile_path[i]);
1691  m->tile_map[i] = NULL;
1692  }
1693  m->in_memory = MAP_SWAPPED;
1694 }
1695 
1706  mapstruct *tmp, *last;
1707  int i;
1708 
1709  if (!m)
1710  return;
1711  if (m->in_memory == MAP_IN_MEMORY) {
1712  /* change to MAP_SAVING, even though we are not,
1713  * so that object_remove() doesn't do as much work.
1714  */
1715  m->in_memory = MAP_SAVING;
1716  free_map(m);
1717  }
1718  /* move this out of free_map, since tmpname can still be needed if
1719  * the map is swapped out.
1720  */
1721  free(m->tmpname);
1722  m->tmpname = NULL;
1723  FREE_AND_CLEAR_STR_IF(m->reset_group);
1724  last = NULL;
1725  /* We need to look through all the maps and see if any maps
1726  * are pointing at this one for tiling information. Since
1727  * tiling can be assymetric, we just can not look to see which
1728  * maps this map tiles with and clears those.
1729  */
1730  for (tmp = first_map; tmp != NULL; tmp = tmp->next) {
1731  if (tmp->next == m)
1732  last = tmp;
1733 
1734  /* This should hopefully get unrolled on a decent compiler */
1735  for (i = 0; i < 4; i++)
1736  if (tmp->tile_map[i] == m)
1737  tmp->tile_map[i] = NULL;
1738  }
1739 
1740  /* If last is null, then this should be the first map in the list */
1741  if (!last) {
1742  if (m == first_map)
1743  first_map = m->next;
1744  else
1745  /* m->path is a static char, so should hopefully still have
1746  * some useful data in it.
1747  */
1748  LOG(llevError, "delete_map: Unable to find map %s in list\n", m->path);
1749  } else
1750  last->next = m->next;
1751 
1752  free(m);
1753 }
1754 
1760  // Right now this just sets the fixed swap time.
1761  m->timeout = MAP_MINTIMEOUT;
1762 }
1763 
1777 mapstruct *ready_map_name(const char *name, int flags) {
1778  mapstruct *m;
1779 
1780  if (!name)
1781  return (NULL);
1782 
1783  /* Have we been at this level before? */
1784  m = has_been_loaded(name);
1785 
1786  /* Map is good to go, so just return it */
1787  if (m && (m->in_memory == MAP_LOADING || m->in_memory == MAP_IN_MEMORY)) {
1788  map_reset_swap(m);
1789  return m;
1790  }
1791 
1792  /* Rewrite old paths starting with LOCALDIR/PLAYERDIR to new '~' paths. */
1793  char buf[MAX_BUF], buf2[MAX_BUF];
1794  snprintf(buf, sizeof(buf), "%s/%s", settings.localdir, settings.playerdir);
1795  if (strncmp(name, buf, strlen(buf)) == 0) {
1796  snprintf(buf2, sizeof(buf2), "~%s", name+strlen(buf)+1);
1797  name = buf2;
1798  }
1799 
1800  /* Paths starting with '~' are unique. */
1801  if (name[0] == '~') {
1803  }
1804 
1805  /* unique maps always get loaded from their original location, and never
1806  * a temp location. Likewise, if map_flush is set, or we have never loaded
1807  * this map, load it now. I removed the reset checking from here -
1808  * it seems the probability of a player trying to enter a map that should
1809  * reset but hasn't yet is quite low, and removing that makes this function
1810  * a bit cleaner (and players probably shouldn't rely on exact timing for
1811  * resets in any case - if they really care, they should use the 'maps command.
1812  */
1813  if ((flags&(MAP_FLUSH|MAP_PLAYER_UNIQUE)) || !m) {
1814  /* first visit or time to reset */
1815  if (m) {
1816  clean_tmp_map(m); /* Doesn't make much difference */
1817  delete_map(m);
1818  }
1819 
1821  if (m == NULL) return NULL;
1822 
1823  /* If a player unique map, no extra unique object file to load.
1824  * if from the editor, likewise.
1825  */
1828 
1830  if (load_overlay_map(name, m) != 0) {
1831  delete_map(m);
1832  m = mapfile_load(name, 0);
1833  if (m == NULL) {
1834  /* Really, this map is bad :( */
1835  return NULL;
1836  }
1837  }
1838  }
1839  } else {
1840  /* If in this loop, we found a temporary map, so load it up. */
1841 
1842  if (load_temporary_map(m) != 0) {
1843  /*
1844  * There was a failure loading the temporary map, fall back to original one.
1845  * load_temporary_map() already logged the error.
1846  */
1847  delete_map(m);
1848  m = mapfile_load(name, 0);
1849  if (m == NULL) {
1850  /* Really, this map is bad :( */
1851  return NULL;
1852  }
1853  }
1855 
1856  clean_tmp_map(m);
1857  m->in_memory = MAP_IN_MEMORY;
1858  /* tempnam() on sun systems (probably others) uses malloc
1859  * to allocated space for the string. Free it here.
1860  * In some cases, load_temporary_map above won't find the
1861  * temporary map, and so has reloaded a new map. If that
1862  * is the case, tmpname is now null
1863  */
1864  free(m->tmpname);
1865  m->tmpname = NULL;
1866  /* It's going to be saved anew anyway */
1867  }
1868 
1869  /* Below here is stuff common to both first time loaded maps and
1870  * temp maps.
1871  */
1872 
1873  decay_objects(m); /* start the decay */
1874 
1875  if (m->outdoor)
1877 
1878  if (!(flags&(MAP_FLUSH))) {
1879  if (m->last_reset_time == 0) {
1880  m->last_reset_time = seconds();
1881  }
1882  }
1883 
1884  /* Randomize monsters direction and animation state */
1885 
1886  if (!(flags & MAP_STYLE)) {
1887  for (int x = 0; x < MAP_WIDTH(m); x++)
1888  for (int y = 0; y < MAP_HEIGHT(m); y++)
1889  FOR_MAP_PREPARE(m, x, y, op) {
1890  if (!op->head && QUERY_FLAG(op, FLAG_MONSTER) && (op->direction == 0 || op->facing == 0)) {
1891  if (op->animation) {
1892  auto facings = NUM_FACINGS(op);
1893  op->facing = facings > 1 ? 1 + (cf_random() % facings) : 1;
1894  op->direction = op->facing;
1895  const int max_state = NUM_ANIMATIONS(op) / facings;
1896  op->state = max_state > 1 ? cf_random() % max_state : 0;
1897  animate_object(op, op->direction);
1898  }
1899  }
1900  } FOR_MAP_FINISH();
1901 
1902  }
1903 
1904  map_reset_swap(m);
1906 
1907  return m;
1908 }
1909 
1926  archetype *at;
1927  int x, y;
1928  int diff = 0;
1929  int i;
1930  int64_t exp_pr_sq, total_exp = 0;
1931 
1932  if (MAP_DIFFICULTY(m)) {
1933  return MAP_DIFFICULTY(m);
1934  }
1935 
1936  for (x = 0; x < MAP_WIDTH(m); x++)
1937  for (y = 0; y < MAP_HEIGHT(m); y++)
1938  FOR_MAP_PREPARE(m, x, y, op) {
1939  if (QUERY_FLAG(op, FLAG_MONSTER))
1940  total_exp += op->stats.exp;
1941  if (QUERY_FLAG(op, FLAG_GENERATOR)) {
1942  total_exp += op->stats.exp;
1943  // If we have an other_arch on our generator, just use that.
1944  // FIXME: Figure out what to do if we are doing template generation from inventory.
1945  at = op->other_arch ? op->other_arch : NULL;
1946  if (at != NULL) {
1947  // Make sure we can't set off a null pointer dereference in atoi().
1948  const char *val = object_get_value(op, "generator_limit");
1949  int lim = atoi(val ? val : "0");
1950  // We assume, on average, the generator will generate half its contents.
1951  if (!lim || lim >= 16)
1952  total_exp += at->clone.stats.exp*8;
1953  else
1954  total_exp += at->clone.stats.exp*(lim/2);
1955  }
1956  }
1957  } FOR_MAP_FINISH();
1958  // Used to be multiplied by 1000, but this undershot horribly
1959  // once I fixed the calculation for generators.
1960  // I'm trying out some exponentiation, since linear scaling
1961  // seems to overshoot low-level maps and undershoot high-level maps.
1962  // I also feel comfortable, knowing that generators return
1963  // sensible values, to up the max diff this calculates from 20 to 25.
1964  // - Neila Hawkins 2021-03-04
1965  exp_pr_sq = (pow(total_exp, 1.75))/(MAP_WIDTH(m)*MAP_HEIGHT(m)+1);
1966  diff = 25;
1967  for (i = 1; i < 25; i++)
1968  if (exp_pr_sq <= level_exp(i, 1.0)) {
1969  diff = i;
1970  break;
1971  }
1972 
1973  return diff;
1974 }
1975 
1983  if (m->tmpname == NULL)
1984  return;
1985  (void)unlink(m->tmpname);
1986 }
1987 
1991 void free_all_maps(void) {
1992  int real_maps = 0;
1993 
1994  while (first_map) {
1995  /* I think some of the callers above before it gets here set this to be
1996  * saving, but we still want to free this data
1997  */
1998  if (first_map->in_memory == MAP_SAVING)
2001  real_maps++;
2002  }
2003  LOG(llevDebug, "free_all_maps: Freed %d maps\n", real_maps);
2004 }
2005 
2023 int change_map_light(mapstruct *m, int change) {
2024  int new_level = m->darkness+change;
2025 
2026  /* Nothing to do */
2027  if (!change
2028  || (new_level <= 0 && m->darkness == 0)
2029  || (new_level >= MAX_DARKNESS && m->darkness >= MAX_DARKNESS)) {
2030  return 0;
2031  }
2032 
2033  /* inform all players on the map */
2034  if (change > 0)
2035  ext_info_map(NDI_BLACK, m, MSG_TYPE_MISC, MSG_SUBTYPE_NONE, "It becomes darker.");
2036  else
2037  ext_info_map(NDI_BLACK, m, MSG_TYPE_MISC, MSG_SUBTYPE_NONE, "It becomes brighter.");
2038 
2039  /* Do extra checking. since m->darkness is a unsigned value,
2040  * we need to be extra careful about negative values.
2041  * In general, the checks below are only needed if change
2042  * is not +/-1
2043  */
2044  if (new_level < 0)
2045  m->darkness = 0;
2046  else if (new_level >= MAX_DARKNESS)
2047  m->darkness = MAX_DARKNESS;
2048  else
2049  m->darkness = new_level;
2050 
2051  /* All clients need to get re-updated for the change */
2053  return 1;
2054 }
2055 
2078 static inline void add_face_layer(int low_layer, int high_layer, object *ob, object *layers[], int honor_visibility) {
2079  int l, l1;
2080  object *tmp;
2081 
2082  for (l = low_layer; l <= high_layer; l++) {
2083  if (!layers[l]) {
2084  /* found an empty spot. now, we want to make sure
2085  * highest visibility at top, etc.
2086  */
2087  layers[l] = ob;
2088  if (!honor_visibility)
2089  return;
2090 
2091  /* This is basically a mini bubble sort. Only swap
2092  * position if the lower face has greater (not equal)
2093  * visibility - map stacking is secondary consideration here.
2094  */
2095  for (l1 = (l-1); l1 >= low_layer; l1--) {
2096  if (layers[l1]->face->visibility > layers[l1+1]->face->visibility) {
2097  tmp = layers[l1+1];
2098  layers[l1+1] = layers[l1];
2099  layers[l1] = tmp;
2100  }
2101  }
2102  /* Nothing more to do - face inserted */
2103  return;
2104  }
2105  }
2106  /* If we get here, all the layers have an object..
2107  */
2108  if (!honor_visibility) {
2109  /* Basically, in this case, it is pure stacking logic, so
2110  * new object goes on the top.
2111  */
2112  for (l = low_layer; l < high_layer; l++)
2113  layers[l] = layers[l+1];
2114  layers[high_layer] = ob;
2115  /* If this object doesn't have higher visibility than
2116  * the lowest object, no reason to go further.
2117  */
2118  } else if (ob->face->visibility >= layers[low_layer]->face->visibility) {
2119  /*
2120  * Start at the top (highest visibility) layer and work down.
2121  * once this face exceed that of the layer, push down those
2122  * other layers, and then replace the layer with our object.
2123  */
2124  for (l = high_layer; l >= low_layer; l--) {
2125  if (ob->face->visibility >= layers[l]->face->visibility) {
2126  for (l1 = low_layer; l1 < l; l1++)
2127  layers[l1] = layers[l1+1];
2128  layers[l] = ob;
2129  break;
2130  }
2131  }
2132  }
2133 }
2134 
2147 void update_position(mapstruct *m, int x, int y) {
2148  object *player = NULL;
2149  uint8_t flags = 0, oldflags, light = 0;
2150  object *layers[MAP_LAYERS];
2151 
2152  MoveType move_block = 0, move_slow = 0, move_on = 0, move_off = 0, move_allow = 0;
2153 
2154  oldflags = GET_MAP_FLAGS(m, x, y);
2155  if (!(oldflags&P_NEED_UPDATE)) {
2156  LOG(llevDebug, "update_position called with P_NEED_UPDATE not set: %s (%d, %d)\n", m->path, x, y);
2157  return;
2158  }
2159 
2160  memset(layers, 0, MAP_LAYERS*sizeof(object *));
2161 
2162  FOR_MAP_PREPARE(m, x, y, tmp) {
2163  /* DMs just don't do anything when hidden, including no light. */
2164  if (QUERY_FLAG(tmp, FLAG_WIZ) && tmp->contr->hidden)
2165  continue;
2166 
2167  if (tmp->type == PLAYER)
2168  player = tmp;
2169 
2170  /* This could be made additive I guess (two lights better than
2171  * one). But if so, it shouldn't be a simple additive - 2
2172  * light bulbs do not illuminate twice as far as once since
2173  * it is a dissipation factor that is squared (or is it cubed?)
2174  */
2175  if (tmp->glow_radius > light)
2176  light = tmp->glow_radius;
2177 
2178  /* if this object is visible and not a blank face,
2179  * update the objects that show how this space
2180  * looks.
2181  */
2182  if (!tmp->invisible && tmp->face != blank_face) {
2183  if (tmp->map_layer) {
2184  add_face_layer(tmp->map_layer, map_layer_info[tmp->map_layer].high_layer,
2185  tmp, layers, map_layer_info[tmp->map_layer].honor_visibility);
2186  } else if (tmp->move_type&MOVE_FLYING) {
2187  add_face_layer(MAP_LAYER_FLY1, MAP_LAYER_FLY2, tmp, layers, 1);
2188  } else if ((tmp->type == PLAYER || QUERY_FLAG(tmp, FLAG_MONSTER) || QUERY_FLAG(tmp, FLAG_CAN_ROLL))) {
2189  // Put things that are likely to move on the LIVING layers
2191  } else if (QUERY_FLAG(tmp, FLAG_IS_FLOOR)) {
2192  layers[MAP_LAYER_FLOOR] = tmp;
2193  /* floors hide everything else */
2194  memset(layers+1, 0, (MAP_LAYERS-1)*sizeof(object *));
2195  /* Check for FLAG_SEE_ANYWHERE is removed - objects
2196  * with that flag should just have a high visibility
2197  * set - we shouldn't need special code here.
2198  */
2199  } else if (QUERY_FLAG(tmp, FLAG_NO_PICK)) {
2201  } else {
2203  }
2204  }
2205  if (tmp == tmp->above) {
2206  LOG(llevError, "Error in structure of map\n");
2207  exit(-1);
2208  }
2209 
2210  move_slow |= tmp->move_slow;
2211  move_block |= tmp->move_block;
2212  move_on |= tmp->move_on;
2213  move_off |= tmp->move_off;
2214  move_allow |= tmp->move_allow;
2215 
2216  if (QUERY_FLAG(tmp, FLAG_ALIVE))
2217  flags |= P_IS_ALIVE;
2218  if (QUERY_FLAG(tmp, FLAG_NO_MAGIC))
2219  flags |= P_NO_MAGIC;
2221  flags |= P_NO_CLERIC;
2222 
2223  if (QUERY_FLAG(tmp, FLAG_BLOCKSVIEW))
2224  flags |= P_BLOCKSVIEW;
2225  } FOR_MAP_FINISH(); /* for stack of objects */
2226 
2227  if (player)
2228  flags |= P_PLAYER;
2229 
2230  /* we don't want to rely on this function to have accurate flags, but
2231  * since we're already doing the work, we calculate them here.
2232  * if they don't match, logic is broken someplace.
2233  */
2234  if (((oldflags&~(P_NEED_UPDATE|P_NO_ERROR)) != flags)
2235  && (!(oldflags&P_NO_ERROR))) {
2236  LOG(llevDebug, "update_position: updated flags do not match old flags: %s (x=%d,y=%d) %x != %x\n",
2237  m->path, x, y, (oldflags&~P_NEED_UPDATE), flags);
2238  }
2239 
2240  SET_MAP_FLAGS(m, x, y, flags);
2241  SET_MAP_MOVE_BLOCK(m, x, y, move_block&~move_allow);
2242  SET_MAP_MOVE_ON(m, x, y, move_on);
2243  SET_MAP_MOVE_OFF(m, x, y, move_off);
2244  SET_MAP_MOVE_SLOW(m, x, y, move_slow);
2245  SET_MAP_LIGHT(m, x, y, light);
2246 
2247  /* Note that player may be NULL here, which is fine - if no player, need
2248  * to clear any value that may be set.
2249  */
2250  SET_MAP_PLAYER(m, x, y, player);
2251 
2252  /* Note it is intentional we copy everything, including NULL values. */
2253  memcpy(GET_MAP_FACE_OBJS(m, x, y), layers, sizeof(object *)*MAP_LAYERS);
2254 }
2255 
2263  int timeout;
2264 
2265  timeout = MAP_RESET_TIMEOUT(map);
2266  if (timeout <= 0)
2267  timeout = MAP_DEFAULTRESET;
2268  if (timeout >= MAP_MAXRESET)
2269  timeout = MAP_MAXRESET;
2270  MAP_RESET_TIMEOUT(map) = timeout;
2271  MAP_WHEN_RESET(map) = seconds()+timeout;
2272 }
2273 
2288 static mapstruct *load_and_link_tiled_map(mapstruct *orig_map, int tile_num) {
2289  int dest_tile = (tile_num+2)%4;
2290  char path[HUGE_BUF];
2291 
2292  path_combine_and_normalize(orig_map->path, orig_map->tile_path[tile_num], path, sizeof(path));
2293 
2294  orig_map->tile_map[tile_num] = ready_map_name(path, 0);
2295  if (orig_map->tile_map[tile_num] == NULL) {
2296  LOG(llevError, "%s has invalid tiled map %s\n", orig_map->path, path);
2297  free(orig_map->tile_path[tile_num]);
2298  orig_map->tile_path[tile_num] = NULL;
2299  return NULL;
2300  }
2301 
2302  /* need to do a strcmp here as the orig_map->path is not a shared string */
2303  if (orig_map->tile_map[tile_num]->tile_path[dest_tile]
2304  && !strcmp(orig_map->tile_map[tile_num]->tile_path[dest_tile], orig_map->path))
2305  orig_map->tile_map[tile_num]->tile_map[dest_tile] = orig_map;
2306 
2307  return orig_map->tile_map[tile_num];
2308 }
2309 
2323 int out_of_map(mapstruct *m, int x, int y) {
2324  int16_t xp = x, yp = y;
2325  if (get_map_from_coord(m, &xp, &yp) == NULL) {
2326  return 1;
2327  } else {
2328  return 0;
2329  }
2330 }
2331 
2351 mapstruct *get_map_from_coord(mapstruct *m, int16_t *x, int16_t *y) {
2352 
2353  /* Simple case - coordinates are within this local
2354  * map.
2355  */
2356 
2357  if ( !m ) return NULL;
2358  if (m->in_memory == MAP_SWAPPED) {
2359  // callers are calling get_map_from_coord() to access the map, so if
2360  // it's swapped out return early here. While we could finish this
2361  // computation without having to swap the map in, when they try to
2362  // get/set it will abort()
2363  //
2364  // This should never happen (if it did, the swapper is buggy) but it
2365  // does actually happen because of object recycling (e.g. op->enemy
2366  // points to a completely different object on a swapped out map)
2367  return NULL;
2368  }
2369  if (!OUT_OF_REAL_MAP(m, *x, *y))
2370  return m;
2371 
2372  do /* With the first case there, we can assume we are out of the map if we get here */
2373  {
2374  // Figure out what map should be in the direction we are off the map, and then
2375  // load that map and look again.
2376  if (*x < 0) {
2377  if (!m->tile_path[3])
2378  return NULL;
2379  if (!m->tile_map[3] || m->tile_map[3]->in_memory != MAP_IN_MEMORY){
2381  /* Make sure we loaded properly. */
2382  if (!m->tile_map[3])
2383  return NULL;
2384  }
2385  *x += MAP_WIDTH(m->tile_map[3]);
2386  m = m->tile_map[3];
2387  }
2388  else if (*x >= MAP_WIDTH(m)) {
2389  if (!m->tile_path[1])
2390  return NULL;
2391  if (!m->tile_map[1] || m->tile_map[1]->in_memory != MAP_IN_MEMORY){
2393  /* Make sure we loaded properly. */
2394  if (!m->tile_map[1])
2395  return NULL;
2396  }
2397  *x -= MAP_WIDTH(m);
2398  m = m->tile_map[1];
2399  }
2400  // It is possible that x and y be considered separate compare groups,
2401  // But using an else-if here retains the old behavior that recursion produced.
2402  else if (*y < 0) {
2403  if (!m->tile_path[0])
2404  return NULL;
2405  if (!m->tile_map[0] || m->tile_map[0]->in_memory != MAP_IN_MEMORY){
2407  /* Make sure we loaded properly. */
2408  if (!m->tile_map[0])
2409  return NULL;
2410  }
2411  *y += MAP_HEIGHT(m->tile_map[0]);
2412  m = m->tile_map[0];
2413  }
2414  else if (*y >= MAP_HEIGHT(m)) {
2415  if (!m->tile_path[2])
2416  return NULL;
2417  if (!m->tile_map[2] || m->tile_map[2]->in_memory != MAP_IN_MEMORY){
2419  /* Make sure we loaded properly. */
2420  if (!m->tile_map[2])
2421  return NULL;
2422  }
2423  *y -= MAP_HEIGHT(m);
2424  m = m->tile_map[2];
2425  }
2426  // The check here is if our single tile is in the map.
2427  // That is exactly what the OUT_OF_MAP macro does.
2428  } while (OUT_OF_REAL_MAP(m, *x, *y));
2429  return m; /* We have found our map */
2430 }
2431 
2445 static int adjacent_map(const mapstruct *map1, const mapstruct *map2, int *dx, int *dy) {
2446  if (!map1 || !map2)
2447  return 0;
2448 
2449  if (map1 == map2) {
2450  *dx = 0;
2451  *dy = 0;
2452  } else if (map1->tile_map[0] == map2) { /* up */
2453  *dx = 0;
2454  *dy = -MAP_HEIGHT(map2);
2455  } else if (map1->tile_map[1] == map2) { /* right */
2456  *dx = MAP_WIDTH(map1);
2457  *dy = 0;
2458  } else if (map1->tile_map[2] == map2) { /* down */
2459  *dx = 0;
2460  *dy = MAP_HEIGHT(map1);
2461  } else if (map1->tile_map[3] == map2) { /* left */
2462  *dx = -MAP_WIDTH(map2);
2463  *dy = 0;
2464  } else if (map1->tile_map[0] && map1->tile_map[0]->tile_map[1] == map2) { /* up right */
2465  *dx = MAP_WIDTH(map1->tile_map[0]);
2466  *dy = -MAP_HEIGHT(map1->tile_map[0]);
2467  } else if (map1->tile_map[0] && map1->tile_map[0]->tile_map[3] == map2) { /* up left */
2468  *dx = -MAP_WIDTH(map2);
2469  *dy = -MAP_HEIGHT(map1->tile_map[0]);
2470  } else if (map1->tile_map[1] && map1->tile_map[1]->tile_map[0] == map2) { /* right up */
2471  *dx = MAP_WIDTH(map1);
2472  *dy = -MAP_HEIGHT(map2);
2473  } else if (map1->tile_map[1] && map1->tile_map[1]->tile_map[2] == map2) { /* right down */
2474  *dx = MAP_WIDTH(map1);
2475  *dy = MAP_HEIGHT(map1->tile_map[1]);
2476  } else if (map1->tile_map[2] && map1->tile_map[2]->tile_map[1] == map2) { /* down right */
2477  *dx = MAP_WIDTH(map1->tile_map[2]);
2478  *dy = MAP_HEIGHT(map1);
2479  } else if (map1->tile_map[2] && map1->tile_map[2]->tile_map[3] == map2) { /* down left */
2480  *dx = -MAP_WIDTH(map2);
2481  *dy = MAP_HEIGHT(map1);
2482  } else if (map1->tile_map[3] && map1->tile_map[3]->tile_map[0] == map2) { /* left up */
2483  *dx = -MAP_WIDTH(map1->tile_map[3]);
2484  *dy = -MAP_HEIGHT(map2);
2485  } else if (map1->tile_map[3] && map1->tile_map[3]->tile_map[2] == map2) { /* left down */
2486  *dx = -MAP_WIDTH(map1->tile_map[3]);
2487  *dy = MAP_HEIGHT(map1->tile_map[3]);
2488  } else { /* not "adjacent" enough */
2489  return 0;
2490  }
2491 
2492  return 1;
2493 }
2494 
2522 int get_rangevector(object *op1, const object *op2, rv_vector *retval, int flags) {
2523  if (!adjacent_map(op1->map, op2->map, &retval->distance_x, &retval->distance_y)) {
2524  /* be conservative and fill in _some_ data */
2525  retval->distance = 100000;
2526  retval->distance_x = 32767;
2527  retval->distance_y = 32767;
2528  retval->direction = 0;
2529  retval->part = NULL;
2530  return 0;
2531  } else {
2532  object *best;
2533 
2534  retval->distance_x += op2->x-op1->x;
2535  retval->distance_y += op2->y-op1->y;
2536 
2537  best = op1;
2538  /* If this is multipart, find the closest part now */
2539  if (!(flags&0x1) && op1->more) {
2540  object *tmp;
2541  int best_distance = retval->distance_x*retval->distance_x+
2542  retval->distance_y*retval->distance_y, tmpi;
2543 
2544  /* we just take the offset of the piece to head to figure
2545  * distance instead of doing all that work above again
2546  * since the distance fields we set above are positive in the
2547  * same axis as is used for multipart objects, the simply arithmetic
2548  * below works.
2549  */
2550  for (tmp = op1->more; tmp != NULL; tmp = tmp->more) {
2551  tmpi = (op1->x-tmp->x+retval->distance_x)*(op1->x-tmp->x+retval->distance_x)+
2552  (op1->y-tmp->y+retval->distance_y)*(op1->y-tmp->y+retval->distance_y);
2553  if (tmpi < best_distance) {
2554  best_distance = tmpi;
2555  best = tmp;
2556  }
2557  }
2558  if (best != op1) {
2559  retval->distance_x += op1->x-best->x;
2560  retval->distance_y += op1->y-best->y;
2561  }
2562  }
2563  retval->part = best;
2564  retval->distance = ihypot(retval->distance_x, retval->distance_y);
2565  retval->direction = find_dir_2(-retval->distance_x, -retval->distance_y);
2566  return 1;
2567  }
2568 }
2569 
2590 int get_rangevector_from_mapcoord(const mapstruct *m, int x, int y, const object *op2, rv_vector *retval) {
2591  if (!adjacent_map(m, op2->map, &retval->distance_x, &retval->distance_y)) {
2592  /* be conservative and fill in _some_ data */
2593  retval->distance = 100000;
2594  retval->distance_x = 32767;
2595  retval->distance_y = 32767;
2596  retval->direction = 0;
2597  retval->part = NULL;
2598  return 0;
2599  } else {
2600  retval->distance_x += op2->x-x;
2601  retval->distance_y += op2->y-y;
2602 
2603  retval->part = NULL;
2604  retval->distance = isqrt(retval->distance_x*retval->distance_x+retval->distance_y*retval->distance_y);
2605  retval->direction = find_dir_2(-retval->distance_x, -retval->distance_y);
2606  return 1;
2607  }
2608 }
2609 
2628 int on_same_map(const object *op1, const object *op2) {
2629  int dx, dy;
2630 
2631  return adjacent_map(op1->map, op2->map, &dx, &dy);
2632 }
2633 
2651 object *map_find_by_flag(mapstruct *map, int x, int y, int flag) {
2652  object *tmp;
2653 
2654  for (tmp = GET_MAP_OB(map, x, y); tmp != NULL; tmp = tmp->above) {
2655  object *head;
2656 
2657  head = HEAD(tmp);
2658  if (QUERY_FLAG(head, flag))
2659  return head;
2660  }
2661  return NULL;
2662 }
2663 
2669  char base[HUGE_BUF], path[sizeof(base) + 4];
2670  int count;
2671 
2672  if (map->unique) {
2673  snprintf(path, sizeof(path), "%s/%s/%s", settings.localdir, settings.playerdir, map->path+1);
2674  if (unlink(path) != 0) {
2675  LOG(llevError, "Could not delete %s: %s\n", path, strerror(errno));
2676  }
2677  return;
2678  }
2679 
2680  create_items_path(map->path, base, sizeof(base));
2681 
2682  for (count = 0; count < 10; count++) {
2683  snprintf(path, sizeof(path), "%s.v%02d", base, count);
2684  unlink(path);
2685  }
2686 }
2687 
2693 const char *map_get_path(const object *item) {
2694  if (item->map != NULL) {
2695  if (strlen(item->map->path) > 0) {
2696  return item->map->path;
2697  }
2698 
2699  return item->map->name ? item->map->name : "(empty path and name)";
2700  }
2701 
2702  if (item->env != NULL)
2703  return map_get_path(item->env);
2704 
2705  return "(no map and no env!)";
2706 }
2707 
2713 bool map_path_unique(const char *path) {
2714  return path != NULL && path[0] == '~';
2715 }
2716 
2717 MapSpace *map_space(const mapstruct *m, int x, int y) {
2718  if (m->spaces == NULL) // guard against map being swapped out
2719  abort();
2720  if (OUT_OF_REAL_MAP(m, x, y)) // array out of bounds check
2721  abort();
2722  return &m->spaces[x + m->width * y];
2723 }
2724 
2729 int map_light_on(mapstruct *m, int x, int y) {
2730  /* Check the spaces with the max light radius to see if any of them
2731  * have lights, and if any of them light the player enough, then return 1.
2732  */
2733  for (int i = x - MAX_LIGHT_RADII; i <= x + MAX_LIGHT_RADII; i++) {
2734  for (int j = y - MAX_LIGHT_RADII; j <= y + MAX_LIGHT_RADII; j++) {
2735  int16_t nx = i;
2736  int16_t ny = j;
2737  auto real = get_map_from_coord(m, &nx, &ny);
2738  if (real == nullptr)
2739  continue;
2740 
2741  int light = GET_MAP_LIGHT(real, nx, ny);
2742  if (light == 0)
2743  continue;
2744 
2745  if (ihypot(i - x, j - y) < light)
2746  return 1;
2747  }
2748  }
2749 
2750  return 0;
2751 }
2752 
2756 bool coords_in_shop(mapstruct *map, int x, int y) {
2757  FOR_MAP_PREPARE(map, x, y, floor)
2758  if (floor->type == SHOP_FLOOR) return true;
2759  FOR_MAP_FINISH();
2760  return false;
2761 }
2762 
2763 bool shop_contains(object *ob) {
2764  if (!ob->map) return 0;
2765  return coords_in_shop(ob->map, ob->x, ob->y);
2766 }
mapstruct::tile_path
char * tile_path[4]
Path to adjoining maps.
Definition: map.h:356
GET_MAP_OB
#define GET_MAP_OB(M, X, Y)
Gets the bottom object on a map.
Definition: map.h:173
MAP_FLUSH
#define MAP_FLUSH
Always load map from the map directory, and don't do unique items or the like.
Definition: map.h:94
living::exp
int64_t exp
Experience.
Definition: living.h:47
S_IWUSR
#define S_IWUSR
Definition: win32.h:47
shopitems::strength
int8_t strength
The degree of specialisation the shop has in this item, as a percentage from -100 to 100.
Definition: map.h:302
PLAYER
@ PLAYER
Definition: object.h:112
object_get_owner
object * object_get_owner(object *op)
Returns the object which this object marks as being the owner.
Definition: object.cpp:789
Settings::mapdir
const char * mapdir
Where the map files are.
Definition: global.h:252
output_file.h
path.h
FREE_AND_CLEAR_STR_IF
#define FREE_AND_CLEAR_STR_IF(xyz)
Definition: global.h:202
global.h
settings
struct Settings settings
Global settings.
Definition: init.cpp:139
MOVE_WALK
#define MOVE_WALK
Object walks.
Definition: define.h:383
safe_strncpy
#define safe_strncpy
Definition: compat.h:27
FOR_MAP_FINISH
#define FOR_MAP_FINISH()
Finishes FOR_MAP_PREPARE().
Definition: define.h:714
SAVE_MODE
#define SAVE_MODE
If you have defined SAVE_PLAYER, you might want to change this, too.
Definition: config.h:563
llevError
@ llevError
Error, serious thing.
Definition: logger.h:11
P_BLOCKSVIEW
#define P_BLOCKSVIEW
This spot blocks the player's view.
Definition: map.h:229
MOVE_FLYING
#define MOVE_FLYING
Combo of fly_low and fly_high.
Definition: define.h:386
EVENT_MAPUNLOAD
#define EVENT_MAPUNLOAD
A map is freed (includes swapping out)
Definition: events.h:64
LOG
void LOG(LogLevel logLevel, const char *format,...)
Logs a message to stderr, or to file.
Definition: logger.cpp:58
get_empty_map
mapstruct * get_empty_map(int sizex, int sizey)
Creates and returns a map of the specific size.
Definition: map.cpp:852
INS_MAP_LOAD
#define INS_MAP_LOAD
Disable lots of checkings.
Definition: object.h:585
of_close
int of_close(OutputFile *of)
Closes an output file.
Definition: output_file.cpp:61
SET_FLAG
#define SET_FLAG(xyz, p)
Definition: define.h:369
archetype::more
archetype * more
Next part of a linked object.
Definition: object.h:486
create_items_path
static void create_items_path(const char *s, char *buf, size_t size)
This makes absolute path to the itemfile where unique objects will be saved.
Definition: map.cpp:166
get_region_by_name
region * get_region_by_name(const char *region_name)
Gets a region by name.
Definition: region.cpp:45
of_open
FILE * of_open(OutputFile *of, const char *fname)
Opens an output file.
Definition: output_file.cpp:30
player
One player.
Definition: player.h:107
MAP_RESET_TIMEOUT
#define MAP_RESET_TIMEOUT(m)
Definition: map.h:67
FLAG_IS_LINKED
#define FLAG_IS_LINKED
The object is linked with other objects.
Definition: define.h:302
blocked_link
int blocked_link(object *ob, mapstruct *m, int16_t sx, int16_t sy)
Returns true if the given coordinate is blocked except by the object passed is not blocking.
Definition: map.cpp:354
strdup_local
#define strdup_local
Definition: compat.h:29
object::inv
object * inv
Pointer to the first object in the inventory.
Definition: object.h:298
delete_unique_items
static void delete_unique_items(mapstruct *m)
This goes through map 'm' and removes any unique items on the map.
Definition: map.cpp:1332
ready_map_name
mapstruct * ready_map_name(const char *name, int flags)
Makes sure the given map is loaded and swapped in.
Definition: map.cpp:1777
QUERY_FLAG
#define QUERY_FLAG(xyz, p)
Definition: define.h:371
MAP_STYLE
#define MAP_STYLE
Active objects shouldn't be put on active list.
Definition: map.h:97
S_IROTH
#define S_IROTH
Definition: win32.h:50
load_temporary_map
static int load_temporary_map(mapstruct *m)
Loads a map, which has been loaded earlier, from file.
Definition: map.cpp:1261
ob_move_block
bool ob_move_block(object *ob1, object *ob2)
Basic macro to see if ob2 blocks ob1 from moving onto this space.
Definition: map.cpp:327
MAP_LAYER_FLY1
#define MAP_LAYER_FLY1
Flying objects - creatures, spells.
Definition: map.h:48
has_been_loaded
mapstruct * has_been_loaded(const char *name)
Checks whether map has been loaded.
Definition: map.cpp:79
print_shop_string
static void print_shop_string(mapstruct *m, char *output_string, int size)
Opposite of parse string(), this puts the string that was originally fed in to the map (or something ...
Definition: map.cpp:955
MAP_LAYER_LIVING1
#define MAP_LAYER_LIVING1
Living creatures.
Definition: map.h:46
update_position
void update_position(mapstruct *m, int x, int y)
This function updates various attributes about a specific space on the map (what it looks like,...
Definition: map.cpp:2147
MAP_LOADING
#define MAP_LOADING
This map is being loaded.
Definition: map.h:131
map_light_on
int map_light_on(mapstruct *m, int x, int y)
Return the light level at position (X, Y) on map M.
Definition: map.cpp:2729
Settings::datadir
const char * datadir
Read only data files.
Definition: global.h:249
add_face_layer
static void add_face_layer(int low_layer, int high_layer, object *ob, object *layers[], int honor_visibility)
This function is used for things that can have multiple layers - NO_PICK, ITEM, LIVING,...
Definition: map.cpp:2078
object::arch
struct archetype * arch
Pointer to archetype.
Definition: object.h:424
P_NO_CLERIC
#define P_NO_CLERIC
No clerical spells cast here.
Definition: map.h:241
stringbuffer_new
StringBuffer * stringbuffer_new(void)
Create a new string buffer.
Definition: stringbuffer.cpp:57
SHOP_FLOOR
@ SHOP_FLOOR
Definition: object.h:188
if
if(!(yy_init))
Definition: loader.cpp:36435
object::x
int16_t x
Definition: object.h:335
maps_saved_total
int maps_saved_total
Definition: logger.cpp:40
MAP_IN_MEMORY
#define MAP_IN_MEMORY
Map is fully loaded.
Definition: map.h:129
MAP_LAYER_ITEM3
#define MAP_LAYER_ITEM3
Definition: map.h:45
object::map
struct mapstruct * map
Pointer to the map in which this object is present.
Definition: object.h:305
MoveType
unsigned char MoveType
Typdef here to define type large enough to hold bitmask of all movement types.
Definition: define.h:409
shopitems::index
int index
Being the size of the shopitems array.
Definition: map.h:304
SET_MAP_MOVE_ON
#define SET_MAP_MOVE_ON(M, X, Y, C)
Sets the move_on state of a square.
Definition: map.h:207
CHECK_INV
@ CHECK_INV
b.t.
Definition: object.h:174
CALLOC
#define CALLOC(x, y)
Definition: compat.h:31
FLAG_WIZ
#define FLAG_WIZ
Object has special privilegies.
Definition: define.h:218
map_path
void map_path(const char *map, int flags, char *pathname, size_t bufsize)
Definition: map.cpp:1174
map_layer_info
static const Map_Layer_Info map_layer_info[MAP_LAYERS]
the ob->map_layer holds the low layer.
Definition: map.cpp:63
MAP_LAYERS
#define MAP_LAYERS
This correspondes to the map layers in the map2 protocol.
Definition: map.h:32
MAP_LAYER_NO_PICK2
#define MAP_LAYER_NO_PICK2
Non pickable ground objects.
Definition: map.h:42
flags
static const flag_definition flags[]
Flag mapping.
Definition: gridarta-types-convert.cpp:101
typedata::name
const char * name
Object name.
Definition: define.h:91
clean_object
void clean_object(object *op)
Remove and free all objects in the inventory of the given object.
Definition: map.cpp:1596
load_object
int load_object(FILE *fp, object *op, int bufstate, int map_flags, bool artifact_init)
Loads an object from the given file-pointer.
Definition: loader.cpp:38953
PROFILE_BEGIN
#define PROFILE_BEGIN(expr)
Definition: global.h:364
MAP_LAYER_FLOOR
#define MAP_LAYER_FLOOR
Definition: map.h:40
typedata::name_pl
const char * name_pl
Plural name.
Definition: define.h:92
dump_map
void dump_map(const mapstruct *m)
Prints out debug-information about a map.
Definition: map.cpp:245
NDI_NAVY
#define NDI_NAVY
Definition: newclient.h:248
blank_face
const Face * blank_face
Following can just as easily be pointers, but it is easier to keep them like this.
Definition: image.cpp:36
TRANSPORT
@ TRANSPORT
see doc/Developers/objects
Definition: object.h:113
LO_NEWFILE
#define LO_NEWFILE
Definition: loader.h:17
MAP_LAYER_NO_PICK1
#define MAP_LAYER_NO_PICK1
Non pickable ground objects.
Definition: map.h:41
rv_vector::part
object * part
Part we found.
Definition: map.h:378
object::title
sstring title
Of foo, etc.
Definition: object.h:325
mapstruct::path
char path[HUGE_BUF]
Filename of the map.
Definition: map.h:358
FLAG_CAN_ROLL
#define FLAG_CAN_ROLL
Object can be rolled.
Definition: define.h:241
GET_MAP_FACE_OBJS
#define GET_MAP_FACE_OBJS(M, X, Y)
Returns the layers array so update_position can just copy the entire array over.
Definition: map.h:190
MSG_TYPE_MISC
#define MSG_TYPE_MISC
Messages that don't go elsewhere.
Definition: newclient.h:417
free_all_maps
void free_all_maps(void)
Frees all allocated maps.
Definition: map.cpp:1991
buf
StringBuffer * buf
Definition: readable.cpp:1565
object::above
object * above
Pointer to the object stacked above this one.
Definition: object.h:296
HUGE_BUF
#define HUGE_BUF
Used for messages - some can be quite long.
Definition: define.h:37
ihypot
int ihypot(int a, int b)
Rough estimate of hypot(a, b).
Definition: utils.cpp:570
Map_Layer_Info::honor_visibility
uint8_t honor_visibility
If 0 then don't reorder items, else allow.
Definition: map.cpp:54
name
Plugin animator file specs[Config] name
Definition: animfiles.txt:4
mapstruct::width
uint16_t width
Definition: map.h:340
FLAG_REMOVED
#define FLAG_REMOVED
Object is not in any map or invenory.
Definition: define.h:219
draw_ext_info
vs only yadda is in because all tags get reset on the next draw_ext_info In the second since it is all in one draw_ext_info
Definition: media-tags.txt:61
rv_vector::distance_y
int distance_y
Y delta.
Definition: map.h:376
map_remove_unique_files
void map_remove_unique_files(const mapstruct *map)
Remove files containing the map's unique items.
Definition: map.cpp:2668
LO_NOREAD
#define LO_NOREAD
Definition: loader.h:18
typedata
Link an object type with skill needed to identify, and general name.
Definition: define.h:89
save_objects
int save_objects(mapstruct *m, FILE *fp, FILE *fp2, int flag)
This saves all the objects on the map in a non destructive fashion.
Definition: map.cpp:725
PROFILE_END
#define PROFILE_END(var, expr)
Definition: global.h:369
FLAG_ALIVE
#define FLAG_ALIVE
Object can fight (or be fought)
Definition: define.h:217
object::y
int16_t y
Position in the map for this object.
Definition: object.h:335
m
static event_registration m
Definition: citylife.cpp:424
set_darkness_map
void set_darkness_map(mapstruct *m)
Set the darkness level for a map, based on the time of the day.
Definition: main.cpp:371
rv_vector::distance_x
int distance_x
X delta.
Definition: map.h:375
MOVE_ALL
#define MOVE_ALL
Mask of all movement types.
Definition: define.h:389
NUM_FACINGS
#define NUM_FACINGS(ob)
Definition: global.h:174
stringbuffer_finish
char * stringbuffer_finish(StringBuffer *sb)
Deallocate the string buffer instance and return the string.
Definition: stringbuffer.cpp:76
apply_auto_fix
void apply_auto_fix(mapstruct *m)
Go through the entire map (only the first time when an original map is loaded) and performs special a...
Definition: main.cpp:258
MAP_DIFFICULTY
#define MAP_DIFFICULTY(m)
Definition: map.h:68
object_free_drop_inventory
void object_free_drop_inventory(object *ob)
Frees everything allocated by an object, removes it from the list of used objects,...
Definition: object.cpp:1545
MAP_MINTIMEOUT
#define MAP_MINTIMEOUT
At least that many ticks before swapout.
Definition: config.h:409
map_size
uint32_t map_size(mapstruct *m)
Calculate map size without intermediate sign extension.
Definition: map.cpp:808
SAVE_FLAG_NO_REMOVE
#define SAVE_FLAG_NO_REMOVE
If set, objects are not removed while saving.
Definition: map.h:110
MAP_LAYER_FLY2
#define MAP_LAYER_FLY2
Arrows, etc.
Definition: map.h:49
object_value_set_shared
bool object_value_set_shared(const object *op, sstring key)
Determine if an extra value is set to a non empty or 0 value.
Definition: object.cpp:4375
of_cancel
void of_cancel(OutputFile *of)
Cancels a save process.
Definition: output_file.cpp:89
get_typedata
const typedata * get_typedata(int itemtype)
Definition: item.cpp:328
FLAG_UNPAID
#define FLAG_UNPAID
Object hasn't been paid for yet.
Definition: define.h:223
P_NO_MAGIC
#define P_NO_MAGIC
Spells (some) can't pass this object.
Definition: map.h:230
MSG_TYPE_ATTACK_NOKEY
#define MSG_TYPE_ATTACK_NOKEY
Keys are like attacks, so...
Definition: newclient.h:621
FREE_OBJ_NO_DESTROY_CALLBACK
#define FREE_OBJ_NO_DESTROY_CALLBACK
Do not run the destroy callback.
Definition: object.h:545
stats.h
check_inv_recursive
object * check_inv_recursive(object *op, const object *trig)
Checks object and its inventory for specific item.
Definition: button.cpp:782
SAVE_FLAG_SAVE_UNPAID
#define SAVE_FLAG_SAVE_UNPAID
If set, unpaid items will be saved.
Definition: map.h:109
path_combine_and_normalize
char * path_combine_and_normalize(const char *src, const char *dst, char *path, size_t size)
Combines the 2 paths.
Definition: path.cpp:172
load_unique_objects
static void load_unique_objects(mapstruct *m)
Loads unique objects from file(s) into the map which is in memory.
Definition: map.cpp:1357
FLAG_NO_MAGIC
#define FLAG_NO_MAGIC
Spells (some) can't pass this object.
Definition: define.h:263
archetype::clone
object clone
An object from which to do object_copy()
Definition: object.h:487
SAVE_ERROR_RCREATION
#define SAVE_ERROR_RCREATION
Couldn't create the regular save file.
Definition: map.h:143
add_string
sstring add_string(const char *str)
Share a string.
Definition: shstr.cpp:137
FLAG_MONSTER
#define FLAG_MONSTER
Will attack players.
Definition: define.h:232
first_map
mapstruct * first_map
First map.
Definition: init.cpp:107
HEAD
#define HEAD(op)
Returns the head part of an object.
Definition: object.h:607
clean_tmp_map
void clean_tmp_map(mapstruct *m)
Removse the temporary file used by the map.
Definition: map.cpp:1982
MAP_OVERLAY
#define MAP_OVERLAY
Map to load is an overlay.
Definition: map.h:98
MAP_WHEN_RESET
#define MAP_WHEN_RESET(m)
This is when the map will reset.
Definition: map.h:65
change_map_light
int change_map_light(mapstruct *m, int change)
Used to change map light level (darkness) up or down.
Definition: map.cpp:2023
object::move_type
MoveType move_type
Type of movement this object uses.
Definition: object.h:436
ext_info_map
void void ext_info_map(int color, const mapstruct *map, uint8_t type, uint8_t subtype, const char *str1)
Writes to everyone on the specified map.
Definition: main.cpp:334
mapfile_load_lowlevel
mapstruct * mapfile_load_lowlevel(const char *map, const char *pathname, int flags)
Definition: map.cpp:1184
object::face
const Face * face
Face with colors.
Definition: object.h:341
out_of_map
int out_of_map(mapstruct *m, int x, int y)
Return 1 if coordinates X and Y are out of the map M, taking into account tiling.
Definition: map.cpp:2323
MAX_DARKNESS
#define MAX_DARKNESS
Maximum map darkness, there is no practical reason to exceed this.
Definition: define.h:439
MSG_TYPE_ATTACK
#define MSG_TYPE_ATTACK
Attack related messages.
Definition: newclient.h:413
isqrt
int isqrt(int n)
Compute the square root.
Definition: utils.cpp:562
object::type
uint8_t type
PLAYER, BULLET, etc.
Definition: object.h:348
t
in that case they will be relative to whatever the PWD of the crossfire server process is You probably shouldn t
Definition: server-directories.txt:28
SET_MAP_FLAGS
#define SET_MAP_FLAGS(M, X, Y, C)
Sets map flags.
Definition: map.h:162
remove_button_link
void remove_button_link(object *op)
Remove the object from the linked lists of buttons in the map.
Definition: button.cpp:693
SAVE_MODE_OVERLAY
#define SAVE_MODE_OVERLAY
Map is persisted as an overlay.
Definition: map.h:121
FLAG_BLOCKSVIEW
#define FLAG_BLOCKSVIEW
Object blocks view.
Definition: define.h:256
SAVE_ERROR_UCREATION
#define SAVE_ERROR_UCREATION
Couldn't create the file for unique objects.
Definition: map.h:144
shopitems::name_pl
const char * name_pl
Plural name.
Definition: map.h:300
object_free
void object_free(object *ob, int flags)
Frees everything allocated by an object, removes it from the list of used objects,...
Definition: object.cpp:1577
GET_MAP_MOVE_BLOCK
#define GET_MAP_MOVE_BLOCK(M, X, Y)
Gets the blocking state of a square.
Definition: map.h:195
FOR_INV_FINISH
#define FOR_INV_FINISH()
Finishes FOR_INV_PREPARE().
Definition: define.h:661
FLAG_NO_PICK
#define FLAG_NO_PICK
Object can't be picked up.
Definition: define.h:226
P_PLAYER
#define P_PLAYER
There is a player on this space.
Definition: map.h:239
MAP_DEFAULTRESET
#define MAP_DEFAULTRESET
Default time to reset.
Definition: config.h:427
INS_ON_TOP
#define INS_ON_TOP
Always put object on top.
Definition: object.h:583
P_NEED_UPDATE
#define P_NEED_UPDATE
This space is out of date.
Definition: map.h:242
free_map
void free_map(mapstruct *m)
Frees everything allocated by the given mapstructure.
Definition: map.cpp:1659
level_exp
int64_t level_exp(int level, double expmul)
Returns how much experience is needed for a player to become the given level.
Definition: living.cpp:1885
free_all_objects
static void free_all_objects(mapstruct *m)
Remove and free all objects in the given map.
Definition: map.cpp:1612
archetype
The archetype structure is a set of rules on how to generate and manipulate objects which point to ar...
Definition: object.h:483
P_OUT_OF_MAP
#define P_OUT_OF_MAP
This space is outside the map.
Definition: map.h:252
sproto.h
GET_MAP_LIGHT
#define GET_MAP_LIGHT(M, X, Y)
Gets map light.
Definition: map.h:165
get_map_from_coord
mapstruct * get_map_from_coord(mapstruct *m, int16_t *x, int16_t *y)
This is basically the same as out_of_map above(), but instead we return NULL if no map is valid (coor...
Definition: map.cpp:2351
MapSpace
This structure contains all information related to one map square.
Definition: map.h:259
FLAG_IS_FLOOR
#define FLAG_IS_FLOOR
Can't see what's underneath this object.
Definition: define.h:289
cf_random
uint32_t cf_random(void)
Definition: cf_random.cpp:5
get_rangevector_from_mapcoord
int get_rangevector_from_mapcoord(const mapstruct *m, int x, int y, const object *op2, rv_vector *retval)
This is basically the same as get_rangevector() above, but instead of the first parameter being an ob...
Definition: map.cpp:2590
map_find_by_flag
object * map_find_by_flag(mapstruct *map, int x, int y, int flag)
Finds an object in a map tile by flag number.
Definition: map.cpp:2651
delete_map
void delete_map(mapstruct *m)
Frees the map, including the mapstruct.
Definition: map.cpp:1705
FLAG_OVERLAY_FLOOR
#define FLAG_OVERLAY_FLOOR
Object is an overlay floor.
Definition: define.h:242
MSG_SUBTYPE_NONE
#define MSG_SUBTYPE_NONE
Definition: newclient.h:424
INS_NO_WALK_ON
#define INS_NO_WALK_ON
Don't call check_walk_on against the originator.
Definition: object.h:582
ob_blocked
int ob_blocked(const object *ob, mapstruct *m, int16_t x, int16_t y)
Returns true if the given object can't fit in the given spot.
Definition: map.cpp:489
NDI_BLACK
#define NDI_BLACK
Definition: newclient.h:246
object_insert_in_map_at
object * object_insert_in_map_at(object *op, mapstruct *m, object *originator, int flag, int x, int y)
Same as object_insert_in_map() except it handle separate coordinates and do a clean job preparing mul...
Definition: object.cpp:2085
SAVE_MODE_NORMAL
#define SAVE_MODE_NORMAL
No special handling.
Definition: map.h:119
mapstruct::last_reset_time
long last_reset_time
A timestamp of the last original map loading.
Definition: map.h:359
link_multipart_objects
static void link_multipart_objects(mapstruct *m)
Go through all the objects on the map looking for objects whose arch says they are multipart yet acco...
Definition: map.cpp:585
get_typedata_by_name
const typedata * get_typedata_by_name(const char *name)
Definition: item.cpp:348
fatal
void fatal(enum fatal_error err)
fatal() is meant to be called whenever a fatal signal is intercepted.
Definition: utils.cpp:590
MAP_NO_DIFFICULTY
#define MAP_NO_DIFFICULTY
If set then don't compute a map difficulty if it is 0.
Definition: map.h:96
get_linked_map
mapstruct * get_linked_map(void)
Allocates, initialises, and returns a pointer to a mapstruct, linked through first_map.
Definition: map.cpp:786
seconds
long seconds(void)
Return wall clock time in seconds.
Definition: time.cpp:348
MAP_WIDTH
#define MAP_WIDTH(m)
Map width.
Definition: map.h:76
maps_loaded_total
int maps_loaded_total
Definition: logger.cpp:39
create_template_pathname
void create_template_pathname(const char *name, char *buf, size_t size)
same as create_pathname(), but for the template maps.
Definition: map.cpp:145
MAX_BUF
#define MAX_BUF
Used for all kinds of things.
Definition: define.h:35
EVENT_MAPREADY
#define EVENT_MAPREADY
A map is ready, either first load or after reload.
Definition: events.h:62
strlcpy
size_t strlcpy(char *dst, const char *src, size_t size)
Portable implementation of strlcpy(3).
Definition: porting.cpp:222
map_space
MapSpace * map_space(const mapstruct *m, int x, int y)
Definition: map.cpp:2717
object_new
object * object_new(void)
Grabs an object from the list of unused objects, makes sure it is initialised, and returns it.
Definition: object.cpp:1258
create_overlay_pathname
void create_overlay_pathname(const char *name, char *buf, size_t size)
Same as create_pathname(), but for the overlay maps.
Definition: map.cpp:125
OB_MOVE_BLOCK
#define OB_MOVE_BLOCK(ob1, ob2)
Definition: define.h:410
shopitems::typenum
int typenum
Itemtype number we need to match, -1 if it is the default price.
Definition: map.h:301
object::head
object * head
Points to the main object of a large body.
Definition: object.h:304
set_map_reset_time
void set_map_reset_time(mapstruct *map)
Updates the map's timeout.
Definition: map.cpp:2262
free_string
void free_string(sstring str)
This will reduce the refcount, and if it has reached 0, str will be freed.
Definition: shstr.cpp:294
Settings::playerdir
const char * playerdir
Where the player files are.
Definition: global.h:251
StringBuffer
A buffer that will be expanded as content is added to it.
Definition: stringbuffer.cpp:25
FLAG_DAMNED
#define FLAG_DAMNED
The object is very cursed.
Definition: define.h:304
SET_MAP_MOVE_SLOW
#define SET_MAP_MOVE_SLOW(M, X, Y, C)
Sets the slowing state of a square.
Definition: map.h:202
FOR_MAP_PREPARE
#define FOR_MAP_PREPARE(map_, mx_, my_, it_)
Constructs a loop iterating over all objects of a map tile.
Definition: define.h:707
OUT_OF_REAL_MAP
#define OUT_OF_REAL_MAP(M, X, Y)
Checks if a square is out of the map.
Definition: map.h:220
SAVE_ERROR_URENAME
#define SAVE_ERROR_URENAME
Couldn't rename unique temporary file.
Definition: map.h:147
find_dir_2
int find_dir_2(int x, int y)
Computes a direction which you should travel to move of x and y.
Definition: object.cpp:3662
load_and_link_tiled_map
static mapstruct * load_and_link_tiled_map(mapstruct *orig_map, int tile_num)
This updates the orig_map->tile_map[tile_num] value after loading the map.
Definition: map.cpp:2288
P_IS_ALIVE
#define P_IS_ALIVE
Something alive is on this space.
Definition: map.h:240
decay_objects
void decay_objects(mapstruct *m)
Decay and destroy persihable items in a map.
Definition: utils.cpp:175
NDI_UNIQUE
#define NDI_UNIQUE
Print immediately, don't buffer.
Definition: newclient.h:266
FLAG_GENERATOR
#define FLAG_GENERATOR
Will generate type ob->stats.food.
Definition: define.h:235
object::name
sstring name
The name of the object, obviously...
Definition: object.h:319
Map_Layer_Info
Information about a layer.
Definition: map.cpp:52
load_map_header
static int load_map_header(FILE *fp, mapstruct *m)
This loads the header information of the map.
Definition: map.cpp:997
INS_ABOVE_FLOOR_ONLY
#define INS_ABOVE_FLOOR_ONLY
Put object immediatly above the floor.
Definition: object.h:581
FREE_AND_CLEAR
#define FREE_AND_CLEAR(xyz)
Free the pointer and then set it to NULL.
Definition: global.h:195
shopitems::name
const char * name
Name of the item in question, null if it is the default item.
Definition: map.h:299
Map_Layer_Info::high_layer
uint8_t high_layer
Highest layer for this group.
Definition: map.cpp:53
adjacent_map
static int adjacent_map(const mapstruct *map1, const mapstruct *map2, int *dx, int *dy)
Return whether map2 is adjacent to map1.
Definition: map.cpp:2445
Face::visibility
uint8_t visibility
How visible is the face compared to other faces, highest wins.
Definition: face.h:16
get_map_flags
int get_map_flags(mapstruct *oldmap, mapstruct **newmap, int16_t x, int16_t y, int16_t *nx, int16_t *ny)
This rolls up wall, blocks_magic, blocks_view, etc, all into one function that just returns a P_.
Definition: map.cpp:300
mapstruct
This is a game-map.
Definition: map.h:318
object::env
object * env
Pointer to the object which is the environment.
Definition: object.h:301
create_pathname
char * create_pathname(const char *name, char *buf, size_t size)
Get the full path to a map file.
Definition: map.cpp:104
floor
Magical Runes Runes are magical inscriptions on the dungeon floor
Definition: runes-guide.txt:3
msgbuf
static char msgbuf[HUGE_BUF]
Definition: loader.cpp:35880
P_NO_ERROR
#define P_NO_ERROR
Purely temporary - if set, update_position does not complain if the flags are different.
Definition: map.h:243
MAP_LAYER_ITEM1
#define MAP_LAYER_ITEM1
Items that can be picked up.
Definition: map.h:43
MapSpace::flags
uint8_t flags
Flags about this space (see the P_ values above).
Definition: map.h:263
animate_object
void animate_object(object *op, int dir)
Updates the face-variable of an object.
Definition: anim.cpp:44
mapstruct::name
char * name
Name of map as given by its creator.
Definition: map.h:321
AB_NO_PASS
#define AB_NO_PASS
Definition: map.h:238
shop_contains
bool shop_contains(object *ob)
Check if an object is in a shop.
Definition: map.cpp:2763
mapstruct::in_memory
uint32_t in_memory
Combination of IN_MEMORY_xxx flags.
Definition: map.h:338
MAP_SWAPPED
#define MAP_SWAPPED
Map spaces have been saved to disk.
Definition: map.h:130
rv_vector
This is used by get_rangevector to determine where the other creature is.
Definition: map.h:373
update_buttons
void update_buttons(mapstruct *m)
Updates every button on the map (by calling update_button() for them).
Definition: button.cpp:227
objects
object * objects
Pointer to the list of used objects.
Definition: object.cpp:294
shopitems
Shop-related information for a map.
Definition: map.h:298
object_get_value
sstring object_get_value(const object *op, const char *const key)
Get an extra value by key.
Definition: object.cpp:4331
map_get_path
const char * map_get_path(const object *item)
Return the map path on which the specified item is.
Definition: map.cpp:2693
SET_MAP_MOVE_BLOCK
#define SET_MAP_MOVE_BLOCK(M, X, Y, C)
Sets the blocking state of a square.
Definition: map.h:197
on_same_map
int on_same_map(const object *op1, const object *op2)
Checks whether 2 objects are on the same map or not.
Definition: map.cpp:2628
CLEAR_FLAG
#define CLEAR_FLAG(xyz, p)
Definition: define.h:370
map_path_unique
bool map_path_unique(const char *path)
Return true if the given map path leads to a unique map.
Definition: map.cpp:2713
MAP_HEIGHT
#define MAP_HEIGHT(m)
Map height.
Definition: map.h:78
save_object_in_sb
void save_object_in_sb(StringBuffer *sb, object *op, const int flag)
Store a string representation of op in sb.
Definition: object.cpp:5296
NUM_ANIMATIONS
#define NUM_ANIMATIONS(ob)
Definition: global.h:173
MAP_ENTER_Y
#define MAP_ENTER_Y(m)
Default Y coordinate for map enter.
Definition: map.h:85
strip_endline
void strip_endline(char *buf)
Removes endline from buffer (modified in place).
Definition: utils.cpp:314
mapstruct::tile_map
mapstruct * tile_map[4]
Adjoining maps.
Definition: map.h:357
typedata::number
int number
Type.
Definition: define.h:90
object_remove_from_active_list
void object_remove_from_active_list(object *op)
This function removes object 'op' from the list of active objects.
Definition: object.cpp:1377
INS_NO_MERGE
#define INS_NO_MERGE
Don't try to merge with other items.
Definition: object.h:580
arch_to_object
object * arch_to_object(archetype *at)
Creates and returns a new object which is a copy of the given archetype.
Definition: arch.cpp:227
mapstruct::spaces
MapSpace * spaces
Array of spaces on this map.
Definition: map.h:348
S_IRUSR
#define S_IRUSR
Definition: win32.h:56
get_rangevector
int get_rangevector(object *op1, const object *op2, rv_vector *retval, int flags)
From map.c This is used by get_player to determine where the other creature is.
Definition: map.cpp:2522
update_all_map_los
void update_all_map_los(mapstruct *map)
update all_map_los is like update_all_los() below, but updates everyone on the map,...
Definition: los.cpp:567
allocate_map
void allocate_map(mapstruct *m)
This basically allocates the dynamic array of spaces for the map.
Definition: map.cpp:822
MAP_PLAYER_UNIQUE
#define MAP_PLAYER_UNIQUE
This map is player-specific.
Definition: map.h:95
FMT64U
#define FMT64U
Definition: compat.h:17
loader.h
object_fix_multipart
void object_fix_multipart(object *tmp)
Ensures specified object has its more parts correctly inserted in map.
Definition: object.cpp:4670
S_IWOTH
#define S_IWOTH
Definition: win32.h:41
fix_container_multipart
static void fix_container_multipart(object *container)
Go through all the objects in a container (recursively) looking for objects whose arch says they are ...
Definition: map.cpp:544
FLAG_OBJ_ORIGINAL
#define FLAG_OBJ_ORIGINAL
NEVER SET THIS.
Definition: define.h:344
MAP_ENTER_X
#define MAP_ENTER_X(m)
Default X coordinate for map enter.
Definition: map.h:83
Settings::templatedir
const char * templatedir
Directory for the template map.
Definition: global.h:255
object_remove
void object_remove(object *op)
This function removes the object op from the linked list of objects which it is currently tied to.
Definition: object.cpp:1818
GET_MAP_FLAGS
#define GET_MAP_FLAGS(M, X, Y)
Gets map flags.
Definition: map.h:160
DOOR
@ DOOR
Definition: object.h:131
object_sum_weight
signed long object_sum_weight(object *op)
object_sum_weight() is a recursive function which calculates the weight an object is carrying.
Definition: object.cpp:553
EVENT_MAPLOAD
#define EVENT_MAPLOAD
A map is loaded (pristine state)
Definition: events.h:61
LL_NORMAL
#define LL_NORMAL
Definition: loader.h:12
OB_TYPE_MOVE_BLOCK
#define OB_TYPE_MOVE_BLOCK(ob1, type)
Basic macro to see if if ob1 can not move onto a space based on the 'type' move_block parameter Add c...
Definition: define.h:418
SAVE_ERROR_CLOSE
#define SAVE_ERROR_CLOSE
Close error for regular file.
Definition: map.h:148
S_IWGRP
#define S_IWGRP
Definition: win32.h:44
make_path_to_file
void make_path_to_file(const char *filename)
Checks if any directories in the given path doesn't exist, and creates if necessary.
Definition: porting.cpp:164
mapstruct::unique
uint32_t unique
If set, this is a per player unique map.
Definition: map.h:331
save_map
int save_map(mapstruct *m, int flag)
Saves a map to file.
Definition: map.cpp:1404
calculate_difficulty
int calculate_difficulty(mapstruct *m)
This routine is supposed to find out the difficulty of the map.
Definition: map.cpp:1925
mapstruct::next
mapstruct * next
Next map, linked list.
Definition: map.h:319
object::stats
living stats
Str, Con, Dex, etc.
Definition: object.h:378
object::more
object * more
Pointer to the rest of a large body of objects.
Definition: object.h:303
P_NEW_MAP
#define P_NEW_MAP
Coordinates passed result in a new tiled map.
Definition: map.h:253
SET_MAP_PLAYER
#define SET_MAP_PLAYER(M, X, Y, C)
Definition: map.h:170
blocks_prayer
sstring blocks_prayer
For update_position() mostly.
Definition: init.cpp:126
Settings::tmpdir
const char * tmpdir
Directory to use for temporary files.
Definition: global.h:256
mapfile_load
mapstruct * mapfile_load(const char *map, int flags)
Opens the file "filename" and reads information about the map from the given file,...
Definition: map.cpp:1225
LO_REPEAT
#define LO_REPEAT
Definition: loader.h:15
parse_shop_string
static shopitems * parse_shop_string(const char *input_string, const mapstruct *map)
Takes a string from a map definition and outputs a pointer to the array of shopitems corresponding to...
Definition: map.cpp:874
FLAG_UNIQUE
#define FLAG_UNIQUE
Item is really unique (UNIQUE_ITEMS)
Definition: define.h:274
OUT_OF_MEMORY
@ OUT_OF_MEMORY
Definition: define.h:48
SAVE_ERROR_OK
#define SAVE_ERROR_OK
No error.
Definition: map.h:142
MAP_MAXRESET
#define MAP_MAXRESET
MAP_MAXRESET is the maximum time a map can have before being reset.
Definition: config.h:425
rv_vector::direction
int direction
General direction to the targer.
Definition: map.h:377
SET_MAP_LIGHT
#define SET_MAP_LIGHT(M, X, Y, L)
Sets map light.
Definition: map.h:167
SAVE_ERROR_NO_PATH
#define SAVE_ERROR_NO_PATH
Map had no path set.
Definition: map.h:146
rv_vector::distance
unsigned int distance
Distance, in squares.
Definition: map.h:374
map_reset_swap
void map_reset_swap(mapstruct *m)
Call this when an in-memory map is used or referenced.
Definition: map.cpp:1759
map_layer_name
const char *const map_layer_name[MAP_LAYERS]
These correspond to the layer names in map.h - since some of the types can be on multiple layers,...
Definition: map.cpp:46
object::move_block
MoveType move_block
What movement types this blocks.
Definition: object.h:437
object::next
object * next
Pointer to the next object in the free/used list.
Definition: object.h:285
load_overlay_map
static int load_overlay_map(const char *filename, mapstruct *m)
Loads an overlay for a map, which has been loaded earlier, from file.
Definition: map.cpp:1297
FOR_INV_PREPARE
#define FOR_INV_PREPARE(op_, it_)
Constructs a loop iterating over the inventory of an object.
Definition: define.h:654
check_path
int check_path(const char *name, int prepend_dir)
This function checks if a file with the given path exists.
Definition: map.cpp:201
S_IRGRP
#define S_IRGRP
Definition: win32.h:53
MAX_LIGHT_RADII
#define MAX_LIGHT_RADII
Max radii for 'light' object, really large values allow objects that can slow down the game.
Definition: define.h:435
dump_all_maps
void dump_all_maps(void)
Prints out debug-information about all maps.
Definition: map.cpp:268
events_execute_global_event
void events_execute_global_event(int eventcode,...)
Execute a global event.
Definition: events.cpp:30
load_objects
void load_objects(mapstruct *m, FILE *fp, int mapflags)
Loads (and parses) the objects into a given map from the specified file pointer.
Definition: map.cpp:613
llevDebug
@ llevDebug
Only for debugging purposes.
Definition: logger.h:13
MAP_LAYER_LIVING2
#define MAP_LAYER_LIVING2
Definition: map.h:47
coords_in_shop
bool coords_in_shop(mapstruct *map, int x, int y)
Check if the given map coordinates are in a shop.
Definition: map.cpp:2756
MAP_SAVING
#define MAP_SAVING
Map being saved.
Definition: map.h:132
face
in that case they will be relative to whatever the PWD of the crossfire server process is You probably shouldn though Notes on Specific and settings file datadir Usually usr share crossfire Contains data that the server does not need to modify while such as the etc A default install will pack the and treasurelist definitions into a single or trs file and the graphics into a face(metadata) and .tar(bitmaps) file
LL_MORE
#define LL_MORE
Definition: loader.h:11
Settings::uniquedir
const char * uniquedir
Directory for the unique items.
Definition: global.h:254
OutputFile
Definition: output_file.h:41
SET_MAP_MOVE_OFF
#define SET_MAP_MOVE_OFF(M, X, Y, C)
Sets the move_off state of a square.
Definition: map.h:212
Settings::localdir
const char * localdir
Read/write data files.
Definition: global.h:250