ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/deliantra/server/server/main.C

Comparing deliantra/server/server/main.C (file contents):
Revision 1.19 by root, Sun Sep 3 22:45:57 2006 UTC vs.
Revision 1.23 by root, Sun Sep 10 15:59:57 2006 UTC

		1
1	/*	2	/*
2	* static char *rcsid_main_c =	3	* static char *rcsid_main_c =
3	* "$Id: main.C,v 1.19 2006/09/03 22:45:57 root Exp $";	4	* "$Id: main.C,v 1.23 2006/09/10 15:59:57 root Exp $";
4	*/	5	*/
5		6
6	/*	7	/*
7	CrossFire, A Multiplayer game for X-windows	8	CrossFire, A Multiplayer game for X-windows
8		9
…		…
29	#include <global.h>	30	#include <global.h>
30	#include <object.h>	31	#include <object.h>
31	#include <tod.h>	32	#include <tod.h>
32		33
33	#ifdef HAVE_DES_H	34	#ifdef HAVE_DES_H
34	#include <des.h>	35	# include <des.h>
35	#else	36	#else
36	# ifdef HAVE_CRYPT_H	37	# ifdef HAVE_CRYPT_H
37	# include <crypt.h>	38	# include <crypt.h>
38	# endif	39	# endif
39	#endif	40	#endif
40		41
41	#ifndef __CEXTRACT__	42	#ifndef __CEXTRACT__
42	#include <sproto.h>	43	# include <sproto.h>
43	#endif	44	#endif
44		45
45	#ifdef HAVE_TIME_H	46	#ifdef HAVE_TIME_H
46	#include <time.h>	47	# include <time.h>
47	#endif	48	#endif
48		49
49	#include <../random_maps/random_map.h>	50	#include <../random_maps/random_map.h>
50	#include <../random_maps/rproto.h>	51	#include <../random_maps/rproto.h>
51	#include "path.h"	52	#include "path.h"
52		53
53	shstr undead_name;
54
55	static char days[7][4] = {	54	static char days[7][4] = {
56	"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};	55	"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
		56	};
57		57
		58	void
58	void version(object *op) {	59	version (object *op)
		60	{
59	if(op!=NULL)	61	if (op != NULL)
60	clear_win_info(op);	62	clear_win_info (op);
61		63
62	new_draw_info_format(NDI_UNIQUE, 0, op, "This is Crossfire v%s",VERSION);	64	new_draw_info_format (NDI_UNIQUE, 0, op, "This is Crossfire v%s", VERSION);
63		65
64	/* If in a socket, don't print out the list of authors. It confuses the	66	/* If in a socket, don't print out the list of authors. It confuses the
65	* crossclient program.	67	* crossclient program.
66	*/	68	*/
67	if (op==NULL) return;	69	if (op == NULL)
		70	return;
68	new_draw_info(NDI_UNIQUE, 0,op,"Authors and contributors to this program:");	71	new_draw_info (NDI_UNIQUE, 0, op, "Authors and contributors to this program:");
69	new_draw_info(NDI_UNIQUE, 0,op,"mwedel@sonic.net (Mark Wedel)");	72	new_draw_info (NDI_UNIQUE, 0, op, "mwedel@sonic.net (Mark Wedel)");
70	new_draw_info(NDI_UNIQUE, 0,op,"frankj@ifi.uio.no (Frank Tore Johansen)");	73	new_draw_info (NDI_UNIQUE, 0, op, "frankj@ifi.uio.no (Frank Tore Johansen)");
71	new_draw_info(NDI_UNIQUE, 0,op,"kjetilho@ifi.uio.no (Kjetil Torgrim Homme)");	74	new_draw_info (NDI_UNIQUE, 0, op, "kjetilho@ifi.uio.no (Kjetil Torgrim Homme)");
72	new_draw_info(NDI_UNIQUE, 0,op,"tvangod@ecst.csuchico.edu (Tyler Van Gorder)");	75	new_draw_info (NDI_UNIQUE, 0, op, "tvangod@ecst.csuchico.edu (Tyler Van Gorder)");
73	new_draw_info(NDI_UNIQUE, 0,op,"elmroth@cd.chalmers.se (Tony Elmroth)");	76	new_draw_info (NDI_UNIQUE, 0, op, "elmroth@cd.chalmers.se (Tony Elmroth)");
74	new_draw_info(NDI_UNIQUE, 0,op,"dougal.scott@fcit.monasu.edu.au (Dougal Scott)");	77	new_draw_info (NDI_UNIQUE, 0, op, "dougal.scott@fcit.monasu.edu.au (Dougal Scott)");
75	new_draw_info(NDI_UNIQUE, 0,op,"wchuang@athena.mit.edu (William)");	78	new_draw_info (NDI_UNIQUE, 0, op, "wchuang@athena.mit.edu (William)");
76	new_draw_info(NDI_UNIQUE, 0,op,"ftww@cs.su.oz.au (Geoff Bailey)");	79	new_draw_info (NDI_UNIQUE, 0, op, "ftww@cs.su.oz.au (Geoff Bailey)");
77	new_draw_info(NDI_UNIQUE, 0,op,"jorgens@flipper.pvv.unit.no (Kjetil Wiekhorst Jxrgensen)");	80	new_draw_info (NDI_UNIQUE, 0, op, "jorgens@flipper.pvv.unit.no (Kjetil Wiekhorst Jxrgensen)");
78	new_draw_info(NDI_UNIQUE, 0,op,"c.blackwood@rdt.monash.edu.au (Cameron Blackwood)");	81	new_draw_info (NDI_UNIQUE, 0, op, "c.blackwood@rdt.monash.edu.au (Cameron Blackwood)");
79	new_draw_info(NDI_UNIQUE, 0,op,"jtraub+@cmu.edu (Joseph L. Traub)");	82	new_draw_info (NDI_UNIQUE, 0, op, "jtraub+@cmu.edu (Joseph L. Traub)");
80	new_draw_info(NDI_UNIQUE, 0,op,"rgg@aaii.oz.au (Rupert G. Goldie)");	83	new_draw_info (NDI_UNIQUE, 0, op, "rgg@aaii.oz.au (Rupert G. Goldie)");
81	new_draw_info(NDI_UNIQUE, 0,op,"eanders+@cmu.edu (Eric A. Anderson)");	84	new_draw_info (NDI_UNIQUE, 0, op, "eanders+@cmu.edu (Eric A. Anderson)");
82	new_draw_info(NDI_UNIQUE, 0,op,"eneq@Prag.DoCS.UU.SE (Rickard Eneqvist)");	85	new_draw_info (NDI_UNIQUE, 0, op, "eneq@Prag.DoCS.UU.SE (Rickard Eneqvist)");
83	new_draw_info(NDI_UNIQUE, 0,op,"Jarkko.Sonninen@lut.fi (Jarkko Sonninen)");	86	new_draw_info (NDI_UNIQUE, 0, op, "Jarkko.Sonninen@lut.fi (Jarkko Sonninen)");
84	new_draw_info(NDI_UNIQUE, 0,op,"kholland@sunlab.cit.cornell.du (Karl Holland)");	87	new_draw_info (NDI_UNIQUE, 0, op, "kholland@sunlab.cit.cornell.du (Karl Holland)");
85	new_draw_info(NDI_UNIQUE, 0,op,"vick@bern.docs.uu.se (Mikael Lundgren)");	88	new_draw_info (NDI_UNIQUE, 0, op, "vick@bern.docs.uu.se (Mikael Lundgren)");
86	new_draw_info(NDI_UNIQUE, 0,op,"mol@meryl.csd.uu.se (Mikael Olsson)");	89	new_draw_info (NDI_UNIQUE, 0, op, "mol@meryl.csd.uu.se (Mikael Olsson)");
87	new_draw_info(NDI_UNIQUE, 0,op,"Tero.Haatanen@lut.fi (Tero Haatanen)");	90	new_draw_info (NDI_UNIQUE, 0, op, "Tero.Haatanen@lut.fi (Tero Haatanen)");
88	new_draw_info(NDI_UNIQUE, 0,op,"ylitalo@student.docs.uu.se (Lasse Ylitalo)");	91	new_draw_info (NDI_UNIQUE, 0, op, "ylitalo@student.docs.uu.se (Lasse Ylitalo)");
89	new_draw_info(NDI_UNIQUE, 0,op,"anipa@guru.magic.fi (Niilo Neuvo)");	92	new_draw_info (NDI_UNIQUE, 0, op, "anipa@guru.magic.fi (Niilo Neuvo)");
90	new_draw_info(NDI_UNIQUE, 0,op,"mta@modeemi.cs.tut.fi (Markku J{rvinen)");	93	new_draw_info (NDI_UNIQUE, 0, op, "mta@modeemi.cs.tut.fi (Markku J{rvinen)");
91	new_draw_info(NDI_UNIQUE, 0,op,"meunier@inf.enst.fr (Sylvain Meunier)");	94	new_draw_info (NDI_UNIQUE, 0, op, "meunier@inf.enst.fr (Sylvain Meunier)");
92	new_draw_info(NDI_UNIQUE, 0,op,"jfosback@darmok.uoregon.edu (Jason Fosback)");	95	new_draw_info (NDI_UNIQUE, 0, op, "jfosback@darmok.uoregon.edu (Jason Fosback)");
93	new_draw_info(NDI_UNIQUE, 0,op,"cedman@capitalist.princeton.edu (Carl Edman)");	96	new_draw_info (NDI_UNIQUE, 0, op, "cedman@capitalist.princeton.edu (Carl Edman)");
94	new_draw_info(NDI_UNIQUE, 0,op,"henrich@crh.cl.msu.edu (Charles Henrich)");	97	new_draw_info (NDI_UNIQUE, 0, op, "henrich@crh.cl.msu.edu (Charles Henrich)");
95	new_draw_info(NDI_UNIQUE, 0,op,"schmid@fb3-s7.math.tu-berlin.de (Gregor Schmid)");	98	new_draw_info (NDI_UNIQUE, 0, op, "schmid@fb3-s7.math.tu-berlin.de (Gregor Schmid)");
96	new_draw_info(NDI_UNIQUE, 0,op,"quinet@montefiore.ulg.ac.be (Raphael Quinet)");	99	new_draw_info (NDI_UNIQUE, 0, op, "quinet@montefiore.ulg.ac.be (Raphael Quinet)");
97	new_draw_info(NDI_UNIQUE, 0,op,"jam@modeemi.cs.tut.fi (Jari Vanhala)");	100	new_draw_info (NDI_UNIQUE, 0, op, "jam@modeemi.cs.tut.fi (Jari Vanhala)");
98	new_draw_info(NDI_UNIQUE, 0,op,"kivinen@joker.cs.hut.fi (Tero Kivinen)");	101	new_draw_info (NDI_UNIQUE, 0, op, "kivinen@joker.cs.hut.fi (Tero Kivinen)");
99	new_draw_info(NDI_UNIQUE, 0,op,"peterm@soda.berkeley.edu (Peter Mardahl)");	102	new_draw_info (NDI_UNIQUE, 0, op, "peterm@soda.berkeley.edu (Peter Mardahl)");
100	new_draw_info(NDI_UNIQUE, 0,op,"matt@cs.odu.edu (Matthew Zeher)");	103	new_draw_info (NDI_UNIQUE, 0, op, "matt@cs.odu.edu (Matthew Zeher)");
101	new_draw_info(NDI_UNIQUE, 0,op,"srt@sun-dimas.aero.org (Scott R. Turner)");	104	new_draw_info (NDI_UNIQUE, 0, op, "srt@sun-dimas.aero.org (Scott R. Turner)");
102	new_draw_info(NDI_UNIQUE, 0,op,"huma@netcom.com (Ben Fennema)");	105	new_draw_info (NDI_UNIQUE, 0, op, "huma@netcom.com (Ben Fennema)");
103	new_draw_info(NDI_UNIQUE, 0,op,"njw@cs.city.ac.uk (Nick Williams)");	106	new_draw_info (NDI_UNIQUE, 0, op, "njw@cs.city.ac.uk (Nick Williams)");
104	new_draw_info(NDI_UNIQUE, 0,op,"Wacren@Gin.ObsPM.Fr (Laurent Wacrenier)");	107	new_draw_info (NDI_UNIQUE, 0, op, "Wacren@Gin.ObsPM.Fr (Laurent Wacrenier)");
105	new_draw_info(NDI_UNIQUE, 0,op,"thomas@astro.psu.edu (Brian Thomas)");	108	new_draw_info (NDI_UNIQUE, 0, op, "thomas@astro.psu.edu (Brian Thomas)");
106	new_draw_info(NDI_UNIQUE, 0,op,"jsm@axon.ksc.nasa.gov (John Steven Moerk)");	109	new_draw_info (NDI_UNIQUE, 0, op, "jsm@axon.ksc.nasa.gov (John Steven Moerk)");
107	new_draw_info(NDI_UNIQUE, 0,op,"Delbecq David [david.delbecq@mailandnews.com]");	110	new_draw_info (NDI_UNIQUE, 0, op, "Delbecq David [david.delbecq@mailandnews.com]");
108	new_draw_info(NDI_UNIQUE, 0,op,"Chachkoff Yann [yann.chachkoff@mailandnews.com]\n");	111	new_draw_info (NDI_UNIQUE, 0, op, "Chachkoff Yann [yann.chachkoff@mailandnews.com]\n");
109	new_draw_info(NDI_UNIQUE, 0,op,"Images and art:");	112	new_draw_info (NDI_UNIQUE, 0, op, "Images and art:");
110	new_draw_info(NDI_UNIQUE, 0,op,"Peter Gardner");	113	new_draw_info (NDI_UNIQUE, 0, op, "Peter Gardner");
111	new_draw_info(NDI_UNIQUE, 0,op,"David Gervais [david_eg@mail.com]");	114	new_draw_info (NDI_UNIQUE, 0, op, "David Gervais [david_eg@mail.com]");
112	new_draw_info(NDI_UNIQUE, 0,op,"Mitsuhiro Itakura [ita@gold.koma.jaeri.go.jp]");	115	new_draw_info (NDI_UNIQUE, 0, op, "Mitsuhiro Itakura [ita@gold.koma.jaeri.go.jp]");
113	new_draw_info(NDI_UNIQUE, 0,op,"Hansjoerg Malthaner [hansjoerg.malthaner@danet.de]");	116	new_draw_info (NDI_UNIQUE, 0, op, "Hansjoerg Malthaner [hansjoerg.malthaner@danet.de]");
114	new_draw_info(NDI_UNIQUE, 0,op,"Mårten Woxberg [maxmc@telia.com]");	117	new_draw_info (NDI_UNIQUE, 0, op, "Mårten Woxberg [maxmc@telia.com]");
115	new_draw_info(NDI_UNIQUE, 0,op,"And many more!");	118	new_draw_info (NDI_UNIQUE, 0, op, "And many more!");
116	}	119	}
117		120
		121	void
