server/common/init.C

/*
 * static char *rcsid_init_c =
 *   "$Id: init.C,v 1.7 2006-09-07 13:34:56 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, name, lc, plus, change) # name,
#  include "attackinc.h"
# undef def
};

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

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

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

int resist_table[NROFATTACKS] = {
# define def(uc, name, lc, 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.8
Committed:	Thu Sep 7 13:52:08 2006 UTC (17 years, 8 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.7:	+3 -3 lines
Log Message:	* empty log message *
#	Content
1	/*
2	* static char *rcsid_init_c =
3	* "$Id: init.C,v 1.7 2006-09-07 13:34:56 root Exp $";
4	*/
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	#define EXTERN // horrible hack
30
31	#include <global.h>
32	#include <object.h>
33
34	extern const char* const attacktype_desc[NROFATTACKS] = {
35	# define def(uc, name, lc, plus, change) # name,
36	# include "attackinc.h"
37	# undef def
38	};
39
40	extern const keyword resist_save[NROFATTACKS] = {
41	# define def(uc, name, lc, plus, change) KW_resist_ ## lc,
42	# include "attackinc.h"
43	# undef def
44	};
45
46	extern const char* const resist_plus[NROFATTACKS] = {
47	# define def(uc, name, lc, plus, change) # plus,
48	# include "attackinc.h"
49	# undef def
50	};
51
52	extern const char* const change_resist_msg[NROFATTACKS] = {
53	# define def(uc, name, lc, plus, change) # change,
54	# include "attackinc.h"
55	# undef def
56	};
57
58	int resist_table[NROFATTACKS] = {
59	# define def(uc, name, lc, plus, change) ATNR_ ## uc,
60	# include "attackinc.h"
61	# undef def
62	};
63
64	/* 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	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	}
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	logfile = stderr;
265	}
266	else if ((logfile=fopen(settings.logfilename, "a"))==NULL) {
267	fprintf(stderr,"Unable to open %s as the logfile - will use stderr instead\n",
268	settings.logfilename);
269	logfile = stderr;
270	}
271	else {
272	setvbuf(logfile, NULL, _IOLBF, 0);
273	}
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	void
302	init_objects(void)
303	{
304	/* Initialize all objects: */
305	objects = NULL;
306	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	if (at->clone.type == MAP) {
324	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	}
332	at = at->next;
333	}
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	LOG(llevError, "Cannot open %s for writing\n", filename);
353	return;
354	}
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	todtick = 0;
380	write_todclock();
381	return;
382	}
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	return;
414	}
415
416	level = 0;
417	while (fgets(buf, MAX_BUF, fp)!=NULL) {
418	if (*buf=='#') continue;
419	if((cp=strchr(buf,'\n'))!=NULL)
420	*cp='\0';
421	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	}
473	LOG(llevDebug, "got %d messages in %d categories.\n", total, mess+1);
474	close_and_delete(fp, comp);
475	}