server/common/init.C

/*
 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
 * 
 * Copyright (©) 2005,2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
 * Copyright (©) 2002 Mark Wedel & Crossfire Development Team
 * Copyright (©) 1992 Frank Tore Johansen
 * 
 * Deliantra is free software: you can redistribute it and/or modify it under
 * the terms of the Affero GNU General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or (at your
 * option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the Affero GNU General Public License
 * and the GNU General Public License along with this program. If not, see
 * <http://www.gnu.org/licenses/>.
 * 
 * The authors can be reached via e-mail to <support@deliantra.net>
 */

#define EXTERN                  // horrible hack

#include <global.h>
#include <object.h>

dynbuf_text msg_dynbuf (65536, 65536);

extern const char *const attacktype_name[NROFATTACKS] = {
# define def(uc, lc, desc, plus, change) # lc,
#  include "attackinc.h"
# undef def
};

extern const char *const attacktype_desc[NROFATTACKS] = {
# define def(uc, lc, desc, plus, change) # desc,
#  include "attackinc.h"
# undef def
};

extern const char *const resist_plus[NROFATTACKS] = {
# define def(uc, lc, desc, plus, change) # plus,
#  include "attackinc.h"
# undef def
};

extern const char *const change_resist_msg[NROFATTACKS] = {
# define def(uc, lc, desc, plus, change) # change,
#  include "attackinc.h"
# undef def
};

int resist_table[NROFATTACKS] = {
# define def(uc, lc, desc, plus, change) ATNR_ ## uc,
#  include "attackinc.h"
# undef def
};

/* You unforunately need to looking in include/global.h to see what these
 * correspond to.
 */
struct Settings settings = {
  LOGFILE,                      /* Logfile */
  CSPORT,                       /* Client/server port */
  llevTrace,                    /* Log level */
  0, NULL, 0,                   /* dumpvalues, dumparg, daemonmode */
  0,                            /* argc */
  NULL,                         /* argv */
  CONFDIR,
  DATADIR,
  LOCALDIR,
  PLAYERDIR, MAPDIR, ARCHETYPES, REGIONS, TREASURES,
  UNIQUE_DIR, "",
  TMPDIR,
  PK_LUCK_PENALTY,
  STAT_LOSS_ON_DEATH,
  PERMANENT_EXPERIENCE_RATIO,
  DEATH_PENALTY_RATIO,
  DEATH_PENALTY_LEVEL,
  BALANCED_STAT_LOSS,
  NOT_PERMADETH,
  SIMPLE_EXP,
  SET_TITLE,
  RESURRECTION,
  SEARCH_ITEMS,
  SPELL_ENCUMBRANCE,
  SPELL_FAILURE_EFFECTS,
  SET_FRIENDLY_FIRE,
  0,
  0,
  EXPLORE_MODE,
  SPELLPOINT_LEVEL_DEPEND,
  0,
  1.25,

/* Armor enchantment stuff */
  ARMOR_MAX_ENCHANT,
  ARMOR_WEIGHT_REDUCTION,
  ARMOR_WEIGHT_LINEAR,
  ARMOR_SPEED_IMPROVEMENT,
  ARMOR_SPEED_LINEAR,
};

/* perhaps not the best place for this, but needs to be
 * in some file in the common area so that standalone
 * programs, like the random map generator, can be built.
 */
const char *const spellpathnames[NRSPELLPATHS] = {
  "Protection",
  "Fire",
  "Frost",
  "Electricity",
  "Missiles",
  "Self",
  "Summoning",
  "Abjuration",
  "Restoration",
  "Detonation",
  "Mind",
  "Creation",
  "Teleportation",
  "Information",
  "Transmutation",
  "Transferrence",
  "Turning",
  "Wounding",
  "Death",
  "Light"
};

/* init_environ initialises values from the environmental variables.
 * it needs to be called very early, since command line options should
 * overwrite these if specified.
 */
