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.15 by root, Wed Aug 30 08:28:32 2006 UTC vs.
Revision 1.70 by root, Thu Jan 4 20:29:45 2007 UTC

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

Diff Legend

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