118	void info_keys(object *op) {	122	info_keys (object *op)
		123	{
119	clear_win_info(op);	124	clear_win_info (op);
120	new_draw_info(NDI_UNIQUE, 0,op,"Push `hjklynub' to walk in a direction.");	125	new_draw_info (NDI_UNIQUE, 0, op, "Push `hjklynub' to walk in a direction.");
121	new_draw_info(NDI_UNIQUE, 0,op,"Shift + dir = fire, Ctrl + dir = run");	126	new_draw_info (NDI_UNIQUE, 0, op, "Shift + dir = fire, Ctrl + dir = run");
122	new_draw_info(NDI_UNIQUE, 0,op,"(To fire at yourself, hit `.'");	127	new_draw_info (NDI_UNIQUE, 0, op, "(To fire at yourself, hit `.'");
123	new_draw_info(NDI_UNIQUE, 0,op,"To attack, walk into the monsters.");	128	new_draw_info (NDI_UNIQUE, 0, op, "To attack, walk into the monsters.");
124	new_draw_info(NDI_UNIQUE, 0,op,"\" = speak ' = extended command");	129	new_draw_info (NDI_UNIQUE, 0, op, "\" = speak ' = extended command");
125	new_draw_info(NDI_UNIQUE, 0,op,"i = inventory , = get : = look");	130	new_draw_info (NDI_UNIQUE, 0, op, "i = inventory , = get : = look");
126	new_draw_info(NDI_UNIQUE, 0,op,"<> = rotate d = drop ? = help");	131	new_draw_info (NDI_UNIQUE, 0, op, "<> = rotate d = drop ? = help");
127	new_draw_info(NDI_UNIQUE, 0,op,"a = apply A = apply below t = throw");	132	new_draw_info (NDI_UNIQUE, 0, op, "a = apply A = apply below t = throw");
128	new_draw_info(NDI_UNIQUE, 0,op,"e = examine E = exa below @ = autopick");	133	new_draw_info (NDI_UNIQUE, 0, op, "e = examine E = exa below @ = autopick");
129	new_draw_info(NDI_UNIQUE, 0,op,"C = configure s = brace v = version");	134	new_draw_info (NDI_UNIQUE, 0, op, "C = configure s = brace v = version");
130	new_draw_info(NDI_UNIQUE, 0,op,"+- = change range <tab> = browse spells");	135	new_draw_info (NDI_UNIQUE, 0, op, "+- = change range <tab> = browse spells");
131	new_draw_info(NDI_UNIQUE, 0,op,"x = change inventory type");	136	new_draw_info (NDI_UNIQUE, 0, op, "x = change inventory type");
132	new_draw_info(NDI_UNIQUE, 0,op,"Mouse: L = examine, M = apply, R = drop/get");	137	new_draw_info (NDI_UNIQUE, 0, op, "Mouse: L = examine, M = apply, R = drop/get");
133	new_draw_info(NDI_UNIQUE, 0,op,"'help = info about extended commands.");	138	new_draw_info (NDI_UNIQUE, 0, op, "'help = info about extended commands.");
134	new_draw_info(NDI_UNIQUE, 0,op,"Ctrl-R = refresh Ctrl-C = clear");	139	new_draw_info (NDI_UNIQUE, 0, op, "Ctrl-R = refresh Ctrl-C = clear");
135	new_draw_info(NDI_UNIQUE, 0,op,"You can type a number before most commands.");	140	new_draw_info (NDI_UNIQUE, 0, op, "You can type a number before most commands.");
136	new_draw_info(NDI_UNIQUE, 0,op,"(For instance 3d drops 3 items.)");	141	new_draw_info (NDI_UNIQUE, 0, op, "(For instance 3d drops 3 items.)");
137	}	142	}
138		143
		144	void
139	void start_info(object *op) {	145	start_info (object *op)
		146	{
140	char buf[MAX_BUF];	147	char buf[MAX_BUF];
141		148
142	sprintf(buf,"Welcome to Crossfire, v%s!",VERSION);	149	sprintf (buf, "Welcome to Crossfire, v%s!", VERSION);
143	new_draw_info(NDI_UNIQUE, 0,op,buf);	150	new_draw_info (NDI_UNIQUE, 0, op, buf);
144	new_draw_info(NDI_UNIQUE, 0,op,"Press `?' for help");	151	new_draw_info (NDI_UNIQUE, 0, op, "Press `?' for help");
145	new_draw_info(NDI_UNIQUE, 0,op," ");	152	new_draw_info (NDI_UNIQUE, 0, op, " ");
146	new_draw_info_format(NDI_UNIQUE | NDI_ALL | NDI_DK_ORANGE, 5, op,	153	new_draw_info_format (NDI_UNIQUE | NDI_ALL | NDI_DK_ORANGE, 5, op, "%s entered the game.", &op->name);
147	"%s entered the game.",&op->name);
148	if(!op->contr->name_changed) {	154	if (!op->contr->name_changed)
		155	{
149	new_draw_info(NDI_UNIQUE, 0,op,"Note that you must set your name with the name");	156	new_draw_info (NDI_UNIQUE, 0, op, "Note that you must set your name with the name");
150	new_draw_info(NDI_UNIQUE, 0,op,"command to enter the highscore list.");	157	new_draw_info (NDI_UNIQUE, 0, op, "command to enter the highscore list.");
151	new_draw_info(NDI_UNIQUE, 0,op,"(You can also use the crossfire.name X-resource.)");	158	new_draw_info (NDI_UNIQUE, 0, op, "(You can also use the crossfire.name X-resource.)");
152	}	159	}
153	}	160	}
154		161
155	/* Really, there is no reason to crypt the passwords any system. But easier	162	/* Really, there is no reason to crypt the passwords any system. But easier
156	* to just leave this enabled for backward compatibility. Put the	163	* to just leave this enabled for backward compatibility. Put the
157	* simple case at top - no encryption - makes it easier to read.	164	* simple case at top - no encryption - makes it easier to read.
158	*/	165	*/
		166	char *
159	char *crypt_string(char *str, char *salt) {	167	crypt_string (char *str, char *salt)
		168	{
160	#if defined(WIN32) || (defined(__FreeBSD__) && !defined(HAVE_LIBDES))	169	#if defined(WIN32) || (defined(__FreeBSD__) && !defined(HAVE_LIBDES))
161	return(str);	170	return (str);
162	#else	171	#else
163	static char *c=
164	"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789./";	172	static char *c = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789./";
165	char s[2];	173	char s[2];
166		174
167	if(salt==NULL)	175	if (salt == NULL)
168	s[0]= c[RANDOM() % (int)strlen(c)],	176	s[0] = c[RANDOM () % (int) strlen (c)], s[1] = c[RANDOM () % (int) strlen (c)];
169	s[1]= c[RANDOM() % (int)strlen(c)];
170	else	177	else
171	s[0]= salt[0],	178	s[0] = salt[0], s[1] = salt[1];
172	s[1]= salt[1];
173		179
174	# ifdef HAVE_LIBDES	180	# ifdef HAVE_LIBDES
175	return (char*)des_crypt(str,s);	181	return (char *) des_crypt (str, s);
176	# endif	182	# endif
177	/* Default case - just use crypt */	183	/* Default case - just use crypt */
178	return (char*)crypt(str,s);	184	return (char *) crypt (str, s);
179	#endif	185	#endif
180	}	186	}
181		187
		188	int
182	int check_password(char *typed,char *crypted) {	189	check_password (char *typed, char *crypted)
		190	{
183	return !strcmp(crypt_string(typed,crypted),crypted);	191	return !strcmp (crypt_string (typed, crypted), crypted);
184	}	192	}
185		193
186	/* This is a basic little function to put the player back to his	194	/* This is a basic little function to put the player back to his
187	* savebed. We do some error checking - its possible that the	195	* savebed. We do some error checking - its possible that the
188	* savebed map may no longer exist, so we make sure the player	196	* savebed map may no longer exist, so we make sure the player
189	* goes someplace.	197	* goes someplace.
190	*/	198	*/
		199	void
191	void enter_player_savebed(object *op)	200	enter_player_savebed (object *op)
192	{	201	{
193	mapstruct *oldmap = op->map;	202	mapstruct *oldmap = op->map;
194	object *tmp;	203	object *tmp;
195		204
196	tmp=get_object();	205	tmp = get_object ();
197		206
198	EXIT_PATH(tmp) = op->contr->savebed_map;	207	EXIT_PATH (tmp) = op->contr->savebed_map;
199	EXIT_X(tmp) = op->contr->bed_x;	208	EXIT_X (tmp) = op->contr->bed_x;
200	EXIT_Y(tmp) = op->contr->bed_y;	209	EXIT_Y (tmp) = op->contr->bed_y;
201	enter_exit(op,tmp);	210	enter_exit (op, tmp);
202	/* If the player has not changed maps and the name does not match	211	/* If the player has not changed maps and the name does not match
203	* that of the savebed, his savebed map is gone. Lets go back	212	* that of the savebed, his savebed map is gone. Lets go back
204	* to the emergency path. Update what the players savebed is	213	* to the emergency path. Update what the players savebed is
205	* while we're at it.	214	* while we're at it.
206	*/	215	*/
207	if (oldmap == op->map && strcmp(op->contr->savebed_map, oldmap->path)) {	216	if (oldmap == op->map && strcmp (op->contr->savebed_map, oldmap->path))
		217	{
208	LOG(llevDebug,"Player %s savebed location %s is invalid - going to emergency location (%s)\n",	218	LOG (llevDebug, "Player %s savebed location %s is invalid - going to emergency location (%s)\n",
209	settings.emergency_mapname, &op->name, op->contr->savebed_map);	219	settings.emergency_mapname, &op->name, op->contr->savebed_map);
210	strcpy(op->contr->savebed_map, settings.emergency_mapname);	220	strcpy (op->contr->savebed_map, settings.emergency_mapname);
211	op->contr->bed_x = settings.emergency_x;	221	op->contr->bed_x = settings.emergency_x;
212	op->contr->bed_y = settings.emergency_y;	222	op->contr->bed_y = settings.emergency_y;
213	EXIT_PATH(tmp) = op->contr->savebed_map;	223	EXIT_PATH (tmp) = op->contr->savebed_map;
214	EXIT_X(tmp) = op->contr->bed_x;	224	EXIT_X (tmp) = op->contr->bed_x;
215	EXIT_Y(tmp) = op->contr->bed_y;	225	EXIT_Y (tmp) = op->contr->bed_y;
216	enter_exit(op,tmp);	226	enter_exit (op, tmp);
217	}	227	}
218	free_object(tmp);	228	free_object (tmp);
219	}	229	}
220		230
221	/* All this really is is a glorified remove_object that also updates	231	/* All this really is is a glorified remove_object that also updates
222	* the counts on the map if needed.	232	* the counts on the map if needed.
223	*/	233	*/
		234	void
224	void leave_map(object *op)	235	leave_map (object *op)
225	{	236	{
226	mapstruct *oldmap = op->map;	237	mapstruct *oldmap = op->map;
227		238
228	remove_ob(op);	239	remove_ob (op);
229		240
230	if (oldmap) {	241	if (oldmap)
		242	{
231	if (!op->contr->hidden)	243	if (!op->contr->hidden)
232	oldmap->players--;	244	oldmap->players--;
233	if (oldmap->players <= 0) { /* can be less than zero due to errors in tracking this */	245	if (oldmap->players <= 0)
		246	{ /* can be less than zero due to errors in tracking this */
234	set_map_timeout(oldmap);	247	set_map_timeout (oldmap);
235	}	248	}
236	}	249	}
237	}	250	}
238		251
239	/*	252	/*
…		…
241	* new map. map, x, y must be set. map is the map we are moving the	254	* new map. map, x, y must be set. map is the map we are moving the
242	* player to - it could be the map he just came from if the load failed for	255	* player to - it could be the map he just came from if the load failed for
243	* whatever reason. If default map coordinates are to be used, then	256	* whatever reason. If default map coordinates are to be used, then
244	* the function that calls this should figure them out.	257	* the function that calls this should figure them out.
245	*/	258	*/
		259	static void
