server/common/init.C

/*
 * static char *rcsid_init_c =
 *   "$Id: init.C,v 1.8 2006-09-07 13:52:08 root Exp $";
 */

/*
    CrossFire, A Multiplayer game for X-windows

    Copyright (C) 2002 Mark Wedel & Crossfire Development Team
    Copyright (C) 1992 Frank Tore Johansen

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 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 GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

    The authors can be reached via e-mail at crossfire-devel@real-time.com
*/

#define EXTERN // horrible hack

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

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

extern const keyword resist_save[NROFATTACKS] = {
# define def(uc, lc, name, plus, change) KW_resist_ ## lc,
#  include "attackinc.h"
# undef def
};

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

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

int resist_table[NROFATTACKS] = {
# define def(uc, lc, name, 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 */

/* Debug level */
#ifdef DEBUG
  llevDebug,
#else
  llevInfo,
#endif

0, NULL, 0,    /* dumpvalues, dumparg, daemonmode */
0, /* argc */
NULL, /* argv */
CONFDIR,
DATADIR, 
LOCALDIR,
PLAYERDIR, MAPDIR, ARCHETYPES,REGIONS,TREASURES, 
UNIQUE_DIR, TEMPLATE_DIR,
TMPDIR,
STAT_LOSS_ON_DEATH,
PK_LUCK_PENALTY,
PERMANENT_EXPERIENCE_RATIO,
DEATH_PENALTY_RATIO,
DEATH_PENALTY_LEVEL,
BALANCED_STAT_LOSS,
NOT_PERMADETH,
SIMPLE_EXP,
RESET_LOCATION_TIME,
SET_TITLE,
RESURRECTION,
SEARCH_ITEMS,
SPELL_ENCUMBRANCE,
SPELL_FAILURE_EFFECTS,
CASTING_TIME,
REAL_WIZ,
RECYCLE_TMP_MAPS,
EXPLORE_MODE,
SPELLPOINT_LEVEL_DEPEND,
SET_FRIENDLY_FIRE,
"", /* Who format specifier */
"", /* who wiz format specifier */
MOTD,
"rules",
"news",
"",             /* DM_MAIL */
0,              /* This and the next 3 values are metaserver values */
"",
"",
0,
"",
0,0,0,0,0,0,0,0,  /* worldmap settings*/
EMERGENCY_MAPPATH, EMERGENCY_X, EMERGENCY_Y,
0,
1.0,
/* Armor enchantment stuff */
ARMOR_MAX_ENCHANT,
ARMOR_WEIGHT_REDUCTION,
ARMOR_WEIGHT_LINEAR,
ARMOR_SPEED_IMPROVEMENT,
ARMOR_SPEED_LINEAR,
1, /* no_player_stealing */
1, /* create_home_portals */
};

/* 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"
};


/* This loads the emergency map information from a
 * .emergency file in the map directory.  Doing this makes
 * it easier to switch between map distributions (don't need
 * to recompile.  Note that there is no reason I see that
 * this could not be re-loaded during play, but it seems
 * like there should be little reason to do that.
 */
static void init_emergency_mappath(void)
{
    char filename[MAX_BUF], tmpbuf[MAX_BUF];
    FILE    *fp;
    int online=0;

    /* If this file doesn't exist, not a big deal */
    sprintf(filename,"%s/%s/.emergency",settings.datadir, settings.mapdir);
    if ((fp = fopen(filename, "r"))!=NULL) {
        while (fgets(tmpbuf, MAX_BUF-1, fp)) {
            if (tmpbuf[0] == '#') continue; /* ignore comments */
            
            if (online == 0) {
                tmpbuf[strlen(tmpbuf)-1] = 0;   /* kill newline */
                settings.emergency_mapname = strdup_local(tmpbuf);
            }
            else if (online == 1) {
                settings.emergency_x = atoi(tmpbuf);
            }

            else if (online == 2) {
                settings.emergency_y = atoi(tmpbuf);
            }
            online++;
            if (online>2) break;
        }
        fclose(fp);
        if (online<=2)
            LOG(llevError,"Online read partial data from %s\n", filename);
        LOG(llevDebug,"Emergency mappath reset to %s (%d, %d)\n", settings.emergency_mapname,
            settings.emergency_x, settings.emergency_y);
    }
}
    

