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.28 by root, Thu Sep 14 23:13:49 2006 UTC vs.
Revision 1.167 by root, Tue Oct 12 06:20:14 2010 UTC

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

Diff Legend

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