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.49 by root, Wed Dec 20 09:14:22 2006 UTC vs.
Revision 1.179 by root, Sat Nov 17 23:33:18 2018 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,2013,2014,2015,2016 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	}
289	x += freearr_x[i];	105
290	y += freearr_y[i];	106	if (i >= 0)
		107	{
		108	maptile *m = newmap;
		109	sint16 nx = x + DIRX (i);
		110	sint16 ny = y + DIRY (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	*/
473	sprintf (newmap_name, "/random%s+%04d",
474	*rp.final_map ? rp.final_map : rp.origin_map,
475	reference_number++);
476
477	/* now to generate the actual map. */
478	new_map = generate_random_map (newmap_name, &rp);
479
480	/* Update the exit_ob so it now points directly at the newly created
481	* random maps. Not that it is likely to happen, but it does mean that a
482	* exit in a unique map leading to a random map will not work properly.
483	* It also means that if the created random map gets reset before
484	* the exit leading to it, that the exit will no longer work.
485	*/
486	if (new_map)
487	{
488	int x, y;
489
490	x = EXIT_X (exit_ob) = MAP_ENTER_X (new_map);
491	y = EXIT_Y (exit_ob) = MAP_ENTER_Y (new_map);
492	EXIT_PATH (exit_ob) = newmap_name;
493	strcpy (new_map->path, newmap_name);
494	enter_map (pl, new_map, x, y);
495	}
496	}
497
498	/* The player is trying to enter a non-randomly generated template map. In this
499	* case, use a map file for a template
500	*/
501
502	static void
503	enter_fixed_template_map (object *pl, object *exit_ob)
504	{
505	maptile *new_map;
506	char tmpnum[32], exitpath[HUGE_BUF], resultname[HUGE_BUF], tmpstring[HUGE_BUF], *sourcemap;
507	const char *new_map_name;
508
509	/* Split the exit path string into two parts, one
510	* for where to store the map, and one for were
511	* to generate the map from.
512	*/
513	snprintf (exitpath, sizeof (exitpath), "%s", EXIT_PATH (exit_ob) + 2);
514	sourcemap = strchr (exitpath, '!');
515	if (!sourcemap)
516	{
517	new_draw_info_format (NDI_UNIQUE, 0, pl, "The %s is closed.", &exit_ob->name);
518	/* Should only occur when no source map is set.
519	*/
520	LOG (llevError, "enter_fixed_template_map: Exit %s (%d,%d) on map %s has no source template.\n",
521	&exit_ob->name, exit_ob->x, exit_ob->y, exit_ob->map->path);
522	return;
523	}
524
525	*sourcemap++ = '\0';
526
527	/* If we are not coming from a template map, we can use relative directories
528	* for the map to generate from.
529	*/
530	if (!exit_ob->map->templatemap)
531	sourcemap = path_combine_and_normalize (exit_ob->map->path, sourcemap);
532
533	/* Do replacement of %x, %y, and %n to the x coord of the exit, the y coord
534	* of the exit, and the name of the map the exit is on, respectively.
535	*/
536	sprintf (tmpnum, "%d", exit_ob->x);
537	replace (exitpath, "%x", tmpnum, resultname, sizeof (resultname));
538
539	sprintf (tmpnum, "%d", exit_ob->y);
540	sprintf (tmpstring, "%s", resultname);
541	replace (tmpstring, "%y", tmpnum, resultname, sizeof (resultname));
542
543	sprintf (tmpstring, "%s", resultname);
544	replace (tmpstring, "%n", exit_ob->map->name, resultname, sizeof (resultname));
545
546	/* If we are coming from another template map, use reletive paths unless
547	* indicated otherwise.
548	*/
549	if (exit_ob->map->templatemap && (resultname[0] != '/'))
550	new_map_name = path_combine_and_normalize (exit_ob->map->path, resultname);
551	else
552	new_map_name = create_template_pathname (resultname);
553
554	/* Attempt to load the map, if unable to, then
555	* create the map from the template.
556	*/
557	new_map = ready_map_name (new_map_name, MAP_PLAYER_UNIQUE);
558	if (!new_map)
559	{
560	new_map = load_original_map (create_pathname (sourcemap), MAP_PLAYER_UNIQUE);
561	if (new_map)
562	fix_auto_apply (new_map);
563	}
564
565	if (new_map)
566	{
567	/* set the path of the map to where it should be
568	* so we don't just save over the source map.
569	*/
570	strcpy (new_map->path, new_map_name);
571	new_map->templatemap = 1;
572	enter_map (pl, new_map, EXIT_X (exit_ob), EXIT_Y (exit_ob));
573	}
574	else
575	{
576	new_draw_info_format (NDI_UNIQUE, 0, pl, "The %s is closed.", &exit_ob->name);
577	/* Should only occur when an invalid source map is set.
578	*/
579	LOG (llevDebug, "enter_fixed_template_map: Exit %s (%d,%d) on map %s leads no where.\n",
580	&exit_ob->name, exit_ob->x, exit_ob->y, exit_ob->map->path);
581	}
582	}
583
584	/* The player is trying to enter a randomly generated template map. In this
585	* case, generate the map as needed.
586	*/
587
588	static void
589	enter_random_template_map (object *pl, object *exit_ob)
590	{
591	maptile *new_map;
592	char tmpnum[32], resultname[HUGE_BUF], tmpstring[HUGE_BUF];
593	const char *new_map_name;
594	RMParms rp;
595
596	/* Do replacement of %x, %y, and %n to the x coord of the exit, the y coord
597	* of the exit, and the name of the map the exit is on, respectively.
598	*/
599	sprintf (tmpnum, "%d", exit_ob->x);
600	replace (EXIT_PATH (exit_ob) + 3, "%x", tmpnum, resultname, sizeof (resultname));
601
602	sprintf (tmpnum, "%d", exit_ob->y);
603	sprintf (tmpstring, "%s", resultname);
604	replace (tmpstring, "%y", tmpnum, resultname, sizeof (resultname));
605
606	sprintf (tmpstring, "%s", resultname);
607	replace (tmpstring, "%n", exit_ob->map->name, resultname, sizeof (resultname));
608
609	/* If we are coming from another template map, use reletive paths unless
610	* indicated otherwise.
611	*/
612	if (exit_ob->map->templatemap && (resultname[0] != '/'))
613	{
614	new_map_name = path_combine_and_normalize (exit_ob->map->path, resultname);
615	}
616	else
617	{
618	new_map_name = create_template_pathname (resultname);
619	}
620
621	new_map = ready_map_name (new_map_name, MAP_PLAYER_UNIQUE);
622	if (!new_map)
623	{
624	memset (&rp, 0, sizeof (RMParms));
625	rp.Xsize = -1;
626	rp.Ysize = -1;
627	rp.region = get_region_by_map (exit_ob->map);
628	if (exit_ob->msg)
629	set_random_map_variable (&rp, exit_ob->msg);
630	rp.origin_x = exit_ob->x;
631	rp.origin_y = exit_ob->y;
632	strcpy (rp.origin_map, pl->map->path);
633
634	/* now to generate the actual map. */
635	new_map = generate_random_map (new_map_name, &rp);
636	}
637
638
639	/* Update the exit_ob so it now points directly at the newly created
640	* random maps. Not that it is likely to happen, but it does mean that a
641	* exit in a unique map leading to a random map will not work properly.
642	* It also means that if the created random map gets reset before
643	* the exit leading to it, that the exit will no longer work.
644	*/
645	if (new_map)
646	{
647	int x, y;
648
649	x = EXIT_X (exit_ob) = MAP_ENTER_X (new_map);
650	y = EXIT_Y (exit_ob) = MAP_ENTER_Y (new_map);
651	new_map->templatemap = 1;
652	enter_map (pl, new_map, x, y);
653	}
654	}
655
656
657	/* Code to enter/detect a character entering a unique map.
658	*/
659	static void
660	enter_unique_map (object *op, object *exit_ob)
661	{
662	char apartment[HUGE_BUF];
663	maptile *newmap;
664
665	if (EXIT_PATH (exit_ob)[0] == '/')
666	{
667	sprintf (apartment, "%s/%s/%s/%s", settings.localdir, settings.playerdir, &op->name, clean_path (EXIT_PATH (exit_ob)));
668	newmap = ready_map_name (apartment, MAP_PLAYER_UNIQUE);
669	if (!newmap)
670	{
671	newmap = load_original_map (create_pathname (EXIT_PATH (exit_ob)), MAP_PLAYER_UNIQUE);
672	if (newmap)
673	fix_auto_apply (newmap);
674	}
675	}
676	else
677	{ /* relative directory */
678	char reldir[HUGE_BUF], tmpc[HUGE_BUF], *cp;
679
680	if (exit_ob->map->unique)
681	{
682
683	strcpy (reldir, unclean_path (exit_ob->map->path));
684
685	/* Need to copy this over, as clean_path only has one static return buffer */
686	strcpy (tmpc, clean_path (reldir));
687	/* Remove final component, if any */
688	if ((cp = strrchr (tmpc, '_')) != NULL)
689	*cp = 0;
690
691	sprintf (apartment, "%s/%s/%s/%s_%s", settings.localdir, settings.playerdir, &op->name, tmpc, clean_path (EXIT_PATH (exit_ob)));
692
693	newmap = ready_map_name (apartment, MAP_PLAYER_UNIQUE);
694	if (!newmap)
695	{
696	newmap = load_original_map (create_pathname (path_combine_and_normalize (reldir, EXIT_PATH (exit_ob))), MAP_PLAYER_UNIQUE);
697	if (newmap)	152	if (i < 0)
698	fix_auto_apply (newmap);	153	golem->drop_and_destroy ();
699	}
700	}
701	else
702	{
703	/* The exit is unique, but the map we are coming from is not unique. So
704	* use the basic logic - don't need to demangle the path name
705	*/
706	sprintf (apartment, "%s/%s/%s/%s", settings.localdir,
707	settings.playerdir, &op->name, clean_path (path_combine_and_normalize (exit_ob->map->path, EXIT_PATH (exit_ob))));
708	newmap = ready_map_name (apartment, MAP_PLAYER_UNIQUE);
709	if (!newmap)
710	{
711	newmap = ready_map_name (path_combine_and_normalize (exit_ob->map->path, EXIT_PATH (exit_ob)), 0);
712	if (newmap)
713	fix_auto_apply (newmap);
714	}
715	}
716	}
717
718	if (newmap)
719	{
720	strcpy (newmap->path, apartment);
721	newmap->unique = 1;
722	enter_map (op, newmap, EXIT_X (exit_ob), EXIT_Y (exit_ob));
723	}
724	else
725	{
726	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s is closed.", &exit_ob->name);
727	/* Perhaps not critical, but I would think that the unique maps
728	* should be new enough this does not happen. This also creates
729	* a strange situation where some players could perhaps have visited
730	* such a map before it was removed, so they have the private
731	* map, but other players can't get it anymore.
732	*/
733	LOG (llevDebug, "enter_unique_map: Exit %s (%d,%d) on map %s is leads no where.\n",
734	&exit_ob->name, exit_ob->x, exit_ob->y, exit_ob->map->path);
735	}
736
737	}
738
739
740	/* Tries to move 'op' to exit_ob. op is the character or monster that is
741	* using the exit, where exit_ob is the exit object (boat, door, teleporter,
742	* etc.) if exit_ob is null, then op->contr->maplevel contains that map to
743	* move the object to. This is used when loading the player.
744	*
745	* Largely redone by MSW 2001-01-21 - this function was overly complex
746	* and had some obscure bugs.
747	*/
748
749	void
750	enter_exit (object *op, object *exit_ob)
751	{
752	#define PORTAL_DESTINATION_NAME "Town portal destination" /* this one should really be in a header file */
753	object *tmp;
754
755	/* It may be nice to support other creatures moving across
756	* exits, but right now a lot of the code looks at op->contr,
757	* so that is an RFE.
758	*/
759	if (op->type != PLAYER)
760	return;
761
762	/* First, lets figure out what map the player is going to go to */
763	if (exit_ob)
764	{
765	/* check to see if we make a template map */
766	if (EXIT_PATH (exit_ob) && EXIT_PATH (exit_ob)[1] == '@')
767	{
768	if (EXIT_PATH (exit_ob)[2] == '!')
769	{
770	/* generate a template map randomly */
771	enter_random_template_map (op, exit_ob);
772	}
773	else	154	else
774	{
775	/* generate a template map from a fixed template */
776	enter_fixed_template_map (op, exit_ob);
777	}
778	}
779	/* check to see if we make a randomly generated map */
780	else if (EXIT_PATH (exit_ob) && EXIT_PATH (exit_ob)[1] == '!')
781	{
782	enter_random_map (op, exit_ob);
783	}
784	else if (QUERY_FLAG (exit_ob, FLAG_UNIQUE))
785	{
786	enter_unique_map (op, exit_ob);
787	}
788	else
789	{
790	int x = EXIT_X (exit_ob), y = EXIT_Y (exit_ob);
791
792	/* 'Normal' exits that do not do anything special
793	* Simple enough we don't need another routine for it.
794	*/
795	maptile *newmap;
796
797	if (exit_ob->map)
798	{
799	newmap = ready_map_name (path_combine_and_normalize (exit_ob->map->path, EXIT_PATH (exit_ob)), 0);
800	/* Random map was previously generated, but is no longer about. Lets generate a new
801	* map.
802	*/
803	if (!newmap && !strncmp (EXIT_PATH (exit_ob), "/random/", 8))
804	{	155	{
805	/* Maps that go down have a message set. However, maps that go	156	newmap->insert (golem, x + DIRX (i), y + DIRY (i));
806	* 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);
807	* point generating a random map, because it won't match the maps.
808	*/
809	if (exit_ob->msg)
810	{
811	enter_random_map (op, exit_ob);
812	}
813	else
814	{
815	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s is closed.", &exit_ob->name);
816	return;
817	}
818
819	/* For exits that cause damages (like pits). Don't know if any
820	* random maps use this or not.
821	*/
822	if (exit_ob->stats.dam && op->type == PLAYER)
823	hit_player (op, exit_ob->stats.dam, exit_ob, exit_ob->attacktype, 1);
824	return;
825	}	158	}
826	}	159	}
827	else
828	{
829	/* For word of recall and other force objects
830	* They contain the full pathname of the map to go back to,
831	* so we don't need to normalize it.
832	* But we do need to see if it is unique or not
833	*/
834	if (!strncmp (EXIT_PATH (exit_ob), settings.localdir, strlen (settings.localdir)))
835	newmap = ready_map_name (EXIT_PATH (exit_ob), MAP_PLAYER_UNIQUE);
836	else
837	newmap = ready_map_name (EXIT_PATH (exit_ob), 0);
838	}	160	}
839	if (!newmap)
840	{
841	if (exit_ob->name)
842	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s is closed.", &exit_ob->name);
843	/* don't cry to momma if name is not set - as in tmp objects
844	* used by the savebed code and character creation */
845	return;
846	}
847		161
848	/* 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
849	* I will note for example that with this method, it is impossible to	163	* about pending objects.
850	* set 0,0 destination coordinates. Really, if we want to support
851	* using the new maps default coordinates, the exit ob should use
852	* something like -1, -1 so it is clear to do that.
853	*/
854	if (x == 0 && y == 0)
855	{
856	x = MAP_ENTER_X (newmap);
857	y = MAP_ENTER_Y (newmap);
858	LOG (llevDebug, "enter_exit: Exit %s (%d,%d) on map %s is 0 destination coordinates\n",
859	&exit_ob->name, exit_ob->x, exit_ob->y, exit_ob->map ? exit_ob->map->path : "<nil>");
860	}
861
862	/* mids 02/13/2002 if exit is damned, update players death & WoR home-position and delete town portal */
863	if (QUERY_FLAG (exit_ob, FLAG_DAMNED))
864	{
865	/* remove an old force with a slaying field == PORTAL_DESTINATION_NAME */
866	for (tmp = op->inv; tmp != NULL; tmp = tmp->below)
867	{
868	if (tmp->type == FORCE && tmp->slaying && !strcmp (tmp->slaying, PORTAL_DESTINATION_NAME))
869	break;
870	}
871	if (tmp)
872	{
873	tmp->remove ();
874	tmp->destroy ();
875	}
876
877	strcpy (op->contr->savebed_map, path_combine_and_normalize (exit_ob->map->path, EXIT_PATH (exit_ob)));
878	op->contr->bed_x = EXIT_X (exit_ob), op->contr->bed_y = EXIT_Y (exit_ob);
879	save_player (op, 1);
880	/* LOG(llevDebug,"enter_exit: Taking damned exit %s to (%d,%d) on map %s\n",
881	* exit_ob->name?exit_ob->name:"(none)", exit_ob->x, exit_ob->y,
882	* path_combine_and_normalize(exit_ob->map->path, EXIT_PATH(exit_ob))); */
883	}
884
885	enter_map (op, newmap, x, y);
886	}
887	/* For exits that cause damages (like pits) */
888	if (exit_ob->stats.dam && op->type == PLAYER)
889	hit_player (op, exit_ob->stats.dam, exit_ob, exit_ob->attacktype, 1);
890	}
891	else
892	{
893	int flags = 0;
894	maptile *newmap;
895
896	/* Hypothetically, I guess its possible that a standard map matches
897	* the localdir, but that seems pretty unlikely - unlikely enough that
898	* I'm not going to attempt to try to deal with that possibility.
899	* We use the fact that when a player saves on a unique map, it prepends
900	* the localdir to that name. So its an easy way to see of the map is
901	* unique or not.
902	*/	164	*/
903	if (!strncmp (op->contr->maplevel, settings.localdir, strlen (settings.localdir)))	165	move_all_pets ();
904	flags = MAP_PLAYER_UNIQUE;
905		166
906	/* newmap returns the map (if already loaded), or loads it for	167	return true;
907	* us.
908	*/
909	newmap = ready_map_name (op->contr->maplevel, flags);
910	if (!newmap)
911	{
912	LOG (llevError, "enter_exit: Pathname to map does not exist! (%s)\n", op->contr->maplevel);
913	newmap = ready_map_name (settings.emergency_mapname, 0);
914	op->x = settings.emergency_x;
915	op->y = settings.emergency_y;
916	/* If we can't load the emergency map, something is probably really
917	* screwed up, so bail out now.
918	*/
919	if (!newmap)
920	{
921	LOG (llevError, "enter_exit: could not load emergency map? Fatal error\n");
922	abort ();
923	}
924	}
925
926	enter_map (op, newmap, op->x, op->y);
927	}	168	}
		169
		170	return false;