246	static void enter_map(object *op, mapstruct *newmap, int x, int y) {	260	enter_map (object *op, mapstruct *newmap, int x, int y)
		261	{
247	mapstruct *oldmap = op->map;	262	mapstruct *oldmap = op->map;
248		263
249	if (out_of_map(newmap, x, y)) {	264	if (out_of_map (newmap, x, y))
		265	{
250	LOG(llevError,"enter_map: supplied coordinates are not within the map! (%s: %d, %d)\n",	266	LOG (llevError, "enter_map: supplied coordinates are not within the map! (%s: %d, %d)\n", newmap->path, x, y);
251	newmap->path, x, y);
252	x=MAP_ENTER_X(newmap);	267	x = MAP_ENTER_X (newmap);
253	y=MAP_ENTER_Y(newmap);	268	y = MAP_ENTER_Y (newmap);
254	if (out_of_map(newmap, x, y)) {	269	if (out_of_map (newmap, x, y))
		270	{
255	LOG(llevError,"enter_map: map %s provides invalid default enter location (%d, %d) > (%d, %d)\n",	271	LOG (llevError, "enter_map: map %s provides invalid default enter location (%d, %d) > (%d, %d)\n",
256	newmap->path, x, y, MAP_WIDTH(newmap), MAP_HEIGHT(newmap));	272	newmap->path, x, y, MAP_WIDTH (newmap), MAP_HEIGHT (newmap));
257	new_draw_info(NDI_UNIQUE, 0, op, "The exit is closed");	273	new_draw_info (NDI_UNIQUE, 0, op, "The exit is closed");
258	return;	274	return;
259	}	275	}
260	}	276	}
261	/* try to find a spot for the player */	277	/* try to find a spot for the player */
262	if (ob_blocked(op, newmap, x, y)) { /* First choice blocked */	278	if (ob_blocked (op, newmap, x, y))
		279	{ /* First choice blocked */
263	/* We try to find a spot for the player, starting closest in.	280	/* We try to find a spot for the player, starting closest in.
264	* We could use find_first_free_spot, but that doesn't randomize it at all,	281	* We could use find_first_free_spot, but that doesn't randomize it at all,
265	* So for example, if the north space is free, you would always end up there even	282	* So for example, if the north space is free, you would always end up there even
266	* if other spaces around are available.	283	* if other spaces around are available.
267	* Note that for the second and third calls, we could start at a position other	284	* Note that for the second and third calls, we could start at a position other
268	* than one, but then we could end up on the other side of walls and so forth.	285	* than one, but then we could end up on the other side of walls and so forth.
269	*/	286	*/
270	int i = find_free_spot(op,newmap, x, y, 1, SIZEOFFREE1+1);	287	int i = find_free_spot (op, newmap, x, y, 1, SIZEOFFREE1 + 1);
		288
		289	if (i == -1)
		290	{
		291	i = find_free_spot (op, newmap, x, y, 1, SIZEOFFREE2 + 1);
271	if (i==-1) {	292	if (i == -1)
272	i = find_free_spot(op,newmap, x, y, 1, SIZEOFFREE2+1);	293	i = find_free_spot (op, newmap, x, y, 1, SIZEOFFREE);
		294	}
273	if (i==-1)	295	if (i != -1)
274	i = find_free_spot(op,newmap, x, y, 1, SIZEOFFREE);
275	}	296	{
276	if (i != -1 ) {
277	x += freearr_x[i];	297	x += freearr_x[i];
278	y += freearr_y[i];	298	y += freearr_y[i];
		299	}
279	} else {	300	else
		301	{
280	/* not much we can do in this case. */	302	/* not much we can do in this case. */
281	LOG(llevInfo,"enter_map: Could not find free spot for player - will dump on top of object (%s: %d, %d)\n",	303	LOG (llevInfo, "enter_map: Could not find free spot for player - will dump on top of object (%s: %d, %d)\n", newmap->path, x, y);
282	newmap->path, x , y);
283	}
284	} /* end if looking for free spot */
285		304	}
		305	} /* end if looking for free spot */
		306
286	if (op->map!=NULL)	307	if (op->map != NULL)
287	{	308	{
288	INVOKE_PLAYER (MAP_CHANGE, op->contr, ARG_MAP (op->map), ARG_MAP (newmap));	309	INVOKE_PLAYER (MAP_CHANGE, op->contr, ARG_MAP (op->map), ARG_MAP (newmap));
289	INVOKE_MAP (LEAVE, op->map, ARG_PLAYER (op->contr));	310	INVOKE_MAP (LEAVE, op->map, ARG_PLAYER (op->contr));
290	}	311	}
291		312
292	/* If it is a player login, he has yet to be inserted anyplace.	313	/* If it is a player login, he has yet to be inserted anyplace.
293	* otherwise, we need to deal with removing the player here.	314	* otherwise, we need to deal with removing the player here.
294	*/	315	*/
295	if(!QUERY_FLAG(op, FLAG_REMOVED))	316	if (!QUERY_FLAG (op, FLAG_REMOVED))
296	remove_ob(op);	317	remove_ob (op);
297		318
298	/* remove_ob clears these so they must be reset after the remove_ob call */	319	/* remove_ob clears these so they must be reset after the remove_ob call */
299	op->x = x;	320	op->x = x;
300	op->y = y;	321	op->y = y;
301	op->map = newmap;	322	op->map = newmap;
302	insert_ob_in_map(op,op->map,NULL,INS_NO_WALK_ON);	323	insert_ob_in_map (op, op->map, NULL, INS_NO_WALK_ON);
303		324
304	INVOKE_MAP (ENTER, op->map, ARG_PLAYER (op->contr));	325	INVOKE_MAP (ENTER, op->map, ARG_PLAYER (op->contr));
305		326
306	if (!op->contr->hidden)	327	if (!op->contr->hidden)
307	newmap->players++;	328	newmap->players++;
308		329
309	newmap->timeout=0;	330	newmap->timeout = 0;
310	op->enemy = NULL;	331	op->enemy = NULL;
311		332
312	if (op->contr) {	333	if (op->contr)
		334	{
313	strcpy(op->contr->maplevel, newmap->path);	335	strcpy (op->contr->maplevel, newmap->path);
314	op->contr->count=0;	336	op->contr->count = 0;
315	}	337	}
316		338
317	/* Update any golems */	339	/* Update any golems */
318	if(op->type == PLAYER && op->contr->ranges[range_golem] != NULL) {	340	if (op->type == PLAYER && op->contr->ranges[range_golem] != NULL)
		341	{
319	int i = find_free_spot(op->contr->ranges[range_golem],newmap,	342	int i = find_free_spot (op->contr->ranges[range_golem], newmap,
320	x, y, 1, SIZEOFFREE);	343	x, y, 1, SIZEOFFREE);
		344
321	remove_ob(op->contr->ranges[range_golem]);	345	remove_ob (op->contr->ranges[range_golem]);
322	if (i==-1) {	346	if (i == -1)
		347	{
323	remove_friendly_object(op->contr->ranges[range_golem]);	348	remove_friendly_object (op->contr->ranges[range_golem]);
324	free_object(op->contr->ranges[range_golem]);	349	free_object (op->contr->ranges[range_golem]);
325	op->contr->ranges[range_golem]=NULL;	350	op->contr->ranges[range_golem] = NULL;
326	op->contr->golem_count=0;	351	op->contr->golem_count = 0;
		352	}
		353	else
327	}	354	{
328	else {
329	object *tmp;	355	object *tmp;
		356
330	for (tmp=op->contr->ranges[range_golem]; tmp!=NULL; tmp=tmp->more) {	357	for (tmp = op->contr->ranges[range_golem]; tmp != NULL; tmp = tmp->more)
		358	{
331	tmp->x = x + freearr_x[i]+ (tmp->arch==NULL?0:tmp->arch->clone.x);	359	tmp->x = x + freearr_x[i] + (tmp->arch == NULL ? 0 : tmp->arch->clone.x);
332	tmp->y = y + freearr_y[i]+ (tmp->arch==NULL?0:tmp->arch->clone.y);	360	tmp->y = y + freearr_y[i] + (tmp->arch == NULL ? 0 : tmp->arch->clone.y);
333	tmp->map = newmap;	361	tmp->map = newmap;
334	}	362	}
335	insert_ob_in_map(op->contr->ranges[range_golem], newmap, NULL,0);	363	insert_ob_in_map (op->contr->ranges[range_golem], newmap, NULL, 0);
336	op->contr->ranges[range_golem]->direction =	364	op->contr->ranges[range_golem]->direction =
337	find_dir_2(op->x - op->contr->ranges[range_golem]->x,	365	find_dir_2 (op->x - op->contr->ranges[range_golem]->x, op->y - op->contr->ranges[range_golem]->y);
338	op->y - op->contr->ranges[range_golem]->y);
339	}	366	}
340	}	367	}
341	op->direction=0;	368	op->direction = 0;
342		369
343	/* since the players map is already loaded, we don't need to worry	370	/* since the players map is already loaded, we don't need to worry
344	* about pending objects.	371	* about pending objects.
345	*/	372	*/
346	remove_all_pets(newmap);	373	remove_all_pets (newmap);
347		374
348	/* If the player is changing maps, we need to do some special things	375	/* If the player is changing maps, we need to do some special things
349	* Do this after the player is on the new map - otherwise the force swap of the	376	* Do this after the player is on the new map - otherwise the force swap of the
350	* old map does not work.	377	* old map does not work.
351	*/	378	*/
352	if (oldmap != newmap) {	379	if (oldmap != newmap)
		380	{
353	if (oldmap) /* adjust old map */	381	if (oldmap) /* adjust old map */
354	{	382	{
355	oldmap->players--;	383	oldmap->players--;
356		384
357	if (oldmap->players <= 0) /* can be less than zero due to errors in tracking this */	385	if (oldmap->players <= 0) /* can be less than zero due to errors in tracking this */
358	set_map_timeout(oldmap);	386	set_map_timeout (oldmap);
359	}	387	}
360	}	388	}
361	swap_below_max (newmap->path);
362	}	389	}
363		390
		391	void
364	void set_map_timeout(mapstruct *oldmap)	392	set_map_timeout (mapstruct *oldmap)
365	{	393	{
366	#if MAP_MAXTIMEOUT	394	#if MAP_MAXTIMEOUT
367	oldmap->timeout = MAP_TIMEOUT(oldmap);	395	oldmap->timeout = MAP_TIMEOUT (oldmap);
368	/* Do MINTIMEOUT first, so that MAXTIMEOUT is used if that is	396	/* Do MINTIMEOUT first, so that MAXTIMEOUT is used if that is
369	* lower than the min value.	397	* lower than the min value.
370	*/	398	*/
371	#if MAP_MINTIMEOUT	399	# if MAP_MINTIMEOUT
372	if (oldmap->timeout < MAP_MINTIMEOUT) {	400	if (oldmap->timeout < MAP_MINTIMEOUT)
		401	{
373	oldmap->timeout = MAP_MINTIMEOUT;	402	oldmap->timeout = MAP_MINTIMEOUT;
374	}	403	}
375	#endif	404	# endif
376	if (oldmap->timeout > MAP_MAXTIMEOUT) {	405	if (oldmap->timeout > MAP_MAXTIMEOUT)
		406	{
377	oldmap->timeout = MAP_MAXTIMEOUT;	407	oldmap->timeout = MAP_MAXTIMEOUT;
378	}	408	}
379	#else	409	#else
380	/* save out the map */	410	/* save out the map */
381	swap_map(oldmap);	411	swap_map (oldmap);
382	#endif /* MAP_MAXTIMEOUT */	412	#endif /* MAP_MAXTIMEOUT */
383	}	413	}
384		414
385		415
386	/* clean_path takes a path and replaces all / with _	416	/* clean_path takes a path and replaces all / with _
387	* We do a strcpy so that we do not change the original string.	417	* We do a strcpy so that we do not change the original string.
388	*/	418	*/
		419	char *
389	char *clean_path(const char *file)	420	clean_path (const char *file)
390	{	421	{
391	static char newpath[MAX_BUF],*cp;	422	static char newpath[MAX_BUF], *cp;
392		423
393	strncpy(newpath, file, MAX_BUF-1);	424	strncpy (newpath, file, MAX_BUF - 1);
394	newpath[MAX_BUF-1]='\0';	425	newpath[MAX_BUF - 1] = '\0';
395	for (cp=newpath; *cp!='\0'; cp++) {	426	for (cp = newpath; *cp != '\0'; cp++)
396	if (*cp=='/') *cp='_';
397	}	427	{
		428	if (*cp == '/')
		429	*cp = '_';
		430	}
398	return newpath;	431	return newpath;
399	}	432	}
400		433
401		434
402	/* unclean_path takes a path and replaces all _ with /	435	/* unclean_path takes a path and replaces all _ with /
403	* This basically undoes clean path.	436	* This basically undoes clean path.
404	* We do a strcpy so that we do not change the original string.	437	* We do a strcpy so that we do not change the original string.
405	* We are smart enough to start after the last / in case we	438	* We are smart enough to start after the last / in case we
406	* are getting passed a string that points to a unique map	439	* are getting passed a string that points to a unique map
407	* path.	440	* path.
408	*/	441	*/
		442	char *
409	char *unclean_path(const char *src)	443	unclean_path (const char *src)
410	{	444	{
411	static char newpath[MAX_BUF],*cp;	445	static char newpath[MAX_BUF], *cp;
412		446
413	cp=strrchr(src, '/');	447	cp = strrchr (src, '/');
414	if (cp)	448	if (cp)
415	strncpy(newpath, cp+1, MAX_BUF-1);	449	strncpy (newpath, cp + 1, MAX_BUF - 1);
416	else	450	else
417	strncpy(newpath, src, MAX_BUF-1);	451	strncpy (newpath, src, MAX_BUF - 1);
418	newpath[MAX_BUF-1]='\0';	452	newpath[MAX_BUF - 1] = '\0';
419		453
420	for (cp=newpath; *cp!='\0'; cp++) {	454	for (cp = newpath; *cp != '\0'; cp++)
421	if (*cp=='_') *cp='/';
422	}	455	{
		456	if (*cp == '_')
		457	*cp = '/';
		458	}
423	return newpath;	459	return newpath;
424	}	460	}
425		461
426		462
427	/* The player is trying to enter a randomly generated map. In this case, generate the	463	/* The player is trying to enter a randomly generated map. In this case, generate the
428	* random map as needed.	464	* random map as needed.
429	*/	465	*/
430		466
		467	static void