void
init_environ ()
{
  const char *cp;

  if (cp = getenv ("DELIANTRA_CONFDIR"    )) settings.confdir     = cp; 
  if (cp = getenv ("DELIANTRA_LIBDIR"     )) settings.datadir     = cp;
  if (cp = getenv ("DELIANTRA_LOCALDIR"   )) settings.localdir    = cp;
  if (cp = getenv ("DELIANTRA_PLAYERDIR"  )) settings.playerdir   = cp;
  if (cp = getenv ("DELIANTRA_MAPDIR"     )) settings.mapdir      = cp; 
  if (cp = getenv ("DELIANTRA_ARCHETYPES" )) settings.archetypes  = cp; 
  if (cp = getenv ("DELIANTRA_TREASURES"  )) settings.treasures   = cp; 
  if (cp = getenv ("DELIANTRA_UNIQUEDIR"  )) settings.uniquedir   = cp; 
  if (cp = getenv ("DELIANTRA_TEMPLATEDIR")) settings.templatedir = cp; 
  if (cp = getenv ("DELIANTRA_TMPDIR"     )) settings.tmpdir      = cp;

  if (cp = getenv ("DELIANTRA_LOGFILE"    )) settings.logfilename = cp;
}

/*
 * Initialises all global variables.
 * Might use environment-variables as default for some of them.
 */
void
init_globals ()
{
  if (settings.logfilename[0] == 0)
    log_setfd (-1);
  else 
    {
      int logfd = open (settings.logfilename, O_CREAT|O_WRONLY|O_APPEND, 0666);

      if (logfd >= 0)
        log_setfd (logfd);
      else
        {
          log_setfd (-1);
          LOG (llevError, "Unable to open %s as the logfile - will use stderr instead", settings.logfilename);
        }
    }
}

void
init_dynamic ()
{
  first_map_ext_path = "/start/HallsOfSelection";
  first_map_path = "/HallOfSelection";
}

/*
 * initialises the attack messages.
 * Called by init_library().
 */

//attackmess_t attack_mess[NROFATTACKMESS][MAXATTACKMESS];

void
init_attackmess ()
{
  object_thawer thawer (settings.datadir, "attackmess");

  if (!thawer)
    {
      LOG (llevError, "Can't open %s.\n", thawer.name);
      return;
    }

  int msgnum = -1;
  int total = 0;

  while (thawer.kw)
    {
      if (thawer.kw != KW_type)
        if (!thawer.parse_error ("attackmess file"))
          break;

      thawer.get (msgnum);
      thawer.next ();

      int level = 0;

      while (thawer.kw == KW_hp)
        {
          // our old friend, dog-slow sscanf
          int hp;
          char buf1[1024];
          char buf2[1024];
          char buf3[1024];

          if (4 != sscanf (thawer.value_nn, "%d %1023[^|]|%1023[^|]|%1023[^|]",
                           &hp, buf1, buf2, buf3))
            thawer.parse_error ("attackmess file");
          else
            {
              if (*buf2 == '-')
                *buf2 = 0; // sscanf can't parse empty fields, so use "-" as marker

              attack_mess[msgnum][level].level = hp;
              attack_mess[msgnum][level].buf1  = strdup (buf1);
              attack_mess[msgnum][level].buf2  = strdup (buf2);
              attack_mess[msgnum][level].buf3  = strdup (buf3);

              ++level;
              ++total;
            }

          thawer.next ();
        }

      attack_mess[msgnum][level].level = -1;
      attack_mess[msgnum][level].buf1  = 0;
      attack_mess[msgnum][level].buf2  = 0;
      attack_mess[msgnum][level].buf3  = 0;
    }

  LOG (llevDebug, "got %d messages in %d categories.\n", total, msgnum + 1);
}

