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.71 by pippijn, Sat Jan 6 14:42:29 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 (cede_count >= 500)
		504	{
		505	cede_count = 0;
		506	coroapi::cede ();
		507	}
		508
		509	int unique = 0;
		510	for (object *op = spaces [i].bot; op; op = op->above)
		511	{
		512	// count per-object, but cede only when modification-safe
		513	cede_count++;
		514
		515	if (op->flag [FLAG_UNIQUE] && op->flag [FLAG_IS_FLOOR])
		516	unique = 1;
		517
		518	if (!op->can_map_save ())
647	continue;	519	continue;
648		520
649	if (unique || QUERY_FLAG (op, FLAG_UNIQUE))	521	if (unique || op->flag [FLAG_UNIQUE])
650	save_object (fp2, op, 3);	522	{
651	else if (flag == 0 || (flag == 2 && (!QUERY_FLAG (op, FLAG_OBJ_ORIGINAL) && !QUERY_FLAG (op, FLAG_UNPAID))))	523	if (flags & IO_UNIQUES)
652	save_object (fp, op, 3);	524	save_object (freezer, op, 1);
		525	}
		526	else if (flags & IO_OBJECTS)
		527	save_object (freezer, op, 1);
		528	}
		529	}
653		530
654	} /* for this space */	531	return true;
655	} /* for this j */
656	}	532	}
657		533
658	/*	534	bool
659	* Allocates, initialises, and returns a pointer to a mapstruct.	535	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	{	536	{
667	mapstruct *map = new mapstruct;	537	object_thawer thawer (path);
668	mapstruct *mp;
669		538
670	for (mp = first_map; mp != NULL && mp->next != NULL; mp = mp->next);	539	if (!thawer)
671	if (mp == NULL)	540	return false;
672	first_map = map;
673	else
674	mp->next = map;
675		541
		542	if (skip_header)
		543	for (;;)
		544	{
		545	keyword kw = thawer.get_kv ();
		546
		547	if (kw == KW_end)
		548	break;
		549
		550	thawer.skip_kv (kw);
		551	}
		552
		553	return load_objects (thawer);
		554	}
		555
		556	bool
		557	maptile::save_objects (const char *path, int flags)
		558	{
		559	object_freezer freezer;
		560
		561	if (!save_objects (freezer, flags))
		562	return false;
		563
		564	return freezer.save (path);
		565	}
		566
		567	maptile::maptile ()
		568	{
676	map->in_memory = MAP_SWAPPED;	569	in_memory = MAP_SWAPPED;
		570
677	/* The maps used to pick up default x and y values from the	571	/* The maps used to pick up default x and y values from the
678	* map archetype. Mimic that behaviour.	572	* map archetype. Mimic that behaviour.
679	*/	573	*/
680	MAP_WIDTH (map) = 16;	574	width = 16;
681	MAP_HEIGHT (map) = 16;	575	height = 16;
682	MAP_RESET_TIMEOUT (map) = 0;	576	reset_timeout = 0;
683	MAP_TIMEOUT (map) = 300;	577	timeout = 300;
684	MAP_ENTER_X (map) = 0;	578	enter_x = 0;
685	MAP_ENTER_Y (map) = 0;	579	enter_y = 0;
686	/*set part to -1 indicating conversion to weather map not yet done */	580	}
687	MAP_WORLDPARTX (map) = -1;	581
688	MAP_WORLDPARTY (map) = -1;	582	maptile::maptile (int w, int h)
689	return map;	583	{
		584	in_memory = MAP_SWAPPED;
		585
		586	width = w;
		587	height = h;
		588	reset_timeout = 0;
		589	timeout = 300;
		590	enter_x = 0;
		591	enter_y = 0;
		592
		593	alloc ();
690	}	594	}
691		595
692	/*	596	/*
693	* Allocates the arrays contained in a mapstruct.	597	* Allocates the arrays contained in a maptile.
694	* This basically allocates the dynamic array of spaces for the	598	* This basically allocates the dynamic array of spaces for the
695	* map.	599	* map.
696	*/	600	*/
697
698	void	601	void
699	allocate_map (mapstruct *m)	602	maptile::alloc ()
700	{	603	{
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)	604	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;	605	return;
		606
		607	spaces = salloc0<mapspace> (size ());
731	}	608	}
732		609
733	/* Takes a string from a map definition and outputs a pointer to the array of shopitems	610	/* 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	611	* corresponding to that string. Memory is allocated for this, it must be freed
735	* at a later date.	612	* at a later date.
736	* Called by parse_map_headers below.	613	* Called by parse_map_headers below.
737	*/	614	*/
738
739	static shopitems *	615	static shopitems *
740	parse_shop_string (const char *input_string)	616	parse_shop_string (const char *input_string)
741	{	617	{
742	char *shop_string, *p, *q, *next_semicolon, *next_colon;	618	char *shop_string, *p, *q, *next_semicolon, *next_colon;
743	shopitems *items = NULL;	619	shopitems *items = NULL;
744	int i = 0, number_of_entries = 0;	620	int i = 0, number_of_entries = 0;
745	const typedata *current_type;	621	const typedata *current_type;
746		622
747	shop_string = strdup_local (input_string);	623	shop_string = strdup (input_string);
748	p = shop_string;	624	p = shop_string;
749	/* first we'll count the entries, we'll need that for allocating the array shortly */	625	/* first we'll count the entries, we'll need that for allocating the array shortly */
750	while (p)	626	while (p)
751	{	627	{
752	p = strchr (p, ';');	628	p = strchr (p, ';');
753	number_of_entries++;	629	number_of_entries++;
754	if (p)	630	if (p)
755	p++;	631	p++;
756	}	632	}
		633
757	p = shop_string;	634	p = shop_string;
758	strip_endline (p);	635	strip_endline (p);
759	items = new shopitems[number_of_entries + 1];	636	items = new shopitems[number_of_entries + 1];
760	for (i = 0; i < number_of_entries; i++)	637	for (i = 0; i < number_of_entries; i++)
761	{	638	{
762	if (!p)	639	if (!p)
763	{	640	{
764	LOG (llevError, "parse_shop_string: I seem to have run out of string, that shouldn't happen.\n");	641	LOG (llevError, "parse_shop_string: I seem to have run out of string, that shouldn't happen.\n");
765	break;	642	break;
766	}	643	}
		644
767	next_semicolon = strchr (p, ';');	645	next_semicolon = strchr (p, ';');
768	next_colon = strchr (p, ':');	646	next_colon = strchr (p, ':');
769	/* if there is a stregth specified, figure out what it is, we'll need it soon. */	647	/* 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))	648	if (next_colon && (!next_semicolon || next_colon < next_semicolon))
771	items[i].strength = atoi (strchr (p, ':') + 1);	649	items[i].strength = atoi (strchr (p, ':') + 1);
…		…
798	* the next entry while we're at it, better print a warning	676	* the next entry while we're at it, better print a warning
799	*/	677	*/
800	LOG (llevError, "invalid type %s defined in shopitems in string %s\n", p, input_string);	678	LOG (llevError, "invalid type %s defined in shopitems in string %s\n", p, input_string);
801	}	679	}
802	}	680	}
		681
