ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/deliantra/server/server/main.C

Comparing deliantra/server/server/main.C (file contents):
Revision 1.18 by root, Sun Sep 3 09:00:09 2006 UTC vs.
Revision 1.175 by root, Mon Oct 29 23:55:55 2012 UTC

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

Diff Legend

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