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

Comparing deliantra/server/server/main.C (file contents):
Revision 1.24 by root, Tue Sep 12 19:20:08 2006 UTC vs.
Revision 1.62 by root, Sat Dec 30 10:16:11 2006 UTC

…		…
16		16
17	You should have received a copy of the GNU General Public License	17	You should have received a copy of the GNU General Public License
18	along with this program; if not, write to the Free Software	18	along with this program; if not, write to the Free Software
19	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	19	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20		20
21	The authors can be reached via e-mail at crossfire-devel@real-time.com	21	The authors can be reached via e-mail at <crossfire@schmorp.de>
22	*/	22	*/
23		23
24	#include <global.h>	24	#include <global.h>
25	#include <object.h>	25	#include <object.h>
26	#include <tod.h>	26	#include <tod.h>
…		…
31	# ifdef HAVE_CRYPT_H	31	# ifdef HAVE_CRYPT_H
32	# include <crypt.h>	32	# include <crypt.h>
33	# endif	33	# endif
34	#endif	34	#endif
35		35
36	#ifndef __CEXTRACT__
37	# include <sproto.h>	36	#include <sproto.h>
38	#endif
39
40	#ifdef HAVE_TIME_H
41	# include <time.h>	37	#include <time.h>
42	#endif
43		38
44	#include <../random_maps/random_map.h>	39	#include <../random_maps/random_map.h>
45	#include <../random_maps/rproto.h>	40	#include <../random_maps/rproto.h>
46	#include "path.h"	41	#include "path.h"
47		42
…		…
106	new_draw_info (NDI_UNIQUE, 0, op, "Images and art:");	101	new_draw_info (NDI_UNIQUE, 0, op, "Images and art:");
107	new_draw_info (NDI_UNIQUE, 0, op, "Peter Gardner");	102	new_draw_info (NDI_UNIQUE, 0, op, "Peter Gardner");
108	new_draw_info (NDI_UNIQUE, 0, op, "David Gervais [david_eg@mail.com]");	103	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]");	104	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]");	105	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]");	106	new_draw_info (NDI_UNIQUE, 0, op, "MÃ¥rten Woxberg [maxmc@telia.com]");
112	new_draw_info (NDI_UNIQUE, 0, op, "And many more!");	107	new_draw_info (NDI_UNIQUE, 0, op, "And many more!");
113	}	108	}
114		109
115	void	110	void
116	info_keys (object *op)	111	info_keys (object *op)
…		…
133	new_draw_info (NDI_UNIQUE, 0, op, "Ctrl-R = refresh Ctrl-C = clear");	128	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.");	129	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.)");	130	new_draw_info (NDI_UNIQUE, 0, op, "(For instance 3d drops 3 items.)");
136	}	131	}
137		132
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	}
187
188	/* This is a basic little function to put the player back to his	133	/* This is a basic little function to put the player back to his
189	* savebed. We do some error checking - its possible that the	134	* savebed. We do some error checking - its possible that the
190	* savebed map may no longer exist, so we make sure the player	135	* savebed map may no longer exist, so we make sure the player
191	* goes someplace.	136	* goes someplace.
192	*/	137	*/
193	void	138	void
194	enter_player_savebed (object *op)	139	enter_player_savebed (object *op)
195	{	140	{
196	mapstruct *oldmap = op->map;	141	maptile *oldmap = op->map;
197	object *tmp;	142	object *tmp;
198		143
199	tmp = get_object ();	144	tmp = object::create ();
200		145
201	EXIT_PATH (tmp) = op->contr->savebed_map;	146	EXIT_PATH (tmp) = op->contr->savebed_map;
202	EXIT_X (tmp) = op->contr->bed_x;	147	EXIT_X (tmp) = op->contr->bed_x;
203	EXIT_Y (tmp) = op->contr->bed_y;	148	EXIT_Y (tmp) = op->contr->bed_y;
204	enter_exit (op, tmp);	149	op->enter_exit (tmp);
		150
205	/* If the player has not changed maps and the name does not match	151	/* 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	152	* that of the savebed, his savebed map is gone. Lets go back
207	* to the emergency path. Update what the players savebed is	153	* to the emergency path. Update what the players savebed is
208	* while we're at it.	154	* while we're at it.
209	*/	155	*/
		156	//TODO: must go - move to interim map
210	if (oldmap == op->map && strcmp (op->contr->savebed_map, oldmap->path))	157	if (oldmap == op->map && strcmp (op->contr->savebed_map, oldmap->path))
211	{	158	{
212	LOG (llevDebug, "Player %s savebed location %s is invalid - going to emergency location (%s)\n",	159	LOG (llevDebug, "Player %s savebed location %s is invalid - going to emergency location\n",
213	settings.emergency_mapname, &op->name, op->contr->savebed_map);	160	&op->name, op->contr->savebed_map);
214	strcpy (op->contr->savebed_map, settings.emergency_mapname);	161	strcpy (op->contr->savebed_map, "/world/world_105_115");
215	op->contr->bed_x = settings.emergency_x;	162	op->contr->bed_x = 5;
216	op->contr->bed_y = settings.emergency_y;	163	op->contr->bed_y = 37;
217	EXIT_PATH (tmp) = op->contr->savebed_map;	164	EXIT_PATH (tmp) = op->contr->savebed_map;
218	EXIT_X (tmp) = op->contr->bed_x;	165	EXIT_X (tmp) = op->contr->bed_x;
219	EXIT_Y (tmp) = op->contr->bed_y;	166	EXIT_Y (tmp) = op->contr->bed_y;
220	enter_exit (op, tmp);	167	op->enter_exit (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	mapstruct *oldmap = op->map;
232
233	remove_ob (op);
234
235	if (oldmap)
236	{	168	}
237	if (!op->contr->hidden)	169
238	oldmap->players--;	170	tmp->destroy ();
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	}	171	}
245		172
246	/*	173	/*
247	* enter_map(): Moves the player and pets from current map (if any) to	174	* 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	175	* 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	176	* 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	177	* whatever reason. If default map coordinates are to be used, then
251	* the function that calls this should figure them out.	178	* the function that calls this should figure them out.
252	*/	179	*/
253	static void	180	void
254	enter_map (object op, mapstruct newmap, int x, int y)	181	object::enter_map (maptile *newmap, int x, int y)
255	{	182	{
256	mapstruct *oldmap = op->map;	183	if (!newmap->load ())
		184	return;
257		185
258	if (out_of_map (newmap, x, y))	186	if (out_of_map (newmap, x, y))
259	{	187	{
260	LOG (llevError, "enter_map: supplied coordinates are not within the map! (%s: %d, %d)\n", newmap->path, x, y);	188	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);	189	x = newmap->enter_x;
262	y = MAP_ENTER_Y (newmap);	190	y = newmap->enter_y;
263	if (out_of_map (newmap, x, y))	191	if (out_of_map (newmap, x, y))
264	{	192	{
265	LOG (llevError, "enter_map: map %s provides invalid default enter location (%d, %d) > (%d, %d)\n",	193	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));	194	&newmap->path, x, y, newmap->width, newmap->height);
267	new_draw_info (NDI_UNIQUE, 0, op, "The exit is closed");	195	new_draw_info (NDI_UNIQUE, 0, this, "The exit is closed");
268	return;	196	return;
269	}	197	}
270	}	198	}
		199
271	/* try to find a spot for the player */	200	/* try to find a spot for the player */
272	if (ob_blocked (op, newmap, x, y))	201	if (ob_blocked (this, newmap, x, y))
273	{ /* First choice blocked */	202	{ /* First choice blocked */
274	/* We try to find a spot for the player, starting closest in.	203	/* We try to find a spot for the player, starting closest in.
275	* We could use find_first_free_spot, but that doesn't randomize it at all,	204	* We could use find_first_free_spot, but that doesn't randomize it at all,
276	* So for example, if the north space is free, you would always end up there even	205	* So for example, if the north space is free, you would always end up there even
277	* if other spaces around are available.	206	* if other spaces around are available.
278	* Note that for the second and third calls, we could start at a position other	207	* Note that for the second and third calls, we could start at a position other
279	* than one, but then we could end up on the other side of walls and so forth.	208	* than one, but then we could end up on the other side of walls and so forth.
280	*/	209	*/
281	int i = find_free_spot (op, newmap, x, y, 1, SIZEOFFREE1 + 1);	210	int i = find_free_spot (this, newmap, x, y, 1, SIZEOFFREE1 + 1);
282		211
283	if (i == -1)	212	if (i == -1)
284	{	213	{
285	i = find_free_spot (op, newmap, x, y, 1, SIZEOFFREE2 + 1);	214	i = find_free_spot (this, newmap, x, y, 1, SIZEOFFREE2 + 1);
286	if (i == -1)	215	if (i == -1)
287	i = find_free_spot (op, newmap, x, y, 1, SIZEOFFREE);	216	i = find_free_spot (this, newmap, x, y, 1, SIZEOFFREE);
288	}	217	}
		218
289	if (i != -1)	219	if (i != -1)
290	{	220	{
291	x += freearr_x[i];	221	x += freearr_x[i];
292	y += freearr_y[i];	222	y += freearr_y[i];
293	}	223	}
294	else	224	else
295	{
296	/* not much we can do in this case. */	225	/* not much we can do in this case. */
297	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);	226	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);
298	}
299	} /* end if looking for free spot */
300
301	if (op->map != NULL)
302	{	227	}
303	INVOKE_PLAYER (MAP_CHANGE, op->contr, ARG_MAP (op->map), ARG_MAP (newmap));	228
		229	if (map)
304	INVOKE_MAP (LEAVE, op->map, ARG_PLAYER (op->contr));	230	if (INVOKE_MAP (LEAVE, map, ARG_PLAYER (contr)))
305	}	231	return;
		232
		233	if (INVOKE_PLAYER (MAP_CHANGE, contr, ARG_MAP (newmap), ARG_INT (x), ARG_INT (y)))
		234	return;
		235
		236	if (INVOKE_MAP (ENTER, newmap, ARG_PLAYER (contr), ARG_INT (x), ARG_INT (y)))
		237	return;
