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.1 by elmex, Sun Aug 13 17:16:00 2006 UTC vs.
Revision 1.56 by root, Sat Dec 30 10:16:10 2006 UTC

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

Diff Legend

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