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

Diff Legend

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