/*
 * It is vital that init_library() is called by any functions
 * using this library.
 * If you want to lessen the size of the program using the library,
 * you can replace the call to init_library() with init_globals() and
 * init_function_pointers().  Good idea to also call init_vars and
 * init_hash_table if you are doing any object loading.
 */

void init_library(void) {
    init_environ();
    init_globals();
    init_objects();
    init_vars();
    init_block();
    ReadBmapNames ();
    ReadSmooth();
    init_anim();    /* Must be after we read in the bitmaps */
    init_archetypes();  /* Reads all archetypes from file */
    init_dynamic ();
    init_attackmess();
    init_clocks();
    init_emergency_mappath();
    init_experience();
}


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

    cp=getenv("CROSSFIRE_LIBDIR");
    if (cp) settings.datadir=cp;
    cp=getenv("CROSSFIRE_LOCALDIR");
    if (cp) settings.localdir=cp;
    cp=getenv("CROSSFIRE_PLAYERDIR");
    if (cp) settings.playerdir=cp;
    cp=getenv("CROSSFIRE_MAPDIR");
    if (cp) settings.mapdir=cp;
    cp=getenv("CROSSFIRE_ARCHETYPES");
    if (cp) settings.archetypes=cp;
    cp=getenv("CROSSFIRE_TREASURES");
    if (cp) settings.treasures=cp;
    cp=getenv("CROSSFIRE_UNIQUEDIR");
    if (cp) settings.uniquedir=cp;
    cp=getenv("CROSSFIRE_TEMPLATEDIR");
    if (cp) settings.templatedir=cp;
    cp=getenv("CROSSFIRE_TMPDIR");
    if (cp) settings.tmpdir=cp;
}
    

/*
 * Initialises all global variables.
 * Might use environment-variables as default for some of them.
 */

void init_globals(void) {
    if (settings.logfilename[0] == 0) {
        logfile = stderr;
    }
    else if ((logfile=fopen(settings.logfilename, "a"))==NULL) {
        fprintf(stderr,"Unable to open %s as the logfile - will use stderr instead\n",
                settings.logfilename);
        logfile = stderr;
    }
    else {
        setvbuf(logfile, NULL, _IOLBF, 0);
    }
    exiting = 0;
    first_player=NULL;
    first_friendly_object=NULL;
    first_map=NULL;
    first_treasurelist=NULL;
    first_artifactlist=NULL;
    first_archetype=NULL;
    *first_map_ext_path=0;
    warn_archetypes=0;
    nroftreasures = 0;
    nrofartifacts = 0;
    nrofallowedstr=0;
    ring_arch = NULL;
    amulet_arch = NULL;
    staff_arch = NULL;
    trying_emergency_save = 0;
    num_animations=0;
    animations_allocated=0;
    init_defaults();
}

/*
 * Sets up and initialises the linked list of free and used objects.
 * Allocates a certain chunk of objects and puts them on the free list.
 * Called by init_library();
 */

void
init_objects(void)
{
  /* Initialize all objects: */
  objects = NULL;
  active_objects = NULL;
}

/*
 * Initialises global variables which can be changed by options.
 * Called by init_library().
 */

void init_defaults(void) {
  editor=0;
  nroferrors=0;
}


void init_dynamic (void) {
    archetype *at = first_archetype;
    while (at) {
        if (at->clone.type == MAP) {
            if (at->clone.race) {
                strcpy (first_map_ext_path, at->clone.race);
            }
            if (EXIT_PATH (&at->clone)) {
                strcpy (first_map_path, EXIT_PATH (&at->clone));
                return;
            }
        }
        at = at->next;
    }
    LOG(llevDebug,"You Need a archetype called 'map' and it have to contain start map\n");
    exit (-1);
}

unsigned long todtick;

/*
 * Write out the current time to the file so time does not
 * reset every time the server reboots.
 */