803	items[i].index = number_of_entries;	682	items[i].index = number_of_entries;
804	if (next_semicolon)	683	if (next_semicolon)
805	p = ++next_semicolon;	684	p = ++next_semicolon;
806	else	685	else
807	p = NULL;	686	p = NULL;
808	}	687	}
		688
809	free (shop_string);	689	free (shop_string);
810	return items;	690	return items;
811	}	691	}
812		692
813	/* opposite of parse string, this puts the string that was originally fed in to	693	/* opposite of parse string, this puts the string that was originally fed in to
814	* the map (or something equivilent) into output_string. */	694	* the map (or something equivilent) into output_string. */
815	static void	695	static void
816	print_shop_string (mapstruct *m, char *output_string)	696	print_shop_string (maptile *m, char *output_string)
817	{	697	{
818	int i;	698	int i;
819	char tmp[MAX_BUF];	699	char tmp[MAX_BUF];
820		700
821	strcpy (output_string, "");	701	strcpy (output_string, "");
822	for (i = 0; i < m->shopitems[0].index; i++)	702	for (i = 0; i < m->shopitems[0].index; i++)
823	{	703	{
824	if (m->shopitems[i].typenum)	704	if (m->shopitems[i].typenum)
825	{	705	{
826	if (m->shopitems[i].strength)	706	if (m->shopitems[i].strength)
827	{
828	sprintf (tmp, "%s:%d;", m->shopitems[i].name, m->shopitems[i].strength);	707	sprintf (tmp, "%s:%d;", m->shopitems[i].name, m->shopitems[i].strength);
829	}
830	else	708	else
831	sprintf (tmp, "%s;", m->shopitems[i].name);	709	sprintf (tmp, "%s;", m->shopitems[i].name);
832	}	710	}
833	else	711	else
834	{	712	{
835	if (m->shopitems[i].strength)	713	if (m->shopitems[i].strength)
836	{
837	sprintf (tmp, "*:%d;", m->shopitems[i].strength);	714	sprintf (tmp, "*:%d;", m->shopitems[i].strength);
838	}
839	else	715	else
840	sprintf (tmp, "*");	716	sprintf (tmp, "*");
841	}	717	}
		718
842	strcat (output_string, tmp);	719	strcat (output_string, tmp);
843	}	720	}
844	}	721	}
845		722
846	/* This loads the header information of the map. The header	723	/* This loads the header information of the map. The header
…		…
851	* put all the stuff in the map object so that names actually make	728	* put all the stuff in the map object so that names actually make
852	* sense.	729	* sense.
853	* This could be done in lex (like the object loader), but I think	730	* 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.	731	* currently, there are few enough fields this is not a big deal.
855	* MSW 2001-07-01	732	* MSW 2001-07-01
856	* return 0 on success, 1 on failure.
857	*/	733	*/
858		734	bool
859	static int	735	maptile::load_header (object_thawer &thawer)
860	load_map_header (object_thawer & fp, mapstruct *m)
861	{	736	{
862	char buf[HUGE_BUF], msgbuf[HUGE_BUF], maplorebuf[HUGE_BUF], *key = NULL, *value, *end;	737	for (;;)
863	int msgpos = 0;
864	int maplorepos = 0;
865
866	while (fgets (buf, HUGE_BUF - 1, fp) != NULL)
867	{	738	{
868	buf[HUGE_BUF - 1] = 0;	739	keyword kw = thawer.get_kv ();
869	key = buf;	740
870	while (isspace (*key))	741	switch (kw)
871	key++;
872	if (*key == 0)
873	continue; /* empty line */
874	value = strchr (key, ' ');
875	if (!value)
876	{	742	{
877	end = strchr (key, '\n');	743	case KW_EOF:
878	if (end != NULL)	744	LOG (llevError, "%s: end of file while reading map header, aborting header load.\n", &path);
		745	return false;
		746
		747	case KW_end:
		748	return true;
		749
		750	default:
		751	case KW_ERROR:
		752	LOG (llevError, "%s: skipping errornous line (%s) while reading map header.\n", &path, thawer.last_keyword);
879	{	753	break;
880	*end = 0;	754
		755	case KW_msg:
		756	thawer.get_ml (KW_endmsg, msg);
881	}	757	break;
		758
		759	case KW_lore: // CF+ extension
		760	thawer.get_ml (KW_endlore, maplore);
		761	break;
		762
		763	case KW_maplore:
		764	thawer.get_ml (KW_endmaplore, maplore);
		765	break;
		766
		767	case KW_arch:
		768	if (strcmp (thawer.get_str (), "map"))
		769	LOG (llevError, "%s: loading map and got a non 'arch map' line (arch %s), skipping.\n", &path, thawer.get_str ());
		770	break;
		771
		772	case KW_oid:
		773	thawer.get (this, thawer.get_sint32 ());
		774	break;
		775
		776	case KW_file_format_version: break; // nop
		777
		778	case KW_name: thawer.get (name); break;
		779	case KW_attach: thawer.get (attach); break;
		780	case KW_reset_time: thawer.get (reset_time); break;
		781	case KW_shopgreed: thawer.get (shopgreed); break;
		782	case KW_shopmin: thawer.get (shopmin); break;
		783	case KW_shopmax: thawer.get (shopmax); break;
		784	case KW_shoprace: thawer.get (shoprace); break;
		785	case KW_outdoor: thawer.get (outdoor); break;
		786	case KW_temp: thawer.get (temp); break;
		787	case KW_pressure: thawer.get (pressure); break;
		788	case KW_humid: thawer.get (humid); break;
		789	case KW_windspeed: thawer.get (windspeed); break;
		790	case KW_winddir: thawer.get (winddir); break;
		791	case KW_sky: thawer.get (sky); break;
		792
		793	case KW_per_player: thawer.get (per_player); break;
		794	case KW_per_party: thawer.get (per_party); break;
		795
		796	case KW_region: get_region_by_name (thawer.get_str ()); break;
		797	case KW_shopitems: shopitems = parse_shop_string (thawer.get_str ()); break;
		798
		799	// old names new names
		800	case KW_hp: case KW_enter_x: thawer.get (enter_x); break;
		801	case KW_sp: case KW_enter_y: thawer.get (enter_y); break;
		802	case KW_x: case KW_width: thawer.get (width); break;
		803	case KW_y: case KW_height: thawer.get (height); break;
		804	case KW_weight: case KW_reset_timeout: thawer.get (reset_timeout); break;
		805	case KW_value: case KW_swap_time: thawer.get (timeout); break;
		806	case KW_level: case KW_difficulty: thawer.get (difficulty); difficulty = clamp (difficulty, 1, settings.max_level); break;
		807	case KW_invisible: case KW_darkness: thawer.get (darkness); break;
		808	case KW_stand_still: case KW_fixed_resettime: thawer.get (fixed_resettime); break;
		809
		810	case KW_tile_path_1: thawer.get (tile_path [0]); break;
		811	case KW_tile_path_2: thawer.get (tile_path [1]); break;
		812	case KW_tile_path_3: thawer.get (tile_path [2]); break;
		813	case KW_tile_path_4: thawer.get (tile_path [3]); break;
882	}	814	}
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	{	815	}
1149	LOG (llevError, "Got premature eof on map header!\n");
1150	return 1;
1151	}
1152	return 0;
1153	}
1154		816
1155	/*	817	abort ();
1156	* Opens the file "filename" and reads information about the map	818	}
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		819
1167	mapstruct *	820	bool
1168	load_original_map (const char *filename, int flags)	821	maptile::load_header (const char *path)
1169	{	822	{
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);	823	object_thawer thawer (path);
1183		824
1184	if (!thawer)	825	if (!thawer)
1185	return 0;	826	return false;
1186		827
1187	m = get_linked_map ();	828	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	}	829	}
1296		830
1297	/******************************************************************************	831	/******************************************************************************
1298	* This is the start of unique map handling code	832	* This is the start of unique map handling code
1299	*****************************************************************************/	833	*****************************************************************************/
1300		834
1301	/* This goes through map 'm' and removed any unique items on the map. */	835	/* This goes through the maptile and removed any unique items on the map. */
1302	static void	836	void
1303	delete_unique_items (mapstruct *m)	837	maptile::clear_unique_items ()
1304	{	838	{
1305	int i, j, unique;	839	for (int i = 0; i < size (); ++i)
1306	object *op, *next;	840	{
		841	int unique = 0;
		842	for (object *op = spaces [i].bot; op; )
		843	{
		844	object *above = op->above;
1307		845
1308	for (i = 0; i < MAP_WIDTH (m); i++)	846	if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE))
1309	for (j = 0; j < MAP_HEIGHT (m); j++)	847	unique = 1;
		848
		849	if (op->head == NULL && (QUERY_FLAG (op, FLAG_UNIQUE) || unique))
		850	{
		851	op->destroy_inv (false);
		852	op->destroy ();
		853	}
		854
		855	op = above;
		856	}
		857	}
		858	}
		859
		860	bool
		861	maptile::save_header (object_freezer &freezer)
		862	{
		863	#define MAP_OUT(k) freezer.put (KW_ ## k, k)
		864	#define MAP_OUT2(k,v) freezer.put (KW_ ## k, v)
		865
		866	MAP_OUT2 (arch, "map");
		867
		868	if (name) MAP_OUT (name);
		869	MAP_OUT (swap_time);
		870	MAP_OUT (reset_time);
		871	MAP_OUT (reset_timeout);
		872	MAP_OUT (fixed_resettime);
		873	MAP_OUT (difficulty);
		874
		875	if (region) MAP_OUT2 (region, region->name);
		876
		877	if (shopitems)
		878	{
		879	char shop[MAX_BUF];
		880	print_shop_string (this, shop);
		881	MAP_OUT2 (shopitems, shop);
		882	}
		883
		884	MAP_OUT (shopgreed);
		885	MAP_OUT (shopmin);
		886	MAP_OUT (shopmax);
		887	if (shoprace) MAP_OUT (shoprace);
		888	MAP_OUT (darkness);
		889	MAP_OUT (width);
		890	MAP_OUT (height);
		891	MAP_OUT (enter_x);
		892	MAP_OUT (enter_y);
		893
		894	if (msg) freezer.put (KW_msg , KW_endmsg , msg);
		895	if (maplore) freezer.put (KW_maplore, KW_endmaplore, maplore);
		896
		897	MAP_OUT (outdoor);
		898	MAP_OUT (temp);
		899	MAP_OUT (pressure);
		900	MAP_OUT (humid);
		901	MAP_OUT (windspeed);
		902	MAP_OUT (winddir);
		903	MAP_OUT (sky);
		904
		905	MAP_OUT (per_player);
		906	MAP_OUT (per_party);
		907
		908	if (tile_path [0]) MAP_OUT2 (tile_path_1, tile_path [0]);
		909	if (tile_path [1]) MAP_OUT2 (tile_path_2, tile_path [1]);
		910	if (tile_path [2]) MAP_OUT2 (tile_path_3, tile_path [2]);
		911	if (tile_path [3]) MAP_OUT2 (tile_path_4, tile_path [3]);
		912
		913	freezer.put (this);
		914	freezer.put (KW_end);
		915
		916	return true;
		917	}
		918
		919	bool
		920	maptile::save_header (const char *path)
		921	{
		922	object_freezer freezer;
		923
		924	if (!save_header (freezer))
		925	return false;
		926
		927	return freezer.save (path);
		928	}
		929
		930	/*
		931	* Remove and free all objects in the given map.
		932	*/
		933	void
		934	maptile::clear ()
		935	{
		936	if (!spaces)
		937	return;
		938
		939	for (mapspace *ms = spaces + size (); ms-- > spaces; )
		940	while (object *op = ms->bot)
1310	{	941	{
1311	unique = 0;	942	if (op->head)
1312	for (op = get_map_ob (m, i, j); op; op = next)	943	op = op->head;
		944
		945	op->destroy_inv (false);
		946	op->destroy ();
		947	}
		948
		949	sfree (spaces, size ()), spaces = 0;
		950
		951	if (buttons)
		952	free_objectlinkpt (buttons), buttons = 0;
		953	}
		954
		955	void
		956	maptile::clear_header ()
		957	{
		958	name = 0;
		959	msg = 0;
		960	maplore = 0;
		961	shoprace = 0;
		962	delete [] shopitems, shopitems = 0;
		963
		964	for (int i = 0; i < 4; i++)
		965	tile_path [i] = 0;
		966	}
		967
		968	maptile::~maptile ()
		969	{
		970	assert (destroyed ());
		971	}
		972
		973	void
		974	maptile::clear_links_to (maptile *m)
		975	{
		976	/* We need to look through all the maps and see if any maps
		977	* are pointing at this one for tiling information. Since
		978	* tiling can be asymetric, we just can not look to see which
		979	* maps this map tiles with and clears those.
		980	*/
		981	for (int i = 0; i < 4; i++)
		982	if (tile_map[i] == m)
		983	tile_map[i] = 0;
		984	}
		985
		986	void
		987	maptile::do_destroy ()
		988	{
		989	attachable::do_destroy ();
		990
		991	clear ();
		992	}
		993
		994	/*
		995	* Updates every button on the map (by calling update_button() for them).
		996	*/
		997	void
		998	maptile::update_buttons ()
		999	{
		1000	for (oblinkpt *obp = buttons; obp; obp = obp->next)
		1001	for (objectlink *ol = obp->link; ol; ol = ol->next)
		1002	{
		1003	if (!ol->ob)
1313	{	1004	{
1314	next = op->above;	1005	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))	1006	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;	1007	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	}	1008	}
		1009
		1010	if (ol->ob->type == BUTTON || ol->ob->type == PEDESTAL)
		1011	{
		1012	update_button (ol->ob);
		1013	break;
1325	}	1014	}
1326	}	1015	}
1327	}	1016	}
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		1017
1807	/*	1018	/*
1808	* This routine is supposed to find out the difficulty of the map.	1019	* This routine is supposed to find out the difficulty of the map.
1809	* difficulty does not have a lot to do with character level,	1020	* difficulty does not have a lot to do with character level,
1810	* but does have a lot to do with treasure on the map.	1021	* 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	1023	* 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	1024	* in the map is zero, then use this routine. Maps should really
1814	* have a difficulty set than using this function - human calculation	1025	* have a difficulty set than using this function - human calculation
1815	* is much better than this functions guesswork.	1026	* is much better than this functions guesswork.
1816	*/	1027	*/
1817
1818	int	1028	int
1819	calculate_difficulty (mapstruct *m)	1029	maptile::estimate_difficulty () const
1820	{	1030	{
1821	object *op;
1822	archetype *at;
1823	int x, y, i;
1824	long monster_cnt = 0;	1031	long monster_cnt = 0;
1825	double avgexp = 0;	1032	double avgexp = 0;
1826	sint64 total_exp = 0;	1033	sint64 total_exp = 0;
1827		1034
1828	if (MAP_DIFFICULTY (m))	1035	for (mapspace *ms = spaces + size (); ms-- > spaces; )
1829	{	1036	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	{	1037	{
1838	if (QUERY_FLAG (op, FLAG_MONSTER))	1038	if (QUERY_FLAG (op, FLAG_MONSTER))
1839	{	1039	{
1840	total_exp += op->stats.exp;	1040	total_exp += op->stats.exp;
1841	monster_cnt++;	1041	monster_cnt++;
1842	}	1042	}
1843		1043
1844	if (QUERY_FLAG (op, FLAG_GENERATOR))	1044	if (QUERY_FLAG (op, FLAG_GENERATOR))
1845	{	1045	{
1846	total_exp += op->stats.exp;	1046	total_exp += op->stats.exp;
		1047
1847	at = type_to_archetype (GENERATE_TYPE (op));	1048	if (archetype *at = type_to_archetype (GENERATE_TYPE (op)))
1848
1849	if (at != NULL)
1850	total_exp += at->clone.stats.exp * 8;	1049	total_exp += at->clone.stats.exp * 8;
1851		1050
1852	monster_cnt++;	1051	monster_cnt++;
1853	}	1052	}
1854	}	1053	}
1855		1054
1856	avgexp = (double) total_exp / monster_cnt;	1055	avgexp = (double) total_exp / monster_cnt;
1857		1056
1858	for (i = 1; i <= settings.max_level; i++)	1057	for (int i = 1; i <= settings.max_level; i++)
1859	{
1860	if ((level_exp (i, 1) - level_exp (i - 1, 1)) > (100 * avgexp))	1058	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;	1059	return i;
1864	}
1865	}
1866		1060
1867	return 1;	1061	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	}	1062	}
1896		1063
1897	/* change_map_light() - used to change map light level (darkness)	1064	/* change_map_light() - used to change map light level (darkness)
1898	* up or down. Returns true if successful. It should now be	1065	* up or down. Returns true if successful. It should now be
1899	* possible to change a value by more than 1.	1066	* possible to change a value by more than 1.
1900	* Move this from los.c to map.c since this is more related	1067	* Move this from los.c to map.c since this is more related
1901	* to maps than los.	1068	* to maps than los.
1902	* postive values make it darker, negative make it brighter	1069	* postive values make it darker, negative make it brighter
1903	*/	1070	*/
1904
1905	int	1071	int
1906	change_map_light (mapstruct *m, int change)	1072	maptile::change_map_light (int change)
1907	{	1073	{
1908	int new_level = m->darkness + change;	1074	int new_level = darkness + change;
1909		1075
1910	/* Nothing to do */	1076	/* Nothing to do */
1911	if (!change || (new_level <= 0 && m->darkness == 0) || (new_level >= MAX_DARKNESS && m->darkness >= MAX_DARKNESS))	1077	if (!change || (new_level <= 0 && darkness == 0) || (new_level >= MAX_DARKNESS && darkness >= MAX_DARKNESS))
1912	{
1913	return 0;	1078	return 0;
1914	}
1915		1079
1916	/* inform all players on the map */	1080	/* inform all players on the map */
1917	if (change > 0)	1081	if (change > 0)
1918	new_info_map (NDI_BLACK | NDI_UNIQUE, m, "It becomes darker.");	1082	new_info_map (NDI_BLACK | NDI_UNIQUE, this, "It becomes darker.");
1919	else	1083	else
1920	new_info_map (NDI_BLACK | NDI_UNIQUE, m, "It becomes brighter.");	1084	new_info_map (NDI_BLACK | NDI_UNIQUE, this, "It becomes brighter.");
1921		1085
1922	/* Do extra checking. since m->darkness is a unsigned value,	1086	/* Do extra checking. since darkness is a unsigned value,
1923	* we need to be extra careful about negative values.	1087	* we need to be extra careful about negative values.
1924	* In general, the checks below are only needed if change	1088	* In general, the checks below are only needed if change
1925	* is not +/-1	1089	* is not +/-1
1926	*/	1090	*/
1927	if (new_level < 0)	1091	if (new_level < 0)
1928	m->darkness = 0;	1092	darkness = 0;
1929	else if (new_level >= MAX_DARKNESS)	1093	else if (new_level >= MAX_DARKNESS)
1930	m->darkness = MAX_DARKNESS;	1094	darkness = MAX_DARKNESS;
1931	else	1095	else
1932	m->darkness = new_level;	1096	darkness = new_level;
1933		1097
1934	/* All clients need to get re-updated for the change */	1098	/* All clients need to get re-updated for the change */
1935	update_all_map_los (m);	1099	update_all_map_los (this);
1936	return 1;	1100	return 1;
1937	}	1101	}
1938
1939		1102
1940	/*	1103	/*
1941	* This function updates various attributes about a specific space	1104	* This function updates various attributes about a specific space
1942	* on the map (what it looks like, whether it blocks magic,	1105	* on the map (what it looks like, whether it blocks magic,
1943	* has a living creatures, prevents people from passing	1106	* has a living creatures, prevents people from passing
1944	* through, etc)	1107	* through, etc)
1945	*/	1108	*/
1946	void	1109	void
1947	update_position (mapstruct *m, int x, int y)	1110	mapspace::update_ ()
1948	{	1111	{
1949	object *tmp, *last = NULL;	1112	object *tmp, *last = 0;
1950	uint8 flags = 0, oldflags, light = 0, anywhere = 0;	1113	uint8 flags = 0, light = 0, anywhere = 0;
1951	New_Face *top, *floor, *middle;	1114	New_Face *top, *floor, *middle;
1952	object *top_obj, *floor_obj, *middle_obj;	1115	object *top_obj, *floor_obj, *middle_obj;
1953	MoveType move_block = 0, move_slow = 0, move_on = 0, move_off = 0, move_allow = 0;	1116	MoveType move_block = 0, move_slow = 0, move_on = 0, move_off = 0, move_allow = 0;
1954		1117
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;	1118	middle = blank_face;
1963	top = blank_face;	1119	top = blank_face;
1964	floor = blank_face;	1120	floor = blank_face;
1965		1121
1966	middle_obj = NULL;	1122	middle_obj = 0;
1967	top_obj = NULL;	1123	top_obj = 0;
1968	floor_obj = NULL;	1124	floor_obj = 0;
1969		1125
1970	for (tmp = get_map_ob (m, x, y); tmp; last = tmp, tmp = tmp->above)	1126	for (tmp = bot; tmp; last = tmp, tmp = tmp->above)
1971	{	1127	{
1972
1973	/* This could be made additive I guess (two lights better than	1128	/* This could be made additive I guess (two lights better than
1974	* one). But if so, it shouldn't be a simple additive - 2	1129	* one). But if so, it shouldn't be a simple additive - 2
1975	* light bulbs do not illuminate twice as far as once since	1130	* light bulbs do not illuminate twice as far as once since
1976	* it is a disapation factor that is squared (or is it cubed?)	1131	* it is a dissapation factor that is cubed.
1977	*/	1132	*/
1978	if (tmp->glow_radius > light)	1133	if (tmp->glow_radius > light)
1979	light = tmp->glow_radius;	1134	light = tmp->glow_radius;
1980		1135
1981	/* This call is needed in order to update objects the player	1136	/* This call is needed in order to update objects the player
…		…
2019	{	1174	{
2020	middle = tmp->face;	1175	middle = tmp->face;
2021	middle_obj = tmp;	1176	middle_obj = tmp;
2022	}	1177	}
2023	}	1178	}
		1179
2024	if (tmp == tmp->above)	1180	if (tmp == tmp->above)
2025	{	1181	{
2026	LOG (llevError, "Error in structure of map\n");	1182	LOG (llevError, "Error in structure of map\n");
2027	exit (-1);	1183	exit (-1);
2028	}	1184	}
2029		1185
2030	move_slow |= tmp->move_slow;	1186	move_slow |= tmp->move_slow;
2031	move_block |= tmp->move_block;	1187	move_block |= tmp->move_block;
2032	move_on |= tmp->move_on;	1188	move_on |= tmp->move_on;
2033	move_off |= tmp->move_off;	1189	move_off |= tmp->move_off;
2034	move_allow |= tmp->move_allow;	1190	move_allow |= tmp->move_allow;
2035		1191
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))	1192	if (QUERY_FLAG (tmp, FLAG_BLOCKSVIEW)) flags |= P_BLOCKSVIEW;
2046	flags |= P_BLOCKSVIEW;	1193	if (QUERY_FLAG (tmp, FLAG_NO_MAGIC)) flags |= P_NO_MAGIC;
2047	} /* for stack of objects */	1194	if (tmp->type == PLAYER) flags |= P_PLAYER;
2048		1195	if (tmp->type == SAFE_GROUND) flags |= P_SAFE;
2049	/* we don't want to rely on this function to have accurate flags, but	1196	if (QUERY_FLAG (tmp, FLAG_ALIVE)) flags |= P_IS_ALIVE;
2050	* since we're already doing the work, we calculate them here.	1197	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	{	1198	}
2055	LOG (llevDebug, "update_position: updated flags do not match old flags: %s (old=%d,new=%d) %x != %x\n",	1199
2056	m->path, x, y, (oldflags & ~P_NEED_UPDATE), flags);	1200	this->light = light;
2057	}	1201	this->flags_ = flags;
2058	SET_MAP_FLAGS (m, x, y, flags);	1202	this->move_block = move_block & ~move_allow;
2059	SET_MAP_MOVE_BLOCK (m, x, y, move_block & ~move_allow);	1203	this->move_on = move_on;
2060	SET_MAP_MOVE_ON (m, x, y, move_on);	1204	this->move_off = move_off;
2061	SET_MAP_MOVE_OFF (m, x, y, move_off);	1205	this->move_slow = move_slow;
2062	SET_MAP_MOVE_SLOW (m, x, y, move_slow);
2063		1206
2064	/* At this point, we have a floor face (if there is a floor),	1207	/* 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	1208	* and the floor is set - we are not going to touch it at
2066	* this point.	1209	* this point.
2067	* middle contains the highest visibility face.	1210	* middle contains the highest visibility face.
…		…
2092		1235
2093	/* If two top faces are already set, quit processing */	1236	/* If two top faces are already set, quit processing */
2094	if ((top != blank_face) && (middle != blank_face))	1237	if ((top != blank_face) && (middle != blank_face))
2095	break;	1238	break;
2096		1239
2097	/* Only show visible faces, unless its the editor - show all */	1240	/* Only show visible faces */
2098	if (!tmp->invisible || editor)	1241	if (!tmp->invisible)
2099	{	1242	{
2100	/* Fill in top if needed */	1243	/* Fill in top if needed */
2101	if (top == blank_face)	1244	if (top == blank_face)
2102	{	1245	{
2103	top = tmp->face;	1246	top = tmp->face;
…		…
2121	break;	1264	break;
2122	}	1265	}
2123	}	1266	}
2124	}	1267	}
2125	}	1268	}
		1269