306		238
307	/* If it is a player login, he has yet to be inserted anyplace.	239	/* If it is a player login, he has yet to be inserted anyplace.
308	* otherwise, we need to deal with removing the player here.	240	* otherwise, we need to deal with removing the player here.
309	*/	241	*/
310	if (!QUERY_FLAG (op, FLAG_REMOVED))
311	remove_ob (op);	242	remove ();
312		243
313	/* remove_ob clears these so they must be reset after the remove_ob call */
314	op->x = x;	244	this->x = x;
315	op->y = y;	245	this->y = y;
316	op->map = newmap;	246	map = newmap;
		247
317	insert_ob_in_map (op, op->map, NULL, INS_NO_WALK_ON);	248	insert_ob_in_map (this, map, 0, INS_NO_WALK_ON);
318
319	INVOKE_MAP (ENTER, op->map, ARG_PLAYER (op->contr));
320
321	if (!op->contr->hidden)
322	newmap->players++;
323		249
324	newmap->timeout = 0;	250	newmap->timeout = 0;
325	op->enemy = NULL;	251	enemy = NULL;
326		252
327	if (op->contr)	253	if (contr)
328	{	254	{
329	strcpy (op->contr->maplevel, newmap->path);	255	strcpy (contr->maplevel, newmap->path);
330	op->contr->count = 0;	256	contr->count = 0;
331	}	257	}
332		258
333	/* Update any golems */	259	/* Update any golems */
334	if (op->type == PLAYER && op->contr->ranges[range_golem] != NULL)	260	if (type == PLAYER && contr->ranges[range_golem])
335	{	261	{
336	int i = find_free_spot (op->contr->ranges[range_golem], newmap,	262	int i = find_free_spot (contr->ranges[range_golem], newmap,
337	x, y, 1, SIZEOFFREE);	263	x, y, 1, SIZEOFFREE);
338		264
339	remove_ob (op->contr->ranges[range_golem]);	265	contr->ranges[range_golem]->remove ();
		266
340	if (i == -1)	267	if (i == -1)
341	{	268	{
342	remove_friendly_object (op->contr->ranges[range_golem]);	269	remove_friendly_object (contr->ranges[range_golem]);
343	free_object (op->contr->ranges[range_golem]);	270	contr->ranges[range_golem]->destroy ();
344	op->contr->ranges[range_golem] = NULL;	271	contr->ranges[range_golem] = 0;
345	op->contr->golem_count = 0;
346	}	272	}
347	else	273	else
348	{	274	{
349	object *tmp;
350
351	for (tmp = op->contr->ranges[range_golem]; tmp != NULL; tmp = tmp->more)	275	for (object *tmp = contr->ranges[range_golem]; tmp != NULL; tmp = tmp->more)
352	{	276	{
353	tmp->x = x + freearr_x[i] + (tmp->arch == NULL ? 0 : tmp->arch->clone.x);	277	tmp->x = x + freearr_x[i] + (tmp->arch == NULL ? 0 : tmp->arch->clone.x);
354	tmp->y = y + freearr_y[i] + (tmp->arch == NULL ? 0 : tmp->arch->clone.y);	278	tmp->y = y + freearr_y[i] + (tmp->arch == NULL ? 0 : tmp->arch->clone.y);
355	tmp->map = newmap;	279	tmp->map = newmap;
356	}	280	}
		281
357	insert_ob_in_map (op->contr->ranges[range_golem], newmap, NULL, 0);	282	insert_ob_in_map (contr->ranges[range_golem], newmap, NULL, 0);
358	op->contr->ranges[range_golem]->direction =	283	contr->ranges[range_golem]->direction =
359	find_dir_2 (op->x - op->contr->ranges[range_golem]->x, op->y - op->contr->ranges[range_golem]->y);	284	find_dir_2 (x - contr->ranges[range_golem]->x, y - contr->ranges[range_golem]->y);
360	}	285	}
361	}	286	}
		287