431	static void enter_random_map(object *pl, object *exit_ob)	468	enter_random_map (object *pl, object *exit_ob)
432	{	469	{
433	mapstruct *new_map;	470	mapstruct *new_map;
434	char newmap_name[HUGE_BUF], *cp;	471	char newmap_name[HUGE_BUF], *cp;
435	static int reference_number = 0;	472	static int reference_number = 0;
436	RMParms rp;	473	RMParms rp;
437		474
438	memset(&rp, 0, sizeof(RMParms));	475	memset (&rp, 0, sizeof (RMParms));
439	rp.Xsize=-1;	476	rp.Xsize = -1;
440	rp.Ysize=-1;	477	rp.Ysize = -1;
441	rp.region=get_region_by_map(exit_ob->map);	478	rp.region = get_region_by_map (exit_ob->map);
		479	if (exit_ob->msg)
442	if (exit_ob->msg) set_random_map_variable(&rp,exit_ob->msg);	480	set_random_map_variable (&rp, exit_ob->msg);
443	rp.origin_x = exit_ob->x;	481	rp.origin_x = exit_ob->x;
444	rp.origin_y = exit_ob->y;	482	rp.origin_y = exit_ob->y;
445	strcpy(rp.origin_map, pl->map->path);	483	strcpy (rp.origin_map, pl->map->path);
446		484
447	/* If we have a final_map, use it as a base name to give some clue	485	/* If we have a final_map, use it as a base name to give some clue
448	* as where the player is. Otherwise, use the origin map.	486	* as where the player is. Otherwise, use the origin map.
449	* Take the last component (after the last slash) to give	487	* Take the last component (after the last slash) to give
450	* shorter names without bogus slashes.	488	* shorter names without bogus slashes.
451	*/	489	*/
452	if (rp.final_map[0]) {	490	if (rp.final_map[0])
		491	{
453	cp = strrchr(rp.final_map, '/');	492	cp = strrchr (rp.final_map, '/');
		493	if (!cp)
454	if (!cp) cp = rp.final_map;	494	cp = rp.final_map;
455	} else {	495	}
		496	else
		497	{
456	char buf[HUGE_BUF];	498	char buf[HUGE_BUF];
457		499
458	cp = strrchr(rp.origin_map, '/');	500	cp = strrchr (rp.origin_map, '/');
		501	if (!cp)
459	if (!cp) cp = rp.origin_map;	502	cp = rp.origin_map;
460	/* Need to strip of any trailing digits, if it has them */	503	/* Need to strip of any trailing digits, if it has them */
461	strcpy(buf, cp);	504	strcpy (buf, cp);
462	while (isdigit(buf[strlen(buf) - 1]))	505	while (isdigit (buf[strlen (buf) - 1]))
463	buf[strlen(buf) - 1] = 0;	506	buf[strlen (buf) - 1] = 0;
464	cp = buf;	507	cp = buf;
465	}	508	}
466		509
467	sprintf(newmap_name,"/random/%s%04d",cp+1, reference_number++);	510	sprintf (newmap_name, "/random/%s%04d", cp + 1, reference_number++);
468		511
469	/* now to generate the actual map. */	512	/* now to generate the actual map. */
470	new_map=generate_random_map(newmap_name,&rp);	513	new_map = generate_random_map (newmap_name, &rp);
471		514
472	/* Update the exit_ob so it now points directly at the newly created	515	/* Update the exit_ob so it now points directly at the newly created
473	* random maps. Not that it is likely to happen, but it does mean that a	516	* random maps. Not that it is likely to happen, but it does mean that a
474	* exit in a unique map leading to a random map will not work properly.	517	* exit in a unique map leading to a random map will not work properly.
475	* It also means that if the created random map gets reset before	518	* It also means that if the created random map gets reset before
476	* the exit leading to it, that the exit will no longer work.	519	* the exit leading to it, that the exit will no longer work.
477	*/	520	*/
478	if(new_map) {	521	if (new_map)
		522	{
479	int x, y;	523	int x, y;
		524
480	x=EXIT_X(exit_ob) = MAP_ENTER_X(new_map);	525	x = EXIT_X (exit_ob) = MAP_ENTER_X (new_map);
481	y=EXIT_Y(exit_ob) = MAP_ENTER_Y(new_map);	526	y = EXIT_Y (exit_ob) = MAP_ENTER_Y (new_map);
482	EXIT_PATH(exit_ob) = newmap_name;	527	EXIT_PATH (exit_ob) = newmap_name;
483	strcpy(new_map->path, newmap_name);	528	strcpy (new_map->path, newmap_name);
484	enter_map(pl, new_map, x, y);	529	enter_map (pl, new_map, x, y);
485	}	530	}
486	}	531	}
487		532
488	/* The player is trying to enter a non-randomly generated template map. In this	533	/* The player is trying to enter a non-randomly generated template map. In this
489	* case, use a map file for a template	534	* case, use a map file for a template
490	*/	535	*/
491		536
		537	static void
492	static void enter_fixed_template_map(object *pl, object *exit_ob)	538	enter_fixed_template_map (object *pl, object *exit_ob)
493	{	539	{
494	mapstruct *new_map;	540	mapstruct *new_map;
495	char tmpnum[32], exitpath[HUGE_BUF], resultname[HUGE_BUF], tmpstring[HUGE_BUF], *sourcemap;	541	char tmpnum[32], exitpath[HUGE_BUF], resultname[HUGE_BUF], tmpstring[HUGE_BUF], *sourcemap;
496	const char *new_map_name;	542	const char *new_map_name;
497		543
498	/* Split the exit path string into two parts, one	544	/* Split the exit path string into two parts, one
499	* for where to store the map, and one for were	545	* for where to store the map, and one for were
500	* to generate the map from.	546	* to generate the map from.
501	*/	547	*/
502	snprintf(exitpath, sizeof(exitpath), "%s", EXIT_PATH(exit_ob)+2);	548	snprintf (exitpath, sizeof (exitpath), "%s", EXIT_PATH (exit_ob) + 2);
503	sourcemap = strchr(exitpath, '!');	549	sourcemap = strchr (exitpath, '!');
504	if (!sourcemap) {	550	if (!sourcemap)
		551	{
505	new_draw_info_format(NDI_UNIQUE, 0, pl, "The %s is closed.", &exit_ob->name);	552	new_draw_info_format (NDI_UNIQUE, 0, pl, "The %s is closed.", &exit_ob->name);
506	/* Should only occur when no source map is set.	553	/* Should only occur when no source map is set.
507	*/	554	*/
508	LOG(llevError,"enter_fixed_template_map: Exit %s (%d,%d) on map %s has no source template.\n",	555	LOG (llevError, "enter_fixed_template_map: Exit %s (%d,%d) on map %s has no source template.\n",
509	&exit_ob->name, exit_ob->x, exit_ob->y, exit_ob->map->path);	556	&exit_ob->name, exit_ob->x, exit_ob->y, exit_ob->map->path);
510	return;	557	return;
511	}	558	}
512	*sourcemap++ = '\0';	559	*sourcemap++ = '\0';
513		560
514	/* If we are not coming from a template map, we can use relative directories	561	/* If we are not coming from a template map, we can use relative directories
515	* for the map to generate from.	562	* for the map to generate from.
516	*/	563	*/
517	if (!exit_ob->map->templatemap) {	564	if (!exit_ob->map->templatemap)
		565	{
518	sourcemap = path_combine_and_normalize(exit_ob->map->path, sourcemap);	566	sourcemap = path_combine_and_normalize (exit_ob->map->path, sourcemap);
519	}
520		567	}
		568
521	/* Do replacement of %x, %y, and %n to the x coord of the exit, the y coord	569	/* Do replacement of %x, %y, and %n to the x coord of the exit, the y coord
522	* of the exit, and the name of the map the exit is on, respectively.	570	* of the exit, and the name of the map the exit is on, respectively.
523	*/	571	*/
524	sprintf(tmpnum ,"%d", exit_ob->x);	572	sprintf (tmpnum, "%d", exit_ob->x);
525	replace(exitpath, "%x", tmpnum, resultname, sizeof(resultname));	573	replace (exitpath, "%x", tmpnum, resultname, sizeof (resultname));
526		574
527	sprintf(tmpnum ,"%d", exit_ob->y);	575	sprintf (tmpnum, "%d", exit_ob->y);
528	sprintf(tmpstring, "%s", resultname);	576	sprintf (tmpstring, "%s", resultname);
529	replace(tmpstring, "%y", tmpnum, resultname, sizeof(resultname));	577	replace (tmpstring, "%y", tmpnum, resultname, sizeof (resultname));
530		578
531	sprintf(tmpstring, "%s", resultname);	579	sprintf (tmpstring, "%s", resultname);
532	replace(tmpstring, "%n", exit_ob->map->name, resultname, sizeof(resultname));	580	replace (tmpstring, "%n", exit_ob->map->name, resultname, sizeof (resultname));
533		581
534	/* If we are coming from another template map, use reletive paths unless	582	/* If we are coming from another template map, use reletive paths unless
535	* indicated otherwise.	583	* indicated otherwise.
536	*/	584	*/
537	if (exit_ob->map->templatemap && (resultname[0] != '/')) {	585	if (exit_ob->map->templatemap && (resultname[0] != '/'))
		586	{
538	new_map_name = path_combine_and_normalize(exit_ob->map->path, resultname);	587	new_map_name = path_combine_and_normalize (exit_ob->map->path, resultname);
539	} else {	588	}
		589	else
		590	{
540	new_map_name = create_template_pathname(resultname);	591	new_map_name = create_template_pathname (resultname);
541	}
542		592	}
		593
543	/* Attempt to load the map, if unable to, then	594	/* Attempt to load the map, if unable to, then
544	* create the map from the template.	595	* create the map from the template.
545	*/	596	*/
546	new_map = ready_map_name(new_map_name, MAP_PLAYER_UNIQUE);	597	new_map = ready_map_name (new_map_name, MAP_PLAYER_UNIQUE);
547	if (!new_map) {	598	if (!new_map)
		599	{
548	new_map = load_original_map(create_pathname(sourcemap), MAP_PLAYER_UNIQUE);	600	new_map = load_original_map (create_pathname (sourcemap), MAP_PLAYER_UNIQUE);
549	if (new_map) fix_auto_apply(new_map);
550	}
551
552	if (new_map) {	601	if (new_map)
		602	fix_auto_apply (new_map);
		603	}
		604
		605	if (new_map)
		606	{
553	/* set the path of the map to where it should be	607	/* set the path of the map to where it should be
554	* so we don't just save over the source map.	608	* so we don't just save over the source map.
555	*/	609	*/
556	strcpy(new_map->path, new_map_name);	610	strcpy (new_map->path, new_map_name);
557	new_map->templatemap = 1;	611	new_map->templatemap = 1;
558	enter_map(pl, new_map, EXIT_X(exit_ob), EXIT_Y(exit_ob));	612	enter_map (pl, new_map, EXIT_X (exit_ob), EXIT_Y (exit_ob));
559	} else {	613	}
		614	else
		615	{
560	new_draw_info_format(NDI_UNIQUE, 0, pl, "The %s is closed.", &exit_ob->name);	616	new_draw_info_format (NDI_UNIQUE, 0, pl, "The %s is closed.", &exit_ob->name);
561	/* Should only occur when an invalid source map is set.	617	/* Should only occur when an invalid source map is set.
562	*/	618	*/
563	LOG(llevDebug,"enter_fixed_template_map: Exit %s (%d,%d) on map %s leads no where.\n",	619	LOG (llevDebug, "enter_fixed_template_map: Exit %s (%d,%d) on map %s leads no where.\n",
564	&exit_ob->name, exit_ob->x, exit_ob->y, exit_ob->map->path);	620	&exit_ob->name, exit_ob->x, exit_ob->y, exit_ob->map->path);
565	}	621	}
566	}	622	}
567		623
568		624
569	/* The player is trying to enter a randomly generated template map. In this	625	/* The player is trying to enter a randomly generated template map. In this
570	* case, generate the map as needed.	626	* case, generate the map as needed.
571	*/	627	*/
572		628
		629	static void
573	static void enter_random_template_map(object *pl, object *exit_ob)	630	enter_random_template_map (object *pl, object *exit_ob)
574	{	631	{
575	mapstruct *new_map;	632	mapstruct *new_map;
576	char tmpnum[32], resultname[HUGE_BUF], tmpstring[HUGE_BUF];	633	char tmpnum[32], resultname[HUGE_BUF], tmpstring[HUGE_BUF];
577	const char *new_map_name;	634	const char *new_map_name;
578	RMParms rp;	635	RMParms rp;
579		636
580	/* Do replacement of %x, %y, and %n to the x coord of the exit, the y coord	637	/* Do replacement of %x, %y, and %n to the x coord of the exit, the y coord
581	* of the exit, and the name of the map the exit is on, respectively.	638	* of the exit, and the name of the map the exit is on, respectively.
582	*/	639	*/
583	sprintf(tmpnum ,"%d", exit_ob->x);	640	sprintf (tmpnum, "%d", exit_ob->x);
584	replace(EXIT_PATH(exit_ob)+3, "%x", tmpnum, resultname, sizeof(resultname));	641	replace (EXIT_PATH (exit_ob) + 3, "%x", tmpnum, resultname, sizeof (resultname));
585		642
586	sprintf(tmpnum ,"%d", exit_ob->y);	643	sprintf (tmpnum, "%d", exit_ob->y);
587	sprintf(tmpstring, "%s", resultname);	644	sprintf (tmpstring, "%s", resultname);
588	replace(tmpstring, "%y", tmpnum, resultname, sizeof(resultname));	645	replace (tmpstring, "%y", tmpnum, resultname, sizeof (resultname));
589		646
590	sprintf(tmpstring, "%s", resultname);	647	sprintf (tmpstring, "%s", resultname);
591	replace(tmpstring, "%n", exit_ob->map->name, resultname, sizeof(resultname));	648	replace (tmpstring, "%n", exit_ob->map->name, resultname, sizeof (resultname));
592		649
593	/* If we are coming from another template map, use reletive paths unless	650	/* If we are coming from another template map, use reletive paths unless
594	* indicated otherwise.	651	* indicated otherwise.
595	*/	652	*/
596	if (exit_ob->map->templatemap && (resultname[0] != '/')) {	653	if (exit_ob->map->templatemap && (resultname[0] != '/'))
		654	{
597	new_map_name = path_combine_and_normalize(exit_ob->map->path, resultname);	655	new_map_name = path_combine_and_normalize (exit_ob->map->path, resultname);
598	} else {	656	}
		657	else
		658	{
599	new_map_name = create_template_pathname(resultname);	659	new_map_name = create_template_pathname (resultname);
600	}	660	}
601		661
602	new_map = ready_map_name(new_map_name, MAP_PLAYER_UNIQUE);	662	new_map = ready_map_name (new_map_name, MAP_PLAYER_UNIQUE);
603	if (!new_map) {	663	if (!new_map)
		664	{
604	memset(&rp, 0, sizeof(RMParms));	665	memset (&rp, 0, sizeof (RMParms));
605	rp.Xsize=-1;	666	rp.Xsize = -1;
606	rp.Ysize=-1;	667	rp.Ysize = -1;
607	rp.region=get_region_by_map(exit_ob->map);	668	rp.region = get_region_by_map (exit_ob->map);
		669	if (exit_ob->msg)
608	if (exit_ob->msg) set_random_map_variable(&rp,exit_ob->msg);	670	set_random_map_variable (&rp, exit_ob->msg);
609	rp.origin_x = exit_ob->x;	671	rp.origin_x = exit_ob->x;
610	rp.origin_y = exit_ob->y;	672	rp.origin_y = exit_ob->y;
611	strcpy(rp.origin_map, pl->map->path);	673	strcpy (rp.origin_map, pl->map->path);
612		674
613	/* now to generate the actual map. */	675	/* now to generate the actual map. */
614	new_map=generate_random_map(new_map_name,&rp);	676	new_map = generate_random_map (new_map_name, &rp);
615	}	677	}
616		678
617		679
618	/* Update the exit_ob so it now points directly at the newly created	680	/* Update the exit_ob so it now points directly at the newly created
619	* random maps. Not that it is likely to happen, but it does mean that a	681	* random maps. Not that it is likely to happen, but it does mean that a
620	* exit in a unique map leading to a random map will not work properly.	682	* exit in a unique map leading to a random map will not work properly.
621	* It also means that if the created random map gets reset before	683	* It also means that if the created random map gets reset before
622	* the exit leading to it, that the exit will no longer work.	684	* the exit leading to it, that the exit will no longer work.
623	*/	685	*/
624	if(new_map) {	686	if (new_map)
		687	{
625	int x, y;	688	int x, y;
		689
626	x=EXIT_X(exit_ob) = MAP_ENTER_X(new_map);	690	x = EXIT_X (exit_ob) = MAP_ENTER_X (new_map);
627	y=EXIT_Y(exit_ob) = MAP_ENTER_Y(new_map);	691	y = EXIT_Y (exit_ob) = MAP_ENTER_Y (new_map);
628	new_map->templatemap = 1;	692	new_map->templatemap = 1;
629	enter_map(pl, new_map, x, y);	693	enter_map (pl, new_map, x, y);
630	}	694	}
631	}	695	}
632		696
633		697
634	/* Code to enter/detect a character entering a unique map.	698	/* Code to enter/detect a character entering a unique map.
635	*/	699	*/
		700	static void
