Crossfire Server, Trunk
server.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 <assert.h>
22 #include <ctype.h>
23 #include <fcntl.h>
24 #include <math.h>
25 #include <stdlib.h>
26 #include <string.h>
27 #include <time.h>
28 
29 #ifndef WIN32
30 #include <unistd.h>
31 #endif
32 
33 /* FIXME: This is required on certain systems to get crypt(3) to work. */
34 #ifdef HAVE_CRYPT_H
35 #include <crypt.h>
36 #endif
37 
38 #include "object.h"
39 #include "path.h"
40 #include "random_maps/random_map.h"
41 #include "random_maps/rproto.h"
42 #include "sproto.h"
43 #include "tod.h"
44 #include "version.h"
45 #include "server.h"
46 
48 static const int shutdown_warn_times[] = {120, 90, 60, 45, 30, 15, 10, 5, 4, 3, 2, 1};
49 
51 static const char *days[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
52 
53 volatile sig_atomic_t shutdown_flag;
54 
70 static char const* crypt_string(char const *str, char const* salt) {
71 #if defined(WIN32)
72  // Windows will never attempt to crypt()
73  return str;
74 #else
75 #if (defined(__FreeBSD__))
76  // If legacy mode is enabled, do not crypt() on FreeBSD
77  if (settings.crypt_mode == 0) {
78  return str;
79  }
80 #endif
81  char s[3];
82 
83  if (salt == NULL) {
84  /* Generate a two-character salt for the DES cipher.
85  * We want the salt to be in this character set.
86  */
87  static const char *const c =
88  "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789./";
89  s[0] = c[RANDOM()%(int)strlen(c)],
90  s[1] = c[RANDOM()%(int)strlen(c)];
91  } else {
92  s[0] = salt[0],
93  s[1] = salt[1];
94  }
95  s[2] = '\0';
96 
97  return crypt(str, s);
98 #endif
99 }
100 
101 char const* newhash(char const *password) {
102  return crypt_string(password, NULL);
103 }
104 
114 bool check_password(const char *typed, const char *crypted) {
115  // An empty hashed password only matches an empty input password.
116  if (strlen(crypted) == 0) {
117  return strlen(typed) == 0 ? true : false;
118  }
119 
120  const char *typed_hashed = crypt_string(typed, crypted);
121  if (typed_hashed != NULL) {
122  return strcmp(typed_hashed, crypted) == 0;
123  } else {
124  LOG(llevError, "Could not check password with stored hash %s\n", crypted);
125  return false;
126  }
127 }
128 
138 void enter_player_savebed(object *op) {
139  mapstruct *oldmap = op->map;
140  object *tmp;
141 
142  tmp = object_new();
143 
144  EXIT_PATH(tmp) = add_string(op->contr->savebed_map);
145  EXIT_X(tmp) = op->contr->bed_x;
146  EXIT_Y(tmp) = op->contr->bed_y;
147  enter_exit(op, tmp);
148  /* If the player has not changed maps and the name does not match
149  * that of the savebed, his savebed map is gone. Lets go back
150  * to the emergency path. Update what the players savebed is
151  * while we're at it.
152  */
153  if (oldmap == op->map && strcmp(op->contr->savebed_map, oldmap->path)) {
154  LOG(llevDebug, "Player %s savebed location %s is invalid - going to emergency location (%s)\n",
155  settings.emergency_mapname, op->name, op->contr->savebed_map);
156  safe_strncpy(op->contr->savebed_map, settings.emergency_mapname, MAX_BUF);
157  op->contr->bed_x = settings.emergency_x;
158  op->contr->bed_y = settings.emergency_y;
159  free_string(op->contr->savebed_map);
160  EXIT_PATH(tmp) = add_string(op->contr->savebed_map);
161  EXIT_X(tmp) = op->contr->bed_x;
162  EXIT_Y(tmp) = op->contr->bed_y;
163  enter_exit(op, tmp);
164  }
166 }
167 
179 static void enter_map(object *op, mapstruct *newmap, int x, int y) {
180  mapstruct *oldmap = op->map;
181 
182  /* Default hp/sp for exits changed to -1 to use enter_x/enter_y values by default, but if one value
183  * is specified, we want the other to default to zero like before the change.
184  */
185  if (x < 0 && y >= 0) x=0;
186  if (y < 0 && x >= 0) y=0;
187 
188  if (out_of_map(newmap, x, y)) {
189  LOG(llevError, "enter_map: supplied coordinates are not within the map! (%s: %d, %d)\n", newmap->path, x, y);
190  /* If op has invalid (probably -1,-1) coordinates, force them to a correct value, else issues later on. */
191  if (op->x == x)
192  op->x = MAP_ENTER_X(newmap);
193  if (op->y == y)
194  op->y = MAP_ENTER_Y(newmap);
195  x = MAP_ENTER_X(newmap);
196  y = MAP_ENTER_Y(newmap);
197  if (out_of_map(newmap, x, y)) {
198  LOG(llevError, "enter_map: map %s provides invalid default enter location (%d, %d) > (%d, %d)\n", newmap->path, x, y, MAP_WIDTH(newmap), MAP_HEIGHT(newmap));
200  "The exit is closed");
201  return;
202  }
203  }
204  /* try to find a spot for the player */
205  if (ob_blocked(op, newmap, x, y)) { /* First choice blocked */
206  /* We try to find a spot for the player, starting closest in.
207  * We could use object_find_first_free_spot(), but that doesn't randomize it at all,
208  * So for example, if the north space is free, you would always end up there even
209  * if other spaces around are available.
210  * Note that for the second and third calls, we could start at a position other
211  * than one, but then we could end up on the other side of walls and so forth.
212  */
213  int i = object_find_free_spot(op, newmap, x, y, 1, SIZEOFFREE1+1);
214  if (i == -1) {
215  i = object_find_free_spot(op, newmap, x, y, 1, SIZEOFFREE2+1);
216  if (i == -1)
217  i = object_find_free_spot(op, newmap, x, y, 1, SIZEOFFREE);
218  }
219  if (i != -1) {
220  x += freearr_x[i];
221  y += freearr_y[i];
222  } else {
223  /* not much we can do in this case. */
224  LOG(llevInfo, "enter_map: Could not find free spot for player - will dump on top of object (%s: %d, %d)\n", newmap->path, x, y);
225  }
226  } /* end if looking for free spot */
227 
228  /* If it is a player login, he has yet to be inserted anyplace.
229  * otherwise, we need to deal with removing the playe here.
230  */
231  if (!QUERY_FLAG(op, FLAG_REMOVED))
232  object_remove(op);
233  /* object_remove clears these so they must be reset after the object_remove() call */
234  object_insert_in_map_at(op, newmap, NULL, INS_NO_WALK_ON, x, y);
235 
236  object_set_enemy(op, NULL);
237 
238  if (op->contr) {
239  safe_strncpy(op->contr->maplevel, newmap->path,
240  sizeof(op->contr->maplevel));
241  op->contr->count = 0;
242  }
243 
244  /* Update any golems */
245  if (op->type == PLAYER && op->contr->ranges[range_golem] != NULL) {
246  int i = object_find_free_spot(op->contr->ranges[range_golem], newmap, x, y, 1, SIZEOFFREE);
247  object_remove(op->contr->ranges[range_golem]);
248  if (i == -1) {
249  remove_friendly_object(op->contr->ranges[range_golem]);
250  object_free_drop_inventory(op->contr->ranges[range_golem]);
251  op->contr->ranges[range_golem] = NULL;
252  op->contr->golem_count = 0;
253  } else {
254  object_insert_in_map_at(op->contr->ranges[range_golem], newmap, NULL, 0, x+freearr_x[i], y+freearr_y[i]);
255  op->contr->ranges[range_golem]->direction = find_dir_2(op->x-op->contr->ranges[range_golem]->x, op->y-op->contr->ranges[range_golem]->y);
256  }
257  }
258  op->direction = 0;
259 
260  /* since the players map is already loaded, we don't need to worry
261  * about pending objects.
262  */
264 
265  /* If the player is changing maps, we need to do some special things
266  * Do this after the player is on the new map - otherwise the force swap of the
267  * old map does not work.
268  */
269  if (oldmap != newmap) {
270  player_map_change_common(op, oldmap, newmap);
271  }
272 
273  map_newmap_cmd(op->contr->socket);
274 }
275 
276 void player_map_change_common(object* op, mapstruct* const oldmap,
277  mapstruct* const newmap) {
278  if (oldmap != NULL) {
280 
281  /* can be less than zero due to errors in tracking this */
282  if (oldmap->players <= 0) {
283  set_map_timeout(oldmap);
284  }
285  }
286 
288  newmap->timeout = 0;
290 }
291 
298 void set_map_timeout(mapstruct *oldmap) {
299 #if MAP_MAXTIMEOUT
300  oldmap->timeout = MAP_TIMEOUT(oldmap);
301  /* Do MINTIMEOUT first, so that MAXTIMEOUT is used if that is
302  * lower than the min value.
303  */
304 #if MAP_MINTIMEOUT
305  if (oldmap->timeout < MAP_MINTIMEOUT) {
306  oldmap->timeout = MAP_MINTIMEOUT;
307  }
308 #endif
309  if (oldmap->timeout > MAP_MAXTIMEOUT) {
310  oldmap->timeout = MAP_MAXTIMEOUT;
311  }
312 #else
313  /* save out the map */
314  swap_map(oldmap);
315 #endif /* MAP_MAXTIMEOUT */
316 }
317 
331 static char *clean_path(const char *file, char *newpath, int size) {
332  char *cp;
333 
334  strlcpy(newpath, file, size);
335  for (cp = newpath; *cp != '\0'; cp++) {
336  if (*cp == '/')
337  *cp = '_';
338  }
339  return newpath;
340 }
341 
359 static char *unclean_path(const char *src, char *newpath, int size) {
360  char *cp;
361 
362  cp = const_cast<char *>(strrchr(src, '/'));
363  if (cp)
364  strlcpy(newpath, cp+1, size);
365  else
366  strlcpy(newpath, src, size);
367 
368  for (cp = newpath; *cp != '\0'; cp++) {
369  if (*cp == '_')
370  *cp = '/';
371  }
372  return newpath;
373 }
374 
384 static void enter_random_map(object *pl, object *exit_ob) {
385  mapstruct *new_map;
386  char newmap_name[HUGE_BUF], buf[HUGE_BUF], *cp;
387  static int reference_number = 0;
388  RMParms rp;
389 
390  memset(&rp, 0, sizeof(RMParms));
391  rp.Xsize = -1;
392  rp.Ysize = -1;
393  rp.region = get_region_by_map(exit_ob->map);
394  if (exit_ob->msg)
395  set_random_map_variable(&rp, exit_ob->msg);
396  rp.origin_x = exit_ob->x;
397  rp.origin_y = exit_ob->y;
398  safe_strncpy(rp.origin_map, pl->map->path, sizeof(rp.origin_map));
399 
400  /* If we have a final_map, use it as a base name to give some clue
401  * as where the player is. Otherwise, use the origin map.
402  * Take the last component (after the last slash) to give
403  * shorter names without bogus slashes.
404  */
405  if (rp.final_map[0]) {
406  cp = strrchr(rp.final_map, '/');
407  if (!cp)
408  cp = rp.final_map;
409  } else {
410  cp = strrchr(rp.origin_map, '/');
411  if (!cp)
412  cp = rp.origin_map;
413  /* Need to strip of any trailing digits, if it has them */
414  strlcpy(buf, cp, sizeof(buf));
415  while (isdigit(buf[strlen(buf)-1]))
416  buf[strlen(buf)-1] = 0;
417  cp = buf;
418  }
419 
420  snprintf(newmap_name, sizeof(newmap_name), "/random/%s%04d", cp+1, reference_number++);
421 
422  /* now to generate the actual map. */
423  new_map = generate_random_map(newmap_name, &rp, NULL, exit_ob->map ? exit_ob->map->reset_group : NULL);
424 
425  /* Update the exit_ob so it now points directly at the newly created
426  * random maps. Not that it is likely to happen, but it does mean that a
427  * exit in a unique map leading to a random map will not work properly.
428  * It also means that if the created random map gets reset before
429  * the exit leading to it, that the exit will no longer work.
430  */
431  if (new_map) {
432  int x, y;
433 
434  x = EXIT_X(exit_ob) = MAP_ENTER_X(new_map);
435  y = EXIT_Y(exit_ob) = MAP_ENTER_Y(new_map);
436  EXIT_PATH(exit_ob) = add_string(newmap_name);
437  strlcpy(new_map->path, newmap_name, sizeof(new_map->path));
438  enter_map(pl, new_map, x, y);
439 
440  /* Make the initial map part of the same reset group so it doesn't
441  * reset before the random maps */
442  if (exit_ob->map && exit_ob->map->reset_group == NULL && new_map->reset_group) {
443  exit_ob->map->reset_group = add_string(new_map->reset_group);
444  }
445  }
446 }
447 
457 static void enter_fixed_template_map(object *pl, object *exit_ob) {
458  mapstruct *new_map;
459  char tmpnum[32], exitpath[HUGE_BUF], resultname[HUGE_BUF], tmpstring[HUGE_BUF], *sourcemap;
460  char sourcemap_buf[HUGE_BUF];
461  char new_map_name[MAX_BUF];
462 
463  /* Split the exit path string into two parts, one
464  * for where to store the map, and one for were
465  * to generate the map from.
466  */
467  strlcpy(exitpath, EXIT_PATH(exit_ob)+2, sizeof(exitpath));
468  sourcemap = strchr(exitpath, '!');
469  if (!sourcemap) {
472  "The %s is closed.",
473  exit_ob->name);
474  LOG(llevError, "enter_fixed_template_map: Exit %s (%d,%d) on map %s has no source template.\n", exit_ob->name, exit_ob->x, exit_ob->y, exit_ob->map->path);
475  return;
476  }
477  *sourcemap++ = '\0';
478 
479  /* If we are not coming from a template map, we can use relative directories
480  * for the map to generate from.
481  */
482  if (!exit_ob->map->is_template) {
483  /* We can't use exitpath directly, as sourcemap points there. */
484  path_combine_and_normalize(exit_ob->map->path, sourcemap, sourcemap_buf, sizeof(sourcemap_buf));
485  sourcemap = sourcemap_buf;
486  }
487 
488  /* Do replacement of %x, %y, and %n to the x coord of the exit, the y coord
489  * of the exit, and the name of the map the exit is on, respectively.
490  */
491  snprintf(tmpnum, sizeof(tmpnum), "%d", exit_ob->x);
492  replace(exitpath, "%x", tmpnum, resultname, sizeof(resultname));
493 
494  snprintf(tmpnum, sizeof(tmpnum), "%d", exit_ob->y);
495  strlcpy(tmpstring, resultname, sizeof(tmpstring));
496  replace(tmpstring, "%y", tmpnum, resultname, sizeof(resultname));
497 
498  strlcpy(tmpstring, resultname, sizeof(tmpstring));
499  replace(tmpstring, "%n", exit_ob->map->name, resultname, sizeof(resultname));
500 
501  /* If we are coming from another template map, use reletive paths unless
502  * indicated otherwise.
503  */
504  if (exit_ob->map->is_template && (resultname[0] != '/')) {
505  path_combine_and_normalize(exit_ob->map->path, resultname, new_map_name, sizeof(new_map_name));
506  } else {
507  create_template_pathname(resultname, new_map_name, sizeof(new_map_name));
508  }
509 
510  /* Attempt to load the map, if unable to, then
511  * create the map from the template.
512  */
513  new_map = ready_map_name(new_map_name, MAP_PLAYER_UNIQUE);
514  if (!new_map) {
515  char path[MAX_BUF];
516  create_pathname(sourcemap, path, MAX_BUF);
517  new_map = mapfile_load(path, MAP_PLAYER_UNIQUE);
518  if (!new_map) {
520  MSG_TYPE_COMMAND_FAILURE, "The %s is closed.",
521  exit_ob->name);
522  LOG(llevError,
523  "Template exit in '%s' (%d, %d) does not reference a valid "
524  "template. Make sure a template exists at '%s'.\n",
525  exit_ob->map->path, exit_ob->x, exit_ob->y, path);
526  return;
527  }
528  }
529 
530  assert(new_map);
531  /* set the path of the map to where it should be
532  * so we don't just save over the source map.
533  */
534  strlcpy(new_map->path, new_map_name, sizeof(new_map->path));
535  new_map->is_template = 1;
536  enter_map(pl, new_map, EXIT_X(exit_ob), EXIT_Y(exit_ob));
537 }
538 
548 static void enter_random_template_map(object *pl, object *exit_ob) {
549  mapstruct *new_map;
550  char tmpnum[32], resultname[HUGE_BUF], tmpstring[HUGE_BUF];
551  char new_map_name[MAX_BUF];
552  RMParms rp;
553 
554  /* Do replacement of %x, %y, and %n to the x coord of the exit, the y coord
555  * of the exit, and the name of the map the exit is on, respectively.
556  */
557  snprintf(tmpnum, sizeof(tmpnum), "%d", exit_ob->x);
558  replace(EXIT_PATH(exit_ob)+3, "%x", tmpnum, resultname, sizeof(resultname));
559 
560  snprintf(tmpnum, sizeof(tmpnum), "%d", exit_ob->y);
561  strlcpy(tmpstring, resultname, sizeof(tmpstring));
562  replace(tmpstring, "%y", tmpnum, resultname, sizeof(resultname));
563 
564  strlcpy(tmpstring, resultname, sizeof(tmpstring));
565  replace(tmpstring, "%n", exit_ob->map->name, resultname, sizeof(resultname));
566 
567  /* If we are coming from another template map, use reletive paths unless
568  * indicated otherwise.
569  */
570  if (exit_ob->map->is_template && (resultname[0] != '/')) {
571  path_combine_and_normalize(exit_ob->map->path, resultname, new_map_name, sizeof(new_map_name));
572  } else {
573  create_template_pathname(resultname, new_map_name, sizeof(new_map_name));
574  }
575 
576  new_map = ready_map_name(new_map_name, MAP_PLAYER_UNIQUE);
577  if (!new_map) {
578  memset(&rp, 0, sizeof(RMParms));
579  rp.Xsize = -1;
580  rp.Ysize = -1;
581  rp.region = get_region_by_map(exit_ob->map);
582  if (exit_ob->msg)
583  set_random_map_variable(&rp, exit_ob->msg);
584  rp.origin_x = exit_ob->x;
585  rp.origin_y = exit_ob->y;
586  safe_strncpy(rp.origin_map, pl->map->path, sizeof(rp.origin_map));
587 
588  /* now to generate the actual map. */
589  new_map = generate_random_map(new_map_name, &rp, NULL, exit_ob->map ? exit_ob->map->reset_group : NULL);
590  }
591 
592  /* Update the exit_ob so it now points directly at the newly created
593  * random maps. Not that it is likely to happen, but it does mean that a
594  * exit in a unique map leading to a random map will not work properly.
595  * It also means that if the created random map gets reset before
596  * the exit leading to it, that the exit will no longer work.
597  */
598  if (new_map) {
599  int x, y;
600 
601  x = EXIT_X(exit_ob) = MAP_ENTER_X(new_map);
602  y = EXIT_Y(exit_ob) = MAP_ENTER_Y(new_map);
603  new_map->is_template = 1;
604  enter_map(pl, new_map, x, y);
605  }
606 }
607 
616 static void enter_unique_map(object *op, object *exit_ob) {
617  char apartment[HUGE_BUF], path[MAX_BUF];
618  mapstruct *newmap;
619 
620  if (EXIT_PATH(exit_ob)[0] == '/') {
621  snprintf(apartment, sizeof(apartment), "~%s/%s", op->name, clean_path(EXIT_PATH(exit_ob), path, sizeof(path)));
622  newmap = ready_map_name(apartment, MAP_PLAYER_UNIQUE);
623  if (!newmap) {
624  newmap = mapfile_load(EXIT_PATH(exit_ob), 0);
625  }
626  } else { /* relative directory */
627  char reldir[HUGE_BUF], tmpc[HUGE_BUF], *cp;
628 
629  if (exit_ob->map->unique) {
630  // Use player's current map path to construct base of relative path in 'src'
631  char* src = strdup(op->map->path);
632  char* slash = strrchr(src, '/');
633  if (slash == NULL) {
634  abort();
635  }
636  *slash = '\0';
637 
638  unclean_path(exit_ob->map->path, reldir, sizeof(reldir));
639 
640  /* Need to copy this over, as clean_path only has one static return buffer */
641  clean_path(reldir, tmpc, sizeof(tmpc));
642  /* Remove final component, if any */
643  if ((cp = strrchr(tmpc, '_')) != NULL)
644  *cp = 0;
645 
646  snprintf(apartment, sizeof(apartment), "%s/%s_%s", src, tmpc, clean_path(EXIT_PATH(exit_ob), path, sizeof(path)));
647 
648  newmap = ready_map_name(apartment, MAP_PLAYER_UNIQUE);
649  if (!newmap) {
650  newmap = mapfile_load(path_combine_and_normalize(reldir, EXIT_PATH(exit_ob), tmpc, sizeof(tmpc)), 0);
651  }
652  } else {
653  /* The exit is unique, but the map we are coming from is not unique. So
654  * use the basic logic - don't need to demangle the path name
655  */
656  path_combine_and_normalize(exit_ob->map->path, EXIT_PATH(exit_ob), reldir, sizeof(reldir));
657  snprintf(apartment, sizeof(apartment), "~%s/%s", op->name, clean_path(reldir, path, sizeof(path)));
658  newmap = ready_map_name(apartment, MAP_PLAYER_UNIQUE);
659  if (!newmap) {
660  path_combine_and_normalize(exit_ob->map->path, EXIT_PATH(exit_ob), reldir, sizeof(reldir));
661  newmap = ready_map_name(reldir, 0);
662  if (newmap)
663  apply_auto_fix(newmap);
664  }
665  }
666  }
667 
668  if (newmap) {
669  strlcpy(newmap->path, apartment, sizeof(newmap->path));
670  newmap->unique = 1;
671  enter_map(op, newmap, EXIT_X(exit_ob), EXIT_Y(exit_ob));
672  } else {
675  "The %s is closed.",
676  exit_ob->name);
677  /* Perhaps not critical, but I would think that the unique maps
678  * should be new enough this does not happen. This also creates
679  * a strange situation where some players could perhaps have visited
680  * such a map before it was removed, so they have the private
681  * map, but other players can't get it anymore.
682  */
683  LOG(llevDebug, "enter_unique_map: Exit %s (%d,%d) on map %s is leads no where.\n", exit_ob->name, exit_ob->x, exit_ob->y, exit_ob->map->path);
684  }
685 }
686 
687 void enter_player_maplevel(object *op) {
688  assert(op != NULL);
689  int flags = 0, x = op->x, y = op->y;
690  mapstruct *newmap;
691 
692  assert(op->type == PLAYER);
693 
694  /* newmap returns the map (if already loaded), or loads it for us. */
695  newmap = ready_map_name(op->contr->maplevel, flags);
696  if (!newmap) {
700  if (!newmap) {
701  LOG(llevError, "Fatal: Could not load emergency map!\n");
702  abort();
703  }
704 
706  "You find yourself somewhere unexpected...");
707  }
708 
709  /* as a special case, if coordinates are (-1, -1), then the item should
710  * be put at the default location. Used for loginmethod 0 (old clients). */
711  if (x == -1 && y == -1) {
712  x = MAP_ENTER_X(newmap);
713  y = MAP_ENTER_Y(newmap);
714  }
715 
716  enter_map(op, newmap, x, y);
717 }
718 
732 void enter_exit(object *op, object *exit_ob) {
733 #define PORTAL_DESTINATION_NAME "Town portal destination" /* this one should really be in a header file */
734  /* It may be nice to support other creatures moving across
735  * exits, but right now a lot of the code looks at op->contr,
736  * so thta is an RFE.
737  */
738  if (op->type != PLAYER)
739  return;
740 
741  assert(exit_ob != NULL);
742  assert(EXIT_PATH(exit_ob) != NULL);
743 
744  /* Don't word-of-recall out of a shop */
745  if ( exit_ob->subtype == SP_WORD_OF_RECALL ) {
746  /* Scan inventory for unpaid objects */
747  object *item = op->inv;
749  if (QUERY_FLAG(item, FLAG_UNPAID)) {
750  char buf[MAX_BUF];
751 
752  ob_describe(item, op, 1, buf, sizeof(buf));
754  "You feel a force fizzling away. You feel a vibration from: %s",buf);
755  return;
756  }
758  }
759 
760  /* Need to remove player from transport */
761  if (op->contr->transport)
762  ob_apply(op->contr->transport, op, AP_UNAPPLY);
763 
764  /* check to see if we make a template map
765  * Template maps have an EXIT_PATH in the form:
766  * /@[!]<MAP_NAME>!<TEMPLATE_PATH>
767  *
768  * <MAP_NAME> is the name of the destination map, which is saved in LOCALDIR/template-maps/.
769  * <TEMPLATE_PATH> is the path to a template map, used when <MAP_NAME> does not exist.
770  */
771  if (EXIT_PATH(exit_ob) && EXIT_PATH(exit_ob)[1] == '@') {
772  if (EXIT_PATH(exit_ob)[2] == '!') {
773  /* generate a template map randomly */
774  enter_random_template_map(op, exit_ob);
775  } else {
776  /* generate a template map from a fixed template */
777  enter_fixed_template_map(op, exit_ob);
778  }
779  }
780  /* check to see if we make a randomly generated map */
781  else if (EXIT_PATH(exit_ob) && EXIT_PATH(exit_ob)[1] == '!') {
782  enter_random_map(op, exit_ob);
783  } else if (QUERY_FLAG(exit_ob, FLAG_UNIQUE)) {
784  enter_unique_map(op, exit_ob);
785  } else {
786  int x = EXIT_X(exit_ob), y = EXIT_Y(exit_ob);
787  /* 'Normal' exits that do not do anything special
788  * Simple enough we don't need another routine for it.
789  */
790  mapstruct *newmap;
791  if (exit_ob->map) {
792  char tmp_path[HUGE_BUF];
793 
794  path_combine_and_normalize(exit_ob->map->path, EXIT_PATH(exit_ob), tmp_path, sizeof(tmp_path));
795  newmap = ready_map_name(tmp_path, 0);
796  /* Random map was previously generated, but is no longer about. Lets generate a new
797  * map.
798  */
799  if (!newmap && !strncmp(EXIT_PATH(exit_ob), "/random/", 8)) {
800  /* Maps that go down have a message set. However, maps that go
801  * up, don't. If the going home has reset, there isn't much
802  * point generating a random map, because it won't match the maps.
803  */
804  if (exit_ob->msg) {
805  enter_random_map(op, exit_ob);
806  } else {
809  "The %s is closed.",
810  exit_ob->name);
811  return;
812  }
813 
814  /* For exits that cause damages (like pits). Don't know if any
815  * random maps use this or not.
816  */
817  if (exit_ob->stats.dam && op->type == PLAYER)
818  hit_player(op, exit_ob->stats.dam, exit_ob, exit_ob->attacktype, 1);
819  return;
820  }
821  } else {
822  /* For word of recall and other force objects
823  * They contain the full pathname of the map to go back to,
824  * so we don't need to normalize it.
825  * But we do need to see if it is unique or not
826  */
827  if (!strncmp(EXIT_PATH(exit_ob), settings.localdir, strlen(settings.localdir)))
828  newmap = ready_map_name(EXIT_PATH(exit_ob), MAP_PLAYER_UNIQUE);
829  else
830  newmap = ready_map_name(EXIT_PATH(exit_ob), 0);
831  }
832  if (!newmap) {
833  if (exit_ob->name)
836  "The %s is closed.",
837  exit_ob->name);
838  /* don't cry to momma if name is not set - as in tmp objects
839  * used by the savebed code and character creation */
840  return;
841  }
842 
843  if (x == -1 && y == -1) {
844  x = MAP_ENTER_X(newmap);
845  y = MAP_ENTER_Y(newmap);
846  }
847 
848  /* mids 02/13/2002 if exit is damned, update players death & WoR home-position and delete town portal */
849  if (QUERY_FLAG(exit_ob, FLAG_DAMNED)) {
850  object *tmp;
851 
852  /* remove an old force with a slaying field == PORTAL_DESTINATION_NAME */
854  if (tmp) {
857  }
858 
859  path_combine_and_normalize(exit_ob->map->path, EXIT_PATH(exit_ob), op->contr->savebed_map, sizeof(op->contr->savebed_map));
860  op->contr->bed_x = EXIT_X(exit_ob), op->contr->bed_y = EXIT_Y(exit_ob);
861  save_player(op, 1);
862  }
863 
864  enter_map(op, newmap, x, y);
865  }
866 
867  LOG(llevDebug, "%s enters %s\n", op->name, EXIT_PATH(exit_ob));
868 
869  /* For exits that cause damages (like pits) */
870  if (exit_ob->stats.dam && op->type == PLAYER)
871  hit_player(op, exit_ob->stats.dam, exit_ob, exit_ob->attacktype, 1);
872 
873  if (op->contr) {
874  object* exit_copy = object_new();
875  object_copy(exit_ob, exit_copy);
876  exit_copy->speed = 0; // Item isn't on map or in inv, but object_copy() may have added it to active list
877  object_update_speed(exit_copy);
878  exit_copy->map = exit_ob->map; // hack to set map without actually inserting
879  if (op->contr->last_exit) {
880  object_free(op->contr->last_exit, FREE_OBJ_NO_DESTROY_CALLBACK);
881  }
882  op->contr->last_exit = exit_copy;
883  }
884 }
885 
891 static int move_towards(object *ob, object *towards, unsigned int mindist) {
892  rv_vector rv;
893  get_rangevector(ob, towards, &rv, 0);
894  if (rv.direction != 0 && rv.distance > mindist && ob->speed_left > 0) {
895  move_player(ob, rv.direction);
896  }
897  return rv.direction;
898 }
899 
904 static bool object_on_exit(object* ob, object* exit) {
905  int x = exit->x;
906  int y = exit->y;
907  int sx, sy, sx2, sy2;
908  object_get_multi_size(exit, &sx, &sy, &sx2, &sy2);
909  return (ob->x >= x+sx2) && (ob->x <= x+sx) && (ob->y >= y+sy2) && (ob->y <= y+sy);
910 }
911 
915 static void do_follow(player *pl) {
916  assert(pl->followed_player != NULL);
918  if (followed && followed->ob && followed->ob->map) {
919  if (query_flag(pl->ob, FLAG_WIZ)) {
920  rv_vector rv;
921  if (!get_rangevector(pl->ob, followed->ob, &rv, 0) || rv.distance > 4) {
922  int space = object_find_free_spot(pl->ob, followed->ob->map, followed->ob->x, followed->ob->y, 1, 25);
923  if (space == -1) {
925  space = 0;
926  }
927  object_remove(pl->ob);
928  object_insert_in_map_at(pl->ob, followed->ob->map, NULL, 0, followed->ob->x+freearr_x[space], followed->ob->y+freearr_y[space]);
931  }
932  } else {
933  if (!can_follow(pl->ob, followed)) {
935  "%s stops letting you follow them.", pl->followed_player);
937  return;
938  }
939  if (move_towards(pl->ob, followed->ob, 1)== 0 && followed->ob->contr->last_exit != NULL) {
940  // Move to and apply exit
941  object* exit = followed->ob->contr->last_exit;
942  if (!object_on_exit(pl->ob, exit)) {
943  move_towards(pl->ob, exit, 0);
944  } else {
945  enter_exit(pl->ob, exit);
946  }
947  }
948  }
949  } else {
951  "You stop following %s.", pl->followed_player);
953  }
954 }
955 
961 static void process_players1(void) {
962  int flag;
963  player *pl, *plnext;
964 
965  /* Basically, we keep looping until all the players have done their actions. */
966  for (flag = 1; flag != 0; ) {
967  flag = 0;
968  for (pl = first_player; pl != NULL; pl = plnext) {
969  plnext = pl->next; /* In case a player exits the game in handle_player() */
970 
971  if (pl->ob == NULL)
972  continue;
973 
974  /* Only do this on the first pass - what we are recording
975  * here is the number of ticks the player has been online - not
976  * how many actions/moves the player has done.
977  */
978  if (!flag) pl->ticks_played++;
979 
980  if (pl->followed_player) {
981  do_follow(pl);
982  }
983 
984  if (pl->ob->speed_left > 0) {
985  if (handle_newcs_player(pl->ob))
986  flag = 1;
987  } /* end if player has speed left */
988 
989  /* If the player is not actively playing, don't make a
990  * backup save - nothing to save anyway. Plus, the
991  * map may not longer be valid. This can happen when the
992  * player quits - they exist for purposes of tracking on the map,
993  * but don't actually reside on any actual map.
994  */
995  if (QUERY_FLAG(pl->ob, FLAG_REMOVED))
996  continue;
997 
998 #ifdef AUTOSAVE
999  /* check for ST_PLAYING state so that we don't try to save off when
1000  * the player is logging in.
1001  */
1002  if ((pl->last_save_tick+AUTOSAVE) < pticks && pl->state == ST_PLAYING) {
1003  /* Don't save the player on unholy ground. Instead, increase the
1004  * tick time so it will be about 10 seconds before we try and save
1005  * again.
1006  */
1007  if (get_map_flags(pl->ob->map, NULL, pl->ob->x, pl->ob->y, NULL, NULL)&P_NO_CLERIC) {
1008  pl->last_save_tick += 100;
1009  } else {
1010  save_player(pl->ob, 1);
1011  pl->last_save_tick = pticks;
1012  hiscore_check(pl->ob, 1);
1013  }
1014  }
1015 #endif
1016  } /* end of for loop for all the players */
1017  } /* for flag */
1018  for (pl = first_player; pl != NULL; pl = pl->next) {
1019  int has_action = 1;
1020 
1022  if (pl->ob->weapon_speed_left > 1.0)
1023  pl->ob->weapon_speed_left = 1.0;
1024 
1025  pl->socket->sounds_this_tick = 0;
1026 
1027  if (settings.casting_time == TRUE) {
1028  if (pl->ob->casting_time > 0) {
1029  pl->ob->casting_time--;
1030  has_action = 0;
1031  }
1032  }
1033  /* If the character is idle (standing around resting) increase
1034  * regen rates.
1035  */
1036  if (has_action && pl->ob->speed_left > 0) {
1037  pl->ob->last_heal -= 2;
1038  pl->ob->last_sp -= 2;
1039  pl->ob->last_grace -= 2;
1040  pl->ob->last_eat += 2; /* Slow down food consumption */
1041  }
1042  do_some_living(pl->ob);
1043  }
1044 }
1045 
1053 static void process_players2(void) {
1054  player *pl;
1055 
1056  /* Then check if any players should use weapon-speed instead of speed */
1057  for (pl = first_player; pl != NULL; pl = pl->next) {
1058  /* The code that did weapon_sp handling here was out of place -
1059  * this isn't called until after the player has finished there
1060  * actions, and is thus out of place. All we do here is bounds
1061  * checking.
1062  */
1063  if (pl->has_hit) {
1064  /* This needs to be here - if the player is running, we need to
1065  * clear this each tick, but new commands are not being received
1066  * so execute_newserver_command() is never called
1067  */
1068  pl->has_hit = 0;
1069  } else if (pl->ob->speed_left > pl->ob->speed)
1070  pl->ob->speed_left = pl->ob->speed;
1071  }
1072 }
1073 
1074 #define SPEED_DEBUG
1075 
1076 static bool object_in_icecube(object *op) {
1077  return op->env != NULL && strcmp(op->env->arch->name, "icecube") == 0;
1078 }
1079 
1083 void process_events(void) {
1084  object *op;
1085  object marker;
1086  tag_t tag;
1087 
1088  process_players1();
1089 
1090  memset(&marker, 0, sizeof(object));
1091  /* Put marker object at beginning of active list */
1092  marker.active_next = active_objects;
1093 
1094  if (marker.active_next)
1095  marker.active_next->active_prev = &marker;
1096  marker.active_prev = NULL;
1097  active_objects = &marker;
1098 
1099  while (marker.active_next) {
1100  op = marker.active_next;
1101  tag = op->count;
1102 
1103  /* Move marker forward - swap op and marker */
1104  op->active_prev = marker.active_prev;
1105 
1106  if (op->active_prev)
1107  op->active_prev->active_next = op;
1108  else
1109  active_objects = op;
1110 
1111  marker.active_next = op->active_next;
1112 
1113  if (marker.active_next)
1114  marker.active_next->active_prev = &marker;
1115  marker.active_prev = op;
1116  op->active_next = &marker;
1117 
1118  /* Now process op */
1119  if (QUERY_FLAG(op, FLAG_FREED)) {
1120  LOG(llevError, "BUG: process_events(): Free object on list\n");
1121  op->speed = 0;
1123  continue;
1124  }
1125 
1126  /* I've seen occasional crashes due to this - the object is removed,
1127  * and thus the map it points to (last map it was on) may be bogus
1128  * The real bug is to try to find out the cause of this - someone
1129  * is probably calling object_remove() without either an insert_ob or
1130  * object_free_drop_inventory() afterwards, leaving an object dangling.
1131  * But I'd rather log this and continue on instead of crashing.
1132  * Don't remove players - when a player quits, the object is in
1133  * sort of a limbo, of removed, but something we want to keep
1134  * around.
1135  */
1136  if (QUERY_FLAG(op, FLAG_REMOVED)
1137  && op->type != PLAYER
1138  && op->map
1139  && op->map->in_memory != MAP_IN_MEMORY) {
1140  StringBuffer *sb;
1141  char *diff;
1142 
1143  LOG(llevError, "BUG: process_events(): Removed object on list\n");
1144  sb = stringbuffer_new();
1145  object_dump(op, sb);
1146  diff = stringbuffer_finish(sb);
1147  LOG(llevError, "%s\n", diff);
1148  free(diff);
1150  continue;
1151  }
1152 
1153  if (!op->speed) {
1154  LOG(llevError, "BUG: process_events(): Object %s has no speed, but is on active list\n", op->arch->name);
1156  continue;
1157  }
1158 
1159  if (op->map == NULL
1160  && op->env == NULL
1161  && op->name
1162  && op->type != MAP) {
1163  LOG(llevError, "BUG: process_events(): Object without map or inventory is on active list: %s (%d)\n", op->name, op->count);
1164  op->speed = 0;
1166  continue;
1167  }
1168 
1169  /* Seen some cases where process_object() is crashing because
1170  * the object is on a swapped out map. But can't be sure if
1171  * something in the chain of events caused the object to
1172  * change maps or was just never removed - this will
1173  * give some clue as to its state before call to
1174  * process_object
1175  */
1176  if (op->map && op->map->in_memory != MAP_IN_MEMORY) {
1177  LOG(llevError, "BUG: process_events(): Processing object on swapped out map: %s (%d), map=%s\n", op->name, op->count, op->map->path);
1178  }
1179 
1180  /* Animate the object. Bug of feature that andim_speed
1181  * is based on ticks, and not the creatures speed?
1182  */
1183  if ((op->anim_speed && op->last_anim >= op->anim_speed)
1184  || (op->temp_animation && op->last_anim >= op->temp_anim_speed)) {
1185  op->state++;
1186  if ((op->type == PLAYER) || (op->type == MONSTER))
1187  animate_object(op, op->facing);
1188  else
1189  animate_object(op, op->direction);
1190  op->last_anim = 1;
1191  } else {
1192  op->last_anim++;
1193  }
1194 
1195  if (op->speed_left > 0) {
1196  // Players are special because their speed_left has already been
1197  // reduced in do_server(). Players effectively process every tick
1198  // so long they have non-zero speed left.
1199  if (op->type != PLAYER) {
1200  // Objects in icecubes decay at a slower rate
1201  if (object_in_icecube(op)) {
1202  op->speed_left -= 10;
1203  } else {
1204  op->speed_left -= 1;
1205  }
1206  }
1207  process_object(op);
1208  if (object_was_destroyed(op, tag))
1209  continue;
1210  } else {
1211  // Custom-made creatures for random maps can still have negative speeds, so catch that with FABS().
1212  op->speed_left += FABS(op->speed);
1213  }
1214  if (settings.casting_time == TRUE && op->casting_time > 0)
1215  op->casting_time--;
1216  }
1217 
1218  /* Remove marker object from active list */
1219  if (marker.active_prev != NULL)
1220  marker.active_prev->active_next = NULL;
1221  else
1222  active_objects = NULL;
1223 
1224  process_players2();
1225 }
1226 
1231 void clean_tmp_files(void) {
1232  mapstruct *m, *next;
1233  for (m = first_map; m != NULL; m = next) {
1234  next = m->next;
1235  if (m->in_memory == MAP_IN_MEMORY) {
1236  // Save all maps currently in memory, because they might contain
1237  // unique tiles that have not been written to disk.
1238  if (settings.recycle_tmp_maps) {
1239  // swap_map() also updates the write log.
1240  swap_map(m);
1241  } else {
1243  // FIXME: Unfortunately, save_map() also unnecessarily saves
1244  // non-unique tiles to a new temporary file, so we have to
1245  // get rid of it here.
1246  clean_tmp_map(m);
1247  }
1248  } else {
1249  // Remove the swap file.
1250  clean_tmp_map(m);
1251  }
1252  }
1253  write_todclock(); /* lets just write the clock here */
1254 }
1255 
1257 void cleanup(void) {
1258  LOG(llevInfo, "Cleaning up...\n");
1259  clean_tmp_files();
1261  accounts_save();
1262 
1263  close_modules();
1264 
1265 #ifdef MEMORY_DEBUG
1266  free_all_maps();
1267  free_style_maps();
1268 #endif
1269  cleanupPlugins();
1270  commands_clear();
1271 #ifdef MEMORY_DEBUG
1272  free_all_archs();
1274  free_all_images();
1276  free_all_recipes();
1278  free_all_god();
1279  free_all_anim();
1280  i18n_free();
1281  free_loader();
1282  free_globals();
1283  free_server();
1285  free_knowledge();
1286  free_quest();
1288  /* See what the string data that is out there that hasn't been freed. */
1289  /* LOG(llevDebug, "%s", ss_dump_table(0xff));*/
1290 #endif
1291  exit(0);
1292 }
1293 
1302 void leave(player *pl, int draw_exit) {
1303  if (!QUERY_FLAG(pl->ob, FLAG_REMOVED)) {
1305  object_remove(pl->ob);
1306  }
1307 
1308  pl->socket->status = Ns_Dead;
1309  LOG(llevInfo, "logout: %s from %s\n", pl->ob->name, pl->socket->host);
1310 
1311  strcpy(pl->ob->contr->killer, "left");
1312  hiscore_check(pl->ob, 1);
1313 
1314  /* If this player is the captain of the transport, need to do
1315  * some extra work. By the time we get here, object_remove()
1316  * should have already been called.
1317  */
1318  if (pl->transport && pl->transport->contr == pl) {
1319  /* If inv is a non player, inv->contr will be NULL, but that
1320  * is OK.
1321  */
1322  if (pl->transport->inv)
1324  else
1325  pl->transport->contr = NULL;
1326 
1327  if (pl->transport->contr) {
1328  char name[MAX_BUF];
1329 
1333  "%s has left. You are now the captain of %s",
1334  pl->ob->name, name);
1335  }
1336  }
1337 
1338  if (pl->ob->map) {
1339  if (pl->ob->map->in_memory == MAP_IN_MEMORY)
1340  pl->ob->map->timeout = MAP_TIMEOUT(pl->ob->map);
1341  pl->ob->map = NULL;
1342  }
1343  pl->ob->type = DEAD_OBJECT; /* To avoid problems with inventory window */
1344  party_leave(pl->ob);
1345  /* If a hidden dm dropped connection do not create
1346  * inconsistencies by showing that they have left the game
1347  */
1348  if (!(QUERY_FLAG(pl->ob, FLAG_WIZ) && pl->ob->contr->hidden)
1349  && (draw_exit) && (pl->state != ST_GET_NAME && pl->state != ST_GET_PASSWORD && pl->state != ST_CONFIRM_PASSWORD))
1352  "%s left the game.",
1353  pl->ob->name);
1354 }
1355 
1363 int forbid_play(void) {
1364 #if !defined(_IBMR2) && !defined(___IBMR2) && defined(PERM_FILE)
1365  char buf[MAX_BUF], day[MAX_BUF];
1366  FILE *fp;
1367  time_t clock;
1368  struct tm *tm;
1369  int i, start, stop, forbit = 0;
1370 
1371  clock = time(NULL);
1372  tm = (struct tm *)localtime(&clock);
1373 
1374  snprintf(buf, sizeof(buf), "%s/%s", settings.confdir, PERM_FILE);
1375  if ((fp = fopen(buf, "r")) == NULL)
1376  return 0;
1377 
1378  while (fgets(buf, sizeof(buf), fp)) {
1379  if (buf[0] == '#')
1380  continue;
1381  if (!strncmp(buf, "msg", 3)) {
1382  if (forbit)
1383  while (fgets(buf, sizeof(buf), fp)) /* print message */
1384  fputs(buf, logfile);
1385  break;
1386  } else if (sscanf(buf, "%s %d%*c%d\n", day, &start, &stop) != 3) {
1387  LOG(llevDebug, "Warning: Incomplete line in permission file ignored.\n");
1388  continue;
1389  }
1390 
1391  for (i = 0; i < 7; i++) {
1392  if (!strncmp(buf, days[i], 3)
1393  && (tm->tm_wday == i)
1394  && (tm->tm_hour >= start)
1395  && (tm->tm_hour < stop))
1396  forbit = 1;
1397  }
1398  }
1399 
1400  fclose(fp);
1401 
1402  return forbit;
1403 #else
1404  return 0;
1405 #endif
1406 }
1407 
1408 static void save_and_kick_all_players(void) {
1409  for (player *pl = first_player; pl != NULL; ) {
1410  player *npl = pl->next;
1411  save_player(pl->ob, 0);
1412  leave(pl, 0);
1414  pl = npl;
1415  }
1416 }
1417 
1418 static void do_shutdown(void) {
1420  MSG_TYPE_ADMIN_DM, "The server has shut down.");
1422 
1423  // Maps are saved out in clean_tmp_files(), called by cleanup().
1424  cleanup();
1425 }
1426 
1430 static bool check_shutdown(void) {
1431  if (shutdown_flag == 1) {
1432  LOG(llevInfo, "Received SIGINT; shutting down...\n");
1433  return true;
1434  }
1435 
1437  return false;
1438  }
1439 
1441  if (count_players() == 0) {
1442  if (shutdown_state.time == 0) {
1443  // Start idle countdown
1444  shutdown_state.time = time(NULL);
1445  return false;
1446  } else {
1447  time_t diff = time(NULL) - shutdown_state.time;
1448  if (diff > 60) {
1449  LOG(llevInfo, "No active players in the last %ld seconds, shutting down...\n", diff);
1450  return true;
1451  } else {
1452  return false;
1453  }
1454  }
1455  } else {
1456  // Reset idle time, since there are players
1457  shutdown_state.time = 0;
1458  }
1459  return false;
1460  }
1461 
1462  assert(shutdown_state.type == SHUTDOWN_TIME);
1463 
1464  /* If a timed shutdown is coming, remind players periodically. */
1465  time_t time_left = shutdown_state.time - time(NULL);
1466 
1467  for (unsigned int i = shutdown_state.next_warn; i < sizeof(shutdown_warn_times) / sizeof(int); i++) {
1468  if (shutdown_warn_times[i] == (int)ceil(time_left / 60.0)) {
1471  "Server shutting down in %d minutes.", shutdown_warn_times[i]);
1472  shutdown_state.next_warn = i + 1;
1473  return false;
1474  }
1475  }
1476 
1477  if (time_left <= 0) {
1478  return true;
1479  }
1480  return false;
1481 }
1482 
1487 void login_check_shutdown(object* const op) {
1489  return;
1490  }
1491 
1495  "This server will shut down when all players leave.");
1496  return;
1497  }
1498 
1499  assert(shutdown_state.type == SHUTDOWN_TIME);
1500 
1501  time_t time_left = shutdown_state.time - time(NULL);
1502  if (time_left <= 60*shutdown_warn_times[0]) {
1505  "This server will shut down in %lu minutes.", time_left / 60);
1506  }
1507 }
1508 
1523 static void do_specials(void) {
1524  if (check_shutdown()) {
1525  do_shutdown();
1526  }
1527 
1528 #ifdef CS_LOGSTATS
1529  if ((time(NULL)-cst_lst.time_start) >= CS_LOGTIME) {
1530  write_cs_stats();
1531  }
1532 #endif
1533 
1534  if (!(pticks%10))
1536 
1537 #ifdef WATCHDOG
1538  if (!(pticks%503))
1539  watchdog();
1540 #endif
1541 
1542  if (!(pticks%PTICKS_PER_CLOCK))
1543  tick_the_clock();
1544 
1545  if (!(pticks%509))
1546  flush_old_maps(); /* Clears the tmp-files of maps which have reset */
1547 
1548  if (!(pticks%2503))
1549  fix_weight(); /* Hack to fix weightproblems caused by bugs */
1550 
1551  if (!(pticks%2521))
1552  metaserver_update(); /* 2500 ticks is about 5 minutes */
1553 
1554  if (!(pticks%2531))
1555  accounts_save();
1556 
1557  if (!(pticks%5003))
1559 
1560  if (!(pticks%5009))
1562 
1563  if (!(pticks%5011))
1565 
1566  if (!(pticks%12503))
1567  fix_luck();
1568 }
1569 
1578 void server_main(int argc, char *argv[]) {
1579  PROFILE_BEGIN();
1580 #ifdef WIN32 /* ---win32 this sets the win32 from 0d0a to 0a handling */
1581  _fmode = _O_BINARY;
1582 #endif
1583 
1584 #ifndef WIN32
1585  /* Here we check that we aren't root or suid */
1586  if (getuid() == 0 || geteuid() == 0) {
1587  fprintf(stderr,
1588  "Running crossfire-server as root is a bad idea; aborting!\n"
1589  "Please run it again as a normal, unprivileged user.\n");
1590  exit(EXIT_FAILURE);
1591  }
1592 #endif
1593 
1594 #ifdef DEBUG_MALLOC_LEVEL
1595  malloc_debug(DEBUG_MALLOC_LEVEL);
1596 #endif
1597 
1598  init(argc, argv);
1599  initPlugins(); /* GROS - Init the Plugins */
1600  // Give feedback that loading is complete. This prevents confusion on when it is done loading.
1601  PROFILE_END(diff, LOG(llevInfo, "Initialization complete (%ld ms). Waiting for connections.\n", diff/1000));
1602 #ifdef WIN32
1603  while (bRunning) {
1604 #else
1605  while (TRUE) {
1606 #endif
1607  nroferrors = 0;
1608 
1609  tick_game_time();
1610  do_server();
1611  process_events(); /* "do" something with objects with speed */
1612  cftimer_process_timers(); /* Process the crossfire Timers */
1614  check_active_maps(); /* Removes unused maps after a certain timeout */
1615  do_specials(); /* Routines called from time to time. */
1616  update_players();
1617  }
1618 
1619  /* This is unreachable. */
1620  abort();
1621 }
write_book_archive
void write_book_archive(void)
Definition: readable.cpp:2047
object_was_destroyed
#define object_was_destroyed(op, old_tag)
Definition: object.h:68
Settings::casting_time
uint8_t casting_time
Definition: global.h:270
obj::weapon_speed
float weapon_speed
Definition: object.h:337
fix_weight
void fix_weight(void)
Definition: player.cpp:3847
check_shutdown
static bool check_shutdown(void)
Definition: server.cpp:1430
mapdef::reset_group
sstring reset_group
Definition: map.h:329
give.next
def next
Definition: give.py:44
handle_newcs_player
int handle_newcs_player(object *op)
Definition: player.cpp:3054
PLAYER
@ PLAYER
Definition: object.h:110
path.h
global.h
FREE_OBJ_NO_DESTROY_CALLBACK
#define FREE_OBJ_NO_DESTROY_CALLBACK
Definition: object.h:534
i18n_free
void i18n_free(void)
Definition: languages.cpp:239
first_player
player * first_player
Definition: init.cpp:106
clean_tmp_files
void clean_tmp_files(void)
Definition: server.cpp:1231
settings
struct Settings settings
Definition: init.cpp:139
liv::dam
int16_t dam
Definition: living.h:46
INS_NO_WALK_ON
#define INS_NO_WALK_ON
Definition: object.h:571
random_map.h
tick_the_clock
void tick_the_clock(void)
Definition: weather.cpp:94
safe_strncpy
#define safe_strncpy
Definition: compat.h:27
MAP
@ MAP
Definition: object.h:128
remove_friendly_object
void remove_friendly_object(object *op)
Definition: friend.cpp:54
pets_terminate_all
void pets_terminate_all(object *owner)
Definition: pets.cpp:225
enter_player_savebed
void enter_player_savebed(object *op)
Definition: server.cpp:138
pl::transport
object * transport
Definition: player.h:213
ST_GET_PASSWORD
#define ST_GET_PASSWORD
Definition: define.h:547
MONSTER
@ MONSTER
Definition: object.h:203
Settings::recycle_tmp_maps
uint8_t recycle_tmp_maps
Definition: global.h:272
Settings::emergency_y
uint16_t emergency_y
Definition: global.h:300
llevError
@ llevError
Definition: logger.h:11
RMParms::origin_map
char origin_map[RM_SIZE]
Definition: random_map.h:55
FABS
#define FABS(x)
Definition: define.h:22
MSG_TYPE_ADMIN_PLAYER
#define MSG_TYPE_ADMIN_PLAYER
Definition: newclient.h:496
LOG
void LOG(LogLevel logLevel, const char *format,...)
Definition: logger.cpp:51
SHUTDOWN_IDLE
@ SHUTDOWN_IDLE
Definition: commands.h:44
PTICKS_PER_CLOCK
#define PTICKS_PER_CLOCK
Definition: tod.h:12
free_all_readable
void free_all_readable(void)
Definition: readable.cpp:2011
object_free_all_data
void object_free_all_data(void)
Definition: object.cpp:767
enter_map
static void enter_map(object *op, mapstruct *newmap, int x, int y)
Definition: server.cpp:179
diamondslots.x
x
Definition: diamondslots.py:15
ready_map_name
mapstruct * ready_map_name(const char *name, int flags)
Definition: map.cpp:1793
obj::map
struct mapdef * map
Definition: object.h:303
SIZEOFFREE1
#define SIZEOFFREE1
Definition: define.h:153
QUERY_FLAG
#define QUERY_FLAG(xyz, p)
Definition: define.h:226
flush_old_maps
void flush_old_maps(void)
Definition: swap.cpp:289
ST_GET_NAME
#define ST_GET_NAME
Definition: define.h:546
set_map_timeout
void set_map_timeout(mapstruct *oldmap)
Definition: server.cpp:298
Settings::crypt_mode
uint8_t crypt_mode
Definition: global.h:330
c
static event_registration c
Definition: citylife.cpp:425
stringbuffer_new
StringBuffer * stringbuffer_new(void)
Definition: stringbuffer.cpp:57
object_set_enemy
void object_set_enemy(object *op, object *enemy)
Definition: object.cpp:915
FLAG_UNIQUE
#define FLAG_UNIQUE
Definition: define.h:287
pl
Definition: player.h:105
accounts_save
void accounts_save(void)
Definition: account.cpp:266
EXIT_PATH
#define EXIT_PATH(xyz)
Definition: define.h:439
do_server
void do_server(void)
Definition: loop.cpp:562
RMParms::Ysize
int Ysize
Definition: random_map.h:75
do_follow
static void do_follow(player *pl)
Definition: server.cpp:915
MAP_MAXTIMEOUT
#define MAP_MAXTIMEOUT
Definition: config.h:399
set_random_map_variable
int set_random_map_variable(RMParms *rp, const char *buf)
Definition: reader.c:2579
guildjoin.ob
ob
Definition: guildjoin.py:42
enter_random_map
static void enter_random_map(object *pl, object *exit_ob)
Definition: server.cpp:384
draw_ext_info_format
void draw_ext_info_format(int flags, int pri, const object *pl, uint8_t type, uint8_t subtype, const char *format,...) PRINTF_ARGS(6
mapdef::in_memory
uint32_t in_memory
Definition: map.h:338
mad_mage_user.file
file
Definition: mad_mage_user.py:15
move_player
int move_player(object *op, int dir)
Definition: player.cpp:2916
pl::ob
object * ob
Definition: player.h:176
free_all_newserver
void free_all_newserver(void)
Definition: init.cpp:403
object_copy
void object_copy(const object *src_ob, object *dest_ob)
Definition: object.cpp:1192
MAP_PLAYER_UNIQUE
#define MAP_PLAYER_UNIQUE
Definition: map.h:97
PROFILE_BEGIN
#define PROFILE_BEGIN(expr)
Definition: global.h:366
RMParms::origin_y
int origin_y
Definition: random_map.h:88
Ice.tmp
int tmp
Definition: Ice.py:207
free_knowledge
void free_knowledge(void)
Definition: knowledge.cpp:1277
Settings::emergency_x
uint16_t emergency_x
Definition: global.h:300
generate_random_map
mapstruct * generate_random_map(const char *OutFileName, RMParms *RP, char **use_layout, sstring reset_group)
Definition: random_map.cpp:75
flags
static const flag_definition flags[]
Definition: gridarta-types-convert.c:101
cleanupPlugins
void cleanupPlugins(void)
Definition: plugins.cpp:4556
obj::msg
sstring msg
Definition: object.h:328
range_golem
@ range_golem
Definition: player.h:34
enter_player_maplevel
void enter_player_maplevel(object *op)
Definition: server.cpp:687
MSG_TYPE_MISC
#define MSG_TYPE_MISC
Definition: newclient.h:413
party_obsolete_parties
void party_obsolete_parties(void)
Definition: party.cpp:215
free_all_maps
void free_all_maps(void)
Definition: map.cpp:1985
pticks
uint32_t pticks
Definition: time.cpp:47
buf
StringBuffer * buf
Definition: readable.cpp:1611
active_objects
object * active_objects
Definition: object.cpp:296
initPlugins
void initPlugins(void)
Definition: plugins.cpp:4506
hiscore_check
void hiscore_check(object *op, int quiet)
Definition: hiscore.cpp:348
version.h
RMParms
Definition: random_map.h:14
HUGE_BUF
#define HUGE_BUF
Definition: define.h:37
query_flag
static int query_flag(const object *op, int flag)
Definition: object.h:494
MSG_TYPE_COMMAND
#define MSG_TYPE_COMMAND
Definition: newclient.h:404
move_towards
static int move_towards(object *ob, object *towards, unsigned int mindist)
Definition: server.cpp:891
obj::last_heal
int32_t last_heal
Definition: object.h:365
Ns_Dead
@ Ns_Dead
Definition: newserver.h:67
MSG_TYPE_ADMIN_DM
#define MSG_TYPE_ADMIN_DM
Definition: newclient.h:497
CS_Stats::time_start
time_t time_start
Definition: newclient.h:698
PROFILE_END
#define PROFILE_END(var, expr)
Definition: global.h:371
RMParms::origin_x
int origin_x
Definition: random_map.h:89
m
static event_registration m
Definition: citylife.cpp:425
mapdef::players
int16_t players
Definition: map.h:337
MAP_IN_MEMORY
#define MAP_IN_MEMORY
Definition: map.h:131
stringbuffer_finish
char * stringbuffer_finish(StringBuffer *sb)
Definition: stringbuffer.cpp:76
apply_auto_fix
void apply_auto_fix(mapstruct *m)
Definition: main.cpp:258
login_check_shutdown
void login_check_shutdown(object *const op)
Definition: server.cpp:1487
object_free_drop_inventory
void object_free_drop_inventory(object *ob)
Definition: object.cpp:1560
shutdown_s::time
time_t time
Definition: commands.h:49
forbid_play
int forbid_play(void)
Definition: server.cpp:1363
pl::next
struct pl * next
Definition: player.h:106
MAP_MINTIMEOUT
#define MAP_MINTIMEOUT
Definition: config.h:401
write_todclock
void write_todclock(void)
Definition: init.cpp:524
final_free_player
void final_free_player(player *pl)
Definition: init.cpp:455
obj::active_next
struct obj * active_next
Definition: object.h:285
obj::name
sstring name
Definition: object.h:317
EVENT_CLOCK
#define EVENT_CLOCK
Definition: events.h:40
pl::state
uint8_t state
Definition: player.h:131
freearr_y
short freearr_y[SIZEOFFREE]
Definition: object.cpp:305
clean_path
static char * clean_path(const char *file, char *newpath, int size)
Definition: server.cpp:331
query_name
void query_name(const object *op, char *buf, size_t size)
Definition: item.cpp:585
path_combine_and_normalize
char * path_combine_and_normalize(const char *src, const char *dst, char *path, size_t size)
Definition: path.cpp:172
clean_friendly_list
void clean_friendly_list(void)
Definition: friend.cpp:82
RMParms::final_map
char final_map[RM_SIZE]
Definition: random_map.h:57
object_dump
void object_dump(const object *op, StringBuffer *sb)
Definition: object.cpp:645
party_leave
void party_leave(object *op)
Definition: party.cpp:123
add_string
sstring add_string(const char *str)
Definition: shstr.cpp:124
EVENT_MAPENTER
#define EVENT_MAPENTER
Definition: events.h:46
first_map
mapstruct * first_map
Definition: init.cpp:107
FOR_OB_AND_BELOW_FINISH
#define FOR_OB_AND_BELOW_FINISH()
Definition: define.h:754
object_get_multi_size
void object_get_multi_size(const object *ob, int *sx, int *sy, int *hx, int *hy)
Definition: object.cpp:4737
clean_tmp_map
void clean_tmp_map(mapstruct *m)
Definition: map.cpp:1976
free_quest
void free_quest(void)
Definition: quest.cpp:910
shutdown_s::type
enum shutdown_type type
Definition: commands.h:48
make_face_from_files.str
str
Definition: make_face_from_files.py:24
obj::speed_left
float speed_left
Definition: object.h:336
process_events
void process_events(void)
Definition: server.cpp:1083
python_init.path
path
Definition: python_init.py:8
FLAG_FREED
#define FLAG_FREED
Definition: define.h:233
server_main
void server_main(int argc, char *argv[])
Definition: server.cpp:1578
out_of_map
int out_of_map(mapstruct *m, int x, int y)
Definition: map.cpp:2320
socket_struct::host
char * host
Definition: newserver.h:100
do_specials
static void do_specials(void)
Definition: server.cpp:1523
PORTAL_DESTINATION_NAME
#define PORTAL_DESTINATION_NAME
nroferrors
long nroferrors
Definition: init.cpp:112
ob_describe
char * ob_describe(const object *op, const object *observer, int use_media_tags, char *buf, size_t size)
Definition: ob_methods.cpp:91
object_update_speed
void object_update_speed(object *op)
Definition: object.cpp:1349
object_on_exit
static bool object_on_exit(object *ob, object *exit)
Definition: server.cpp:904
obj::x
int16_t x
Definition: object.h:333
enter_exit
void enter_exit(object *op, object *exit_ob)
Definition: server.cpp:732
newhash
char const * newhash(char const *password)
Definition: server.cpp:101
FLAG_DAMNED
#define FLAG_DAMNED
Definition: define.h:317
CFweardisguise.tag
tag
Definition: CFweardisguise.py:25
object_free
void object_free(object *ob, int flags)
Definition: object.cpp:1592
pl::has_hit
uint32_t has_hit
Definition: player.h:144
obj::speed
float speed
Definition: object.h:335
mapdef::timeout
int32_t timeout
Definition: map.h:334
pl::followed_player
sstring followed_player
Definition: player.h:217
tag_t
uint32_t tag_t
Definition: object.h:12
rproto.h
RMParms::region
struct regiondef * region
Definition: random_map.h:96
Settings::confdir
const char * confdir
Definition: global.h:247
sproto.h
logfile
FILE * logfile
Definition: init.cpp:114
FOR_OB_AND_BELOW_PREPARE
#define FOR_OB_AND_BELOW_PREPARE(op_)
Definition: define.h:750
mapdef
Definition: map.h:317
process_players1
static void process_players1(void)
Definition: server.cpp:961
MSG_TYPE_SPELL
#define MSG_TYPE_SPELL
Definition: newclient.h:411
cftimer_process_timers
void cftimer_process_timers(void)
Definition: timers.cpp:44
object_in_icecube
static bool object_in_icecube(object *op)
Definition: server.cpp:1076
SHUTDOWN_NONE
@ SHUTDOWN_NONE
Definition: commands.h:42
ob_blocked
int ob_blocked(const object *ob, mapstruct *m, int16_t x, int16_t y)
Definition: map.cpp:488
object_insert_in_map_at
object * object_insert_in_map_at(object *op, mapstruct *m, object *originator, int flag, int x, int y)
Definition: object.cpp:2098
mapdef::name
char * name
Definition: map.h:320
MAP_WIDTH
#define MAP_WIDTH(m)
Definition: map.h:78
mapdef::is_template
uint32_t is_template
Definition: map.h:331
SIZEOFFREE
#define SIZEOFFREE
Definition: define.h:155
create_template_pathname
void create_template_pathname(const char *name, char *buf, size_t size)
Definition: map.cpp:144
EXIT_X
#define EXIT_X(xyz)
Definition: define.h:441
shutdown_flag
volatile sig_atomic_t shutdown_flag
Definition: server.cpp:53
MAX_BUF
#define MAX_BUF
Definition: define.h:35
free_all_recipes
void free_all_recipes(void)
Definition: recipe.cpp:815
strlcpy
size_t strlcpy(char *dst, const char *src, size_t size)
Definition: porting.cpp:222
object_new
object * object_new(void)
Definition: object.cpp:1273
free_all_god
void free_all_god(void)
Definition: holy.cpp:329
PERM_FILE
#define PERM_FILE
Definition: config.h:446
free_string
void free_string(sstring str)
Definition: shstr.cpp:280
SAVE_MODE_NORMAL
#define SAVE_MODE_NORMAL
Definition: map.h:121
RANDOM
#define RANDOM()
Definition: define.h:644
free_loader
void free_loader(void)
Definition: loader.c:5333
StringBuffer
Definition: stringbuffer.cpp:25
FREE_AND_CLEAR_STR
#define FREE_AND_CLEAR_STR(xyz)
Definition: global.h:198
free_quest_definitions
void free_quest_definitions(void)
bRunning
int bRunning
enter_unique_map
static void enter_unique_map(object *op, object *exit_ob)
Definition: server.cpp:616
MSG_TYPE_COMMAND_FAILURE
#define MSG_TYPE_COMMAND_FAILURE
Definition: newclient.h:531
can_follow
bool can_follow(object *, player *)
Definition: c_wiz.cpp:2759
obj::y
int16_t y
Definition: object.h:333
socket_struct::sounds_this_tick
int8_t sounds_this_tick
Definition: newserver.h:121
player_map_change_common
void player_map_change_common(object *op, mapstruct *const oldmap, mapstruct *const newmap)
Definition: server.cpp:276
ST_PLAYING
#define ST_PLAYING
Definition: define.h:541
find_dir_2
int find_dir_2(int x, int y)
Definition: object.cpp:3670
pets_attempt_follow
void pets_attempt_follow(object *for_owner, int force)
Definition: pets.cpp:249
replace
void replace(const char *src, const char *key, const char *replacement, char *result, size_t resultsize)
Definition: utils.cpp:337
FLAG_REMOVED
#define FLAG_REMOVED
Definition: define.h:232
object_find_by_type_and_slaying
object * object_find_by_type_and_slaying(const object *who, int type, const char *slaying)
Definition: object.cpp:4151
FLAG_WIZ
#define FLAG_WIZ
Definition: define.h:231
swap_map
int swap_map(mapstruct *map)
Definition: swap.cpp:135
Settings::emergency_mapname
char * emergency_mapname
Definition: global.h:299
llevInfo
@ llevInfo
Definition: logger.h:12
obj::type
uint8_t type
Definition: object.h:346
obj::last_grace
int16_t last_grace
Definition: object.h:367
NDI_UNIQUE
#define NDI_UNIQUE
Definition: newclient.h:262
roll-o-matic.stop
def stop()
Definition: roll-o-matic.py:78
obj::stats
living stats
Definition: object.h:376
MSG_TYPE_SPELL_FAILURE
#define MSG_TYPE_SPELL_FAILURE
Definition: newclient.h:633
SIZEOFFREE2
#define SIZEOFFREE2
Definition: define.h:154
obj::contr
struct pl * contr
Definition: object.h:282
free_style_maps
void free_style_maps(void)
Definition: style.cpp:312
check_password
bool check_password(const char *typed, const char *crypted)
Definition: server.cpp:114
shutdown_warn_times
static const int shutdown_warn_times[]
Definition: server.cpp:48
ST_CONFIRM_PASSWORD
#define ST_CONFIRM_PASSWORD
Definition: define.h:548
metaserver_update
void metaserver_update(void)
Definition: metaserver.cpp:85
get_map_flags
int get_map_flags(mapstruct *oldmap, mapstruct **newmap, int16_t x, int16_t y, int16_t *nx, int16_t *ny)
Definition: map.cpp:301
save_and_kick_all_players
static void save_and_kick_all_players(void)
Definition: server.cpp:1408
item
Definition: item.py:1
create_pathname
char * create_pathname(const char *name, char *buf, size_t size)
Definition: map.cpp:103
write_cs_stats
void write_cs_stats(void)
SHUTDOWN_TIME
@ SHUTDOWN_TIME
Definition: commands.h:43
give.op
op
Definition: give.py:33
NDI_ALL
#define NDI_ALL
Definition: newclient.h:263
socket_struct::status
enum Sock_Status status
Definition: newserver.h:90
animate_object
void animate_object(object *op, int dir)
Definition: anim.cpp:44
update_players
void update_players(void)
Definition: loop.cpp:705
object_find_free_spot
int object_find_free_spot(const object *ob, mapstruct *m, int x, int y, int start, int stop)
Definition: object.cpp:3552
EVENT_MAPLEAVE
#define EVENT_MAPLEAVE
Definition: events.h:47
enter_random_template_map
static void enter_random_template_map(object *pl, object *exit_ob)
Definition: server.cpp:548
pl::killer
char killer[BIG_NAME]
Definition: player.h:189
obj::weapon_speed_left
float weapon_speed_left
Definition: object.h:338
rv_vector
Definition: map.h:373
init
void init(int argc, char **argv)
Definition: init.cpp:1108
obj::last_sp
int32_t last_sp
Definition: object.h:366
obj::casting_time
int16_t casting_time
Definition: object.h:410
hit_player
int hit_player(object *op, int dam, object *hitter, uint32_t type, int full_hit)
Definition: attack.cpp:1860
EXIT_Y
#define EXIT_Y(xyz)
Definition: define.h:442
diamondslots.y
y
Definition: diamondslots.py:16
free_globals
void free_globals(void)
Definition: init.cpp:443
free_server
void free_server(void)
Definition: init.cpp:1148
ob_apply
method_ret ob_apply(object *op, object *applier, int aflags)
Definition: ob_methods.cpp:44
pl::hidden
uint32_t hidden
Definition: player.h:147
MAP_HEIGHT
#define MAP_HEIGHT(m)
Definition: map.h:80
MAP_ENTER_Y
#define MAP_ENTER_Y(m)
Definition: map.h:87
NDI_DK_ORANGE
#define NDI_DK_ORANGE
Definition: newclient.h:248
find_player_partial_name
player * find_player_partial_name(const char *plname)
Definition: player.cpp:112
obj::subtype
uint8_t subtype
Definition: object.h:347
watchdog
void watchdog(void)
obj::last_eat
int32_t last_eat
Definition: object.h:364
map_newmap_cmd
void map_newmap_cmd(socket_struct *ns)
Definition: request.cpp:621
get_rangevector
int get_rangevector(object *op1, const object *op2, rv_vector *retval, int flags)
Definition: map.cpp:2553
DEAD_OBJECT
@ DEAD_OBJECT
Definition: object.h:159
make_face_from_files.int
int
Definition: make_face_from_files.py:26
get_region_by_map
region * get_region_by_map(mapstruct *m)
Definition: region.cpp:74
save_player
int save_player(object *op, int flag)
Definition: login.cpp:230
draw_ext_info
void draw_ext_info(int flags, int pri, const object *pl, uint8_t type, uint8_t subtype, const char *message)
Definition: main.cpp:308
obj::active_prev
struct obj * active_prev
Definition: object.h:289
pl::ticks_played
uint32_t ticks_played
Definition: player.h:221
free_all_artifacts
void free_all_artifacts(void)
MAP_ENTER_X
#define MAP_ENTER_X(m)
Definition: map.h:85
process_object
void process_object(object *op)
Definition: time.cpp:796
object_remove
void object_remove(object *op)
Definition: object.cpp:1833
shutdown_state
struct shutdown_s shutdown_state
Definition: c_wiz.cpp:43
cleanup
void cleanup(void)
Definition: server.cpp:1257
pl::last_exit
struct obj * last_exit
Definition: player.h:207
leave
void leave(player *pl, int draw_exit)
Definition: server.cpp:1302
FLAG_UNPAID
#define FLAG_UNPAID
Definition: define.h:236
do_some_living
void do_some_living(object *op)
Definition: player.cpp:3240
P_NO_CLERIC
#define P_NO_CLERIC
Definition: map.h:239
save_map
int save_map(mapstruct *m, int flag)
Definition: map.cpp:1428
shutdown_s::next_warn
int next_warn
Definition: commands.h:51
fix_luck
void fix_luck(void)
Definition: player.cpp:3863
check_active_maps
void check_active_maps(void)
Definition: swap.cpp:199
commands_clear
void commands_clear()
Definition: commands.cpp:347
count_players
int count_players(void)
Definition: metaserver.cpp:46
AP_UNAPPLY
#define AP_UNAPPLY
Definition: define.h:575
obj::attacktype
uint32_t attacktype
Definition: object.h:350
server.h
close_modules
void close_modules()
Definition: init.cpp:80
freearr_x
short freearr_x[SIZEOFFREE]
Definition: object.cpp:299
tod.h
mapdef::path
char path[HUGE_BUF]
Definition: map.h:358
MAP_TIMEOUT
#define MAP_TIMEOUT(m)
Definition: map.h:66
days
static const char * days[]
Definition: server.cpp:51
TRUE
#define TRUE
Definition: compat.h:11
do_shutdown
static void do_shutdown(void)
Definition: server.cpp:1418
CS_LOGTIME
#define CS_LOGTIME
Definition: config.h:188
cst_lst
CS_Stats cst_lst
Definition: newclient.h:701
mapfile_load
mapstruct * mapfile_load(const char *map, int flags)
Definition: map.cpp:1250
pl::socket
socket_struct * socket
Definition: player.h:107
rv_vector::direction
int direction
Definition: map.h:377
altar_valkyrie.pl
pl
Definition: altar_valkyrie.py:28
MSG_TYPE_ADMIN
#define MSG_TYPE_ADMIN
Definition: newclient.h:402
rv_vector::distance
unsigned int distance
Definition: map.h:374
RMParms::Xsize
int Xsize
Definition: random_map.h:74
FORCE
@ FORCE
Definition: object.h:227
enter_fixed_template_map
static void enter_fixed_template_map(object *pl, object *exit_ob)
Definition: server.cpp:457
mapdef::unique
uint32_t unique
Definition: map.h:330
knowledge_process_incremental
void knowledge_process_incremental(void)
Definition: knowledge.cpp:1436
object.h
tick_game_time
void tick_game_time()
Definition: time.cpp:181
events_execute_global_event
void events_execute_global_event(int eventcode,...)
Definition: events.cpp:27
llevDebug
@ llevDebug
Definition: logger.h:13
SP_WORD_OF_RECALL
#define SP_WORD_OF_RECALL
Definition: spells.h:92
process_players2
static void process_players2(void)
Definition: server.cpp:1053
AUTOSAVE
#define AUTOSAVE
Definition: config.h:586
obj::inv
struct obj * inv
Definition: object.h:296
give.name
name
Definition: give.py:27
player_update_bg_music
void player_update_bg_music(object *player)
Definition: sounds.cpp:161
unclean_path
static char * unclean_path(const char *src, char *newpath, int size)
Definition: server.cpp:359
crypt_string
static char const * crypt_string(char const *str, char const *salt)
Definition: server.cpp:70
Settings::localdir
const char * localdir
Definition: global.h:249