void write_todclock(void)
{
    char filename[MAX_BUF];
    FILE *fp;

    sprintf(filename, "%s/clockdata", settings.localdir);
    if ((fp = fopen(filename, "w")) == NULL) {
        LOG(llevError, "Cannot open %s for writing\n", filename);
        return;
    }
    fprintf(fp, "%lu", todtick);
    fclose(fp);
}

/*
 * Initializes the gametime and TOD counters
 * Called by init_library().
 */

void init_clocks(void)
{
    char filename[MAX_BUF];
    FILE *fp;
    static int has_been_done=0;

    if (has_been_done)
        return;
    else
        has_been_done = 1;

    sprintf(filename, "%s/clockdata", settings.localdir);
    LOG(llevDebug, "Reading clockdata from %s...", filename);
    if ((fp = fopen(filename, "r")) == NULL) {
        LOG(llevError, "Can't open %s.\n", filename);
        todtick = 0;
        write_todclock();
        return;
    }
    fscanf(fp, "%lu", &todtick);
    LOG(llevDebug, "todtick=%lu\n", todtick);
    fclose(fp);
}

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

//attackmess_t attack_mess[NROFATTACKMESS][MAXATTACKMESS];

void init_attackmess(void){
    char buf[MAX_BUF];
    char filename[MAX_BUF];
    char *cp, *p;
    FILE *fp;
    static int has_been_done=0;
    int mess, level, comp;
    int mode=0, total=0;

    if (has_been_done)
        return;
    else
        has_been_done = 1;

    sprintf(filename, "%s/attackmess", settings.datadir);
    LOG(llevDebug, "Reading attack messages from %s...", filename);
    if ((fp = open_and_uncompress(filename, 0, &comp)) == NULL) {
        LOG(llevError, "Can't open %s.\n", filename);
        return;
    }

    level = 0;
    while (fgets(buf, MAX_BUF, fp)!=NULL) {
        if (*buf=='#') continue;
        if((cp=strchr(buf,'\n'))!=NULL)
            *cp='\0';
        cp=buf;
        while(*cp==' ') /* Skip blanks */
            cp++;

        if (strncmp(cp, "TYPE:", 5)==0) {
            p = strtok(buf, ":");
            p = strtok(NULL, ":");
            if (mode == 1) {
                attack_mess[mess][level].level = -1;
                attack_mess[mess][level].buf1 = NULL;
                attack_mess[mess][level].buf2 = NULL;
                attack_mess[mess][level].buf3 = NULL;
            }
            level = 0;
            mess = atoi(p);
            mode = 1;
            continue;
        }
        if (mode==1) {
            p = strtok(buf, "=");
            attack_mess[mess][level].level = atoi(buf);
            p = strtok(NULL, "=");
            if (p != NULL)
                attack_mess[mess][level].buf1 = strdup_local(p);
            else
              attack_mess[mess][level].buf1 = strdup_local("");
            mode = 2;
            continue;
        } else if (mode==2) {
            p = strtok(buf, "=");
            attack_mess[mess][level].level = atoi(buf);
            p = strtok(NULL, "=");
            if (p != NULL)
                attack_mess[mess][level].buf2 = strdup_local(p);
            else
                attack_mess[mess][level].buf2 = strdup_local("");
            mode = 3;
            continue;
        } else if (mode==3) {
            p = strtok(buf, "=");
            attack_mess[mess][level].level = atoi(buf);
            p = strtok(NULL, "=");
            if (p != NULL)
                attack_mess[mess][level].buf3 = strdup_local(p);
            else
                attack_mess[mess][level].buf3 = strdup_local("");
            mode = 1;
            level++;
            total++;
            continue;
        }
    }
    LOG(llevDebug, "got %d messages in %d categories.\n", total, mess+1);
    close_and_delete(fp, comp);
}
Revision:	1.9
Committed:	Sat Sep 9 23:49:06 2006 UTC (17 years, 8 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.8:	+6 -6 lines
Log Message:	rationalise attackinc.h
#	User	Rev	Content
1	elmex	1.1	/*
2			* static char *rcsid_init_c =
3	root	1.9	* "$Id: init.C,v 1.8 2006-09-07 13:52:08 root Exp $";
4	elmex	1.1	*/
5
6			/*
7			CrossFire, A Multiplayer game for X-windows
8
9			Copyright (C) 2002 Mark Wedel & Crossfire Development Team
10			Copyright (C) 1992 Frank Tore Johansen
11
12			This program is free software; you can redistribute it and/or modify
13			it under the terms of the GNU General Public License as published by
14			the Free Software Foundation; either version 2 of the License, or
15			(at your option) any later version.
16
17			This program is distributed in the hope that it will be useful,
18			but WITHOUT ANY WARRANTY; without even the implied warranty of
19			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20			GNU General Public License for more details.
21
22			You should have received a copy of the GNU General Public License
23			along with this program; if not, write to the Free Software
24			Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25
26			The authors can be reached via e-mail at crossfire-devel@real-time.com
27			*/
28
29	root	1.7	#define EXTERN // horrible hack
30
31	elmex	1.1	#include <global.h>
32			#include <object.h>
33
34	root	1.7	extern const char* const attacktype_desc[NROFATTACKS] = {
35	root	1.9	# define def(uc, lc, name, plus, change) # name,
36	root	1.7	# include "attackinc.h"
37			# undef def
38			};
39
40			extern const keyword resist_save[NROFATTACKS] = {
41	root	1.9	# define def(uc, lc, name, plus, change) KW_resist_ ## lc,
42	root	1.7	# include "attackinc.h"
43			# undef def
44			};
45
46			extern const char* const resist_plus[NROFATTACKS] = {
47	root	1.9	# define def(uc, lc, name, plus, change) # plus,
48	root	1.7	# include "attackinc.h"
49			# undef def
50			};
51
52			extern const char* const change_resist_msg[NROFATTACKS] = {
53	root	1.9	# define def(uc, lc, name, plus, change) # change,
54	root	1.7	# include "attackinc.h"
55			# undef def
56			};
57
58			int resist_table[NROFATTACKS] = {
59	root	1.9	# define def(uc, lc, name, plus, change) ATNR_ ## uc,
60	root	1.7	# include "attackinc.h"
61			# undef def
62			};
63
64	elmex	1.1	/* You unforunately need to looking in include/global.h to see what these
65			* correspond to.
66			*/
67			struct Settings settings = {
68			LOGFILE, /* Logfile */
69			CSPORT, /* Client/server port */
70
71			/* Debug level */
72			#ifdef DEBUG
73			llevDebug,
74			#else
75			llevInfo,
76			#endif
77
78			0, NULL, 0, /* dumpvalues, dumparg, daemonmode */
79			0, /* argc */
80			NULL, /* argv */
81			CONFDIR,
82			DATADIR,
83			LOCALDIR,
84			PLAYERDIR, MAPDIR, ARCHETYPES,REGIONS,TREASURES,
85			UNIQUE_DIR, TEMPLATE_DIR,
86			TMPDIR,
87			STAT_LOSS_ON_DEATH,
88			PK_LUCK_PENALTY,
89			PERMANENT_EXPERIENCE_RATIO,
90			DEATH_PENALTY_RATIO,
91			DEATH_PENALTY_LEVEL,
92			BALANCED_STAT_LOSS,
93			NOT_PERMADETH,
94			SIMPLE_EXP,
95			RESET_LOCATION_TIME,
96			SET_TITLE,
97			RESURRECTION,
98			SEARCH_ITEMS,
99			SPELL_ENCUMBRANCE,
100			SPELL_FAILURE_EFFECTS,
101			CASTING_TIME,
102			REAL_WIZ,
103			RECYCLE_TMP_MAPS,
104			EXPLORE_MODE,
105			SPELLPOINT_LEVEL_DEPEND,
106			SET_FRIENDLY_FIRE,
107			"", /* Who format specifier */
108			"", /* who wiz format specifier */
109			MOTD,
110			"rules",
111			"news",
112			"", /* DM_MAIL */
113			0, /* This and the next 3 values are metaserver values */
114			"",
115			"",
116			0,
117			"",
118			0,0,0,0,0,0,0,0, /* worldmap settings*/
119			EMERGENCY_MAPPATH, EMERGENCY_X, EMERGENCY_Y,
120			0,
121			1.0,
122			/* Armor enchantment stuff */
123			ARMOR_MAX_ENCHANT,
124			ARMOR_WEIGHT_REDUCTION,
125			ARMOR_WEIGHT_LINEAR,
126			ARMOR_SPEED_IMPROVEMENT,
127			ARMOR_SPEED_LINEAR,
128			1, /* no_player_stealing */
129			1, /* create_home_portals */
130			};
131
132			/* perhaps not the best place for this, but needs to be
133			* in some file in the common area so that standalone
134			* programs, like the random map generator, can be built.
135			*/
136			const char* const spellpathnames[NRSPELLPATHS] = {
137			"Protection",
138			"Fire",
139			"Frost",
140			"Electricity",
141			"Missiles",
142			"Self",
143			"Summoning",
144			"Abjuration",
145			"Restoration",
146			"Detonation",
147			"Mind",
148			"Creation",
149			"Teleportation",
150			"Information",
151			"Transmutation",
152			"Transferrence",
153			"Turning",
154			"Wounding",
155			"Death",
156			"Light"
157			};
158
159
160			/* This loads the emergency map information from a
161			* .emergency file in the map directory. Doing this makes
162			* it easier to switch between map distributions (don't need
163			* to recompile. Note that there is no reason I see that
164			* this could not be re-loaded during play, but it seems
165			* like there should be little reason to do that.
166			*/
167			static void init_emergency_mappath(void)
168			{
169			char filename[MAX_BUF], tmpbuf[MAX_BUF];
170			FILE *fp;
171			int online=0;
172
173			/* If this file doesn't exist, not a big deal */
174			sprintf(filename,"%s/%s/.emergency",settings.datadir, settings.mapdir);
175			if ((fp = fopen(filename, "r"))!=NULL) {
176	root	1.2	while (fgets(tmpbuf, MAX_BUF-1, fp)) {
177			if (tmpbuf[0] == '#') continue; /* ignore comments */
178
179			if (online == 0) {
180			tmpbuf[strlen(tmpbuf)-1] = 0; /* kill newline */
181			settings.emergency_mapname = strdup_local(tmpbuf);
182			}
183			else if (online == 1) {
184			settings.emergency_x = atoi(tmpbuf);
185			}
186
187			else if (online == 2) {
188			settings.emergency_y = atoi(tmpbuf);
189			}
190			online++;
191			if (online>2) break;
192			}
193			fclose(fp);
194			if (online<=2)
195			LOG(llevError,"Online read partial data from %s\n", filename);
196			LOG(llevDebug,"Emergency mappath reset to %s (%d, %d)\n", settings.emergency_mapname,
197			settings.emergency_x, settings.emergency_y);
198	elmex	1.1	}
199			}
200
201
202			/*
203			* It is vital that init_library() is called by any functions
204			* using this library.
205			* If you want to lessen the size of the program using the library,
206			* you can replace the call to init_library() with init_globals() and
207			* init_function_pointers(). Good idea to also call init_vars and
208			* init_hash_table if you are doing any object loading.
209			*/
210
211			void init_library(void) {
212			init_environ();
213			init_globals();
214			init_objects();
215			init_vars();
216			init_block();
217			ReadBmapNames ();
218			ReadSmooth();
219			init_anim(); /* Must be after we read in the bitmaps */
220			init_archetypes(); /* Reads all archetypes from file */
221			init_dynamic ();
222			init_attackmess();
223			init_clocks();
224			init_emergency_mappath();
225			init_experience();
226			}
227
228
229			/* init_environ initializes values from the environmental variables.
230			* it needs to be called very early, since command line options should
231			* overwrite these if specified.
232			*/
233			void init_environ(void) {
234			char *cp;
235
236			cp=getenv("CROSSFIRE_LIBDIR");
237			if (cp) settings.datadir=cp;
238			cp=getenv("CROSSFIRE_LOCALDIR");
239			if (cp) settings.localdir=cp;
240			cp=getenv("CROSSFIRE_PLAYERDIR");
241			if (cp) settings.playerdir=cp;
242			cp=getenv("CROSSFIRE_MAPDIR");
243			if (cp) settings.mapdir=cp;
244			cp=getenv("CROSSFIRE_ARCHETYPES");
245			if (cp) settings.archetypes=cp;
246			cp=getenv("CROSSFIRE_TREASURES");
247			if (cp) settings.treasures=cp;
248			cp=getenv("CROSSFIRE_UNIQUEDIR");
249			if (cp) settings.uniquedir=cp;
250			cp=getenv("CROSSFIRE_TEMPLATEDIR");
251			if (cp) settings.templatedir=cp;
252			cp=getenv("CROSSFIRE_TMPDIR");
253			if (cp) settings.tmpdir=cp;
254			}
255
256
257			/*
258			* Initialises all global variables.
259			* Might use environment-variables as default for some of them.
260			*/
261
262			void init_globals(void) {
263			if (settings.logfilename[0] == 0) {
264	root	1.2	logfile = stderr;
265	elmex	1.1	}
266			else if ((logfile=fopen(settings.logfilename, "a"))==NULL) {
267	root	1.2	fprintf(stderr,"Unable to open %s as the logfile - will use stderr instead\n",
268			settings.logfilename);
269			logfile = stderr;
270	elmex	1.1	}
271			else {
272	root	1.2	setvbuf(logfile, NULL, _IOLBF, 0);
273	elmex	1.1	}
274			exiting = 0;
275			first_player=NULL;
276			first_friendly_object=NULL;
277			first_map=NULL;
278			first_treasurelist=NULL;
279			first_artifactlist=NULL;
280			first_archetype=NULL;
281			*first_map_ext_path=0;
282			warn_archetypes=0;
283			nroftreasures = 0;
284			nrofartifacts = 0;
285			nrofallowedstr=0;
286			ring_arch = NULL;
287			amulet_arch = NULL;
288			staff_arch = NULL;
289			trying_emergency_save = 0;
290			num_animations=0;
291			animations_allocated=0;
292			init_defaults();
293			}
294
295			/*
296			* Sets up and initialises the linked list of free and used objects.
297			* Allocates a certain chunk of objects and puts them on the free list.
298			* Called by init_library();
299			*/
300
301	pippijn	1.6	void
302			init_objects(void)
303			{
304			/* Initialize all objects: */
305			objects = NULL;
306	elmex	1.1	active_objects = NULL;
307			}
308
309			/*
310			* Initialises global variables which can be changed by options.
311			* Called by init_library().
312			*/
313
314			void init_defaults(void) {
315			editor=0;
316			nroferrors=0;
317			}
318
319
320			void init_dynamic (void) {
321			archetype *at = first_archetype;
322			while (at) {
323	root	1.2	if (at->clone.type == MAP) {
324	elmex	1.1	if (at->clone.race) {
325			strcpy (first_map_ext_path, at->clone.race);
326			}
327			if (EXIT_PATH (&at->clone)) {
328			strcpy (first_map_path, EXIT_PATH (&at->clone));
329			return;
330			}
331	root	1.2	}
332			at = at->next;
333	elmex	1.1	}
334			LOG(llevDebug,"You Need a archetype called 'map' and it have to contain start map\n");
335			exit (-1);
336			}
337
338			unsigned long todtick;
339
340			/*
341			* Write out the current time to the file so time does not
342			* reset every time the server reboots.
343			*/
344
345			void write_todclock(void)
346			{
347			char filename[MAX_BUF];
348			FILE *fp;
349
350			sprintf(filename, "%s/clockdata", settings.localdir);
351			if ((fp = fopen(filename, "w")) == NULL) {
352	root	1.2	LOG(llevError, "Cannot open %s for writing\n", filename);
353			return;
354	elmex	1.1	}
355			fprintf(fp, "%lu", todtick);
356			fclose(fp);
357			}
358
359			/*
360			* Initializes the gametime and TOD counters
361			* Called by init_library().
362			*/
363
364			void init_clocks(void)
365			{
366			char filename[MAX_BUF];
367			FILE *fp;
368			static int has_been_done=0;
369
370			if (has_been_done)
371			return;
372			else
373			has_been_done = 1;
374
375			sprintf(filename, "%s/clockdata", settings.localdir);
376			LOG(llevDebug, "Reading clockdata from %s...", filename);
377			if ((fp = fopen(filename, "r")) == NULL) {
378			LOG(llevError, "Can't open %s.\n", filename);
379	root	1.2	todtick = 0;
380			write_todclock();
381			return;
382	elmex	1.1	}
383			fscanf(fp, "%lu", &todtick);
384			LOG(llevDebug, "todtick=%lu\n", todtick);
385			fclose(fp);
386			}
387
388			/*
389			* Initializes the attack messages.
390			* Called by init_library().
391			*/
392
393			//attackmess_t attack_mess[NROFATTACKMESS][MAXATTACKMESS];
394
395			void init_attackmess(void){
396			char buf[MAX_BUF];
397			char filename[MAX_BUF];
398			char cp, p;
399			FILE *fp;
400			static int has_been_done=0;
401			int mess, level, comp;
402			int mode=0, total=0;
403
404			if (has_been_done)
405			return;
406			else
407			has_been_done = 1;
408
409			sprintf(filename, "%s/attackmess", settings.datadir);
410			LOG(llevDebug, "Reading attack messages from %s...", filename);
411			if ((fp = open_and_uncompress(filename, 0, &comp)) == NULL) {
412			LOG(llevError, "Can't open %s.\n", filename);
413	root	1.2	return;
414	elmex	1.1	}
415
416			level = 0;
417			while (fgets(buf, MAX_BUF, fp)!=NULL) {
418			if (*buf=='#') continue;
419	root	1.2	if((cp=strchr(buf,'\n'))!=NULL)
420	elmex	1.1	*cp='\0';
421	root	1.2	cp=buf;
422			while(cp==' ') / Skip blanks */
423			cp++;
424
425			if (strncmp(cp, "TYPE:", 5)==0) {
426			p = strtok(buf, ":");
427			p = strtok(NULL, ":");
428			if (mode == 1) {
429			attack_mess[mess][level].level = -1;
430			attack_mess[mess][level].buf1 = NULL;
431			attack_mess[mess][level].buf2 = NULL;
432			attack_mess[mess][level].buf3 = NULL;
433			}
434			level = 0;
435			mess = atoi(p);
436			mode = 1;
437			continue;
438			}
439			if (mode==1) {
440			p = strtok(buf, "=");
441			attack_mess[mess][level].level = atoi(buf);
442			p = strtok(NULL, "=");
443			if (p != NULL)
444			attack_mess[mess][level].buf1 = strdup_local(p);
445			else
446			attack_mess[mess][level].buf1 = strdup_local("");
447			mode = 2;
448			continue;
449			} else if (mode==2) {
450			p = strtok(buf, "=");
451			attack_mess[mess][level].level = atoi(buf);
452			p = strtok(NULL, "=");
453			if (p != NULL)
454			attack_mess[mess][level].buf2 = strdup_local(p);
455			else
456			attack_mess[mess][level].buf2 = strdup_local("");
457			mode = 3;
458			continue;
459			} else if (mode==3) {
460			p = strtok(buf, "=");
461			attack_mess[mess][level].level = atoi(buf);
462			p = strtok(NULL, "=");
463			if (p != NULL)
464			attack_mess[mess][level].buf3 = strdup_local(p);
465			else
466			attack_mess[mess][level].buf3 = strdup_local("");
467			mode = 1;
468			level++;
469			total++;
470			continue;
471			}
472	elmex	1.1	}
473			LOG(llevDebug, "got %d messages in %d categories.\n", total, mess+1);
474			close_and_delete(fp, comp);
475			}