636	static void enter_unique_map(object *op, object *exit_ob)	701	enter_unique_map (object *op, object *exit_ob)
637	{	702	{
638	char apartment[HUGE_BUF];	703	char apartment[HUGE_BUF];
639	mapstruct *newmap;	704	mapstruct *newmap;
640		705
641	if (EXIT_PATH(exit_ob)[0]=='/') {	706	if (EXIT_PATH (exit_ob)[0] == '/')
642	sprintf(apartment, "%s/%s/%s/%s", settings.localdir,	707	{
643	settings.playerdir, &op->name, clean_path(EXIT_PATH(exit_ob)));	708	sprintf (apartment, "%s/%s/%s/%s", settings.localdir, settings.playerdir, &op->name, clean_path (EXIT_PATH (exit_ob)));
644	newmap = ready_map_name(apartment, MAP_PLAYER_UNIQUE);	709	newmap = ready_map_name (apartment, MAP_PLAYER_UNIQUE);
645	if (!newmap) {	710	if (!newmap)
		711	{
646	newmap = load_original_map(create_pathname(EXIT_PATH(exit_ob)), MAP_PLAYER_UNIQUE);	712	newmap = load_original_map (create_pathname (EXIT_PATH (exit_ob)), MAP_PLAYER_UNIQUE);
		713	if (newmap)
647	if (newmap) fix_auto_apply(newmap);	714	fix_auto_apply (newmap);
648	}	715	}
649	} else { /* relative directory */	716	}
		717	else
		718	{ /* relative directory */
650	char reldir[HUGE_BUF], tmpc[HUGE_BUF], *cp;	719	char reldir[HUGE_BUF], tmpc[HUGE_BUF], *cp;
651		720
652	if (exit_ob->map->unique) {	721	if (exit_ob->map->unique)
		722	{
653		723
654	strcpy(reldir, unclean_path(exit_ob->map->path));	724	strcpy (reldir, unclean_path (exit_ob->map->path));
655		725
656	/* Need to copy this over, as clean_path only has one static return buffer */	726	/* Need to copy this over, as clean_path only has one static return buffer */
657	strcpy(tmpc, clean_path(reldir));	727	strcpy (tmpc, clean_path (reldir));
658	/* Remove final component, if any */	728	/* Remove final component, if any */
659	if ((cp=strrchr(tmpc, '_'))!=NULL) *cp=0;	729	if ((cp = strrchr (tmpc, '_')) != NULL)
		730	*cp = 0;
660		731
661	sprintf(apartment, "%s/%s/%s/%s_%s", settings.localdir,	732	sprintf (apartment, "%s/%s/%s/%s_%s", settings.localdir, settings.playerdir, &op->name, tmpc, clean_path (EXIT_PATH (exit_ob)));
662	settings.playerdir, &op->name, tmpc,
663	clean_path(EXIT_PATH(exit_ob)));
664		733
665	newmap = ready_map_name(apartment, MAP_PLAYER_UNIQUE);	734	newmap = ready_map_name (apartment, MAP_PLAYER_UNIQUE);
666	if (!newmap) {	735	if (!newmap)
		736	{
667	newmap = load_original_map(create_pathname(path_combine_and_normalize(reldir, EXIT_PATH(exit_ob))), MAP_PLAYER_UNIQUE);	737	newmap = load_original_map (create_pathname (path_combine_and_normalize (reldir, EXIT_PATH (exit_ob))), MAP_PLAYER_UNIQUE);
		738	if (newmap)
668	if (newmap) fix_auto_apply(newmap);	739	fix_auto_apply (newmap);
		740	}
669	}	741	}
		742	else
670	}	743	{
671	else {
672	/* The exit is unique, but the map we are coming from is not unique. So	744	/* The exit is unique, but the map we are coming from is not unique. So
673	* use the basic logic - don't need to demangle the path name	745	* use the basic logic - don't need to demangle the path name
674	*/	746	*/
675	sprintf(apartment, "%s/%s/%s/%s", settings.localdir,	747	sprintf (apartment, "%s/%s/%s/%s", settings.localdir,
676	settings.playerdir, &op->name,
677	clean_path(path_combine_and_normalize(exit_ob->map->path, EXIT_PATH(exit_ob))));	748	settings.playerdir, &op->name, clean_path (path_combine_and_normalize (exit_ob->map->path, EXIT_PATH (exit_ob))));
678	newmap = ready_map_name(apartment, MAP_PLAYER_UNIQUE);	749	newmap = ready_map_name (apartment, MAP_PLAYER_UNIQUE);
679	if (!newmap) {	750	if (!newmap)
		751	{
680	newmap = ready_map_name(path_combine_and_normalize(exit_ob->map->path, EXIT_PATH(exit_ob)), 0);	752	newmap = ready_map_name (path_combine_and_normalize (exit_ob->map->path, EXIT_PATH (exit_ob)), 0);
		753	if (newmap)
681	if (newmap) fix_auto_apply(newmap);	754	fix_auto_apply (newmap);
682	}
683	}	755	}
		756	}
684	}	757	}
685		758
686	if (newmap) {	759	if (newmap)
		760	{
687	strcpy(newmap->path, apartment);	761	strcpy (newmap->path, apartment);
688	newmap->unique = 1;	762	newmap->unique = 1;
689	enter_map(op, newmap, EXIT_X(exit_ob), EXIT_Y(exit_ob));	763	enter_map (op, newmap, EXIT_X (exit_ob), EXIT_Y (exit_ob));
690	} else {	764	}
		765	else
		766	{
691	new_draw_info_format(NDI_UNIQUE, 0, op, "The %s is closed.", &exit_ob->name);	767	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s is closed.", &exit_ob->name);
692	/* Perhaps not critical, but I would think that the unique maps	768	/* Perhaps not critical, but I would think that the unique maps
693	* should be new enough this does not happen. This also creates	769	* should be new enough this does not happen. This also creates
694	* a strange situation where some players could perhaps have visited	770	* a strange situation where some players could perhaps have visited
695	* such a map before it was removed, so they have the private	771	* such a map before it was removed, so they have the private
696	* map, but other players can't get it anymore.	772	* map, but other players can't get it anymore.
697	*/	773	*/
698	LOG(llevDebug,"enter_unique_map: Exit %s (%d,%d) on map %s is leads no where.\n",	774	LOG (llevDebug, "enter_unique_map: Exit %s (%d,%d) on map %s is leads no where.\n",
699	&exit_ob->name, exit_ob->x, exit_ob->y, exit_ob->map->path);	775	&exit_ob->name, exit_ob->x, exit_ob->y, exit_ob->map->path);
700	}	776	}
701		777
702	}	778	}
703		779
704		780
705	/* Tries to move 'op' to exit_ob. op is the character or monster that is	781	/* Tries to move 'op' to exit_ob. op is the character or monster that is
706	* using the exit, where exit_ob is the exit object (boat, door, teleporter,	782	* using the exit, where exit_ob is the exit object (boat, door, teleporter,
…		…
709	*	785	*
710	* Largely redone by MSW 2001-01-21 - this function was overly complex	786	* Largely redone by MSW 2001-01-21 - this function was overly complex
711	* and had some obscure bugs.	787	* and had some obscure bugs.
712	*/	788	*/
713		789
		790	void
