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 
108 std::vector<region *> all_regions;
114 FILE *logfile;
115 int exiting;
123 long ob_count;
124 
125 const char *undead_name; /* Used in hit_player() in main.c */
128 std::vector<materialtype_t *> materials;
129 
130 static void init_environ(void);
131 static void init_defaults(void);
132 static void init_dynamic(void);
133 static void init_clocks(void);
134 
135 /*
136  * Default values for settings.
137  */
138 struct Settings settings = {
139  nullptr,
140  CSPORT,
141  llevInfo,
142  nullptr,
143  0, // dumpvalues
144  nullptr, // dumpargs
145  CONFDIR,
146  DATADIR,
147  LOCALDIR,
148  PLAYERDIR,
149  MAPDIR,
150  REGIONS,
151  UNIQUE_DIR,
152  TEMPLATE_DIR,
153  TMPDIR,
161  SIMPLE_EXP,
163  SET_TITLE,
164  RESURRECTION,
165  SEARCH_ITEMS,
168  CASTING_TIME,
169  REAL_WIZ,
174  "",
175  "",
176  MOTD,
177  "rules",
178  "news",
179  0, // meta_on
180  "",
181  "",
182  0, // meta_port
183  "",
184  0,
185  0,
186  0,
187  0,
188  0,
189  0,
190  0,
191  nullptr,
192  EMERGENCY_X,
193  EMERGENCY_Y,
194  0,
195  1.0,
196  /* Armor enchantment stuff */
202  1,
203  0,
204  1,
205  5000000,
206  10,
207  0,
208  0,
209  0,
210  nullptr, // log_timestamp_format
211  3, // .starting_stat_min
212  18, // .starting_stat_max
213  85, // .starting_stat_points
214  115, // .roll_stat_points
215  0, /* max_stat - will be loaded from stats file */
216  1, /* special_break_map, 1 for historical reasons */
217  {},
218  0,
219  0,
220  nullptr,
221  0,
222  0,
223  0, // .hooks_count
224  { nullptr, },
225  { nullptr },
226  0, // .ignore_assets_errors
227  nullptr, // .archetypes_tracker
228  nullptr, // .fatal_hook
229 };
230 
232 
238 const char *const spellpathnames[NRSPELLPATHS] = {
239  "Protection",
240  "Fire",
241  "Frost",
242  "Electricity",
243  "Missiles",
244  "Self",
245  "Summoning",
246  "Abjuration",
247  "Restoration",
248  "Detonation",
249  "Mind",
250  "Creation",
251  "Teleportation",
252  "Information",
253  "Transmutation",
254  "Transferrence",
255  "Turning",
256  "Wounding",
257  "Death",
258  "Light"
259 };
260 
261 
273 static void init_emergency_mappath(void) {
274  char filename[MAX_BUF], tmpbuf[MAX_BUF];
275  FILE *fp;
276  int online = 0;
277 
279 
280  /* If this file doesn't exist, not a big deal */
281  snprintf(filename, sizeof(filename), "%s/%s/.emergency", settings.datadir, settings.mapdir);
282  fp = fopen(filename, "r");
283  if (fp != NULL) {
284  while (fgets(tmpbuf, MAX_BUF-1, fp)) {
285  if (tmpbuf[0] == '#')
286  continue; /* ignore comments */
287 
288  if (online == 0) {
289  tmpbuf[strlen(tmpbuf)-1] = 0; /* kill newline */
292  } else if (online == 1) {
293  settings.emergency_x = atoi(tmpbuf);
294  } else if (online == 2) {
295  settings.emergency_y = atoi(tmpbuf);
296  }
297  online++;
298  if (online > 2)
299  break;
300  }
301  fclose(fp);
302  if (online <= 2)
303  LOG(llevError, "Online read partial data from %s\n", filename);
304  LOG(llevDebug, "emergency map set to %s (%d, %d)\n",
307  }
308 }
309 
310 void load_assets(void) {
312  assets_end_load();
313 }
314 
322 void init_library(void) {
323  init_environ();
324  init_hash_table();
325  init_globals();
326  init_stats(); /* Needs to be fairly early, since the loader will check
327  * against the settings.max_stat value */
328 
329  for (int mess = 0; mess < MAXATTACKMESS; mess++) {
330  for (int level = 0; level < MAXATTACKMESS; level++) {
331  attack_mess[mess][level].level = -1;
332  attack_mess[mess][level].buf1 = NULL;
333  attack_mess[mess][level].buf2 = NULL;
334  attack_mess[mess][level].buf3 = NULL;
335  }
336  }
337 
338  assets_init();
339  i18n_init();
340  init_objects();
341  init_block();
342 
343  load_assets();
344 
345  init_clocks();
347  init_experience();
348 
349  if (getManager()->dumpUndefined() > 0 && !settings.ignore_assets_errors) {
350  LOG(llevError, "Assets errors, please fix and restart.\n");
352  }
353 
354  init_dynamic();
355 }
356 
362 static void init_environ(void) {
363  char *cp;
364 
365  cp = getenv("CROSSFIRE_LIBDIR");
366  if (cp)
367  settings.datadir = cp;
368  cp = getenv("CROSSFIRE_LOCALDIR");
369  if (cp)
370  settings.localdir = cp;
371  cp = getenv("CROSSFIRE_PLAYERDIR");
372  if (cp)
373  settings.playerdir = cp;
374  cp = getenv("CROSSFIRE_MAPDIR");
375  if (cp)
376  settings.mapdir = cp;
377  cp = getenv("CROSSFIRE_UNIQUEDIR");
378  if (cp)
379  settings.uniquedir = cp;
380  cp = getenv("CROSSFIRE_TEMPLATEDIR");
381  if (cp)
382  settings.templatedir = cp;
383  cp = getenv("CROSSFIRE_TMPDIR");
384  if (cp)
385  settings.tmpdir = cp;
386 }
387 
394 void init_globals(void) {
395  memset(&statistics, 0, sizeof(struct Statistics));
396 
397  /* Log to stderr by default. */
398  logfile = stderr;
399 
400  /* Try to open the log file specified on the command-line. */
401  if (settings.logfilename != NULL) {
402  logfile = fopen(settings.logfilename, "a");
403 
404  /* If writable, set buffer mode to per-line. */
405  if (logfile != NULL) {
406  setvbuf(logfile, NULL, _IOLBF, 0);
407  } else {
408  logfile = stderr;
409 
410  LOG(llevError, "Could not open '%s' for logging.\n",
412  }
413  }
414 
415  exiting = 0;
416  first_player = NULL;
417  first_map = NULL;
418  first_artifactlist = NULL;
419  *first_map_ext_path = 0;
420  nrofartifacts = 0;
421  nrofallowedstr = 0;
422  undead_name = add_string("undead");
423  blocks_prayer = add_string("blocks_prayer");
425  init_defaults();
426 }
427 
438 void free_globals(void) {
439  int msg, attack;
440 
443  for (msg = 0; msg < NROFATTACKMESS; msg++)
444  for (attack = 0; attack < MAXATTACKMESS; attack++) {
445  free(attack_mess[msg][attack].buf1);
446  free(attack_mess[msg][attack].buf2);
447  free(attack_mess[msg][attack].buf3);
448  }
449 
451 
453  free_experience();
454 
455  for (auto region : all_regions) {
461  }
462  all_regions.clear();
463 
464  assets_free();
465 }
466 
471 static void init_defaults(void) {
472  nroferrors = 0;
473 }
474 
484 static void init_dynamic(void) {
486  if (!at) {
487  LOG(llevError, "You need a archetype for a legacy map, with type %d and subtype %d\n", MAP, MAP_TYPE_LEGACY);
489  }
490  if (EXIT_PATH(&at->clone)) {
491  mapstruct *first;
492 
494  first = ready_map_name(first_map_path, 0);
495  if (!first) {
496  LOG(llevError, "Initial map %s can't be found! Please ensure maps are correctly installed.\n", first_map_path);
497  LOG(llevError, "Unable to continue without initial map.\n");
499  }
500  delete_map(first);
501  } else {
502  LOG(llevError, "Legacy map must have a 'slaying' field!\n");
504  }
505 
507  LOG(llevError, "Can not find object of type MAP subtype MAP_TYPE_DEFAULT.\n");
508  LOG(llevError, "Are the archetype files up to date? Can not continue.\n");
510  }
511 }
512 
517 void write_todclock(void) {
518  char filename[MAX_BUF];
519  FILE *fp;
520  OutputFile of;
521 
522  snprintf(filename, sizeof(filename), "%s/clockdata", settings.localdir);
523  fp = of_open(&of, filename);
524  if (fp == NULL)
525  return;
526  fprintf(fp, "%lu", todtick);
527  of_close(&of);
528 }
529 
534 static void init_clocks(void) {
535  char filename[MAX_BUF];
536  FILE *fp;
537  static int has_been_done = 0;
538 
539  if (has_been_done)
540  return;
541  else
542  has_been_done = 1;
543 
544  snprintf(filename, sizeof(filename), "%s/clockdata", settings.localdir);
545  fp = fopen(filename, "r");
546  if (fp == NULL) {
547  LOG(llevError, "Can't open %s.\n", filename);
548  todtick = 0;
549  write_todclock();
550  return;
551  }
552  /* Read TOD and default to 0 on failure. */
553  if (fscanf(fp, "%lu", &todtick) == 1) {
554  LOG(llevDebug, "clockdata: todtick is %lu\n", todtick);
555  fclose(fp);
556  } else {
557  LOG(llevError, "Couldn't parse todtick, using default value 0\n");
558  todtick = 0;
559  fclose(fp);
560  write_todclock();
561  }
562 }
563 
570 void init_attackmess(BufferReader *reader, const char *filename) {
571  char *buf;
572  char *cp, *p;
573  int mess = -1, level;
574  int mode = 0, total = 0;
575 
576  level = 0;
577  while ((buf = bufferreader_next_line(reader)) != NULL) {
578  if (*buf == '#' || *buf == '\0')
579  continue;
580  /*
581  * Skip blanks -- strspn is slightly faster than a loop w/ optimization on
582  * Also, note we go from the beginning of the line again, since cp was at the end.
583  * While here, also skip tabs for more complete whitespace handling.
584  *
585  * SilverNexus 2018-01-21
586  */
587  cp = buf + strspn(buf, " \t");
588 
589  if (strncmp(cp, "TYPE:", 5) == 0) {
590  p = strtok(buf, ":");
591  p = strtok(NULL, ":");
592  if (mode == 1) {
593  attack_mess[mess][level].level = -1;
594  free(attack_mess[mess][level].buf1);
595  free(attack_mess[mess][level].buf2);
596  free(attack_mess[mess][level].buf3);
597  attack_mess[mess][level].buf1 = NULL;
598  attack_mess[mess][level].buf2 = NULL;
599  attack_mess[mess][level].buf3 = NULL;
600  }
601  level = 0;
602  mess = atoi(p);
603  mode = 1;
604  continue;
605  }
606  if (mode == 1) {
607  p = strtok(buf, "=");
608  attack_mess[mess][level].level = atoi(buf);
609  p = strtok(NULL, "=");
610  free(attack_mess[mess][level].buf1);
611  if (p != NULL)
612  attack_mess[mess][level].buf1 = strdup_local(p);
613  else
614  attack_mess[mess][level].buf1 = strdup_local("");
615  mode = 2;
616  continue;
617  } else if (mode == 2) {
618  p = strtok(buf, "=");
619  attack_mess[mess][level].level = atoi(buf);
620  p = strtok(NULL, "=");
621  free(attack_mess[mess][level].buf2);
622  if (p != NULL)
623  attack_mess[mess][level].buf2 = strdup_local(p);
624  else
625  attack_mess[mess][level].buf2 = strdup_local("");
626  mode = 3;
627  continue;
628  } else if (mode == 3) {
629  p = strtok(buf, "=");
630  attack_mess[mess][level].level = atoi(buf);
631  p = strtok(NULL, "=");
632  free(attack_mess[mess][level].buf3);
633  if (p != NULL)
634  attack_mess[mess][level].buf3 = strdup_local(p);
635  else
636  attack_mess[mess][level].buf3 = strdup_local("");
637  mode = 1;
638  level++;
639  total++;
640  continue;
641  }
642  }
643  LOG(llevDebug, "attackmsg %s: %d messages in %d categories\n", filename, total, mess+1);
644 }
init_globals
void init_globals(void)
Definition: init.cpp:394
init_objects
void init_objects(void)
Definition: object.cpp:327
init_dynamic
static void init_dynamic(void)
Definition: init.cpp:484
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:138
MAP
@ MAP
Definition: object.h:128
AT_POISON
#define AT_POISON
Definition: attack.h:86
AT_MAGIC
#define AT_MAGIC
Definition: attack.h:77
Settings::emergency_y
uint16_t emergency_y
Definition: global.h:300
statistics
struct Statistics statistics
Definition: init.cpp:231
llevError
@ llevError
Definition: logger.h:11
init_emergency_mappath
static void init_emergency_mappath(void)
Definition: init.cpp:273
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
player
Definition: player.h:105
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
AssetsManager.h
spellpathnames
const char *const spellpathnames[NRSPELLPATHS]
Definition: init.cpp:238
first_map_ext_path
char first_map_ext_path[MAX_BUF]
Definition: init.cpp:121
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
EXIT_PATH
#define EXIT_PATH(xyz)
Definition: define.h:439
init_attackmess
void init_attackmess(BufferReader *reader, const char *filename)
Definition: init.cpp:570
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
attackmess_t::buf1
char * buf1
Definition: attack.h:120
init_clocks
static void init_clocks(void)
Definition: init.cpp:534
Settings::emergency_x
uint16_t emergency_x
Definition: global.h:300
SEE_LAST_ERROR
@ SEE_LAST_ERROR
Definition: define.h:52
region::name
char * name
Definition: map.h:276
SIMPLE_EXP
#define SIMPLE_EXP
Definition: config.h:154
clear_friendly_list
void clear_friendly_list(void)
Definition: friend.cpp:134
NROFATTACKS
#define NROFATTACKS
Definition: attack.h:17
npc_dialog.filename
filename
Definition: npc_dialog.py:99
assets_free
void assets_free()
Definition: assets.cpp:72
Statistics
Definition: global.h:361
materials
std::vector< materialtype_t * > materials
Definition: init.cpp:128
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
buf
StringBuffer * buf
Definition: readable.cpp:1551
getManager
AssetsManager * getManager()
Definition: assets.cpp:305
REGIONS
#define REGIONS
Definition: config.h:509
init_stats
void init_stats()
Definition: living.cpp:2582
i18n_init
void i18n_init(void)
Definition: languages.cpp:130
region::longname
char * longname
Definition: map.h:282
DEATH_PENALTY_RATIO
#define DEATH_PENALTY_RATIO
Definition: config.h:151
RESURRECTION
#define RESURRECTION
Definition: config.h:161
write_todclock
void write_todclock(void)
Definition: init.cpp:517
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:362
SPELLPOINT_LEVEL_DEPEND
#define SPELLPOINT_LEVEL_DEPEND
Definition: config.h:155
PK_LUCK_PENALTY
#define PK_LUCK_PENALTY
Definition: config.h:165
archetype::clone
object clone
Definition: object.h:476
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
region::msg
char * msg
Definition: map.h:284
trying_emergency_save
long trying_emergency_save
Definition: init.cpp:111
region::jailmap
char * jailmap
Definition: map.h:288
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
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
artifactlist
Definition: artifact.h:24
resist_save
const char *const resist_save[NROFATTACKS]
Definition: init.cpp:31
sstring
const typedef char * sstring
Definition: global.h:47
archetype
Definition: object.h:472
logfile
FILE * logfile
Definition: init.cpp:114
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:125
fatal
void fatal(enum fatal_error err)
Definition: utils.cpp:570
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
load_assets
void load_assets(void)
Definition: init.cpp:310
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
region
Definition: map.h:275
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
all_regions
std::vector< region * > all_regions
Definition: init.cpp:108
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:322
attacktype_desc
const char *const attacktype_desc[NROFATTACKS]
Definition: init.cpp:40
FREE_AND_CLEAR
#define FREE_AND_CLEAR(xyz)
Definition: global.h:193
AT_SLOW
#define AT_SLOW
Definition: attack.h:87
init_hash_table
void init_hash_table(void)
Definition: shstr.cpp:55
mapstruct
Definition: map.h:316
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
attackmess_t::buf2
char * buf2
Definition: attack.h:121
free_globals
void free_globals(void)
Definition: init.cpp:438
assets.h
SPELL_FAILURE_EFFECTS
#define SPELL_FAILURE_EFFECTS
Definition: config.h:157
init_defaults
static void init_defaults(void)
Definition: init.cpp:471
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:1549
first_artifactlist
artifactlist * first_artifactlist
Definition: init.cpp:109
attackmess_t::level
int level
Definition: attack.h:119
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
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:113
Chaos_Attacks
Definition: attack.h:125
blocks_prayer
sstring blocks_prayer
Definition: init.cpp:126
Settings::tmpdir
const char * tmpdir
Definition: global.h:255
AT_PARALYZE
#define AT_PARALYZE
Definition: attack.h:88
EMERGENCY_MAPPATH
#define EMERGENCY_MAPPATH
Definition: config.h:498
CSPORT
#define CSPORT
Definition: config.h:354
BufferReader
Definition: bufferreader.cpp:21
assets_init
void assets_init()
Definition: assets.cpp:65
exiting
int exiting
Definition: init.cpp:115
attackmess_t
Definition: attack.h:118
object.h
NOT_PERMADETH
#define NOT_PERMADETH
Definition: config.h:163
llevDebug
@ llevDebug
Definition: logger.h:13
NRSPELLPATHS
#define NRSPELLPATHS
Definition: spells.h:40
assets_end_load
void assets_end_load()
Definition: assets.cpp:227
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
attackmess_t::buf3
char * buf3
Definition: attack.h:122
Settings::localdir
const char * localdir
Definition: global.h:249