ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/deliantra/server/common/map.C

Comparing deliantra/server/common/map.C (file contents):
Revision 1.29 by root, Sun Sep 10 16:00:23 2006 UTC vs.
Revision 1.74 by root, Sun Jan 14 23:35:03 2007 UTC

1
2	/*
3	* static char *rcsid_map_c =
4	* "$Id: map.C,v 1.29 2006/09/10 16:00:23 root Exp $";
5	*/
6
7	/*	1	/*
8	CrossFire, A Multiplayer game for X-windows	2	CrossFire, A Multiplayer game for X-windows
9		3
		4	Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
10	Copyright (C) 2001-2003 Mark Wedel & Crossfire Development Team	5	Copyright (C) 2001-2003 Mark Wedel & Crossfire Development Team
11	Copyright (C) 1992 Frank Tore Johansen	6	Copyright (C) 1992 Frank Tore Johansen
12		7
13	This program is free software; you can redistribute it and/or modify	8	This program is free software; you can redistribute it and/or modify
14	it under the terms of the GNU General Public License as published by	9	it under the terms of the GNU General Public License as published by
…		…
22		17
23	You should have received a copy of the GNU General Public License	18	You should have received a copy of the GNU General Public License
24	along with this program; if not, write to the Free Software	19	along with this program; if not, write to the Free Software
25	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	20	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26		21
27	The authors can be reached via e-mail at crossfire-devel@real-time.com	22	The authors can be reached via e-mail at <crossfire@schmorp.de>
28	*/	23	*/
29
30		24
31	#include <global.h>	25	#include <global.h>
32	#include <funcpoint.h>	26	#include <funcpoint.h>
33		27
34	#include <loader.h>	28	#include <loader.h>
35	#ifndef WIN32 /* ---win32 exclude header */
36	# include <unistd.h>	29	#include <unistd.h>
37	#endif /* win32 */
38		30
39	#include "path.h"	31	#include "path.h"
40
41
42	extern int nrofallocobjects, nroffreeobjects;
43
44	/*
45	* Returns the mapstruct which has a name matching the given argument.
46	* return NULL if no match is found.
47	*/
48
49	mapstruct *
50	has_been_loaded (const char *name)
51	{
52	mapstruct *map;
53
54	if (!name || !*name)
55	return 0;
56	for (map = first_map; map; map = map->next)
57	if (!strcmp (name, map->path))
58	break;
59	return (map);
60	}
61		32
62	/*	33	/*
63	* This makes a path absolute outside the world of Crossfire.	34	* This makes a path absolute outside the world of Crossfire.
64	* In other words, it prepends LIBDIR/MAPDIR/ to the given path	35	* In other words, it prepends LIBDIR/MAPDIR/ to the given path
65	* and returns the pointer to a static array containing the result.	36	* and returns the pointer to a static array containing the result.
66	* it really should be called create_mapname	37	* it really should be called create_mapname
67	*/	38	*/
68
69	const char *	39	const char *
70	create_pathname (const char *name)	40	create_pathname (const char *name)
71	{	41	{
72	static char buf[MAX_BUF];	42	static char buf[8192];
73
74	/* Why? having extra / doesn't confuse unix anyplace? Dependancies
75	* someplace else in the code? msw 2-17-97
76	*/
77	if (*name == '/')
78	sprintf (buf, "%s/%s%s", settings.datadir, settings.mapdir, name);
79	else
80	sprintf (buf, "%s/%s/%s", settings.datadir, settings.mapdir, name);	43	snprintf (buf, sizeof (buf), "%s/%s/%s", settings.datadir, settings.mapdir, name);
81	return (buf);	44	return buf;
82	}	45	}
83
84	/*
85	* same as create_pathname, but for the overlay maps.
86	*/
87
88	const char *
89	create_overlay_pathname (const char *name)
90	{
91	static char buf[MAX_BUF];
92
93	/* Why? having extra / doesn't confuse unix anyplace? Dependancies
94	* someplace else in the code? msw 2-17-97
95	*/
96	if (*name == '/')
97	sprintf (buf, "%s/%s%s", settings.localdir, settings.mapdir, name);
98	else
99	sprintf (buf, "%s/%s/%s", settings.localdir, settings.mapdir, name);
100	return (buf);
101	}
102
103	/*
104	* same as create_pathname, but for the template maps.
105	*/
106
107	const char *
108	create_template_pathname (const char *name)
109	{
110	static char buf[MAX_BUF];
111
112	/* Why? having extra / doesn't confuse unix anyplace? Dependancies
113	* someplace else in the code? msw 2-17-97
114	*/
115	if (*name == '/')
116	sprintf (buf, "%s/%s%s", settings.localdir, settings.templatedir, name);
117	else
118	sprintf (buf, "%s/%s/%s", settings.localdir, settings.templatedir, name);
119	return (buf);
120	}
121
122	/*
123	* This makes absolute path to the itemfile where unique objects
124	* will be saved. Converts '/' to '@'. I think it's essier maintain
125	* files than full directory structure, but if this is problem it can
126	* be changed.
127	*/
128	static const char *
129	create_items_path (const char *s)
130	{
131	static char buf[MAX_BUF];
132	char *t;
133
134	if (*s == '/')
135	s++;
136
137	sprintf (buf, "%s/%s/", settings.localdir, settings.uniquedir);
138
139	for (t = buf + strlen (buf); *s; s++, t++)
140	if (*s == '/')
141	*t = '@';
142	else
143	*t = *s;
144	*t = 0;
145	return (buf);
146	}
147
148		46
149	/*	47	/*
150	* This function checks if a file with the given path exists.	48	* This function checks if a file with the given path exists.
151	* -1 is returned if it fails, otherwise the mode of the file	49	* -1 is returned if it fails, otherwise the mode of the file
152	* is returned.	50	* is returned.
…		…
159	* the rest of the code only cares that the file is readable.	57	* the rest of the code only cares that the file is readable.
160	* when the editor goes away, the call to stat should probably be	58	* when the editor goes away, the call to stat should probably be
161	* replaced by an access instead (similar to the windows one, but	59	* replaced by an access instead (similar to the windows one, but
162	* that seems to be missing the prepend_dir processing	60	* that seems to be missing the prepend_dir processing
163	*/	61	*/
164
165	int	62	int
166	check_path (const char *name, int prepend_dir)	63	check_path (const char *name, int prepend_dir)
167	{	64	{
168	char buf[MAX_BUF];	65	char buf[MAX_BUF];
169		66
170	#ifndef WIN32
171	char *endbuf;	67	char *endbuf;
172	struct stat statbuf;	68	struct stat statbuf;
173	int mode = 0;	69	int mode = 0;
174	#endif
175		70
176	if (prepend_dir)	71	if (prepend_dir)
177	strcpy (buf, create_pathname (name));	72	strcpy (buf, create_pathname (name));
178	else	73	else
179	strcpy (buf, name);	74	strcpy (buf, name);
180	#ifdef WIN32 /* ***win32: check this sucker in windows style. */
181	return (_access (buf, 0));
182	#else
183		75
184	/* old method (strchr(buf, '\0')) seemd very odd to me -	76	/* old method (strchr(buf, '\0')) seemd very odd to me -
185	* this method should be equivalant and is clearer.	77	* this method should be equivalant and is clearer.
186	* Can not use strcat because we need to cycle through	78	* Can not use strcat because we need to cycle through
187	* all the names.	79	* all the names.
…		…
200	if ((statbuf.st_mode & S_IWGRP && getegid () == statbuf.st_gid) ||	92	if ((statbuf.st_mode & S_IWGRP && getegid () == statbuf.st_gid) ||
201	(statbuf.st_mode & S_IWUSR && geteuid () == statbuf.st_uid) || (statbuf.st_mode & S_IWOTH))	93	(statbuf.st_mode & S_IWUSR && geteuid () == statbuf.st_uid) || (statbuf.st_mode & S_IWOTH))
202	mode |= 2;	94	mode |= 2;
203		95
204	return (mode);	96	return (mode);
205	#endif
206	}
207
208	/*
209	* Prints out debug-information about a map.
210	* Dumping these at llevError doesn't seem right, but is
211	* necessary to make sure the information is in fact logged.
212	*/
213
214	void
215	dump_map (const mapstruct *m)
216	{
217	LOG (llevError, "Map %s status: %d.\n", m->path, m->in_memory);
218	LOG (llevError, "Size: %dx%d Start: %d,%d\n", MAP_WIDTH (m), MAP_HEIGHT (m), MAP_ENTER_X (m), MAP_ENTER_Y (m));
219
220	if (m->msg != NULL)
221	LOG (llevError, "Message:\n%s", m->msg);
222
223	if (m->maplore != NULL)
224	LOG (llevError, "Lore:\n%s", m->maplore);
225
226	if (m->tmpname != NULL)
227	LOG (llevError, "Tmpname: %s\n", m->tmpname);
228
229	LOG (llevError, "Difficulty: %d\n", m->difficulty);
230	LOG (llevError, "Darkness: %d\n", m->darkness);
231	}
232
233	/*
234	* Prints out debug-information about all maps.
235	* This basically just goes through all the maps and calls
236	* dump_map on each one.
237	*/
238
239	void
240	dump_all_maps (void)
241	{
242	mapstruct *m;
243
244	for (m = first_map; m != NULL; m = m->next)
245	{
246	dump_map (m);
247	}
248	}	97	}
249		98
250	/* This rolls up wall, blocks_magic, blocks_view, etc, all into	99	/* This rolls up wall, blocks_magic, blocks_view, etc, all into
251	* one function that just returns a P_.. value (see map.h)	100	* one function that just returns a P_.. value (see map.h)
252	* it will also do map translation for tiled maps, returning	101	* it will also do map translation for tiled maps, returning
…		…
256	* is needed. The case of not passing values is if we're just	105	* is needed. The case of not passing values is if we're just
257	* checking for the existence of something on those spaces, but	106	* checking for the existence of something on those spaces, but
258	* don't expect to insert/remove anything from those spaces.	107	* don't expect to insert/remove anything from those spaces.
259	*/	108	*/
260	int	109	int
261	get_map_flags (mapstruct *oldmap, mapstruct **newmap, sint16 x, sint16 y, sint16 * nx, sint16 * ny)	110	get_map_flags (maptile *oldmap, maptile **newmap, sint16 x, sint16 y, sint16 *nx, sint16 *ny)
262	{	111	{
263	sint16 newx, newy;	112	sint16 newx = x;
264	int retval = 0;	113	sint16 newy = y;
265	mapstruct *mp;
266		114
267	if (out_of_map (oldmap, x, y))	115	maptile *mp = get_map_from_coord (oldmap, &newx, &newy);
		116
		117	if (!mp)
268	return P_OUT_OF_MAP;	118	return P_OUT_OF_MAP;
269	newx = x;
270	newy = y;
271	mp = get_map_from_coord (oldmap, &newx, &newy);
272	if (mp != oldmap)
273	retval |= P_NEW_MAP;
274	if (newmap)
275	*newmap = mp;
276	if (nx)
277	*nx = newx;
278	if (ny)
279	*ny = newy;
280		119
281	retval |= mp->spaces[newx + mp->width * newy].flags;	120	if (newmap) *newmap = mp;
		121	if (nx) *nx = newx;
		122	if (ny) *ny = newy;
282		123
283	return retval;	124	return mp->at (newx, newy).flags () | (mp != oldmap ? P_NEW_MAP : 0);
284	}	125	}
285
286		126
287	/*	127	/*
288	* Returns true if the given coordinate is blocked except by the	128	* Returns true if the given coordinate is blocked except by the
289	* object passed is not blocking. This is used with	129	* object passed is not blocking. This is used with
290	* multipart monsters - if we want to see if a 2x2 monster	130	* multipart monsters - if we want to see if a 2x2 monster
…		…
294	* monster.	134	* monster.
295	* m, x, y are the target map/coordinates - needed for map tiling.	135	* m, x, y are the target map/coordinates - needed for map tiling.
296	* the coordinates & map passed in should have been updated for tiling	136	* the coordinates & map passed in should have been updated for tiling
297	* by the caller.	137	* by the caller.
298	*/	138	*/
299
300	int	139	int
301	blocked_link (object *ob, mapstruct *m, int sx, int sy)	140	blocked_link (object *ob, maptile *m, int sx, int sy)
302	{	141	{
303	object *tmp;	142	object *tmp;
304	int mflags, blocked;	143	int mflags, blocked;
305		144
306	/* Make sure the coordinates are valid - they should be, as caller should	145	/* Make sure the coordinates are valid - they should be, as caller should
…		…
313	}	152	}
314		153
315	/* Save some cycles - instead of calling get_map_flags(), just get the value	154	/* Save some cycles - instead of calling get_map_flags(), just get the value
316	* directly.	155	* directly.
317	*/	156	*/
318	mflags = m->spaces[sx + m->width * sy].flags;	157	mflags = m->at (sx, sy).flags ();
319		158
320	blocked = GET_MAP_MOVE_BLOCK (m, sx, sy);	159	blocked = GET_MAP_MOVE_BLOCK (m, sx, sy);
321		160
322	/* If space is currently not blocked by anything, no need to	161	/* If space is currently not blocked by anything, no need to
323	* go further. Not true for players - all sorts of special	162	* go further. Not true for players - all sorts of special
…		…
342	/* We basically go through the stack of objects, and if there is	181	/* We basically go through the stack of objects, and if there is
343	* some other object that has NO_PASS or FLAG_ALIVE set, return	182	* some other object that has NO_PASS or FLAG_ALIVE set, return
344	* true. If we get through the entire stack, that must mean	183	* true. If we get through the entire stack, that must mean
345	* ob is blocking it, so return 0.	184	* ob is blocking it, so return 0.
346	*/	185	*/
347	for (tmp = GET_MAP_OB (m, sx, sy); tmp != NULL; tmp = tmp->above)	186	for (tmp = GET_MAP_OB (m, sx, sy); tmp; tmp = tmp->above)
348	{	187	{
349		188
350	/* This must be before the checks below. Code for inventory checkers. */	189	/* This must be before the checks below. Code for inventory checkers. */
351	if (tmp->type == CHECK_INV && OB_MOVE_BLOCK (ob, tmp))	190	if (tmp->type == CHECK_INV && OB_MOVE_BLOCK (ob, tmp))
352	{	191	{
…		…
416	*	255	*
417	* Note this used to be arch_blocked, but with new movement	256	* Note this used to be arch_blocked, but with new movement
418	* code, we need to have actual object to check its move_type	257	* code, we need to have actual object to check its move_type
419	* against the move_block values.	258	* against the move_block values.
420	*/	259	*/
421
422	int	260	int
423	ob_blocked (const object *ob, mapstruct *m, sint16 x, sint16 y)	261	ob_blocked (const object *ob, maptile *m, sint16 x, sint16 y)
424	{	262	{
425	archetype *tmp;	263	archetype *tmp;
426	int flag;	264	int flag;
427	mapstruct *m1;	265	maptile *m1;
428	sint16 sx, sy;	266	sint16 sx, sy;
429		267
430	if (ob == NULL)	268	if (!ob)
431	{	269	{
432	flag = get_map_flags (m, &m1, x, y, &sx, &sy);	270	flag = get_map_flags (m, &m1, x, y, &sx, &sy);
433	if (flag & P_OUT_OF_MAP)	271	if (flag & P_OUT_OF_MAP)
434	return P_OUT_OF_MAP;	272	return P_OUT_OF_MAP;
435		273
436	/* don't have object, so don't know what types would block */	274	/* don't have object, so don't know what types would block */
437	return (GET_MAP_MOVE_BLOCK (m1, sx, sy));	275	return m1->at (sx, sy).move_block;
438	}	276	}
439		277
440	for (tmp = ob->arch; tmp != NULL; tmp = tmp->more)	278	for (tmp = ob->arch; tmp; tmp = tmp->more)
441	{	279	{
442	flag = get_map_flags (m, &m1, x + tmp->clone.x, y + tmp->clone.y, &sx, &sy);	280	flag = get_map_flags (m, &m1, x + tmp->clone.x, y + tmp->clone.y, &sx, &sy);
443		281
444	if (flag & P_OUT_OF_MAP)	282	if (flag & P_OUT_OF_MAP)
445	return P_OUT_OF_MAP;	283	return P_OUT_OF_MAP;
446	if (flag & P_IS_ALIVE)	284	if (flag & P_IS_ALIVE)
447	return P_IS_ALIVE;	285	return P_IS_ALIVE;
448		286
		287	mapspace &ms = m1->at (sx, sy);
		288
449	/* find_first_free_spot() calls this function. However, often	289	/* find_first_free_spot() calls this function. However, often
450	* ob doesn't have any move type (when used to place exits)	290	* ob doesn't have any move type (when used to place exits)
451	* so the AND operation in OB_TYPE_MOVE_BLOCK doesn't work.	291	* so the AND operation in OB_TYPE_MOVE_BLOCK doesn't work.
452	*/	292	*/
453		293
454	if (ob->move_type == 0 && GET_MAP_MOVE_BLOCK (m1, sx, sy) != MOVE_ALL)	294	if (ob->move_type == 0 && ms.move_block != MOVE_ALL)
455	continue;	295	continue;
456		296
457	/* Note it is intentional that we check ob - the movement type of the	297	/* Note it is intentional that we check ob - the movement type of the
458	* head of the object should correspond for the entire object.	298	* head of the object should correspond for the entire object.
459	*/	299	*/
460	if (OB_TYPE_MOVE_BLOCK (ob, GET_MAP_MOVE_BLOCK (m1, sx, sy)))	300	if (OB_TYPE_MOVE_BLOCK (ob, ms.move_block))
461	return AB_NO_PASS;	301	return P_NO_PASS;
462
463	}	302	}
		303
464	return 0;	304	return 0;
465	}	305	}
466		306
467	/* When the map is loaded, load_object does not actually insert objects	307	/* When the map is loaded, load_object does not actually insert objects
468	* into inventory, but just links them. What this does is go through	308	* into inventory, but just links them. What this does is go through
469	* and insert them properly.	309	* and insert them properly.
470	* The object 'container' is the object that contains the inventory.	310	* The object 'container' is the object that contains the inventory.
471	* This is needed so that we can update the containers weight.	311	* This is needed so that we can update the containers weight.
472	*/	312	*/
473
474	void	313	void
475	fix_container (object *container)	314	fix_container (object *container)
476	{	315	{
477	object *tmp = container->inv, *next;	316	object *tmp = container->inv, *next;
478		317
479	container->inv = NULL;	318	container->inv = 0;
480	while (tmp != NULL)	319	while (tmp)
481	{	320	{
482	next = tmp->below;	321	next = tmp->below;
483	if (tmp->inv)	322	if (tmp->inv)
484	fix_container (tmp);	323	fix_container (tmp);
		324
485	(void) insert_ob_in_ob (tmp, container);	325	insert_ob_in_ob (tmp, container);
486	tmp = next;	326	tmp = next;
487	}	327	}
		328
488	/* sum_weight will go through and calculate what all the containers are	329	/* sum_weight will go through and calculate what all the containers are
489	* carrying.	330	* carrying.
490	*/	331	*/
491	sum_weight (container);	332	sum_weight (container);
		333	}
		334
		335	void
		336	maptile::set_object_flag (int flag, int value)
		337	{
		338	if (!spaces)
		339	return;
		340
		341	for (mapspace *ms = spaces + size (); ms-- > spaces; )
		342	for (object *tmp = ms->bot; tmp; tmp = tmp->above)
		343	tmp->flag [flag] = value;
492	}	344	}
493		345
494	/* link_multipart_objects go through all the objects on the map looking	346	/* link_multipart_objects go through all the objects on the map looking
495	* for objects whose arch says they are multipart yet according to the	347	* for objects whose arch says they are multipart yet according to the
496	* info we have, they only have the head (as would be expected when	348	* info we have, they only have the head (as would be expected when
497	* they are saved). We do have to look for the old maps that did save	349	* they are saved). We do have to look for the old maps that did save
498	* the more sections and not re-add sections for them.	350	* the more sections and not re-add sections for them.
499	*/	351	*/
500		352	void
501	static void	353	maptile::link_multipart_objects ()
502	link_multipart_objects (mapstruct *m)
503	{	354	{
504	int x, y;	355	if (!spaces)
505	object *tmp, *op, *last, *above;	356	return;
506	archetype *at;
507		357
508	for (x = 0; x < MAP_WIDTH (m); x++)	358	for (mapspace *ms = spaces + size (); ms-- > spaces; )
509	for (y = 0; y < MAP_HEIGHT (m); y++)	359	for (object *tmp = ms->bot; tmp; )
510	for (tmp = get_map_ob (m, x, y); tmp != NULL; tmp = above)
511	{	360	{
512	above = tmp->above;	361	object *above = tmp->above;
513		362
514	/* already multipart - don't do anything more */	363	/* already multipart - don't do anything more */
515	if (tmp->head || tmp->more)	364	if (!tmp->head && !tmp->more)
516	continue;	365	{
517
518	/* If there is nothing more to this object, this for loop	366	/* If there is nothing more to this object, this for loop
519	* won't do anything.	367	* won't do anything.
520	*/	368	*/
521	for (at = tmp->arch->more, last = tmp; at != NULL; at = at->more, last = op)	369	archetype *at;
		370	object *last, *op;
		371	for (at = tmp->arch->more, last = tmp;
		372	at;
		373	at = at->more, last = op)
522	{	374	{
523	op = arch_to_object (at);	375	op = arch_to_object (at);
524		376
525	/* update x,y coordinates */	377	/* update x,y coordinates */
526	op->x += tmp->x;	378	op->x += tmp->x;
527	op->y += tmp->y;	379	op->y += tmp->y;
528	op->head = tmp;	380	op->head = tmp;
529	op->map = m;	381	op->map = this;
530	last->more = op;	382	last->more = op;
531	op->name = tmp->name;	383	op->name = tmp->name;
532	op->title = tmp->title;	384	op->title = tmp->title;
		385
533	/* we could link all the parts onto tmp, and then just	386	/* we could link all the parts onto tmp, and then just
534	* call insert_ob_in_map once, but the effect is the same,	387	* call insert_ob_in_map once, but the effect is the same,
535	* as insert_ob_in_map will call itself with each part, and	388	* as insert_ob_in_map will call itself with each part, and
536	* the coding is simpler to just to it here with each part.	389	* the coding is simpler to just to it here with each part.
537	*/	390	*/
538	insert_ob_in_map (op, op->map, tmp, INS_NO_MERGE | INS_ABOVE_FLOOR_ONLY | INS_NO_WALK_ON);	391	insert_ob_in_map (op, op->map, tmp, INS_NO_MERGE | INS_ABOVE_FLOOR_ONLY | INS_NO_WALK_ON);
539	} /* for at = tmp->arch->more */	392	}
540	} /* for objects on this space */	393	}
		394
		395	tmp = above;
		396	}
541	}	397	}
542		398
543	/*	399	/*
544	* Loads (ands parses) the objects into a given map from the specified	400	* Loads (ands parses) the objects into a given map from the specified
545	* file pointer.	401	* file pointer.
546	* mapflags is the same as we get with load_original_map	402	* mapflags is the same as we get with load_original_map
547	*/	403	*/
548	void	404	bool
549	load_objects (mapstruct *m, object_thawer & fp, int mapflags)	405	maptile::_load_objects (object_thawer &thawer)
550	{	406	{
551	int i, j;
552	int unique;	407	int unique;
553	object *op, *prev = NULL, *last_more = NULL, *otmp;	408	object *op, *prev = NULL, *last_more = NULL, *otmp;
554		409
555	op = get_object ();	410	op = object::create ();
556	op->map = m; /* To handle buttons correctly */	411	op->map = this; /* To handle buttons correctly */
557		412
558	while ((i = load_object (fp, op, mapflags)))	413	while (int i = load_object (thawer, op, 0))
559	{	414	{
560	/* if the archetype for the object is null, means that we	415	/* if the archetype for the object is null, means that we
561	* got an invalid object. Don't do anything with it - the game	416	* got an invalid object. Don't do anything with it - the game
562	* or editor will not be able to do anything with it either.	417	* or editor will not be able to do anything with it either.
563	*/	418	*/
…		…
565	{	420	{
566	LOG (llevDebug, "Discarding object without arch: %s\n", op->name ? (const char *) op->name : "(null)");	421	LOG (llevDebug, "Discarding object without arch: %s\n", op->name ? (const char *) op->name : "(null)");
567	continue;	422	continue;
568	}	423	}
569		424
570
571	switch (i)	425	switch (i)
572	{	426	{
573	case LL_NORMAL:	427	case LL_NORMAL:
574	/* if we are loading an overlay, put the floors on the bottom */
575	if ((QUERY_FLAG (op, FLAG_IS_FLOOR) || QUERY_FLAG (op, FLAG_OVERLAY_FLOOR)) && mapflags & MAP_OVERLAY)
576	insert_ob_in_map (op, m, op, INS_NO_MERGE | INS_NO_WALK_ON | INS_ABOVE_FLOOR_ONLY | INS_MAP_LOAD);
577	else
578	insert_ob_in_map (op, m, op, INS_NO_MERGE | INS_NO_WALK_ON | INS_ON_TOP | INS_MAP_LOAD);	428	insert_ob_in_map (op, this, op, INS_NO_MERGE | INS_NO_WALK_ON | INS_ON_TOP | INS_MAP_LOAD);
579		429
580	if (op->inv)	430	if (op->inv)
581	sum_weight (op);	431	sum_weight (op);
582		432
583	prev = op, last_more = op;	433	prev = op, last_more = op;
584	break;	434	break;
585		435
586	case LL_MORE:	436	case LL_MORE:
587	insert_ob_in_map (op, m, op, INS_NO_MERGE | INS_NO_WALK_ON | INS_ABOVE_FLOOR_ONLY);	437	insert_ob_in_map (op, this, op, INS_NO_MERGE | INS_NO_WALK_ON | INS_ABOVE_FLOOR_ONLY);
588	op->head = prev, last_more->more = op, last_more = op;	438	op->head = prev, last_more->more = op, last_more = op;
589	break;	439	break;
590	}	440	}
591		441
592	if (mapflags & MAP_STYLE)
593	remove_from_active_list (op);
594
595	op = get_object ();	442	op = object::create ();
596	op->map = m;	443	op->map = this;
597	}	444	}
598		445
		446	op->destroy ();
		447
		448	#if 0
599	for (i = 0; i < m->width; i++)	449	for (i = 0; i < width; i++)
600	{
601	for (j = 0; j < m->height; j++)	450	for (j = 0; j < height; j++)
602	{
603	unique = 0;
604	/* check for unique items, or unique squares */
605	for (otmp = get_map_ob (m, i, j); otmp; otmp = otmp->above)
606	{
607	if (QUERY_FLAG (otmp, FLAG_UNIQUE) || QUERY_FLAG (otmp, FLAG_OBJ_SAVE_ON_OVL))
608	unique = 1;
609	if (!(mapflags & (MAP_OVERLAY | MAP_PLAYER_UNIQUE) || unique))
610	SET_FLAG (otmp, FLAG_OBJ_ORIGINAL);
611	}
612	}
613	}
614
615	free_object (op);
616	link_multipart_objects (m);
617	}
618
619	/* This saves all the objects on the map in a non destructive fashion.
620	* Modified by MSW 2001-07-01 to do in a single pass - reduces code,
621	* and we only save the head of multi part objects - this is needed
622	* in order to do map tiling properly.
623	*/
624	void
625	save_objects (mapstruct *m, object_freezer & fp, object_freezer & fp2, int flag)
626	{
627	int i, j = 0, unique = 0;
628	object *op;
629
630	/* first pass - save one-part objects */
631	for (i = 0; i < MAP_WIDTH (m); i++)
632	for (j = 0; j < MAP_HEIGHT (m); j++)
633	{	451	{
634	unique = 0;	452	unique = 0;
		453	/* check for unique items, or unique squares */
635	for (op = get_map_ob (m, i, j); op; op = op->above)	454	for (otmp = GET_MAP_OB (m, i, j); otmp; otmp = otmp->above)
636	{	455	{
637	if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE))	456	if (QUERY_FLAG (otmp, FLAG_UNIQUE) || QUERY_FLAG (otmp, FLAG_OBJ_SAVE_ON_OVL))
638	unique = 1;	457	unique = 1;
639		458
640	if (op->type == PLAYER)	459	if (!(mapflags & (MAP_OVERLAY | MAP_PLAYER_UNIQUE) || unique))
641	{	460	SET_FLAG (otmp, FLAG_OBJ_ORIGINAL);
642	LOG (llevDebug, "Player on map that is being saved\n");
643	continue;
644	}	461	}
		462	}
		463	#endif
645		464
646	if (op->head || op->owner)	465	return true;
		466	}
		467
		468	void
		469	maptile::activate ()
		470	{
		471	if (!spaces)
		472	return;
		473
		474	for (mapspace *ms = spaces + size (); ms-- > spaces; )
		475	for (object *op = ms->bot; op; op = op->above)
		476	op->activate_recursive ();
		477	}
		478
		479	void
		480	maptile::deactivate ()
		481	{
		482	if (!spaces)
		483	return;
		484
		485	for (mapspace *ms = spaces + size (); ms-- > spaces; )
		486	for (object *op = ms->bot; op; op = op->above)
		487	op->deactivate_recursive ();
		488	}
		489
		490	bool
		491	maptile::_save_objects (object_freezer &freezer, int flags)
		492	{
		493	static int cede_count = 0;
		494
		495	if (flags & IO_HEADER)
		496	_save_header (freezer);
		497
		498	if (!spaces)
		499	return false;
		500
		501	for (int i = 0; i < size (); ++i)
		502	{
		503	#if 0 // temporarily disabled for improved(?) stability, schmorp #TODO#d#//D
		504	if (cede_count >= 500)
		505	{
		506	cede_count = 0;
		507	coroapi::cede ();
		508	}
		509	#endif
		510
		511	int unique = 0;
		512	for (object *op = spaces [i].bot; op; op = op->above)
		513	{
		514	// count per-object, but cede only when modification-safe
		515	cede_count++;
		516
		517	if (op->flag [FLAG_UNIQUE] && op->flag [FLAG_IS_FLOOR])
		518	unique = 1;
		519
		520	if (!op->can_map_save ())
647	continue;	521	continue;
648		522
649	if (unique || QUERY_FLAG (op, FLAG_UNIQUE))	523	if (unique || op->flag [FLAG_UNIQUE])
650	save_object (fp2, op, 3);	524	{
651	else if (flag == 0 || (flag == 2 && (!QUERY_FLAG (op, FLAG_OBJ_ORIGINAL) && !QUERY_FLAG (op, FLAG_UNPAID))))	525	if (flags & IO_UNIQUES)
652	save_object (fp, op, 3);	526	save_object (freezer, op, 1);
		527	}
		528	else if (flags & IO_OBJECTS)
		529	save_object (freezer, op, 1);
		530	}
		531	}
653		532
654	} /* for this space */	533	return true;
655	} /* for this j */
656	}	534	}
657		535
658	/*	536	bool
659	* Allocates, initialises, and returns a pointer to a mapstruct.	537	maptile::_load_objects (const char *path, bool skip_header)
660	* Modified to no longer take a path option which was not being
661	* used anyways. MSW 2001-07-01
662	*/
663
664	mapstruct *
665	get_linked_map (void)
666	{	538	{
667	mapstruct *map = new mapstruct;	539	object_thawer thawer (path);
668	mapstruct *mp;
669		540
670	for (mp = first_map; mp != NULL && mp->next != NULL; mp = mp->next);	541	if (!thawer)
671	if (mp == NULL)	542	return false;
672	first_map = map;
673	else
674	mp->next = map;
675		543
		544	if (skip_header)
		545	for (;;)
		546	{
		547	keyword kw = thawer.get_kv ();
		548
		549	if (kw == KW_end)
		550	break;
		551
		552	thawer.skip_kv (kw);
		553	}
		554
		555	return _load_objects (thawer);
		556	}
		557
		558	bool
		559	maptile::_save_objects (const char *path, int flags)
		560	{
		561	object_freezer freezer;
		562
		563	if (!_save_objects (freezer, flags))
		564	return false;
		565
		566	return freezer.save (path);
		567	}
		568
		569	maptile::maptile ()
		570	{
676	map->in_memory = MAP_SWAPPED;	571	in_memory = MAP_SWAPPED;
		572
677	/* The maps used to pick up default x and y values from the	573	/* The maps used to pick up default x and y values from the
678	* map archetype. Mimic that behaviour.	574	* map archetype. Mimic that behaviour.
679	*/	575	*/
680	MAP_WIDTH (map) = 16;	576	width = 16;
681	MAP_HEIGHT (map) = 16;	577	height = 16;
682	MAP_RESET_TIMEOUT (map) = 0;	578	reset_timeout = 0;
683	MAP_TIMEOUT (map) = 300;	579	timeout = 300;
684	MAP_ENTER_X (map) = 0;	580	enter_x = 0;
685	MAP_ENTER_Y (map) = 0;	581	enter_y = 0;
686	/*set part to -1 indicating conversion to weather map not yet done */	582	}
687	MAP_WORLDPARTX (map) = -1;	583
688	MAP_WORLDPARTY (map) = -1;	584	maptile::maptile (int w, int h)
689	return map;	585	{
		586	in_memory = MAP_SWAPPED;
		587
		588	width = w;
		589	height = h;
		590	reset_timeout = 0;
		591	timeout = 300;
		592	enter_x = 0;
		593	enter_y = 0;
		594
		595	alloc ();
690	}	596	}
691		597
692	/*	598	/*
693	* Allocates the arrays contained in a mapstruct.	599	* Allocates the arrays contained in a maptile.
694	* This basically allocates the dynamic array of spaces for the	600	* This basically allocates the dynamic array of spaces for the
695	* map.	601	* map.
696	*/	602	*/
697
698	void	603	void
699	allocate_map (mapstruct *m)	604	maptile::alloc ()
700	{	605	{
701	m->in_memory = MAP_IN_MEMORY;
702	/* Log this condition and free the storage. We could I suppose
703	* realloc, but if the caller is presuming the data will be intact,
704	* that is their poor assumption.
705	*/
706	if (m->spaces)	606	if (spaces)
707	{
708	LOG (llevError, "allocate_map called with already allocated map (%s)\n", m->path);
709	free (m->spaces);
710	}
711
712	m->spaces = (MapSpace *) calloc (1, MAP_WIDTH (m) * MAP_HEIGHT (m) * sizeof (MapSpace));
713
714	if (m->spaces == NULL)
715	fatal (OUT_OF_MEMORY);
716	}
717
718	/* Create and returns a map of the specific size. Used
719	* in random map code and the editor.
720	*/
721	mapstruct *
722	get_empty_map (int sizex, int sizey)
723	{
724	mapstruct *m = get_linked_map ();
725
726	m->width = sizex;
727	m->height = sizey;
728	m->in_memory = MAP_SWAPPED;
729	allocate_map (m);
730	return m;	607	return;
		608
		609	spaces = salloc0<mapspace> (size ());
731	}	610	}
732		611
733	/* Takes a string from a map definition and outputs a pointer to the array of shopitems	612	/* Takes a string from a map definition and outputs a pointer to the array of shopitems
734	* corresponding to that string. Memory is allocated for this, it must be freed	613	* corresponding to that string. Memory is allocated for this, it must be freed
735	* at a later date.	614	* at a later date.
736	* Called by parse_map_headers below.	615	* Called by parse_map_headers below.
737	*/	616	*/
738
739	static shopitems *	617	static shopitems *
740	parse_shop_string (const char *input_string)	618	parse_shop_string (const char *input_string)
741	{	619	{
742	char *shop_string, *p, *q, *next_semicolon, *next_colon;	620	char *shop_string, *p, *q, *next_semicolon, *next_colon;
743	shopitems *items = NULL;	621	shopitems *items = NULL;
744	int i = 0, number_of_entries = 0;	622	int i = 0, number_of_entries = 0;
745	const typedata *current_type;	623	const typedata *current_type;
746		624
747	shop_string = strdup_local (input_string);	625	shop_string = strdup (input_string);
748	p = shop_string;	626	p = shop_string;
749	/* first we'll count the entries, we'll need that for allocating the array shortly */	627	/* first we'll count the entries, we'll need that for allocating the array shortly */
750	while (p)	628	while (p)
751	{	629	{
752	p = strchr (p, ';');	630	p = strchr (p, ';');
753	number_of_entries++;	631	number_of_entries++;
754	if (p)	632	if (p)
755	p++;	633	p++;
756	}	634	}
		635
757	p = shop_string;	636	p = shop_string;
758	strip_endline (p);	637	strip_endline (p);
759	items = new shopitems[number_of_entries + 1];	638	items = new shopitems[number_of_entries + 1];
760	for (i = 0; i < number_of_entries; i++)	639	for (i = 0; i < number_of_entries; i++)
761	{	640	{
762	if (!p)	641	if (!p)
763	{	642	{
764	LOG (llevError, "parse_shop_string: I seem to have run out of string, that shouldn't happen.\n");	643	LOG (llevError, "parse_shop_string: I seem to have run out of string, that shouldn't happen.\n");
765	break;	644	break;
766	}	645	}
		646
767	next_semicolon = strchr (p, ';');	647	next_semicolon = strchr (p, ';');
768	next_colon = strchr (p, ':');	648	next_colon = strchr (p, ':');
769	/* if there is a stregth specified, figure out what it is, we'll need it soon. */	649	/* if there is a stregth specified, figure out what it is, we'll need it soon. */
770	if (next_colon && (!next_semicolon || next_colon < next_semicolon))	650	if (next_colon && (!next_semicolon || next_colon < next_semicolon))
771	items[i].strength = atoi (strchr (p, ':') + 1);	651	items[i].strength = atoi (strchr (p, ':') + 1);
…		…
798	* the next entry while we're at it, better print a warning	678	* the next entry while we're at it, better print a warning
799	*/	679	*/
800	LOG (llevError, "invalid type %s defined in shopitems in string %s\n", p, input_string);	680	LOG (llevError, "invalid type %s defined in shopitems in string %s\n", p, input_string);
801	}	681	}
802	}	682	}
		683
803	items[i].index = number_of_entries;	684	items[i].index = number_of_entries;
804	if (next_semicolon)	685	if (next_semicolon)
805	p = ++next_semicolon;	686	p = ++next_semicolon;
806	else	687	else
807	p = NULL;	688	p = NULL;
808	}	689	}
		690
809	free (shop_string);	691	free (shop_string);
810	return items;	692	return items;
811	}	693	}
812		694
813	/* opposite of parse string, this puts the string that was originally fed in to	695	/* opposite of parse string, this puts the string that was originally fed in to
814	* the map (or something equivilent) into output_string. */	696	* the map (or something equivilent) into output_string. */
815	static void	697	static void
816	print_shop_string (mapstruct *m, char *output_string)	698	print_shop_string (maptile *m, char *output_string)
817	{	699	{
818	int i;	700	int i;
819	char tmp[MAX_BUF];	701	char tmp[MAX_BUF];
820		702
821	strcpy (output_string, "");	703	strcpy (output_string, "");
822	for (i = 0; i < m->shopitems[0].index; i++)	704	for (i = 0; i < m->shopitems[0].index; i++)
823	{	705	{
824	if (m->shopitems[i].typenum)	706	if (m->shopitems[i].typenum)
825	{	707	{
826	if (m->shopitems[i].strength)	708	if (m->shopitems[i].strength)
827	{
828	sprintf (tmp, "%s:%d;", m->shopitems[i].name, m->shopitems[i].strength);	709	sprintf (tmp, "%s:%d;", m->shopitems[i].name, m->shopitems[i].strength);
829	}
830	else	710	else
831	sprintf (tmp, "%s;", m->shopitems[i].name);	711	sprintf (tmp, "%s;", m->shopitems[i].name);
832	}	712	}
833	else	713	else
834	{	714	{
835	if (m->shopitems[i].strength)	715	if (m->shopitems[i].strength)
836	{
837	sprintf (tmp, "*:%d;", m->shopitems[i].strength);	716	sprintf (tmp, "*:%d;", m->shopitems[i].strength);
838	}
839	else	717	else
840	sprintf (tmp, "*");	718	sprintf (tmp, "*");
841	}	719	}
		720
842	strcat (output_string, tmp);	721	strcat (output_string, tmp);
843	}	722	}
844	}	723	}
845		724
846	/* This loads the header information of the map. The header	725	/* This loads the header information of the map. The header
…		…
851	* put all the stuff in the map object so that names actually make	730	* put all the stuff in the map object so that names actually make
852	* sense.	731	* sense.
853	* This could be done in lex (like the object loader), but I think	732	* This could be done in lex (like the object loader), but I think
854	* currently, there are few enough fields this is not a big deal.	733	* currently, there are few enough fields this is not a big deal.
855	* MSW 2001-07-01	734	* MSW 2001-07-01
856	* return 0 on success, 1 on failure.
857	*/	735	*/
858		736	bool
859	static int	737	maptile::_load_header (object_thawer &thawer)
860	load_map_header (object_thawer & fp, mapstruct *m)
861	{	738	{
862	char buf[HUGE_BUF], msgbuf[HUGE_BUF], maplorebuf[HUGE_BUF], *key = NULL, *value, *end;	739	for (;;)
863	int msgpos = 0;
864	int maplorepos = 0;
865
866	while (fgets (buf, HUGE_BUF - 1, fp) != NULL)
867	{	740	{
868	buf[HUGE_BUF - 1] = 0;	741	keyword kw = thawer.get_kv ();
869	key = buf;	742
870	while (isspace (*key))	743	switch (kw)
871	key++;
872	if (*key == 0)
873	continue; /* empty line */
874	value = strchr (key, ' ');
875	if (!value)
876	{	744	{
877	end = strchr (key, '\n');	745	case KW_EOF:
878	if (end != NULL)	746	LOG (llevError, "%s: end of file while reading map header, aborting header load.\n", &path);
		747	return false;
		748
		749	case KW_end:
		750	return true;
		751
		752	default:
		753	case KW_ERROR:
		754	LOG (llevError, "%s: skipping errornous line (%s) while reading map header.\n", &path, thawer.last_keyword);
879	{	755	break;
880	*end = 0;	756
		757	case KW_msg:
		758	thawer.get_ml (KW_endmsg, msg);
881	}	759	break;
		760
		761	case KW_lore: // CF+ extension
		762	thawer.get_ml (KW_endlore, maplore);
		763	break;
		764
		765	case KW_maplore:
		766	thawer.get_ml (KW_endmaplore, maplore);
		767	break;
		768
		769	case KW_arch:
		770	if (strcmp (thawer.get_str (), "map"))
		771	LOG (llevError, "%s: loading map and got a non 'arch map' line (arch %s), skipping.\n", &path, thawer.get_str ());
		772	break;
		773
		774	case KW_oid:
		775	thawer.get (this, thawer.get_sint32 ());
		776	break;
		777
		778	case KW_file_format_version: break; // nop
		779
		780	case KW_name: thawer.get (name); break;
		781	case KW_attach: thawer.get (attach); break;
		782	case KW_reset_time: thawer.get (reset_time); break;
		783	case KW_shopgreed: thawer.get (shopgreed); break;
		784	case KW_shopmin: thawer.get (shopmin); break;
		785	case KW_shopmax: thawer.get (shopmax); break;
		786	case KW_shoprace: thawer.get (shoprace); break;
		787	case KW_outdoor: thawer.get (outdoor); break;
		788	case KW_temp: thawer.get (temp); break;
		789	case KW_pressure: thawer.get (pressure); break;
		790	case KW_humid: thawer.get (humid); break;
		791	case KW_windspeed: thawer.get (windspeed); break;
		792	case KW_winddir: thawer.get (winddir); break;
		793	case KW_sky: thawer.get (sky); break;
		794
		795	case KW_per_player: thawer.get (per_player); break;
		796	case KW_per_party: thawer.get (per_party); break;
		797
		798	case KW_region: get_region_by_name (thawer.get_str ()); break;
		799	case KW_shopitems: shopitems = parse_shop_string (thawer.get_str ()); break;
		800
		801	// old names new names
		802	case KW_hp: case KW_enter_x: thawer.get (enter_x); break;
		803	case KW_sp: case KW_enter_y: thawer.get (enter_y); break;
		804	case KW_x: case KW_width: thawer.get (width); break;
		805	case KW_y: case KW_height: thawer.get (height); break;
		806	case KW_weight: case KW_reset_timeout: thawer.get (reset_timeout); break;
		807	case KW_value: case KW_swap_time: thawer.get (timeout); break;
		808	case KW_level: case KW_difficulty: thawer.get (difficulty); difficulty = clamp (difficulty, 1, settings.max_level); break;
		809	case KW_invisible: case KW_darkness: thawer.get (darkness); break;
		810	case KW_stand_still: case KW_fixed_resettime: thawer.get (fixed_resettime); break;
		811
		812	case KW_tile_path_1: thawer.get (tile_path [0]); break;
		813	case KW_tile_path_2: thawer.get (tile_path [1]); break;
		814	case KW_tile_path_3: thawer.get (tile_path [2]); break;
		815	case KW_tile_path_4: thawer.get (tile_path [3]); break;
882	}	816	}
883	else
884	{
885	*value = 0;
886	value++;
887	end = strchr (value, '\n');
888	while (isspace (*value))
889	{
890	value++;
891	if (*value == '\0' || value == end)
892	{
893	/* Nothing but spaces. */
894	value = NULL;
895	break;
896	}
897	}
898	}
899
900	if (!end)
901	{
902	LOG (llevError, "Error loading map header - did not find a newline - perhaps file is truncated? Buf=%s\n", buf);
903	return 1;
904	}
905
906	/* key is the field name, value is what it should be set
907	* to. We've already done the work to null terminate key,
908	* and strip off any leading spaces for both of these.
909	* We have not touched the newline at the end of the line -
910	* these are needed for some values. the end pointer
911	* points to the first of the newlines.
912	* value could be NULL! It would be easy enough to just point
913	* this to "" to prevent cores, but that would let more errors slide
914	* through.
915	*
916	* First check for entries that do not use the value parameter, then
917	* validate that value is given and check for the remaining entries
918	* that use the parameter.
919	*/
920
921	if (!strcmp (key, "msg"))
922	{
923	while (fgets (buf, HUGE_BUF - 1, fp) != NULL)
924	{
925	if (!strcmp (buf, "endmsg\n"))
926	break;
927	else
928	{
929	/* slightly more efficient than strcat */
930	strcpy (msgbuf + msgpos, buf);
931	msgpos += strlen (buf);
932	}
933	}
934	/* There are lots of maps that have empty messages (eg, msg/endmsg
935	* with nothing between). There is no reason in those cases to
936	* keep the empty message. Also, msgbuf contains garbage data
937	* when msgpos is zero, so copying it results in crashes
938	*/
939	if (msgpos != 0)
940	m->msg = strdup_local (msgbuf);
941	}
942	else if (!strcmp (key, "maplore"))
943	{
944	while (fgets (buf, HUGE_BUF - 1, fp) != NULL)
945	{
946	if (!strcmp (buf, "endmaplore\n"))
947	break;
948	else
949	{
950	/* slightly more efficient than strcat */
951	strcpy (maplorebuf + maplorepos, buf);
952	maplorepos += strlen (buf);
953	}
954	}
955	if (maplorepos != 0)
956	m->maplore = strdup_local (maplorebuf);
957	}
958	else if (!strcmp (key, "end"))
959	{
960	break;
961	}
962	else if (value == NULL)
963	{
964	LOG (llevError, "Got '%s' line without parameter in map header\n", key);
965	}
966	else if (!strcmp (key, "arch"))
967	{
968	/* This is an oddity, but not something we care about much. */
969	if (strcmp (value, "map\n"))
970	LOG (llevError, "loading map and got a non 'arch map' line(%s %s)?\n", key, value);
971	}
972	else if (!strcmp (key, "name"))
973	{
974	*end = 0;
975	m->name = strdup_local (value);
976	}
977	/* first strcmp value on these are old names supported
978	* for compatibility reasons. The new values (second) are
979	* what really should be used.
980	*/
981	else if (!strcmp (key, "oid"))
982	{
983	fp.get (m, atoi (value));
984	}
985	else if (!strcmp (key, "attach"))
986	{
987	m->attach = value;
988	}
989	else if (!strcmp (key, "hp") || !strcmp (key, "enter_x"))
990	{
991	m->enter_x = atoi (value);
992	}
993	else if (!strcmp (key, "sp") || !strcmp (key, "enter_y"))
994	{
995	m->enter_y = atoi (value);
996	}
997	else if (!strcmp (key, "x") || !strcmp (key, "width"))
998	{
999	m->width = atoi (value);
1000	}
1001	else if (!strcmp (key, "y") || !strcmp (key, "height"))
1002	{
1003	m->height = atoi (value);
1004	}
1005	else if (!strcmp (key, "weight") || !strcmp (key, "reset_timeout"))
1006	{
1007	m->reset_timeout = atoi (value);
1008	}
1009	else if (!strcmp (key, "value") || !strcmp (key, "swap_time"))
1010	{
1011	m->timeout = atoi (value);
1012	}
1013	else if (!strcmp (key, "level") || !strcmp (key, "difficulty"))
1014	{
1015	m->difficulty = atoi (value);
1016	}
1017	else if (!strcmp (key, "invisible") || !strcmp (key, "darkness"))
1018	{
1019	m->darkness = atoi (value);
1020	}
1021	else if (!strcmp (key, "stand_still") || !strcmp (key, "fixed_resettime"))
1022	{
1023	m->fixed_resettime = atoi (value);
1024	}
1025	else if (!strcmp (key, "unique"))
1026	{
1027	m->unique = atoi (value);
1028	}
1029	else if (!strcmp (key, "template"))
1030	{
1031	m->templatemap = atoi (value);
1032	}
1033	else if (!strcmp (key, "region"))
1034	{
1035	m->region = get_region_by_name (value);
1036	}
1037	else if (!strcmp (key, "shopitems"))
1038	{
1039	*end = 0;
1040	m->shopitems = parse_shop_string (value);
1041	}
1042	else if (!strcmp (key, "shopgreed"))
1043	{
1044	m->shopgreed = atof (value);
1045	}
1046	else if (!strcmp (key, "shopmin"))
1047	{
1048	m->shopmin = atol (value);
1049	}
1050	else if (!strcmp (key, "shopmax"))
1051	{
1052	m->shopmax = atol (value);
1053	}
1054	else if (!strcmp (key, "shoprace"))
1055	{
1056	*end = 0;
1057	m->shoprace = strdup_local (value);
1058	}
1059	else if (!strcmp (key, "outdoor"))
1060	{
1061	m->outdoor = atoi (value);
1062	}
1063	else if (!strcmp (key, "temp"))
1064	{
1065	m->temp = atoi (value);
1066	}
1067	else if (!strcmp (key, "pressure"))
1068	{
1069	m->pressure = atoi (value);
1070	}
1071	else if (!strcmp (key, "humid"))
1072	{
1073	m->humid = atoi (value);
1074	}
1075	else if (!strcmp (key, "windspeed"))
1076	{
1077	m->windspeed = atoi (value);
1078	}
1079	else if (!strcmp (key, "winddir"))
1080	{
1081	m->winddir = atoi (value);
1082	}
1083	else if (!strcmp (key, "sky"))
1084	{
1085	m->sky = atoi (value);
1086	}
1087	else if (!strcmp (key, "nosmooth"))
1088	{
1089	m->nosmooth = atoi (value);
1090	}
1091	else if (!strncmp (key, "tile_path_", 10))
1092	{
1093	int tile = atoi (key + 10);
1094
1095	if (tile < 1 || tile > 4)
1096	{
1097	LOG (llevError, "load_map_header: tile location %d out of bounds (%s)\n", tile, m->path);
1098	}
1099	else
1100	{
1101	char *path;
1102
1103	*end = 0;
1104
1105	if (m->tile_path[tile - 1])
1106	{
1107	LOG (llevError, "load_map_header: tile location %d duplicated (%s)\n", tile, m->path);
1108	free (m->tile_path[tile - 1]);
1109	m->tile_path[tile - 1] = NULL;
1110	}
1111
1112	if (check_path (value, 1) != -1)
1113	{
1114	/* The unadorned path works. */
1115	path = value;
1116	}
1117	else
1118	{
1119	/* Try again; it could be a relative exit. */
1120
1121	path = path_combine_and_normalize (m->path, value);
1122
1123	if (check_path (path, 1) == -1)
1124	{
1125	LOG (llevError, "get_map_header: Bad tile path %s %s\n", m->path, value);
1126	path = NULL;
1127	}
1128	}
1129
1130	if (editor)
1131	{
1132	/* Use the value as in the file. */
1133	m->tile_path[tile - 1] = strdup_local (value);
1134	}
1135	else if (path != NULL)
1136	{
1137	/* Use the normalized value. */
1138	m->tile_path[tile - 1] = strdup_local (path);
1139	}
1140	} /* end if tile direction (in)valid */
1141	}
1142	else
1143	{
1144	LOG (llevError, "Got unknown value in map header: %s %s\n", key, value);
1145	}
1146	}
1147	if (!key || strcmp (key, "end"))
1148	{	817	}
1149	LOG (llevError, "Got premature eof on map header!\n");
1150	return 1;
1151	}
1152	return 0;
1153	}
1154		818
1155	/*	819	abort ();
1156	* Opens the file "filename" and reads information about the map	820	}
1157	* from the given file, and stores it in a newly allocated
1158	* mapstruct. A pointer to this structure is returned, or NULL on failure.
1159	* flags correspond to those in map.h. Main ones used are
1160	* MAP_PLAYER_UNIQUE, in which case we don't do any name changes, and
1161	* MAP_BLOCK, in which case we block on this load. This happens in all
1162	* cases, no matter if this flag is set or not.
1163	* MAP_STYLE: style map - don't add active objects, don't add to server
1164	* managed map list.
1165	*/
1166		821
1167	mapstruct *	822	bool
1168	load_original_map (const char *filename, int flags)	823	maptile::_load_header (const char *path)
1169	{	824	{
1170	mapstruct *m;
1171	char pathname[MAX_BUF];
1172
1173	if (flags & MAP_PLAYER_UNIQUE)
1174	strcpy (pathname, filename);
1175	else if (flags & MAP_OVERLAY)
1176	strcpy (pathname, create_overlay_pathname (filename));
1177	else
1178	strcpy (pathname, create_pathname (filename));
1179
1180	LOG (llevDebug, "load_original_map(%x): %s (%s)\n", flags, filename, pathname);
1181
1182	object_thawer thawer (pathname);	825	object_thawer thawer (path);
1183		826
1184	if (!thawer)	827	if (!thawer)
1185	return 0;	828	return false;
1186		829
1187	m = get_linked_map ();	830	return _load_header (thawer);
1188
1189	strcpy (m->path, filename);
1190	if (load_map_header (thawer, m))
1191	{
1192	LOG (llevError, "Error loading map header for %s, flags=%d\n", filename, flags);
1193	delete_map (m);
1194	return NULL;
1195	}
1196
1197	allocate_map (m);
1198
1199	m->in_memory = MAP_LOADING;
1200	load_objects (m, thawer, flags & (MAP_BLOCK | MAP_STYLE));
1201
1202	m->in_memory = MAP_IN_MEMORY;
1203	if (!MAP_DIFFICULTY (m))
1204	MAP_DIFFICULTY (m) = calculate_difficulty (m);
1205	set_map_reset_time (m);
1206	m->instantiate ();
1207	return (m);
1208	}
1209
1210	/*
1211	* Loads a map, which has been loaded earlier, from file.
1212	* Return the map object we load into (this can change from the passed
1213	* option if we can't find the original map)
1214	*/
1215
1216	static mapstruct *
1217	load_temporary_map (mapstruct *m)
1218	{
1219	char buf[MAX_BUF];
1220
1221	if (!m->tmpname)
1222	{
1223	LOG (llevError, "No temporary filename for map %s\n", m->path);
1224	strcpy (buf, m->path);
1225	delete_map (m);
1226	m = load_original_map (buf, 0);
1227	if (m == NULL)
1228	return NULL;
1229	fix_auto_apply (m); /* Chests which open as default */
1230	return m;
1231	}
1232
1233	object_thawer thawer (m->tmpname);
1234
1235	if (!thawer)
1236	{
1237	strcpy (buf, m->path);
1238	delete_map (m);
1239	m = load_original_map (buf, 0);
1240	if (!m)
1241	return NULL;
1242	fix_auto_apply (m); /* Chests which open as default */
1243	return m;
1244	}
1245
1246	if (load_map_header (thawer, m))
1247	{
1248	LOG (llevError, "Error loading map header for %s (%s)\n", m->path, m->tmpname);
1249	delete_map (m);
1250	m = load_original_map (m->path, 0);
1251	return NULL;
1252	}
1253	allocate_map (m);
1254
1255	m->in_memory = MAP_LOADING;
1256	load_objects (m, thawer, 0);
1257
1258	m->in_memory = MAP_IN_MEMORY;
1259	INVOKE_MAP (SWAPIN, m);
1260	return m;
1261	}
1262
1263	/*
1264	* Loads a map, which has been loaded earlier, from file.
1265	* Return the map object we load into (this can change from the passed
1266	* option if we can't find the original map)
1267	*/
1268
1269	mapstruct *
1270	load_overlay_map (const char *filename, mapstruct *m)
1271	{
1272	char pathname[MAX_BUF];
1273
1274	strcpy (pathname, create_overlay_pathname (filename));
1275
1276	object_thawer thawer (pathname);
1277
1278	if (!thawer)
1279	return m;
1280
1281	if (load_map_header (thawer, m))
1282	{
1283	LOG (llevError, "Error loading map header for overlay %s (%s)\n", m->path, pathname);
1284	delete_map (m);
1285	m = load_original_map (m->path, 0);
1286	return NULL;
1287	}
1288	/*allocate_map(m); */
1289
1290	m->in_memory = MAP_LOADING;
1291	load_objects (m, thawer, MAP_OVERLAY);
1292
1293	m->in_memory = MAP_IN_MEMORY;
1294	return m;
1295	}	831	}
1296		832
1297	/******************************************************************************	833	/******************************************************************************
1298	* This is the start of unique map handling code	834	* This is the start of unique map handling code
1299	*****************************************************************************/	835	*****************************************************************************/
1300		836
1301	/* This goes through map 'm' and removed any unique items on the map. */	837	/* This goes through the maptile and removed any unique items on the map. */
1302	static void	838	void
1303	delete_unique_items (mapstruct *m)	839	maptile::clear_unique_items ()
1304	{	840	{
1305	int i, j, unique;	841	for (int i = 0; i < size (); ++i)
1306	object *op, *next;	842	{
		843	int unique = 0;
		844	for (object *op = spaces [i].bot; op; )
		845	{
		846	object *above = op->above;
1307		847
1308	for (i = 0; i < MAP_WIDTH (m); i++)	848	if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE))
1309	for (j = 0; j < MAP_HEIGHT (m); j++)	849	unique = 1;
		850
		851	if (op->head == NULL && (QUERY_FLAG (op, FLAG_UNIQUE) || unique))
		852	{
		853	op->destroy_inv (false);
		854	op->destroy ();
		855	}
		856
		857	op = above;
		858	}
		859	}
		860	}
		861
		862	bool
		863	maptile::_save_header (object_freezer &freezer)
		864	{
		865	#define MAP_OUT(k) freezer.put (KW_ ## k, k)
		866	#define MAP_OUT2(k,v) freezer.put (KW_ ## k, v)
		867
		868	MAP_OUT2 (arch, "map");
		869
		870	if (name) MAP_OUT (name);
		871	MAP_OUT (swap_time);
		872	MAP_OUT (reset_time);
		873	MAP_OUT (reset_timeout);
		874	MAP_OUT (fixed_resettime);
		875	MAP_OUT (difficulty);
		876
		877	if (region) MAP_OUT2 (region, region->name);
		878
		879	if (shopitems)
		880	{
		881	char shop[MAX_BUF];
		882	print_shop_string (this, shop);
		883	MAP_OUT2 (shopitems, shop);
		884	}
		885
		886	MAP_OUT (shopgreed);
		887	MAP_OUT (shopmin);
		888	MAP_OUT (shopmax);
		889	if (shoprace) MAP_OUT (shoprace);
		890	MAP_OUT (darkness);
		891	MAP_OUT (width);
		892	MAP_OUT (height);
		893	MAP_OUT (enter_x);
		894	MAP_OUT (enter_y);
		895
		896	if (msg) freezer.put (KW_msg , KW_endmsg , msg);
		897	if (maplore) freezer.put (KW_maplore, KW_endmaplore, maplore);
		898
		899	MAP_OUT (outdoor);
		900	MAP_OUT (temp);
		901	MAP_OUT (pressure);
		902	MAP_OUT (humid);
		903	MAP_OUT (windspeed);
		904	MAP_OUT (winddir);
		905	MAP_OUT (sky);
		906
		907	MAP_OUT (per_player);
		908	MAP_OUT (per_party);
		909
		910	if (tile_path [0]) MAP_OUT2 (tile_path_1, tile_path [0]);
		911	if (tile_path [1]) MAP_OUT2 (tile_path_2, tile_path [1]);
		912	if (tile_path [2]) MAP_OUT2 (tile_path_3, tile_path [2]);
		913	if (tile_path [3]) MAP_OUT2 (tile_path_4, tile_path [3]);
		914
		915	freezer.put (this);
		916	freezer.put (KW_end);
		917
		918	return true;
		919	}
		920
		921	bool
		922	maptile::_save_header (const char *path)
		923	{
		924	object_freezer freezer;
		925
		926	if (!_save_header (freezer))
		927	return false;
		928
		929	return freezer.save (path);
		930	}
		931
		932	/*
		933	* Remove and free all objects in the given map.
		934	*/
		935	void
		936	maptile::clear ()
		937	{
		938	if (!spaces)
		939	return;
		940
		941	for (mapspace *ms = spaces + size (); ms-- > spaces; )
		942	while (object *op = ms->bot)
1310	{	943	{
1311	unique = 0;	944	if (op->head)
1312	for (op = get_map_ob (m, i, j); op; op = next)	945	op = op->head;
		946
		947	op->destroy_inv (false);
		948	op->destroy ();
		949	}
		950
		951	sfree (spaces, size ()), spaces = 0;
		952
		953	if (buttons)
		954	free_objectlinkpt (buttons), buttons = 0;
		955	}
		956
		957	void
		958	maptile::clear_header ()
		959	{
		960	name = 0;
		961	msg = 0;
		962	maplore = 0;
		963	shoprace = 0;
		964	delete [] shopitems, shopitems = 0;
		965
		966	for (int i = 0; i < 4; i++)
		967	tile_path [i] = 0;
		968	}
		969
		970	maptile::~maptile ()
		971	{
		972	assert (destroyed ());
		973	}
		974
		975	void
		976	maptile::clear_links_to (maptile *m)
		977	{
		978	/* We need to look through all the maps and see if any maps
		979	* are pointing at this one for tiling information. Since
		980	* tiling can be asymetric, we just can not look to see which
		981	* maps this map tiles with and clears those.
		982	*/
		983	for (int i = 0; i < 4; i++)
		984	if (tile_map[i] == m)
		985	tile_map[i] = 0;
		986	}
		987
		988	void
		989	maptile::do_destroy ()
		990	{
		991	attachable::do_destroy ();
		992
		993	clear ();
		994	}
		995
		996	/*
		997	* Updates every button on the map (by calling update_button() for them).
		998	*/
		999	void
		1000	maptile::update_buttons ()
		1001	{
		1002	for (oblinkpt *obp = buttons; obp; obp = obp->next)
		1003	for (objectlink *ol = obp->link; ol; ol = ol->next)
		1004	{
		1005	if (!ol->ob)
1313	{	1006	{
1314	next = op->above;	1007	LOG (llevError, "Internal error in update_button (%s (%dx%d), connected %ld).\n",
1315	if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE))	1008	ol->ob ? (const char *) ol->ob->name : "null", ol->ob ? ol->ob->x : -1, ol->ob ? ol->ob->y : -1, obp->value);
1316	unique = 1;	1009	continue;
1317	if (op->head == NULL && (QUERY_FLAG (op, FLAG_UNIQUE) || unique))
1318	{
1319	clean_object (op);
1320	if (QUERY_FLAG (op, FLAG_IS_LINKED))
1321	remove_button_link (op);
1322	remove_ob (op);
1323	free_object (op);
1324	}	1010	}
		1011
		1012	if (ol->ob->type == BUTTON || ol->ob->type == PEDESTAL)
		1013	{
		1014	update_button (ol->ob);
		1015	break;
1325	}	1016	}
1326	}	1017	}
1327	}	1018	}
1328
1329
1330	/*
1331	* Loads unique objects from file(s) into the map which is in memory
1332	* m is the map to load unique items into.
1333	*/
1334	static void
1335	load_unique_objects (mapstruct *m)
1336	{
1337	int count;
1338	char firstname[MAX_BUF];
1339
1340	for (count = 0; count < 10; count++)
1341	{
1342	sprintf (firstname, "%s.v%02d", create_items_path (m->path), count);
1343	if (!access (firstname, R_OK))
1344	break;
1345	}
1346	/* If we get here, we did not find any map */
1347	if (count == 10)
1348	return;
1349
1350	object_thawer thawer (firstname);
1351
1352	if (!thawer)
1353	return;
1354
1355	m->in_memory = MAP_LOADING;
1356	if (m->tmpname == NULL) /* if we have loaded unique items from */
1357	delete_unique_items (m); /* original map before, don't duplicate them */
1358	load_objects (m, thawer, 0);
1359
1360	m->in_memory = MAP_IN_MEMORY;
1361	}
1362
1363
1364	/*
1365	* Saves a map to file. If flag is set, it is saved into the same
1366	* file it was (originally) loaded from. Otherwise a temporary
1367	* filename will be genarated, and the file will be stored there.
1368	* The temporary filename will be stored in the mapstructure.
1369	* If the map is unique, we also save to the filename in the map
1370	* (this should have been updated when first loaded)
1371	*/
1372
1373	int
1374	new_save_map (mapstruct *m, int flag)
1375	{
1376	char filename[MAX_BUF], buf[MAX_BUF], shop[MAX_BUF];
1377	int i;
1378
1379	if (flag && !*m->path)
1380	{
1381	LOG (llevError, "Tried to save map without path.\n");
1382	return -1;
1383	}
1384
1385	if (flag || (m->unique) || (m->templatemap))
1386	{
1387	if (!m->unique && !m->templatemap)
1388	{ /* flag is set */
1389	if (flag == 2)
1390	strcpy (filename, create_overlay_pathname (m->path));
1391	else
1392	strcpy (filename, create_pathname (m->path));
1393	}
1394	else
1395	strcpy (filename, m->path);
1396
1397	make_path_to_file (filename);
1398	}
1399	else
1400	{
1401	if (!m->tmpname)
1402	m->tmpname = tempnam_local (settings.tmpdir, NULL);
1403
1404	strcpy (filename, m->tmpname);
1405	}
1406
1407	LOG (llevDebug, "Saving map %s to %s\n", m->path, filename);
1408	m->in_memory = MAP_SAVING;
1409
1410	object_freezer freezer;
1411
1412	/* legacy */
1413	fprintf (freezer, "arch map\n");
1414	if (m->name)
1415	fprintf (freezer, "name %s\n", m->name);
1416	if (!flag)
1417	fprintf (freezer, "swap_time %d\n", m->swap_time);
1418	if (m->reset_timeout)
1419	fprintf (freezer, "reset_timeout %d\n", m->reset_timeout);
1420	if (m->fixed_resettime)
1421	fprintf (freezer, "fixed_resettime %d\n", m->fixed_resettime);
1422	/* we unfortunately have no idea if this is a value the creator set
1423	* or a difficulty value we generated when the map was first loaded
1424	*/
1425	if (m->difficulty)
1426	fprintf (freezer, "difficulty %d\n", m->difficulty);
1427	if (m->region)
1428	fprintf (freezer, "region %s\n", m->region->name);
1429	if (m->shopitems)
1430	{
1431	print_shop_string (m, shop);
1432	fprintf (freezer, "shopitems %s\n", shop);
1433	}
1434	if (m->shopgreed)
1435	fprintf (freezer, "shopgreed %f\n", m->shopgreed);
1436	#ifndef WIN32
1437	if (m->shopmin)
1438	fprintf (freezer, "shopmin %llu\n", m->shopmin);
1439	if (m->shopmax)
1440	fprintf (freezer, "shopmax %llu\n", m->shopmax);
1441	#else
1442	if (m->shopmin)
1443	fprintf (freezer, "shopmin %I64u\n", m->shopmin);
1444	if (m->shopmax)
1445	fprintf (freezer, "shopmax %I64u\n", m->shopmax);
1446	#endif
1447	if (m->shoprace)
1448	fprintf (freezer, "shoprace %s\n", m->shoprace);
1449	if (m->darkness)
1450	fprintf (freezer, "darkness %d\n", m->darkness);
1451	if (m->width)
1452	fprintf (freezer, "width %d\n", m->width);
1453	if (m->height)
1454	fprintf (freezer, "height %d\n", m->height);
1455	if (m->enter_x)
1456	fprintf (freezer, "enter_x %d\n", m->enter_x);
1457	if (m->enter_y)
1458	fprintf (freezer, "enter_y %d\n", m->enter_y);
1459	if (m->msg)
1460	fprintf (freezer, "msg\n%sendmsg\n", m->msg);
1461	if (m->maplore)
1462	fprintf (freezer, "maplore\n%sendmaplore\n", m->maplore);
1463	if (m->unique)
1464	fprintf (freezer, "unique %d\n", m->unique);
1465	if (m->templatemap)
1466	fprintf (freezer, "template %d\n", m->templatemap);
1467	if (m->outdoor)
1468	fprintf (freezer, "outdoor %d\n", m->outdoor);
1469	if (m->temp)
1470	fprintf (freezer, "temp %d\n", m->temp);
1471	if (m->pressure)
1472	fprintf (freezer, "pressure %d\n", m->pressure);
1473	if (m->humid)
1474	fprintf (freezer, "humid %d\n", m->humid);
1475	if (m->windspeed)
1476	fprintf (freezer, "windspeed %d\n", m->windspeed);
1477	if (m->winddir)
1478	fprintf (freezer, "winddir %d\n", m->winddir);
1479	if (m->sky)
1480	fprintf (freezer, "sky %d\n", m->sky);
1481	if (m->nosmooth)
1482	fprintf (freezer, "nosmooth %d\n", m->nosmooth);
1483
1484	/* Save any tiling information, except on overlays */
1485	if (flag != 2)
1486	for (i = 0; i < 4; i++)
1487	if (m->tile_path[i])
1488	fprintf (freezer, "tile_path_%d %s\n", i + 1, m->tile_path[i]);
1489
1490	freezer.put (m);
1491	fprintf (freezer, "end\n");
1492
1493	/* In the game save unique items in the different file, but
1494	* in the editor save them to the normal map file.
1495	* If unique map, save files in the proper destination (set by
1496	* player)
1497	*/
1498	if ((flag == 0 || flag == 2) && !m->unique && !m->templatemap)
1499	{
1500	object_freezer unique;
1501
1502	if (flag == 2)
1503	save_objects (m, freezer, unique, 2);
1504	else
1505	save_objects (m, freezer, unique, 0);
1506
1507	sprintf (buf, "%s.v00", create_items_path (m->path));
1508
1509	unique.save (buf);
1510	}
1511	else
1512	{ /* save same file when not playing, like in editor */
1513	save_objects (m, freezer, freezer, 0);
1514	}
1515
1516	freezer.save (filename);
1517
1518	return 0;
1519	}
1520
1521
1522	/*
1523	* Remove and free all objects in the inventory of the given object.
1524	* object.c ?
1525	*/
1526
1527	void
1528	clean_object (object *op)
1529	{
1530	object *tmp, *next;
1531
1532	for (tmp = op->inv; tmp; tmp = next)
1533	{
1534	next = tmp->below;
1535	clean_object (tmp);
1536	if (QUERY_FLAG (tmp, FLAG_IS_LINKED))
1537	remove_button_link (tmp);
1538	remove_ob (tmp);
1539	free_object (tmp);
1540	}
1541	}
1542
1543	/*
1544	* Remove and free all objects in the given map.
1545	*/
1546
1547	void
1548	free_all_objects (mapstruct *m)
1549	{
1550	int i, j;
1551	object *op;
1552
1553	for (i = 0; i < MAP_WIDTH (m); i++)
1554	for (j = 0; j < MAP_HEIGHT (m); j++)
1555	{
1556	object *previous_obj = NULL;
1557
1558	while ((op = GET_MAP_OB (m, i, j)) != NULL)
1559	{
1560	if (op == previous_obj)
1561	{
1562	LOG (llevDebug, "free_all_objects: Link error, bailing out.\n");
1563	break;
1564	}
1565	previous_obj = op;
1566	if (op->head != NULL)
1567	op = op->head;
1568
1569	/* If the map isn't in memory, free_object will remove and
1570	* free objects in op's inventory. So let it do the job.
1571	*/
1572	if (m->in_memory == MAP_IN_MEMORY)
1573	clean_object (op);
1574	remove_ob (op);
1575	free_object (op);
1576	}
1577	}
1578	}
1579
1580	/*
1581	* Frees everything allocated by the given mapstructure.
1582	* don't free tmpname - our caller is left to do that
1583	*/
1584
1585	void
1586	free_map (mapstruct *m, int flag)
1587	{
1588	int i;
1589
1590	if (!m->in_memory)
1591	{
1592	LOG (llevError, "Trying to free freed map.\n");
1593	return;
1594	}
1595	if (flag && m->spaces)
1596	free_all_objects (m);
1597	if (m->name)
1598	FREE_AND_CLEAR (m->name);
1599	if (m->spaces)
1600	FREE_AND_CLEAR (m->spaces);
1601	if (m->msg)
1602	FREE_AND_CLEAR (m->msg);
1603	if (m->maplore)
1604	FREE_AND_CLEAR (m->maplore);
1605	if (m->shopitems)
1606	delete[]m->shopitems;
1607	m->shopitems = 0;
1608	if (m->shoprace)
1609	FREE_AND_CLEAR (m->shoprace);
1610	if (m->buttons)
1611	free_objectlinkpt (m->buttons);
1612	m->buttons = NULL;
1613	for (i = 0; i < 4; i++)
1614	{
1615	if (m->tile_path[i])
1616	FREE_AND_CLEAR (m->tile_path[i]);
1617	m->tile_map[i] = NULL;
1618	}
1619	m->in_memory = MAP_SWAPPED;
1620	}
1621
1622	/*
1623	* function: vanish mapstruct
1624	* m : pointer to mapstruct, if NULL no action
1625	* this deletes all the data on the map (freeing pointers)
1626	* and then removes this map from the global linked list of maps.
1627	*/
1628
1629	void
1630	delete_map (mapstruct *m)
1631	{
1632	mapstruct *tmp, *last;
1633	int i;
1634
1635	if (!m)
1636	return;
1637
1638	m->clear ();
1639
1640	if (m->in_memory == MAP_IN_MEMORY)
1641	{
1642	/* change to MAP_SAVING, even though we are not,
1643	* so that remove_ob doesn't do as much work.
1644	*/
1645	m->in_memory = MAP_SAVING;
1646	free_map (m, 1);
1647	}
1648	/* move this out of free_map, since tmpname can still be needed if
1649	* the map is swapped out.
1650	*/
1651	if (m->tmpname)
1652	{
1653	free (m->tmpname);
1654	m->tmpname = NULL;
1655	}
1656	last = NULL;
1657	/* We need to look through all the maps and see if any maps
1658	* are pointing at this one for tiling information. Since
1659	* tiling can be assymetric, we just can not look to see which
1660	* maps this map tiles with and clears those.
1661	*/
1662	for (tmp = first_map; tmp != NULL; tmp = tmp->next)
1663	{
1664	if (tmp->next == m)
1665	last = tmp;
1666
1667	/* This should hopefully get unrolled on a decent compiler */
1668	for (i = 0; i < 4; i++)
1669	if (tmp->tile_map[i] == m)
1670	tmp->tile_map[i] = NULL;
1671	}
1672
1673	/* If last is null, then this should be the first map in the list */
1674	if (!last)
1675	{
1676	if (m == first_map)
1677	first_map = m->next;
1678	else
1679	/* m->path is a static char, so should hopefully still have
1680	* some useful data in it.
1681	*/
1682	LOG (llevError, "delete_map: Unable to find map %s in list\n", m->path);
1683	}
1684	else
1685	last->next = m->next;
1686
1687	delete m;
1688	}
1689
1690
1691
1692	/*
1693	* Makes sure the given map is loaded and swapped in.
1694	* name is path name of the map.
1695	* flags meaning:
1696	* 0x1 (MAP_FLUSH): flush the map - always load from the map directory,
1697	* and don't do unique items or the like.
1698	* 0x2 (MAP_PLAYER_UNIQUE) - this is a unique map for each player.
1699	* dont do any more name translation on it.
1700	*
1701	* Returns a pointer to the given map.
1702	*/
1703
1704	mapstruct *
1705	ready_map_name (const char *name, int flags)
1706	{
1707	mapstruct *m;
1708
1709	if (!name)
1710	return (NULL);
1711
1712	/* Have we been at this level before? */
1713	m = has_been_loaded (name);
1714
1715	/* Map is good to go, so just return it */
1716	if (m && (m->in_memory == MAP_LOADING || m->in_memory == MAP_IN_MEMORY))
1717	{
1718	return m;
1719	}
1720
1721	/* unique maps always get loaded from their original location, and never
1722	* a temp location. Likewise, if map_flush is set, or we have never loaded
1723	* this map, load it now. I removed the reset checking from here -
1724	* it seems the probability of a player trying to enter a map that should
1725	* reset but hasn't yet is quite low, and removing that makes this function
1726	* a bit cleaner (and players probably shouldn't rely on exact timing for
1727	* resets in any case - if they really care, they should use the 'maps command.
1728	*/
1729	if ((flags & (MAP_FLUSH | MAP_PLAYER_UNIQUE)) || !m)
1730	{
1731
1732	/* first visit or time to reset */
1733	if (m)
1734	{
1735	clean_tmp_map (m); /* Doesn't make much difference */
1736	delete_map (m);
1737	}
1738
1739	/* create and load a map */
1740	if (flags & MAP_PLAYER_UNIQUE)
1741	LOG (llevDebug, "Trying to load map %s.\n", name);
1742	else
1743	LOG (llevDebug, "Trying to load map %s.\n", create_pathname (name));
1744
1745	//eval_pv ("$x = Event::time", 1);//D
1746	if (!(m = load_original_map (name, (flags & MAP_PLAYER_UNIQUE))))
1747	return (NULL);
1748	//eval_pv ("warn \"LOAD \", Event::time - $x", 1);//D
1749
1750	fix_auto_apply (m); /* Chests which open as default */
1751
1752	/* If a player unique map, no extra unique object file to load.
1753	* if from the editor, likewise.
1754	*/
1755	if (!(flags & (MAP_FLUSH | MAP_PLAYER_UNIQUE)))
1756	load_unique_objects (m);
1757
1758	if (!(flags & (MAP_FLUSH | MAP_PLAYER_UNIQUE | MAP_OVERLAY)))
1759	{
1760	m = load_overlay_map (name, m);
1761	if (m == NULL)
1762	return NULL;
1763	}
1764
1765	if (flags & MAP_PLAYER_UNIQUE)
1766	INVOKE_MAP (SWAPIN, m);
1767
1768	}
1769	else
1770	{
1771	/* If in this loop, we found a temporary map, so load it up. */
1772
1773	m = load_temporary_map (m);
1774	if (m == NULL)
1775	return NULL;
1776	load_unique_objects (m);
1777
1778	clean_tmp_map (m);
1779	m->in_memory = MAP_IN_MEMORY;
1780	/* tempnam() on sun systems (probably others) uses malloc
1781	* to allocated space for the string. Free it here.
1782	* In some cases, load_temporary_map above won't find the
1783	* temporary map, and so has reloaded a new map. If that
1784	* is the case, tmpname is now null
1785	*/
1786	if (m->tmpname)
1787	free (m->tmpname);
1788	m->tmpname = NULL;
1789	/* It's going to be saved anew anyway */
1790	}
1791
1792	/* Below here is stuff common to both first time loaded maps and
1793	* temp maps.
1794	*/
1795
1796	decay_objects (m); /* start the decay */
1797	/* In case other objects press some buttons down */
1798	update_buttons (m);
1799	if (m->outdoor)
1800	set_darkness_map (m);
1801	/* run the weather over this map */
1802	weather_effect (name);
1803	return m;
1804	}
1805
1806		1019
1807	/*	1020	/*
1808	* This routine is supposed to find out the difficulty of the map.	1021	* This routine is supposed to find out the difficulty of the map.
1809	* difficulty does not have a lot to do with character level,	1022	* difficulty does not have a lot to do with character level,
1810	* but does have a lot to do with treasure on the map.	1023	* but does have a lot to do with treasure on the map.
…		…
1812	* Difficulty can now be set by the map creature. If the value stored	1025	* Difficulty can now be set by the map creature. If the value stored
1813	* in the map is zero, then use this routine. Maps should really	1026	* in the map is zero, then use this routine. Maps should really
1814	* have a difficulty set than using this function - human calculation	1027	* have a difficulty set than using this function - human calculation
1815	* is much better than this functions guesswork.	1028	* is much better than this functions guesswork.
1816	*/	1029	*/
1817
1818	int	1030	int
1819	calculate_difficulty (mapstruct *m)	1031	maptile::estimate_difficulty () const
1820	{	1032	{
1821	object *op;
1822	archetype *at;
1823	int x, y, i;
1824	long monster_cnt = 0;	1033	long monster_cnt = 0;
1825	double avgexp = 0;	1034	double avgexp = 0;
1826	sint64 total_exp = 0;	1035	sint64 total_exp = 0;
1827		1036
1828	if (MAP_DIFFICULTY (m))	1037	for (mapspace *ms = spaces + size (); ms-- > spaces; )
1829	{	1038	for (object *op = ms->bot; op; op = op->above)
1830	LOG (llevDebug, "Using stored map difficulty: %d\n", MAP_DIFFICULTY (m));
1831	return MAP_DIFFICULTY (m);
1832	}
1833
1834	for (x = 0; x < MAP_WIDTH (m); x++)
1835	for (y = 0; y < MAP_HEIGHT (m); y++)
1836	for (op = get_map_ob (m, x, y); op != NULL; op = op->above)
1837	{	1039	{
1838	if (QUERY_FLAG (op, FLAG_MONSTER))	1040	if (QUERY_FLAG (op, FLAG_MONSTER))
1839	{	1041	{
1840	total_exp += op->stats.exp;	1042	total_exp += op->stats.exp;
1841	monster_cnt++;	1043	monster_cnt++;
1842	}	1044	}
1843		1045
1844	if (QUERY_FLAG (op, FLAG_GENERATOR))	1046	if (QUERY_FLAG (op, FLAG_GENERATOR))
1845	{	1047	{
1846	total_exp += op->stats.exp;	1048	total_exp += op->stats.exp;
		1049
1847	at = type_to_archetype (GENERATE_TYPE (op));	1050	if (archetype *at = type_to_archetype (GENERATE_TYPE (op)))
1848
1849	if (at != NULL)
1850	total_exp += at->clone.stats.exp * 8;	1051	total_exp += at->clone.stats.exp * 8;
1851		1052
1852	monster_cnt++;	1053	monster_cnt++;
1853	}	1054	}
1854	}	1055	}
1855		1056
1856	avgexp = (double) total_exp / monster_cnt;	1057	avgexp = (double) total_exp / monster_cnt;
1857		1058
1858	for (i = 1; i <= settings.max_level; i++)	1059	for (int i = 1; i <= settings.max_level; i++)
1859	{
1860	if ((level_exp (i, 1) - level_exp (i - 1, 1)) > (100 * avgexp))	1060	if ((level_exp (i, 1) - level_exp (i - 1, 1)) > (100 * avgexp))
1861	{
1862	/* LOG(llevDebug, "Calculated difficulty for map: %s: %d\n", m->name, i); */
1863	return i;	1061	return i;
1864	}
1865	}
1866		1062
1867	return 1;	1063	return 1;
1868	}
1869
1870	void
1871	clean_tmp_map (mapstruct *m)
1872	{
1873	if (m->tmpname == NULL)
1874	return;
1875	INVOKE_MAP (CLEAN, m);
1876	(void) unlink (m->tmpname);
1877	}
1878
1879	void
1880	free_all_maps (void)
1881	{
1882	int real_maps = 0;
1883
1884	while (first_map)
1885	{
1886	/* I think some of the callers above before it gets here set this to be
1887	* saving, but we still want to free this data
1888	*/
1889	if (first_map->in_memory == MAP_SAVING)
1890	first_map->in_memory = MAP_IN_MEMORY;
1891	delete_map (first_map);
1892	real_maps++;
1893	}
1894	LOG (llevDebug, "free_all_maps: Freed %d maps\n", real_maps);
1895	}	1064	}
1896		1065
1897	/* change_map_light() - used to change map light level (darkness)	1066	/* change_map_light() - used to change map light level (darkness)
1898	* up or down. Returns true if successful. It should now be	1067	* up or down. Returns true if successful. It should now be
1899	* possible to change a value by more than 1.	1068	* possible to change a value by more than 1.
1900	* Move this from los.c to map.c since this is more related	1069	* Move this from los.c to map.c since this is more related
1901	* to maps than los.	1070	* to maps than los.
1902	* postive values make it darker, negative make it brighter	1071	* postive values make it darker, negative make it brighter
1903	*/	1072	*/
1904
1905	int	1073	int
1906	change_map_light (mapstruct *m, int change)	1074	maptile::change_map_light (int change)
1907	{	1075	{
1908	int new_level = m->darkness + change;	1076	int new_level = darkness + change;
1909		1077
1910	/* Nothing to do */	1078	/* Nothing to do */
1911	if (!change || (new_level <= 0 && m->darkness == 0) || (new_level >= MAX_DARKNESS && m->darkness >= MAX_DARKNESS))	1079	if (!change || (new_level <= 0 && darkness == 0) || (new_level >= MAX_DARKNESS && darkness >= MAX_DARKNESS))
1912	{
1913	return 0;	1080	return 0;
1914	}
1915		1081
1916	/* inform all players on the map */	1082	/* inform all players on the map */
1917	if (change > 0)	1083	if (change > 0)
1918	new_info_map (NDI_BLACK | NDI_UNIQUE, m, "It becomes darker.");	1084	new_info_map (NDI_BLACK | NDI_UNIQUE, this, "It becomes darker.");
1919	else	1085	else
1920	new_info_map (NDI_BLACK | NDI_UNIQUE, m, "It becomes brighter.");	1086	new_info_map (NDI_BLACK | NDI_UNIQUE, this, "It becomes brighter.");
1921		1087
1922	/* Do extra checking. since m->darkness is a unsigned value,	1088	/* Do extra checking. since darkness is a unsigned value,
1923	* we need to be extra careful about negative values.	1089	* we need to be extra careful about negative values.
1924	* In general, the checks below are only needed if change	1090	* In general, the checks below are only needed if change
1925	* is not +/-1	1091	* is not +/-1
1926	*/	1092	*/
1927	if (new_level < 0)	1093	if (new_level < 0)
1928	m->darkness = 0;	1094	darkness = 0;
1929	else if (new_level >= MAX_DARKNESS)	1095	else if (new_level >= MAX_DARKNESS)
1930	m->darkness = MAX_DARKNESS;	1096	darkness = MAX_DARKNESS;
1931	else	1097	else
1932	m->darkness = new_level;	1098	darkness = new_level;
1933		1099
1934	/* All clients need to get re-updated for the change */	1100	/* All clients need to get re-updated for the change */
1935	update_all_map_los (m);	1101	update_all_map_los (this);
1936	return 1;	1102	return 1;
1937	}	1103	}
1938
1939		1104
1940	/*	1105	/*
1941	* This function updates various attributes about a specific space	1106	* This function updates various attributes about a specific space
1942	* on the map (what it looks like, whether it blocks magic,	1107	* on the map (what it looks like, whether it blocks magic,
1943	* has a living creatures, prevents people from passing	1108	* has a living creatures, prevents people from passing
1944	* through, etc)	1109	* through, etc)
1945	*/	1110	*/
1946	void	1111	void
1947	update_position (mapstruct *m, int x, int y)	1112	mapspace::update_ ()
1948	{	1113	{
1949	object *tmp, *last = NULL;	1114	object *tmp, *last = 0;
1950	uint8 flags = 0, oldflags, light = 0, anywhere = 0;	1115	uint8 flags = P_UPTODATE, light = 0, anywhere = 0;
1951	New_Face *top, *floor, *middle;	1116	New_Face *top, *floor, *middle;
1952	object *top_obj, *floor_obj, *middle_obj;	1117	object *top_obj, *floor_obj, *middle_obj;
1953	MoveType move_block = 0, move_slow = 0, move_on = 0, move_off = 0, move_allow = 0;	1118	MoveType move_block = 0, move_slow = 0, move_on = 0, move_off = 0, move_allow = 0;
1954		1119
1955	oldflags = GET_MAP_FLAGS (m, x, y);
1956	if (!(oldflags & P_NEED_UPDATE))
1957	{
1958	LOG (llevDebug, "update_position called with P_NEED_UPDATE not set: %s (%d, %d)\n", m->path, x, y);
1959	return;
1960	}
1961
1962	middle = blank_face;	1120	middle = blank_face;
1963	top = blank_face;	1121	top = blank_face;
1964	floor = blank_face;	1122	floor = blank_face;
1965		1123
1966	middle_obj = NULL;	1124	middle_obj = 0;
1967	top_obj = NULL;	1125	top_obj = 0;
1968	floor_obj = NULL;	1126	floor_obj = 0;
1969		1127
1970	for (tmp = get_map_ob (m, x, y); tmp; last = tmp, tmp = tmp->above)	1128	for (tmp = bot; tmp; last = tmp, tmp = tmp->above)
1971	{	1129	{
1972
1973	/* This could be made additive I guess (two lights better than	1130	/* This could be made additive I guess (two lights better than
1974	* one). But if so, it shouldn't be a simple additive - 2	1131	* one). But if so, it shouldn't be a simple additive - 2
1975	* light bulbs do not illuminate twice as far as once since	1132	* light bulbs do not illuminate twice as far as once since
1976	* it is a disapation factor that is squared (or is it cubed?)	1133	* it is a dissapation factor that is cubed.
1977	*/	1134	*/
1978	if (tmp->glow_radius > light)	1135	if (tmp->glow_radius > light)
1979	light = tmp->glow_radius;	1136	light = tmp->glow_radius;
1980		1137
1981	/* This call is needed in order to update objects the player	1138	/* This call is needed in order to update objects the player
…		…
2019	{	1176	{
2020	middle = tmp->face;	1177	middle = tmp->face;
2021	middle_obj = tmp;	1178	middle_obj = tmp;
2022	}	1179	}
2023	}	1180	}
		1181
2024	if (tmp == tmp->above)	1182	if (tmp == tmp->above)
2025	{	1183	{
2026	LOG (llevError, "Error in structure of map\n");	1184	LOG (llevError, "Error in structure of map\n");
2027	exit (-1);	1185	exit (-1);
2028	}	1186	}
2029		1187
2030	move_slow |= tmp->move_slow;	1188	move_slow |= tmp->move_slow;
2031	move_block |= tmp->move_block;	1189	move_block |= tmp->move_block;
2032	move_on |= tmp->move_on;	1190	move_on |= tmp->move_on;
2033	move_off |= tmp->move_off;	1191	move_off |= tmp->move_off;
2034	move_allow |= tmp->move_allow;	1192	move_allow |= tmp->move_allow;
2035		1193
2036	if (QUERY_FLAG (tmp, FLAG_ALIVE))
2037	flags |= P_IS_ALIVE;
2038	if (QUERY_FLAG (tmp, FLAG_NO_MAGIC))
2039	flags |= P_NO_MAGIC;
2040	if (QUERY_FLAG (tmp, FLAG_DAMNED))
2041	flags |= P_NO_CLERIC;
2042	if (tmp->type == SAFE_GROUND)
2043	flags |= P_SAFE;
2044
2045	if (QUERY_FLAG (tmp, FLAG_BLOCKSVIEW))	1194	if (QUERY_FLAG (tmp, FLAG_BLOCKSVIEW)) flags |= P_BLOCKSVIEW;
2046	flags |= P_BLOCKSVIEW;	1195	if (QUERY_FLAG (tmp, FLAG_NO_MAGIC)) flags |= P_NO_MAGIC;
2047	} /* for stack of objects */	1196	if (tmp->type == PLAYER) flags |= P_PLAYER;
2048		1197	if (tmp->type == SAFE_GROUND) flags |= P_SAFE;
2049	/* we don't want to rely on this function to have accurate flags, but	1198	if (QUERY_FLAG (tmp, FLAG_ALIVE)) flags |= P_IS_ALIVE;
2050	* since we're already doing the work, we calculate them here.	1199	if (QUERY_FLAG (tmp, FLAG_DAMNED)) flags |= P_NO_CLERIC;
2051	* if they don't match, logic is broken someplace.
2052	*/
2053	if (((oldflags & ~(P_NEED_UPDATE | P_NO_ERROR)) != flags) && (!(oldflags & P_NO_ERROR)))
2054	{	1200	}
2055	LOG (llevDebug, "update_position: updated flags do not match old flags: %s (old=%d,new=%d) %x != %x\n",	1201
2056	m->path, x, y, (oldflags & ~P_NEED_UPDATE), flags);	1202	this->light = light;
2057	}	1203	this->flags_ = flags;
2058	SET_MAP_FLAGS (m, x, y, flags);	1204	this->move_block = move_block & ~move_allow;
2059	SET_MAP_MOVE_BLOCK (m, x, y, move_block & ~move_allow);	1205	this->move_on = move_on;
2060	SET_MAP_MOVE_ON (m, x, y, move_on);	1206	this->move_off = move_off;
2061	SET_MAP_MOVE_OFF (m, x, y, move_off);	1207	this->move_slow = move_slow;
2062	SET_MAP_MOVE_SLOW (m, x, y, move_slow);
2063		1208
2064	/* At this point, we have a floor face (if there is a floor),	1209	/* At this point, we have a floor face (if there is a floor),
2065	* and the floor is set - we are not going to touch it at	1210	* and the floor is set - we are not going to touch it at
2066	* this point.	1211	* this point.
2067	* middle contains the highest visibility face.	1212	* middle contains the highest visibility face.
…		…
2092		1237
2093	/* If two top faces are already set, quit processing */	1238	/* If two top faces are already set, quit processing */
2094	if ((top != blank_face) && (middle != blank_face))	1239	if ((top != blank_face) && (middle != blank_face))
2095	break;	1240	break;
2096		1241
2097	/* Only show visible faces, unless its the editor - show all */	1242	/* Only show visible faces */
2098	if (!tmp->invisible || editor)	1243	if (!tmp->invisible)
2099	{	1244	{
2100	/* Fill in top if needed */	1245	/* Fill in top if needed */
2101	if (top == blank_face)	1246	if (top == blank_face)
2102	{	1247	{
2103	top = tmp->face;	1248	top = tmp->face;
…		…
2121	break;	1266	break;
2122	}	1267	}
2123	}	1268	}
2124	}	1269	}
2125	}	1270	}
		1271