714	void enter_exit(object *op, object *exit_ob) {	791	enter_exit (object *op, object *exit_ob)
		792	{
715	#define PORTAL_DESTINATION_NAME "Town portal destination" /* this one should really be in a header file */	793	#define PORTAL_DESTINATION_NAME "Town portal destination" /* this one should really be in a header file */
716	object *tmp;	794	object *tmp;
		795
717	/* It may be nice to support other creatures moving across	796	/* It may be nice to support other creatures moving across
718	* exits, but right now a lot of the code looks at op->contr,	797	* exits, but right now a lot of the code looks at op->contr,
719	* so thta is an RFE.	798	* so thta is an RFE.
720	*/	799	*/
721	if (op->type != PLAYER) return;	800	if (op->type != PLAYER)
		801	return;
722		802
723	/* First, lets figure out what map the player is going to go to */	803	/* First, lets figure out what map the player is going to go to */
724	if (exit_ob){	804	if (exit_ob)
		805	{
725		806
726	/* check to see if we make a template map */	807	/* check to see if we make a template map */
727	if(EXIT_PATH(exit_ob)&&EXIT_PATH(exit_ob)[1]=='@') {	808	if (EXIT_PATH (exit_ob) && EXIT_PATH (exit_ob)[1] == '@')
		809	{
728	if (EXIT_PATH(exit_ob)[2]=='!') {	810	if (EXIT_PATH (exit_ob)[2] == '!')
		811	{
729	/* generate a template map randomly */	812	/* generate a template map randomly */
730	enter_random_template_map(op, exit_ob);	813	enter_random_template_map (op, exit_ob);
		814	}
731	} else {	815	else
		816	{
732	/* generate a template map from a fixed template */	817	/* generate a template map from a fixed template */
733	enter_fixed_template_map(op, exit_ob);	818	enter_fixed_template_map (op, exit_ob);
734	}
735	}	819	}
		820	}
736	/* check to see if we make a randomly generated map */	821	/* check to see if we make a randomly generated map */
737	else if(EXIT_PATH(exit_ob)&&EXIT_PATH(exit_ob)[1]=='!') {	822	else if (EXIT_PATH (exit_ob) && EXIT_PATH (exit_ob)[1] == '!')
		823	{
738	enter_random_map(op, exit_ob);	824	enter_random_map (op, exit_ob);
739	}	825	}
740	else if (QUERY_FLAG(exit_ob, FLAG_UNIQUE)) {	826	else if (QUERY_FLAG (exit_ob, FLAG_UNIQUE))
		827	{
741	enter_unique_map(op, exit_ob);	828	enter_unique_map (op, exit_ob);
		829	}
742	} else {	830	else
		831	{
743	int x=EXIT_X(exit_ob), y=EXIT_Y(exit_ob);	832	int x = EXIT_X (exit_ob), y = EXIT_Y (exit_ob);
		833
744	/* 'Normal' exits that do not do anything special	834	/* 'Normal' exits that do not do anything special
745	* Simple enough we don't need another routine for it.	835	* Simple enough we don't need another routine for it.
746	*/	836	*/
747	mapstruct *newmap;	837	mapstruct *newmap;
		838
748	if (exit_ob->map) {	839	if (exit_ob->map)
		840	{
749	newmap = ready_map_name(path_combine_and_normalize(exit_ob->map->path, EXIT_PATH(exit_ob)), 0);	841	newmap = ready_map_name (path_combine_and_normalize (exit_ob->map->path, EXIT_PATH (exit_ob)), 0);
750	/* Random map was previously generated, but is no longer about. Lets generate a new	842	/* Random map was previously generated, but is no longer about. Lets generate a new
751	* map.	843	* map.
752	*/	844	*/
753	if (!newmap && !strncmp(EXIT_PATH(exit_ob),"/random/",8)) {	845	if (!newmap && !strncmp (EXIT_PATH (exit_ob), "/random/", 8))
		846	{
754	/* Maps that go down have a message set. However, maps that go	847	/* Maps that go down have a message set. However, maps that go
755	* up, don't. If the going home has reset, there isn't much	848	* up, don't. If the going home has reset, there isn't much
756	* point generating a random map, because it won't match the maps.	849	* point generating a random map, because it won't match the maps.
757	*/	850	*/
758	if (exit_ob->msg) {	851	if (exit_ob->msg)
		852	{
759	enter_random_map(op, exit_ob);	853	enter_random_map (op, exit_ob);
760	} else {
761	new_draw_info_format(NDI_UNIQUE, 0, op, "The %s is closed.", &exit_ob->name);
762	return;
763	}	854	}
		855	else
		856	{
		857	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s is closed.", &exit_ob->name);
		858	return;
		859	}
764		860
765	/* For exits that cause damages (like pits). Don't know if any	861	/* For exits that cause damages (like pits). Don't know if any
766	* random maps use this or not.	862	* random maps use this or not.
767	*/	863	*/
768	if(exit_ob->stats.dam && op->type==PLAYER)	864	if (exit_ob->stats.dam && op->type == PLAYER)
769	hit_player(op,exit_ob->stats.dam,exit_ob,exit_ob->attacktype,1);	865	hit_player (op, exit_ob->stats.dam, exit_ob, exit_ob->attacktype, 1);
770	return;	866	return;
771	}	867	}
		868	}
772	} else {	869	else
		870	{
773	/* For word of recall and other force objects	871	/* For word of recall and other force objects
774	* They contain the full pathname of the map to go back to,	872	* They contain the full pathname of the map to go back to,
775	* so we don't need to normalize it.	873	* so we don't need to normalize it.
776	* But we do need to see if it is unique or not	874	* But we do need to see if it is unique or not
777	*/	875	*/
778	if (!strncmp(EXIT_PATH(exit_ob), settings.localdir, strlen(settings.localdir)))	876	if (!strncmp (EXIT_PATH (exit_ob), settings.localdir, strlen (settings.localdir)))
779	newmap = ready_map_name(EXIT_PATH(exit_ob), MAP_PLAYER_UNIQUE);	877	newmap = ready_map_name (EXIT_PATH (exit_ob), MAP_PLAYER_UNIQUE);
780	else	878	else
781	newmap = ready_map_name(EXIT_PATH(exit_ob), 0);	879	newmap = ready_map_name (EXIT_PATH (exit_ob), 0);
782	}	880	}
783	if (!newmap)	881	if (!newmap)
784	{	882	{
785	if (exit_ob->name)	883	if (exit_ob->name)
786	new_draw_info_format(NDI_UNIQUE, 0, op, "The %s is closed.", &exit_ob->name);	884	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s is closed.", &exit_ob->name);
787	/* don't cry to momma if name is not set - as in tmp objects	885	/* don't cry to momma if name is not set - as in tmp objects
788	* used by the savebed code and character creation */	886	* used by the savebed code and character creation */
789	return;	887	return;
790	}	888	}
791		889
792	/* This supports the old behaviour, but it really should not be used.	890	/* This supports the old behaviour, but it really should not be used.
793	* I will note for example that with this method, it is impossible to	891	* I will note for example that with this method, it is impossible to
794	* set 0,0 destination coordinates. Really, if we want to support	892	* set 0,0 destination coordinates. Really, if we want to support
795	* using the new maps default coordinates, the exit ob should use	893	* using the new maps default coordinates, the exit ob should use
796	* something like -1, -1 so it is clear to do that.	894	* something like -1, -1 so it is clear to do that.
797	*/	895	*/
798	if (x==0 && y==0) {	896	if (x == 0 && y == 0)
		897	{
799	x=MAP_ENTER_X(newmap);	898	x = MAP_ENTER_X (newmap);
800	y=MAP_ENTER_Y(newmap);	899	y = MAP_ENTER_Y (newmap);
801	LOG(llevDebug,"enter_exit: Exit %s (%d,%d) on map %s is 0 destination coordinates\n",	900	LOG (llevDebug, "enter_exit: Exit %s (%d,%d) on map %s is 0 destination coordinates\n",
802	&exit_ob->name, exit_ob->x, exit_ob->y,
803	exit_ob->map ? exit_ob->map->path : "<nil>");	901	&exit_ob->name, exit_ob->x, exit_ob->y, exit_ob->map ? exit_ob->map->path : "<nil>");
804	}	902	}
805		903
806	/* mids 02/13/2002 if exit is damned, update players death & WoR home-position and delete town portal */	904	/* mids 02/13/2002 if exit is damned, update players death & WoR home-position and delete town portal */
807	if (QUERY_FLAG(exit_ob, FLAG_DAMNED)) {	905	if (QUERY_FLAG (exit_ob, FLAG_DAMNED))
		906	{
808	/* remove an old force with a slaying field == PORTAL_DESTINATION_NAME */	907	/* remove an old force with a slaying field == PORTAL_DESTINATION_NAME */
809	for(tmp=op->inv; tmp != NULL; tmp = tmp->below) {	908	for (tmp = op->inv; tmp != NULL; tmp = tmp->below)
		909	{
810	if(tmp->type == FORCE && tmp->slaying && !strcmp(tmp->slaying, PORTAL_DESTINATION_NAME)) break;	910	if (tmp->type == FORCE && tmp->slaying && !strcmp (tmp->slaying, PORTAL_DESTINATION_NAME))
		911	break;
811	}	912	}
812	if(tmp) {	913	if (tmp)
		914	{
813	remove_ob(tmp);	915	remove_ob (tmp);
814	free_object(tmp);	916	free_object (tmp);
815	}	917	}
816		918
817	strcpy(op->contr->savebed_map, path_combine_and_normalize(exit_ob->map->path, EXIT_PATH(exit_ob)));	919	strcpy (op->contr->savebed_map, path_combine_and_normalize (exit_ob->map->path, EXIT_PATH (exit_ob)));
818	op->contr->bed_x = EXIT_X(exit_ob), op->contr->bed_y = EXIT_Y(exit_ob);	920	op->contr->bed_x = EXIT_X (exit_ob), op->contr->bed_y = EXIT_Y (exit_ob);
819	save_player(op, 1);	921	save_player (op, 1);
820	/* LOG(llevDebug,"enter_exit: Taking damned exit %s to (%d,%d) on map %s\n",	922	/* LOG(llevDebug,"enter_exit: Taking damned exit %s to (%d,%d) on map %s\n",
821	* exit_ob->name?exit_ob->name:"(none)", exit_ob->x, exit_ob->y,	923	* exit_ob->name?exit_ob->name:"(none)", exit_ob->x, exit_ob->y,
822	* path_combine_and_normalize(exit_ob->map->path, EXIT_PATH(exit_ob))); */	924	* path_combine_and_normalize(exit_ob->map->path, EXIT_PATH(exit_ob))); */
823	}	925	}
824		926
825	enter_map(op, newmap, x, y);	927	enter_map (op, newmap, x, y);
826	}	928	}
827	/* For exits that cause damages (like pits) */	929	/* For exits that cause damages (like pits) */
828	if(exit_ob->stats.dam && op->type==PLAYER)	930	if (exit_ob->stats.dam && op->type == PLAYER)
829	hit_player(op,exit_ob->stats.dam,exit_ob,exit_ob->attacktype,1);	931	hit_player (op, exit_ob->stats.dam, exit_ob, exit_ob->attacktype, 1);
830	} else {	932	}
		933	else
		934	{
831	int flags = 0;	935	int flags = 0;
832	mapstruct *newmap;	936	mapstruct *newmap;
833		937
834		938
835	/* Hypothetically, I guess its possible that a standard map matches	939	/* Hypothetically, I guess its possible that a standard map matches
836	* the localdir, but that seems pretty unlikely - unlikely enough that	940	* the localdir, but that seems pretty unlikely - unlikely enough that
837	* I'm not going to attempt to try to deal with that possibility.	941	* I'm not going to attempt to try to deal with that possibility.
838	* We use the fact that when a player saves on a unique map, it prepends	942	* We use the fact that when a player saves on a unique map, it prepends
839	* the localdir to that name. So its an easy way to see of the map is	943	* the localdir to that name. So its an easy way to see of the map is
840	* unique or not.	944	* unique or not.
841	*/	945	*/
842	if (!strncmp(op->contr->maplevel, settings.localdir, strlen(settings.localdir)))	946	if (!strncmp (op->contr->maplevel, settings.localdir, strlen (settings.localdir)))
843	flags = MAP_PLAYER_UNIQUE;	947	flags = MAP_PLAYER_UNIQUE;
844		948
845	/* newmap returns the map (if already loaded), or loads it for	949	/* newmap returns the map (if already loaded), or loads it for
846	* us.	950	* us.
847	*/	951	*/
848	newmap = ready_map_name(op->contr->maplevel, flags);	952	newmap = ready_map_name (op->contr->maplevel, flags);
849	if (!newmap)	953	if (!newmap)
850	{	954	{
851	LOG(llevError,
852	"enter_exit: Pathname to map does not exist! (%s)\n",	955	LOG (llevError, "enter_exit: Pathname to map does not exist! (%s)\n", op->contr->maplevel);
853	op->contr->maplevel);
854	newmap = ready_map_name(settings.emergency_mapname, 0);	956	newmap = ready_map_name (settings.emergency_mapname, 0);
855	op->x = settings.emergency_x;	957	op->x = settings.emergency_x;
856	op->y = settings.emergency_y;	958	op->y = settings.emergency_y;
857	/* If we can't load the emergency map, something is probably really	959	/* If we can't load the emergency map, something is probably really
858	* screwed up, so bail out now.	960	* screwed up, so bail out now.
859	*/	961	*/
860	if (!newmap) {	962	if (!newmap)
		963	{
861	LOG(llevError,"enter_exit: could not load emergency map? Fatal error\n");	964	LOG (llevError, "enter_exit: could not load emergency map? Fatal error\n");
862	abort();	965	abort ();
863	}
864	}	966	}
		967	}
865	enter_map(op, newmap, op->x, op->y);	968	enter_map (op, newmap, op->x, op->y);
866	}	969	}
867	}	970	}
868		971
869	/*	972	/*
870	* process_active_maps(): Works like process_events(), but it only	973	* process_active_maps(): Works like process_events(), but it only
871	* processes maps which a player is on.	974	* processes maps which a player is on.
872	*	975	*
873	*/	976	*/
874		977
875	#if 0 // dead code, schmorp	978	#if 0 // dead code, schmorp
		979	void