Revision:	1.61
Committed:	Mon Oct 11 18:40:43 2010 UTC (13 years, 8 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.60:	+10 -4 lines
Log Message:	resists_xxx body_xxx_yyy match
#	Content
1	/*
2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	*
4	* Copyright (©) 2005,2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (©) 2002 Mark Wedel & Crossfire Development Team
6	* Copyright (©) 1992 Frank Tore Johansen
7	*
8	* Deliantra is free software: you can redistribute it and/or modify it under
9	* the terms of the Affero GNU General Public License as published by the
10	* Free Software Foundation, either version 3 of the License, or (at your
11	* option) any later version.
12	*
13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.
17	*
18	* You should have received a copy of the Affero GNU General Public License
19	* and the GNU General Public License along with this program. If not, see
20	* <http://www.gnu.org/licenses/>.
21	*
22	* The authors can be reached via e-mail to <support@deliantra.net>
23	*/
24
25	#define EXTERN // horrible hack
26
27	#include <global.h>
28	#include <object.h>
29
30	dynbuf_text msg_dynbuf (65536, 65536);
31
32	extern const char *const attacktype_name[NROFATTACKS] = {
33	# define def(uc, lc, desc, plus, change) # lc,
34	# include "attackinc.h"
35	# undef def
36	};
37
38	extern const char *const attacktype_desc[NROFATTACKS] = {
39	# define def(uc, lc, desc, plus, change) # desc,
40	# include "attackinc.h"
41	# undef def
42	};
43
44	extern const char *const resist_plus[NROFATTACKS] = {
45	# define def(uc, lc, desc, plus, change) # plus,
46	# include "attackinc.h"
47	# undef def
48	};
49
50	extern const char *const change_resist_msg[NROFATTACKS] = {
51	# define def(uc, lc, desc, plus, change) # change,
52	# include "attackinc.h"
53	# undef def
54	};
55
56	int resist_table[NROFATTACKS] = {
57	# define def(uc, lc, desc, plus, change) ATNR_ ## uc,
58	# include "attackinc.h"
59	# undef def
60	};
61
62	/* You unforunately need to looking in include/global.h to see what these
63	* correspond to.
64	*/
65	struct Settings settings = {
66	LOGFILE, /* Logfile */
67	CSPORT, /* Client/server port */
68	llevTrace, /* Log level */
69	0, NULL, 0, /* dumpvalues, dumparg, daemonmode */
70	0, /* argc */
71	NULL, /* argv */
72	CONFDIR,
73	DATADIR,
74	LOCALDIR,
75	PLAYERDIR, MAPDIR, ARCHETYPES, REGIONS, TREASURES,
76	UNIQUE_DIR, "",
77	TMPDIR,
78	PK_LUCK_PENALTY,
79	STAT_LOSS_ON_DEATH,
80	PERMANENT_EXPERIENCE_RATIO,
81	DEATH_PENALTY_RATIO,
82	DEATH_PENALTY_LEVEL,
83	BALANCED_STAT_LOSS,
84	NOT_PERMADETH,
85	SIMPLE_EXP,
86	SET_TITLE,
87	RESURRECTION,
88	SEARCH_ITEMS,
89	SPELL_ENCUMBRANCE,
90	SPELL_FAILURE_EFFECTS,
91	SET_FRIENDLY_FIRE,
92	0,
93	0,
94	EXPLORE_MODE,
95	SPELLPOINT_LEVEL_DEPEND,
96	0,
97	1.25,
98
99	/* Armor enchantment stuff */
100	ARMOR_MAX_ENCHANT,
101	ARMOR_WEIGHT_REDUCTION,
102	ARMOR_WEIGHT_LINEAR,
103	ARMOR_SPEED_IMPROVEMENT,
104	ARMOR_SPEED_LINEAR,
105	};
106
107	/* perhaps not the best place for this, but needs to be
108	* in some file in the common area so that standalone
109	* programs, like the random map generator, can be built.
110	*/
111	const char *const spellpathnames[NRSPELLPATHS] = {
112	"Protection",
113	"Fire",
114	"Frost",
115	"Electricity",
116	"Missiles",
117	"Self",
118	"Summoning",
119	"Abjuration",
120	"Restoration",
121	"Detonation",
122	"Mind",
123	"Creation",
124	"Teleportation",
125	"Information",
126	"Transmutation",
127	"Transferrence",
128	"Turning",
129	"Wounding",
130	"Death",
131	"Light"
132	};
133
134	/* init_environ initialises values from the environmental variables.
135	* it needs to be called very early, since command line options should
136	* overwrite these if specified.
137	*/
138	void
139	init_environ ()
140	{
141	const char *cp;
142
143	if (cp = getenv ("DELIANTRA_CONFDIR" )) settings.confdir = cp;
144	if (cp = getenv ("DELIANTRA_LIBDIR" )) settings.datadir = cp;
145	if (cp = getenv ("DELIANTRA_LOCALDIR" )) settings.localdir = cp;
146	if (cp = getenv ("DELIANTRA_PLAYERDIR" )) settings.playerdir = cp;
147	if (cp = getenv ("DELIANTRA_MAPDIR" )) settings.mapdir = cp;
148	if (cp = getenv ("DELIANTRA_ARCHETYPES" )) settings.archetypes = cp;
149	if (cp = getenv ("DELIANTRA_TREASURES" )) settings.treasures = cp;
150	if (cp = getenv ("DELIANTRA_UNIQUEDIR" )) settings.uniquedir = cp;
151	if (cp = getenv ("DELIANTRA_TEMPLATEDIR")) settings.templatedir = cp;
152	if (cp = getenv ("DELIANTRA_TMPDIR" )) settings.tmpdir = cp;
153
154	if (cp = getenv ("DELIANTRA_LOGFILE" )) settings.logfilename = cp;
155	}
156
157	/*
158	* Initialises all global variables.
159	* Might use environment-variables as default for some of them.
160	*/
161	void
162	init_globals ()
163	{
164	if (settings.logfilename[0] == 0)
165	log_setfd (-1);
166	else
167	{
168	int logfd = open (settings.logfilename, O_CREAT\|O_WRONLY\|O_APPEND, 0666);
169
170	if (logfd >= 0)
171	log_setfd (logfd);
172	else
173	{
174	log_setfd (-1);
175	LOG (llevError, "Unable to open %s as the logfile - will use stderr instead", settings.logfilename);
176	}
177	}
178	}
179
180	void
181	init_dynamic ()
182	{
183	first_map_ext_path = "/start/HallsOfSelection";
184	first_map_path = "/HallOfSelection";
185	}
186
187	/*
188	* initialises the attack messages.
189	* Called by init_library().
190	*/
191
192	//attackmess_t attack_mess[NROFATTACKMESS][MAXATTACKMESS];
193
194	void
195	init_attackmess ()
196	{
197	object_thawer thawer (settings.datadir, "attackmess");
198
199	if (!thawer)
200	{
201	LOG (llevError, "Can't open %s.\n", thawer.name);
202	return;
203	}
204
205	int msgnum = -1;
206	int total = 0;
207
208	while (thawer.kw)
209	{
210	if (thawer.kw != KW_type)
211	if (!thawer.parse_error ("attackmess file"))
212	break;
213
214	thawer.get (msgnum);
215	thawer.next ();
216
217	int level = 0;
218
219	while (thawer.kw == KW_hp)
220	{
221	// our old friend, dog-slow sscanf
222	int hp;
223	char buf1[1024];
224	char buf2[1024];
225	char buf3[1024];
226
227	if (4 != sscanf (thawer.value_nn, "%d %1023[^\|]\|%1023[^\|]\|%1023[^\|]",
228	&hp, buf1, buf2, buf3))
229	thawer.parse_error ("attackmess file");
230	else
231	{
232	if (*buf2 == '-')
233	*buf2 = 0; // sscanf can't parse empty fields, so use "-" as marker
234
235	attack_mess[msgnum][level].level = hp;
236	attack_mess[msgnum][level].buf1 = strdup (buf1);
237	attack_mess[msgnum][level].buf2 = strdup (buf2);
238	attack_mess[msgnum][level].buf3 = strdup (buf3);
239
240	++level;
241	++total;
242	}
243
244	thawer.next ();
245	}
246
247	attack_mess[msgnum][level].level = -1;
248	attack_mess[msgnum][level].buf1 = 0;
249	attack_mess[msgnum][level].buf2 = 0;
250	attack_mess[msgnum][level].buf3 = 0;
251	}
252
253	LOG (llevDebug, "got %d messages in %d categories.\n", total, msgnum + 1);
254	}
255