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

Diff Legend

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