362	op->direction = 0;	288	direction = 0;
363		289
364	/* since the players map is already loaded, we don't need to worry	290	/* since the players map is already loaded, we don't need to worry
365	* about pending objects.	291	* about pending objects.
366	*/	292	*/
367	remove_all_pets (newmap);	293	remove_all_pets (newmap);
368
369	/* If the player is changing maps, we need to do some special things
370	* Do this after the player is on the new map - otherwise the force swap of the
371	* old map does not work.
372	*/
373	if (oldmap != newmap)
374	{
375	if (oldmap) /* adjust old map */
376	{
377	oldmap->players--;
378
379	if (oldmap->players <= 0) /* can be less than zero due to errors in tracking this */
380	set_map_timeout (oldmap);
381	}
382	}
383	}	294	}
384
385	void
386	set_map_timeout (mapstruct *oldmap)
387	{
388	#if MAP_MAXTIMEOUT
389	oldmap->timeout = MAP_TIMEOUT (oldmap);
390	/* Do MINTIMEOUT first, so that MAXTIMEOUT is used if that is
391	* lower than the min value.
392	*/
393	# if MAP_MINTIMEOUT
394	if (oldmap->timeout < MAP_MINTIMEOUT)
395	{
396	oldmap->timeout = MAP_MINTIMEOUT;
397	}
398	# endif
399	if (oldmap->timeout > MAP_MAXTIMEOUT)
400	{
401	oldmap->timeout = MAP_MAXTIMEOUT;
402	}
403	#else
404	/* save out the map */
405	swap_map (oldmap);
406	#endif /* MAP_MAXTIMEOUT */
407	}
408
409		295
410	/* clean_path takes a path and replaces all / with _	296	/* clean_path takes a path and replaces all / with _
411	* We do a strcpy so that we do not change the original string.	297	* We do a strcpy so that we do not change the original string.
412	*/	298	*/
413	char *	299	char *
…		…
420	if (*cp == '/')	306	if (*cp == '/')
421	*cp = '_';	307	*cp = '_';
422		308
423	return newpath;	309	return newpath;
424	}	310	}
425
426		311
427	/* unclean_path takes a path and replaces all _ with /	312	/* unclean_path takes a path and replaces all _ with /
428	* This basically undoes clean path.	313	* This basically undoes clean path.
429	* We do a strcpy so that we do not change the original string.	314	* We do a strcpy so that we do not change the original string.
430	* We are smart enough to start after the last / in case we	315	* We are smart enough to start after the last / in case we
…		…
444	*cp = '/';	329	*cp = '/';
445		330
446	return newpath;	331	return newpath;
447	}	332	}
448		333
449
450	/* The player is trying to enter a randomly generated map. In this case, generate the
451	* random map as needed.
452	*/
453
454	static void
455	enter_random_map (object pl, object exit_ob)
456	{
457	mapstruct *new_map;
458	char newmap_name[HUGE_BUF], *cp;
459	static int reference_number = 0;
460	RMParms rp;
461
462	memset (&rp, 0, sizeof (RMParms));
463	rp.Xsize = -1;
464	rp.Ysize = -1;
465	rp.region = get_region_by_map (exit_ob->map);
466	if (exit_ob->msg)
467	set_random_map_variable (&rp, exit_ob->msg);
468	rp.origin_x = exit_ob->x;
469	rp.origin_y = exit_ob->y;
470	strcpy (rp.origin_map, pl->map->path);
471
472	/* If we have a final_map, use it as a base name to give some clue
473	* as where the player is. Otherwise, use the origin map.
474	* Take the last component (after the last slash) to give
475	* shorter names without bogus slashes.
476	*/
477	if (rp.final_map[0])
478	{
479	cp = strrchr (rp.final_map, '/');
480	if (!cp)
481	cp = rp.final_map;
482	}
483	else
484	{
485	char buf[HUGE_BUF];
486
487	cp = strrchr (rp.origin_map, '/');
488	if (!cp)
489	cp = rp.origin_map;
490	/* Need to strip of any trailing digits, if it has them */
491	strcpy (buf, cp);
492	while (isdigit (buf[strlen (buf) - 1]))
493	buf[strlen (buf) - 1] = 0;
494	cp = buf;
495	}
496
497	sprintf (newmap_name, "/random/%s%04d", cp + 1, reference_number++);
498
499	/* now to generate the actual map. */
500	new_map = generate_random_map (newmap_name, &rp);
501
502	/* Update the exit_ob so it now points directly at the newly created
503	* random maps. Not that it is likely to happen, but it does mean that a
504	* exit in a unique map leading to a random map will not work properly.
505	* It also means that if the created random map gets reset before
506	* the exit leading to it, that the exit will no longer work.
507	*/
508	if (new_map)
509	{
510	int x, y;
511
512	x = EXIT_X (exit_ob) = MAP_ENTER_X (new_map);
513	y = EXIT_Y (exit_ob) = MAP_ENTER_Y (new_map);
514	EXIT_PATH (exit_ob) = newmap_name;
515	strcpy (new_map->path, newmap_name);
516	enter_map (pl, new_map, x, y);
517	}
518	}
519
520	/* The player is trying to enter a non-randomly generated template map. In this
521	* case, use a map file for a template
522	*/
523
524	static void
525	enter_fixed_template_map (object pl, object exit_ob)
526	{
527	mapstruct *new_map;
528	char tmpnum[32], exitpath[HUGE_BUF], resultname[HUGE_BUF], tmpstring[HUGE_BUF], *sourcemap;
529	const char *new_map_name;
530
531	/* Split the exit path string into two parts, one
532	* for where to store the map, and one for were
533	* to generate the map from.
534	*/
535	snprintf (exitpath, sizeof (exitpath), "%s", EXIT_PATH (exit_ob) + 2);
536	sourcemap = strchr (exitpath, '!');
537	if (!sourcemap)
538	{
539	new_draw_info_format (NDI_UNIQUE, 0, pl, "The %s is closed.", &exit_ob->name);
540	/* Should only occur when no source map is set.
541	*/
542	LOG (llevError, "enter_fixed_template_map: Exit %s (%d,%d) on map %s has no source template.\n",
543	&exit_ob->name, exit_ob->x, exit_ob->y, exit_ob->map->path);
544	return;
545	}
546	*sourcemap++ = '\0';
547
548	/* If we are not coming from a template map, we can use relative directories
549	* for the map to generate from.
550	*/
551	if (!exit_ob->map->templatemap)
552	{
553	sourcemap = path_combine_and_normalize (exit_ob->map->path, sourcemap);
554	}
555
556	/* Do replacement of %x, %y, and %n to the x coord of the exit, the y coord
557	* of the exit, and the name of the map the exit is on, respectively.
558	*/
559	sprintf (tmpnum, "%d", exit_ob->x);
560	replace (exitpath, "%x", tmpnum, resultname, sizeof (resultname));
561
562	sprintf (tmpnum, "%d", exit_ob->y);
563	sprintf (tmpstring, "%s", resultname);
564	replace (tmpstring, "%y", tmpnum, resultname, sizeof (resultname));
565
566	sprintf (tmpstring, "%s", resultname);
567	replace (tmpstring, "%n", exit_ob->map->name, resultname, sizeof (resultname));
568
569	/* If we are coming from another template map, use reletive paths unless
570	* indicated otherwise.
571	*/
572	if (exit_ob->map->templatemap && (resultname[0] != '/'))
573	{
574	new_map_name = path_combine_and_normalize (exit_ob->map->path, resultname);
575	}
576	else
577	{
578	new_map_name = create_template_pathname (resultname);
579	}
580
581	/* Attempt to load the map, if unable to, then
582	* create the map from the template.
583	*/
584	new_map = ready_map_name (new_map_name, MAP_PLAYER_UNIQUE);
585	if (!new_map)
586	{
587	new_map = load_original_map (create_pathname (sourcemap), MAP_PLAYER_UNIQUE);
588	if (new_map)
589	fix_auto_apply (new_map);
590	}
591
592	if (new_map)
593	{
594	/* set the path of the map to where it should be
595	* so we don't just save over the source map.
596	*/
597	strcpy (new_map->path, new_map_name);
598	new_map->templatemap = 1;
599	enter_map (pl, new_map, EXIT_X (exit_ob), EXIT_Y (exit_ob));
600	}
601	else
602	{
603	new_draw_info_format (NDI_UNIQUE, 0, pl, "The %s is closed.", &exit_ob->name);
604	/* Should only occur when an invalid source map is set.
605	*/
606	LOG (llevDebug, "enter_fixed_template_map: Exit %s (%d,%d) on map %s leads no where.\n",
607	&exit_ob->name, exit_ob->x, exit_ob->y, exit_ob->map->path);
608	}
609	}
610
611
612	/* The player is trying to enter a randomly generated template map. In this
613	* case, generate the map as needed.
614	*/
615
616	static void
617	enter_random_template_map (object pl, object exit_ob)
618	{
619	mapstruct *new_map;
620	char tmpnum[32], resultname[HUGE_BUF], tmpstring[HUGE_BUF];
621	const char *new_map_name;
622	RMParms rp;
623
624	/* Do replacement of %x, %y, and %n to the x coord of the exit, the y coord
625	* of the exit, and the name of the map the exit is on, respectively.
626	*/
627	sprintf (tmpnum, "%d", exit_ob->x);
628	replace (EXIT_PATH (exit_ob) + 3, "%x", tmpnum, resultname, sizeof (resultname));
629
630	sprintf (tmpnum, "%d", exit_ob->y);
631	sprintf (tmpstring, "%s", resultname);
632	replace (tmpstring, "%y", tmpnum, resultname, sizeof (resultname));
633
634	sprintf (tmpstring, "%s", resultname);
635	replace (tmpstring, "%n", exit_ob->map->name, resultname, sizeof (resultname));
636
637	/* If we are coming from another template map, use reletive paths unless
638	* indicated otherwise.
639	*/
640	if (exit_ob->map->templatemap && (resultname[0] != '/'))
641	{
642	new_map_name = path_combine_and_normalize (exit_ob->map->path, resultname);
643	}
644	else
645	{
646	new_map_name = create_template_pathname (resultname);
647	}
648
649	new_map = ready_map_name (new_map_name, MAP_PLAYER_UNIQUE);
650	if (!new_map)
651	{
652	memset (&rp, 0, sizeof (RMParms));
653	rp.Xsize = -1;
654	rp.Ysize = -1;
655	rp.region = get_region_by_map (exit_ob->map);
656	if (exit_ob->msg)
657	set_random_map_variable (&rp, exit_ob->msg);
658	rp.origin_x = exit_ob->x;
659	rp.origin_y = exit_ob->y;
660	strcpy (rp.origin_map, pl->map->path);
661
662	/* now to generate the actual map. */
663	new_map = generate_random_map (new_map_name, &rp);
664	}
665
666
667	/* Update the exit_ob so it now points directly at the newly created
668	* random maps. Not that it is likely to happen, but it does mean that a
669	* exit in a unique map leading to a random map will not work properly.
670	* It also means that if the created random map gets reset before
671	* the exit leading to it, that the exit will no longer work.
672	*/
673	if (new_map)
674	{
675	int x, y;
676
677	x = EXIT_X (exit_ob) = MAP_ENTER_X (new_map);
678	y = EXIT_Y (exit_ob) = MAP_ENTER_Y (new_map);
679	new_map->templatemap = 1;
680	enter_map (pl, new_map, x, y);
681	}
682	}
683
684
685	/* Code to enter/detect a character entering a unique map.
686	*/
687	static void
688	enter_unique_map (object op, object exit_ob)
689	{
690	char apartment[HUGE_BUF];
691	mapstruct *newmap;
692
693	if (EXIT_PATH (exit_ob)[0] == '/')
694	{
695	sprintf (apartment, "%s/%s/%s/%s", settings.localdir, settings.playerdir, &op->name, clean_path (EXIT_PATH (exit_ob)));
696	newmap = ready_map_name (apartment, MAP_PLAYER_UNIQUE);
697	if (!newmap)
698	{
699	newmap = load_original_map (create_pathname (EXIT_PATH (exit_ob)), MAP_PLAYER_UNIQUE);
700	if (newmap)
701	fix_auto_apply (newmap);
702	}
703	}
704	else
705	{ /* relative directory */
706	char reldir[HUGE_BUF], tmpc[HUGE_BUF], *cp;
707
708	if (exit_ob->map->unique)
709	{
710
711	strcpy (reldir, unclean_path (exit_ob->map->path));
712
713	/* Need to copy this over, as clean_path only has one static return buffer */
714	strcpy (tmpc, clean_path (reldir));
715	/* Remove final component, if any */
716	if ((cp = strrchr (tmpc, '_')) != NULL)
717	*cp = 0;
718
719	sprintf (apartment, "%s/%s/%s/%s_%s", settings.localdir, settings.playerdir, &op->name, tmpc, clean_path (EXIT_PATH (exit_ob)));
720
721	newmap = ready_map_name (apartment, MAP_PLAYER_UNIQUE);
722	if (!newmap)
723	{
724	newmap = load_original_map (create_pathname (path_combine_and_normalize (reldir, EXIT_PATH (exit_ob))), MAP_PLAYER_UNIQUE);
725	if (newmap)
726	fix_auto_apply (newmap);
727	}
728	}
729	else
730	{
731	/* The exit is unique, but the map we are coming from is not unique. So
732	* use the basic logic - don't need to demangle the path name
733	*/
734	sprintf (apartment, "%s/%s/%s/%s", settings.localdir,
735	settings.playerdir, &op->name, clean_path (path_combine_and_normalize (exit_ob->map->path, EXIT_PATH (exit_ob))));
736	newmap = ready_map_name (apartment, MAP_PLAYER_UNIQUE);
737	if (!newmap)
738	{
739	newmap = ready_map_name (path_combine_and_normalize (exit_ob->map->path, EXIT_PATH (exit_ob)), 0);
740	if (newmap)
741	fix_auto_apply (newmap);
742	}
743	}
744	}
745
746	if (newmap)
747	{
748	strcpy (newmap->path, apartment);
749	newmap->unique = 1;
750	enter_map (op, newmap, EXIT_X (exit_ob), EXIT_Y (exit_ob));
751	}
752	else
753	{
754	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s is closed.", &exit_ob->name);
755	/* Perhaps not critical, but I would think that the unique maps
756	* should be new enough this does not happen. This also creates
757	* a strange situation where some players could perhaps have visited
758	* such a map before it was removed, so they have the private
759	* map, but other players can't get it anymore.
760	*/
761	LOG (llevDebug, "enter_unique_map: Exit %s (%d,%d) on map %s is leads no where.\n",
762	&exit_ob->name, exit_ob->x, exit_ob->y, exit_ob->map->path);
763	}
764
765	}
766
767
768	/* Tries to move 'op' to exit_ob. op is the character or monster that is
769	* using the exit, where exit_ob is the exit object (boat, door, teleporter,
770	* etc.) if exit_ob is null, then op->contr->maplevel contains that map to
771	* move the object to. This is used when loading the player.
772	*
773	* Largely redone by MSW 2001-01-21 - this function was overly complex
774	* and had some obscure bugs.
775	*/
776
777	void
778	enter_exit (object op, object exit_ob)
779	{
780	#define PORTAL_DESTINATION_NAME "Town portal destination" /* this one should really be in a header file */
781	object *tmp;
782
783	/* It may be nice to support other creatures moving across
784	* exits, but right now a lot of the code looks at op->contr,
785	* so thta is an RFE.
786	*/
787	if (op->type != PLAYER)
788	return;
789
790	/* First, lets figure out what map the player is going to go to */
791	if (exit_ob)
792	{
793
794	/* check to see if we make a template map */
795	if (EXIT_PATH (exit_ob) && EXIT_PATH (exit_ob)[1] == '@')
796	{
797	if (EXIT_PATH (exit_ob)[2] == '!')
798	{
799	/* generate a template map randomly */
800	enter_random_template_map (op, exit_ob);
801	}
802	else
803	{
804	/* generate a template map from a fixed template */
805	enter_fixed_template_map (op, exit_ob);
806	}
807	}
808	/* check to see if we make a randomly generated map */
809	else if (EXIT_PATH (exit_ob) && EXIT_PATH (exit_ob)[1] == '!')
810	{
811	enter_random_map (op, exit_ob);
812	}
813	else if (QUERY_FLAG (exit_ob, FLAG_UNIQUE))
814	{
815	enter_unique_map (op, exit_ob);
816	}
817	else
818	{
819	int x = EXIT_X (exit_ob), y = EXIT_Y (exit_ob);
820
821	/* 'Normal' exits that do not do anything special
822	* Simple enough we don't need another routine for it.
823	*/
824	mapstruct *newmap;
825
826	if (exit_ob->map)
827	{
828	newmap = ready_map_name (path_combine_and_normalize (exit_ob->map->path, EXIT_PATH (exit_ob)), 0);
829	/* Random map was previously generated, but is no longer about. Lets generate a new
830	* map.
831	*/
832	if (!newmap && !strncmp (EXIT_PATH (exit_ob), "/random/", 8))
833	{
834	/* Maps that go down have a message set. However, maps that go
835	* up, don't. If the going home has reset, there isn't much
836	* point generating a random map, because it won't match the maps.
837	*/
838	if (exit_ob->msg)
839	{
840	enter_random_map (op, exit_ob);
841	}
842	else
843	{
844	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s is closed.", &exit_ob->name);
845	return;
846	}
847
848	/* For exits that cause damages (like pits). Don't know if any
849	* random maps use this or not.
850	*/
851	if (exit_ob->stats.dam && op->type == PLAYER)
852	hit_player (op, exit_ob->stats.dam, exit_ob, exit_ob->attacktype, 1);
853	return;
854	}
855	}
856	else
857	{
858	/* For word of recall and other force objects
859	* They contain the full pathname of the map to go back to,
860	* so we don't need to normalize it.
861	* But we do need to see if it is unique or not
862	*/
863	if (!strncmp (EXIT_PATH (exit_ob), settings.localdir, strlen (settings.localdir)))
864	newmap = ready_map_name (EXIT_PATH (exit_ob), MAP_PLAYER_UNIQUE);
865	else
866	newmap = ready_map_name (EXIT_PATH (exit_ob), 0);
867	}
868	if (!newmap)
869	{
870	if (exit_ob->name)
871	new_draw_info_format (NDI_UNIQUE, 0, op, "The %s is closed.", &exit_ob->name);
872	/* don't cry to momma if name is not set - as in tmp objects
873	* used by the savebed code and character creation */
874	return;
875	}
876
877	/* This supports the old behaviour, but it really should not be used.
878	* I will note for example that with this method, it is impossible to
879	* set 0,0 destination coordinates. Really, if we want to support
880	* using the new maps default coordinates, the exit ob should use
881	* something like -1, -1 so it is clear to do that.
882	*/
883	if (x == 0 && y == 0)
884	{
885	x = MAP_ENTER_X (newmap);
886	y = MAP_ENTER_Y (newmap);
887	LOG (llevDebug, "enter_exit: Exit %s (%d,%d) on map %s is 0 destination coordinates\n",
888	&exit_ob->name, exit_ob->x, exit_ob->y, exit_ob->map ? exit_ob->map->path : "<nil>");
889	}
890
891	/* mids 02/13/2002 if exit is damned, update players death & WoR home-position and delete town portal */
892	if (QUERY_FLAG (exit_ob, FLAG_DAMNED))
893	{
894	/* remove an old force with a slaying field == PORTAL_DESTINATION_NAME */
895	for (tmp = op->inv; tmp != NULL; tmp = tmp->below)
896	{
897	if (tmp->type == FORCE && tmp->slaying && !strcmp (tmp->slaying, PORTAL_DESTINATION_NAME))
898	break;
899	}
900	if (tmp)
901	{
902	remove_ob (tmp);
903	free_object (tmp);
904	}
905
906	strcpy (op->contr->savebed_map, path_combine_and_normalize (exit_ob->map->path, EXIT_PATH (exit_ob)));
907	op->contr->bed_x = EXIT_X (exit_ob), op->contr->bed_y = EXIT_Y (exit_ob);
908	save_player (op, 1);
909	/* LOG(llevDebug,"enter_exit: Taking damned exit %s to (%d,%d) on map %s\n",
910	* exit_ob->name?exit_ob->name:"(none)", exit_ob->x, exit_ob->y,
911	* path_combine_and_normalize(exit_ob->map->path, EXIT_PATH(exit_ob))); */
912	}
913
914	enter_map (op, newmap, x, y);
915	}
916	/* For exits that cause damages (like pits) */
917	if (exit_ob->stats.dam && op->type == PLAYER)
918	hit_player (op, exit_ob->stats.dam, exit_ob, exit_ob->attacktype, 1);
919	}
920	else
921	{
922	int flags = 0;
923	mapstruct *newmap;
924
925
926	/* Hypothetically, I guess its possible that a standard map matches
927	* the localdir, but that seems pretty unlikely - unlikely enough that
928	* I'm not going to attempt to try to deal with that possibility.
929	* We use the fact that when a player saves on a unique map, it prepends
930	* the localdir to that name. So its an easy way to see of the map is
931	* unique or not.
932	*/
933	if (!strncmp (op->contr->maplevel, settings.localdir, strlen (settings.localdir)))
934	flags = MAP_PLAYER_UNIQUE;
935
936	/* newmap returns the map (if already loaded), or loads it for
937	* us.
938	*/
939	newmap = ready_map_name (op->contr->maplevel, flags);
940	if (!newmap)
941	{
942	LOG (llevError, "enter_exit: Pathname to map does not exist! (%s)\n", op->contr->maplevel);
943	newmap = ready_map_name (settings.emergency_mapname, 0);
944	op->x = settings.emergency_x;
945	op->y = settings.emergency_y;
946	/* If we can't load the emergency map, something is probably really
947	* screwed up, so bail out now.
948	*/
949	if (!newmap)
950	{
951	LOG (llevError, "enter_exit: could not load emergency map? Fatal error\n");
952	abort ();
953	}
954	}
955	enter_map (op, newmap, op->x, op->y);
956	}
957	}
958
959	/*
960	* process_active_maps(): Works like process_events(), but it only
961	* processes maps which a player is on.
962	*
963	*/
964
965	#if 0 // dead code, schmorp
966	void
967	process_active_maps ()
968	{
969	for (mapstruct *map = first_map; map != NULL; map = map->next)
970	if (map->in_memory == MAP_IN_MEMORY)
971	if (players_on_map (map, TRUE))
972	process_events (map);
973	}
974	#endif
975
976	/* process_players1 and process_players2 do all the player related stuff.	334	/* process_players1 and process_players2 do all the player related stuff.
977	* I moved it out of process events and process_map. This was to some	335	* I moved it out of process events and process_map. This was to some
978	* extent for debugging as well as to get a better idea of the time used	336	* extent for debugging as well as to get a better idea of the time used
979	* by the various functions. process_players1() does the processing before	337	* by the various functions. process_players1() does the processing before
980	* objects have been updated, process_players2() does the processing that	338	* objects have been updated, process_players2() does the processing that
981	* is needed after the players have been updated.	339	* is needed after the players have been updated.
982	*/	340	*/
983		341	static void
984	void	342	process_players1 ()
985	process_players1 (mapstruct *map)
986	{	343	{
987	int flag;	344	int flag;
988	player pl, plnext;
989		345
990	/* Basically, we keep looping until all the players have done their actions. */	346	/* Basically, we keep looping until all the players have done their actions. */
991	for (flag = 1; flag != 0;)	347	for (flag = 1; flag != 0;)
992	{	348	{
993	flag = 0;	349	flag = 0;
994	for (pl = first_player; pl != NULL; pl = plnext)	350	for_all_players (pl)
995	{	351	{
996	plnext = pl->next; /* In case a player exits the game in handle_player() */	352	pl->refcnt_chk ();
997		353
998	if (pl->ob == NULL)	354	if (!pl->ob \|\| !pl->ns)
999	continue;	355	continue;
1000		356
1001	if (map != NULL && pl->ob->map != map)
1002	continue;
1003
1004	if (pl->ob->speed_left > 0)	357	if (pl->ob->speed_left > 0)
1005	{
1006	if (handle_newcs_player (pl->ob))	358	if (handle_newcs_player (pl->ob))
1007	flag = 1;	359	flag = 1;
1008	} /* end if player has speed left */
1009		360
1010	/* If the player is not actively playing, don't make a	361	/* If the player is not actively playing, don't make a
1011	* backup save - nothing to save anyway. Plus, the	362	* backup save - nothing to save anyway. Plus, the
1012	* map may not longer be valid. This can happen when the	363	* map may not longer be valid. This can happen when the
1013	* player quits - they exist for purposes of tracking on the map,	364	* player quits - they exist for purposes of tracking on the map,
…		…
1018		369
1019	#ifdef AUTOSAVE	370	#ifdef AUTOSAVE
1020	/* check for ST_PLAYING state so that we don't try to save off when	371	/* check for ST_PLAYING state so that we don't try to save off when
1021	* the player is logging in.	372	* the player is logging in.
1022	*/	373	*/
1023	if ((pl->last_save_tick + AUTOSAVE) < (uint32) pticks && pl->state == ST_PLAYING)	374	if ((pl->last_save_tick + AUTOSAVE) < (uint32) pticks && pl->ns->state == ST_PLAYING)
1024	{	375	{
1025	/* Don't save the player on unholy ground. Instead, increase the	376	pl->ob->contr->save ();
1026	* tick time so it will be about 10 seconds before we try and save
1027	* again.
1028	*/
1029	// if (get_map_flags(pl->ob->map, NULL, pl->ob->x, pl->ob->y, NULL, NULL) & P_NO_CLERIC) {
1030	// pl->last_save_tick += 100;
1031	// } else {
1032	save_player (pl->ob, 1);
1033	pl->last_save_tick = pticks;	377	pl->last_save_tick = pticks;
1034	// }
1035	}	378	}
1036	#endif	379	#endif
1037	} /* end of for loop for all the players */	380	} /* end of for loop for all the players */
1038	} /* for flag */	381	} /* for flag */
1039	for (pl = first_player; pl != NULL; pl = pl->next)	382
		383	for_all_players (pl)
1040	{	384	{
1041	if (map != NULL && (pl->ob == NULL \|\| pl->ob->map != map))	385	if (!pl->ob \|\| !pl->ns)
1042	continue;	386	continue;
		387
1043	if (settings.casting_time == TRUE)	388	if (settings.casting_time)
1044	{	389	{
1045	if (pl->ob->casting_time > 0)	390	if (pl->ob->casting_time > 0)
1046	{	391	{
1047	pl->ob->casting_time--;	392	pl->ob->casting_time--;
1048	pl->ob->start_holding = 1;	393	pl->ob->start_holding = 1;
1049	}	394	}
		395
1050	/* set spell_state so we can update the range in stats field */	396	/* set spell_state so we can update the range in stats field */
1051	if ((pl->ob->casting_time == 0) && (pl->ob->start_holding == 1))	397	if ((pl->ob->casting_time == 0) && (pl->ob->start_holding == 1))
1052	{
1053	pl->ob->start_holding = 0;	398	pl->ob->start_holding = 0;
1054	}	399	}
1055	}	400
1056	do_some_living (pl->ob);	401	do_some_living (pl->ob);
1057	/* draw(pl->ob); // updated in socket code */
1058	}	402	}
1059	}	403	}
1060		404
1061	void	405	static void
1062	process_players2 (mapstruct *map)	406	process_players2 ()
1063	{	407	{
1064	player *pl;
1065
1066	/* Then check if any players should use weapon-speed instead of speed */	408	/* Then check if any players should use weapon-speed instead of speed */
1067	for (pl = first_player; pl != NULL; pl = pl->next)	409	for_all_players (pl)
1068	{	410	{
1069	if (map != NULL)
1070	{
1071	if (pl->ob == NULL \|\| QUERY_FLAG (pl->ob, FLAG_REMOVED))
1072	continue;
1073	else if (pl->loading != NULL) /* Player is blocked */
1074	pl->ob->speed_left -= pl->ob->speed;
1075	if (pl->ob->map != map)
1076	continue;
1077	}
1078
1079	/* The code that did weapon_sp handling here was out of place -	411	/* The code that did weapon_sp handling here was out of place -
1080	* this isn't called until after the player has finished there	412	* this isn't called until after the player has finished there
1081	* actions, and is thus out of place. All we do here is bounds	413	* actions, and is thus out of place. All we do here is bounds
1082	* checking.	414	* checking.
1083	*/	415	*/
…		…
1089	/* This needs to be here - if the player is running, we need to	421	/* This needs to be here - if the player is running, we need to
1090	* clear this each tick, but new commands are not being received	422	* clear this each tick, but new commands are not being received
1091	* so execute_newserver_command() is never called	423	* so execute_newserver_command() is never called
1092	*/	424	*/
1093	pl->has_hit = 0;	425	pl->has_hit = 0;
1094
1095	}	426	}
1096	else if (pl->ob->speed_left > pl->ob->speed)	427	else if (pl->ob->speed_left > pl->ob->speed)
1097	pl->ob->speed_left = pl->ob->speed;	428	pl->ob->speed_left = pl->ob->speed;
1098	}	429	}
1099	}	430	}
1100		431
1101	void	432	void
1102	process_events (mapstruct *map)	433	process_events ()
1103	{	434	{
1104	object *op;	435	object *op;
1105	object *marker = get_object ();
1106	tag_t tag;
1107		436
		437	static object_ptr marker_;
		438
		439	if (!marker_)
		440	marker_ = object::create ();
		441
		442	object *marker = marker_;
		443
1108	process_players1 (map);	444	process_players1 ();
1109		445
1110	marker->active_next = active_objects;	446	marker->active_next = active_objects;
1111		447
1112	if (marker->active_next)	448	if (marker->active_next)
1113	marker->active_next->active_prev = marker;	449	marker->active_next->active_prev = marker;
1114		450
1115	marker->active_prev = NULL;	451	marker->active_prev = 0;
1116	active_objects = marker;	452	active_objects = marker;
1117		453
1118	while (marker->active_next)	454	while (marker->active_next)
1119	{	455	{
1120	op = marker->active_next;	456	op = marker->active_next;
1121	tag = op->count;
1122		457
1123	/* Move marker forward - swap op and marker */	458	/* Move marker forward - swap op and marker */
1124	op->active_prev = marker->active_prev;	459	op->active_prev = marker->active_prev;
1125		460
1126	if (op->active_prev)	461	if (op->active_prev)
…		…
1138		473
1139	/* Now process op */	474	/* Now process op */
1140	if (QUERY_FLAG (op, FLAG_FREED))	475	if (QUERY_FLAG (op, FLAG_FREED))
1141	{	476	{
1142	LOG (llevError, "BUG: process_events(): Free object on list\n");	477	LOG (llevError, "BUG: process_events(): Free object on list\n");
1143	op->speed = 0;	478	op->set_speed (0);
1144	update_ob_speed (op);
1145	continue;	479	continue;
1146	}	480	}
1147		481
1148	/* I've seen occasional crashes due to this - the object is removed,	482	/* I've seen occasional crashes due to this - the object is removed,
1149	* and thus the map it points to (last map it was on) may be bogus	483	* and thus the map it points to (last map it was on) may be bogus
…		…
1156	* around.	490	* around.
1157	*/	491	*/
1158	if (QUERY_FLAG (op, FLAG_REMOVED) && op->type != PLAYER && op->map && op->map->in_memory != MAP_IN_MEMORY)	492	if (QUERY_FLAG (op, FLAG_REMOVED) && op->type != PLAYER && op->map && op->map->in_memory != MAP_IN_MEMORY)
1159	{	493	{
1160	LOG (llevError, "BUG: process_events(): Removed object on list\n");	494	LOG (llevError, "BUG: process_events(): Removed object on list\n");
1161	dump_object (op);	495	char *dump = dump_object (op);
1162	LOG (llevError, errmsg);	496	LOG (llevError, dump);
1163	free_object (op);	497	free (dump);
		498	op->destroy ();
1164	continue;	499	continue;
1165	}	500	}
1166		501
1167	if (!op->speed)	502	if (!op->speed)
1168	{	503	{
1169	LOG (llevError, "BUG: process_events(): Object %s has no speed, " "but is on active list\n", &op->arch->name);	504	LOG (llevError, "BUG: process_events(): Object %s has no speed, "
1170	update_ob_speed (op);	505	"but is on active list\n", &op->arch->name);
		506	op->set_speed (0);
1171	continue;	507	continue;
1172	}	508	}
1173		509
1174	if (op->map == NULL && op->env == NULL && op->name && op->type != MAP && map == NULL)	510	if (op->map == NULL && op->env == NULL && op->name && op->type != MAP)
1175	{	511	{
1176	LOG (llevError, "BUG: process_events(): Object without map or " "inventory is on active list: %s (%d)\n", &op->name, op->count);	512	LOG (llevError, "BUG: process_events(): Object without map or "
		513	"inventory is on active list: %s (%d)\n", &op->name, op->count);
1177	op->speed = 0;	514	op->set_speed (0);
1178	update_ob_speed (op);
1179	continue;	515	continue;
1180	}	516	}
1181		517
1182	if (map != NULL && op->map != map)
1183	continue;
1184
1185	/* Animate the object. Bug of feature that andim_speed	518	/* Animate the object. Bug or feature that anim_speed
1186	* is based on ticks, and not the creatures speed?	519	* is based on ticks, and not the creatures speed?
1187	*/	520	*/
1188	if (op->anim_speed && op->last_anim >= op->anim_speed)	521	if (op->anim_speed && op->last_anim >= op->anim_speed)
1189	{	522	{
1190	if ((op->type == PLAYER) \|\| (op->type == MONSTER))	523	if ((op->type == PLAYER))
1191	animate_object (op, op->facing);	524	animate_object (op, op->facing);
1192	else	525	else
1193	animate_object (op, op->direction);	526	animate_object (op, op->direction);
1194		527
1195	op->last_anim = 1;	528	op->last_anim = 1;
…		…
1213	LOG (llevDebug, "process_events: calling process_object with removed object %s\n", op->name ? op->name : "null");	546	LOG (llevDebug, "process_events: calling process_object with removed object %s\n", op->name ? op->name : "null");
1214	}	547	}
1215	#endif	548	#endif
1216	--op->speed_left;	549	--op->speed_left;
1217	process_object (op);	550	process_object (op);
		551
1218	if (was_destroyed (op, tag))	552	if (op->destroyed ())
1219	continue;	553	continue;
1220	}	554	}
		555
1221	if (settings.casting_time == TRUE && op->casting_time > 0)	556	if (settings.casting_time == TRUE && op->casting_time > 0)
1222	op->casting_time--;	557	op->casting_time--;
		558
1223	if (op->speed_left <= 0)	559	if (op->speed_left <= 0)
1224	op->speed_left += FABS (op->speed);	560	op->speed_left += FABS (op->speed);
1225	}	561	}
1226		562
1227	/* Remove marker object from active list */	563	/* Remove marker object from active list */
1228	if (marker->active_prev != NULL)	564	if (marker->active_prev != NULL)
1229	marker->active_prev->active_next = NULL;	565	marker->active_prev->active_next = NULL;
1230	else	566	else
1231	active_objects = NULL;	567	active_objects = NULL;
1232		568
1233	process_players2 (map);	569	process_players2 ();
1234
1235	free_object (marker);
1236	}	570	}
1237		571
		572	/* clean up everything before exiting */
