ViewVC Help

View File | Revision Log | Show Annotations | Download File

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

Comparing deliantra/server/common/map.C (file contents):
Revision 1.29 by root, Sun Sep 10 16:00:23 2006 UTC vs.
Revision 1.55 by root, Wed Dec 27 18:09:48 2006 UTC

1
2	/*
3	* static char *rcsid_map_c =
4	* "$Id: map.C,v 1.29 2006/09/10 16:00:23 root Exp $";
5	*/
6
7	/*	1	/*
8	CrossFire, A Multiplayer game for X-windows	2	CrossFire, A Multiplayer game for X-windows
9		3
10	Copyright (C) 2001-2003 Mark Wedel & Crossfire Development Team	4	Copyright (C) 2001-2003 Mark Wedel & Crossfire Development Team
11	Copyright (C) 1992 Frank Tore Johansen	5	Copyright (C) 1992 Frank Tore Johansen
…		…
22		16
23	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
24	along with this program; if not, write to the Free Software	18	along with this program; if not, write to the Free Software
25	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.	19	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26		20
27	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>
28	*/	22	*/
29
30		23
31	#include <global.h>	24	#include <global.h>
32	#include <funcpoint.h>	25	#include <funcpoint.h>
33		26
34	#include <loader.h>	27	#include <loader.h>
35	#ifndef WIN32 /* ---win32 exclude header */
36	# include <unistd.h>	28	#include <unistd.h>
37	#endif /* win32 */
38		29
39	#include "path.h"	30	#include "path.h"
40		31
41
42	extern int nrofallocobjects, nroffreeobjects;
43
44	/*	32	/*
45	* Returns the mapstruct which has a name matching the given argument.	33	* Returns the maptile which has a name matching the given argument.
46	* return NULL if no match is found.	34	* return NULL if no match is found.
47	*/	35	*/
48		36	maptile *
49	mapstruct *
50	has_been_loaded (const char *name)	37	has_been_loaded (const char *name)
51	{	38	{
52	mapstruct *map;
53
54	if (!name || !*name)	39	if (!name || !*name)
55	return 0;	40	return 0;
56	for (map = first_map; map; map = map->next)	41
		42	for_all_maps (map)
57	if (!strcmp (name, map->path))	43	if (!strcmp (name, map->path))
58	break;
59	return (map);	44	return map;
		45
		46	return 0;
60	}	47	}
61		48
62	/*	49	/*
63	* This makes a path absolute outside the world of Crossfire.	50	* This makes a path absolute outside the world of Crossfire.
64	* In other words, it prepends LIBDIR/MAPDIR/ to the given path	51	* In other words, it prepends LIBDIR/MAPDIR/ to the given path
…		…
165	int	152	int
166	check_path (const char *name, int prepend_dir)	153	check_path (const char *name, int prepend_dir)
167	{	154	{
168	char buf[MAX_BUF];	155	char buf[MAX_BUF];
169		156
170	#ifndef WIN32
171	char *endbuf;	157	char *endbuf;
172	struct stat statbuf;	158	struct stat statbuf;
173	int mode = 0;	159	int mode = 0;
174	#endif
175		160
176	if (prepend_dir)	161	if (prepend_dir)
177	strcpy (buf, create_pathname (name));	162	strcpy (buf, create_pathname (name));
178	else	163	else
179	strcpy (buf, name);	164	strcpy (buf, name);
180	#ifdef WIN32 /* ***win32: check this sucker in windows style. */
181	return (_access (buf, 0));
182	#else
183		165
184	/* old method (strchr(buf, '\0')) seemd very odd to me -	166	/* old method (strchr(buf, '\0')) seemd very odd to me -
185	* this method should be equivalant and is clearer.	167	* this method should be equivalant and is clearer.
186	* Can not use strcat because we need to cycle through	168	* Can not use strcat because we need to cycle through
187	* all the names.	169	* all the names.
…		…
200	if ((statbuf.st_mode & S_IWGRP && getegid () == statbuf.st_gid) ||	182	if ((statbuf.st_mode & S_IWGRP && getegid () == statbuf.st_gid) ||
201	(statbuf.st_mode & S_IWUSR && geteuid () == statbuf.st_uid) || (statbuf.st_mode & S_IWOTH))	183	(statbuf.st_mode & S_IWUSR && geteuid () == statbuf.st_uid) || (statbuf.st_mode & S_IWOTH))
202	mode |= 2;	184	mode |= 2;
203		185
204	return (mode);	186	return (mode);
205	#endif
206	}	187	}
207		188
208	/*	189	/*
209	* Prints out debug-information about a map.	190	* Prints out debug-information about a map.
210	* Dumping these at llevError doesn't seem right, but is	191	* Dumping these at llevError doesn't seem right, but is
211	* necessary to make sure the information is in fact logged.	192	* necessary to make sure the information is in fact logged.
212	*/	193	*/
213		194
214	void	195	void
215	dump_map (const mapstruct *m)	196	dump_map (const maptile *m)
216	{	197	{
217	LOG (llevError, "Map %s status: %d.\n", m->path, m->in_memory);	198	LOG (llevError, "Map %s status: %d.\n", m->path, m->in_memory);
218	LOG (llevError, "Size: %dx%d Start: %d,%d\n", MAP_WIDTH (m), MAP_HEIGHT (m), MAP_ENTER_X (m), MAP_ENTER_Y (m));	199	LOG (llevError, "Size: %dx%d Start: %d,%d\n", m->width, m->height, m->enter_x, m->enter_y);
219		200
220	if (m->msg != NULL)	201	if (m->msg != NULL)
221	LOG (llevError, "Message:\n%s", m->msg);	202	LOG (llevError, "Message:\n%s", m->msg);
222		203
223	if (m->maplore != NULL)	204	if (m->maplore != NULL)
…		…
237	*/	218	*/
238		219
239	void	220	void
240	dump_all_maps (void)	221	dump_all_maps (void)
241	{	222	{
242	mapstruct *m;	223	for_all_maps (m)
243
244	for (m = first_map; m != NULL; m = m->next)
245	{
246	dump_map (m);	224	dump_map (m);
247	}
248	}	225	}
249		226
250	/* This rolls up wall, blocks_magic, blocks_view, etc, all into	227	/* This rolls up wall, blocks_magic, blocks_view, etc, all into
251	* one function that just returns a P_.. value (see map.h)	228	* one function that just returns a P_.. value (see map.h)
252	* it will also do map translation for tiled maps, returning	229	* it will also do map translation for tiled maps, returning
…		…
256	* is needed. The case of not passing values is if we're just	233	* is needed. The case of not passing values is if we're just
257	* checking for the existence of something on those spaces, but	234	* checking for the existence of something on those spaces, but
258	* don't expect to insert/remove anything from those spaces.	235	* don't expect to insert/remove anything from those spaces.
259	*/	236	*/
260	int	237	int
261	get_map_flags (mapstruct *oldmap, mapstruct **newmap, sint16 x, sint16 y, sint16 * nx, sint16 * ny)	238	get_map_flags (maptile *oldmap, maptile **newmap, sint16 x, sint16 y, sint16 *nx, sint16 *ny)
262	{	239	{
263	sint16 newx, newy;	240	sint16 newx, newy;
264	int retval = 0;	241	int retval = 0;
265	mapstruct *mp;	242	maptile *mp;
266		243
267	if (out_of_map (oldmap, x, y))
268	return P_OUT_OF_MAP;
269	newx = x;	244	newx = x;
270	newy = y;	245	newy = y;
		246
271	mp = get_map_from_coord (oldmap, &newx, &newy);	247	mp = get_map_from_coord (oldmap, &newx, &newy);
		248
		249	if (!mp)
		250	return P_OUT_OF_MAP;
		251
272	if (mp != oldmap)	252	if (mp != oldmap)
273	retval |= P_NEW_MAP;	253	retval |= P_NEW_MAP;
274	if (newmap)
275	*newmap = mp;
276	if (nx)
277	*nx = newx;
278	if (ny)
279	*ny = newy;
280		254
281	retval |= mp->spaces[newx + mp->width * newy].flags;	255	if (newmap) *newmap = mp;
		256	if (nx) *nx = newx;
		257	if (ny) *ny = newy;
282		258
283	return retval;	259	return retval | mp->at (newx, newy).flags ();
284	}	260	}
285
286		261
287	/*	262	/*
288	* Returns true if the given coordinate is blocked except by the	263	* Returns true if the given coordinate is blocked except by the
289	* object passed is not blocking. This is used with	264	* object passed is not blocking. This is used with
290	* multipart monsters - if we want to see if a 2x2 monster	265	* multipart monsters - if we want to see if a 2x2 monster
…		…
294	* monster.	269	* monster.
295	* m, x, y are the target map/coordinates - needed for map tiling.	270	* m, x, y are the target map/coordinates - needed for map tiling.
296	* the coordinates & map passed in should have been updated for tiling	271	* the coordinates & map passed in should have been updated for tiling
297	* by the caller.	272	* by the caller.
298	*/	273	*/
299
300	int	274	int
301	blocked_link (object *ob, mapstruct *m, int sx, int sy)	275	blocked_link (object *ob, maptile *m, int sx, int sy)
302	{	276	{
303	object *tmp;	277	object *tmp;
304	int mflags, blocked;	278	int mflags, blocked;
305		279
306	/* Make sure the coordinates are valid - they should be, as caller should	280	/* Make sure the coordinates are valid - they should be, as caller should
…		…
313	}	287	}
314		288
315	/* Save some cycles - instead of calling get_map_flags(), just get the value	289	/* Save some cycles - instead of calling get_map_flags(), just get the value
316	* directly.	290	* directly.
317	*/	291	*/
318	mflags = m->spaces[sx + m->width * sy].flags;	292	mflags = m->at (sx, sy).flags ();
319		293
320	blocked = GET_MAP_MOVE_BLOCK (m, sx, sy);	294	blocked = GET_MAP_MOVE_BLOCK (m, sx, sy);
321		295
322	/* If space is currently not blocked by anything, no need to	296	/* If space is currently not blocked by anything, no need to
323	* go further. Not true for players - all sorts of special	297	* go further. Not true for players - all sorts of special
…		…
342	/* We basically go through the stack of objects, and if there is	316	/* We basically go through the stack of objects, and if there is
343	* some other object that has NO_PASS or FLAG_ALIVE set, return	317	* some other object that has NO_PASS or FLAG_ALIVE set, return
344	* true. If we get through the entire stack, that must mean	318	* true. If we get through the entire stack, that must mean
345	* ob is blocking it, so return 0.	319	* ob is blocking it, so return 0.
346	*/	320	*/
347	for (tmp = GET_MAP_OB (m, sx, sy); tmp != NULL; tmp = tmp->above)	321	for (tmp = GET_MAP_OB (m, sx, sy); tmp; tmp = tmp->above)
348	{	322	{
349		323
350	/* This must be before the checks below. Code for inventory checkers. */	324	/* This must be before the checks below. Code for inventory checkers. */
351	if (tmp->type == CHECK_INV && OB_MOVE_BLOCK (ob, tmp))	325	if (tmp->type == CHECK_INV && OB_MOVE_BLOCK (ob, tmp))
352	{	326	{
…		…
416	*	390	*
417	* Note this used to be arch_blocked, but with new movement	391	* Note this used to be arch_blocked, but with new movement
418	* code, we need to have actual object to check its move_type	392	* code, we need to have actual object to check its move_type
419	* against the move_block values.	393	* against the move_block values.
420	*/	394	*/
421
422	int	395	int
423	ob_blocked (const object *ob, mapstruct *m, sint16 x, sint16 y)	396	ob_blocked (const object *ob, maptile *m, sint16 x, sint16 y)
424	{	397	{
425	archetype *tmp;	398	archetype *tmp;
426	int flag;	399	int flag;
427	mapstruct *m1;	400	maptile *m1;
428	sint16 sx, sy;	401	sint16 sx, sy;
429		402
430	if (ob == NULL)	403	if (ob == NULL)
431	{	404	{
432	flag = get_map_flags (m, &m1, x, y, &sx, &sy);	405	flag = get_map_flags (m, &m1, x, y, &sx, &sy);
433	if (flag & P_OUT_OF_MAP)	406	if (flag & P_OUT_OF_MAP)
434	return P_OUT_OF_MAP;	407	return P_OUT_OF_MAP;
435		408
436	/* don't have object, so don't know what types would block */	409	/* don't have object, so don't know what types would block */
437	return (GET_MAP_MOVE_BLOCK (m1, sx, sy));	410	return m1->at (sx, sy).move_block;
438	}	411	}
439		412
440	for (tmp = ob->arch; tmp != NULL; tmp = tmp->more)	413	for (tmp = ob->arch; tmp; tmp = tmp->more)
441	{	414	{
442	flag = get_map_flags (m, &m1, x + tmp->clone.x, y + tmp->clone.y, &sx, &sy);	415	flag = get_map_flags (m, &m1, x + tmp->clone.x, y + tmp->clone.y, &sx, &sy);
443		416
444	if (flag & P_OUT_OF_MAP)	417	if (flag & P_OUT_OF_MAP)
445	return P_OUT_OF_MAP;	418	return P_OUT_OF_MAP;
446	if (flag & P_IS_ALIVE)	419	if (flag & P_IS_ALIVE)
447	return P_IS_ALIVE;	420	return P_IS_ALIVE;
448		421
		422	mapspace &ms = m1->at (sx, sy);
		423
		424
449	/* find_first_free_spot() calls this function. However, often	425	/* find_first_free_spot() calls this function. However, often
450	* ob doesn't have any move type (when used to place exits)	426	* ob doesn't have any move type (when used to place exits)
451	* so the AND operation in OB_TYPE_MOVE_BLOCK doesn't work.	427	* so the AND operation in OB_TYPE_MOVE_BLOCK doesn't work.
452	*/	428	*/
453		429
454	if (ob->move_type == 0 && GET_MAP_MOVE_BLOCK (m1, sx, sy) != MOVE_ALL)	430	if (ob->move_type == 0 && ms.move_block != MOVE_ALL)
455	continue;	431	continue;
456		432
457	/* Note it is intentional that we check ob - the movement type of the	433	/* Note it is intentional that we check ob - the movement type of the
458	* head of the object should correspond for the entire object.	434	* head of the object should correspond for the entire object.
459	*/	435	*/
460	if (OB_TYPE_MOVE_BLOCK (ob, GET_MAP_MOVE_BLOCK (m1, sx, sy)))	436	if (OB_TYPE_MOVE_BLOCK (ob, ms.move_block))
461	return AB_NO_PASS;	437	return P_NO_PASS;
462
463	}	438	}
		439
464	return 0;	440	return 0;
465	}	441	}
466		442
467	/* When the map is loaded, load_object does not actually insert objects	443	/* When the map is loaded, load_object does not actually insert objects
468	* into inventory, but just links them. What this does is go through	444	* into inventory, but just links them. What this does is go through
…		…
495	* for objects whose arch says they are multipart yet according to the	471	* for objects whose arch says they are multipart yet according to the
496	* info we have, they only have the head (as would be expected when	472	* info we have, they only have the head (as would be expected when
497	* they are saved). We do have to look for the old maps that did save	473	* they are saved). We do have to look for the old maps that did save
498	* the more sections and not re-add sections for them.	474	* the more sections and not re-add sections for them.
499	*/	475	*/
500
501	static void	476	static void
502	link_multipart_objects (mapstruct *m)	477	link_multipart_objects (maptile *m)
503	{	478	{
504	int x, y;	479	int x, y;
505	object *tmp, *op, *last, *above;	480	object *tmp, *op, *last, *above;
506	archetype *at;	481	archetype *at;
507		482
508	for (x = 0; x < MAP_WIDTH (m); x++)	483	for (x = 0; x < m->width; x++)
509	for (y = 0; y < MAP_HEIGHT (m); y++)	484	for (y = 0; y < m->height; y++)
510	for (tmp = get_map_ob (m, x, y); tmp != NULL; tmp = above)	485	for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = above)
511	{	486	{
512	above = tmp->above;	487	above = tmp->above;
513		488
514	/* already multipart - don't do anything more */	489	/* already multipart - don't do anything more */
515	if (tmp->head || tmp->more)	490	if (tmp->head || tmp->more)
…		…
544	* Loads (ands parses) the objects into a given map from the specified	519	* Loads (ands parses) the objects into a given map from the specified
545	* file pointer.	520	* file pointer.
546	* mapflags is the same as we get with load_original_map	521	* mapflags is the same as we get with load_original_map
547	*/	522	*/
548	void	523	void
549	load_objects (mapstruct *m, object_thawer & fp, int mapflags)	524	load_objects (maptile *m, object_thawer & fp, int mapflags)
550	{	525	{
551	int i, j;	526	int i, j;
552	int unique;	527	int unique;
553	object *op, *prev = NULL, *last_more = NULL, *otmp;	528	object *op, *prev = NULL, *last_more = NULL, *otmp;
554		529
555	op = get_object ();	530	op = object::create ();
556	op->map = m; /* To handle buttons correctly */	531	op->map = m; /* To handle buttons correctly */
557		532
558	while ((i = load_object (fp, op, mapflags)))	533	while ((i = load_object (fp, op, mapflags)))
559	{	534	{
560	/* if the archetype for the object is null, means that we	535	/* if the archetype for the object is null, means that we
…		…
565	{	540	{
566	LOG (llevDebug, "Discarding object without arch: %s\n", op->name ? (const char *) op->name : "(null)");	541	LOG (llevDebug, "Discarding object without arch: %s\n", op->name ? (const char *) op->name : "(null)");
567	continue;	542	continue;
568	}	543	}
569		544
570
571	switch (i)	545	switch (i)
572	{	546	{
573	case LL_NORMAL:	547	case LL_NORMAL:
574	/* if we are loading an overlay, put the floors on the bottom */	548	/* if we are loading an overlay, put the floors on the bottom */
575	if ((QUERY_FLAG (op, FLAG_IS_FLOOR) || QUERY_FLAG (op, FLAG_OVERLAY_FLOOR)) && mapflags & MAP_OVERLAY)	549	if ((QUERY_FLAG (op, FLAG_IS_FLOOR) || QUERY_FLAG (op, FLAG_OVERLAY_FLOOR)) && mapflags & MAP_OVERLAY)
576	insert_ob_in_map (op, m, op, INS_NO_MERGE | INS_NO_WALK_ON | INS_ABOVE_FLOOR_ONLY | INS_MAP_LOAD);	550	insert_ob_in_map (op, m, op, INS_NO_MERGE | INS_NO_WALK_ON | INS_ABOVE_FLOOR_ONLY | INS_MAP_LOAD);
577	else	551	else
578	insert_ob_in_map (op, m, op, INS_NO_MERGE | INS_NO_WALK_ON | INS_ON_TOP | INS_MAP_LOAD);	552	insert_ob_in_map (op, m, op, INS_NO_MERGE | INS_NO_WALK_ON | INS_ON_TOP | INS_MAP_LOAD);
579		553
580	if (op->inv)	554	if (op->inv)
581	sum_weight (op);	555	sum_weight (op);
582		556
583	prev = op, last_more = op;	557	prev = op, last_more = op;
584	break;	558	break;
585		559
586	case LL_MORE:	560	case LL_MORE:
587	insert_ob_in_map (op, m, op, INS_NO_MERGE | INS_NO_WALK_ON | INS_ABOVE_FLOOR_ONLY);	561	insert_ob_in_map (op, m, op, INS_NO_MERGE | INS_NO_WALK_ON | INS_ABOVE_FLOOR_ONLY);
588	op->head = prev, last_more->more = op, last_more = op;	562	op->head = prev, last_more->more = op, last_more = op;
589	break;	563	break;
590	}	564	}
591		565
592	if (mapflags & MAP_STYLE)	566	if (mapflags & MAP_STYLE)
593	remove_from_active_list (op);	567	remove_from_active_list (op);
594		568
595	op = get_object ();	569	op = object::create ();
596	op->map = m;	570	op->map = m;
597	}	571	}
598		572
599	for (i = 0; i < m->width; i++)	573	for (i = 0; i < m->width; i++)
600	{	574	{
601	for (j = 0; j < m->height; j++)	575	for (j = 0; j < m->height; j++)
602	{	576	{
603	unique = 0;	577	unique = 0;
604	/* check for unique items, or unique squares */	578	/* check for unique items, or unique squares */
605	for (otmp = get_map_ob (m, i, j); otmp; otmp = otmp->above)	579	for (otmp = GET_MAP_OB (m, i, j); otmp; otmp = otmp->above)
606	{	580	{
607	if (QUERY_FLAG (otmp, FLAG_UNIQUE) || QUERY_FLAG (otmp, FLAG_OBJ_SAVE_ON_OVL))	581	if (QUERY_FLAG (otmp, FLAG_UNIQUE) || QUERY_FLAG (otmp, FLAG_OBJ_SAVE_ON_OVL))
608	unique = 1;	582	unique = 1;
		583
609	if (!(mapflags & (MAP_OVERLAY | MAP_PLAYER_UNIQUE) || unique))	584	if (!(mapflags & (MAP_OVERLAY | MAP_PLAYER_UNIQUE) || unique))
610	SET_FLAG (otmp, FLAG_OBJ_ORIGINAL);	585	SET_FLAG (otmp, FLAG_OBJ_ORIGINAL);
611	}	586	}
612	}	587	}
613	}	588	}
614		589
615	free_object (op);	590	op->destroy ();
616	link_multipart_objects (m);	591	link_multipart_objects (m);
617	}	592	}
618		593
619	/* This saves all the objects on the map in a non destructive fashion.	594	/* This saves all the objects on the map in a non destructive fashion.
620	* Modified by MSW 2001-07-01 to do in a single pass - reduces code,	595	* Modified by MSW 2001-07-01 to do in a single pass - reduces code,
621	* and we only save the head of multi part objects - this is needed	596	* and we only save the head of multi part objects - this is needed
622	* in order to do map tiling properly.	597	* in order to do map tiling properly.
623	*/	598	*/
624	void	599	void
625	save_objects (mapstruct *m, object_freezer & fp, object_freezer & fp2, int flag)	600	save_objects (maptile *m, object_freezer &fp, object_freezer &fp2, int flag)
626	{	601	{
627	int i, j = 0, unique = 0;	602	int i, j = 0, unique = 0;
628	object *op;	603	object *op;
629		604
630	/* first pass - save one-part objects */	605	/* first pass - save one-part objects */
631	for (i = 0; i < MAP_WIDTH (m); i++)	606	for (i = 0; i < m->width; i++)
632	for (j = 0; j < MAP_HEIGHT (m); j++)	607	for (j = 0; j < m->height; j++)
633	{	608	{
634	unique = 0;	609	unique = 0;
		610
635	for (op = get_map_ob (m, i, j); op; op = op->above)	611	for (op = m->at (i, j).bot; op; op = op->above)
636	{	612	{
637	if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE))	613	if (op->flag [FLAG_UNIQUE] && op->flag [FLAG_IS_FLOOR])
638	unique = 1;	614	unique = 1;
639		615
640	if (op->type == PLAYER)	616	if (!op->can_map_save ())
641	{
642	LOG (llevDebug, "Player on map that is being saved\n");
643	continue;
644	}
645
646	if (op->head || op->owner)
647	continue;	617	continue;
648		618
649	if (unique || QUERY_FLAG (op, FLAG_UNIQUE))	619	if (unique || op->flag [FLAG_UNIQUE])
650	save_object (fp2, op, 3);	620	save_object (fp2, op, 1);
651	else if (flag == 0 || (flag == 2 && (!QUERY_FLAG (op, FLAG_OBJ_ORIGINAL) && !QUERY_FLAG (op, FLAG_UNPAID))))	621	else if (flag == 0 || (flag == 2 && (!op->flag [FLAG_OBJ_ORIGINAL] && !op->flag [FLAG_UNPAID])))
652	save_object (fp, op, 3);	622	save_object (fp, op, 1);
653		623	}
654	} /* for this space */	624	}
655	} /* for this j */
656	}	625	}
657		626
658	/*	627	maptile::maptile ()
659	* Allocates, initialises, and returns a pointer to a mapstruct.
660	* Modified to no longer take a path option which was not being
661	* used anyways. MSW 2001-07-01
662	*/
663
664	mapstruct *
665	get_linked_map (void)
666	{	628	{
667	mapstruct *map = new mapstruct;
668	mapstruct *mp;
669
670	for (mp = first_map; mp != NULL && mp->next != NULL; mp = mp->next);
671	if (mp == NULL)
672	first_map = map;
673	else
674	mp->next = map;
675
676	map->in_memory = MAP_SWAPPED;	629	in_memory = MAP_SWAPPED;
		630
677	/* The maps used to pick up default x and y values from the	631	/* The maps used to pick up default x and y values from the
678	* map archetype. Mimic that behaviour.	632	* map archetype. Mimic that behaviour.
679	*/	633	*/
680	MAP_WIDTH (map) = 16;	634	width = 16;
681	MAP_HEIGHT (map) = 16;	635	height = 16;
682	MAP_RESET_TIMEOUT (map) = 0;	636	reset_timeout = 0;
683	MAP_TIMEOUT (map) = 300;	637	timeout = 300;
684	MAP_ENTER_X (map) = 0;	638	enter_x = 0;
685	MAP_ENTER_Y (map) = 0;	639	enter_y = 0;
686	/*set part to -1 indicating conversion to weather map not yet done */	640	/*set part to -1 indicating conversion to weather map not yet done */
687	MAP_WORLDPARTX (map) = -1;	641	worldpartx = -1;
688	MAP_WORLDPARTY (map) = -1;	642	worldparty = -1;
		643	}
		644
		645	void
		646	maptile::link ()
		647	{
		648	next = first_map;
		649	first_map = this;
		650	}
		651
		652	void
		653	maptile::unlink ()
		654	{
		655	if (first_map == this)
		656	first_map = next;
		657	else
		658	{
		659	for_all_maps (m)
		660	if (m->next = this)
		661	{
		662	m->next = next;
		663	return;
		664	}
		665
		666	LOG (llevError, "maptile::unlink() map not on list: %s\n", path);
		667	}
		668	}
		669
		670	/*
		671	* Allocates, initialises, and returns a pointer to a maptile.
		672	* Modified to no longer take a path option which was not being
		673	* used anyways. MSW 2001-07-01
		674	*/
		675	maptile *
		676	get_linked_map (void)
		677	{
		678	maptile *map = new maptile;
		679	map->link ();
689	return map;	680	return map;
690	}	681	}
691		682
692	/*	683	/*
693	* Allocates the arrays contained in a mapstruct.	684	* Allocates the arrays contained in a maptile.
694	* This basically allocates the dynamic array of spaces for the	685	* This basically allocates the dynamic array of spaces for the
695	* map.	686	* map.
696	*/	687	*/
697
698	void	688	void
699	allocate_map (mapstruct *m)	689	maptile::allocate ()
700	{	690	{
701	m->in_memory = MAP_IN_MEMORY;	691	in_memory = MAP_IN_MEMORY;
		692
702	/* Log this condition and free the storage. We could I suppose	693	/* Log this condition and free the storage. We could I suppose
703	* realloc, but if the caller is presuming the data will be intact,	694	* realloc, but if the caller is presuming the data will be intact,
704	* that is their poor assumption.	695	* that is their poor assumption.
705	*/	696	*/
706	if (m->spaces)	697	if (spaces)
707	{	698	{
708	LOG (llevError, "allocate_map called with already allocated map (%s)\n", m->path);	699	LOG (llevError, "allocate_map called with already allocated map (%s)\n", path);
709	free (m->spaces);	700	sfree (spaces, size ());
710	}	701	}
711		702
712	m->spaces = (MapSpace *) calloc (1, MAP_WIDTH (m) * MAP_HEIGHT (m) * sizeof (MapSpace));	703	spaces = salloc0<mapspace> (size ());
713
714	if (m->spaces == NULL)
715	fatal (OUT_OF_MEMORY);
716	}	704	}
717		705
718	/* Create and returns a map of the specific size. Used	706	/* Create and returns a map of the specific size. Used
719	* in random map code and the editor.	707	* in random map code and the editor.
720	*/	708	*/
721	mapstruct *	709	maptile *
722	get_empty_map (int sizex, int sizey)	710	get_empty_map (int sizex, int sizey)
723	{	711	{
724	mapstruct *m = get_linked_map ();	712	maptile *m = get_linked_map ();
725		713
726	m->width = sizex;	714	m->width = sizex;
727	m->height = sizey;	715	m->height = sizey;
728	m->in_memory = MAP_SWAPPED;	716	m->in_memory = MAP_SWAPPED;
		717
729	allocate_map (m);	718	m->allocate ();
		719
730	return m;	720	return m;
731	}	721	}
732		722
733	/* Takes a string from a map definition and outputs a pointer to the array of shopitems	723	/* Takes a string from a map definition and outputs a pointer to the array of shopitems
734	* corresponding to that string. Memory is allocated for this, it must be freed	724	* corresponding to that string. Memory is allocated for this, it must be freed
735	* at a later date.	725	* at a later date.
736	* Called by parse_map_headers below.	726	* Called by parse_map_headers below.
737	*/	727	*/
738
739	static shopitems *	728	static shopitems *
740	parse_shop_string (const char *input_string)	729	parse_shop_string (const char *input_string)
741	{	730	{
742	char *shop_string, *p, *q, *next_semicolon, *next_colon;	731	char *shop_string, *p, *q, *next_semicolon, *next_colon;
743	shopitems *items = NULL;	732	shopitems *items = NULL;
744	int i = 0, number_of_entries = 0;	733	int i = 0, number_of_entries = 0;
745	const typedata *current_type;	734	const typedata *current_type;
746		735
747	shop_string = strdup_local (input_string);	736	shop_string = strdup (input_string);
748	p = shop_string;	737	p = shop_string;
749	/* first we'll count the entries, we'll need that for allocating the array shortly */	738	/* first we'll count the entries, we'll need that for allocating the array shortly */
750	while (p)	739	while (p)
751	{	740	{
752	p = strchr (p, ';');	741	p = strchr (p, ';');
753	number_of_entries++;	742	number_of_entries++;
754	if (p)	743	if (p)
755	p++;	744	p++;
756	}	745	}
		746
757	p = shop_string;	747	p = shop_string;
758	strip_endline (p);	748	strip_endline (p);
759	items = new shopitems[number_of_entries + 1];	749	items = new shopitems[number_of_entries + 1];
760	for (i = 0; i < number_of_entries; i++)	750	for (i = 0; i < number_of_entries; i++)
761	{	751	{
762	if (!p)	752	if (!p)
763	{	753	{
764	LOG (llevError, "parse_shop_string: I seem to have run out of string, that shouldn't happen.\n");	754	LOG (llevError, "parse_shop_string: I seem to have run out of string, that shouldn't happen.\n");
765	break;	755	break;
766	}	756	}
		757
767	next_semicolon = strchr (p, ';');	758	next_semicolon = strchr (p, ';');
768	next_colon = strchr (p, ':');	759	next_colon = strchr (p, ':');
769	/* if there is a stregth specified, figure out what it is, we'll need it soon. */	760	/* if there is a stregth specified, figure out what it is, we'll need it soon. */
770	if (next_colon && (!next_semicolon || next_colon < next_semicolon))	761	if (next_colon && (!next_semicolon || next_colon < next_semicolon))
771	items[i].strength = atoi (strchr (p, ':') + 1);	762	items[i].strength = atoi (strchr (p, ':') + 1);
…		…
798	* the next entry while we're at it, better print a warning	789	* the next entry while we're at it, better print a warning
799	*/	790	*/
800	LOG (llevError, "invalid type %s defined in shopitems in string %s\n", p, input_string);	791	LOG (llevError, "invalid type %s defined in shopitems in string %s\n", p, input_string);
801	}	792	}
802	}	793	}
		794
803	items[i].index = number_of_entries;	795	items[i].index = number_of_entries;
804	if (next_semicolon)	796	if (next_semicolon)
805	p = ++next_semicolon;	797	p = ++next_semicolon;
806	else	798	else
807	p = NULL;	799	p = NULL;
808	}	800	}
		801
809	free (shop_string);	802	free (shop_string);
810	return items;	803	return items;
811	}	804	}
812		805
813	/* opposite of parse string, this puts the string that was originally fed in to	806	/* opposite of parse string, this puts the string that was originally fed in to
814	* the map (or something equivilent) into output_string. */	807	* the map (or something equivilent) into output_string. */
815	static void	808	static void
816	print_shop_string (mapstruct *m, char *output_string)	809	print_shop_string (maptile *m, char *output_string)
817	{	810	{
818	int i;	811	int i;
819	char tmp[MAX_BUF];	812	char tmp[MAX_BUF];
820		813
821	strcpy (output_string, "");	814	strcpy (output_string, "");
822	for (i = 0; i < m->shopitems[0].index; i++)	815	for (i = 0; i < m->shopitems[0].index; i++)
823	{	816	{
824	if (m->shopitems[i].typenum)	817	if (m->shopitems[i].typenum)
825	{	818	{
826	if (m->shopitems[i].strength)	819	if (m->shopitems[i].strength)
827	{
828	sprintf (tmp, "%s:%d;", m->shopitems[i].name, m->shopitems[i].strength);	820	sprintf (tmp, "%s:%d;", m->shopitems[i].name, m->shopitems[i].strength);
829	}
830	else	821	else
831	sprintf (tmp, "%s;", m->shopitems[i].name);	822	sprintf (tmp, "%s;", m->shopitems[i].name);
832	}	823	}
833	else	824	else
834	{	825	{
835	if (m->shopitems[i].strength)	826	if (m->shopitems[i].strength)
836	{
837	sprintf (tmp, "*:%d;", m->shopitems[i].strength);	827	sprintf (tmp, "*:%d;", m->shopitems[i].strength);
838	}
839	else	828	else
840	sprintf (tmp, "*");	829	sprintf (tmp, "*");
841	}	830	}
		831
842	strcat (output_string, tmp);	832	strcat (output_string, tmp);
843	}	833	}
844	}	834	}
845		835
846	/* This loads the header information of the map. The header	836	/* This loads the header information of the map. The header
…		…
855	* MSW 2001-07-01	845	* MSW 2001-07-01
856	* return 0 on success, 1 on failure.	846	* return 0 on success, 1 on failure.
857	*/	847	*/
858		848
859	static int	849	static int
860	load_map_header (object_thawer & fp, mapstruct *m)	850	load_map_header (object_thawer & fp, maptile *m)
861	{	851	{
862	char buf[HUGE_BUF], msgbuf[HUGE_BUF], maplorebuf[HUGE_BUF], *key = NULL, *value, *end;	852	char buf[HUGE_BUF], msgbuf[HUGE_BUF], maplorebuf[HUGE_BUF], *key = NULL, *value, *end;
863	int msgpos = 0;	853	int msgpos = 0;
864	int maplorepos = 0;	854	int maplorepos = 0;
865		855
866	while (fgets (buf, HUGE_BUF - 1, fp) != NULL)	856	while (fgets (buf, HUGE_BUF, fp) != NULL)
867	{	857	{
868	buf[HUGE_BUF - 1] = 0;	858	buf[HUGE_BUF - 1] = 0;
869	key = buf;	859	key = buf;
		860
870	while (isspace (*key))	861	while (isspace (*key))
871	key++;	862	key++;
		863
872	if (*key == 0)	864	if (*key == 0)
873	continue; /* empty line */	865	continue; /* empty line */
		866
874	value = strchr (key, ' ');	867	value = strchr (key, ' ');
		868
875	if (!value)	869	if (!value)
876	{	870	{
877	end = strchr (key, '\n');	871	if ((end = strchr (key, '\n')))
878	if (end != NULL)
879	{
880	*end = 0;	872	*end = 0;
881	}
882	}	873	}
883	else	874	else
884	{	875	{
885	*value = 0;	876	*value = 0;
886	value++;	877	value++;
887	end = strchr (value, '\n');	878	end = strchr (value, '\n');
		879
888	while (isspace (*value))	880	while (isspace (*value))
889	{	881	{
890	value++;	882	value++;
		883
891	if (*value == '\0' || value == end)	884	if (*value == '\0' || value == end)
892	{	885	{
893	/* Nothing but spaces. */	886	/* Nothing but spaces. */
894	value = NULL;	887	value = NULL;
895	break;	888	break;
…		…
918	* that use the parameter.	911	* that use the parameter.
919	*/	912	*/
920		913
921	if (!strcmp (key, "msg"))	914	if (!strcmp (key, "msg"))
922	{	915	{
923	while (fgets (buf, HUGE_BUF - 1, fp) != NULL)	916	while (fgets (buf, HUGE_BUF, fp) != NULL)
924	{	917	{
925	if (!strcmp (buf, "endmsg\n"))	918	if (!strcmp (buf, "endmsg\n"))
926	break;	919	break;
927	else	920	else
928	{	921	{
…		…
935	* with nothing between). There is no reason in those cases to	928	* with nothing between). There is no reason in those cases to
936	* keep the empty message. Also, msgbuf contains garbage data	929	* keep the empty message. Also, msgbuf contains garbage data
937	* when msgpos is zero, so copying it results in crashes	930	* when msgpos is zero, so copying it results in crashes
938	*/	931	*/
939	if (msgpos != 0)	932	if (msgpos != 0)
940	m->msg = strdup_local (msgbuf);	933	m->msg = strdup (msgbuf);
941	}	934	}
942	else if (!strcmp (key, "maplore"))	935	else if (!strcmp (key, "maplore"))
943	{	936	{
944	while (fgets (buf, HUGE_BUF - 1, fp) != NULL)	937	while (fgets (buf, HUGE_BUF, fp) != NULL)
945	{	938	{
946	if (!strcmp (buf, "endmaplore\n"))	939	if (!strcmp (buf, "endmaplore\n"))
947	break;	940	break;
948	else	941	else
949	{	942	{
…		…
951	strcpy (maplorebuf + maplorepos, buf);	944	strcpy (maplorebuf + maplorepos, buf);
952	maplorepos += strlen (buf);	945	maplorepos += strlen (buf);
953	}	946	}
954	}	947	}
955	if (maplorepos != 0)	948	if (maplorepos != 0)
956	m->maplore = strdup_local (maplorebuf);	949	m->maplore = strdup (maplorebuf);
957	}	950	}
958	else if (!strcmp (key, "end"))	951	else if (!strcmp (key, "end"))
959	{	952	{
960	break;	953	break;
961	}	954	}
…		…
970	LOG (llevError, "loading map and got a non 'arch map' line(%s %s)?\n", key, value);	963	LOG (llevError, "loading map and got a non 'arch map' line(%s %s)?\n", key, value);
971	}	964	}
972	else if (!strcmp (key, "name"))	965	else if (!strcmp (key, "name"))
973	{	966	{
974	*end = 0;	967	*end = 0;
975	m->name = strdup_local (value);	968	m->name = strdup (value);
976	}	969	}
977	/* first strcmp value on these are old names supported	970	/* first strcmp value on these are old names supported
978	* for compatibility reasons. The new values (second) are	971	* for compatibility reasons. The new values (second) are
979	* what really should be used.	972	* what really should be used.
980	*/	973	*/
981	else if (!strcmp (key, "oid"))	974	else if (!strcmp (key, "oid"))
982	{
983	fp.get (m, atoi (value));	975	fp.get (m, atoi (value));
984	}
985	else if (!strcmp (key, "attach"))	976	else if (!strcmp (key, "attach"))
986	{
987	m->attach = value;	977	m->attach = value;
988	}
989	else if (!strcmp (key, "hp") || !strcmp (key, "enter_x"))	978	else if (!strcmp (key, "hp") || !strcmp (key, "enter_x"))
990	{
991	m->enter_x = atoi (value);	979	m->enter_x = atoi (value);
992	}
993	else if (!strcmp (key, "sp") || !strcmp (key, "enter_y"))	980	else if (!strcmp (key, "sp") || !strcmp (key, "enter_y"))
994	{
995	m->enter_y = atoi (value);	981	m->enter_y = atoi (value);
996	}
997	else if (!strcmp (key, "x") || !strcmp (key, "width"))	982	else if (!strcmp (key, "x") || !strcmp (key, "width"))
998	{
999	m->width = atoi (value);	983	m->width = atoi (value);
1000	}
1001	else if (!strcmp (key, "y") || !strcmp (key, "height"))	984	else if (!strcmp (key, "y") || !strcmp (key, "height"))
1002	{
1003	m->height = atoi (value);	985	m->height = atoi (value);
1004	}
1005	else if (!strcmp (key, "weight") || !strcmp (key, "reset_timeout"))	986	else if (!strcmp (key, "weight") || !strcmp (key, "reset_timeout"))
1006	{
1007	m->reset_timeout = atoi (value);	987	m->reset_timeout = atoi (value);
1008	}
1009	else if (!strcmp (key, "value") || !strcmp (key, "swap_time"))	988	else if (!strcmp (key, "value") || !strcmp (key, "swap_time"))
1010	{
1011	m->timeout = atoi (value);	989	m->timeout = atoi (value);
1012	}
1013	else if (!strcmp (key, "level") || !strcmp (key, "difficulty"))	990	else if (!strcmp (key, "level") || !strcmp (key, "difficulty"))
1014	{	991	m->difficulty = clamp (atoi (value), 1, settings.max_level);
1015	m->difficulty = atoi (value);
1016	}
1017	else if (!strcmp (key, "invisible") || !strcmp (key, "darkness"))	992	else if (!strcmp (key, "invisible") || !strcmp (key, "darkness"))
1018	{
1019	m->darkness = atoi (value);	993	m->darkness = atoi (value);
1020	}
1021	else if (!strcmp (key, "stand_still") || !strcmp (key, "fixed_resettime"))	994	else if (!strcmp (key, "stand_still") || !strcmp (key, "fixed_resettime"))
1022	{
1023	m->fixed_resettime = atoi (value);	995	m->fixed_resettime = atoi (value);
1024	}
1025	else if (!strcmp (key, "unique"))	996	else if (!strcmp (key, "unique"))
1026	{
1027	m->unique = atoi (value);	997	m->unique = atoi (value);
1028	}
1029	else if (!strcmp (key, "template"))	998	else if (!strcmp (key, "template"))
1030	{
1031	m->templatemap = atoi (value);	999	m->templatemap = atoi (value);
1032	}
1033	else if (!strcmp (key, "region"))	1000	else if (!strcmp (key, "region"))
1034	{
1035	m->region = get_region_by_name (value);	1001	m->region = get_region_by_name (value);
1036	}
1037	else if (!strcmp (key, "shopitems"))	1002	else if (!strcmp (key, "shopitems"))
1038	{	1003	{
1039	*end = 0;	1004	*end = 0;
1040	m->shopitems = parse_shop_string (value);	1005	m->shopitems = parse_shop_string (value);
1041	}	1006	}
1042	else if (!strcmp (key, "shopgreed"))	1007	else if (!strcmp (key, "shopgreed"))
1043	{
1044	m->shopgreed = atof (value);	1008	m->shopgreed = atof (value);
1045	}
1046	else if (!strcmp (key, "shopmin"))	1009	else if (!strcmp (key, "shopmin"))
1047	{
1048	m->shopmin = atol (value);	1010	m->shopmin = atol (value);
1049	}
1050	else if (!strcmp (key, "shopmax"))	1011	else if (!strcmp (key, "shopmax"))
1051	{
1052	m->shopmax = atol (value);	1012	m->shopmax = atol (value);
1053	}
1054	else if (!strcmp (key, "shoprace"))	1013	else if (!strcmp (key, "shoprace"))
1055	{	1014	{
1056	*end = 0;	1015	*end = 0;
1057	m->shoprace = strdup_local (value);	1016	m->shoprace = strdup (value);
1058	}	1017	}
1059	else if (!strcmp (key, "outdoor"))	1018	else if (!strcmp (key, "outdoor"))
1060	{
1061	m->outdoor = atoi (value);	1019	m->outdoor = atoi (value);
1062	}
1063	else if (!strcmp (key, "temp"))	1020	else if (!strcmp (key, "temp"))
1064	{
1065	m->temp = atoi (value);	1021	m->temp = atoi (value);
1066	}
1067	else if (!strcmp (key, "pressure"))	1022	else if (!strcmp (key, "pressure"))
1068	{
1069	m->pressure = atoi (value);	1023	m->pressure = atoi (value);
1070	}
1071	else if (!strcmp (key, "humid"))	1024	else if (!strcmp (key, "humid"))
1072	{
1073	m->humid = atoi (value);	1025	m->humid = atoi (value);
1074	}
1075	else if (!strcmp (key, "windspeed"))	1026	else if (!strcmp (key, "windspeed"))
1076	{
1077	m->windspeed = atoi (value);	1027	m->windspeed = atoi (value);
1078	}
1079	else if (!strcmp (key, "winddir"))	1028	else if (!strcmp (key, "winddir"))
1080	{
1081	m->winddir = atoi (value);	1029	m->winddir = atoi (value);
1082	}
1083	else if (!strcmp (key, "sky"))	1030	else if (!strcmp (key, "sky"))
1084	{
1085	m->sky = atoi (value);	1031	m->sky = atoi (value);
1086	}
1087	else if (!strcmp (key, "nosmooth"))	1032	else if (!strcmp (key, "nosmooth"))
1088	{
1089	m->nosmooth = atoi (value);	1033	m->nosmooth = atoi (value);
1090	}
1091	else if (!strncmp (key, "tile_path_", 10))	1034	else if (!strncmp (key, "tile_path_", 10))
1092	{	1035	{
1093	int tile = atoi (key + 10);	1036	int tile = atoi (key + 10);
1094		1037
1095	if (tile < 1 || tile > 4)	1038	if (tile < 1 || tile > 4)
…		…
1128	}	1071	}
1129		1072
1130	if (editor)	1073	if (editor)
1131	{	1074	{
1132	/* Use the value as in the file. */	1075	/* Use the value as in the file. */
1133	m->tile_path[tile - 1] = strdup_local (value);	1076	m->tile_path[tile - 1] = strdup (value);
1134	}	1077	}
1135	else if (path != NULL)	1078	else if (path != NULL)
1136	{	1079	{
1137	/* Use the normalized value. */	1080	/* Use the normalized value. */
1138	m->tile_path[tile - 1] = strdup_local (path);	1081	m->tile_path[tile - 1] = strdup (path);
1139	}	1082	}
1140	} /* end if tile direction (in)valid */	1083	} /* end if tile direction (in)valid */
1141	}	1084	}
1142	else	1085	else
1143	{
1144	LOG (llevError, "Got unknown value in map header: %s %s\n", key, value);	1086	LOG (llevError, "Got unknown value in map header: %s %s\n", key, value);
1145	}
1146	}	1087	}
		1088
1147	if (!key || strcmp (key, "end"))	1089	if (!key || strcmp (key, "end"))
1148	{	1090	{
1149	LOG (llevError, "Got premature eof on map header!\n");	1091	LOG (llevError, "Got premature eof on map header!\n");
1150	return 1;	1092	return 1;
1151	}	1093	}
		1094
1152	return 0;	1095	return 0;
1153	}	1096	}
1154		1097
1155	/*	1098	/*
1156	* Opens the file "filename" and reads information about the map	1099	* Opens the file "filename" and reads information about the map
1157	* from the given file, and stores it in a newly allocated	1100	* from the given file, and stores it in a newly allocated
1158	* mapstruct. A pointer to this structure is returned, or NULL on failure.	1101	* maptile. A pointer to this structure is returned, or NULL on failure.
1159	* flags correspond to those in map.h. Main ones used are	1102	* flags correspond to those in map.h. Main ones used are
1160	* MAP_PLAYER_UNIQUE, in which case we don't do any name changes, and	1103	* MAP_PLAYER_UNIQUE, in which case we don't do any name changes, and
1161	* MAP_BLOCK, in which case we block on this load. This happens in all	1104	* MAP_BLOCK, in which case we block on this load. This happens in all
1162	* cases, no matter if this flag is set or not.	1105	* cases, no matter if this flag is set or not.
1163	* MAP_STYLE: style map - don't add active objects, don't add to server	1106	* MAP_STYLE: style map - don't add active objects, don't add to server
1164	* managed map list.	1107	* managed map list.
1165	*/	1108	*/
1166		1109	maptile *
1167	mapstruct *
1168	load_original_map (const char *filename, int flags)	1110	load_original_map (const char *filename, int flags)
1169	{	1111	{
1170	mapstruct *m;	1112	maptile *m;
1171	char pathname[MAX_BUF];	1113	char pathname[MAX_BUF];
1172		1114
1173	if (flags & MAP_PLAYER_UNIQUE)	1115	if (flags & MAP_PLAYER_UNIQUE)
1174	strcpy (pathname, filename);	1116	strcpy (pathname, filename);
1175	else if (flags & MAP_OVERLAY)	1117	else if (flags & MAP_OVERLAY)
…		…
1189	strcpy (m->path, filename);	1131	strcpy (m->path, filename);
1190	if (load_map_header (thawer, m))	1132	if (load_map_header (thawer, m))
1191	{	1133	{
1192	LOG (llevError, "Error loading map header for %s, flags=%d\n", filename, flags);	1134	LOG (llevError, "Error loading map header for %s, flags=%d\n", filename, flags);
1193	delete_map (m);	1135	delete_map (m);
1194	return NULL;	1136	return 0;
1195	}	1137	}
1196		1138
1197	allocate_map (m);	1139	m->allocate ();
1198		1140
1199	m->in_memory = MAP_LOADING;	1141	m->in_memory = MAP_LOADING;
1200	load_objects (m, thawer, flags & (MAP_BLOCK | MAP_STYLE));	1142	load_objects (m, thawer, flags & (MAP_BLOCK | MAP_STYLE));
1201		1143
1202	m->in_memory = MAP_IN_MEMORY;	1144	m->in_memory = MAP_IN_MEMORY;
1203	if (!MAP_DIFFICULTY (m))	1145	if (!m->difficulty)
1204	MAP_DIFFICULTY (m) = calculate_difficulty (m);	1146	m->difficulty = calculate_difficulty (m);
1205	set_map_reset_time (m);	1147	set_map_reset_time (m);
1206	m->instantiate ();	1148	m->instantiate ();
1207	return (m);	1149	return (m);
1208	}	1150	}
1209		1151
1210	/*	1152	/*
1211	* Loads a map, which has been loaded earlier, from file.	1153	* Loads a map, which has been loaded earlier, from file.
1212	* Return the map object we load into (this can change from the passed	1154	* Return the map object we load into (this can change from the passed
1213	* option if we can't find the original map)	1155	* option if we can't find the original map)
1214	*/	1156	*/
1215
1216	static mapstruct *	1157	static maptile *
1217	load_temporary_map (mapstruct *m)	1158	load_temporary_map (maptile *m)
1218	{	1159	{
1219	char buf[MAX_BUF];	1160	char buf[MAX_BUF];
1220		1161
1221	if (!m->tmpname)	1162	if (!m->tmpname)
1222	{	1163	{
…		…
1248	LOG (llevError, "Error loading map header for %s (%s)\n", m->path, m->tmpname);	1189	LOG (llevError, "Error loading map header for %s (%s)\n", m->path, m->tmpname);
1249	delete_map (m);	1190	delete_map (m);
1250	m = load_original_map (m->path, 0);	1191	m = load_original_map (m->path, 0);
1251	return NULL;	1192	return NULL;
1252	}	1193	}
		1194
1253	allocate_map (m);	1195	m->allocate ();
1254		1196
1255	m->in_memory = MAP_LOADING;	1197	m->in_memory = MAP_LOADING;
1256	load_objects (m, thawer, 0);	1198	load_objects (m, thawer, 0);
1257		1199
1258	m->in_memory = MAP_IN_MEMORY;	1200	m->in_memory = MAP_IN_MEMORY;
…		…
1263	/*	1205	/*
1264	* Loads a map, which has been loaded earlier, from file.	1206	* Loads a map, which has been loaded earlier, from file.
1265	* Return the map object we load into (this can change from the passed	1207	* Return the map object we load into (this can change from the passed
1266	* option if we can't find the original map)	1208	* option if we can't find the original map)
1267	*/	1209	*/
1268		1210	maptile *
1269	mapstruct *
1270	load_overlay_map (const char *filename, mapstruct *m)	1211	load_overlay_map (const char *filename, maptile *m)
1271	{	1212	{
1272	char pathname[MAX_BUF];	1213	char pathname[MAX_BUF];
1273		1214
1274	strcpy (pathname, create_overlay_pathname (filename));	1215	strcpy (pathname, create_overlay_pathname (filename));
1275		1216
…		…
1281	if (load_map_header (thawer, m))	1222	if (load_map_header (thawer, m))
1282	{	1223	{
1283	LOG (llevError, "Error loading map header for overlay %s (%s)\n", m->path, pathname);	1224	LOG (llevError, "Error loading map header for overlay %s (%s)\n", m->path, pathname);
1284	delete_map (m);	1225	delete_map (m);
1285	m = load_original_map (m->path, 0);	1226	m = load_original_map (m->path, 0);
1286	return NULL;	1227	return 0;
1287	}	1228	}
1288	/*allocate_map(m); */	1229	/*m->allocate ();*/
1289		1230
1290	m->in_memory = MAP_LOADING;	1231	m->in_memory = MAP_LOADING;
1291	load_objects (m, thawer, MAP_OVERLAY);	1232	load_objects (m, thawer, MAP_OVERLAY);
1292		1233
1293	m->in_memory = MAP_IN_MEMORY;	1234	m->in_memory = MAP_IN_MEMORY;
…		…
1298	* This is the start of unique map handling code	1239	* This is the start of unique map handling code
1299	*****************************************************************************/	1240	*****************************************************************************/
1300		1241
1301	/* This goes through map 'm' and removed any unique items on the map. */	1242	/* This goes through map 'm' and removed any unique items on the map. */
1302	static void	1243	static void
1303	delete_unique_items (mapstruct *m)	1244	delete_unique_items (maptile *m)
1304	{	1245	{
1305	int i, j, unique;	1246	int i, j, unique;
1306	object *op, *next;	1247	object *op, *next;
1307		1248
1308	for (i = 0; i < MAP_WIDTH (m); i++)	1249	for (i = 0; i < m->width; i++)
1309	for (j = 0; j < MAP_HEIGHT (m); j++)	1250	for (j = 0; j < m->height; j++)
1310	{	1251	{
1311	unique = 0;	1252	unique = 0;
		1253
1312	for (op = get_map_ob (m, i, j); op; op = next)	1254	for (op = GET_MAP_OB (m, i, j); op; op = next)
1313	{	1255	{
1314	next = op->above;	1256	next = op->above;
		1257
1315	if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE))	1258	if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE))
1316	unique = 1;	1259	unique = 1;
		1260
1317	if (op->head == NULL && (QUERY_FLAG (op, FLAG_UNIQUE) || unique))	1261	if (op->head == NULL && (QUERY_FLAG (op, FLAG_UNIQUE) || unique))
1318	{	1262	{
1319	clean_object (op);	1263	op->destroy_inv (false);
1320	if (QUERY_FLAG (op, FLAG_IS_LINKED))	1264	op->destroy ();
1321	remove_button_link (op);
1322	remove_ob (op);
1323	free_object (op);
1324	}	1265	}
1325	}	1266	}
1326	}	1267	}
1327	}	1268	}
1328		1269
1329
1330	/*	1270	/*
1331	* Loads unique objects from file(s) into the map which is in memory	1271	* Loads unique objects from file(s) into the map which is in memory
1332	* m is the map to load unique items into.	1272	* m is the map to load unique items into.
1333	*/	1273	*/
1334	static void	1274	static void
1335	load_unique_objects (mapstruct *m)	1275	load_unique_objects (maptile *m)
1336	{	1276	{
1337	int count;	1277	int count;
1338	char firstname[MAX_BUF];	1278	char firstname[MAX_BUF];
1339		1279
1340	for (count = 0; count < 10; count++)	1280	for (count = 0; count < 10; count++)
…		…
1353	return;	1293	return;
1354		1294
1355	m->in_memory = MAP_LOADING;	1295	m->in_memory = MAP_LOADING;
1356	if (m->tmpname == NULL) /* if we have loaded unique items from */	1296	if (m->tmpname == NULL) /* if we have loaded unique items from */
1357	delete_unique_items (m); /* original map before, don't duplicate them */	1297	delete_unique_items (m); /* original map before, don't duplicate them */
		1298
1358	load_objects (m, thawer, 0);	1299	load_objects (m, thawer, 0);
1359		1300
1360	m->in_memory = MAP_IN_MEMORY;	1301	m->in_memory = MAP_IN_MEMORY;
1361	}	1302	}
1362
1363		1303
1364	/*	1304	/*
1365	* Saves a map to file. If flag is set, it is saved into the same	1305	* Saves a map to file. If flag is set, it is saved into the same
1366	* file it was (originally) loaded from. Otherwise a temporary	1306	* file it was (originally) loaded from. Otherwise a temporary
1367	* filename will be genarated, and the file will be stored there.	1307	* filename will be genarated, and the file will be stored there.
1368	* The temporary filename will be stored in the mapstructure.	1308	* The temporary filename will be stored in the maptileure.
1369	* If the map is unique, we also save to the filename in the map	1309	* If the map is unique, we also save to the filename in the map
1370	* (this should have been updated when first loaded)	1310	* (this should have been updated when first loaded)
1371	*/	1311	*/
1372
1373	int	1312	int
1374	new_save_map (mapstruct *m, int flag)	1313	new_save_map (maptile *m, int flag)
1375	{	1314	{
1376	char filename[MAX_BUF], buf[MAX_BUF], shop[MAX_BUF];	1315	char filename[MAX_BUF], buf[MAX_BUF], shop[MAX_BUF];
1377	int i;	1316	int i;
1378		1317
1379	if (flag && !*m->path)	1318	if (flag && !*m->path)
…		…
1397	make_path_to_file (filename);	1336	make_path_to_file (filename);
1398	}	1337	}
1399	else	1338	else
1400	{	1339	{
1401	if (!m->tmpname)	1340	if (!m->tmpname)
1402	m->tmpname = tempnam_local (settings.tmpdir, NULL);	1341	m->tmpname = tempnam (settings.tmpdir, NULL);
1403		1342
1404	strcpy (filename, m->tmpname);	1343	strcpy (filename, m->tmpname);
1405	}	1344	}
1406		1345
1407	LOG (llevDebug, "Saving map %s to %s\n", m->path, filename);	1346	LOG (llevDebug, "Saving map %s to %s\n", m->path, filename);
…		…
1431	print_shop_string (m, shop);	1370	print_shop_string (m, shop);
1432	fprintf (freezer, "shopitems %s\n", shop);	1371	fprintf (freezer, "shopitems %s\n", shop);
1433	}	1372	}
1434	if (m->shopgreed)	1373	if (m->shopgreed)
1435	fprintf (freezer, "shopgreed %f\n", m->shopgreed);	1374	fprintf (freezer, "shopgreed %f\n", m->shopgreed);
1436	#ifndef WIN32
1437	if (m->shopmin)	1375	if (m->shopmin)
1438	fprintf (freezer, "shopmin %llu\n", m->shopmin);	1376	fprintf (freezer, "shopmin %llu\n", m->shopmin);
1439	if (m->shopmax)	1377	if (m->shopmax)
1440	fprintf (freezer, "shopmax %llu\n", m->shopmax);	1378	fprintf (freezer, "shopmax %llu\n", m->shopmax);
1441	#else
1442	if (m->shopmin)
1443	fprintf (freezer, "shopmin %I64u\n", m->shopmin);
1444	if (m->shopmax)
1445	fprintf (freezer, "shopmax %I64u\n", m->shopmax);
1446	#endif
1447	if (m->shoprace)	1379	if (m->shoprace)
1448	fprintf (freezer, "shoprace %s\n", m->shoprace);	1380	fprintf (freezer, "shoprace %s\n", m->shoprace);
1449	if (m->darkness)	1381	if (m->darkness)
1450	fprintf (freezer, "darkness %d\n", m->darkness);	1382	fprintf (freezer, "darkness %d\n", m->darkness);
1451	if (m->width)	1383	if (m->width)
…		…
1516	freezer.save (filename);	1448	freezer.save (filename);
1517		1449
1518	return 0;	1450	return 0;
1519	}	1451	}
1520		1452
1521
1522	/*
1523	* Remove and free all objects in the inventory of the given object.
1524	* object.c ?
1525	*/
1526
1527	void
1528	clean_object (object *op)
1529	{
1530	object *tmp, *next;
1531
1532	for (tmp = op->inv; tmp; tmp = next)
1533	{
1534	next = tmp->below;
1535	clean_object (tmp);
1536	if (QUERY_FLAG (tmp, FLAG_IS_LINKED))
1537	remove_button_link (tmp);
1538	remove_ob (tmp);
1539	free_object (tmp);
1540	}
1541	}
1542
1543	/*	1453	/*
1544	* Remove and free all objects in the given map.	1454	* Remove and free all objects in the given map.
1545	*/	1455	*/
1546
1547	void	1456	void
1548	free_all_objects (mapstruct *m)	1457	free_all_objects (maptile *m)
1549	{	1458	{
1550	int i, j;	1459	if (!m->spaces)
1551	object *op;	1460	return;
1552		1461
1553	for (i = 0; i < MAP_WIDTH (m); i++)	1462	for (int i = 0; i < m->width; i++)
1554	for (j = 0; j < MAP_HEIGHT (m); j++)	1463	for (int j = 0; j < m->height; j++)
1555	{	1464	{
1556	object *previous_obj = NULL;	1465	mapspace &ms = m->at (i, j);
1557		1466
1558	while ((op = GET_MAP_OB (m, i, j)) != NULL)	1467	while (object *op = ms.bot)
1559	{	1468	{
1560	if (op == previous_obj)
1561	{
1562	LOG (llevDebug, "free_all_objects: Link error, bailing out.\n");
1563	break;
1564	}
1565	previous_obj = op;
1566	if (op->head != NULL)	1469	if (op->head)
1567	op = op->head;	1470	op = op->head;
1568		1471
1569	/* If the map isn't in memory, free_object will remove and	1472	op->destroy_inv (false);
1570	* free objects in op's inventory. So let it do the job.	1473	op->destroy ();
1571	*/
1572	if (m->in_memory == MAP_IN_MEMORY)
1573	clean_object (op);
1574	remove_ob (op);
1575	free_object (op);
1576	}	1474	}
1577	}	1475	}
1578	}	1476	}
1579		1477
1580	/*	1478	/*
1581	* Frees everything allocated by the given mapstructure.	1479	* Frees everything allocated by the given maptileure.
1582	* don't free tmpname - our caller is left to do that	1480	* don't free tmpname - our caller is left to do that
1583	*/	1481	*/
1584
1585	void	1482	void
1586	free_map (mapstruct *m, int flag)	1483	free_map (maptile *m, int flag)
1587	{	1484	{
1588	int i;	1485	if (!m->in_memory) //TODO: makes no sense to me?
1589
1590	if (!m->in_memory)
1591	{
1592	LOG (llevError, "Trying to free freed map.\n");
1593	return;	1486	return;
1594	}	1487
		1488	m->in_memory = MAP_SAVING;
		1489
		1490	// TODO: use new/delete
		1491
1595	if (flag && m->spaces)	1492	if (flag && m->spaces)
1596	free_all_objects (m);	1493	free_all_objects (m);
1597	if (m->name)	1494
1598	FREE_AND_CLEAR (m->name);	1495	sfree (m->spaces, m->size ()), m->spaces = 0;
1599	if (m->spaces)	1496
1600	FREE_AND_CLEAR (m->spaces);	1497	free (m->name), m->name = 0;
1601	if (m->msg)	1498	free (m->msg), m->msg = 0;
1602	FREE_AND_CLEAR (m->msg);	1499	free (m->maplore), m->maplore = 0;
1603	if (m->maplore)	1500	free (m->shoprace), m->shoprace = 0;
1604	FREE_AND_CLEAR (m->maplore);	1501	delete [] m->shopitems, m->shopitems = 0;
1605	if (m->shopitems)	1502
1606	delete[]m->shopitems;
1607	m->shopitems = 0;
1608	if (m->shoprace)
1609	FREE_AND_CLEAR (m->shoprace);
1610	if (m->buttons)	1503	if (m->buttons)
1611	free_objectlinkpt (m->buttons);	1504	free_objectlinkpt (m->buttons), m->buttons = 0;
1612	m->buttons = NULL;	1505
1613	for (i = 0; i < 4; i++)	1506	for (int i = 0; i < 4; i++)
1614	{	1507	free (m->tile_path[i]), m->tile_path[i] = 0;
1615	if (m->tile_path[i])	1508
1616	FREE_AND_CLEAR (m->tile_path[i]);
1617	m->tile_map[i] = NULL;
1618	}
1619	m->in_memory = MAP_SWAPPED;	1509	m->in_memory = MAP_SWAPPED;
1620	}	1510	}
1621		1511
1622	/*	1512	maptile::~maptile ()
1623	* function: vanish mapstruct	1513	{
1624	* m : pointer to mapstruct, if NULL no action	1514	assert (destroyed ());
1625	* this deletes all the data on the map (freeing pointers)	1515	}
1626	* and then removes this map from the global linked list of maps.
1627	*/
1628		1516
1629	void	1517	void
1630	delete_map (mapstruct *m)	1518	maptile::do_destroy ()
1631	{	1519	{
1632	mapstruct *tmp, *last;	1520	attachable::do_destroy ();
1633	int i;
1634		1521
1635	if (!m)	1522	unlink ();
1636	return;
1637		1523
1638	m->clear ();
1639
1640	if (m->in_memory == MAP_IN_MEMORY)
1641	{
1642	/* change to MAP_SAVING, even though we are not,
1643	* so that remove_ob doesn't do as much work.
1644	*/
1645	m->in_memory = MAP_SAVING;
1646	free_map (m, 1);	1524	free_map (this, 1);
1647	}	1525	free (tmpname), tmpname = 0;
1648	/* move this out of free_map, since tmpname can still be needed if	1526
1649	* the map is swapped out.
1650	*/
1651	if (m->tmpname)
1652	{
1653	free (m->tmpname);
1654	m->tmpname = NULL;
1655	}
1656	last = NULL;
1657	/* We need to look through all the maps and see if any maps	1527	/* We need to look through all the maps and see if any maps
1658	* are pointing at this one for tiling information. Since	1528	* are pointing at this one for tiling information. Since
1659	* tiling can be assymetric, we just can not look to see which	1529	* tiling can be asymetric, we just can not look to see which
1660	* maps this map tiles with and clears those.	1530	* maps this map tiles with and clears those.
1661	*/	1531	*/
1662	for (tmp = first_map; tmp != NULL; tmp = tmp->next)	1532	//TODO: non-euclidean-tiling MUST GO
1663	{	1533	for_all_maps (m)
1664	if (tmp->next == m)
1665	last = tmp;
1666
1667	/* This should hopefully get unrolled on a decent compiler */
1668	for (i = 0; i < 4; i++)	1534	for (int i = 0; i < 4; i++)
1669	if (tmp->tile_map[i] == m)	1535	if (m->tile_map[i] == this)
1670	tmp->tile_map[i] = NULL;	1536	m->tile_map[i] = 0;
1671	}
1672
1673	/* If last is null, then this should be the first map in the list */
1674	if (!last)
1675	{
1676	if (m == first_map)
1677	first_map = m->next;
1678	else
1679	/* m->path is a static char, so should hopefully still have
1680	* some useful data in it.
1681	*/
1682	LOG (llevError, "delete_map: Unable to find map %s in list\n", m->path);
1683	}
1684	else
1685	last->next = m->next;
1686
1687	delete m;
1688	}	1537	}
1689		1538
1690		1539	//TODO: must go
		1540	void
		1541	delete_map (maptile *m)
		1542	{
		1543	if (m)
		1544	m->destroy ();
		1545	}
1691		1546
1692	/*	1547	/*
1693	* Makes sure the given map is loaded and swapped in.	1548	* Makes sure the given map is loaded and swapped in.
1694	* name is path name of the map.	1549	* name is path name of the map.
1695	* flags meaning:	1550	* flags meaning:
…		…
1698	* 0x2 (MAP_PLAYER_UNIQUE) - this is a unique map for each player.	1553	* 0x2 (MAP_PLAYER_UNIQUE) - this is a unique map for each player.
1699	* dont do any more name translation on it.	1554	* dont do any more name translation on it.
1700	*	1555	*
1701	* Returns a pointer to the given map.	1556	* Returns a pointer to the given map.
1702	*/	1557	*/
1703		1558	maptile *
1704	mapstruct *
1705	ready_map_name (const char *name, int flags)	1559	ready_map_name (const char *name, int flags)
1706	{	1560	{
1707	mapstruct *m;
1708
1709	if (!name)	1561	if (!name)
1710	return (NULL);	1562	return 0;
1711		1563
1712	/* Have we been at this level before? */	1564	/* Have we been at this level before? */
1713	m = has_been_loaded (name);	1565	maptile *m = has_been_loaded (name);
1714		1566
1715	/* Map is good to go, so just return it */	1567	/* Map is good to go, so just return it */
1716	if (m && (m->in_memory == MAP_LOADING || m->in_memory == MAP_IN_MEMORY))	1568	if (m && (m->in_memory == MAP_LOADING || m->in_memory == MAP_IN_MEMORY))
1717	{
1718	return m;	1569	return m;
1719	}
1720		1570
1721	/* unique maps always get loaded from their original location, and never	1571	/* unique maps always get loaded from their original location, and never
1722	* a temp location. Likewise, if map_flush is set, or we have never loaded	1572	* a temp location. Likewise, if map_flush is set, or we have never loaded
1723	* this map, load it now. I removed the reset checking from here -	1573	* this map, load it now. I removed the reset checking from here -
1724	* it seems the probability of a player trying to enter a map that should	1574	* it seems the probability of a player trying to enter a map that should
…		…
1726	* a bit cleaner (and players probably shouldn't rely on exact timing for	1576	* a bit cleaner (and players probably shouldn't rely on exact timing for
1727	* resets in any case - if they really care, they should use the 'maps command.	1577	* resets in any case - if they really care, they should use the 'maps command.
1728	*/	1578	*/
1729	if ((flags & (MAP_FLUSH | MAP_PLAYER_UNIQUE)) || !m)	1579	if ((flags & (MAP_FLUSH | MAP_PLAYER_UNIQUE)) || !m)
1730	{	1580	{
1731
1732	/* first visit or time to reset */	1581	/* first visit or time to reset */
1733	if (m)	1582	if (m)
1734	{	1583	{
1735	clean_tmp_map (m); /* Doesn't make much difference */	1584	clean_tmp_map (m); /* Doesn't make much difference */
1736	delete_map (m);	1585	delete_map (m);
…		…
1740	if (flags & MAP_PLAYER_UNIQUE)	1589	if (flags & MAP_PLAYER_UNIQUE)
1741	LOG (llevDebug, "Trying to load map %s.\n", name);	1590	LOG (llevDebug, "Trying to load map %s.\n", name);
1742	else	1591	else
1743	LOG (llevDebug, "Trying to load map %s.\n", create_pathname (name));	1592	LOG (llevDebug, "Trying to load map %s.\n", create_pathname (name));
1744		1593
1745	//eval_pv ("$x = Event::time", 1);//D
1746	if (!(m = load_original_map (name, (flags & MAP_PLAYER_UNIQUE))))	1594	if (!(m = load_original_map (name, (flags & MAP_PLAYER_UNIQUE))))
1747	return (NULL);	1595	return (NULL);
1748	//eval_pv ("warn \"LOAD \", Event::time - $x", 1);//D
1749		1596
1750	fix_auto_apply (m); /* Chests which open as default */	1597	fix_auto_apply (m); /* Chests which open as default */
1751		1598
1752	/* If a player unique map, no extra unique object file to load.	1599	/* If a player unique map, no extra unique object file to load.
1753	* if from the editor, likewise.	1600	* if from the editor, likewise.
…		…
1814	* have a difficulty set than using this function - human calculation	1661	* have a difficulty set than using this function - human calculation
1815	* is much better than this functions guesswork.	1662	* is much better than this functions guesswork.
1816	*/	1663	*/
1817		1664
1818	int	1665	int
1819	calculate_difficulty (mapstruct *m)	1666	calculate_difficulty (maptile *m)
1820	{	1667	{
1821	object *op;	1668	object *op;
1822	archetype *at;	1669	archetype *at;
1823	int x, y, i;	1670	int x, y, i;
1824	long monster_cnt = 0;	1671	long monster_cnt = 0;
1825	double avgexp = 0;	1672	double avgexp = 0;
1826	sint64 total_exp = 0;	1673	sint64 total_exp = 0;
1827		1674
1828	if (MAP_DIFFICULTY (m))	1675	if (m->difficulty)
1829	{	1676	{
1830	LOG (llevDebug, "Using stored map difficulty: %d\n", MAP_DIFFICULTY (m));	1677	LOG (llevDebug, "Using stored map difficulty: %d\n", m->difficulty);
1831	return MAP_DIFFICULTY (m);	1678	return m->difficulty;
1832	}	1679	}
1833		1680
1834	for (x = 0; x < MAP_WIDTH (m); x++)	1681	for (x = 0; x < m->width; x++)
1835	for (y = 0; y < MAP_HEIGHT (m); y++)	1682	for (y = 0; y < m->height; y++)
1836	for (op = get_map_ob (m, x, y); op != NULL; op = op->above)	1683	for (op = GET_MAP_OB (m, x, y); op != NULL; op = op->above)
1837	{	1684	{
1838	if (QUERY_FLAG (op, FLAG_MONSTER))	1685	if (QUERY_FLAG (op, FLAG_MONSTER))
1839	{	1686	{
1840	total_exp += op->stats.exp;	1687	total_exp += op->stats.exp;
1841	monster_cnt++;	1688	monster_cnt++;
…		…
1866		1713
1867	return 1;	1714	return 1;
1868	}	1715	}
1869		1716
1870	void	1717	void
1871	clean_tmp_map (mapstruct *m)	1718	clean_tmp_map (maptile *m)
1872	{	1719	{
1873	if (m->tmpname == NULL)	1720	if (m->tmpname == NULL)
1874	return;	1721	return;
1875	INVOKE_MAP (CLEAN, m);	1722	INVOKE_MAP (CLEAN, m);
1876	(void) unlink (m->tmpname);	1723	(void) unlink (m->tmpname);
…		…
1889	if (first_map->in_memory == MAP_SAVING)	1736	if (first_map->in_memory == MAP_SAVING)
1890	first_map->in_memory = MAP_IN_MEMORY;	1737	first_map->in_memory = MAP_IN_MEMORY;
1891	delete_map (first_map);	1738	delete_map (first_map);
1892	real_maps++;	1739	real_maps++;
1893	}	1740	}
		1741
1894	LOG (llevDebug, "free_all_maps: Freed %d maps\n", real_maps);	1742	LOG (llevDebug, "free_all_maps: Freed %d maps\n", real_maps);
1895	}	1743	}
1896		1744
1897	/* change_map_light() - used to change map light level (darkness)	1745	/* change_map_light() - used to change map light level (darkness)
1898	* up or down. Returns true if successful. It should now be	1746	* up or down. Returns true if successful. It should now be
…		…
1901	* to maps than los.	1749	* to maps than los.
1902	* postive values make it darker, negative make it brighter	1750	* postive values make it darker, negative make it brighter
1903	*/	1751	*/
1904		1752
1905	int	1753	int
1906	change_map_light (mapstruct *m, int change)	1754	change_map_light (maptile *m, int change)
1907	{	1755	{
1908	int new_level = m->darkness + change;	1756	int new_level = m->darkness + change;
1909		1757
1910	/* Nothing to do */	1758	/* Nothing to do */
1911	if (!change || (new_level <= 0 && m->darkness == 0) || (new_level >= MAX_DARKNESS && m->darkness >= MAX_DARKNESS))	1759	if (!change || (new_level <= 0 && m->darkness == 0) || (new_level >= MAX_DARKNESS && m->darkness >= MAX_DARKNESS))
…		…
1934	/* All clients need to get re-updated for the change */	1782	/* All clients need to get re-updated for the change */
1935	update_all_map_los (m);	1783	update_all_map_los (m);
1936	return 1;	1784	return 1;
1937	}	1785	}
1938		1786
1939
1940	/*	1787	/*
1941	* This function updates various attributes about a specific space	1788	* This function updates various attributes about a specific space
1942	* on the map (what it looks like, whether it blocks magic,	1789	* on the map (what it looks like, whether it blocks magic,
1943	* has a living creatures, prevents people from passing	1790	* has a living creatures, prevents people from passing
1944	* through, etc)	1791	* through, etc)
1945	*/	1792	*/
1946	void	1793	void
1947	update_position (mapstruct *m, int x, int y)	1794	mapspace::update_ ()
1948	{	1795	{
1949	object *tmp, *last = NULL;	1796	object *tmp, *last = 0;
1950	uint8 flags = 0, oldflags, light = 0, anywhere = 0;	1797	uint8 flags = 0, light = 0, anywhere = 0;
1951	New_Face *top, *floor, *middle;	1798	New_Face *top, *floor, *middle;
1952	object *top_obj, *floor_obj, *middle_obj;	1799	object *top_obj, *floor_obj, *middle_obj;
1953	MoveType move_block = 0, move_slow = 0, move_on = 0, move_off = 0, move_allow = 0;	1800	MoveType move_block = 0, move_slow = 0, move_on = 0, move_off = 0, move_allow = 0;
1954		1801
1955	oldflags = GET_MAP_FLAGS (m, x, y);
1956	if (!(oldflags & P_NEED_UPDATE))
1957	{
1958	LOG (llevDebug, "update_position called with P_NEED_UPDATE not set: %s (%d, %d)\n", m->path, x, y);
1959	return;
1960	}
1961
1962	middle = blank_face;	1802	middle = blank_face;
1963	top = blank_face;	1803	top = blank_face;
1964	floor = blank_face;	1804	floor = blank_face;
1965		1805
1966	middle_obj = NULL;	1806	middle_obj = 0;
1967	top_obj = NULL;	1807	top_obj = 0;
1968	floor_obj = NULL;	1808	floor_obj = 0;
1969		1809
1970	for (tmp = get_map_ob (m, x, y); tmp; last = tmp, tmp = tmp->above)	1810	for (tmp = bot; tmp; last = tmp, tmp = tmp->above)
1971	{	1811	{
1972
1973	/* This could be made additive I guess (two lights better than	1812	/* This could be made additive I guess (two lights better than
1974	* one). But if so, it shouldn't be a simple additive - 2	1813	* one). But if so, it shouldn't be a simple additive - 2
1975	* light bulbs do not illuminate twice as far as once since	1814	* light bulbs do not illuminate twice as far as once since
1976	* it is a disapation factor that is squared (or is it cubed?)	1815	* it is a dissapation factor that is cubed.
1977	*/	1816	*/
1978	if (tmp->glow_radius > light)	1817	if (tmp->glow_radius > light)
1979	light = tmp->glow_radius;	1818	light = tmp->glow_radius;
1980		1819
1981	/* This call is needed in order to update objects the player	1820	/* This call is needed in order to update objects the player
…		…
2019	{	1858	{
2020	middle = tmp->face;	1859	middle = tmp->face;
2021	middle_obj = tmp;	1860	middle_obj = tmp;
2022	}	1861	}
2023	}	1862	}
		1863
2024	if (tmp == tmp->above)	1864	if (tmp == tmp->above)
2025	{	1865	{
2026	LOG (llevError, "Error in structure of map\n");	1866	LOG (llevError, "Error in structure of map\n");
2027	exit (-1);	1867	exit (-1);
2028	}	1868	}
2029		1869
2030	move_slow |= tmp->move_slow;	1870	move_slow |= tmp->move_slow;
2031	move_block |= tmp->move_block;	1871	move_block |= tmp->move_block;
2032	move_on |= tmp->move_on;	1872	move_on |= tmp->move_on;
2033	move_off |= tmp->move_off;	1873	move_off |= tmp->move_off;
2034	move_allow |= tmp->move_allow;	1874	move_allow |= tmp->move_allow;
2035		1875
2036	if (QUERY_FLAG (tmp, FLAG_ALIVE))
2037	flags |= P_IS_ALIVE;
2038	if (QUERY_FLAG (tmp, FLAG_NO_MAGIC))
2039	flags |= P_NO_MAGIC;
2040	if (QUERY_FLAG (tmp, FLAG_DAMNED))
2041	flags |= P_NO_CLERIC;
2042	if (tmp->type == SAFE_GROUND)
2043	flags |= P_SAFE;
2044
2045	if (QUERY_FLAG (tmp, FLAG_BLOCKSVIEW))	1876	if (QUERY_FLAG (tmp, FLAG_BLOCKSVIEW)) flags |= P_BLOCKSVIEW;
2046	flags |= P_BLOCKSVIEW;	1877	if (QUERY_FLAG (tmp, FLAG_NO_MAGIC)) flags |= P_NO_MAGIC;
2047	} /* for stack of objects */	1878	if (tmp->type == PLAYER) flags |= P_PLAYER;
2048		1879	if (tmp->type == SAFE_GROUND) flags |= P_SAFE;
2049	/* we don't want to rely on this function to have accurate flags, but	1880	if (QUERY_FLAG (tmp, FLAG_ALIVE)) flags |= P_IS_ALIVE;
2050	* since we're already doing the work, we calculate them here.	1881	if (QUERY_FLAG (tmp, FLAG_DAMNED)) flags |= P_NO_CLERIC;
2051	* if they don't match, logic is broken someplace.
2052	*/
2053	if (((oldflags & ~(P_NEED_UPDATE | P_NO_ERROR)) != flags) && (!(oldflags & P_NO_ERROR)))
2054	{	1882	}
2055	LOG (llevDebug, "update_position: updated flags do not match old flags: %s (old=%d,new=%d) %x != %x\n",	1883
2056	m->path, x, y, (oldflags & ~P_NEED_UPDATE), flags);	1884	this->light = light;
2057	}	1885	this->flags_ = flags;
2058	SET_MAP_FLAGS (m, x, y, flags);	1886	this->move_block = move_block & ~move_allow;
2059	SET_MAP_MOVE_BLOCK (m, x, y, move_block & ~move_allow);	1887	this->move_on = move_on;
2060	SET_MAP_MOVE_ON (m, x, y, move_on);	1888	this->move_off = move_off;
2061	SET_MAP_MOVE_OFF (m, x, y, move_off);	1889	this->move_slow = move_slow;
2062	SET_MAP_MOVE_SLOW (m, x, y, move_slow);
2063		1890
2064	/* At this point, we have a floor face (if there is a floor),	1891	/* At this point, we have a floor face (if there is a floor),
2065	* and the floor is set - we are not going to touch it at	1892	* and the floor is set - we are not going to touch it at
2066	* this point.	1893	* this point.
2067	* middle contains the highest visibility face.	1894	* middle contains the highest visibility face.
…		…
2121	break;	1948	break;
2122	}	1949	}
2123	}	1950	}
2124	}	1951	}
2125	}	1952	}
		1953
2126	if (middle == floor)	1954	if (middle == floor)
2127	middle = blank_face;	1955	middle = blank_face;
		1956
2128	if (top == middle)	1957	if (top == middle)
2129	middle = blank_face;	1958	middle = blank_face;
2130	SET_MAP_FACE (m, x, y, top, 0);
2131	if (top != blank_face)
2132	SET_MAP_FACE_OBJ (m, x, y, top_obj, 0);
2133	else
2134	SET_MAP_FACE_OBJ (m, x, y, NULL, 0);
2135	SET_MAP_FACE (m, x, y, middle, 1);
2136	if (middle != blank_face)
2137	SET_MAP_FACE_OBJ (m, x, y, middle_obj, 1);
2138	else
2139	SET_MAP_FACE_OBJ (m, x, y, NULL, 1);
2140	SET_MAP_FACE (m, x, y, floor, 2);
2141	if (floor != blank_face)
2142	SET_MAP_FACE_OBJ (m, x, y, floor_obj, 2);
2143	else
2144	SET_MAP_FACE_OBJ (m, x, y, NULL, 2);
2145	SET_MAP_LIGHT (m, x, y, light);
2146	}
2147		1959
		1960	faces [0] = top; faces_obj [0] = top != blank_face ? top_obj : 0;
		1961	faces [1] = middle; faces_obj [1] = middle != blank_face ? middle_obj : 0;
		1962	faces [2] = floor; faces_obj [2] = floor != blank_face ? floor_obj : 0;
		1963	}
2148		1964
2149	void	1965	void
2150	set_map_reset_time (mapstruct *map)	1966	set_map_reset_time (maptile *map)
2151	{	1967	{
2152	int timeout;	1968	int timeout = map->reset_timeout;
2153		1969
2154	timeout = MAP_RESET_TIMEOUT (map);
2155	if (timeout <= 0)	1970	if (timeout <= 0)
2156	timeout = MAP_DEFAULTRESET;	1971	timeout = MAP_DEFAULTRESET;
2157	if (timeout >= MAP_MAXRESET)	1972	if (timeout >= MAP_MAXRESET)
2158	timeout = MAP_MAXRESET;	1973	timeout = MAP_MAXRESET;
2159	MAP_WHEN_RESET (map) = seconds () + timeout;	1974
		1975	map->reset_time = time (0) + timeout;
2160	}	1976	}
2161		1977
2162	/* this updates the orig_map->tile_map[tile_num] value after loading	1978	/* this updates the orig_map->tile_map[tile_num] value after loading
2163	* the map. It also takes care of linking back the freshly loaded	1979	* the map. It also takes care of linking back the freshly loaded
2164	* maps tile_map values if it tiles back to this one. It returns	1980	* maps tile_map values if it tiles back to this one. It returns
2165	* the value of orig_map->tile_map[tile_num]. It really only does this	1981	* the value of orig_map->tile_map[tile_num]. It really only does this
2166	* so that it is easier for calling functions to verify success.	1982	* so that it is easier for calling functions to verify success.
2167	*/	1983	*/
2168		1984
2169	static mapstruct *	1985	static maptile *
2170	load_and_link_tiled_map (mapstruct *orig_map, int tile_num)	1986	load_and_link_tiled_map (maptile *orig_map, int tile_num)
2171	{	1987	{
2172	int dest_tile = (tile_num + 2) % 4;	1988	int dest_tile = (tile_num + 2) % 4;
2173	char *path = path_combine_and_normalize (orig_map->path, orig_map->tile_path[tile_num]);	1989	char *path = path_combine_and_normalize (orig_map->path, orig_map->tile_path[tile_num]);
2174		1990
2175	orig_map->tile_map[tile_num] = ready_map_name (path, 0);	1991	orig_map->tile_map[tile_num] = ready_map_name (path, 0);
…		…
2190	* tiled maps.	2006	* tiled maps.
2191	*	2007	*
2192	*	2008	*
2193	*/	2009	*/
2194	int	2010	int
2195	out_of_map (mapstruct *m, int x, int y)	2011	out_of_map (maptile *m, int x, int y)
2196	{	2012	{
2197
2198	/* If we get passed a null map, this is obviously the	2013	/* If we get passed a null map, this is obviously the
2199	* case. This generally shouldn't happen, but if the	2014	* case. This generally shouldn't happen, but if the
2200	* map loads fail below, it could happen.	2015	* map loads fail below, it could happen.
2201	*/	2016	*/
2202	if (!m)	2017	if (!m)
…		…
2204		2019
2205	if (x < 0)	2020	if (x < 0)
2206	{	2021	{
2207	if (!m->tile_path[3])	2022	if (!m->tile_path[3])
2208	return 1;	2023	return 1;
		2024
2209	if (!m->tile_map[3] || m->tile_map[3]->in_memory != MAP_IN_MEMORY)	2025	if (!m->tile_map[3] || m->tile_map[3]->in_memory != MAP_IN_MEMORY)
2210	{
2211	load_and_link_tiled_map (m, 3);	2026	load_and_link_tiled_map (m, 3);
2212	}	2027
2213	return (out_of_map (m->tile_map[3], x + MAP_WIDTH (m->tile_map[3]), y));	2028	return (out_of_map (m->tile_map[3], x + m->tile_map[3]->width, y));
2214	}	2029	}
2215	if (x >= MAP_WIDTH (m))	2030
		2031	if (x >= m->width)
2216	{	2032	{
2217	if (!m->tile_path[1])	2033	if (!m->tile_path[1])
2218	return 1;	2034	return 1;
		2035
2219	if (!m->tile_map[1] || m->tile_map[1]->in_memory != MAP_IN_MEMORY)	2036	if (!m->tile_map[1] || m->tile_map[1]->in_memory != MAP_IN_MEMORY)
2220	{
2221	load_and_link_tiled_map (m, 1);	2037	load_and_link_tiled_map (m, 1);
2222	}	2038
2223	return (out_of_map (m->tile_map[1], x - MAP_WIDTH (m), y));	2039	return (out_of_map (m->tile_map[1], x - m->width, y));
2224	}	2040	}
		2041
2225	if (y < 0)	2042	if (y < 0)
2226	{	2043	{
2227	if (!m->tile_path[0])	2044	if (!m->tile_path[0])
2228	return 1;	2045	return 1;
		2046
2229	if (!m->tile_map[0] || m->tile_map[0]->in_memory != MAP_IN_MEMORY)	2047	if (!m->tile_map[0] || m->tile_map[0]->in_memory != MAP_IN_MEMORY)
2230	{
2231	load_and_link_tiled_map (m, 0);	2048	load_and_link_tiled_map (m, 0);
2232	}	2049
2233	return (out_of_map (m->tile_map[0], x, y + MAP_HEIGHT (m->tile_map[0])));	2050	return (out_of_map (m->tile_map[0], x, y + m->tile_map[0]->height));
2234	}	2051	}
2235	if (y >= MAP_HEIGHT (m))	2052
		2053	if (y >= m->height)
2236	{	2054	{
2237	if (!m->tile_path[2])	2055	if (!m->tile_path[2])
2238	return 1;	2056	return 1;
		2057
2239	if (!m->tile_map[2] || m->tile_map[2]->in_memory != MAP_IN_MEMORY)	2058	if (!m->tile_map[2] || m->tile_map[2]->in_memory != MAP_IN_MEMORY)
2240	{
2241	load_and_link_tiled_map (m, 2);	2059	load_and_link_tiled_map (m, 2);
2242	}	2060
2243	return (out_of_map (m->tile_map[2], x, y - MAP_HEIGHT (m)));	2061	return (out_of_map (m->tile_map[2], x, y - m->height));
2244	}	2062	}
2245		2063
2246	/* Simple case - coordinates are within this local	2064	/* Simple case - coordinates are within this local
2247	* map.	2065	* map.
2248	*/	2066	*/
…		…
2255	* the map as that the coordinates are really on, and	2073	* the map as that the coordinates are really on, and
2256	* updates x and y to be the localized coordinates.	2074	* updates x and y to be the localized coordinates.
2257	* Using this is more efficient of calling out_of_map	2075	* Using this is more efficient of calling out_of_map
2258	* and then figuring out what the real map is	2076	* and then figuring out what the real map is
2259	*/	2077	*/
2260	mapstruct *	2078	maptile *
2261	get_map_from_coord (mapstruct *m, sint16 * x, sint16 * y)	2079	get_map_from_coord (maptile *m, sint16 * x, sint16 * y)
2262	{	2080	{
2263		2081
2264	if (*x < 0)	2082	if (*x < 0)
2265	{	2083	{
2266	if (!m->tile_path[3])	2084	if (!m->tile_path[3])
2267	return NULL;	2085	return 0;
2268	if (!m->tile_map[3] || m->tile_map[3]->in_memory != MAP_IN_MEMORY)	2086	if (!m->tile_map[3] || m->tile_map[3]->in_memory != MAP_IN_MEMORY)
2269	load_and_link_tiled_map (m, 3);	2087	load_and_link_tiled_map (m, 3);
2270		2088
2271	*x += MAP_WIDTH (m->tile_map[3]);	2089	*x += m->tile_map[3]->width;
2272	return (get_map_from_coord (m->tile_map[3], x, y));	2090	return (get_map_from_coord (m->tile_map[3], x, y));
2273	}	2091	}
2274	if (*x >= MAP_WIDTH (m))	2092
		2093	if (*x >= m->width)
2275	{	2094	{
2276	if (!m->tile_path[1])	2095	if (!m->tile_path[1])
2277	return NULL;	2096	return 0;
		2097
2278	if (!m->tile_map[1] || m->tile_map[1]->in_memory != MAP_IN_MEMORY)	2098	if (!m->tile_map[1] || m->tile_map[1]->in_memory != MAP_IN_MEMORY)
2279	load_and_link_tiled_map (m, 1);	2099	load_and_link_tiled_map (m, 1);
2280		2100
2281	*x -= MAP_WIDTH (m);	2101	*x -= m->width;
2282	return (get_map_from_coord (m->tile_map[1], x, y));	2102	return (get_map_from_coord (m->tile_map[1], x, y));
2283	}	2103	}
		2104
2284	if (*y < 0)	2105	if (*y < 0)
2285	{	2106	{
2286	if (!m->tile_path[0])	2107	if (!m->tile_path[0])
2287	return NULL;	2108	return 0;
		2109
2288	if (!m->tile_map[0] || m->tile_map[0]->in_memory != MAP_IN_MEMORY)	2110	if (!m->tile_map[0] || m->tile_map[0]->in_memory != MAP_IN_MEMORY)
2289	load_and_link_tiled_map (m, 0);	2111	load_and_link_tiled_map (m, 0);
2290		2112
2291	*y += MAP_HEIGHT (m->tile_map[0]);	2113	*y += m->tile_map[0]->height;
2292	return (get_map_from_coord (m->tile_map[0], x, y));	2114	return (get_map_from_coord (m->tile_map[0], x, y));
2293	}	2115	}
2294	if (*y >= MAP_HEIGHT (m))	2116
		2117	if (*y >= m->height)
2295	{	2118	{
2296	if (!m->tile_path[2])	2119	if (!m->tile_path[2])
2297	return NULL;	2120	return 0;
		2121
2298	if (!m->tile_map[2] || m->tile_map[2]->in_memory != MAP_IN_MEMORY)	2122	if (!m->tile_map[2] || m->tile_map[2]->in_memory != MAP_IN_MEMORY)
2299	load_and_link_tiled_map (m, 2);	2123	load_and_link_tiled_map (m, 2);
2300		2124
2301	*y -= MAP_HEIGHT (m);	2125	*y -= m->height;
2302	return (get_map_from_coord (m->tile_map[2], x, y));	2126	return (get_map_from_coord (m->tile_map[2], x, y));
2303	}	2127	}
2304		2128
2305	/* Simple case - coordinates are within this local	2129	/* Simple case - coordinates are within this local
2306	* map.	2130	* map.
…		…
2312	/**	2136	/**
2313	* Return whether map2 is adjacent to map1. If so, store the distance from	2137	* Return whether map2 is adjacent to map1. If so, store the distance from
2314	* map1 to map2 in dx/dy.	2138	* map1 to map2 in dx/dy.
2315	*/	2139	*/
2316	static int	2140	static int
2317	adjacent_map (const mapstruct *map1, const mapstruct *map2, int *dx, int *dy)	2141	adjacent_map (const maptile *map1, const maptile *map2, int *dx, int *dy)
2318	{	2142	{
2319	if (!map1 || !map2)	2143	if (!map1 || !map2)
2320	return 0;	2144	return 0;
2321		2145
2322	if (map1 == map2)	2146	if (map1 == map2)
…		…
2326		2150
2327	}	2151	}
2328	else if (map1->tile_map[0] == map2)	2152	else if (map1->tile_map[0] == map2)
2329	{ /* up */	2153	{ /* up */
2330	*dx = 0;	2154	*dx = 0;
2331	*dy = -MAP_HEIGHT (map2);	2155	*dy = -map2->height;
2332	}	2156	}
2333	else if (map1->tile_map[1] == map2)	2157	else if (map1->tile_map[1] == map2)
2334	{ /* right */	2158	{ /* right */
2335	*dx = MAP_WIDTH (map1);	2159	*dx = map1->width;
2336	*dy = 0;	2160	*dy = 0;
2337	}	2161	}
2338	else if (map1->tile_map[2] == map2)	2162	else if (map1->tile_map[2] == map2)
2339	{ /* down */	2163	{ /* down */
2340	*dx = 0;	2164	*dx = 0;
2341	*dy = MAP_HEIGHT (map1);	2165	*dy = map1->height;
2342	}	2166	}
2343	else if (map1->tile_map[3] == map2)	2167	else if (map1->tile_map[3] == map2)
2344	{ /* left */	2168	{ /* left */
2345	*dx = -MAP_WIDTH (map2);	2169	*dx = -map2->width;
2346	*dy = 0;	2170	*dy = 0;
2347		2171
2348	}	2172	}
2349	else if (map1->tile_map[0] && map1->tile_map[0]->tile_map[1] == map2)	2173	else if (map1->tile_map[0] && map1->tile_map[0]->tile_map[1] == map2)
2350	{ /* up right */	2174	{ /* up right */
2351	*dx = MAP_WIDTH (map1->tile_map[0]);	2175	*dx = map1->tile_map[0]->width;
2352	*dy = -MAP_HEIGHT (map1->tile_map[0]);	2176	*dy = -map1->tile_map[0]->height;
2353	}	2177	}
2354	else if (map1->tile_map[0] && map1->tile_map[0]->tile_map[3] == map2)	2178	else if (map1->tile_map[0] && map1->tile_map[0]->tile_map[3] == map2)
2355	{ /* up left */	2179	{ /* up left */
2356	*dx = -MAP_WIDTH (map2);	2180	*dx = -map2->width;
2357	*dy = -MAP_HEIGHT (map1->tile_map[0]);	2181	*dy = -map1->tile_map[0]->height;
2358	}	2182	}
2359	else if (map1->tile_map[1] && map1->tile_map[1]->tile_map[0] == map2)	2183	else if (map1->tile_map[1] && map1->tile_map[1]->tile_map[0] == map2)
2360	{ /* right up */	2184	{ /* right up */
2361	*dx = MAP_WIDTH (map1);	2185	*dx = map1->width;
2362	*dy = -MAP_HEIGHT (map2);	2186	*dy = -map2->height;
2363	}	2187	}
2364	else if (map1->tile_map[1] && map1->tile_map[1]->tile_map[2] == map2)	2188	else if (map1->tile_map[1] && map1->tile_map[1]->tile_map[2] == map2)
2365	{ /* right down */	2189	{ /* right down */
2366	*dx = MAP_WIDTH (map1);	2190	*dx = map1->width;
2367	*dy = MAP_HEIGHT (map1->tile_map[1]);	2191	*dy = map1->tile_map[1]->height;
2368	}	2192	}
2369	else if (map1->tile_map[2] && map1->tile_map[2]->tile_map[1] == map2)	2193	else if (map1->tile_map[2] && map1->tile_map[2]->tile_map[1] == map2)
2370	{ /* down right */	2194	{ /* down right */
2371	*dx = MAP_WIDTH (map1->tile_map[2]);	2195	*dx = map1->tile_map[2]->width;
2372	*dy = MAP_HEIGHT (map1);	2196	*dy = map1->height;
2373	}	2197	}
2374	else if (map1->tile_map[2] && map1->tile_map[2]->tile_map[3] == map2)	2198	else if (map1->tile_map[2] && map1->tile_map[2]->tile_map[3] == map2)
2375	{ /* down left */	2199	{ /* down left */
2376	*dx = -MAP_WIDTH (map2);	2200	*dx = -map2->width;
2377	*dy = MAP_HEIGHT (map1);	2201	*dy = map1->height;
2378	}	2202	}
2379	else if (map1->tile_map[3] && map1->tile_map[3]->tile_map[0] == map2)	2203	else if (map1->tile_map[3] && map1->tile_map[3]->tile_map[0] == map2)
2380	{ /* left up */	2204	{ /* left up */
2381	*dx = -MAP_WIDTH (map1->tile_map[3]);	2205	*dx = -map1->tile_map[3]->width;
2382	*dy = -MAP_HEIGHT (map2);	2206	*dy = -map2->height;
2383	}	2207	}
2384	else if (map1->tile_map[3] && map1->tile_map[3]->tile_map[2] == map2)	2208	else if (map1->tile_map[3] && map1->tile_map[3]->tile_map[2] == map2)
2385	{ /* left down */	2209	{ /* left down */
2386	*dx = -MAP_WIDTH (map1->tile_map[3]);	2210	*dx = -map1->tile_map[3]->width;
2387	*dy = MAP_HEIGHT (map1->tile_map[3]);	2211	*dy = map1->tile_map[3]->height;
2388		2212
2389	}	2213	}
2390	else	2214	else
2391	{ /* not "adjacent" enough */	2215	{ /* not "adjacent" enough */
2392	return 0;	2216	return 0;
…		…
2480	* for something in the future. Also, since no object is pasted, the best	2304	* for something in the future. Also, since no object is pasted, the best
2481	* field of the rv_vector is set to NULL.	2305	* field of the rv_vector is set to NULL.
2482	*/	2306	*/
2483		2307
2484	void	2308	void
2485	get_rangevector_from_mapcoord (const mapstruct *m, int x, int y, const object *op2, rv_vector * retval, int flags)	2309	get_rangevector_from_mapcoord (const maptile *m, int x, int y, const object *op2, rv_vector * retval, int flags)
2486	{	2310	{
2487	if (!adjacent_map (m, op2->map, &retval->distance_x, &retval->distance_y))	2311	if (!adjacent_map (m, op2->map, &retval->distance_x, &retval->distance_y))
2488	{	2312	{
2489	/* be conservative and fill in _some_ data */	2313	/* be conservative and fill in _some_ data */
2490	retval->distance = 100000;	2314	retval->distance = 100000;
…		…
2517	{	2341	{
2518	int dx, dy;	2342	int dx, dy;
2519		2343
2520	return adjacent_map (op1->map, op2->map, &dx, &dy);	2344	return adjacent_map (op1->map, op2->map, &dx, &dy);
2521	}	2345	}
		2346
		2347	object *
		2348	maptile::insert (object *op, int x, int y, object *originator, int flags)
		2349	{
		2350	if (!op->flag [FLAG_REMOVED])
		2351	op->remove ();
		2352
		2353	return insert_ob_in_map_at (op, this, originator, flags, x, y);
		2354	}
		2355

Diff Legend

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