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

Diff Legend

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