1238	void	573	void
1239	clean_tmp_files (void)	574	emergency_save ()
1240	{	575	{
1241	mapstruct m, next;	576	LOG (llevDebug, "emergency save begin.\n");
1242		577
1243	LOG (llevInfo, "Cleaning up...\n");	578	LOG (llevDebug, "saving players.\n");
		579	for_all_players (pl)
		580	pl->save (1);
1244		581
1245	/* We save the maps - it may not be intuitive why, but if there are unique	582	// for_all_players (pl)
1246	* items, we need to save the map so they get saved off. Perhaps we should	583	// if (pl->ob)
1247	* just make a special function that only saves the unique items.	584	// pl->ob->remove ();
1248	*/	585
1249	for (m = first_map; m != NULL; m = next)	586	LOG (llevDebug, "saving maps.\n");
		587	maptile::emergency_save ();
		588
		589	LOG (llevDebug, "saving book archive.\n");
		590	write_book_archive ();
		591
		592	LOG (llevDebug, "emergency save done.\n");
		593	}
		594
		595	/* clean up everything before exiting */
		596	void
		597	cleanup (bool make_core)
		598	{
		599	LOG (llevDebug, "cleanup begin.\n");
		600
		601	in_cleanup = true;
		602
		603	if (init_done)
		604	emergency_save ();
		605
		606	LOG (llevDebug, "running cleanup handlers.\n");
		607	INVOKE_GLOBAL (CLEANUP);
		608
		609	LOG (llevDebug, "cleanup done.\n");
		610
		611	if (make_core)
		612	abort ();
		613	else
		614	_exit (0);
		615	}
		616
		617	void
		618	leave (player *pl, int draw_exit)
		619	{
		620	if (pl)
1250	{	621	{
1251	next = m->next;	622	if (pl->ob->type != DEAD_OBJECT)
1252	if (m->in_memory == MAP_IN_MEMORY)
1253	{	623	{
1254	/* If we want to reuse the temp maps, swap it out (note that will also	624	/* If a hidden dm dropped connection do not create
1255	* update the log file. Otherwise, save the map (mostly for unique item	625	* inconsistencies by showing that they have left the game
1256	* stuff). Note that the clean_tmp_map is called after the end of
1257	* the for loop but is in the #else bracket. IF we are recycling the maps,
1258	* we certainly don't want the temp maps removed.
1259	*/	626	*/
1260		627	if (!(QUERY_FLAG (pl->ob, FLAG_WIZ) && pl->ob->contr->hidden)
1261	/* XXX The above comment is dead wrong */	628	&& draw_exit)
1262	if (settings.recycle_tmp_maps == TRUE)
1263	swap_map (m);
1264	else
1265	{	629	{
1266	new_save_map (m, 0); /* note we save here into a overlay map */	630	if (pl->ob->map)
1267	clean_tmp_map (m);	631	{
		632	INVOKE_PLAYER (LOGOUT, pl);
		633	LOG (llevInfo, "LOGOUT: Player named %s from ip %s\n", &pl->ob->name, pl->ns->host);
		634	}
		635
		636	char buf[MAX_BUF];
		637
		638	sprintf (buf, "%s left the game.", &pl->ob->name);
		639	new_draw_info (NDI_UNIQUE \| NDI_ALL \| NDI_DK_ORANGE, 5, 0, buf);
1268	}	640	}
1269	}
1270	}
1271	write_todclock (); /* lets just write the clock here */
1272	}
1273		641
1274	/* clean up everything before exiting */	642	pl->ob->remove ();
1275	void	643	pl->ob->type = DEAD_OBJECT; /* To avoid problems with inventory window */
1276	cleanup (void)	644	}
1277	{
1278	LOG (llevDebug, "Cleanup called. freeing data.\n");
1279	clean_tmp_files ();
1280	write_book_archive ();
1281	#ifdef MEMORY_DEBUG
1282	free_all_maps ();
1283	free_style_maps ();
1284	free_all_object_data ();
1285	free_all_archs ();
1286	free_all_treasures ();
1287	free_all_images ();
1288	free_all_newserver ();
1289	free_all_recipes ();
1290	free_all_readable ();
1291	free_all_god ();
1292	free_all_anim ();
1293	/* See what the string data that is out there that hasn't been freed. */
1294		645
1295	/* LOG(llevDebug, ss_dump_table(0xff));*/
1296	#endif
1297	exit (0);
1298	}
1299
1300	void
1301	leave (player *pl, int draw_exit)
1302	{
1303	if (pl != NULL)
1304	{
1305	/* We do this so that the socket handling routine can do the final	646	/* We do this so that the socket handling routine can do the final
1306	* cleanup. We also leave that loop to actually handle the freeing	647	* cleanup. We also leave that loop to actually handle the freeing
1307	* of the data.	648	* of the data.
1308	*/	649	*/
1309	if (pl->ob->type != DEAD_OBJECT)	650	if (pl->ns)
1310	{	651	pl->ns->destroy ();
1311	pl->socket.status = Ns_Dead;
1312		652
1313	/* If a hidden dm dropped connection do not create
1314	* inconsistencies by showing that they have left the game
1315	*/
1316	if (!(QUERY_FLAG (pl->ob, FLAG_WIZ) && pl->ob->contr->hidden)
1317	&& draw_exit && (pl->state != ST_GET_NAME && pl->state != ST_GET_PASSWORD && pl->state != ST_CONFIRM_PASSWORD))
1318	{
1319	if (pl->ob->map)
1320	{
1321	INVOKE_PLAYER (LOGOUT, pl);
1322	LOG (llevInfo, "LOGOUT: Player named %s from ip %s\n", &pl->ob->name, pl->socket.host);
1323	}
1324
1325	char buf[MAX_BUF];
1326
1327	sprintf (buf, "%s left the game.", &pl->ob->name);
1328	new_draw_info (NDI_UNIQUE \| NDI_ALL \| NDI_DK_ORANGE, 5, NULL, buf);
1329	}
1330
1331	if (!QUERY_FLAG (pl->ob, FLAG_REMOVED))
1332	leave_map (pl->ob);
1333
1334	pl->ob->type = DEAD_OBJECT; /* To avoid problems with inventory window */
1335	}
1336	}	653	}
1337	}	654	}
1338		655
1339	int	656	int
1340	forbid_play (void)	657	forbid_play (void)
…		…
1403	extern unsigned long todtick;	720	extern unsigned long todtick;
1404		721
1405	void	722	void
1406	do_specials (void)	723	do_specials (void)
1407	{	724	{
1408
1409	#ifdef WATCHDOG
1410	if (!(pticks % 503))
1411	watchdog ();
1412	#endif
1413
1414	if (!(pticks % PTICKS_PER_CLOCK))	725	if (!(pticks % PTICKS_PER_CLOCK))
1415	tick_the_clock ();	726	tick_the_clock ();
1416		727
1417	if (!(pticks % 7))	728	if (!(pticks % 7))
1418	shstr::gc ();	729	shstr::gc ();
1419		730
1420	if (!(pticks % 79))
1421	flush_old_maps (); /* Clears the tmp-files of maps which have reset */
1422
1423	if (!(pticks % 2503))	731	if (!(pticks % 2503))
1424	fix_weight (); /* Hack to fix weightproblems caused by bugs */	732	fix_weight (); /* Hack to fix weightproblems caused by bugs */
1425		733
1426	if (!(pticks % 2521))
1427	metaserver_update (); /* 2500 ticks is about 5 minutes */
1428
1429	if (!(pticks % 5003))	734	if (!(pticks % 5003))
1430	write_book_archive ();	735	write_book_archive ();
1431		736
1432	if (!(pticks % 5009))	737	if (!(pticks % 5009))
1433	clean_friendly_list ();	738	clean_friendly_list ();
…		…
1440	}	745	}
1441		746
1442	void	747	void
1443	server_tick ()	748	server_tick ()
1444	{	749	{
1445	nroferrors = 0;	750	// first do the user visible stuff
1446
1447	doeric_server ();	751	doeric_server ();
1448	INVOKE_GLOBAL (CLOCK);	752	INVOKE_GLOBAL (CLOCK);
1449	process_events (NULL); /* "do" something with objects with speed */	753	process_events (); /* "do" something with objects with speed */
1450	flush_sockets ();	754	flush_sockets ();
1451	check_active_maps (); /* Removes unused maps after a certain timeout */	755
		756	// then do some bookkeeping, should not really be here
1452	do_specials (); /* Routines called from time to time. */	757	do_specials (); /* Routines called from time to time. */
1453	object::free_mortals ();	758	attachable::check_mortals ();
1454		759
1455	++pticks;	760	++pticks;
1456	}	761	}
1457		762
1458	int	763	int
1459	main (int argc, char **argv)	764	main (int argc, char **argv)
1460	{	765	{
1461	settings.argc = argc;	766	settings.argc = argc;
1462	settings.argv = argv;	767	settings.argv = argv;
1463		768
1464	cfperl_init ();
1465
1466	init (argc, argv);	769	init (argc, argv);
1467		770
1468	initPlugins ();	771	initPlugins ();
1469		772
1470	for (;;)	773	for (;;)
1471	cfperl_main ();	774	cfperl_main ();
1472		775
1473	// unreached	776	// unreached
1474	emergency_save (0);
1475	cleanup ();	777	cleanup ();
1476		778
1477	return 0;	779	return 0;
1478	}	780	}

Diff Legend

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

Comparing deliantra/server/server/main.C (file contents): Revision 1.24 by root, Tue Sep 12 19:20:08 2006 UTC vs. Revision 1.62 by root, Sat Dec 30 10:16:11 2006 UTC

Diff Legend

Comparing deliantra/server/server/main.C (file contents):
Revision 1.24 by root, Tue Sep 12 19:20:08 2006 UTC vs.
Revision 1.62 by root, Sat Dec 30 10:16:11 2006 UTC