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

Diff Legend

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