2126	if (middle == floor)	1272	if (middle == floor)
2127	middle = blank_face;	1273	middle = blank_face;
		1274
2128	if (top == middle)	1275	if (top == middle)
2129	middle = blank_face;	1276	middle = blank_face;
2130	SET_MAP_FACE (m, x, y, top, 0);
2131	if (top != blank_face)
2132	SET_MAP_FACE_OBJ (m, x, y, top_obj, 0);
2133	else
2134	SET_MAP_FACE_OBJ (m, x, y, NULL, 0);
2135	SET_MAP_FACE (m, x, y, middle, 1);
2136	if (middle != blank_face)
2137	SET_MAP_FACE_OBJ (m, x, y, middle_obj, 1);
2138	else
2139	SET_MAP_FACE_OBJ (m, x, y, NULL, 1);
2140	SET_MAP_FACE (m, x, y, floor, 2);
2141	if (floor != blank_face)
2142	SET_MAP_FACE_OBJ (m, x, y, floor_obj, 2);
2143	else
2144	SET_MAP_FACE_OBJ (m, x, y, NULL, 2);
2145	SET_MAP_LIGHT (m, x, y, light);
2146	}
2147		1277
2148		1278	faces [0] = top; faces_obj [0] = top != blank_face ? top_obj : 0;
2149	void	1279	faces [1] = middle; faces_obj [1] = middle != blank_face ? middle_obj : 0;
2150	set_map_reset_time (mapstruct *map)	1280	faces [2] = floor; faces_obj [2] = floor != blank_face ? floor_obj : 0;
2151	{
2152	int timeout;
2153
2154	timeout = MAP_RESET_TIMEOUT (map);
2155	if (timeout <= 0)
2156	timeout = MAP_DEFAULTRESET;
2157	if (timeout >= MAP_MAXRESET)
2158	timeout = MAP_MAXRESET;
2159	MAP_WHEN_RESET (map) = seconds () + timeout;
2160	}	1281	}
2161		1282
2162	/* this updates the orig_map->tile_map[tile_num] value after loading	1283	/* this updates the orig_map->tile_map[tile_num] value after finding
2163	* the map. It also takes care of linking back the freshly loaded	1284	* the map. It also takes care of linking back the freshly found
2164	* maps tile_map values if it tiles back to this one. It returns	1285	* maps tile_map values if it tiles back to this one. It returns
2165	* the value of orig_map->tile_map[tile_num]. It really only does this	1286	* the value of orig_map->tile_map[tile_num].
2166	* so that it is easier for calling functions to verify success.
2167	*/	1287	*/
2168		1288	static inline maptile *
2169	static mapstruct *	1289	find_and_link (maptile *orig_map, int tile_num)
2170	load_and_link_tiled_map (mapstruct *orig_map, int tile_num)
2171	{	1290	{
		1291	maptile *mp = orig_map->tile_map [tile_num];
		1292
		1293	if (!mp)
		1294	{
		1295	mp = orig_map->find_sync (orig_map->tile_path [tile_num], orig_map);
		1296
		1297	if (!mp)
		1298	{
		1299	// emergency mode, manufacture a dummy map, this creates a memleak, but thats fine
		1300	LOG (llevError, "FATAL: cannot load tiled map %s from %s, leaking memory and worse!\n",
		1301	&orig_map->tile_path[tile_num], &orig_map->path);
		1302	mp = new maptile (1, 1);
		1303	mp->alloc ();
		1304	mp->in_memory = MAP_IN_MEMORY;
		1305	}
		1306	}
		1307
2172	int dest_tile = (tile_num + 2) % 4;	1308	int dest_tile = (tile_num + 2) % 4;
2173	char *path = path_combine_and_normalize (orig_map->path, orig_map->tile_path[tile_num]);
2174		1309
2175	orig_map->tile_map[tile_num] = ready_map_name (path, 0);	1310	orig_map->tile_map [tile_num] = mp;
2176		1311
2177	/* need to do a strcmp here as the orig_map->path is not a shared string */	1312	// optimisation: back-link map to origin map if euclidean
2178	if (orig_map->tile_map[tile_num]->tile_path[dest_tile] && !strcmp (orig_map->tile_map[tile_num]->tile_path[dest_tile], orig_map->path))	1313	//TODO: non-euclidean maps MUST GO
		1314	if (orig_map->tile_map[tile_num]->tile_path[dest_tile] == orig_map->path)
2179	orig_map->tile_map[tile_num]->tile_map[dest_tile] = orig_map;	1315	orig_map->tile_map[tile_num]->tile_map[dest_tile] = orig_map;
2180		1316
2181	return orig_map->tile_map[tile_num];	1317	return mp;
		1318	}
		1319
		1320	static inline void
		1321	load_and_link (maptile *orig_map, int tile_num)
		1322	{
		1323	find_and_link (orig_map, tile_num)->load_sync ();
2182	}	1324	}
2183		1325
2184	/* this returns TRUE if the coordinates (x,y) are out of	1326	/* this returns TRUE if the coordinates (x,y) are out of
2185	* map m. This function also takes into account any	1327	* map m. This function also takes into account any
2186	* tiling considerations, loading adjacant maps as needed.	1328	* tiling considerations, loading adjacant maps as needed.
2187	* This is the function should always be used when it	1329	* This is the function should always be used when it
2188	* necessary to check for valid coordinates.	1330	* necessary to check for valid coordinates.
2189	* This function will recursively call itself for the	1331	* This function will recursively call itself for the
2190	* tiled maps.	1332	* tiled maps.
2191	*
2192	*
2193	*/	1333	*/
2194	int	1334	int
2195	out_of_map (mapstruct *m, int x, int y)	1335	out_of_map (maptile *m, int x, int y)
2196	{	1336	{
2197
2198	/* If we get passed a null map, this is obviously the	1337	/* If we get passed a null map, this is obviously the
2199	* case. This generally shouldn't happen, but if the	1338	* case. This generally shouldn't happen, but if the
2200	* map loads fail below, it could happen.	1339	* map loads fail below, it could happen.
2201	*/	1340	*/
2202	if (!m)	1341	if (!m)
…		…
2204		1343
2205	if (x < 0)	1344	if (x < 0)
2206	{	1345	{
2207	if (!m->tile_path[3])	1346	if (!m->tile_path[3])
2208	return 1;	1347	return 1;
		1348
2209	if (!m->tile_map[3] || m->tile_map[3]->in_memory != MAP_IN_MEMORY)	1349	if (!m->tile_map[3] || m->tile_map[3]->in_memory != MAP_IN_MEMORY)
2210	{	1350	find_and_link (m, 3);
2211	load_and_link_tiled_map (m, 3);	1351
2212	}
2213	return (out_of_map (m->tile_map[3], x + MAP_WIDTH (m->tile_map[3]), y));	1352	return out_of_map (m->tile_map[3], x + m->tile_map[3]->width, y);
2214	}	1353	}
2215	if (x >= MAP_WIDTH (m))	1354
		1355	if (x >= m->width)
2216	{	1356	{
2217	if (!m->tile_path[1])	1357	if (!m->tile_path[1])
2218	return 1;	1358	return 1;
		1359
2219	if (!m->tile_map[1] || m->tile_map[1]->in_memory != MAP_IN_MEMORY)	1360	if (!m->tile_map[1] || m->tile_map[1]->in_memory != MAP_IN_MEMORY)
2220	{	1361	find_and_link (m, 1);
2221	load_and_link_tiled_map (m, 1);	1362
2222	}
2223	return (out_of_map (m->tile_map[1], x - MAP_WIDTH (m), y));	1363	return out_of_map (m->tile_map[1], x - m->width, y);
2224	}	1364	}
		1365
2225	if (y < 0)	1366	if (y < 0)
2226	{	1367	{
2227	if (!m->tile_path[0])	1368	if (!m->tile_path[0])
2228	return 1;	1369	return 1;
		1370
2229	if (!m->tile_map[0] || m->tile_map[0]->in_memory != MAP_IN_MEMORY)	1371	if (!m->tile_map[0] || m->tile_map[0]->in_memory != MAP_IN_MEMORY)
2230	{	1372	find_and_link (m, 0);
2231	load_and_link_tiled_map (m, 0);	1373
2232	}
2233	return (out_of_map (m->tile_map[0], x, y + MAP_HEIGHT (m->tile_map[0])));	1374	return out_of_map (m->tile_map[0], x, y + m->tile_map[0]->height);
2234	}	1375	}
2235	if (y >= MAP_HEIGHT (m))	1376
		1377	if (y >= m->height)
2236	{	1378	{
2237	if (!m->tile_path[2])	1379	if (!m->tile_path[2])
2238	return 1;	1380	return 1;
		1381
2239	if (!m->tile_map[2] || m->tile_map[2]->in_memory != MAP_IN_MEMORY)	1382	if (!m->tile_map[2] || m->tile_map[2]->in_memory != MAP_IN_MEMORY)
2240	{	1383	find_and_link (m, 2);
2241	load_and_link_tiled_map (m, 2);	1384
2242	}
2243	return (out_of_map (m->tile_map[2], x, y - MAP_HEIGHT (m)));	1385	return out_of_map (m->tile_map[2], x, y - m->height);
2244	}	1386	}
2245		1387
2246	/* Simple case - coordinates are within this local	1388	/* Simple case - coordinates are within this local
2247	* map.	1389	* map.
2248	*/	1390	*/
…		…
2251		1393
2252	/* This is basically the same as out_of_map above, but	1394	/* This is basically the same as out_of_map above, but
2253	* instead we return NULL if no map is valid (coordinates	1395	* instead we return NULL if no map is valid (coordinates
2254	* out of bounds and no tiled map), otherwise it returns	1396	* out of bounds and no tiled map), otherwise it returns
2255	* the map as that the coordinates are really on, and	1397	* the map as that the coordinates are really on, and
2256	* updates x and y to be the localized coordinates.	1398	* updates x and y to be the localised coordinates.
2257	* Using this is more efficient of calling out_of_map	1399	* Using this is more efficient of calling out_of_map
2258	* and then figuring out what the real map is	1400	* and then figuring out what the real map is
2259	*/	1401	*/
2260	mapstruct *	1402	maptile *
2261	get_map_from_coord (mapstruct *m, sint16 * x, sint16 * y)	1403	maptile::xy_find (sint16 &x, sint16 &y)
2262	{	1404	{
2263
2264	if (*x < 0)	1405	if (x < 0)
2265	{	1406	{
2266	if (!m->tile_path[3])	1407	if (!tile_path[3])
2267	return NULL;	1408	return 0;
2268	if (!m->tile_map[3] || m->tile_map[3]->in_memory != MAP_IN_MEMORY)
2269	load_and_link_tiled_map (m, 3);
2270		1409
2271	*x += MAP_WIDTH (m->tile_map[3]);	1410	find_and_link (this, 3);
2272	return (get_map_from_coord (m->tile_map[3], x, y));	1411	x += tile_map[3]->width;
2273	}	1412	return tile_map[3]->xy_find (x, y);
2274	if (*x >= MAP_WIDTH (m))
2275	{	1413	}
		1414
		1415	if (x >= width)
		1416	{
2276	if (!m->tile_path[1])	1417	if (!tile_path[1])
2277	return NULL;	1418	return 0;
2278	if (!m->tile_map[1] || m->tile_map[1]->in_memory != MAP_IN_MEMORY)
2279	load_and_link_tiled_map (m, 1);
2280		1419
2281	*x -= MAP_WIDTH (m);	1420	find_and_link (this, 1);
2282	return (get_map_from_coord (m->tile_map[1], x, y));	1421	x -= width;
		1422	return tile_map[1]->xy_find (x, y);
2283	}	1423	}
		1424
2284	if (*y < 0)	1425	if (y < 0)
2285	{	1426	{
2286	if (!m->tile_path[0])	1427	if (!tile_path[0])
2287	return NULL;	1428	return 0;
2288	if (!m->tile_map[0] || m->tile_map[0]->in_memory != MAP_IN_MEMORY)
2289	load_and_link_tiled_map (m, 0);
2290		1429
2291	*y += MAP_HEIGHT (m->tile_map[0]);	1430	find_and_link (this, 0);
2292	return (get_map_from_coord (m->tile_map[0], x, y));	1431	y += tile_map[0]->height;
2293	}	1432	return tile_map[0]->xy_find (x, y);
2294	if (*y >= MAP_HEIGHT (m))
2295	{	1433	}
		1434
		1435	if (y >= height)
		1436	{
2296	if (!m->tile_path[2])	1437	if (!tile_path[2])
2297	return NULL;	1438	return 0;
2298	if (!m->tile_map[2] || m->tile_map[2]->in_memory != MAP_IN_MEMORY)
2299	load_and_link_tiled_map (m, 2);
2300		1439
2301	*y -= MAP_HEIGHT (m);	1440	find_and_link (this, 2);
2302	return (get_map_from_coord (m->tile_map[2], x, y));	1441	y -= height;
		1442	return tile_map[2]->xy_find (x, y);
2303	}	1443	}
2304		1444
2305	/* Simple case - coordinates are within this local	1445	/* Simple case - coordinates are within this local
2306	* map.	1446	* map.
2307	*/	1447	*/
2308
2309	return m;	1448	return this;
2310	}	1449	}
2311		1450
2312	/**	1451	/**
2313	* Return whether map2 is adjacent to map1. If so, store the distance from	1452	* Return whether map2 is adjacent to map1. If so, store the distance from
2314	* map1 to map2 in dx/dy.	1453	* map1 to map2 in dx/dy.
2315	*/	1454	*/
2316	static int	1455	static int
2317	adjacent_map (const mapstruct *map1, const mapstruct *map2, int *dx, int *dy)	1456	adjacent_map (const maptile *map1, const maptile *map2, int *dx, int *dy)
2318	{	1457	{
2319	if (!map1 || !map2)	1458	if (!map1 || !map2)
2320	return 0;	1459	return 0;
2321		1460
		1461	//TODO: this doesn't actually check corretcly when intermediate maps are not loaded
		1462	//fix: compare paths instead (this is likely faster, too!)
2322	if (map1 == map2)	1463	if (map1 == map2)
2323	{	1464	{
2324	*dx = 0;	1465	*dx = 0;
2325	*dy = 0;	1466	*dy = 0;
2326
2327	}	1467	}
2328	else if (map1->tile_map[0] == map2)	1468	else if (map1->tile_map[0] == map2)
2329	{ /* up */	1469	{ /* up */
2330	*dx = 0;	1470	*dx = 0;
2331	*dy = -MAP_HEIGHT (map2);	1471	*dy = -map2->height;
2332	}	1472	}
2333	else if (map1->tile_map[1] == map2)	1473	else if (map1->tile_map[1] == map2)
2334	{ /* right */	1474	{ /* right */
2335	*dx = MAP_WIDTH (map1);	1475	*dx = map1->width;
2336	*dy = 0;	1476	*dy = 0;
2337	}	1477	}
2338	else if (map1->tile_map[2] == map2)	1478	else if (map1->tile_map[2] == map2)
2339	{ /* down */	1479	{ /* down */
2340	*dx = 0;	1480	*dx = 0;
2341	*dy = MAP_HEIGHT (map1);	1481	*dy = map1->height;
2342	}	1482	}
2343	else if (map1->tile_map[3] == map2)	1483	else if (map1->tile_map[3] == map2)
2344	{ /* left */	1484	{ /* left */
2345	*dx = -MAP_WIDTH (map2);	1485	*dx = -map2->width;
2346	*dy = 0;	1486	*dy = 0;
2347
2348	}	1487	}
2349	else if (map1->tile_map[0] && map1->tile_map[0]->tile_map[1] == map2)	1488	else if (map1->tile_map[0] && map1->tile_map[0]->tile_map[1] == map2)
2350	{ /* up right */	1489	{ /* up right */
2351	*dx = MAP_WIDTH (map1->tile_map[0]);	1490	*dx = map1->tile_map[0]->width;
2352	*dy = -MAP_HEIGHT (map1->tile_map[0]);	1491	*dy = -map1->tile_map[0]->height;
2353	}	1492	}
2354	else if (map1->tile_map[0] && map1->tile_map[0]->tile_map[3] == map2)	1493	else if (map1->tile_map[0] && map1->tile_map[0]->tile_map[3] == map2)
2355	{ /* up left */	1494	{ /* up left */
2356	*dx = -MAP_WIDTH (map2);	1495	*dx = -map2->width;
2357	*dy = -MAP_HEIGHT (map1->tile_map[0]);	1496	*dy = -map1->tile_map[0]->height;
2358	}	1497	}
2359	else if (map1->tile_map[1] && map1->tile_map[1]->tile_map[0] == map2)	1498	else if (map1->tile_map[1] && map1->tile_map[1]->tile_map[0] == map2)
2360	{ /* right up */	1499	{ /* right up */
2361	*dx = MAP_WIDTH (map1);	1500	*dx = map1->width;
2362	*dy = -MAP_HEIGHT (map2);	1501	*dy = -map2->height;
2363	}	1502	}
2364	else if (map1->tile_map[1] && map1->tile_map[1]->tile_map[2] == map2)	1503	else if (map1->tile_map[1] && map1->tile_map[1]->tile_map[2] == map2)
2365	{ /* right down */	1504	{ /* right down */
2366	*dx = MAP_WIDTH (map1);	1505	*dx = map1->width;
2367	*dy = MAP_HEIGHT (map1->tile_map[1]);	1506	*dy = map1->tile_map[1]->height;
2368	}	1507	}
2369	else if (map1->tile_map[2] && map1->tile_map[2]->tile_map[1] == map2)	1508	else if (map1->tile_map[2] && map1->tile_map[2]->tile_map[1] == map2)
2370	{ /* down right */	1509	{ /* down right */
2371	*dx = MAP_WIDTH (map1->tile_map[2]);	1510	*dx = map1->tile_map[2]->width;
2372	*dy = MAP_HEIGHT (map1);	1511	*dy = map1->height;
2373	}	1512	}
2374	else if (map1->tile_map[2] && map1->tile_map[2]->tile_map[3] == map2)	1513	else if (map1->tile_map[2] && map1->tile_map[2]->tile_map[3] == map2)
2375	{ /* down left */	1514	{ /* down left */
2376	*dx = -MAP_WIDTH (map2);	1515	*dx = -map2->width;
2377	*dy = MAP_HEIGHT (map1);	1516	*dy = map1->height;
2378	}	1517	}
2379	else if (map1->tile_map[3] && map1->tile_map[3]->tile_map[0] == map2)	1518	else if (map1->tile_map[3] && map1->tile_map[3]->tile_map[0] == map2)
2380	{ /* left up */	1519	{ /* left up */
2381	*dx = -MAP_WIDTH (map1->tile_map[3]);	1520	*dx = -map1->tile_map[3]->width;
2382	*dy = -MAP_HEIGHT (map2);	1521	*dy = -map2->height;
2383	}	1522	}
2384	else if (map1->tile_map[3] && map1->tile_map[3]->tile_map[2] == map2)	1523	else if (map1->tile_map[3] && map1->tile_map[3]->tile_map[2] == map2)
2385	{ /* left down */	1524	{ /* left down */
2386	*dx = -MAP_WIDTH (map1->tile_map[3]);	1525	*dx = -map1->tile_map[3]->width;
2387	*dy = MAP_HEIGHT (map1->tile_map[3]);	1526	*dy = map1->tile_map[3]->height;
2388
2389	}	1527	}
2390	else	1528	else
2391	{ /* not "adjacent" enough */
2392	return 0;	1529	return 0;
2393	}
2394		1530
2395	return 1;	1531	return 1;
		1532	}
		1533
		1534	maptile *
		1535	maptile::xy_load (sint16 &x, sint16 &y)
		1536	{
		1537	maptile *map = xy_find (x, y);
		1538
		1539	if (map)
		1540	map->load_sync ();
		1541
		1542	return map;
		1543	}
		1544
		1545	maptile *
		1546	get_map_from_coord (maptile *m, sint16 *x, sint16 *y)
		1547	{
		1548	return m->xy_load (*x, *y);
2396	}	1549	}
2397		1550
2398	/* From map.c	1551	/* From map.c
2399	* This is used by get_player to determine where the other	1552	* This is used by get_player to determine where the other
2400	* creature is. get_rangevector takes into account map tiling,	1553	* creature is. get_rangevector takes into account map tiling,
…		…
2413	* be unexpected	1566	* be unexpected
2414	*	1567	*
2415	* currently, the only flag supported (0x1) is don't translate for	1568	* currently, the only flag supported (0x1) is don't translate for
2416	* closest body part of 'op1'	1569	* closest body part of 'op1'
2417	*/	1570	*/
2418
2419	void	1571	void
2420	get_rangevector (object *op1, object *op2, rv_vector * retval, int flags)	1572	get_rangevector (object *op1, object *op2, rv_vector * retval, int flags)
2421	{	1573	{
2422	if (!adjacent_map (op1->map, op2->map, &retval->distance_x, &retval->distance_y))	1574	if (!adjacent_map (op1->map, op2->map, &retval->distance_x, &retval->distance_y))
2423	{	1575	{
…		…
2480	* for something in the future. Also, since no object is pasted, the best	1632	* for something in the future. Also, since no object is pasted, the best
2481	* field of the rv_vector is set to NULL.	1633	* field of the rv_vector is set to NULL.
2482	*/	1634	*/
2483		1635
2484	void	1636	void
2485	get_rangevector_from_mapcoord (const mapstruct *m, int x, int y, const object *op2, rv_vector * retval, int flags)	1637	get_rangevector_from_mapcoord (const maptile *m, int x, int y, const object *op2, rv_vector * retval, int flags)
2486	{	1638	{
2487	if (!adjacent_map (m, op2->map, &retval->distance_x, &retval->distance_y))	1639	if (!adjacent_map (m, op2->map, &retval->distance_x, &retval->distance_y))
2488	{	1640	{
2489	/* be conservative and fill in _some_ data */	1641	/* be conservative and fill in _some_ data */
2490	retval->distance = 100000;	1642	retval->distance = 100000;
…		…
2504	}	1656	}
2505	}	1657	}
2506		1658
2507	/* Returns true of op1 and op2 are effectively on the same map	1659	/* Returns true of op1 and op2 are effectively on the same map
2508	* (as related to map tiling). Note that this looks for a path from	1660	* (as related to map tiling). Note that this looks for a path from
2509	* op1 to op2, so if the tiled maps are assymetric and op2 has a path	1661	* op1 to op2, so if the tiled maps are asymetric and op2 has a path
2510	* to op1, this will still return false.	1662	* to op1, this will still return false.
2511	* Note we only look one map out to keep the processing simple	1663	* Note we only look one map out to keep the processing simple
2512	* and efficient. This could probably be a macro.	1664	* and efficient. This could probably be a macro.
2513	* MSW 2001-08-05	1665	* MSW 2001-08-05
2514	*/	1666	*/
…		…
2517	{	1669	{
2518	int dx, dy;	1670	int dx, dy;
2519		1671
2520	return adjacent_map (op1->map, op2->map, &dx, &dy);	1672	return adjacent_map (op1->map, op2->map, &dx, &dy);
2521	}	1673	}
		1674
		1675	object *
		1676	maptile::insert (object *op, int x, int y, object *originator, int flags)
		1677	{
		1678	if (!op->flag [FLAG_REMOVED])
		1679	op->remove ();
		1680
		1681	return insert_ob_in_map_at (op, this, originator, flags, x, y);
		1682	}
		1683

Diff Legend

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