876	void process_active_maps ()	980	process_active_maps ()
877	{	981	{
878	for (mapstruct *map = first_map; map != NULL; map = map->next)	982	for (mapstruct *map = first_map; map != NULL; map = map->next)
879	if (map->in_memory == MAP_IN_MEMORY)	983	if (map->in_memory == MAP_IN_MEMORY)
880	if (players_on_map (map, TRUE))	984	if (players_on_map (map, TRUE))
881	process_events (map);	985	process_events (map);
…		…
888	* by the various functions. process_players1() does the processing before	992	* by the various functions. process_players1() does the processing before
889	* objects have been updated, process_players2() does the processing that	993	* objects have been updated, process_players2() does the processing that
890	* is needed after the players have been updated.	994	* is needed after the players have been updated.
891	*/	995	*/
892		996
		997	void
893	void process_players1(mapstruct *map)	998	process_players1 (mapstruct *map)
894	{	999	{
895	int flag;	1000	int flag;
896	player *pl,*plnext;	1001	player *pl, *plnext;
897		1002
898	/* Basically, we keep looping until all the players have done their actions. */	1003	/* Basically, we keep looping until all the players have done their actions. */
899	for(flag=1;flag!=0;) {	1004	for (flag = 1; flag != 0;)
		1005	{
900	flag=0;	1006	flag = 0;
901	for(pl=first_player;pl!=NULL;pl=plnext) {	1007	for (pl = first_player; pl != NULL; pl = plnext)
		1008	{
902	plnext=pl->next; /* In case a player exits the game in handle_player() */	1009	plnext = pl->next; /* In case a player exits the game in handle_player() */
903		1010
904	if (pl->ob == NULL) continue;	1011	if (pl->ob == NULL)
		1012	continue;
905		1013
906	if (map!=NULL && pl->ob->map!=map) continue;	1014	if (map != NULL && pl->ob->map != map)
		1015	continue;
907		1016
908	if(pl->ob->speed_left>0) {	1017	if (pl->ob->speed_left > 0)
		1018	{
909	if (handle_newcs_player(pl->ob))	1019	if (handle_newcs_player (pl->ob))
910	flag=1;	1020	flag = 1;
911	} /* end if player has speed left */	1021	} /* end if player has speed left */
912		1022
913	/* If the player is not actively playing, don't make a	1023	/* If the player is not actively playing, don't make a
914	* backup save - nothing to save anyway. Plus, the	1024	* backup save - nothing to save anyway. Plus, the
915	* map may not longer be valid. This can happen when the	1025	* map may not longer be valid. This can happen when the
916	* player quits - they exist for purposes of tracking on the map,	1026	* player quits - they exist for purposes of tracking on the map,
917	* but don't actually reside on any actual map.	1027	* but don't actually reside on any actual map.
918	*/	1028	*/
919	if (QUERY_FLAG(pl->ob, FLAG_REMOVED)) continue;	1029	if (QUERY_FLAG (pl->ob, FLAG_REMOVED))
		1030	continue;
920		1031
921	#ifdef AUTOSAVE	1032	#ifdef AUTOSAVE
922	/* check for ST_PLAYING state so that we don't try to save off when	1033	/* check for ST_PLAYING state so that we don't try to save off when
923	* the player is logging in.	1034	* the player is logging in.
924	*/	1035	*/
925	if ((pl->last_save_tick+AUTOSAVE)<pticks && pl->state==ST_PLAYING) {	1036	if ((pl->last_save_tick + AUTOSAVE) < (uint32) pticks && pl->state == ST_PLAYING)
		1037	{
926	/* Don't save the player on unholy ground. Instead, increase the	1038	/* Don't save the player on unholy ground. Instead, increase the
927	* tick time so it will be about 10 seconds before we try and save	1039	* tick time so it will be about 10 seconds before we try and save
928	* again.	1040	* again.
929	*/	1041	*/
930	// if (get_map_flags(pl->ob->map, NULL, pl->ob->x, pl->ob->y, NULL, NULL) & P_NO_CLERIC) {	1042	// if (get_map_flags(pl->ob->map, NULL, pl->ob->x, pl->ob->y, NULL, NULL) & P_NO_CLERIC) {
931	// pl->last_save_tick += 100;	1043	// pl->last_save_tick += 100;
932	// } else {	1044	// } else {
933	save_player(pl->ob,1);	1045	save_player (pl->ob, 1);
934	pl->last_save_tick = pticks;	1046	pl->last_save_tick = pticks;
935	// }	1047	// }
936	}	1048	}
937	#endif	1049	#endif
938	} /* end of for loop for all the players */	1050	} /* end of for loop for all the players */
939	} /* for flag */	1051	} /* for flag */
940	for(pl=first_player;pl!=NULL;pl=pl->next) {	1052	for (pl = first_player; pl != NULL; pl = pl->next)
		1053	{
941	if (map!=NULL && (pl->ob == NULL || pl->ob->map!=map))	1054	if (map != NULL && (pl->ob == NULL || pl->ob->map != map))
		1055	continue;
		1056	if (settings.casting_time == TRUE)
		1057	{
		1058	if (pl->ob->casting_time > 0)
		1059	{
		1060	pl->ob->casting_time--;
		1061	pl->ob->start_holding = 1;
		1062	}
		1063	/* set spell_state so we can update the range in stats field */
		1064	if ((pl->ob->casting_time == 0) && (pl->ob->start_holding == 1))
		1065	{
		1066	pl->ob->start_holding = 0;
		1067	}
		1068	}
		1069	do_some_living (pl->ob);
		1070	/* draw(pl->ob); *//* updated in socket code */
		1071	}
		1072	}
		1073
		1074	void
		1075	process_players2 (mapstruct *map)
		1076	{
		1077	player *pl;
		1078
		1079	/* Then check if any players should use weapon-speed instead of speed */
		1080	for (pl = first_player; pl != NULL; pl = pl->next)
		1081	{
		1082	if (map != NULL)
		1083	{
		1084	if (pl->ob == NULL || QUERY_FLAG (pl->ob, FLAG_REMOVED))
942	continue;	1085	continue;
943	if (settings.casting_time == TRUE) {
944	if (pl->ob->casting_time > 0){
945	pl->ob->casting_time--;
946	pl->ob->start_holding = 1;
947	}
948	/* set spell_state so we can update the range in stats field */
949	if ((pl->ob->casting_time == 0) && (pl->ob->start_holding ==1)){
950	pl->ob->start_holding = 0;
951	}
952	}
953	do_some_living(pl->ob);
954	/* draw(pl->ob);*/ /* updated in socket code */
955	}
956	}
957
958	void process_players2(mapstruct *map)
959	{
960	player *pl;
961
962	/* Then check if any players should use weapon-speed instead of speed */
963	for(pl=first_player;pl!=NULL;pl=pl->next) {
964	if (map!=NULL) {
965	if(pl->ob == NULL || QUERY_FLAG(pl->ob,FLAG_REMOVED))
966	continue;
967	else if(pl->loading != NULL) /* Player is blocked */	1086	else if (pl->loading != NULL) /* Player is blocked */
968	pl->ob->speed_left -= pl->ob->speed;
969	if (pl->ob->map!=map) continue;
970	}
971
972	/* The code that did weapon_sp handling here was out of place -
973	* this isn't called until after the player has finished there
974	* actions, and is thus out of place. All we do here is bounds
975	* checking.
976	*/
977	if (pl->has_hit) {
978	if (pl->ob->speed_left > pl->weapon_sp) pl->ob->speed_left = pl->weapon_sp;
979
980	/* This needs to be here - if the player is running, we need to
981	* clear this each tick, but new commands are not being received
982	* so execute_newserver_command() is never called
983	*/
984	pl->has_hit=0;
985
986	} else if (pl->ob->speed_left>pl->ob->speed)
987	pl->ob->speed_left = pl->ob->speed;	1087	pl->ob->speed_left -= pl->ob->speed;
988	}	1088	if (pl->ob->map != map)
989	}
990
991	#define SPEED_DEBUG
992
993
994	void process_events (mapstruct *map)
995	{
996	object *op;
997	object marker;
998	tag_t tag;
999
1000	process_players1 (map);
1001
1002	memset(&marker, 0, sizeof(object));
1003	/* Put marker object at beginning of active list */
1004	marker.active_next = active_objects;
1005
1006	if (marker.active_next)
1007	marker.active_next->active_prev = &marker;
1008	marker.active_prev = NULL;
1009	active_objects = &marker;
1010
1011	while (marker.active_next) {
1012	op = marker.active_next;
1013	tag = op->count;
1014
1015	/* Move marker forward - swap op and marker */
1016	op->active_prev = marker.active_prev;
1017
1018	if (op->active_prev)
1019	op->active_prev->active_next = op;
1020	else
1021	active_objects = op;
1022
1023	marker.active_next = op->active_next;
1024
1025	if (marker.active_next)
1026	marker.active_next->active_prev = &marker;
1027	marker.active_prev = op;
1028	op->active_next = &marker;
1029
1030	/* Now process op */
1031	if (QUERY_FLAG (op, FLAG_FREED)) {
1032	LOG (llevError, "BUG: process_events(): Free object on list\n");
1033	op->speed = 0;
1034	update_ob_speed (op);
1035	continue;	1089	continue;
1036	}	1090	}
1037		1091
		1092	/* The code that did weapon_sp handling here was out of place -
		1093	* this isn't called until after the player has finished there
		1094	* actions, and is thus out of place. All we do here is bounds
		1095	* checking.
		1096	*/
		1097	if (pl->has_hit)
		1098	{
		1099	if (pl->ob->speed_left > pl->weapon_sp)
		1100	pl->ob->speed_left = pl->weapon_sp;
		1101
		1102	/* This needs to be here - if the player is running, we need to
		1103	* clear this each tick, but new commands are not being received
		1104	* so execute_newserver_command() is never called
		1105	*/
		1106	pl->has_hit = 0;
		1107
		1108	}
		1109	else if (pl->ob->speed_left > pl->ob->speed)
		1110	pl->ob->speed_left = pl->ob->speed;
		1111	}
		1112	}
		1113
		1114	void
		1115	process_events (mapstruct *map)
		1116	{
		1117	object *op;
		1118	object *marker = get_object ();
		1119	tag_t tag;
		1120
		1121	process_players1 (map);
		1122
		1123	marker->active_next = active_objects;
		1124
		1125	if (marker->active_next)
		1126	marker->active_next->active_prev = marker;
		1127
		1128	marker->active_prev = NULL;
		1129	active_objects = marker;
		1130
		1131	while (marker->active_next)
		1132	{
		1133	op = marker->active_next;
		1134	tag = op->count;
		1135
		1136	/* Move marker forward - swap op and marker */
		1137	op->active_prev = marker->active_prev;
		1138
		1139	if (op->active_prev)
		1140	op->active_prev->active_next = op;
		1141	else
		1142	active_objects = op;
		1143
		1144	marker->active_next = op->active_next;
		1145
		1146	if (marker->active_next)
		1147	marker->active_next->active_prev = marker;
		1148
		1149	marker->active_prev = op;
		1150	op->active_next = marker;
		1151
		1152	/* Now process op */
		1153	if (QUERY_FLAG (op, FLAG_FREED))
		1154	{
		1155	LOG (llevError, "BUG: process_events(): Free object on list\n");
		1156	op->speed = 0;
		1157	update_ob_speed (op);
		1158	continue;
		1159	}
		1160
1038	/* I've seen occasional crashes due to this - the object is removed,	1161	/* I've seen occasional crashes due to this - the object is removed,
1039	* and thus the map it points to (last map it was on) may be bogus	1162	* and thus the map it points to (last map it was on) may be bogus
1040	* The real bug is to try to find out the cause of this - someone	1163	* The real bug is to try to find out the cause of this - someone
1041	* is probably calling remove_ob without either an insert_ob or	1164	* is probably calling remove_ob without either an insert_ob or
1042	* free_object afterwards, leaving an object dangling. But I'd	1165	* free_object afterwards, leaving an object dangling. But I'd
1043	* rather log this and continue on instead of crashing.	1166	* rather log this and continue on instead of crashing.
1044	* Don't remove players - when a player quits, the object is in	1167	* Don't remove players - when a player quits, the object is in
1045	* sort of a limbo, of removed, but something we want to keep	1168	* sort of a limbo, of removed, but something we want to keep
1046	* around.	1169	* around.
1047	*/	1170	*/
1048	if (QUERY_FLAG (op, FLAG_REMOVED) && op->type != PLAYER &&	1171	if (QUERY_FLAG (op, FLAG_REMOVED) && op->type != PLAYER && op->map && op->map->in_memory != MAP_IN_MEMORY)
1049	op->map && op->map->in_memory != MAP_IN_MEMORY) {	1172	{
1050	LOG (llevError, "BUG: process_events(): Removed object on list\n");	1173	LOG (llevError, "BUG: process_events(): Removed object on list\n");
1051	dump_object(op);	1174	dump_object (op);
1052	LOG(llevError, errmsg);	1175	LOG (llevError, errmsg);
1053	free_object(op);	1176	free_object (op);
		1177	continue;
		1178	}
		1179
		1180	if (!op->speed)
		1181	{
		1182	LOG (llevError, "BUG: process_events(): Object %s has no speed, " "but is on active list\n", &op->arch->name);
		1183	update_ob_speed (op);
		1184	continue;
		1185	}
		1186
		1187	if (op->map == NULL && op->env == NULL && op->name && op->type != MAP && map == NULL)
		1188	{
		1189	LOG (llevError, "BUG: process_events(): Object without map or " "inventory is on active list: %s (%d)\n", &op->name, op->count);
		1190	op->speed = 0;
		1191	update_ob_speed (op);
		1192	continue;
		1193	}
		1194
		1195	if (map != NULL && op->map != map)
		1196	continue;
		1197
		1198	/* Animate the object. Bug of feature that andim_speed
		1199	* is based on ticks, and not the creatures speed?
		1200	*/
		1201	if (op->anim_speed && op->last_anim >= op->anim_speed)
		1202	{
		1203	if ((op->type == PLAYER) || (op->type == MONSTER))
		1204	animate_object (op, op->facing);
		1205	else
		1206	animate_object (op, op->direction);
		1207
		1208	op->last_anim = 1;
		1209	}
		1210	else
		1211	op->last_anim++;
		1212
		1213	if (op->speed_left > 0)
		1214	{
		1215	#if 0
		1216	/* I've seen occasional crashes in move_symptom() with it
		1217	* crashing because op is removed - add some debugging to
		1218	* track if it is removed at this point.
		1219	* This unfortunately is a bit too verbose it seems - not sure
		1220	* why - I think what happens is a map is freed or something and
		1221	* some objects get 'lost' - removed never to be reclaimed.
		1222	* removed objects generally shouldn't exist.
		1223	*/
		1224	if (QUERY_FLAG (op, FLAG_REMOVED))
		1225	{
		1226	LOG (llevDebug, "process_events: calling process_object with removed object %s\n", op->name ? op->name : "null");
		1227	}
		1228	#endif
		1229	--op->speed_left;
		1230	process_object (op);
		1231	if (was_destroyed (op, tag))
1054	continue;	1232	continue;
1055	}	1233	}
1056
1057	if ( ! op->speed) {
1058	LOG (llevError, "BUG: process_events(): Object %s has no speed, "
1059	"but is on active list\n", &op->arch->name);
1060	update_ob_speed (op);
1061	continue;
1062	}
1063
1064	if (op->map == NULL && op->env == NULL && op->name &&
1065	op->type != MAP && map == NULL) {
1066	LOG (llevError, "BUG: process_events(): Object without map or "
1067	"inventory is on active list: %s (%d)\n",
1068	&op->name, op->count);
1069	op->speed = 0;
1070	update_ob_speed (op);
1071	continue;
1072	}
1073
1074	if (map != NULL && op->map != map)
1075	continue;
1076
1077	/* Animate the object. Bug of feature that andim_speed
1078	* is based on ticks, and not the creatures speed?
1079	*/
1080	if (op->anim_speed && op->last_anim >= op->anim_speed)
1081	{
1082	if ((op->type==PLAYER)||(op->type==MONSTER))
1083	animate_object(op, op->facing);
1084	else
1085	animate_object (op, op->direction);
1086
1087	op->last_anim = 1;
1088	}
1089	else
1090	op->last_anim++;
1091
1092	if (op->speed_left > 0) {
1093	#if 0
1094	/* I've seen occasional crashes in move_symptom() with it
1095	* crashing because op is removed - add some debugging to
1096	* track if it is removed at this point.
1097	* This unfortunately is a bit too verbose it seems - not sure
1098	* why - I think what happens is a map is freed or something and
1099	* some objects get 'lost' - removed never to be reclaimed.
1100	* removed objects generally shouldn't exist.
1101	*/
1102	if (QUERY_FLAG(op, FLAG_REMOVED)) {
1103	LOG(llevDebug,"process_events: calling process_object with removed object %s\n",
1104	op->name?op->name:"null");
1105	}
1106	#endif
1107	--op->speed_left;
1108	process_object (op);
1109	if (was_destroyed (op, tag))
1110	continue;
1111	}
1112	if (settings.casting_time == TRUE && op->casting_time > 0)	1234	if (settings.casting_time == TRUE && op->casting_time > 0)
1113	op->casting_time--;	1235	op->casting_time--;
1114	if (op->speed_left <= 0)	1236	if (op->speed_left <= 0)
1115	op->speed_left += FABS (op->speed);	1237	op->speed_left += FABS (op->speed);
1116	}	1238	}
1117		1239
1118	/* Remove marker object from active list */	1240	/* Remove marker object from active list */
1119	if (marker.active_prev != NULL)	1241	if (marker->active_prev != NULL)
1120	marker.active_prev->active_next = NULL;	1242	marker->active_prev->active_next = NULL;
1121	else	1243	else
1122	active_objects = NULL;	1244	active_objects = NULL;
1123		1245
1124	process_players2 (map);	1246	process_players2 (map);
1125	}
1126		1247
		1248	free_object (marker);
		1249	}
		1250
		1251	void
1127	void clean_tmp_files(void) {	1252	clean_tmp_files (void)
		1253	{
1128	mapstruct *m, *next;	1254	mapstruct *m, *next;
1129		1255
1130	LOG(llevInfo,"Cleaning up...\n");	1256	LOG (llevInfo, "Cleaning up...\n");
1131		1257
1132	/* We save the maps - it may not be intuitive why, but if there are unique	1258	/* We save the maps - it may not be intuitive why, but if there are unique
1133	* items, we need to save the map so they get saved off. Perhaps we should	1259	* items, we need to save the map so they get saved off. Perhaps we should
1134	* just make a special function that only saves the unique items.	1260	* just make a special function that only saves the unique items.
1135	*/	1261	*/
1136	for(m=first_map;m!=NULL;m=next) {	1262	for (m = first_map; m != NULL; m = next)
		1263	{
1137	next=m->next;	1264	next = m->next;
1138	if (m->in_memory == MAP_IN_MEMORY) {	1265	if (m->in_memory == MAP_IN_MEMORY)
		1266	{
1139	/* If we want to reuse the temp maps, swap it out (note that will also	1267	/* If we want to reuse the temp maps, swap it out (note that will also
1140	* update the log file. Otherwise, save the map (mostly for unique item	1268	* update the log file. Otherwise, save the map (mostly for unique item
1141	* stuff). Note that the clean_tmp_map is called after the end of	1269	* stuff). Note that the clean_tmp_map is called after the end of
1142	* the for loop but is in the #else bracket. IF we are recycling the maps,	1270	* the for loop but is in the #else bracket. IF we are recycling the maps,
1143	* we certainly don't want the temp maps removed.	1271	* we certainly don't want the temp maps removed.
1144	*/	1272	*/
1145		1273
1146	/* XXX The above comment is dead wrong */	1274	/* XXX The above comment is dead wrong */
1147	if (settings.recycle_tmp_maps == TRUE)	1275	if (settings.recycle_tmp_maps == TRUE)
1148	swap_map(m);	1276	swap_map (m);
1149	else {	1277	else
		1278	{
1150	new_save_map(m, 0); /* note we save here into a overlay map */	1279	new_save_map (m, 0); /* note we save here into a overlay map */
1151	clean_tmp_map(m);	1280	clean_tmp_map (m);
1152	}	1281	}
1153	}	1282	}
1154	}	1283	}
1155	write_todclock(); /* lets just write the clock here */	1284	write_todclock (); /* lets just write the clock here */
1156	}	1285	}
1157		1286
1158	/* clean up everything before exiting */	1287	/* clean up everything before exiting */
		1288	void
1159	void cleanup(void)	1289	cleanup (void)
1160	{	1290	{
1161	LOG(llevDebug,"Cleanup called. freeing data.\n");	1291	LOG (llevDebug, "Cleanup called. freeing data.\n");
1162	clean_tmp_files();	1292	clean_tmp_files ();
1163	write_book_archive();	1293	write_book_archive ();
1164	#ifdef MEMORY_DEBUG	1294	#ifdef MEMORY_DEBUG
1165	free_all_maps();	1295	free_all_maps ();
1166	free_style_maps();	1296	free_style_maps ();
1167	free_all_object_data();	1297	free_all_object_data ();
1168	free_all_archs();	1298	free_all_archs ();
1169	free_all_treasures();	1299	free_all_treasures ();
1170	free_all_images();	1300	free_all_images ();
1171	free_all_newserver();	1301	free_all_newserver ();
1172	free_all_recipes();	1302	free_all_recipes ();
1173	free_all_readable();	1303	free_all_readable ();
1174	free_all_god();	1304	free_all_god ();
1175	free_all_anim();	1305	free_all_anim ();
1176	/* See what the string data that is out there that hasn't been freed. */	1306	/* See what the string data that is out there that hasn't been freed. */
		1307
1177	/* LOG(llevDebug, ss_dump_table(0xff));*/	1308	/* LOG(llevDebug, ss_dump_table(0xff));*/
1178	#endif	1309	#endif
1179	exit(0);	1310	exit (0);
1180	}	1311	}
1181		1312
		1313	void
1182	void leave(player *pl, int draw_exit) {	1314	leave (player *pl, int draw_exit)
		1315	{
1183	if (pl != NULL) {	1316	if (pl != NULL)
		1317	{
1184	/* We do this so that the socket handling routine can do the final	1318	/* We do this so that the socket handling routine can do the final
1185	* cleanup. We also leave that loop to actually handle the freeing	1319	* cleanup. We also leave that loop to actually handle the freeing
1186	* of the data.	1320	* of the data.
1187	*/	1321	*/
1188	if (pl->ob->type != DEAD_OBJECT)	1322	if (pl->ob->type != DEAD_OBJECT)
1189	{	1323	{
1190	pl->socket.status = Ns_Dead;	1324	pl->socket.status = Ns_Dead;
1191		1325
1192	/* If a hidden dm dropped connection do not create	1326	/* If a hidden dm dropped connection do not create
1193	* inconsistencies by showing that they have left the game	1327	* inconsistencies by showing that they have left the game
1194	*/	1328	*/
1195	if (!(QUERY_FLAG(pl->ob,FLAG_WIZ) && pl->ob->contr->hidden)	1329	if (!(QUERY_FLAG (pl->ob, FLAG_WIZ) && pl->ob->contr->hidden)
1196	&& draw_exit
1197	&& (pl->state != ST_GET_NAME && pl->state!=ST_GET_PASSWORD && pl->state != ST_CONFIRM_PASSWORD))	1330	&& draw_exit && (pl->state != ST_GET_NAME && pl->state != ST_GET_PASSWORD && pl->state != ST_CONFIRM_PASSWORD))
1198	{	1331	{
1199	if (pl->ob->map)	1332	if (pl->ob->map)
1200	{	1333	{
1201	INVOKE_PLAYER (LOGOUT, pl);	1334	INVOKE_PLAYER (LOGOUT, pl);
1202	LOG (llevInfo,"LOGOUT: Player named %s from ip %s\n", &pl->ob->name, pl->socket.host);	1335	LOG (llevInfo, "LOGOUT: Player named %s from ip %s\n", &pl->ob->name, pl->socket.host);
1203	}	1336	}
1204		1337
1205	char buf[MAX_BUF];	1338	char buf[MAX_BUF];
		1339
1206	sprintf (buf, "%s left the game.", &pl->ob->name);	1340	sprintf (buf, "%s left the game.", &pl->ob->name);
1207	new_draw_info(NDI_UNIQUE | NDI_ALL | NDI_DK_ORANGE, 5, NULL, buf);	1341	new_draw_info (NDI_UNIQUE | NDI_ALL | NDI_DK_ORANGE, 5, NULL, buf);
1208	}	1342	}
1209		1343
1210	if (!QUERY_FLAG (pl->ob, FLAG_REMOVED))	1344	if (!QUERY_FLAG (pl->ob, FLAG_REMOVED))
1211	leave_map (pl->ob);	1345	leave_map (pl->ob);
1212		1346
1213	pl->ob->type = DEAD_OBJECT; /* To avoid problems with inventory window */	1347	pl->ob->type = DEAD_OBJECT; /* To avoid problems with inventory window */
1214	}	1348	}
1215	}	1349	}
1216	}	1350	}
1217		1351
		1352	int
1218	int forbid_play(void)	1353	forbid_play (void)
1219	{	1354	{
1220	#if !defined(_IBMR2) && !defined(___IBMR2) && defined(PERM_FILE)	1355	#if !defined(_IBMR2) && !defined(___IBMR2) && defined(PERM_FILE)
1221	char buf[MAX_BUF], day[MAX_BUF];	1356	char buf[MAX_BUF], day[MAX_BUF];
1222	FILE *fp;	1357	FILE *fp;
1223	time_t clock;	1358	time_t clock;
1224	struct tm *tm;	1359	struct tm *tm;
1225	int i, start, stop, forbit=0, comp;	1360	int i, start, stop, forbit = 0, comp;
1226		1361
1227	clock = time (NULL);	1362	clock = time (NULL);
1228	tm = (struct tm *) localtime (&clock);	1363	tm = (struct tm *) localtime (&clock);
1229		1364
1230	sprintf (buf, "%s/%s", settings.confdir, PERM_FILE);	1365	sprintf (buf, "%s/%s", settings.confdir, PERM_FILE);
1231	if ((fp = open_and_uncompress(buf, 0, &comp)) == NULL)	1366	if ((fp = open_and_uncompress (buf, 0, &comp)) == NULL)
1232	return 0;	1367	return 0;
1233		1368
1234	while (fgets (buf, MAX_BUF, fp)) {	1369	while (fgets (buf, MAX_BUF, fp))
		1370	{
1235	if (buf[0]=='#') continue;	1371	if (buf[0] == '#')
		1372	continue;
1236	if (!strncmp (buf, "msg", 3)) {	1373	if (!strncmp (buf, "msg", 3))
		1374	{
1237	if (forbit)	1375	if (forbit)
1238	while (fgets (buf, MAX_BUF, fp)) /* print message */	1376	while (fgets (buf, MAX_BUF, fp)) /* print message */
1239	fputs (buf, logfile);	1377	fputs (buf, logfile);
1240	break;	1378	break;
1241		1379
		1380	}
1242	} else if (sscanf (buf, "%s %d%*c%d\n", day, &start, &stop) != 3) {	1381	else if (sscanf (buf, "%s %d%*c%d\n", day, &start, &stop) != 3)
		1382	{
1243	LOG(llevDebug, "Warning: Incomplete line in permission file ignored.\n");	1383	LOG (llevDebug, "Warning: Incomplete line in permission file ignored.\n");
1244	continue;	1384	continue;
		1385	}
		1386
		1387	for (i = 0; i < 7; i++)
1245	}	1388	{
1246		1389	if (!strncmp (buf, days[i], 3) && (tm->tm_wday == i) && (tm->tm_hour >= start) && (tm->tm_hour < stop))
1247	for (i=0; i< 7; i++) {
1248	if (!strncmp (buf, days[i], 3) && (tm->tm_wday == i) &&
1249	(tm->tm_hour >= start) && (tm->tm_hour < stop))
1250	forbit = 1;	1390	forbit = 1;
1251	}	1391	}
1252	}	1392	}
1253		1393
1254	close_and_delete(fp, comp);	1394	close_and_delete (fp, comp);
1255		1395
1256	return forbit;	1396	return forbit;
1257	#else	1397	#else
1258	return 0;	1398	return 0;
1259	#endif	1399	#endif
1260	}	1400	}
1261		1401
1262	/*	1402	/*
1263	* do_specials() is a collection of functions to call from time to time.	1403	* do_specials() is a collection of functions to call from time to time.
…		…
1273	* doing the various things.	1413	* doing the various things.
1274	*/	1414	*/
1275		1415
1276	extern unsigned long todtick;	1416	extern unsigned long todtick;
1277		1417
		1418	void
1278	void do_specials(void) {	1419	do_specials (void)
		1420	{
1279		1421
1280	#ifdef WATCHDOG	1422	#ifdef WATCHDOG
1281	if (!(pticks % 503))	1423	if (!(pticks % 503))
1282	watchdog();	1424	watchdog ();
1283	#endif	1425	#endif
1284		1426
1285	if (!(pticks % PTICKS_PER_CLOCK))	1427	if (!(pticks % PTICKS_PER_CLOCK))
1286	tick_the_clock();	1428	tick_the_clock ();
1287		1429
1288	if (!(pticks % 7))	1430	if (!(pticks % 7))
1289	shstr::gc ();	1431	shstr::gc ();
1290		1432
1291	if (!(pticks % 79))	1433	if (!(pticks % 79))
1292	flush_old_maps(); /* Clears the tmp-files of maps which have reset */	1434	flush_old_maps (); /* Clears the tmp-files of maps which have reset */
1293		1435
1294	if (!(pticks % 2503))	1436	if (!(pticks % 2503))
1295	fix_weight(); /* Hack to fix weightproblems caused by bugs */	1437	fix_weight (); /* Hack to fix weightproblems caused by bugs */
1296		1438
1297	if (!(pticks % 2521))	1439	if (!(pticks % 2521))
1298	metaserver_update(); /* 2500 ticks is about 5 minutes */	1440	metaserver_update (); /* 2500 ticks is about 5 minutes */
1299		1441
1300	if (!(pticks % 5003))	1442	if (!(pticks % 5003))
1301	write_book_archive();	1443	write_book_archive ();
1302		1444
1303	if (!(pticks % 5009))	1445	if (!(pticks % 5009))
1304	clean_friendly_list();	1446	clean_friendly_list ();
1305		1447
1306	if (!(pticks % 5011))	1448	if (!(pticks % 5011))
1307	obsolete_parties();	1449	obsolete_parties ();
1308		1450
1309	if (!(pticks % 12503))	1451	if (!(pticks % 12503))
1310	fix_luck();	1452	fix_luck ();
1311	}	1453	}
1312		1454
		1455	void
1313	void server_tick ()	1456	server_tick ()
1314	{	1457	{
1315	nroferrors = 0;	1458	nroferrors = 0;
1316		1459
1317	doeric_server();	1460	doeric_server ();
1318	INVOKE_GLOBAL (CLOCK);	1461	INVOKE_GLOBAL (CLOCK);
1319	process_events(NULL); /* "do" something with objects with speed */	1462	process_events (NULL); /* "do" something with objects with speed */
1320	flush_sockets();	1463	flush_sockets ();
1321	check_active_maps(); /* Removes unused maps after a certain timeout */	1464	check_active_maps (); /* Removes unused maps after a certain timeout */
1322	do_specials(); /* Routines called from time to time. */	1465	do_specials (); /* Routines called from time to time. */
		1466	object::free_mortals ();
1323		1467
1324	++pticks;	1468	++pticks;
1325	}	1469	}
1326		1470
		1471	int
1327	int main(int argc, char **argv)	1472	main (int argc, char **argv)
1328	{	1473	{
1329	undead_name = "undead"; // what weird misoptimisation is this again?
1330
1331	settings.argc = argc;	1474	settings.argc = argc;
1332	settings.argv = argv;	1475	settings.argv = argv;
1333		1476
1334	cfperl_init ();	1477	cfperl_init ();
1335		1478

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines