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

Diff Legend

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