Crossfire Server, Trunk
init.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 <stdlib.h>
22 #include <string.h>
23 
24 #include "object.h"
25 #include "output_file.h"
26 
27 #include "assets.h"
28 #include "AssetsManager.h"
29 
31 const char *const resist_save[NROFATTACKS] = {
32  "physical ", "magic ", "fire ", "electricity ", "cold ", "confusion ", "acid ",
33  "drain ", "weaponmagic ", "ghosthit ", "poison ", "slow ", "paralyze ",
34  "turn_undead ", "fear ", "cancellation ", "deplete ", "death ", "chaos ",
35  "counterspell ", "godpower ", "holyword ", "blind ", "internal ", "life_stealing ",
36  "disease "
37 };
38 
40 const char *const attacktype_desc[NROFATTACKS] = {
41  "physical", "magic", "fire", "electricity", "cold", "confusion", "acid",
42  "drain", "weapon magic", "ghost hit", "poison", "slow", "paralyze",
43  "turn undead", "fear", "cancellation", "deplete", "death", "chaos",
44  "counterspell", "god power", "holy word", "blind", "internal", "life stealing",
45  "disease"
46 };
47 
49 const char *const resist_plus[NROFATTACKS] = {
50  "armour", "resist magic", "resist fire", "resist electricity", "resist cold",
51  "resist confusion", "resist acid", "resist drain",
52  "resist weaponmagic", "resist ghosthit", "resist poison", "resist slow",
53  "resist paralyzation", "resist turn undead", "resist fear",
54  "resist cancellation", "resist depletion", "resist death", "resist chaos",
55  "resist counterspell", "resist god power", "resist holy word",
56  "resist blindness", "resist internal", "resist life stealing",
57  "resist diseases"
58 };
59 
61 const char *const resist_color[NROFATTACKS] = {
62  "#FF15CD", "#930C76", "red", "blue", "#2CFFFF", NULL, NULL, NULL, NULL, NULL, "green", NULL, NULL,
63  NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
64 };
65 
70 const char *const change_resist_msg[NROFATTACKS] = {
71  "physical", "magic", "fire", "electricity", "cold", "confusion", "acid",
72  "draining", "weapon magic", "ghosts", "poison", "slow", "paralyze",
73  "turn undead", "fear", "cancellation", "depletion", "death attacks", "chaos",
74  "counterspell", "god power", "holy word", "blinding attacks", "internal",
75  "life stealing", "disease"
76 };
77 
79 
82  { AT_PHYSICAL, 0 },
83  { AT_PHYSICAL, 0 }, /*face = explosion*/
84  { AT_PHYSICAL, 0 },
85  { AT_MAGIC, 1 },
86  { AT_MAGIC, 1 }, /* face = last-burnout */
87  { AT_MAGIC, 1 },
88  { AT_FIRE, 2 },
89  { AT_FIRE, 2 }, /* face = fire.... */
90  { AT_FIRE, 2 },
91  { AT_ELECTRICITY, 3 },
92  { AT_ELECTRICITY, 3 }, /* ball_lightning */
93  { AT_ELECTRICITY, 3 },
94  { AT_COLD, 4 },
95  { AT_COLD, 4 }, /* face=icestorm*/
96  { AT_COLD, 4 },
97  { AT_CONFUSION, 5 },
98  { AT_POISON, 7 },
99  { AT_POISON, 7 }, /* face = acid sphere. generator */
100  { AT_POISON, 7 }, /* poisoncloud face */
101  { AT_SLOW, 8 },
102  { AT_PARALYZE, 9 },
103  { AT_FEAR, 10 }
104 };
105 
114 FILE *logfile;
115 int exiting;
123 long ob_count;
124 
126 const char *undead_name; /* Used in hit_player() in main.c */
130 
131 static void init_environ(void);
132 static void init_defaults(void);
133 static void init_dynamic(void);
134 static void init_clocks(void);
135 
136 /*
137  * Default values for settings.
138  */
139 struct Settings settings = {
140  nullptr,
141  CSPORT,
142  llevInfo,
143  nullptr,
144  0, // dumpvalues
145  nullptr, // dumpargs
146  CONFDIR,
147  DATADIR,
148  LOCALDIR,
149  PLAYERDIR,
150  MAPDIR,
151  REGIONS,
152  UNIQUE_DIR,
153  TEMPLATE_DIR,
154  TMPDIR,
162  SIMPLE_EXP,
164  SET_TITLE,
165  RESURRECTION,
166  SEARCH_ITEMS,
169  CASTING_TIME,
170  REAL_WIZ,
175  "",
176  "",
177  MOTD,
178  "rules",
179  "news",
180  0, // meta_on
181  "",
182  "",
183  0, // meta_port
184  "",
185  0,
186  0,
187  0,
188  0,
189  0,
190  0,
191  0,
192  nullptr,
193  EMERGENCY_X,
194  EMERGENCY_Y,
195  0,
196  1.0,
197  /* Armor enchantment stuff */
203  1,
204  0,
205  1,
206  5000000,
207  10,
208  0,
209  0,
210  0,
211  nullptr, // log_timestamp_format
212  3, // .starting_stat_min
213  18, // .starting_stat_max
214  85, // .starting_stat_points
215  115, // .roll_stat_points
216  0, /* max_stat - will be loaded from stats file */
217  1, /* special_break_map, 1 for historical reasons */
218  nullptr,
219  0,
220  0,
221  nullptr,
222  0,
223  0,
224  0, // .hooks_count
225  { nullptr, },
226  { nullptr },
227  0, // .ignore_assets_errors
228  nullptr, // .archetypes_tracker
229  nullptr, // .fatal_hook
230 };
231 
233 
239 const char *const spellpathnames[NRSPELLPATHS] = {
240  "Protection",
241  "Fire",
242  "Frost",
243  "Electricity",
244  "Missiles",
245  "Self",
246  "Summoning",
247  "Abjuration",
248  "Restoration",
249  "Detonation",
250  "Mind",
251  "Creation",
252  "Teleportation",
253  "Information",
254  "Transmutation",
255  "Transferrence",
256  "Turning",
257  "Wounding",
258  "Death",
259  "Light"
260 };
261 
262 
274 static void init_emergency_mappath(void) {
275  char filename[MAX_BUF], tmpbuf[MAX_BUF];
276  FILE *fp;
277  int online = 0;
278 
280 
281  /* If this file doesn't exist, not a big deal */
282  snprintf(filename, sizeof(filename), "%s/%s/.emergency", settings.datadir, settings.mapdir);
283  fp = fopen(filename, "r");
284  if (fp != NULL) {
285  while (fgets(tmpbuf, MAX_BUF-1, fp)) {
286  if (tmpbuf[0] == '#')
287  continue; /* ignore comments */
288 
289  if (online == 0) {
290  tmpbuf[strlen(tmpbuf)-1] = 0; /* kill newline */
293  } else if (online == 1) {
294  settings.emergency_x = atoi(tmpbuf);
295  } else if (online == 2) {
296  settings.emergency_y = atoi(tmpbuf);
297  }
298  online++;
299  if (online > 2)
300  break;
301  }
302  fclose(fp);
303  if (online <= 2)
304  LOG(llevError, "Online read partial data from %s\n", filename);
305  LOG(llevDebug, "emergency map set to %s (%d, %d)\n",
308  }
309 }
310 
311 void load_assets(void) {
313  assets_end_load();
314 }
315 
324 void init_library(void) {
325  init_environ();
326  init_hash_table();
327  init_globals();
328  init_stats(FALSE); /* Needs to be fairly early, since the loader will check
329  * against the settings.max_stat value
330  */
331 
332  for (int mess = 0; mess < MAXATTACKMESS; mess++) {
333  for (int level = 0; level < MAXATTACKMESS; level++) {
334  attack_mess[mess][level].level = -1;
335  attack_mess[mess][level].buf1 = NULL;
336  attack_mess[mess][level].buf2 = NULL;
337  attack_mess[mess][level].buf3 = NULL;
338  }
339  }
340 
341  assets_init();
342  i18n_init();
343  init_objects();
344  init_block();
345 
346  load_assets();
347 
348  init_clocks();
350  init_experience();
351 
352  if (getManager()->dumpUndefined() > 0 && !settings.ignore_assets_errors) {
353  LOG(llevError, "Assets errors, please fix and restart.\n");
355  }
356 
357  init_dynamic();
358 }
359 
365 static void init_environ(void) {
366  char *cp;
367 
368  cp = getenv("CROSSFIRE_LIBDIR");
369  if (cp)
370  settings.datadir = cp;
371  cp = getenv("CROSSFIRE_LOCALDIR");
372  if (cp)
373  settings.localdir = cp;
374  cp = getenv("CROSSFIRE_PLAYERDIR");
375  if (cp)
376  settings.playerdir = cp;
377  cp = getenv("CROSSFIRE_MAPDIR");
378  if (cp)
379  settings.mapdir = cp;
380  cp = getenv("CROSSFIRE_UNIQUEDIR");
381  if (cp)
382  settings.uniquedir = cp;
383  cp = getenv("CROSSFIRE_TEMPLATEDIR");
384  if (cp)
385  settings.templatedir = cp;
386  cp = getenv("CROSSFIRE_TMPDIR");
387  if (cp)
388  settings.tmpdir = cp;
389 }
390 
397 void init_globals(void) {
398  memset(&statistics, 0, sizeof(struct Statistics));
399 
400  /* Log to stderr by default. */
401  logfile = stderr;
402 
403  /* Try to open the log file specified on the command-line. */
404  if (settings.logfilename != NULL) {
405  logfile = fopen(settings.logfilename, "a");
406 
407  /* If writable, set buffer mode to per-line. */
408  if (logfile != NULL) {
409  setvbuf(logfile, NULL, _IOLBF, 0);
410  } else {
411  logfile = stderr;
412 
413  LOG(llevError, "Could not open '%s' for logging.\n",
415  }
416  }
417 
418  exiting = 0;
419  first_player = NULL;
420  first_map = NULL;
421  first_artifactlist = NULL;
422  *first_map_ext_path = 0;
423  nrofartifacts = 0;
424  nrofallowedstr = 0;
425  ring_arch = NULL;
426  amulet_arch = NULL;
427  undead_name = add_string("undead");
428  blocks_prayer = add_string("blocks_prayer");
430  init_defaults();
431 }
432 
443 void free_globals(void) {
444  int msg, attack;
445  region *reg;
446 
449  for (msg = 0; msg < NROFATTACKMESS; msg++)
450  for (attack = 0; attack < MAXATTACKMESS; attack++) {
451  free(attack_mess[msg][attack].buf1);
452  free(attack_mess[msg][attack].buf2);
453  free(attack_mess[msg][attack].buf3);
454  }
455 
457 
459  free_experience();
460 
461  while (first_region) {
462  reg = first_region->next;
468  first_region = reg;
469  }
470 
471  assets_free();
472 }
473 
478 static void init_defaults(void) {
479  nroferrors = 0;
480 }
481 
491 static void init_dynamic(void) {
493  if (!at) {
494  LOG(llevError, "You need a archetype for a legacy map, with type %d and subtype %d\n", MAP, MAP_TYPE_LEGACY);
496  }
497  if (EXIT_PATH(&at->clone)) {
498  mapstruct *first;
499 
501  first = ready_map_name(first_map_path, 0);
502  if (!first) {
503  LOG(llevError, "Initial map %s can't be found! Please ensure maps are correctly installed.\n", first_map_path);
504  LOG(llevError, "Unable to continue without initial map.\n");
506  }
507  delete_map(first);
508  } else {
509  LOG(llevError, "Legacy map must have a 'slaying' field!\n");
511  }
512 
514  LOG(llevError, "Can not find object of type MAP subtype MAP_TYPE_DEFAULT.\n");
515  LOG(llevError, "Are the archetype files up to date? Can not continue.\n");
517  }
518 }
519 
524 void write_todclock(void) {
525  char filename[MAX_BUF];
526  FILE *fp;
527  OutputFile of;
528 
529  snprintf(filename, sizeof(filename), "%s/clockdata", settings.localdir);
530  fp = of_open(&of, filename);
531  if (fp == NULL)
532  return;
533  fprintf(fp, "%lu", todtick);
534  of_close(&of);
535 }
536 
541 static void init_clocks(void) {
542  char filename[MAX_BUF];
543  FILE *fp;
544  static int has_been_done = 0;
545 
546  if (has_been_done)
547  return;
548  else
549  has_been_done = 1;
550 
551  snprintf(filename, sizeof(filename), "%s/clockdata", settings.localdir);
552  fp = fopen(filename, "r");
553  if (fp == NULL) {
554  LOG(llevError, "Can't open %s.\n", filename);
555  todtick = 0;
556  write_todclock();
557  return;
558  }
559  /* Read TOD and default to 0 on failure. */
560  if (fscanf(fp, "%lu", &todtick) == 1) {
561  LOG(llevDebug, "clockdata: todtick is %lu\n", todtick);
562  fclose(fp);
563  } else {
564  LOG(llevError, "Couldn't parse todtick, using default value 0\n");
565  todtick = 0;
566  fclose(fp);
567  write_todclock();
568  }
569 }
570 
577 void init_attackmess(BufferReader *reader, const char *filename) {
578  char *buf;
579  char *cp, *p;
580  int mess = -1, level;
581  int mode = 0, total = 0;
582 
583  level = 0;
584  while ((buf = bufferreader_next_line(reader)) != NULL) {
585  if (*buf == '#' || *buf == '\0')
586  continue;
587  /*
588  * Skip blanks -- strspn is slightly faster than a loop w/ optimization on
589  * Also, note we go from the beginning of the line again, since cp was at the end.
590  * While here, also skip tabs for more complete whitespace handling.
591  *
592  * SilverNexus 2018-01-21
593  */
594  cp = buf + strspn(buf, " \t");
595 
596  if (strncmp(cp, "TYPE:", 5) == 0) {
597  p = strtok(buf, ":");
598  p = strtok(NULL, ":");
599  if (mode == 1) {
600  attack_mess[mess][level].level = -1;
601  free(attack_mess[mess][level].buf1);
602  free(attack_mess[mess][level].buf2);
603  free(attack_mess[mess][level].buf3);
604  attack_mess[mess][level].buf1 = NULL;
605  attack_mess[mess][level].buf2 = NULL;
606  attack_mess[mess][level].buf3 = NULL;
607  }
608  level = 0;
609  mess = atoi(p);
610  mode = 1;
611  continue;
612  }
613  if (mode == 1) {
614  p = strtok(buf, "=");
615  attack_mess[mess][level].level = atoi(buf);
616  p = strtok(NULL, "=");
617  free(attack_mess[mess][level].buf1);
618  if (p != NULL)
619  attack_mess[mess][level].buf1 = strdup_local(p);
620  else
621  attack_mess[mess][level].buf1 = strdup_local("");
622  mode = 2;
623  continue;
624  } else if (mode == 2) {
625  p = strtok(buf, "=");
626  attack_mess[mess][level].level = atoi(buf);
627  p = strtok(NULL, "=");
628  free(attack_mess[mess][level].buf2);
629  if (p != NULL)
630  attack_mess[mess][level].buf2 = strdup_local(p);
631  else
632  attack_mess[mess][level].buf2 = strdup_local("");
633  mode = 3;
634  continue;
635  } else if (mode == 3) {
636  p = strtok(buf, "=");
637  attack_mess[mess][level].level = atoi(buf);
638  p = strtok(NULL, "=");
639  free(attack_mess[mess][level].buf3);
640  if (p != NULL)
641  attack_mess[mess][level].buf3 = strdup_local(p);
642  else
643  attack_mess[mess][level].buf3 = strdup_local("");
644  mode = 1;
645  level++;
646  total++;
647  continue;
648  }
649  }
650  LOG(llevDebug, "attackmsg %s: %d messages in %d categories\n", filename, total, mess+1);
651 }
materialt
materialtype_t * materialt
Definition: init.cpp:129
init_globals
void init_globals(void)
Definition: init.cpp:397
init_objects
void init_objects(void)
Definition: object.cpp:327
init_dynamic
static void init_dynamic(void)
Definition: init.cpp:491
NROFATTACKMESS
#define NROFATTACKMESS
Definition: attack.h:18
Settings::mapdir
const char * mapdir
Definition: global.h:251
output_file.h
global.h
DEATH_PENALTY_LEVEL
#define DEATH_PENALTY_LEVEL
Definition: config.h:152
SPELL_ENCUMBRANCE
#define SPELL_ENCUMBRANCE
Definition: config.h:156
nrofartifacts
long nrofartifacts
Definition: init.cpp:116
first_player
player * first_player
Definition: init.cpp:106
settings
struct Settings settings
Definition: init.cpp:139
MAP
@ MAP
Definition: object.h:128
AT_POISON
#define AT_POISON
Definition: attack.h:86
attackmess::level
int level
Definition: attack.h:119
AT_MAGIC
#define AT_MAGIC
Definition: attack.h:77
first_region
region * first_region
Definition: init.cpp:108
Settings::emergency_y
uint16_t emergency_y
Definition: global.h:300
statistics
struct Statistics statistics
Definition: init.cpp:232
llevError
@ llevError
Definition: logger.h:11
init_emergency_mappath
static void init_emergency_mappath(void)
Definition: init.cpp:274
LOG
void LOG(LogLevel logLevel, const char *format,...)
Definition: logger.cpp:51
of_close
int of_close(OutputFile *of)
Definition: output_file.cpp:61
of_open
FILE * of_open(OutputFile *of, const char *fname)
Definition: output_file.cpp:30
strdup_local
#define strdup_local
Definition: compat.h:29
EMERGENCY_Y
#define EMERGENCY_Y
Definition: config.h:501
ready_map_name
mapstruct * ready_map_name(const char *name, int flags)
Definition: map.cpp:1793
AT_ELECTRICITY
#define AT_ELECTRICITY
Definition: attack.h:79
first_map_path
char first_map_path[MAX_BUF]
Definition: init.cpp:120
attackmess::buf1
char * buf1
Definition: attack.h:120
AssetsManager.h
spellpathnames
const char *const spellpathnames[NRSPELLPATHS]
Definition: init.cpp:239
first_map_ext_path
char first_map_ext_path[MAX_BUF]
Definition: init.cpp:121
FALSE
#define FALSE
Definition: compat.h:14
Settings::datadir
const char * datadir
Definition: global.h:248
AT_PHYSICAL
#define AT_PHYSICAL
Definition: attack.h:76
todtick
unsigned long todtick
Definition: time.cpp:38
pl
Definition: player.h:105
EXIT_PATH
#define EXIT_PATH(xyz)
Definition: define.h:439
init_attackmess
void init_attackmess(BufferReader *reader, const char *filename)
Definition: init.cpp:577
MAPDIR
#define MAPDIR
Definition: config.h:507
MOTD
#define MOTD
Definition: config.h:440
UNIQUE_DIR
#define UNIQUE_DIR
Definition: config.h:488
mail_login.total
total
Definition: mail_login.py:30
init_clocks
static void init_clocks(void)
Definition: init.cpp:541
Settings::emergency_x
uint16_t emergency_x
Definition: global.h:300
SEE_LAST_ERROR
@ SEE_LAST_ERROR
Definition: define.h:52
SIMPLE_EXP
#define SIMPLE_EXP
Definition: config.h:154
clear_friendly_list
void clear_friendly_list(void)
Definition: friend.cpp:136
NROFATTACKS
#define NROFATTACKS
Definition: attack.h:17
npc_dialog.filename
filename
Definition: npc_dialog.py:99
assets_free
void assets_free()
Definition: assets.cpp:74
Statistics
Definition: global.h:355
MAXATTACKMESS
#define MAXATTACKMESS
Definition: attack.h:19
Settings::ignore_assets_errors
int ignore_assets_errors
Definition: global.h:335
SET_TITLE
#define SET_TITLE
Definition: config.h:153
ring_arch
archetype * ring_arch
Definition: init.cpp:125
buf
StringBuffer * buf
Definition: readable.cpp:1611
getManager
AssetsManager * getManager()
Definition: assets.cpp:309
REGIONS
#define REGIONS
Definition: config.h:509
i18n_init
void i18n_init(void)
Definition: languages.cpp:154
archt
Definition: object.h:472
DEATH_PENALTY_RATIO
#define DEATH_PENALTY_RATIO
Definition: config.h:151
attackmess
Definition: attack.h:118
regiondef::next
struct regiondef * next
Definition: map.h:276
RESURRECTION
#define RESURRECTION
Definition: config.h:161
write_todclock
void write_todclock(void)
Definition: init.cpp:524
nrofallowedstr
long nrofallowedstr
Definition: init.cpp:117
RECYCLE_TMP_MAPS
#define RECYCLE_TMP_MAPS
Definition: config.h:159
init_block
void init_block(void)
Definition: los.cpp:88
AT_COLD
#define AT_COLD
Definition: attack.h:80
ARMOR_SPEED_IMPROVEMENT
#define ARMOR_SPEED_IMPROVEMENT
Definition: config.h:171
init_environ
static void init_environ(void)
Definition: init.cpp:365
SPELLPOINT_LEVEL_DEPEND
#define SPELLPOINT_LEVEL_DEPEND
Definition: config.h:155
PK_LUCK_PENALTY
#define PK_LUCK_PENALTY
Definition: config.h:165
Settings::logfilename
const char * logfilename
Definition: global.h:241
add_string
sstring add_string(const char *str)
Definition: shstr.cpp:124
first_map
mapstruct * first_map
Definition: init.cpp:107
trying_emergency_save
long trying_emergency_save
Definition: init.cpp:111
change_resist_msg
const char *const change_resist_msg[NROFATTACKS]
Definition: init.cpp:70
navar-midane_pickup.msg
list msg
Definition: navar-midane_pickup.py:13
SEARCH_ITEMS
#define SEARCH_ITEMS
Definition: config.h:162
nroferrors
long nroferrors
Definition: init.cpp:112
regiondef::name
char * name
Definition: map.h:277
ARMOR_SPEED_LINEAR
#define ARMOR_SPEED_LINEAR
Definition: config.h:172
ARMOR_WEIGHT_REDUCTION
#define ARMOR_WEIGHT_REDUCTION
Definition: config.h:169
ARMOR_MAX_ENCHANT
#define ARMOR_MAX_ENCHANT
Definition: config.h:168
MAP_TYPE_LEGACY
#define MAP_TYPE_LEGACY
Definition: map.h:57
_materialtype
Definition: material.h:32
artifactliststruct
Definition: artifact.h:26
amulet_arch
archetype * amulet_arch
Definition: init.cpp:125
resist_save
const char *const resist_save[NROFATTACKS]
Definition: init.cpp:31
sstring
const typedef char * sstring
Definition: global.h:43
logfile
FILE * logfile
Definition: init.cpp:114
mapdef
Definition: map.h:317
delete_map
void delete_map(mapstruct *m)
Definition: map.cpp:1730
TMPDIR
#define TMPDIR
Definition: config.h:480
ATTACKS
Chaos_Attacks ATTACKS[22]
Definition: init.cpp:81
ASSETS_ALL
#define ASSETS_ALL
Definition: assets.h:32
undead_name
const char * undead_name
Definition: init.cpp:126
fatal
void fatal(enum fatal_error err)
Definition: utils.cpp:580
resist_plus
const char *const resist_plus[NROFATTACKS]
Definition: init.cpp:49
MAX_BUF
#define MAX_BUF
Definition: define.h:35
CASTING_TIME
#define CASTING_TIME
Definition: config.h:166
strlcpy
size_t strlcpy(char *dst, const char *src, size_t size)
Definition: porting.cpp:222
Settings::playerdir
const char * playerdir
Definition: global.h:250
FREE_AND_CLEAR_STR
#define FREE_AND_CLEAR_STR(xyz)
Definition: global.h:198
crown_arch
archetype * crown_arch
Definition: init.cpp:125
load_assets
void load_assets(void)
Definition: init.cpp:311
ob_count
long ob_count
Definition: init.cpp:123
attack_mess
attackmess_t attack_mess[NROFATTACKMESS][MAXATTACKMESS]
Definition: init.cpp:78
Settings
Definition: global.h:240
ARMOR_WEIGHT_LINEAR
#define ARMOR_WEIGHT_LINEAR
Definition: config.h:170
STAT_LOSS_ON_DEATH
#define STAT_LOSS_ON_DEATH
Definition: config.h:164
Settings::emergency_mapname
char * emergency_mapname
Definition: global.h:299
llevInfo
@ llevInfo
Definition: logger.h:12
REAL_WIZ
#define REAL_WIZ
Definition: config.h:158
SET_FRIENDLY_FIRE
#define SET_FRIENDLY_FIRE
Definition: config.h:167
init_library
void init_library(void)
Definition: init.cpp:324
attacktype_desc
const char *const attacktype_desc[NROFATTACKS]
Definition: init.cpp:40
FREE_AND_CLEAR
#define FREE_AND_CLEAR(xyz)
Definition: global.h:193
archt::clone
object clone
Definition: object.h:476
regiondef::jailmap
char * jailmap
Definition: map.h:289
AT_SLOW
#define AT_SLOW
Definition: attack.h:87
init_hash_table
void init_hash_table(void)
Definition: shstr.cpp:55
ALWAYS_SHOW_HP
#define ALWAYS_SHOW_HP
Definition: config.h:160
free_experience
void free_experience(void)
Definition: exp.cpp:263
TEMPLATE_DIR
#define TEMPLATE_DIR
Definition: config.h:508
init_experience
void init_experience(void)
Definition: exp.cpp:167
RESET_LOCATION_TIME
#define RESET_LOCATION_TIME
Definition: config.h:621
init_stats
void init_stats(int reload)
Definition: living.cpp:2592
free_globals
void free_globals(void)
Definition: init.cpp:443
assets.h
SPELL_FAILURE_EFFECTS
#define SPELL_FAILURE_EFFECTS
Definition: config.h:157
init_defaults
static void init_defaults(void)
Definition: init.cpp:478
BALANCED_STAT_LOSS
#define BALANCED_STAT_LOSS
Definition: config.h:149
resist_color
const char *const resist_color[NROFATTACKS]
Definition: init.cpp:61
PERMANENT_EXPERIENCE_RATIO
#define PERMANENT_EXPERIENCE_RATIO
Definition: config.h:150
level
int level
Definition: readable.cpp:1609
first_artifactlist
artifactlist * first_artifactlist
Definition: init.cpp:109
MAP_TYPE_DEFAULT
#define MAP_TYPE_DEFAULT
Definition: map.h:58
AT_FEAR
#define AT_FEAR
Definition: attack.h:90
EMERGENCY_X
#define EMERGENCY_X
Definition: config.h:500
get_archetype_by_type_subtype
archetype * get_archetype_by_type_subtype(int type, int subtype)
Definition: arch.cpp:99
attackmess::buf3
char * buf3
Definition: attack.h:122
Settings::templatedir
const char * templatedir
Definition: global.h:254
PLAYERDIR
#define PLAYERDIR
Definition: config.h:541
empty_archetype
archetype * empty_archetype
Definition: init.cpp:119
AT_CONFUSION
#define AT_CONFUSION
Definition: attack.h:81
assets_collect
void assets_collect(const char *datadir, int what)
Definition: assets.cpp:115
Chaos_Attacks
Definition: attack.h:125
blocks_prayer
sstring blocks_prayer
Definition: init.cpp:127
Settings::tmpdir
const char * tmpdir
Definition: global.h:255
AT_PARALYZE
#define AT_PARALYZE
Definition: attack.h:88
regiondef::msg
char * msg
Definition: map.h:285
EMERGENCY_MAPPATH
#define EMERGENCY_MAPPATH
Definition: config.h:498
CSPORT
#define CSPORT
Definition: config.h:354
regiondef::longname
char * longname
Definition: map.h:283
BufferReader
Definition: bufferreader.cpp:21
assets_init
void assets_init()
Definition: assets.cpp:67
exiting
int exiting
Definition: init.cpp:115
object.h
NOT_PERMADETH
#define NOT_PERMADETH
Definition: config.h:163
llevDebug
@ llevDebug
Definition: logger.h:13
NRSPELLPATHS
#define NRSPELLPATHS
Definition: spells.h:40
attackmess::buf2
char * buf2
Definition: attack.h:121
assets_end_load
void assets_end_load()
Definition: assets.cpp:231
Settings::uniquedir
const char * uniquedir
Definition: global.h:253
OutputFile
Definition: output_file.h:41
bufferreader_next_line
char * bufferreader_next_line(BufferReader *br)
Definition: bufferreader.cpp:102
AT_FIRE
#define AT_FIRE
Definition: attack.h:78
level
Definition: level.py:1
Settings::localdir
const char * localdir
Definition: global.h:249
regiondef
Definition: map.h:275