[ViewVC] Diff of: cvs/deliantra/server/server/main.C

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

Diff Legend

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

Comparing deliantra/server/server/main.C (file contents): Revision 1.31 by root, Sun Sep 17 14:22:29 2006 UTC vs. Revision 1.144 by root, Thu Nov 19 04:30:46 2009 UTC

Diff Legend

Comparing deliantra/server/server/main.C (file contents):
Revision 1.31 by root, Sun Sep 17 14:22:29 2006 UTC vs.
Revision 1.144 by root, Thu Nov 19 04:30:46 2009 UTC