2126	if (middle == floor)	1270	if (middle == floor)
2127	middle = blank_face;	1271	middle = blank_face;
		1272
2128	if (top == middle)	1273	if (top == middle)
2129	middle = blank_face;	1274	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		1275
2148		1276	faces [0] = top; faces_obj [0] = top != blank_face ? top_obj : 0;
2149	void	1277	faces [1] = middle; faces_obj [1] = middle != blank_face ? middle_obj : 0;
2150	set_map_reset_time (mapstruct *map)	1278	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	}	1279	}
2161		1280
2162	/* this updates the orig_map->tile_map[tile_num] value after loading	1281	/* 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	1282	* 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	1283	* 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	1284	* the value of orig_map->tile_map[tile_num].
2166	* so that it is easier for calling functions to verify success.
2167	*/	1285	*/
2168		1286	static inline maptile *
2169	static mapstruct *	1287	find_and_link (maptile *orig_map, int tile_num)
2170	load_and_link_tiled_map (mapstruct *orig_map, int tile_num)
2171	{	1288	{
		1289	maptile *mp = orig_map->tile_map [tile_num];
		1290
		1291	if (!mp)
		1292	{
		1293	mp = orig_map->find_sync (orig_map->tile_path [tile_num], orig_map);
		1294
		1295	if (!mp)
		1296	{
		1297	// emergency mode, manufacture a dummy map, this creates a memleak, but thats fine
		1298	LOG (llevError, "FATAL: cannot load tiled map %s from %s, leaking memory and worse!\n",
		1299	&orig_map->tile_path[tile_num], &orig_map->path);
		1300	mp = new maptile (1, 1);
		1301	mp->alloc ();
		1302	mp->in_memory = MAP_IN_MEMORY;
		1303	}
		1304	}
		1305
2172	int dest_tile = (tile_num + 2) % 4;	1306	int dest_tile = (tile_num + 2) % 4;
2173	char *path = path_combine_and_normalize (orig_map->path, orig_map->tile_path[tile_num]);
2174		1307
2175	orig_map->tile_map[tile_num] = ready_map_name (path, 0);	1308	orig_map->tile_map [tile_num] = mp;
2176		1309
2177	/* need to do a strcmp here as the orig_map->path is not a shared string */	1310	// 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))	1311	//TODO: non-euclidean maps MUST GO
		1312	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;	1313	orig_map->tile_map[tile_num]->tile_map[dest_tile] = orig_map;
2180		1314
2181	return orig_map->tile_map[tile_num];	1315	return mp;
		1316	}
		1317
		1318	static inline void
		1319	load_and_link (maptile *orig_map, int tile_num)
		1320	{
		1321	find_and_link (orig_map, tile_num)->load_sync ();
2182	}	1322	}
2183		1323
2184	/* this returns TRUE if the coordinates (x,y) are out of	1324	/* this returns TRUE if the coordinates (x,y) are out of
2185	* map m. This function also takes into account any	1325	* map m. This function also takes into account any
2186	* tiling considerations, loading adjacant maps as needed.	1326	* tiling considerations, loading adjacant maps as needed.
2187	* This is the function should always be used when it	1327	* This is the function should always be used when it
2188	* necessary to check for valid coordinates.	1328	* necessary to check for valid coordinates.
2189	* This function will recursively call itself for the	1329	* This function will recursively call itself for the
2190	* tiled maps.	1330	* tiled maps.
2191	*
2192	*
2193	*/	1331	*/
2194	int	1332	int
2195	out_of_map (mapstruct *m, int x, int y)	1333	out_of_map (maptile *m, int x, int y)
2196	{	1334	{
2197
2198	/* If we get passed a null map, this is obviously the	1335	/* If we get passed a null map, this is obviously the
2199	* case. This generally shouldn't happen, but if the	1336	* case. This generally shouldn't happen, but if the
2200	* map loads fail below, it could happen.	1337	* map loads fail below, it could happen.
2201	*/	1338	*/
2202	if (!m)	1339	if (!m)
…		…
2204		1341
2205	if (x < 0)	1342	if (x < 0)
2206	{	1343	{
2207	if (!m->tile_path[3])	1344	if (!m->tile_path[3])
2208	return 1;	1345	return 1;
		1346
2209	if (!m->tile_map[3] || m->tile_map[3]->in_memory != MAP_IN_MEMORY)	1347	if (!m->tile_map[3] || m->tile_map[3]->in_memory != MAP_IN_MEMORY)
2210	{	1348	find_and_link (m, 3);
2211	load_and_link_tiled_map (m, 3);	1349
2212	}
2213	return (out_of_map (m->tile_map[3], x + MAP_WIDTH (m->tile_map[3]), y));	1350	return out_of_map (m->tile_map[3], x + m->tile_map[3]->width, y);
2214	}	1351	}
2215	if (x >= MAP_WIDTH (m))	1352
		1353	if (x >= m->width)
2216	{	1354	{
2217	if (!m->tile_path[1])	1355	if (!m->tile_path[1])
2218	return 1;	1356	return 1;
		1357
2219	if (!m->tile_map[1] || m->tile_map[1]->in_memory != MAP_IN_MEMORY)	1358	if (!m->tile_map[1] || m->tile_map[1]->in_memory != MAP_IN_MEMORY)
2220	{	1359	find_and_link (m, 1);
2221	load_and_link_tiled_map (m, 1);	1360
2222	}
2223	return (out_of_map (m->tile_map[1], x - MAP_WIDTH (m), y));	1361	return out_of_map (m->tile_map[1], x - m->width, y);
2224	}	1362	}
		1363
2225	if (y < 0)	1364	if (y < 0)
2226	{	1365	{
2227	if (!m->tile_path[0])	1366	if (!m->tile_path[0])
2228	return 1;	1367	return 1;
		1368
2229	if (!m->tile_map[0] || m->tile_map[0]->in_memory != MAP_IN_MEMORY)	1369	if (!m->tile_map[0] || m->tile_map[0]->in_memory != MAP_IN_MEMORY)
2230	{	1370	find_and_link (m, 0);
2231	load_and_link_tiled_map (m, 0);	1371
2232	}
2233	return (out_of_map (m->tile_map[0], x, y + MAP_HEIGHT (m->tile_map[0])));	1372	return out_of_map (m->tile_map[0], x, y + m->tile_map[0]->height);
2234	}	1373	}
2235	if (y >= MAP_HEIGHT (m))	1374
		1375	if (y >= m->height)
2236	{	1376	{
2237	if (!m->tile_path[2])	1377	if (!m->tile_path[2])
2238	return 1;	1378	return 1;
		1379
2239	if (!m->tile_map[2] || m->tile_map[2]->in_memory != MAP_IN_MEMORY)	1380	if (!m->tile_map[2] || m->tile_map[2]->in_memory != MAP_IN_MEMORY)
2240	{	1381	find_and_link (m, 2);
2241	load_and_link_tiled_map (m, 2);	1382
2242	}
2243	return (out_of_map (m->tile_map[2], x, y - MAP_HEIGHT (m)));	1383	return out_of_map (m->tile_map[2], x, y - m->height);
2244	}	1384	}
2245		1385
2246	/* Simple case - coordinates are within this local	1386	/* Simple case - coordinates are within this local
2247	* map.	1387	* map.
2248	*/	1388	*/
…		…
2251		1391
2252	/* This is basically the same as out_of_map above, but	1392	/* This is basically the same as out_of_map above, but
2253	* instead we return NULL if no map is valid (coordinates	1393	* instead we return NULL if no map is valid (coordinates
2254	* out of bounds and no tiled map), otherwise it returns	1394	* out of bounds and no tiled map), otherwise it returns
2255	* the map as that the coordinates are really on, and	1395	* the map as that the coordinates are really on, and
2256	* updates x and y to be the localized coordinates.	1396	* updates x and y to be the localised coordinates.
2257	* Using this is more efficient of calling out_of_map	1397	* Using this is more efficient of calling out_of_map
2258	* and then figuring out what the real map is	1398	* and then figuring out what the real map is
2259	*/	1399	*/
2260	mapstruct *	1400	maptile *
2261	get_map_from_coord (mapstruct *m, sint16 * x, sint16 * y)	1401	maptile::xy_find (sint16 &x, sint16 &y)
2262	{	1402	{
2263
2264	if (*x < 0)	1403	if (x < 0)
2265	{	1404	{
2266	if (!m->tile_path[3])	1405	if (!tile_path[3])
2267	return NULL;	1406	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		1407
2271	*x += MAP_WIDTH (m->tile_map[3]);	1408	find_and_link (this, 3);
2272	return (get_map_from_coord (m->tile_map[3], x, y));	1409	x += tile_map[3]->width;
2273	}	1410	return tile_map[3]->xy_find (x, y);
2274	if (*x >= MAP_WIDTH (m))
2275	{	1411	}
		1412
		1413	if (x >= width)
		1414	{
2276	if (!m->tile_path[1])	1415	if (!tile_path[1])
2277	return NULL;	1416	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		1417
2281	*x -= MAP_WIDTH (m);	1418	find_and_link (this, 1);
2282	return (get_map_from_coord (m->tile_map[1], x, y));	1419	x -= width;
		1420	return tile_map[1]->xy_find (x, y);
2283	}	1421	}
		1422
2284	if (*y < 0)	1423	if (y < 0)
2285	{	1424	{
2286	if (!m->tile_path[0])	1425	if (!tile_path[0])
2287	return NULL;	1426	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		1427
2291	*y += MAP_HEIGHT (m->tile_map[0]);	1428	find_and_link (this, 0);
2292	return (get_map_from_coord (m->tile_map[0], x, y));	1429	y += tile_map[0]->height;
2293	}	1430	return tile_map[0]->xy_find (x, y);
2294	if (*y >= MAP_HEIGHT (m))
2295	{	1431	}
		1432
		1433	if (y >= height)
		1434	{
2296	if (!m->tile_path[2])	1435	if (!tile_path[2])
2297	return NULL;	1436	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		1437
2301	*y -= MAP_HEIGHT (m);	1438	find_and_link (this, 2);
2302	return (get_map_from_coord (m->tile_map[2], x, y));	1439	y -= height;
		1440	return tile_map[2]->xy_find (x, y);
2303	}	1441	}
2304		1442
2305	/* Simple case - coordinates are within this local	1443	/* Simple case - coordinates are within this local
2306	* map.	1444	* map.
2307	*/	1445	*/
2308
2309	return m;	1446	return this;
2310	}	1447	}
2311		1448
2312	/**	1449	/**
2313	* Return whether map2 is adjacent to map1. If so, store the distance from	1450	* Return whether map2 is adjacent to map1. If so, store the distance from
2314	* map1 to map2 in dx/dy.	1451	* map1 to map2 in dx/dy.
2315	*/	1452	*/
2316	static int	1453	static int
2317	adjacent_map (const mapstruct *map1, const mapstruct *map2, int *dx, int *dy)	1454	adjacent_map (const maptile *map1, const maptile *map2, int *dx, int *dy)
2318	{	1455	{
2319	if (!map1 || !map2)	1456	if (!map1 || !map2)
2320	return 0;	1457	return 0;
2321		1458
		1459	//TODO: this doesn't actually check corretcly when intermediate maps are not loaded
		1460	//fix: compare paths instead (this is likely faster, too!)
2322	if (map1 == map2)	1461	if (map1 == map2)
2323	{	1462	{
2324	*dx = 0;	1463	*dx = 0;
2325	*dy = 0;	1464	*dy = 0;
2326
2327	}	1465	}
2328	else if (map1->tile_map[0] == map2)	1466	else if (map1->tile_map[0] == map2)
2329	{ /* up */	1467	{ /* up */
2330	*dx = 0;	1468	*dx = 0;
2331	*dy = -MAP_HEIGHT (map2);	1469	*dy = -map2->height;
2332	}	1470	}
2333	else if (map1->tile_map[1] == map2)	1471	else if (map1->tile_map[1] == map2)
2334	{ /* right */	1472	{ /* right */
2335	*dx = MAP_WIDTH (map1);	1473	*dx = map1->width;
2336	*dy = 0;	1474	*dy = 0;
2337	}	1475	}
2338	else if (map1->tile_map[2] == map2)	1476	else if (map1->tile_map[2] == map2)
2339	{ /* down */	1477	{ /* down */
2340	*dx = 0;	1478	*dx = 0;
2341	*dy = MAP_HEIGHT (map1);	1479	*dy = map1->height;
2342	}	1480	}
2343	else if (map1->tile_map[3] == map2)	1481	else if (map1->tile_map[3] == map2)
2344	{ /* left */	1482	{ /* left */
2345	*dx = -MAP_WIDTH (map2);	1483	*dx = -map2->width;
2346	*dy = 0;	1484	*dy = 0;
2347
2348	}	1485	}
2349	else if (map1->tile_map[0] && map1->tile_map[0]->tile_map[1] == map2)	1486	else if (map1->tile_map[0] && map1->tile_map[0]->tile_map[1] == map2)
2350	{ /* up right */	1487	{ /* up right */
2351	*dx = MAP_WIDTH (map1->tile_map[0]);	1488	*dx = map1->tile_map[0]->width;
2352	*dy = -MAP_HEIGHT (map1->tile_map[0]);	1489	*dy = -map1->tile_map[0]->height;
2353	}	1490	}
2354	else if (map1->tile_map[0] && map1->tile_map[0]->tile_map[3] == map2)	1491	else if (map1->tile_map[0] && map1->tile_map[0]->tile_map[3] == map2)
2355	{ /* up left */	1492	{ /* up left */
2356	*dx = -MAP_WIDTH (map2);	1493	*dx = -map2->width;
2357	*dy = -MAP_HEIGHT (map1->tile_map[0]);	1494	*dy = -map1->tile_map[0]->height;
2358	}	1495	}
2359	else if (map1->tile_map[1] && map1->tile_map[1]->tile_map[0] == map2)	1496	else if (map1->tile_map[1] && map1->tile_map[1]->tile_map[0] == map2)
2360	{ /* right up */	1497	{ /* right up */
2361	*dx = MAP_WIDTH (map1);	1498	*dx = map1->width;
2362	*dy = -MAP_HEIGHT (map2);	1499	*dy = -map2->height;
2363	}	1500	}
2364	else if (map1->tile_map[1] && map1->tile_map[1]->tile_map[2] == map2)	1501	else if (map1->tile_map[1] && map1->tile_map[1]->tile_map[2] == map2)
2365	{ /* right down */	1502	{ /* right down */
2366	*dx = MAP_WIDTH (map1);	1503	*dx = map1->width;
2367	*dy = MAP_HEIGHT (map1->tile_map[1]);	1504	*dy = map1->tile_map[1]->height;
2368	}	1505	}
2369	else if (map1->tile_map[2] && map1->tile_map[2]->tile_map[1] == map2)	1506	else if (map1->tile_map[2] && map1->tile_map[2]->tile_map[1] == map2)
2370	{ /* down right */	1507	{ /* down right */
2371	*dx = MAP_WIDTH (map1->tile_map[2]);	1508	*dx = map1->tile_map[2]->width;
2372	*dy = MAP_HEIGHT (map1);	1509	*dy = map1->height;
2373	}	1510	}
2374	else if (map1->tile_map[2] && map1->tile_map[2]->tile_map[3] == map2)	1511	else if (map1->tile_map[2] && map1->tile_map[2]->tile_map[3] == map2)
2375	{ /* down left */	1512	{ /* down left */
2376	*dx = -MAP_WIDTH (map2);	1513	*dx = -map2->width;
2377	*dy = MAP_HEIGHT (map1);	1514	*dy = map1->height;
2378	}	1515	}
2379	else if (map1->tile_map[3] && map1->tile_map[3]->tile_map[0] == map2)	1516	else if (map1->tile_map[3] && map1->tile_map[3]->tile_map[0] == map2)
2380	{ /* left up */	1517	{ /* left up */
2381	*dx = -MAP_WIDTH (map1->tile_map[3]);	1518	*dx = -map1->tile_map[3]->width;
2382	*dy = -MAP_HEIGHT (map2);	1519	*dy = -map2->height;
2383	}	1520	}
2384	else if (map1->tile_map[3] && map1->tile_map[3]->tile_map[2] == map2)	1521	else if (map1->tile_map[3] && map1->tile_map[3]->tile_map[2] == map2)
2385	{ /* left down */	1522	{ /* left down */
2386	*dx = -MAP_WIDTH (map1->tile_map[3]);	1523	*dx = -map1->tile_map[3]->width;
2387	*dy = MAP_HEIGHT (map1->tile_map[3]);	1524	*dy = map1->tile_map[3]->height;
2388
2389	}	1525	}
2390	else	1526	else
2391	{ /* not "adjacent" enough */
2392	return 0;	1527	return 0;
2393	}
2394		1528
2395	return 1;	1529	return 1;
		1530	}
		1531
		1532	maptile *
		1533	maptile::xy_load (sint16 &x, sint16 &y)
		1534	{
		1535	maptile *map = xy_find (x, y);
		1536
		1537	if (map)
		1538	map->load_sync ();
		1539
		1540	return map;
		1541	}
		1542
		1543	maptile *
		1544	get_map_from_coord (maptile *m, sint16 *x, sint16 *y)
		1545	{
		1546	return m->xy_load (*x, *y);
2396	}	1547	}
2397		1548
2398	/* From map.c	1549	/* From map.c
2399	* This is used by get_player to determine where the other	1550	* This is used by get_player to determine where the other
2400	* creature is. get_rangevector takes into account map tiling,	1551	* creature is. get_rangevector takes into account map tiling,
…		…
2413	* be unexpected	1564	* be unexpected
2414	*	1565	*
2415	* currently, the only flag supported (0x1) is don't translate for	1566	* currently, the only flag supported (0x1) is don't translate for
2416	* closest body part of 'op1'	1567	* closest body part of 'op1'
2417	*/	1568	*/
2418
2419	void	1569	void
2420	get_rangevector (object *op1, object *op2, rv_vector * retval, int flags)	1570	get_rangevector (object *op1, object *op2, rv_vector * retval, int flags)
2421	{	1571	{
2422	if (!adjacent_map (op1->map, op2->map, &retval->distance_x, &retval->distance_y))	1572	if (!adjacent_map (op1->map, op2->map, &retval->distance_x, &retval->distance_y))
2423	{	1573	{
…		…
2480	* for something in the future. Also, since no object is pasted, the best	1630	* for something in the future. Also, since no object is pasted, the best
2481	* field of the rv_vector is set to NULL.	1631	* field of the rv_vector is set to NULL.
2482	*/	1632	*/
2483		1633
2484	void	1634	void
2485	get_rangevector_from_mapcoord (const mapstruct *m, int x, int y, const object *op2, rv_vector * retval, int flags)	1635	get_rangevector_from_mapcoord (const maptile *m, int x, int y, const object *op2, rv_vector * retval, int flags)
2486	{	1636	{
2487	if (!adjacent_map (m, op2->map, &retval->distance_x, &retval->distance_y))	1637	if (!adjacent_map (m, op2->map, &retval->distance_x, &retval->distance_y))
2488	{	1638	{
2489	/* be conservative and fill in _some_ data */	1639	/* be conservative and fill in _some_ data */
2490	retval->distance = 100000;	1640	retval->distance = 100000;
…		…
2504	}	1654	}
2505	}	1655	}
2506		1656
2507	/* Returns true of op1 and op2 are effectively on the same map	1657	/* 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	1658	* (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	1659	* op1 to op2, so if the tiled maps are asymetric and op2 has a path
2510	* to op1, this will still return false.	1660	* to op1, this will still return false.
2511	* Note we only look one map out to keep the processing simple	1661	* Note we only look one map out to keep the processing simple
2512	* and efficient. This could probably be a macro.	1662	* and efficient. This could probably be a macro.
2513	* MSW 2001-08-05	1663	* MSW 2001-08-05
2514	*/	1664	*/
…		…
2517	{	1667	{
2518	int dx, dy;	1668	int dx, dy;
2519		1669
2520	return adjacent_map (op1->map, op2->map, &dx, &dy);	1670	return adjacent_map (op1->map, op2->map, &dx, &dy);
2521	}	1671	}
		1672
		1673	object *
		1674	maptile::insert (object *op, int x, int y, object *originator, int flags)
		1675	{
		1676	if (!op->flag [FLAG_REMOVED])
		1677	op->remove ();
		1678
		1679	return insert_ob_in_map_at (op, this, originator, flags, x, y);
		1680	}
		1681

Diff Legend

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