928	}	171	}
929		172
930	/* process_players1 and process_players2 do all the player related stuff.	173	/* process_players1 and process_players2 do all the player related stuff.
931	* 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
932	* 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
…		…
935	* is needed after the players have been updated.	178	* is needed after the players have been updated.
936	*/	179	*/
937	static void	180	static void
938	process_players1 ()	181	process_players1 ()
939	{	182	{
940	int flag;
941	/* 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. */
942	for (flag = 1; flag != 0;)	184	for (int flag = 1; flag != 0;)
943	{	185	{
944	flag = 0;	186	flag = 0;
945	for (player *plnext, *pl = first_player; pl; pl = plnext)	187	for_all_players (pl)
946	{	188	{
947	plnext = pl->next; /* In case a player exits the game in handle_player() */	189	pl->refcnt_chk ();
948		190
949	if (!pl->ob)	191	if (expect_false (!pl->ob || !pl->ns || !pl->ob->active))
950	continue;	192	continue;
951		193
952	if (pl->ob->speed_left > 0)
953	{
954	if (handle_newcs_player (pl->ob))	194	if (handle_newcs_player (pl->ob))
955	flag = 1;	195	flag = 1;
956	} /* end if player has speed left */	196	}
		197	}
957		198
958	/* If the player is not actively playing, don't make a	199	for_all_players (pl)
959	* backup save - nothing to save anyway. Plus, the	200	{
960	* map may not longer be valid. This can happen when the	201	object *ob = pl->ob;
961	* player quits - they exist for purposes of tracking on the map,	202
962	* but don't actually reside on any actual map.	203	// process_objects destroys the speed_left value
963	*/	204	pl->speed_left_save = ob->speed_left;
964	if (QUERY_FLAG (pl->ob, FLAG_REMOVED))	205
		206	if (expect_false (!ob || !pl->ns || !ob->active))
965	continue;	207	continue;
966		208
967	#ifdef AUTOSAVE
968	/* check for ST_PLAYING state so that we don't try to save off when
969	* the player is logging in.
970	*/
971	if ((pl->last_save_tick + AUTOSAVE) < (uint32) pticks && pl->state == ST_PLAYING)
972	{
973	save_player (pl->ob, 1);
974	pl->last_save_tick = pticks;
975	}
976	#endif
977	} /* end of for loop for all the players */
978	} /* for flag */
979
980	for (player *pl = first_player; pl; pl = pl->next)
981	{
982	if (settings.casting_time)
983	{
984	if (pl->ob->casting_time > 0)
985	{
986	pl->ob->casting_time--;
987	pl->ob->start_holding = 1;
988	}
989
990	/* set spell_state so we can update the range in stats field */
991	if ((pl->ob->casting_time == 0) && (pl->ob->start_holding == 1))
992	pl->ob->start_holding = 0;
993	}
994
995	do_some_living (pl->ob);	209	do_some_living (ob);
996	}	210	}
997	}	211	}
998		212
999	static void	213	static void
1000	process_players2 ()	214	process_players2 ()
1001	{	215	{
1002	/* 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 */
1003	for (player *pl = first_player; pl; pl = pl->next)	217	for_all_players (pl)
1004	{	218	{
1005	/* The code that did weapon_sp handling here was out of place -	219	// restore speed_left value saved by process_players1
1006	* this isn't called until after the player has finished there
1007	* actions, and is thus out of place. All we do here is bounds
1008	* checking.
1009	*/
1010	if (pl->has_hit)
1011	{
1012	if (pl->ob->speed_left > pl->weapon_sp)
1013	pl->ob->speed_left = pl->weapon_sp;
1014
1015	/* This needs to be here - if the player is running, we need to
1016	* clear this each tick, but new commands are not being received
1017	* so execute_newserver_command() is never called
1018	*/
1019	pl->has_hit = 0;
1020	}
1021	else if (pl->ob->speed_left > pl->ob->speed)
1022	pl->ob->speed_left = pl->ob->speed;	220	pl->ob->speed_left = pl->speed_left_save;
1023	}
1024	}
1025		221
1026	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
1027	process_events ()	228	process_events ()
1028	{	229	{
1029	object *op;
1030
1031	static object *marker;
1032
1033	if (!marker)
1034	marker = object::create ();
1035
1036	process_players1 ();	230	process_players1 ();
1037		231
1038	marker->active_next = active_objects;	232	for_all_actives (op)
1039
1040	if (marker->active_next)
1041	marker->active_next->active_prev = marker;
1042
1043	marker->active_prev = NULL;
1044	active_objects = marker;
1045
1046	while (marker->active_next)
1047	{	233	{
1048	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];
1049		241
1050	/* Move marker forward - swap op and marker */	242	ecb_prefetch (&next->flag , 0, 1);
1051	op->active_prev = marker->active_prev;	243	ecb_prefetch (&next->speed , 0, 1);
1052		244	ecb_prefetch (&next->anim_speed, 0, 1);
1053	if (op->active_prev)	245	ecb_prefetch (&next->contr , 0, 1);
1054	op->active_prev->active_next = op;	246	}
1055	else
1056	active_objects = op;
1057
1058	marker->active_next = op->active_next;
1059
1060	if (marker->active_next)
1061	marker->active_next->active_prev = marker;
1062
1063	marker->active_prev = op;
1064	op->active_next = marker;
1065		247
1066	/* Now process op */	248	/* Now process op */
1067	if (QUERY_FLAG (op, FLAG_FREED))	249	if (expect_false (op->flag [FLAG_FREED]))
1068	{	250	{
1069	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 ());
1070	op->speed = 0;	252	op->set_speed (0);
1071	update_ob_speed (op);
1072	continue;	253	continue;
1073	}	254	}
1074		255
1075	/* I've seen occasional crashes due to this - the object is removed,	256	if (expect_false (!op->has_active_speed ()))
1076	* and thus the map it points to (last map it was on) may be bogus
1077	* The real bug is to try to find out the cause of this - someone
1078	* is probably calling remove_ob without either an insert_ob or
1079	* free_object afterwards, leaving an object dangling. But I'd
1080	* rather log this and continue on instead of crashing.
1081	* Don't remove players - when a player quits, the object is in
1082	* sort of a limbo, of removed, but something we want to keep
1083	* around.
1084	*/	257	{
1085	if (QUERY_FLAG (op, FLAG_REMOVED) && op->type != PLAYER && op->map && op->map->in_memory != MAP_IN_MEMORY)
1086	{
1087	LOG (llevError, "BUG: process_events(): Removed object on list\n");	258	LOG (llevError, "BUG: process_events(): Object %s has no speed (%f), "
1088	char *dump = dump_object (op);	259	"but is on active list\n", op->debug_desc (), op->speed);
1089	LOG (llevError, dump);	260	op->set_speed (0);
1090	free (dump);
1091	op->destroy ();
1092	continue;	261	continue;
1093	}	262	}
1094		263
1095	if (!op->speed)	264	if (expect_false (op->flag [FLAG_REMOVED]))
1096	{
1097	LOG (llevError, "BUG: process_events(): Object %s has no speed, "
1098	"but is on active list\n", &op->arch->name);
1099	update_ob_speed (op);
1100	continue;
1101	}	265	{
1102		266	LOG (llevError, "BUG: process_events(): removed object is on active list: %s\n",
1103	if (op->map == NULL && op->env == NULL && op->name && op->type != MAP)	267	op->debug_desc ());
1104	{
1105	LOG (llevError, "BUG: process_events(): Object without map or "
1106	"inventory is on active list: %s (%d)\n", &op->name, op->count);
1107	op->speed = 0;	268	op->set_speed (0);
1108	update_ob_speed (op);
1109	continue;	269	continue;
1110	}	270	}
1111		271
1112	/* Animate the object. Bug or feature that anim_speed	272	/* Animate the object. Bug or feature that anim_speed
1113	* is based on ticks, and not the creatures speed?	273	* is based on ticks, and not the creatures speed?
1114	*/	274	*/
1115	if (op->anim_speed && op->last_anim >= op->anim_speed)	275	if (op->anim_speed && op->last_anim >= op->anim_speed)
1116	{	276	{
1117	if ((op->type == PLAYER) || (op->type == MONSTER))
1118	animate_object (op, op->facing);
1119	else
1120	animate_object (op, op->direction);	277	animate_object (op, op->contr ? op->facing : op->direction);
1121
1122	op->last_anim = 1;	278	op->last_anim = 1;
1123	}	279	}
1124	else	280	else
1125	op->last_anim++;	281	++op->last_anim;
1126		282
1127	if (op->speed_left > 0)	283	if (expect_false (op->speed_left > 0.f))
1128	{
1129	#if 0
1130	/* I've seen occasional crashes in move_symptom() with it
1131	* crashing because op is removed - add some debugging to
1132	* track if it is removed at this point.
1133	* This unfortunately is a bit too verbose it seems - not sure
1134	* why - I think what happens is a map is freed or something and
1135	* some objects get 'lost' - removed never to be reclaimed.
1136	* removed objects generally shouldn't exist.
1137	*/
1138	if (QUERY_FLAG (op, FLAG_REMOVED))
1139	{	284	{
1140	LOG (llevDebug, "process_events: calling process_object with removed object %s\n", op->name ? op->name : "null");
1141	}
1142	#endif
1143	--op->speed_left;	285	--op->speed_left;
1144	process_object (op);	286	process_object (op);
1145
1146	if (op->destroyed ())
1147	continue;
1148	}	287	}
1149		288
1150	if (settings.casting_time == TRUE && op->casting_time > 0)	289	// this will destroy the speed_left value for players, but
1151	op->casting_time--;	290	// process_players1 and ..2 save/restore the real value,
1152		291	// so we can avoid a costly test here.
1153	if (op->speed_left <= 0)	292	op->speed_left = min (op->speed, op->speed_left + op->speed);
1154	op->speed_left += FABS (op->speed);
1155	}	293	}
1156
1157	/* Remove marker object from active list */
1158	if (marker->active_prev != NULL)
1159	marker->active_prev->active_next = NULL;
1160	else
1161	active_objects = NULL;
1162		294
1163	process_players2 ();	295	process_players2 ();
1164	}
1165
1166	void
1167	clean_tmp_files (void)
1168	{
1169	maptile *m, *next;
1170
1171	LOG (llevInfo, "Cleaning up...\n");
1172
1173	/* We save the maps - it may not be intuitive why, but if there are unique
1174	* items, we need to save the map so they get saved off. Perhaps we should
1175	* just make a special function that only saves the unique items.
1176	*/
1177	for (m = first_map; m; m = next)
1178	{
1179	next = m->next;
1180
1181	if (m->in_memory == MAP_IN_MEMORY)
1182	{
1183	/* If we want to reuse the temp maps, swap it out (note that will also
1184	* update the log file.
1185	*/
1186
1187	swap_map (m);
1188	}
1189	}
1190
1191	write_todclock (); /* lets just write the clock here */
1192	}	296	}
1193		297
1194	/* clean up everything before exiting */	298	/* clean up everything before exiting */
1195	void	299	void
1196	cleanup (bool make_core)	300	emergency_save ()
1197	{	301	{
1198	LOG (llevDebug, "Cleanup called.\n");	302	LOG (llevInfo, "emergency_save: enter\n");
1199		303
1200	if (init_done)	304	LOG (llevInfo, "emergency_save: saving book archive\n");
1201	{
1202	for (player *pl = first_player; pl != NULL; pl = pl->next)
1203	save_player (pl->ob, 0);
1204
1205	for (player *pl = first_player; pl != NULL; pl = pl->next)
1206	if (!QUERY_FLAG (pl->ob, FLAG_REMOVED))
1207	leave_map (pl->ob);
1208
1209	clean_tmp_files ();
1210	write_book_archive ();	305	write_book_archive ();
1211		306
1212	INVOKE_GLOBAL (CLEANUP);	307	cfperl_emergency_save ();
1213	}	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);
1214		320
1215	if (make_core)	321	if (make_core)
1216	abort ();	322	new_draw_info_format (flags, 0, 0, "This is considered a crash, but all maps and players have been saved.");
1217	else	323	else
1218	_exit (0);	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.");
1219	}
1220		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 */
1221	void	332	void
1222	leave (player *pl, int draw_exit)	333	cleanup (const char *cause, bool make_core)
1223	{	334	{
1224	if (pl != NULL)	335	if (make_core)
1225	{	336	fork_abort (cause);
1226	/* We do this so that the socket handling routine can do the final
1227	* cleanup. We also leave that loop to actually handle the freeing
1228	* of the data.
1229	*/
1230	if (pl->ob->type != DEAD_OBJECT)
1231	{
1232	pl->socket->status = Ns_Dead;
1233		337
1234	/* If a hidden dm dropped connection do not create	338	LOG (make_core ? llevError : llevInfo, "cleanup cause: %s\n", cause);
1235	* inconsistencies by showing that they have left the game
1236	*/
1237	if (!(QUERY_FLAG (pl->ob, FLAG_WIZ) && pl->ob->contr->hidden)
1238	&& draw_exit && (pl->state != ST_GET_NAME && pl->state != ST_GET_PASSWORD && pl->state != ST_CONFIRM_PASSWORD))
1239	{
1240	if (pl->ob->map)
1241	{
1242	INVOKE_PLAYER (LOGOUT, pl);
1243	LOG (llevInfo, "LOGOUT: Player named %s from ip %s\n", &pl->ob->name, pl->socket->host);
1244	}
1245		339
1246	char buf[MAX_BUF];	340	if (!make_core)
		341	cleanup_inform (cause, make_core);
1247		342
1248	sprintf (buf, "%s left the game.", &pl->ob->name);	343	LOG (llevDebug, "cleanup begin.\n");
1249	new_draw_info (NDI_UNIQUE | NDI_ALL | NDI_DK_ORANGE, 5, NULL, buf);
1250	}
1251		344
1252	if (!QUERY_FLAG (pl->ob, FLAG_REMOVED))	345	if (init_done && !in_cleanup)
1253	leave_map (pl->ob);
1254
1255	pl->ob->type = DEAD_OBJECT; /* To avoid problems with inventory window */
1256	}
1257	}	346	{
1258	}	347	in_cleanup = true;
1259		348	emergency_save ();
1260	int
1261	forbid_play (void)
1262	{
1263	#if !defined(_IBMR2) && !defined(___IBMR2) && defined(PERM_FILE)
1264	char buf[MAX_BUF], day[MAX_BUF];
1265	FILE *fp;
1266	time_t clock;
1267	struct tm *tm;
1268	int i, start, stop, forbit = 0, comp;
1269
1270	clock = time (NULL);
1271	tm = (struct tm *) localtime (&clock);
1272
1273	sprintf (buf, "%s/%s", settings.confdir, PERM_FILE);
1274	if ((fp = open_and_uncompress (buf, 0, &comp)) == NULL)
1275	return 0;
1276
1277	while (fgets (buf, MAX_BUF, fp))
1278	{	349	}
1279	if (buf[0] == '#')	350	else
1280	continue;	351	in_cleanup = true;
1281	if (!strncmp (buf, "msg", 3))
1282	{
1283	if (forbit)
1284	while (fgets (buf, MAX_BUF, fp)) /* print message */
1285	fputs (buf, logfile);
1286	break;
1287		352
1288	}	353	LOG (llevDebug, "running cleanup handlers.\n");
1289	else if (sscanf (buf, "%s %d%*c%d\n", day, &start, &stop) != 3)	354	INVOKE_GLOBAL (CLEANUP);
1290	{
1291	LOG (llevDebug, "Warning: Incomplete line in permission file ignored.\n");
1292	continue;
1293	}
1294		355
1295	for (i = 0; i < 7; i++)	356	LOG (llevDebug, "cleanup done.\n");
1296	{	357
1297	if (!strncmp (buf, days[i], 3) && (tm->tm_wday == i) && (tm->tm_hour >= start) && (tm->tm_hour < stop))	358	log_cleanup ();
1298	forbit = 1;	359
1299	}	360	if (make_core)
		361	cleanup_inform (cause, make_core);
		362	else
1300	}	363	{
		364	new_draw_info_format (NDI_REPLY | NDI_UNIQUE | NDI_ALL | NDI_GREEN, 0, 0, "Maps and players successfully saved, exiting.");
		365	new_draw_info_format (NDI_REPLY | NDI_UNIQUE | NDI_ALL | NDI_GREEN, 0, 0, "And again: " CLEANUP_MESSAGE);
		366	client::flush_sockets ();
		367	}
1301		368
1302	close_and_delete (fp, comp);	369	cfperl_cleanup (make_core);
1303		370	_exit (make_core);
1304	return forbit;
1305	#else
1306	return 0;
1307	#endif
1308	}	371	}
1309		372
1310	/*	373	/*
1311	* 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.
1312	* 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
1313	* 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.
1314	* 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
1315	* 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
1316	* 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
1317	* 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
1318	* done on the same tick, but that will happen very infrequently	381	* done on the same tick, but that will happen very infrequently
1319	*	382	*
1320	* 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
1321	* doing the various things.	384	* doing the various things.
1322	*/	385	*/
		386	static void
		387	do_specials ()
		388	{
		389	shstr::gc ();
		390	archetype::gc ();
1323		391
1324	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	}
1325		410
1326	void	411	void
1327	do_specials (void)	412	one_tick ()
1328	{	413	{
1329	if (!(pticks % PTICKS_PER_CLOCK))
1330	tick_the_clock ();
1331
1332	if (!(pticks % 7))
1333	shstr::gc ();
1334
1335	if (!(pticks % 79))
1336	flush_old_maps (); /* Clears the tmp-files of maps which have reset */
1337
1338	if (!(pticks % 2503))
1339	fix_weight (); /* Hack to fix weightproblems caused by bugs */
1340
1341	if (!(pticks % 5003))
1342	write_book_archive ();
1343
1344	if (!(pticks % 5009))
1345	clean_friendly_list ();
1346
1347	if (!(pticks % 5011))
1348	obsolete_parties ();
1349
1350	if (!(pticks % 12503))
1351	fix_luck ();
1352	}
1353
1354	void
1355	server_tick ()
1356	{
1357	nroferrors = 0;
1358
1359	// first do the user visible stuff	414	// first do the user visible stuff
1360	doeric_server ();
1361	INVOKE_GLOBAL (CLOCK);	415	INVOKE_GLOBAL (CLOCK);
1362	process_events (); /* "do" something with objects with speed */	416	process_events (); // "do" something with objects with speed
1363	flush_sockets ();	417	client::clock (); // draw client maps etc.
1364		418
1365	// then do some bookkeeping, should not really be here	419	// then do some bookkeeping, should not really be here
1366	check_active_maps (); /* Removes unused maps after a certain timeout */
1367	do_specials (); /* Routines called from time to time. */	420	do_specials (); /* Routines called from time to time. */
1368	object::free_mortals ();	421	attachable::check_mortals ();
1369		422
1370	++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");
1371	}	426	}
1372		427
		428	// normal main
1373	int	429	int
1374	main (int argc, char **argv)	430	main (int argc, char **argv)
1375	{	431	{
1376	settings.argc = argc;	432	settings.argc = argc;
1377	settings.argv = argv;	433	settings.argv = argv;
1378		434
		435	rndm.seed (time (0));
		436
		437	// temporary(?) testing hack
		438	if (argc >= 2 && !strcmp (argv [1], "--noise"))
		439	{
		440	void noise_test ();
		441	noise_test ();
		442	exit (0);
		443	}
		444
		445	#if 0
		446	// code sometiems used for timing benchmarks
		447	random_number_generator<freeciv_random_generator> rng;
		448	rng.seed(0);
		449	for (int i = 0; i < 10; ++i)
		450	printf ("%08x\n", rng.get_u32());
		451	for (int i = 0; i < 1000000; ++i)
		452	volatile int r = rng.get_u32 ();
		453	cstamp s = stamp ();
		454	for (int i = 0; i < 1000000; ++i)
		455	volatile int r = rng.next ();
		456	printf ("c %d\n", (int)measure (s));
		457	exit (0);
		458	#endif
		459
1379	init (argc, argv);	460	init (argc, argv);
1380
1381	initPlugins ();
1382		461
1383	for (;;)	462	for (;;)
1384	cfperl_main ();	463	cfperl_main ();
1385
1386	// unreached
1387	emergency_save (0);
1388	cleanup ();
1389
1390	return 0;
1391	}	464	}
		465

Diff Legend

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