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.9 by root, Sun Aug 27 16:15:11 2006 UTC vs.
Revision 1.27 by root, Fri Sep 8 12:56:42 2006 UTC

1	/*	1	/*
2	* static char *rcsid_map_c =	2	* static char *rcsid_map_c =
3	* "$Id: map.C,v 1.9 2006/08/27 16:15:11 root Exp $";	3	* "$Id: map.C,v 1.27 2006/09/08 12:56:42 root Exp $";
4	*/	4	*/
5		5
6	/*	6	/*
7	CrossFire, A Multiplayer game for X-windows	7	CrossFire, A Multiplayer game for X-windows
8		8
…		…
47		47
48	mapstruct *has_been_loaded (const char *name) {	48	mapstruct *has_been_loaded (const char *name) {
49	mapstruct *map;	49	mapstruct *map;
50		50
51	if (!name || !*name)	51	if (!name || !*name)
52	return 0;	52	return 0;
53	for (map = first_map; map; map = map->next)	53	for (map = first_map; map; map = map->next)
54	if (!strcmp (name, map->path))	54	if (!strcmp (name, map->path))
55	break;	55	break;
56	return (map);	56	return (map);
57	}	57	}
58		58
59	/*	59	/*
60	* This makes a path absolute outside the world of Crossfire.	60	* This makes a path absolute outside the world of Crossfire.
…		…
155	{	155	{
156	char buf[MAX_BUF];	156	char buf[MAX_BUF];
157	#ifndef WIN32	157	#ifndef WIN32
158	char *endbuf;	158	char *endbuf;
159	struct stat statbuf;	159	struct stat statbuf;
160	int mode = 0, i;	160	int mode = 0;
161	#endif	161	#endif
162		162
163	if (prepend_dir)	163	if (prepend_dir)
164	strcpy (buf, create_pathname(name));	164	strcpy (buf, create_pathname(name));
165	else	165	else
166	strcpy(buf, name);	166	strcpy(buf, name);
167	#ifdef WIN32 /* ***win32: check this sucker in windows style. */	167	#ifdef WIN32 /* ***win32: check this sucker in windows style. */
168	return(_access(buf,0));	168	return(_access(buf,0));
169	#else	169	#else
170		170
171	/* old method (strchr(buf, '\0')) seemd very odd to me -	171	/* old method (strchr(buf, '\0')) seemd very odd to me -
172	* this method should be equivalant and is clearer.	172	* this method should be equivalant and is clearer.
173	* Can not use strcat because we need to cycle through	173	* Can not use strcat because we need to cycle through
174	* all the names.	174	* all the names.
175	*/	175	*/
176	endbuf = buf + strlen(buf);	176	endbuf = buf + strlen(buf);
177		177
178	for (i = 0; i < NROF_COMPRESS_METHODS; i++) {
179	if (uncomp[i][0])
180	strcpy(endbuf, uncomp[i][0]);
181	else
182	*endbuf = '\0';
183	if (!stat (buf, &statbuf))	178	if (stat (buf, &statbuf))
184	break;
185	}
186	if (i == NROF_COMPRESS_METHODS)
187	return (-1);	179	return -1;
188	if (!S_ISREG (statbuf.st_mode))	180	if (!S_ISREG (statbuf.st_mode))
189	return (-1);	181	return (-1);
190		182
191	if (((statbuf.st_mode & S_IRGRP) && getegid() == statbuf.st_gid) ||	183	if (((statbuf.st_mode & S_IRGRP) && getegid() == statbuf.st_gid) ||
192	((statbuf.st_mode & S_IRUSR) && geteuid() == statbuf.st_uid) ||	184	((statbuf.st_mode & S_IRUSR) && geteuid() == statbuf.st_uid) ||
193	(statbuf.st_mode & S_IROTH))	185	(statbuf.st_mode & S_IROTH))
194	mode |= 4;	186	mode |= 4;
195		187
196	if ((statbuf.st_mode & S_IWGRP && getegid() == statbuf.st_gid) ||	188	if ((statbuf.st_mode & S_IWGRP && getegid() == statbuf.st_gid) ||
197	(statbuf.st_mode & S_IWUSR && geteuid() == statbuf.st_uid) ||	189	(statbuf.st_mode & S_IWUSR && geteuid() == statbuf.st_uid) ||
198	(statbuf.st_mode & S_IWOTH))	190	(statbuf.st_mode & S_IWOTH))
199	mode |= 2;	191	mode |= 2;
200		192
201	return (mode);	193	return (mode);
202	#endif	194	#endif
203	}	195	}
204		196
…		…
209	*/	201	*/
210		202
211	void dump_map(const mapstruct *m) {	203	void dump_map(const mapstruct *m) {
212	LOG(llevError,"Map %s status: %d.\n",m->path,m->in_memory);	204	LOG(llevError,"Map %s status: %d.\n",m->path,m->in_memory);
213	LOG(llevError,"Size: %dx%d Start: %d,%d\n",	205	LOG(llevError,"Size: %dx%d Start: %d,%d\n",
214	MAP_WIDTH(m), MAP_HEIGHT(m),	206	MAP_WIDTH(m), MAP_HEIGHT(m),
215	MAP_ENTER_X(m), MAP_ENTER_Y(m));	207	MAP_ENTER_X(m), MAP_ENTER_Y(m));
216		208
217	if(m->msg!=NULL)	209	if(m->msg!=NULL)
218	LOG(llevError,"Message:\n%s",m->msg);	210	LOG(llevError,"Message:\n%s",m->msg);
219		211
220	if(m->maplore!=NULL)	212	if(m->maplore!=NULL)
221	LOG(llevError,"Lore:\n%s",m->maplore);	213	LOG(llevError,"Lore:\n%s",m->maplore);
222		214
223	if(m->tmpname!=NULL)	215	if(m->tmpname!=NULL)
224	LOG(llevError,"Tmpname: %s\n",m->tmpname);	216	LOG(llevError,"Tmpname: %s\n",m->tmpname);
225		217
226	LOG(llevError,"Difficulty: %d\n",m->difficulty);	218	LOG(llevError,"Difficulty: %d\n",m->difficulty);
227	LOG(llevError,"Darkness: %d\n",m->darkness);	219	LOG(llevError,"Darkness: %d\n",m->darkness);
228	}	220	}
229		221
…		…
234	*/	226	*/
235		227
236	void dump_all_maps(void) {	228	void dump_all_maps(void) {
237	mapstruct *m;	229	mapstruct *m;
238	for(m=first_map;m!=NULL;m=m->next) {	230	for(m=first_map;m!=NULL;m=m->next) {
239	dump_map(m);	231	dump_map(m);
240	}	232	}
241	}	233	}
242		234
243	/* This rolls up wall, blocks_magic, blocks_view, etc, all into	235	/* This rolls up wall, blocks_magic, blocks_view, etc, all into
244	* one function that just returns a P_.. value (see map.h)	236	* one function that just returns a P_.. value (see map.h)
…		…
259	if (out_of_map(oldmap, x, y)) return P_OUT_OF_MAP;	251	if (out_of_map(oldmap, x, y)) return P_OUT_OF_MAP;
260	newx = x;	252	newx = x;
261	newy = y;	253	newy = y;
262	mp = get_map_from_coord(oldmap, &newx, &newy);	254	mp = get_map_from_coord(oldmap, &newx, &newy);
263	if (mp != oldmap)	255	if (mp != oldmap)
264	retval |= P_NEW_MAP;	256	retval |= P_NEW_MAP;
265	if (newmap) *newmap = mp;	257	if (newmap) *newmap = mp;
266	if (nx) *nx = newx;	258	if (nx) *nx = newx;
267	if (ny) *ny = newy;	259	if (ny) *ny = newy;
268	retval |= mp->spaces[newx + mp->width * newy].flags;	260	retval |= mp->spaces[newx + mp->width * newy].flags;
269		261
…		…
293		285
294	/* Make sure the coordinates are valid - they should be, as caller should	286	/* Make sure the coordinates are valid - they should be, as caller should
295	* have already checked this.	287	* have already checked this.
296	*/	288	*/
297	if (OUT_OF_REAL_MAP(m, sx, sy)) {	289	if (OUT_OF_REAL_MAP(m, sx, sy)) {
298	LOG(llevError,"blocked_link: Passed map, x, y coordinates outside of map\n");	290	LOG(llevError,"blocked_link: Passed map, x, y coordinates outside of map\n");
299	return 1;	291	return 1;
300	}	292	}
301		293
302	/* Save some cycles - instead of calling get_map_flags(), just get the value	294	/* Save some cycles - instead of calling get_map_flags(), just get the value
303	* directly.	295	* directly.
304	*/	296	*/
…		…
320	* let the player through (inventory checkers for example)	312	* let the player through (inventory checkers for example)
321	*/	313	*/
322	if (!(mflags & P_IS_ALIVE) && !OB_TYPE_MOVE_BLOCK(ob, blocked)) return 0;	314	if (!(mflags & P_IS_ALIVE) && !OB_TYPE_MOVE_BLOCK(ob, blocked)) return 0;
323		315
324	if(ob->head != NULL)	316	if(ob->head != NULL)
325	ob=ob->head;	317	ob=ob->head;
326		318
327	/* We basically go through the stack of objects, and if there is	319	/* 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	320	* some other object that has NO_PASS or FLAG_ALIVE set, return
329	* true. If we get through the entire stack, that must mean	321	* true. If we get through the entire stack, that must mean
330	* ob is blocking it, so return 0.	322	* ob is blocking it, so return 0.
331	*/	323	*/
332	for(tmp = GET_MAP_OB(m,sx,sy); tmp!= NULL; tmp = tmp->above) {	324	for(tmp = GET_MAP_OB(m,sx,sy); tmp!= NULL; tmp = tmp->above) {
333		325
334	/* This must be before the checks below. Code for inventory checkers. */	326	/* This must be before the checks below. Code for inventory checkers. */
335	if (tmp->type==CHECK_INV && OB_MOVE_BLOCK(ob, tmp)) {	327	if (tmp->type==CHECK_INV && OB_MOVE_BLOCK(ob, tmp)) {
336	/* If last_sp is set, the player/monster needs an object,	328	/* 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	329	* so we check for it. If they don't have it, they can't
338	* pass through this space.	330	* pass through this space.
339	*/	331	*/
340	if (tmp->last_sp) {	332	if (tmp->last_sp) {
341	if (check_inv_recursive(ob,tmp)==NULL)	333	if (check_inv_recursive(ob,tmp)==NULL)
342	return 1;	334	return 1;
343	else	335	else
344	continue;	336	continue;
345	} else {	337	} else {
346	/* In this case, the player must not have the object -	338	/* In this case, the player must not have the object -
347	* if they do, they can't pass through.	339	* if they do, they can't pass through.
348	*/	340	*/
349	if (check_inv_recursive(ob,tmp)!=NULL) /* player has object */	341	if (check_inv_recursive(ob,tmp)!=NULL) /* player has object */
350	return 1;	342	return 1;
351	else	343	else
352	continue;	344	continue;
353	}	345	}
354	} /* if check_inv */	346	} /* if check_inv */
355	else {	347	else {
356	/* Broke apart a big nasty if into several here to make	348	/* Broke apart a big nasty if into several here to make
357	* this more readable. first check - if the space blocks	349	* this more readable. first check - if the space blocks
358	* movement, can't move here.	350	* movement, can't move here.
359	* second - if a monster, can't move there, unles it is a	351	* second - if a monster, can't move there, unles it is a
360	* hidden dm	352	* hidden dm
361	*/	353	*/
362	if (OB_MOVE_BLOCK(ob, tmp)) return 1;	354	if (OB_MOVE_BLOCK(ob, tmp)) return 1;
363	if (QUERY_FLAG(tmp,FLAG_ALIVE) && tmp->head != ob && tmp != ob &&	355	if (QUERY_FLAG(tmp,FLAG_ALIVE) && tmp->head != ob && tmp != ob &&
364	tmp->type != DOOR && !(QUERY_FLAG(tmp,FLAG_WIZ) && tmp->contr->hidden))	356	tmp->type != DOOR && !(QUERY_FLAG(tmp,FLAG_WIZ) && tmp->contr->hidden))
365	return 1;	357	return 1;
366	}	358	}
367		359
368	}	360	}
369	return 0;	361	return 0;
370	}	362	}
371		363
…		…
402	int flag;	394	int flag;
403	mapstruct *m1;	395	mapstruct *m1;
404	sint16 sx, sy;	396	sint16 sx, sy;
405		397
406	if(ob==NULL) {	398	if(ob==NULL) {
407	flag= get_map_flags(m,&m1, x,y, &sx, &sy);	399	flag= get_map_flags(m,&m1, x,y, &sx, &sy);
408	if (flag & P_OUT_OF_MAP) return P_OUT_OF_MAP;	400	if (flag & P_OUT_OF_MAP) return P_OUT_OF_MAP;
409		401
410	/* don't have object, so don't know what types would block */	402	/* don't have object, so don't know what types would block */
411	return(GET_MAP_MOVE_BLOCK(m1, sx, sy));	403	return(GET_MAP_MOVE_BLOCK(m1, sx, sy));
412	}	404	}
413		405
414	for(tmp=ob->arch; tmp!=NULL;tmp=tmp->more) {	406	for(tmp=ob->arch; tmp!=NULL;tmp=tmp->more) {
415	flag = get_map_flags(m, &m1, x+tmp->clone.x,y+tmp->clone.y, &sx, &sy);	407	flag = get_map_flags(m, &m1, x+tmp->clone.x,y+tmp->clone.y, &sx, &sy);
416		408
417	if (flag & P_OUT_OF_MAP) return P_OUT_OF_MAP;	409	if (flag & P_OUT_OF_MAP) return P_OUT_OF_MAP;
418	if (flag & P_IS_ALIVE) return P_IS_ALIVE;	410	if (flag & P_IS_ALIVE) return P_IS_ALIVE;
419		411
420	/* find_first_free_spot() calls this function. However, often	412	/* find_first_free_spot() calls this function. However, often
421	* ob doesn't have any move type (when used to place exits)	413	* 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.	414	* so the AND operation in OB_TYPE_MOVE_BLOCK doesn't work.
423	*/	415	*/
424		416
425	if (ob->move_type == 0 && GET_MAP_MOVE_BLOCK(m1, sx, sy) != MOVE_ALL) continue;	417	if (ob->move_type == 0 && GET_MAP_MOVE_BLOCK(m1, sx, sy) != MOVE_ALL) continue;
426		418
427	/* Note it is intentional that we check ob - the movement type of the	419	/* Note it is intentional that we check ob - the movement type of the
428	* head of the object should correspond for the entire object.	420	* head of the object should correspond for the entire object.
429	*/	421	*/
430	if (OB_TYPE_MOVE_BLOCK(ob, GET_MAP_MOVE_BLOCK(m1, sx, sy)))	422	if (OB_TYPE_MOVE_BLOCK(ob, GET_MAP_MOVE_BLOCK(m1, sx, sy)))
431	return AB_NO_PASS;	423	return AB_NO_PASS;
432		424
433	}	425	}
434	return 0;	426	return 0;
435	}	427	}
436		428
…		…
445	{	437	{
446	object *tmp=container->inv, *next;	438	object *tmp=container->inv, *next;
447		439
448	container->inv=NULL;	440	container->inv=NULL;
449	while (tmp!=NULL) {	441	while (tmp!=NULL) {
450	next = tmp->below;	442	next = tmp->below;
451	if (tmp->inv)	443	if (tmp->inv)
452	fix_container(tmp);	444	fix_container(tmp);
453	(void) insert_ob_in_ob(tmp,container);	445	(void) insert_ob_in_ob(tmp,container);
454	tmp = next;	446	tmp = next;
455	}	447	}
456	/* sum_weight will go through and calculate what all the containers are	448	/* sum_weight will go through and calculate what all the containers are
457	* carrying.	449	* carrying.
458	*/	450	*/
459	sum_weight(container);	451	sum_weight(container);
…		…
468		460
469	static void link_multipart_objects(mapstruct *m)	461	static void link_multipart_objects(mapstruct *m)
470	{	462	{
471	int x,y;	463	int x,y;
472	object *tmp, *op, *last, *above;	464	object *tmp, *op, *last, *above;
473	archetype *at;	465	archetype *at;
474		466
475	for(x=0;x<MAP_WIDTH(m);x++)	467	for(x=0;x<MAP_WIDTH(m);x++)
476	for(y=0;y<MAP_HEIGHT(m);y++)	468	for(y=0;y<MAP_HEIGHT(m);y++)
477	for(tmp=get_map_ob(m,x,y);tmp!=NULL;tmp=above) {	469	for(tmp=get_map_ob(m,x,y);tmp!=NULL;tmp=above) {
478	above=tmp->above;	470	above=tmp->above;
479		471
480	/* already multipart - don't do anything more */	472	/* already multipart - don't do anything more */
481	if (tmp->head || tmp->more) continue;	473	if (tmp->head || tmp->more) continue;
482		474
483	/* If there is nothing more to this object, this for loop	475	/* If there is nothing more to this object, this for loop
484	* won't do anything.	476	* won't do anything.
485	*/	477	*/
486	for (at = tmp->arch->more, last=tmp; at != NULL; at=at->more, last=op) {	478	for (at = tmp->arch->more, last=tmp; at != NULL; at=at->more, last=op) {
487	op = arch_to_object(at);	479	op = arch_to_object(at);
488		480
489	/* update x,y coordinates */	481	/* update x,y coordinates */
490	op->x += tmp->x;	482	op->x += tmp->x;
491	op->y += tmp->y;	483	op->y += tmp->y;
492	op->head = tmp;	484	op->head = tmp;
493	op->map = m;	485	op->map = m;
494	last->more = op;	486	last->more = op;
495	if (tmp->name != op->name) {	487	op->name = tmp->name;
496	if (op->name) free_string(op->name);	488	op->title = tmp->title;
497	op->name = add_string(tmp->name);
498	}
499	if (tmp->title != op->title) {
500	if (op->title) free_string(op->title);
501	op->title = add_string(tmp->title);
502	}
503	/* we could link all the parts onto tmp, and then just	489	/* we could link all the parts onto tmp, and then just
504	* call insert_ob_in_map once, but the effect is the same,	490	* 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	491	* 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.	492	* the coding is simpler to just to it here with each part.
507	*/	493	*/
508	insert_ob_in_map(op, op->map, tmp,INS_NO_MERGE|INS_ABOVE_FLOOR_ONLY|INS_NO_WALK_ON);	494	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 */	495	} /* for at = tmp->arch->more */
510	} /* for objects on this space */	496	} /* for objects on this space */
511	}	497	}
512		498
513
514
515	/*	499	/*
516	* Loads (ands parses) the objects into a given map from the specified	500	* Loads (ands parses) the objects into a given map from the specified
517	* file pointer.	501	* file pointer.
518	* mapflags is the same as we get with load_original_map	502	* mapflags is the same as we get with load_original_map
519	*/	503	*/
520		504	void
521	void load_objects (mapstruct *m, FILE *fp, object_thawer &thawer, int mapflags) {	505	load_objects (mapstruct *m, object_thawer &fp, int mapflags)
522	int i,j,bufstate=LO_NEWFILE;	506	{
		507	int i, j;
523	int unique;	508	int unique;
524	object *op, *prev=NULL,*last_more=NULL, *otmp;	509	object *op, *prev = NULL, *last_more = NULL, *otmp;
525		510
526	op=get_object();	511	op = get_object ();
527	op->map = m; /* To handle buttons correctly */	512	op->map = m; /* To handle buttons correctly */
528		513
529	while((i = load_object (fp, thawer, op, bufstate, mapflags))) {	514	while ((i = load_object (fp, op, mapflags)))
530	/* Since the loading of the map header does not load an object	515	{
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	516	/* if the archetype for the object is null, means that we
537	* got an invalid object. Don't do anything with it - the game	517	* 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.	518	* or editor will not be able to do anything with it either.
539	*/	519	*/
540	if (op->arch==NULL) {	520	if (op->arch == NULL)
		521	{
541	LOG(llevDebug,"Discarding object without arch: %s\n", op->name?op->name:"(null)");	522	LOG (llevDebug, "Discarding object without arch: %s\n",
		523	op->name ? (const char *) op->name : "(null)");
542	continue;	524	continue;
543	}	525	}
544		526
545		527
546	switch(i) {	528	switch (i)
		529	{
547	case LL_NORMAL:	530	case LL_NORMAL:
548	/* if we are loading an overlay, put the floors on the bottom */	531	/* if we are loading an overlay, put the floors on the bottom */
549	if ((QUERY_FLAG(op, FLAG_IS_FLOOR) ||	532	if ((QUERY_FLAG (op, FLAG_IS_FLOOR) ||
550	QUERY_FLAG(op, FLAG_OVERLAY_FLOOR)) && mapflags & MAP_OVERLAY)	533	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);	534	insert_ob_in_map (op, m, op,
552	else	535	INS_NO_MERGE | INS_NO_WALK_ON |
553	insert_ob_in_map(op,m,op,INS_NO_MERGE | INS_NO_WALK_ON | INS_ON_TOP | INS_MAP_LOAD);	536	INS_ABOVE_FLOOR_ONLY | INS_MAP_LOAD);
		537	else
		538	insert_ob_in_map (op, m, op,
		539	INS_NO_MERGE | INS_NO_WALK_ON | INS_ON_TOP |
		540	INS_MAP_LOAD);
554		541
555	if (op->inv)	542	if (op->inv)
556	sum_weight(op);	543	sum_weight (op);
557		544
558	prev=op,last_more=op;	545	prev = op, last_more = op;
559	break;	546	break;
560		547
561	case LL_MORE:	548	case LL_MORE:
562	insert_ob_in_map(op,m, op, INS_NO_MERGE | INS_NO_WALK_ON | INS_ABOVE_FLOOR_ONLY);	549	insert_ob_in_map (op, m, op,
		550	INS_NO_MERGE | INS_NO_WALK_ON |
		551	INS_ABOVE_FLOOR_ONLY);
563	op->head=prev,last_more->more=op,last_more=op;	552	op->head = prev, last_more->more = op, last_more = op;
564	break;	553	break;
565	}	554	}
		555
566	if (mapflags & MAP_STYLE) {	556	if (mapflags & MAP_STYLE)
567	remove_from_active_list(op);	557	remove_from_active_list (op);
568	}	558
569	op=get_object();	559	op = get_object ();
570	op->map = m;	560	op->map = m;
571	}	561	}
		562
572	for (i=0;i<m->width;i++){	563	for (i = 0; i < m->width; i++)
		564	{
573	for (j=0;j<m->height;j++){	565	for (j = 0; j < m->height; j++)
		566	{
574	unique =0;	567	unique = 0;
575	/* check for unique items, or unique squares */	568	/* check for unique items, or unique squares */
576	for (otmp = get_map_ob(m, i, j); otmp; otmp = otmp->above) {	569	for (otmp = get_map_ob (m, i, j); otmp; otmp = otmp->above)
577	if (QUERY_FLAG(otmp, FLAG_UNIQUE) || QUERY_FLAG(otmp, FLAG_OBJ_SAVE_ON_OVL))	570	{
578	unique = 1;	571	if (QUERY_FLAG (otmp, FLAG_UNIQUE)
		572	|| QUERY_FLAG (otmp, FLAG_OBJ_SAVE_ON_OVL))
		573	unique = 1;
579	if (!(mapflags & (MAP_OVERLAY|MAP_PLAYER_UNIQUE) || unique))	574	if (!(mapflags & (MAP_OVERLAY | MAP_PLAYER_UNIQUE) || unique))
580	SET_FLAG(otmp, FLAG_OBJ_ORIGINAL);	575	SET_FLAG (otmp, FLAG_OBJ_ORIGINAL);
		576	}
		577	}
581	}	578	}
582	}	579
583	}
584	free_object(op);	580	free_object (op);
585	link_multipart_objects(m);	581	link_multipart_objects (m);
586	}	582	}
587		583
588	/* This saves all the objects on the map in a non destructive fashion.	584	/* This saves all the objects on the map in a non destructive fashion.
589	* Modified by MSW 2001-07-01 to do in a single pass - reduces code,	585	* Modified by MSW 2001-07-01 to do in a single pass - reduces code,
590	* and we only save the head of multi part objects - this is needed	586	* and we only save the head of multi part objects - this is needed
591	* in order to do map tiling properly.	587	* in order to do map tiling properly.
592	*/	588	*/
593	void save_objects (mapstruct *m, FILE *fp, object_freezer &freezer, FILE *fp2, object_freezer &freezer2, int flag) {	589	void save_objects (mapstruct *m, object_freezer &fp, object_freezer &fp2, int flag) {
594	int i, j = 0,unique=0;	590	int i, j = 0,unique=0;
595	object *op;	591	object *op;
596	/* first pass - save one-part objects */	592	/* first pass - save one-part objects */
597	for(i = 0; i < MAP_WIDTH(m); i++)	593	for(i = 0; i < MAP_WIDTH(m); i++)
598	for (j = 0; j < MAP_HEIGHT(m); j++) {	594	for (j = 0; j < MAP_HEIGHT(m); j++) {
599	unique=0;	595	unique=0;
600	for(op = get_map_ob (m, i, j); op; op = op->above) {	596	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))	597	if (QUERY_FLAG(op,FLAG_IS_FLOOR) && QUERY_FLAG(op, FLAG_UNIQUE))
602	unique=1;	598	unique=1;
603		599
604	if(op->type == PLAYER) {	600	if(op->type == PLAYER) {
605	LOG(llevDebug, "Player on map that is being saved\n");	601	LOG(llevDebug, "Player on map that is being saved\n");
606	continue;	602	continue;
607	}	603	}
608		604
609	if (op->head || op->owner)	605	if (op->head || op->owner)
610	continue;	606	continue;
611		607
612	if (unique || QUERY_FLAG(op, FLAG_UNIQUE))	608	if (unique || QUERY_FLAG(op, FLAG_UNIQUE))
613	save_object( fp2 , freezer2, op, 3);	609	save_object (fp2, op, 3);
614	else	610	else
615	if (flag == 0 ||	611	if (flag == 0 ||
616	(flag == 2 && (!QUERY_FLAG(op, FLAG_OBJ_ORIGINAL) &&	612	(flag == 2 && (!QUERY_FLAG(op, FLAG_OBJ_ORIGINAL) &&
617	!QUERY_FLAG(op, FLAG_UNPAID))))	613	!QUERY_FLAG(op, FLAG_UNPAID))))
618	save_object(fp, freezer, op, 3);	614	save_object(fp, op, 3);
619		615
620	} /* for this space */	616	} /* for this space */
621	} /* for this j */	617	} /* for this j */
622	}	618	}
623		619
624	/*	620	/*
625	* Allocates, initialises, and returns a pointer to a mapstruct.	621	* Allocates, initialises, and returns a pointer to a mapstruct.
626	* Modified to no longer take a path option which was not being	622	* Modified to no longer take a path option which was not being
627	* used anyways. MSW 2001-07-01	623	* used anyways. MSW 2001-07-01
628	*/	624	*/
629		625
630	mapstruct *get_linked_map(void) {	626	mapstruct *get_linked_map(void) {
631	mapstruct *map=(mapstruct *) calloc(1,sizeof(mapstruct));	627	mapstruct *map = new mapstruct;
632	mapstruct *mp;	628	mapstruct *mp;
633
634	if(map==NULL)
635	fatal(OUT_OF_MEMORY);
636		629
637	for(mp=first_map;mp!=NULL&&mp->next!=NULL;mp=mp->next);	630	for(mp=first_map;mp!=NULL&&mp->next!=NULL;mp=mp->next);
638	if(mp==NULL)	631	if(mp==NULL)
639	first_map=map;	632	first_map=map;
640	else	633	else
641	mp->next=map;	634	mp->next=map;
642		635
643	map->in_memory=MAP_SWAPPED;	636	map->in_memory=MAP_SWAPPED;
644	/* The maps used to pick up default x and y values from the	637	/* The maps used to pick up default x and y values from the
645	* map archetype. Mimic that behaviour.	638	* map archetype. Mimic that behaviour.
646	*/	639	*/
…		…
648	MAP_HEIGHT(map)=16;	641	MAP_HEIGHT(map)=16;
649	MAP_RESET_TIMEOUT(map)=0;	642	MAP_RESET_TIMEOUT(map)=0;
650	MAP_TIMEOUT(map)=300;	643	MAP_TIMEOUT(map)=300;
651	MAP_ENTER_X(map)=0;	644	MAP_ENTER_X(map)=0;
652	MAP_ENTER_Y(map)=0;	645	MAP_ENTER_Y(map)=0;
653	/*set part to -1 indicating conversion to weather map not yet done*/	646	/*set part to -1 indicating conversion to weather map not yet done*/
654	MAP_WORLDPARTX(map)=-1;	647	MAP_WORLDPARTX(map)=-1;
655	MAP_WORLDPARTY(map)=-1;	648	MAP_WORLDPARTY(map)=-1;
656	return map;	649	return map;
657	}	650	}
658		651
659	/*	652	/*
660	* Allocates the arrays contained in a mapstruct.	653	* Allocates the arrays contained in a mapstruct.
…		…
667	/* Log this condition and free the storage. We could I suppose	660	/* Log this condition and free the storage. We could I suppose
668	* realloc, but if the caller is presuming the data will be intact,	661	* realloc, but if the caller is presuming the data will be intact,
669	* that is their poor assumption.	662	* that is their poor assumption.
670	*/	663	*/
671	if (m->spaces) {	664	if (m->spaces) {
672	LOG(llevError,"allocate_map called with already allocated map (%s)\n", m->path);	665	LOG(llevError,"allocate_map called with already allocated map (%s)\n", m->path);
673	free(m->spaces);	666	free(m->spaces);
674	}	667	}
675		668
676	m->spaces = (MapSpace *) calloc(1, MAP_WIDTH(m) * MAP_HEIGHT(m) * sizeof(MapSpace));	669	m->spaces = (MapSpace *) calloc(1, MAP_WIDTH(m) * MAP_HEIGHT(m) * sizeof(MapSpace));
677		670
678	if(m->spaces==NULL)	671	if(m->spaces==NULL)
679	fatal(OUT_OF_MEMORY);	672	fatal(OUT_OF_MEMORY);
680	}	673	}
681		674
682	/* Create and returns a map of the specific size. Used	675	/* Create and returns a map of the specific size. Used
683	* in random map code and the editor.	676	* in random map code and the editor.
684	*/	677	*/
…		…
705		698
706	shop_string=strdup_local(input_string);	699	shop_string=strdup_local(input_string);
707	p=shop_string;	700	p=shop_string;
708	/* first we'll count the entries, we'll need that for allocating the array shortly */	701	/* first we'll count the entries, we'll need that for allocating the array shortly */
709	while (p) {	702	while (p) {
710	p=strchr(p, ';');	703	p=strchr(p, ';');
711	number_of_entries++;	704	number_of_entries++;
712	if (p) p++;	705	if (p) p++;
713	}	706	}
714	p=shop_string;	707	p=shop_string;
715	strip_endline(p);	708	strip_endline(p);
716	items=(shopitems *) CALLOC(number_of_entries+1, sizeof(shopitems));	709	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++) {	710	for (i=0; i<number_of_entries; i++) {
719	if (!p) {	711	if (!p) {
720	LOG(llevError, "parse_shop_string: I seem to have run out of string, that shouldn't happen.\n");	712	LOG(llevError, "parse_shop_string: I seem to have run out of string, that shouldn't happen.\n");
721	break;	713	break;
722	}	714	}
723	next_semicolon=strchr(p, ';');	715	next_semicolon=strchr(p, ';');
724	next_colon=strchr(p, ':');	716	next_colon=strchr(p, ':');
725	/* if there is a stregth specified, figure out what it is, we'll need it soon. */	717	/* 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))	718	if (next_colon &&( !next_semicolon || next_colon<next_semicolon))
727	items[i].strength=atoi(strchr(p,':')+1);	719	items[i].strength=atoi(strchr(p,':')+1);
728		720
729	if (isdigit(*p) || *p=='*') {	721	if (isdigit(*p) || *p=='*') {
730	items[i].typenum = atoi(p); /* atoi returns 0 when we have an asterisk */	722	items[i].typenum = atoi(p); /* atoi returns 0 when we have an asterisk */
731	current_type=get_typedata(items[i].typenum);	723	current_type=get_typedata(items[i].typenum);
732	if (current_type) {	724	if (current_type) {
733	items[i].name=current_type->name;	725	items[i].name=current_type->name;
734	items[i].name_pl=current_type->name_pl;	726	items[i].name_pl=current_type->name_pl;
735	}	727	}
736	}	728	}
737	else { /*we have a named type, let's figure out what it is */	729	else { /*we have a named type, let's figure out what it is */
738	q=strpbrk(p,";:");	730	q=strpbrk(p,";:");
739	if (q) *q='\0';	731	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	}	732
		733	current_type=get_typedata_by_name(p);
		734	if (current_type) {
		735	items[i].name=current_type->name;
		736	items[i].typenum=current_type->number;
		737	items[i].name_pl=current_type->name_pl;
		738	}
		739	else { /* oh uh, something's wrong, let's free up this one, and try
		740	* the next entry while we're at it, better print a warning
		741	*/
		742	LOG(llevError, "invalid type %s defined in shopitems in string %s\n",
		743	p, input_string);
		744	}
		745	}
754	items[i].index=number_of_entries;	746	items[i].index=number_of_entries;
755	if (next_semicolon) p=++next_semicolon;	747	if (next_semicolon) p=++next_semicolon;
756	else p=NULL;	748	else p=NULL;
757	}	749	}
758	free(shop_string);	750	free(shop_string);
759	return items;	751	return items;
760	}	752	}
761		753
…		…
764	static void print_shop_string(mapstruct *m, char *output_string) {	756	static void print_shop_string(mapstruct *m, char *output_string) {
765	int i;	757	int i;
766	char tmp[MAX_BUF];	758	char tmp[MAX_BUF];
767	strcpy(output_string, "");	759	strcpy(output_string, "");
768	for (i=0; i< m->shopitems[0].index; i++) {	760	for (i=0; i< m->shopitems[0].index; i++) {
769	if (m->shopitems[i].typenum) {	761	if (m->shopitems[i].typenum) {
770	if (m->shopitems[i].strength) {	762	if (m->shopitems[i].strength) {
771	sprintf(tmp, "%s:%d;", m->shopitems[i].name, m->shopitems[i].strength);	763	sprintf(tmp, "%s:%d;", m->shopitems[i].name, m->shopitems[i].strength);
772	}	764	}
773	else sprintf(tmp, "%s;", m->shopitems[i].name);	765	else sprintf(tmp, "%s;", m->shopitems[i].name);
774	}	766	}
775	else {	767	else {
776	if (m->shopitems[i].strength) {	768	if (m->shopitems[i].strength) {
777	sprintf(tmp, "*:%d;", m->shopitems[i].strength);	769	sprintf(tmp, "*:%d;", m->shopitems[i].strength);
778	}	770	}
779	else sprintf(tmp, "*");	771	else sprintf(tmp, "*");
780	}	772	}
781	strcat(output_string, tmp);	773	strcat(output_string, tmp);
782	}	774	}
783	}	775	}
784		776
785	/* This loads the header information of the map. The header	777	/* This loads the header information of the map. The header
786	* contains things like difficulty, size, timeout, etc.	778	* contains things like difficulty, size, timeout, etc.
…		…
793	* currently, there are few enough fields this is not a big deal.	785	* currently, there are few enough fields this is not a big deal.
794	* MSW 2001-07-01	786	* MSW 2001-07-01
795	* return 0 on success, 1 on failure.	787	* return 0 on success, 1 on failure.
796	*/	788	*/
797		789
798	static int load_map_header(FILE *fp, mapstruct *m)	790	static int load_map_header(object_thawer &fp, mapstruct *m)
799	{	791	{
800	char buf[HUGE_BUF], msgbuf[HUGE_BUF], maplorebuf[HUGE_BUF], *key=NULL, *value, *end;	792	char buf[HUGE_BUF], msgbuf[HUGE_BUF], maplorebuf[HUGE_BUF], *key=NULL, *value, *end;
801	int msgpos=0;	793	int msgpos=0;
802	int maplorepos=0;	794	int maplorepos=0;
803		795
804	while (fgets(buf, HUGE_BUF-1, fp)!=NULL) {	796	while (fgets(buf, HUGE_BUF-1, fp)!=NULL) {
805	buf[HUGE_BUF-1] = 0;	797	buf[HUGE_BUF-1] = 0;
806	key = buf;	798	key = buf;
807	while (isspace(*key)) key++;	799	while (isspace(*key)) key++;
808	if (*key == 0) continue; /* empty line */	800	if (*key == 0) continue; /* empty line */
809	value = strchr(key, ' ');	801	value = strchr(key, ' ');
810	if (!value) {	802	if (!value) {
811	end = strchr(key, '\n');	803	end = strchr(key, '\n');
812	if (end != NULL) {	804	if (end != NULL) {
813	*end = 0;	805	*end = 0;
814	}	806	}
815	} else {	807	} else {
816	*value = 0;	808	*value = 0;
817	value++;	809	value++;
818	end = strchr(value, '\n');	810	end = strchr(value, '\n');
819	while (isspace(*value)) {	811	while (isspace(*value)) {
820	value++;	812	value++;
821	if (*value == '\0' || value == end) {	813	if (*value == '\0' || value == end) {
822	/* Nothing but spaces. */	814	/* Nothing but spaces. */
823	value = NULL;	815	value = NULL;
824	break;	816	break;
825	}	817	}
826	}	818	}
827	}	819	}
828	if (!end) {	820
		821	if (!end) {
829	LOG(llevError, "Error loading map header - did not find a newline - perhaps file is truncated? Buf=%s\n",	822	LOG(llevError, "Error loading map header - did not find a newline - perhaps file is truncated? Buf=%s\n",
830	buf);	823	buf);
831	return 1;	824	return 1;
832	}	825	}
833
834		826
835	/* key is the field name, value is what it should be set	827	/* key is the field name, value is what it should be set
836	* to. We've already done the work to null terminate key,	828	* to. We've already done the work to null terminate key,
837	* and strip off any leading spaces for both of these.	829	* and strip off any leading spaces for both of these.
838	* We have not touched the newline at the end of the line -	830	* We have not touched the newline at the end of the line -
839	* these are needed for some values. the end pointer	831	* these are needed for some values. the end pointer
840	* points to the first of the newlines.	832	* points to the first of the newlines.
841	* value could be NULL! It would be easy enough to just point	833	* 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	834	* this to "" to prevent cores, but that would let more errors slide
843	* through.	835	* through.
844	*	836	*
845	* First check for entries that do not use the value parameter, then	837	* First check for entries that do not use the value parameter, then
846	* validate that value is given and check for the remaining entries	838	* validate that value is given and check for the remaining entries
847	* that use the parameter.	839	* that use the parameter.
848	*/	840	*/
849		841
850	if (!strcmp(key,"msg")) {	842	if (!strcmp(key,"msg")) {
851	while (fgets(buf, HUGE_BUF-1, fp)!=NULL) {	843	while (fgets(buf, HUGE_BUF-1, fp)!=NULL) {
852	if (!strcmp(buf,"endmsg\n")) break;	844	if (!strcmp(buf,"endmsg\n")) break;
853	else {	845	else {
854	/* slightly more efficient than strcat */	846	/* slightly more efficient than strcat */
855	strcpy(msgbuf+msgpos, buf);	847	strcpy(msgbuf+msgpos, buf);
856	msgpos += strlen(buf);	848	msgpos += strlen(buf);
857	}	849	}
858	}	850	}
859	/* There are lots of maps that have empty messages (eg, msg/endmsg	851	/* There are lots of maps that have empty messages (eg, msg/endmsg
860	* with nothing between). There is no reason in those cases to	852	* with nothing between). There is no reason in those cases to
861	* keep the empty message. Also, msgbuf contains garbage data	853	* keep the empty message. Also, msgbuf contains garbage data
862	* when msgpos is zero, so copying it results in crashes	854	* when msgpos is zero, so copying it results in crashes
863	*/	855	*/
864	if (msgpos != 0)	856	if (msgpos != 0)
865	m->msg = strdup_local(msgbuf);	857	m->msg = strdup_local(msgbuf);
866	}	858	}
867	else if (!strcmp(key,"maplore")) {	859	else if (!strcmp(key,"maplore")) {
868	while (fgets(buf, HUGE_BUF-1, fp)!=NULL) {	860	while (fgets(buf, HUGE_BUF-1, fp)!=NULL) {
869	if (!strcmp(buf,"endmaplore\n")) break;	861	if (!strcmp(buf,"endmaplore\n")) break;
870	else {	862	else {
871	/* slightly more efficient than strcat */	863	/* slightly more efficient than strcat */
872	strcpy(maplorebuf+maplorepos, buf);	864	strcpy(maplorebuf+maplorepos, buf);
873	maplorepos += strlen(buf);	865	maplorepos += strlen(buf);
874	}	866	}
875	}	867	}
876	if (maplorepos != 0)	868	if (maplorepos != 0)
877	m->maplore = strdup_local(maplorebuf);	869	m->maplore = strdup_local(maplorebuf);
878	}	870	}
879	else if (!strcmp(key,"end")) {	871	else if (!strcmp(key,"end")) {
880	break;	872	break;
881	}	873	}
882	else if (value == NULL) {	874	else if (value == NULL) {
883	LOG(llevError, "Got '%s' line without parameter in map header\n", key);	875	LOG(llevError, "Got '%s' line without parameter in map header\n", key);
884	}	876	}
885	else if (!strcmp(key, "arch")) {	877	else if (!strcmp(key, "arch")) {
886	/* This is an oddity, but not something we care about much. */	878	/* This is an oddity, but not something we care about much. */
887	if (strcmp(value,"map\n"))	879	if (strcmp(value,"map\n"))
888	LOG(llevError,"loading map and got a non 'arch map' line(%s %s)?\n",key,value);	880	LOG(llevError,"loading map and got a non 'arch map' line(%s %s)?\n",key,value);
889	}	881	}
890	else if (!strcmp(key,"name")) {	882	else if (!strcmp(key,"name")) {
891	*end=0;	883	*end=0;
892	m->name = strdup_local(value);	884	m->name = strdup_local(value);
893	}	885	}
894	/* first strcmp value on these are old names supported	886	/* first strcmp value on these are old names supported
895	* for compatibility reasons. The new values (second) are	887	* for compatibility reasons. The new values (second) are
896	* what really should be used.	888	* what really should be used.
897	*/	889	*/
		890	else if (!strcmp(key,"oid")) {
		891	fp.get (m, atoi(value));
		892	} else if (!strcmp(key, "attach")) {
		893	m->attach = value;
898	else if (!strcmp(key,"hp") || !strcmp(key, "enter_x")) {	894	} else if (!strcmp(key,"hp") || !strcmp(key, "enter_x")) {
899	m->enter_x = atoi(value);	895	m->enter_x = atoi(value);
900	} else if (!strcmp(key,"sp") || !strcmp(key, "enter_y")) {	896	} else if (!strcmp(key,"sp") || !strcmp(key, "enter_y")) {
901	m->enter_y = atoi(value);	897	m->enter_y = atoi(value);
902	} else if (!strcmp(key,"x") || !strcmp(key, "width")) {	898	} else if (!strcmp(key,"x") || !strcmp(key, "width")) {
903	m->width = atoi(value);	899	m->width = atoi(value);
904	} else if (!strcmp(key,"y") || !strcmp(key, "height")) {	900	} else if (!strcmp(key,"y") || !strcmp(key, "height")) {
905	m->height = atoi(value);	901	m->height = atoi(value);
906	} else if (!strcmp(key,"weight") || !strcmp(key, "reset_timeout")) {	902	} else if (!strcmp(key,"weight") || !strcmp(key, "reset_timeout")) {
907	m->reset_timeout = atoi(value);	903	m->reset_timeout = atoi(value);
908	} else if (!strcmp(key,"value") || !strcmp(key, "swap_time")) {	904	} else if (!strcmp(key,"value") || !strcmp(key, "swap_time")) {
909	m->timeout = atoi(value);	905	m->timeout = atoi(value);
910	} else if (!strcmp(key,"level") || !strcmp(key, "difficulty")) {	906	} else if (!strcmp(key,"level") || !strcmp(key, "difficulty")) {
911	m->difficulty = atoi(value);	907	m->difficulty = atoi(value);
912	} else if (!strcmp(key,"invisible") || !strcmp(key, "darkness")) {	908	} else if (!strcmp(key,"invisible") || !strcmp(key, "darkness")) {
913	m->darkness = atoi(value);	909	m->darkness = atoi(value);
914	} else if (!strcmp(key,"stand_still") || !strcmp(key, "fixed_resettime")) {	910	} else if (!strcmp(key,"stand_still") || !strcmp(key, "fixed_resettime")) {
915	m->fixed_resettime = atoi(value);	911	m->fixed_resettime = atoi(value);
916	} else if (!strcmp(key,"unique")) {	912	} else if (!strcmp(key,"unique")) {
917	m->unique = atoi(value);	913	m->unique = atoi(value);
918	} else if (!strcmp(key,"template")) {	914	} else if (!strcmp(key,"template")) {
919	m->templatemap = atoi(value);	915	m->templatemap = atoi(value);
920	} else if (!strcmp(key,"region")) {	916	} else if (!strcmp(key,"region")) {
921	m->region = get_region_by_name(value);	917	m->region = get_region_by_name(value);
922	} else if (!strcmp(key,"shopitems")) {	918	} else if (!strcmp(key,"shopitems")) {
923	*end=0;	919	*end=0;
924	m->shopitems = parse_shop_string(value);	920	m->shopitems = parse_shop_string(value);
925	} else if (!strcmp(key,"shopgreed")) {	921	} else if (!strcmp(key,"shopgreed")) {
926	m->shopgreed = atof(value);	922	m->shopgreed = atof(value);
927	} else if (!strcmp(key,"shopmin")) {	923	} else if (!strcmp(key,"shopmin")) {
928	m->shopmin = atol(value);	924	m->shopmin = atol(value);
929	} else if (!strcmp(key,"shopmax")) {	925	} else if (!strcmp(key,"shopmax")) {
930	m->shopmax = atol(value);	926	m->shopmax = atol(value);
931	} else if (!strcmp(key,"shoprace")) {	927	} else if (!strcmp(key,"shoprace")) {
932	*end=0;	928	*end=0;
933	m->shoprace = strdup_local(value);	929	m->shoprace = strdup_local(value);
934	} else if (!strcmp(key,"outdoor")) {	930	} else if (!strcmp(key,"outdoor")) {
935	m->outdoor = atoi(value);	931	m->outdoor = atoi(value);
936	} else if (!strcmp(key, "temp")) {	932	} else if (!strcmp(key, "temp")) {
937	m->temp = atoi(value);	933	m->temp = atoi(value);
938	} else if (!strcmp(key, "pressure")) {	934	} else if (!strcmp(key, "pressure")) {
939	m->pressure = atoi(value);	935	m->pressure = atoi(value);
940	} else if (!strcmp(key, "humid")) {	936	} else if (!strcmp(key, "humid")) {
941	m->humid = atoi(value);	937	m->humid = atoi(value);
942	} else if (!strcmp(key, "windspeed")) {	938	} else if (!strcmp(key, "windspeed")) {
943	m->windspeed = atoi(value);	939	m->windspeed = atoi(value);
944	} else if (!strcmp(key, "winddir")) {	940	} else if (!strcmp(key, "winddir")) {
945	m->winddir = atoi(value);	941	m->winddir = atoi(value);
946	} else if (!strcmp(key, "sky")) {	942	} else if (!strcmp(key, "sky")) {
947	m->sky = atoi(value);	943	m->sky = atoi(value);
948	} else if (!strcmp(key, "nosmooth")) {	944	} else if (!strcmp(key, "nosmooth")) {
949	m->nosmooth = atoi(value);	945	m->nosmooth = atoi(value);
950	} else if (!strcmp(key, "safe_map")) {	946	}
951	m->safe_map = atoi(value);
952	}
953	else if (!strncmp(key,"tile_path_", 10)) {	947	else if (!strncmp(key,"tile_path_", 10)) {
954	int tile=atoi(key+10);	948	int tile=atoi(key+10);
955		949
956	if (tile<1 || tile>4) {	950	if (tile<1 || tile>4) {
957	LOG(llevError,"load_map_header: tile location %d out of bounds (%s)\n",	951	LOG(llevError,"load_map_header: tile location %d out of bounds (%s)\n",
958	tile, m->path);	952	tile, m->path);
959	} else {	953	} else {
960	char *path;	954	char *path;
961		955
962	*end = 0;	956	*end = 0;
963		957
964	if (m->tile_path[tile-1]) {	958	if (m->tile_path[tile-1]) {
965	LOG(llevError,"load_map_header: tile location %d duplicated (%s)\n",	959	LOG(llevError,"load_map_header: tile location %d duplicated (%s)\n",
966	tile, m->path);	960	tile, m->path);
967	free(m->tile_path[tile-1]);	961	free(m->tile_path[tile-1]);
968	m->tile_path[tile-1] = NULL;	962	m->tile_path[tile-1] = NULL;
969	}	963	}
970		964
971	if (check_path(value, 1) != -1) {	965	if (check_path(value, 1) != -1) {
972	/* The unadorned path works. */	966	/* The unadorned path works. */
973	path = value;	967	path = value;
974	} else {	968	} else {
975	/* Try again; it could be a relative exit. */	969	/* Try again; it could be a relative exit. */
976		970
977	path = path_combine_and_normalize(m->path, value);	971	path = path_combine_and_normalize(m->path, value);
978		972
979	if (check_path(path, 1) == -1) {	973	if (check_path(path, 1) == -1) {
980	LOG(llevError, "get_map_header: Bad tile path %s %s\n", m->path, value);	974	LOG(llevError, "get_map_header: Bad tile path %s %s\n", m->path, value);
981	path = NULL;	975	path = NULL;
982	}	976	}
983	}	977	}
984		978
985	if (editor) {	979	if (editor) {
986	/* Use the value as in the file. */	980	/* Use the value as in the file. */
987	m->tile_path[tile-1] = strdup_local(value);	981	m->tile_path[tile-1] = strdup_local(value);
988	} else if (path != NULL) {	982	} else if (path != NULL) {
989	/* Use the normalized value. */	983	/* Use the normalized value. */
990	m->tile_path[tile-1] = strdup_local(path);	984	m->tile_path[tile-1] = strdup_local(path);
991	}	985	}
992	} /* end if tile direction (in)valid */	986	} /* end if tile direction (in)valid */
993	}	987	}
994	else {	988	else {
995	LOG(llevError,"Got unknown value in map header: %s %s\n", key, value);	989	LOG(llevError,"Got unknown value in map header: %s %s\n", key, value);
996	}	990	}
997	}	991	}
998	if (!key || strcmp(key,"end")) {	992	if (!key || strcmp(key,"end")) {
999	LOG(llevError,"Got premature eof on map header!\n");	993	LOG(llevError,"Got premature eof on map header!\n");
1000	return 1;	994	return 1;
1001	}	995	}
1002	return 0;	996	return 0;
1003	}	997	}
1004		998
1005	/*	999	/*
…		…
1009	* flags correspond to those in map.h. Main ones used are	1003	* flags correspond to those in map.h. Main ones used are
1010	* MAP_PLAYER_UNIQUE, in which case we don't do any name changes, and	1004	* MAP_PLAYER_UNIQUE, in which case we don't do any name changes, and
1011	* MAP_BLOCK, in which case we block on this load. This happens in all	1005	* MAP_BLOCK, in which case we block on this load. This happens in all
1012	* cases, no matter if this flag is set or not.	1006	* cases, no matter if this flag is set or not.
1013	* MAP_STYLE: style map - don't add active objects, don't add to server	1007	* MAP_STYLE: style map - don't add active objects, don't add to server
1014	* managed map list.	1008	* managed map list.
1015	*/	1009	*/
1016		1010
1017	mapstruct *load_original_map(const char *filename, int flags) {	1011	mapstruct *load_original_map(const char *filename, int flags) {
1018	FILE *fp;
1019	mapstruct *m;	1012	mapstruct *m;
1020	int comp;
1021	char pathname[MAX_BUF];	1013	char pathname[MAX_BUF];
1022		1014
1023	LOG(llevDebug, "load_original_map: %s (%x)\n", filename,flags);
1024	if (flags & MAP_PLAYER_UNIQUE)	1015	if (flags & MAP_PLAYER_UNIQUE)
1025	strcpy(pathname, filename);	1016	strcpy(pathname, filename);
1026	else if (flags & MAP_OVERLAY)	1017	else if (flags & MAP_OVERLAY)
1027	strcpy(pathname, create_overlay_pathname(filename));	1018	strcpy(pathname, create_overlay_pathname(filename));
1028	else	1019	else
1029	strcpy(pathname, create_pathname(filename));	1020	strcpy(pathname, create_pathname(filename));
1030		1021
1031	if((fp=open_and_uncompress(pathname, 0, &comp))==NULL) {	1022	LOG(llevDebug, "load_original_map(%x): %s (%s)\n", flags, filename, pathname);
1032	LOG(llevError, "Can't open %s: %s\n", pathname, strerror_local(errno));
1033	return (NULL);
1034	}
1035		1023
1036	object_thawer thawer (filename);	1024	object_thawer thawer (pathname);
		1025
		1026	if (!thawer)
		1027	return 0;
1037		1028
1038	m = get_linked_map();	1029	m = get_linked_map();
1039		1030
1040	strcpy (m->path, filename);	1031	strcpy (m->path, filename);
1041	if (load_map_header(fp, m)) {	1032	if (load_map_header(thawer, m)) {
1042	LOG(llevError,"Error loading map header for %s, flags=%d\n",	1033	LOG(llevError,"Error loading map header for %s, flags=%d\n",
1043	filename, flags);	1034	filename, flags);
1044	delete_map(m);	1035	delete_map(m);
1045	return NULL;	1036	return NULL;
1046	}	1037	}
1047		1038
1048	allocate_map(m);	1039	allocate_map(m);
1049	m->compressed = comp;
1050		1040
1051	m->in_memory=MAP_LOADING;	1041	m->in_memory=MAP_LOADING;
1052	load_objects (m, fp, thawer, flags & (MAP_BLOCK|MAP_STYLE));	1042	load_objects (m, thawer, flags & (MAP_BLOCK|MAP_STYLE));
1053	close_and_delete(fp, comp);	1043
1054	m->in_memory=MAP_IN_MEMORY;	1044	m->in_memory=MAP_IN_MEMORY;
1055	if (!MAP_DIFFICULTY(m))	1045	if (!MAP_DIFFICULTY(m))
1056	MAP_DIFFICULTY(m)=calculate_difficulty(m);	1046	MAP_DIFFICULTY(m)=calculate_difficulty(m);
1057	set_map_reset_time(m);	1047	set_map_reset_time(m);
1058	INVOKE_MAP (LOAD, m);	1048	m->instantiate ();
1059	return (m);	1049	return (m);
1060	}	1050	}
1061		1051
1062	/*	1052	/*
1063	* Loads a map, which has been loaded earlier, from file.	1053	* Loads a map, which has been loaded earlier, from file.
1064	* Return the map object we load into (this can change from the passed	1054	* Return the map object we load into (this can change from the passed
1065	* option if we can't find the original map)	1055	* option if we can't find the original map)
1066	*/	1056	*/
1067		1057
1068	static mapstruct *load_temporary_map(mapstruct *m) {	1058	static mapstruct *load_temporary_map(mapstruct *m) {
1069	FILE *fp;
1070	int comp;
1071	char buf[MAX_BUF];	1059	char buf[MAX_BUF];
1072		1060
1073	if (!m->tmpname) {	1061	if (!m->tmpname) {
1074	LOG(llevError, "No temporary filename for map %s\n", m->path);	1062	LOG(llevError, "No temporary filename for map %s\n", m->path);
1075	strcpy(buf, m->path);	1063	strcpy(buf, m->path);
1076	delete_map(m);	1064	delete_map(m);
1077	m = load_original_map(buf, 0);	1065	m = load_original_map(buf, 0);
1078	if(m==NULL) return NULL;	1066	if(m==NULL) return NULL;
1079	fix_auto_apply(m); /* Chests which open as default */	1067	fix_auto_apply(m); /* Chests which open as default */
1080	return m;	1068	return m;
1081	}
1082
1083	if((fp=open_and_uncompress(m->tmpname,0, &comp))==NULL) {
1084	LOG(llevError, "Cannot open %s: %s\n",m->tmpname, strerror_local(errno));
1085	strcpy(buf, m->path);
1086	delete_map(m);
1087	m = load_original_map(buf, 0);
1088	if(m==NULL) return NULL;
1089	fix_auto_apply(m); /* Chests which open as default */
1090	return m;
1091	}	1069	}
1092		1070
1093	object_thawer thawer (m->tmpname);	1071	object_thawer thawer (m->tmpname);
1094		1072
		1073	if (!thawer)
		1074	{
		1075	strcpy (buf, m->path);
		1076	delete_map (m);
		1077	m = load_original_map (buf, 0);
		1078	if (!m) return NULL;
		1079	fix_auto_apply (m); /* Chests which open as default */
		1080	return m;
		1081	}
		1082
1095	if (load_map_header(fp, m)) {	1083	if (load_map_header(thawer, m)) {
1096	LOG(llevError,"Error loading map header for %s (%s)\n",	1084	LOG(llevError,"Error loading map header for %s (%s)\n",
1097	m->path, m->tmpname);	1085	m->path, m->tmpname);
1098	delete_map(m);	1086	delete_map(m);
1099	m = load_original_map(m->path, 0);	1087	m = load_original_map(m->path, 0);
1100	return NULL;	1088	return NULL;
1101	}	1089	}
1102	m->compressed = comp;
1103	allocate_map(m);	1090	allocate_map(m);
1104		1091
1105	m->in_memory=MAP_LOADING;	1092	m->in_memory=MAP_LOADING;
1106	load_objects (m, fp, thawer, 0);	1093	load_objects (m, thawer, 0);
1107	close_and_delete(fp, comp);	1094
1108	m->in_memory=MAP_IN_MEMORY;	1095	m->in_memory=MAP_IN_MEMORY;
1109	INVOKE_MAP (SWAPIN, m);	1096	INVOKE_MAP (SWAPIN, m);
1110	return m;	1097	return m;
1111	}	1098	}
1112		1099
…		…
1115	* Return the map object we load into (this can change from the passed	1102	* Return the map object we load into (this can change from the passed
1116	* option if we can't find the original map)	1103	* option if we can't find the original map)
1117	*/	1104	*/
1118		1105
1119	mapstruct *load_overlay_map(const char *filename, mapstruct *m) {	1106	mapstruct *load_overlay_map(const char *filename, mapstruct *m) {
1120	FILE *fp;
1121	int comp;
1122	char pathname[MAX_BUF];	1107	char pathname[MAX_BUF];
1123		1108
1124	strcpy(pathname, create_overlay_pathname(filename));	1109	strcpy(pathname, create_overlay_pathname(filename));
1125		1110
1126	if((fp=open_and_uncompress(pathname, 0, &comp))==NULL) {
1127	/* LOG(llevDebug,"Can't open overlay %s\n", pathname);*/
1128	return m;
1129	}
1130
1131	object_thawer thawer (pathname);	1111	object_thawer thawer (pathname);
		1112
		1113	if (!thawer)
		1114	return m;
1132		1115
1133	if (load_map_header(fp, m)) {	1116	if (load_map_header(thawer, m)) {
1134	LOG(llevError,"Error loading map header for overlay %s (%s)\n",	1117	LOG(llevError,"Error loading map header for overlay %s (%s)\n",
1135	m->path, pathname);	1118	m->path, pathname);
1136	delete_map(m);	1119	delete_map(m);
1137	m = load_original_map(m->path, 0);	1120	m = load_original_map(m->path, 0);
1138	return NULL;	1121	return NULL;
1139	}	1122	}
1140	m->compressed = comp;
1141	/*allocate_map(m);*/	1123	/*allocate_map(m);*/
1142		1124
1143	m->in_memory=MAP_LOADING;	1125	m->in_memory=MAP_LOADING;
1144	load_objects (m, fp, thawer, MAP_OVERLAY);	1126	load_objects (m, thawer, MAP_OVERLAY);
1145	close_and_delete(fp, comp);	1127
1146	m->in_memory=MAP_IN_MEMORY;	1128	m->in_memory=MAP_IN_MEMORY;
1147	return m;	1129	return m;
1148	}	1130	}
1149		1131
1150	/******************************************************************************	1132	/******************************************************************************
…		…
1156	{	1138	{
1157	int i,j,unique;	1139	int i,j,unique;
1158	object *op, *next;	1140	object *op, *next;
1159		1141
1160	for(i=0; i<MAP_WIDTH(m); i++)	1142	for(i=0; i<MAP_WIDTH(m); i++)
1161	for(j=0; j<MAP_HEIGHT(m); j++) {	1143	for(j=0; j<MAP_HEIGHT(m); j++) {
1162	unique=0;	1144	unique=0;
1163	for (op=get_map_ob(m, i, j); op; op=next) {	1145	for (op=get_map_ob(m, i, j); op; op=next) {
1164	next = op->above;	1146	next = op->above;
1165	if (QUERY_FLAG(op, FLAG_IS_FLOOR) && QUERY_FLAG(op, FLAG_UNIQUE))	1147	if (QUERY_FLAG(op, FLAG_IS_FLOOR) && QUERY_FLAG(op, FLAG_UNIQUE))
1166	unique=1;	1148	unique=1;
1167	if(op->head == NULL && (QUERY_FLAG(op, FLAG_UNIQUE) || unique)) {	1149	if(op->head == NULL && (QUERY_FLAG(op, FLAG_UNIQUE) || unique)) {
1168	clean_object(op);	1150	clean_object(op);
1169	if (QUERY_FLAG(op, FLAG_IS_LINKED))	1151	if (QUERY_FLAG(op, FLAG_IS_LINKED))
1170	remove_button_link(op);	1152	remove_button_link(op);
1171	remove_ob(op);	1153	remove_ob(op);
1172	free_object(op);	1154	free_object(op);
1173	}	1155	}
1174	}	1156	}
1175	}	1157	}
1176	}	1158	}
1177		1159
1178		1160
1179	/*	1161	/*
1180	* Loads unique objects from file(s) into the map which is in memory	1162	* Loads unique objects from file(s) into the map which is in memory
1181	* m is the map to load unique items into.	1163	* m is the map to load unique items into.
1182	*/	1164	*/
1183	static void load_unique_objects(mapstruct *m) {	1165	static void load_unique_objects(mapstruct *m) {
1184	FILE *fp;
1185	int comp,count;	1166	int count;
1186	char firstname[MAX_BUF];	1167	char firstname[MAX_BUF];
1187		1168
1188	for (count=0; count<10; count++) {	1169	for (count=0; count<10; count++) {
1189	sprintf(firstname, "%s.v%02d", create_items_path(m->path), count);	1170	sprintf(firstname, "%s.v%02d", create_items_path(m->path), count);
1190	if (!access(firstname, R_OK)) break;	1171	if (!access(firstname, R_OK)) break;
1191	}	1172	}
1192	/* If we get here, we did not find any map */	1173	/* If we get here, we did not find any map */
1193	if (count==10) return;	1174	if (count==10) return;
1194		1175
1195	if ((fp=open_and_uncompress(firstname, 0, &comp))==NULL) {
1196	/* There is no expectation that every map will have unique items, but this
1197	* is debug output, so leave it in.
1198	*/
1199	LOG(llevDebug, "Can't open unique items file for %s\n", create_items_path(m->path));
1200	return;
1201	}
1202
1203	object_thawer thawer (firstname);	1176	object_thawer thawer (firstname);
		1177
		1178	if (!thawer)
		1179	return;
1204		1180
1205	m->in_memory=MAP_LOADING;	1181	m->in_memory=MAP_LOADING;
1206	if (m->tmpname == NULL) /* if we have loaded unique items from */	1182	if (m->tmpname == NULL) /* if we have loaded unique items from */
1207	delete_unique_items(m); /* original map before, don't duplicate them */	1183	delete_unique_items(m); /* original map before, don't duplicate them */
1208	load_object(fp, thawer, NULL, LO_NOREAD,0);
1209	load_objects (m, fp, thawer, 0);	1184	load_objects (m, thawer, 0);
1210	close_and_delete(fp, comp);	1185
1211	m->in_memory=MAP_IN_MEMORY;	1186	m->in_memory=MAP_IN_MEMORY;
1212	}	1187	}
1213		1188
1214		1189
1215	/*	1190	/*
…		…
1219	* The temporary filename will be stored in the mapstructure.	1194	* The temporary filename will be stored in the mapstructure.
1220	* If the map is unique, we also save to the filename in the map	1195	* If the map is unique, we also save to the filename in the map
1221	* (this should have been updated when first loaded)	1196	* (this should have been updated when first loaded)
1222	*/	1197	*/
1223		1198
		1199	int
1224	int new_save_map(mapstruct *m, int flag) {	1200	new_save_map (mapstruct * m, int flag)
1225	FILE *fp, *fp2;	1201	{
1226	char filename[MAX_BUF],buf[MAX_BUF], buf_s[MAX_BUF],	1202	char filename[MAX_BUF], buf[MAX_BUF], shop[MAX_BUF];
1227	shop[MAX_BUF], filename_s[MAX_BUF];
1228	int i;	1203	int i;
1229		1204
1230	if (flag && !*m->path) {	1205	if (flag && !*m->path)
		1206	{
1231	LOG(llevError,"Tried to save map without path.\n");	1207	LOG (llevError, "Tried to save map without path.\n");
1232	return -1;	1208	return -1;
1233	}
1234		1209	}
		1210
1235	if (flag || (m->unique) || (m->templatemap)) {	1211	if (flag || (m->unique) || (m->templatemap))
1236	if (!m->unique && !m->templatemap) { /* flag is set */	1212	{
		1213	if (!m->unique && !m->templatemap)
		1214	{ /* flag is set */
1237	if (flag == 2)	1215	if (flag == 2)
1238	strcpy(filename, create_overlay_pathname(m->path));	1216	strcpy (filename, create_overlay_pathname (m->path));
1239	else	1217	else
1240	strcpy (filename, create_pathname (m->path));	1218	strcpy (filename, create_pathname (m->path));
1241	} else	1219	}
		1220	else
1242	strcpy (filename, m->path);	1221	strcpy (filename, m->path);
1243		1222
1244	/* If the compression suffix already exists on the filename, don't
1245	* put it on again. This nasty looking strcmp checks to see if the
1246	* compression suffix is at the end of the filename already.
1247	*/
1248	if (m->compressed &&
1249	strcmp((filename + strlen(filename)-strlen(uncomp[m->compressed][0])),
1250	uncomp[m->compressed][0]))
1251	strcat(filename, uncomp[m->compressed][0]);
1252	make_path_to_file(filename);	1223	make_path_to_file (filename);
1253	} else {	1224	}
		1225	else
		1226	{
1254	if (!m->tmpname)	1227	if (!m->tmpname)
1255	m->tmpname = tempnam_local(settings.tmpdir,NULL);	1228	m->tmpname = tempnam_local (settings.tmpdir, NULL);
		1229
1256	strcpy(filename, m->tmpname);	1230	strcpy (filename, m->tmpname);
1257	}	1231	}
		1232
1258	LOG(llevDebug,"Saving map %s to %s\n", m->path, filename);	1233	LOG (llevDebug, "Saving map %s to %s\n", m->path, filename);
1259	m->in_memory = MAP_SAVING;	1234	m->in_memory = MAP_SAVING;
1260		1235
1261	sprintf (filename_s, "%s~", filename);
1262
1263	/* Compress if it isn't a temporary save. Do compress if unique */
1264	if (m->compressed && (m->unique || m->templatemap || flag)) {
1265	char buf[MAX_BUF];
1266	strcpy(buf, uncomp[m->compressed][2]);
1267	strcat(buf, " > ");
1268	strcat(buf, filename_s);
1269	fp = popen(buf, "w");
1270	} else
1271	fp = fopen(filename_s, "w");
1272
1273	if(fp == NULL) {
1274	LOG(llevError, "Cannot write %s: %s\n", filename_s, strerror_local(errno));
1275	return -1;
1276	}
1277
1278	object_freezer freezer (filename);	1236	object_freezer freezer;
1279		1237
1280	/* legacy */	1238	/* legacy */
1281	fprintf(fp,"arch map\n");	1239	fprintf (freezer, "arch map\n");
		1240	if (m->name)
1282	if (m->name) fprintf(fp,"name %s\n", m->name);	1241	fprintf (freezer, "name %s\n", m->name);
		1242	if (!flag)
1283	if (!flag) fprintf(fp,"swap_time %d\n", m->swap_time);	1243	fprintf (freezer, "swap_time %d\n", m->swap_time);
		1244	if (m->reset_timeout)
1284	if (m->reset_timeout) fprintf(fp,"reset_timeout %d\n", m->reset_timeout);	1245	fprintf (freezer, "reset_timeout %d\n", m->reset_timeout);
		1246	if (m->fixed_resettime)
1285	if (m->fixed_resettime) fprintf(fp,"fixed_resettime %d\n", m->fixed_resettime);	1247	fprintf (freezer, "fixed_resettime %d\n", m->fixed_resettime);
1286	/* we unfortunately have no idea if this is a value the creator set	1248	/* we unfortunately have no idea if this is a value the creator set
1287	* or a difficulty value we generated when the map was first loaded	1249	* or a difficulty value we generated when the map was first loaded
1288	*/	1250	*/
		1251	if (m->difficulty)
1289	if (m->difficulty) fprintf(fp,"difficulty %d\n", m->difficulty);	1252	fprintf (freezer, "difficulty %d\n", m->difficulty);
		1253	if (m->region)
1290	if (m->region) fprintf(fp,"region %s\n", m->region->name);	1254	fprintf (freezer, "region %s\n", m->region->name);
1291	if (m->shopitems) {	1255	if (m->shopitems)
		1256	{
1292	print_shop_string(m, shop);	1257	print_shop_string (m, shop);
1293	fprintf(fp,"shopitems %s\n", shop);	1258	fprintf (freezer, "shopitems %s\n", shop);
1294	}	1259	}
		1260	if (m->shopgreed)
1295	if (m->shopgreed) fprintf(fp,"shopgreed %f\n", m->shopgreed);	1261	fprintf (freezer, "shopgreed %f\n", m->shopgreed);
1296	#ifndef WIN32	1262	#ifndef WIN32
		1263	if (m->shopmin)
1297	if (m->shopmin) fprintf(fp,"shopmin %llu\n", m->shopmin);	1264	fprintf (freezer, "shopmin %llu\n", m->shopmin);
		1265	if (m->shopmax)
1298	if (m->shopmax) fprintf(fp,"shopmax %llu\n", m->shopmax);	1266	fprintf (freezer, "shopmax %llu\n", m->shopmax);
1299	#else	1267	#else
		1268	if (m->shopmin)
1300	if (m->shopmin) fprintf(fp,"shopmin %I64u\n", m->shopmin);	1269	fprintf (freezer, "shopmin %I64u\n", m->shopmin);
		1270	if (m->shopmax)
1301	if (m->shopmax) fprintf(fp,"shopmax %I64u\n", m->shopmax);	1271	fprintf (freezer, "shopmax %I64u\n", m->shopmax);
1302	#endif	1272	#endif
		1273	if (m->shoprace)
1303	if (m->shoprace) fprintf(fp,"shoprace %s\n", m->shoprace);	1274	fprintf (freezer, "shoprace %s\n", m->shoprace);
		1275	if (m->darkness)
1304	if (m->darkness) fprintf(fp,"darkness %d\n", m->darkness);	1276	fprintf (freezer, "darkness %d\n", m->darkness);
		1277	if (m->width)
1305	if (m->width) fprintf(fp,"width %d\n", m->width);	1278	fprintf (freezer, "width %d\n", m->width);
		1279	if (m->height)
1306	if (m->height) fprintf(fp,"height %d\n", m->height);	1280	fprintf (freezer, "height %d\n", m->height);
		1281	if (m->enter_x)
1307	if (m->enter_x) fprintf(fp,"enter_x %d\n", m->enter_x);	1282	fprintf (freezer, "enter_x %d\n", m->enter_x);
		1283	if (m->enter_y)
1308	if (m->enter_y) fprintf(fp,"enter_y %d\n", m->enter_y);	1284	fprintf (freezer, "enter_y %d\n", m->enter_y);
		1285	if (m->msg)
1309	if (m->msg) fprintf(fp,"msg\n%sendmsg\n", m->msg);	1286	fprintf (freezer, "msg\n%sendmsg\n", m->msg);
		1287	if (m->maplore)
1310	if (m->maplore) fprintf(fp,"maplore\n%sendmaplore\n", m->maplore);	1288	fprintf (freezer, "maplore\n%sendmaplore\n", m->maplore);
		1289	if (m->unique)
1311	if (m->unique) fprintf(fp,"unique %d\n", m->unique);	1290	fprintf (freezer, "unique %d\n", m->unique);
		1291	if (m->templatemap)
1312	if (m->templatemap) fprintf(fp,"template %d\n", m->templatemap);	1292	fprintf (freezer, "template %d\n", m->templatemap);
		1293	if (m->outdoor)
1313	if (m->outdoor) fprintf(fp,"outdoor %d\n", m->outdoor);	1294	fprintf (freezer, "outdoor %d\n", m->outdoor);
		1295	if (m->temp)
1314	if (m->temp) fprintf(fp, "temp %d\n", m->temp);	1296	fprintf (freezer, "temp %d\n", m->temp);
		1297	if (m->pressure)
1315	if (m->pressure) fprintf(fp, "pressure %d\n", m->pressure);	1298	fprintf (freezer, "pressure %d\n", m->pressure);
		1299	if (m->humid)
1316	if (m->humid) fprintf(fp, "humid %d\n", m->humid);	1300	fprintf (freezer, "humid %d\n", m->humid);
		1301	if (m->windspeed)
1317	if (m->windspeed) fprintf(fp, "windspeed %d\n", m->windspeed);	1302	fprintf (freezer, "windspeed %d\n", m->windspeed);
		1303	if (m->winddir)
1318	if (m->winddir) fprintf(fp, "winddir %d\n", m->winddir);	1304	fprintf (freezer, "winddir %d\n", m->winddir);
		1305	if (m->sky)
1319	if (m->sky) fprintf(fp, "sky %d\n", m->sky);	1306	fprintf (freezer, "sky %d\n", m->sky);
		1307	if (m->nosmooth)
1320	if (m->nosmooth) fprintf(fp, "nosmooth %d\n", m->nosmooth);	1308	fprintf (freezer, "nosmooth %d\n", m->nosmooth);
1321	if (m->safe_map) fprintf(fp, "safe_map %d\n", m->safe_map);
1322		1309
1323	/* Save any tiling information, except on overlays */	1310	/* Save any tiling information, except on overlays */
1324	if (flag != 2)	1311	if (flag != 2)
1325	for (i=0; i<4; i++)	1312	for (i = 0; i < 4; i++)
1326	if (m->tile_path[i])	1313	if (m->tile_path[i])
1327	fprintf(fp,"tile_path_%d %s\n", i+1, m->tile_path[i]);	1314	fprintf (freezer, "tile_path_%d %s\n", i + 1, m->tile_path[i]);
1328		1315
		1316	freezer.put (m);
1329	fprintf(fp,"end\n");	1317	fprintf (freezer, "end\n");
1330		1318
1331	/* In the game save unique items in the different file, but	1319	/* In the game save unique items in the different file, but
1332	* in the editor save them to the normal map file.	1320	* in the editor save them to the normal map file.
1333	* If unique map, save files in the proper destination (set by	1321	* If unique map, save files in the proper destination (set by
1334	* player)	1322	* player)
1335	*/	1323	*/
1336	if ((flag == 0 || flag == 2) && !m->unique && !m->templatemap) {	1324	if ((flag == 0 || flag == 2) && !m->unique && !m->templatemap)
		1325	{
		1326	object_freezer unique;
		1327
		1328	if (flag == 2)
		1329	save_objects (m, freezer, unique, 2);
		1330	else
		1331	save_objects (m, freezer, unique, 0);
		1332
1337	sprintf (buf,"%s.v00",create_items_path (m->path));	1333	sprintf (buf, "%s.v00", create_items_path (m->path));
1338	sprintf (buf_s, "%s~", buf);
1339	if ((fp2 = fopen (buf_s, "w")) == NULL) {
1340	LOG(llevError, "Can't open unique items file %s\n", buf_s);
1341	}
1342		1334
1343	object_freezer freezer2 (buf);	1335	unique.save (buf);
1344
1345	if (flag == 2)
1346	save_objects(m, fp, freezer, fp2, freezer2, 2);
1347	else
1348	save_objects (m, fp,freezer, fp2, freezer2, 0);
1349	if (fp2 != NULL) {
1350	if (ftell (fp2) == 0) {
1351	fclose (fp2);
1352	rename (buf_s, buf);
1353	unlink (buf);
1354	} else {
1355	fclose (fp2);
1356	rename (buf_s, buf);
1357	chmod (buf, SAVE_MODE);
1358	}	1336	}
1359	}
1360	} else { /* save same file when not playing, like in editor */
1361	save_objects(m, fp, freezer, fp, freezer, 0);
1362	}
1363
1364	if (m->compressed && (m->unique || m->templatemap || flag))
1365	pclose(fp);
1366	else	1337	else
1367	fclose(fp);	1338	{ /* save same file when not playing, like in editor */
		1339	save_objects (m, freezer, freezer, 0);
		1340	}
1368		1341
1369	rename (filename_s, filename);	1342	freezer.save (filename);
1370		1343
1371	chmod (filename, SAVE_MODE);
1372	return 0;	1344	return 0;
1373	}	1345	}
1374		1346
1375		1347
1376	/*	1348	/*
1377	* Remove and free all objects in the inventory of the given object.	1349	* Remove and free all objects in the inventory of the given object.
…		…
1382	{	1354	{
1383	object *tmp, *next;	1355	object *tmp, *next;
1384		1356
1385	for(tmp = op->inv; tmp; tmp = next)	1357	for(tmp = op->inv; tmp; tmp = next)
1386	{	1358	{
1387	next = tmp->below;	1359	next = tmp->below;
1388	clean_object(tmp);	1360	clean_object(tmp);
1389	if (QUERY_FLAG(tmp, FLAG_IS_LINKED))	1361	if (QUERY_FLAG(tmp, FLAG_IS_LINKED))
1390	remove_button_link(tmp);	1362	remove_button_link(tmp);
1391	remove_ob(tmp);	1363	remove_ob(tmp);
1392	free_object(tmp);	1364	free_object(tmp);
1393	}	1365	}
1394	}	1366	}
1395		1367
1396	/*	1368	/*
1397	* Remove and free all objects in the given map.	1369	* Remove and free all objects in the given map.
…		…
1400	void free_all_objects(mapstruct *m) {	1372	void free_all_objects(mapstruct *m) {
1401	int i,j;	1373	int i,j;
1402	object *op;	1374	object *op;
1403		1375
1404	for(i=0;i<MAP_WIDTH(m);i++)	1376	for(i=0;i<MAP_WIDTH(m);i++)
1405	for(j=0;j<MAP_HEIGHT(m);j++) {	1377	for(j=0;j<MAP_HEIGHT(m);j++) {
1406	object *previous_obj=NULL;	1378	object *previous_obj=NULL;
1407	while((op=GET_MAP_OB(m,i,j))!=NULL) {	1379	while((op=GET_MAP_OB(m,i,j))!=NULL) {
1408	if (op==previous_obj) {	1380	if (op==previous_obj) {
1409	LOG(llevDebug, "free_all_objects: Link error, bailing out.\n");	1381	LOG(llevDebug, "free_all_objects: Link error, bailing out.\n");
1410	break;	1382	break;
1411	}	1383	}
1412	previous_obj=op;	1384	previous_obj=op;
1413	if(op->head!=NULL)	1385	if(op->head!=NULL)
1414	op = op->head;	1386	op = op->head;
1415		1387
1416	/* If the map isn't in memory, free_object will remove and	1388	/* If the map isn't in memory, free_object will remove and
1417	* free objects in op's inventory. So let it do the job.	1389	* free objects in op's inventory. So let it do the job.
1418	*/	1390	*/
1419	if (m->in_memory==MAP_IN_MEMORY)	1391	if (m->in_memory==MAP_IN_MEMORY)
1420	clean_object(op);	1392	clean_object(op);
1421	remove_ob(op);	1393	remove_ob(op);
1422	free_object(op);	1394	free_object(op);
1423	}	1395	}
1424	}	1396	}
1425	#ifdef MANY_CORES
1426	/* I see periodic cores on metalforge where a map has been swapped out, but apparantly
1427	* an item on that map was not saved - look for that condition and die as appropriate -
1428	* this leaves more of the map data intact for better debugging.
1429	*/
1430	for (op=objects; op!=NULL; op=op->next) {
1431	if (!QUERY_FLAG(op, FLAG_REMOVED) && op->map == m) {
1432	LOG(llevDebug,"free_all_objects: object %s still on map after it should have been freed\n", op->name);
1433	abort();
1434	}
1435	}
1436	#endif
1437	}	1397	}
1438		1398
1439	/*	1399	/*
1440	* Frees everything allocated by the given mapstructure.	1400	* Frees everything allocated by the given mapstructure.
1441	* don't free tmpname - our caller is left to do that	1401	* don't free tmpname - our caller is left to do that
…		…
1443		1403
1444	void free_map(mapstruct *m,int flag) {	1404	void free_map(mapstruct *m,int flag) {
1445	int i;	1405	int i;
1446		1406
1447	if (!m->in_memory) {	1407	if (!m->in_memory) {
1448	LOG(llevError,"Trying to free freed map.\n");	1408	LOG(llevError,"Trying to free freed map.\n");
1449	return;	1409	return;
1450	}	1410	}
1451	if (flag && m->spaces) free_all_objects(m);	1411	if (flag && m->spaces) free_all_objects(m);
1452	if (m->name) FREE_AND_CLEAR(m->name);	1412	if (m->name) FREE_AND_CLEAR(m->name);
1453	if (m->spaces) FREE_AND_CLEAR(m->spaces);	1413	if (m->spaces) FREE_AND_CLEAR(m->spaces);
1454	if (m->msg) FREE_AND_CLEAR(m->msg);	1414	if (m->msg) FREE_AND_CLEAR(m->msg);
1455	if (m->maplore) FREE_AND_CLEAR(m->maplore);	1415	if (m->maplore) FREE_AND_CLEAR(m->maplore);
1456	if (m->shopitems) FREE_AND_CLEAR(m->shopitems);	1416	if (m->shopitems) delete [] m->shopitems; m->shopitems = 0;
1457	if (m->shoprace) FREE_AND_CLEAR(m->shoprace);	1417	if (m->shoprace) FREE_AND_CLEAR(m->shoprace);
1458	if (m->buttons)	1418	if (m->buttons)
1459	free_objectlinkpt(m->buttons);	1419	free_objectlinkpt(m->buttons);
1460	m->buttons = NULL;	1420	m->buttons = NULL;
1461	for (i=0; i<4; i++) {	1421	for (i=0; i<4; i++) {
1462	if (m->tile_path[i]) FREE_AND_CLEAR(m->tile_path[i]);	1422	if (m->tile_path[i]) FREE_AND_CLEAR(m->tile_path[i]);
1463	m->tile_map[i] = NULL;	1423	m->tile_map[i] = NULL;
1464	}	1424	}
1465	m->in_memory = MAP_SWAPPED;	1425	m->in_memory = MAP_SWAPPED;
1466	}	1426	}
1467		1427
1468	/*	1428	/*
…		…
1476	mapstruct *tmp, *last;	1436	mapstruct *tmp, *last;
1477	int i;	1437	int i;
1478		1438
1479	if (!m)	1439	if (!m)
1480	return;	1440	return;
		1441
		1442	m->clear ();
		1443
1481	if (m->in_memory == MAP_IN_MEMORY) {	1444	if (m->in_memory == MAP_IN_MEMORY) {
1482	/* change to MAP_SAVING, even though we are not,	1445	/* change to MAP_SAVING, even though we are not,
1483	* so that remove_ob doesn't do as much work.	1446	* so that remove_ob doesn't do as much work.
1484	*/	1447	*/
1485	m->in_memory = MAP_SAVING;	1448	m->in_memory = MAP_SAVING;
1486	free_map (m, 1);	1449	free_map (m, 1);
1487	}	1450	}
1488	/* move this out of free_map, since tmpname can still be needed if	1451	/* move this out of free_map, since tmpname can still be needed if
1489	* the map is swapped out.	1452	* the map is swapped out.
1490	*/	1453	*/
1491	if (m->tmpname) {	1454	if (m->tmpname) {
1492	free(m->tmpname);	1455	free(m->tmpname);
1493	m->tmpname=NULL;	1456	m->tmpname=NULL;
1494	}	1457	}
1495	last = NULL;	1458	last = NULL;
1496	/* We need to look through all the maps and see if any maps	1459	/* We need to look through all the maps and see if any maps
1497	* are pointing at this one for tiling information. Since	1460	* are pointing at this one for tiling information. Since
1498	* tiling can be assymetric, we just can not look to see which	1461	* tiling can be assymetric, we just can not look to see which
1499	* maps this map tiles with and clears those.	1462	* maps this map tiles with and clears those.
1500	*/	1463	*/
1501	for (tmp = first_map; tmp != NULL; tmp = tmp->next) {	1464	for (tmp = first_map; tmp != NULL; tmp = tmp->next) {
1502	if (tmp->next == m) last = tmp;	1465	if (tmp->next == m) last = tmp;
1503		1466
1504	/* This should hopefully get unrolled on a decent compiler */	1467	/* This should hopefully get unrolled on a decent compiler */
1505	for (i=0; i<4; i++)	1468	for (i=0; i<4; i++)
1506	if (tmp->tile_map[i] == m) tmp->tile_map[i]=NULL;	1469	if (tmp->tile_map[i] == m) tmp->tile_map[i]=NULL;
1507	}	1470	}
1508		1471
1509	/* If last is null, then this should be the first map in the list */	1472	/* If last is null, then this should be the first map in the list */
1510	if (!last) {	1473	if (!last) {
1511	if (m == first_map)	1474	if (m == first_map)
1512	first_map = m->next;	1475	first_map = m->next;
1513	else	1476	else
1514	/* m->path is a static char, so should hopefully still have	1477	/* m->path is a static char, so should hopefully still have
1515	* some useful data in it.	1478	* some useful data in it.
1516	*/	1479	*/
1517	LOG(llevError,"delete_map: Unable to find map %s in list\n",	1480	LOG(llevError,"delete_map: Unable to find map %s in list\n",
1518	m->path);	1481	m->path);
1519	}	1482	}
1520	else	1483	else
1521	last->next = m->next;	1484	last->next = m->next;
1522		1485
1523	free (m);	1486	delete m;
1524	}	1487	}
1525		1488
1526		1489
1527		1490
1528	/*	1491	/*
…		…
1546	/* Have we been at this level before? */	1509	/* Have we been at this level before? */
1547	m = has_been_loaded (name);	1510	m = has_been_loaded (name);
1548		1511
1549	/* Map is good to go, so just return it */	1512	/* Map is good to go, so just return it */
1550	if (m && (m->in_memory == MAP_LOADING || m->in_memory == MAP_IN_MEMORY)) {	1513	if (m && (m->in_memory == MAP_LOADING || m->in_memory == MAP_IN_MEMORY)) {
1551	return m;	1514	return m;
1552	}	1515	}
1553		1516
1554	/* unique maps always get loaded from their original location, and never	1517	/* unique maps always get loaded from their original location, and never
1555	* a temp location. Likewise, if map_flush is set, or we have never loaded	1518	* a temp location. Likewise, if map_flush is set, or we have never loaded
1556	* this map, load it now. I removed the reset checking from here -	1519	* this map, load it now. I removed the reset checking from here -
…		…
1559	* a bit cleaner (and players probably shouldn't rely on exact timing for	1522	* a bit cleaner (and players probably shouldn't rely on exact timing for
1560	* resets in any case - if they really care, they should use the 'maps command.	1523	* resets in any case - if they really care, they should use the 'maps command.
1561	*/	1524	*/
1562	if ((flags & (MAP_FLUSH|MAP_PLAYER_UNIQUE)) || !m) {	1525	if ((flags & (MAP_FLUSH|MAP_PLAYER_UNIQUE)) || !m) {
1563		1526
1564	/* first visit or time to reset */	1527	/* first visit or time to reset */
1565	if (m) {	1528	if (m) {
1566	clean_tmp_map(m); /* Doesn't make much difference */	1529	clean_tmp_map(m); /* Doesn't make much difference */
1567	delete_map(m);	1530	delete_map(m);
1568	}	1531	}
1569		1532
1570	/* create and load a map */	1533	/* create and load a map */
1571	if (flags & MAP_PLAYER_UNIQUE)	1534	if (flags & MAP_PLAYER_UNIQUE)
1572	LOG(llevDebug, "Trying to load map %s.\n", name);	1535	LOG(llevDebug, "Trying to load map %s.\n", name);
1573	else	1536	else
1574	LOG(llevDebug, "Trying to load map %s.\n", create_pathname(name));	1537	LOG(llevDebug, "Trying to load map %s.\n", create_pathname(name));
1575		1538
		1539	//eval_pv ("$x = Event::time", 1);//D
1576	if (!(m = load_original_map(name, (flags & MAP_PLAYER_UNIQUE))))	1540	if (!(m = load_original_map(name, (flags & MAP_PLAYER_UNIQUE))))
1577	return (NULL);	1541	return (NULL);
		1542	//eval_pv ("warn \"LOAD \", Event::time - $x", 1);//D
1578		1543
1579	fix_auto_apply(m); /* Chests which open as default */	1544	fix_auto_apply(m); /* Chests which open as default */
1580		1545
1581	/* If a player unique map, no extra unique object file to load.	1546	/* If a player unique map, no extra unique object file to load.
1582	* if from the editor, likewise.	1547	* if from the editor, likewise.
1583	*/	1548	*/
1584	if (! (flags & (MAP_FLUSH|MAP_PLAYER_UNIQUE)))	1549	if (!(flags & (MAP_FLUSH|MAP_PLAYER_UNIQUE)))
1585	load_unique_objects(m);	1550	load_unique_objects(m);
1586		1551
1587	if (! (flags & (MAP_FLUSH|MAP_PLAYER_UNIQUE|MAP_OVERLAY))) {	1552	if (! (flags & (MAP_FLUSH|MAP_PLAYER_UNIQUE|MAP_OVERLAY))) {
1588	m=load_overlay_map(name, m);	1553	m=load_overlay_map(name, m);
1589	if (m==NULL)	1554	if (m==NULL)
1590	return NULL;	1555	return NULL;
1591	}	1556	}
		1557
		1558	if (flags & MAP_PLAYER_UNIQUE)
		1559	INVOKE_MAP (SWAPIN, m);
1592		1560
1593	} else {	1561	} else {
1594	/* If in this loop, we found a temporary map, so load it up. */	1562	/* If in this loop, we found a temporary map, so load it up. */
1595		1563
1596	m=load_temporary_map (m);	1564	m=load_temporary_map (m);
1597	if(m==NULL) return NULL;	1565	if(m==NULL) return NULL;
1598	load_unique_objects(m);	1566	load_unique_objects(m);
1599		1567
1600	clean_tmp_map(m);	1568	clean_tmp_map(m);
1601	m->in_memory = MAP_IN_MEMORY;	1569	m->in_memory = MAP_IN_MEMORY;
1602	/* tempnam() on sun systems (probably others) uses malloc	1570	/* tempnam() on sun systems (probably others) uses malloc
1603	* to allocated space for the string. Free it here.	1571	* to allocated space for the string. Free it here.
1604	* In some cases, load_temporary_map above won't find the	1572	* In some cases, load_temporary_map above won't find the
1605	* temporary map, and so has reloaded a new map. If that	1573	* temporary map, and so has reloaded a new map. If that
1606	* is the case, tmpname is now null	1574	* is the case, tmpname is now null
1607	*/	1575	*/
1608	if (m->tmpname) free(m->tmpname);	1576	if (m->tmpname) free(m->tmpname);
1609	m->tmpname = NULL;	1577	m->tmpname = NULL;
1610	/* It's going to be saved anew anyway */	1578	/* It's going to be saved anew anyway */
1611	}	1579	}
1612		1580
1613	/* Below here is stuff common to both first time loaded maps and	1581	/* Below here is stuff common to both first time loaded maps and
1614	* temp maps.	1582	* temp maps.
1615	*/	1583	*/
1616		1584
1617	decay_objects(m); /* start the decay */	1585	decay_objects(m); /* start the decay */
1618	/* In case other objects press some buttons down */	1586	/* In case other objects press some buttons down */
1619	update_buttons(m);	1587	update_buttons(m);
1620	if (m->outdoor)	1588	if (m->outdoor)
1621	set_darkness_map(m);	1589	set_darkness_map(m);
1622	/* run the weather over this map */	1590	/* run the weather over this map */
1623	weather_effect(name);	1591	weather_effect(name);
1624	return m;	1592	return m;
1625	}	1593	}
1626		1594
…		…
1637	*/	1605	*/
1638		1606
1639	int calculate_difficulty(mapstruct *m) {	1607	int calculate_difficulty(mapstruct *m) {
1640	object *op;	1608	object *op;
1641	archetype *at;	1609	archetype *at;
1642	int x, y, i, diff;	1610	int x, y, i;
1643	long monster_cnt = 0;	1611	long monster_cnt = 0;
1644	double avgexp = 0;	1612	double avgexp = 0;
1645	sint64 total_exp = 0;	1613	sint64 total_exp = 0;
1646		1614
1647	if (MAP_DIFFICULTY (m))	1615	if (MAP_DIFFICULTY (m))
…		…
1686	return 1;	1654	return 1;
1687	}	1655	}
1688		1656
1689	void clean_tmp_map(mapstruct *m) {	1657	void clean_tmp_map(mapstruct *m) {
1690	if(m->tmpname == NULL)	1658	if(m->tmpname == NULL)
1691	return;	1659	return;
1692	INVOKE_MAP (CLEAN, m);	1660	INVOKE_MAP (CLEAN, m);
1693	(void) unlink(m->tmpname);	1661	(void) unlink(m->tmpname);
1694	}	1662	}
1695		1663
1696	void free_all_maps(void)	1664	void free_all_maps(void)
1697	{	1665	{
1698	int real_maps=0;	1666	int real_maps=0;
1699		1667
1700	while (first_map) {	1668	while (first_map) {
1701	/* I think some of the callers above before it gets here set this to be	1669	/* I think some of the callers above before it gets here set this to be
1702	* saving, but we still want to free this data	1670	* saving, but we still want to free this data
1703	*/	1671	*/
1704	if (first_map->in_memory == MAP_SAVING) first_map->in_memory = MAP_IN_MEMORY;	1672	if (first_map->in_memory == MAP_SAVING) first_map->in_memory = MAP_IN_MEMORY;
1705	delete_map(first_map);	1673	delete_map(first_map);
1706	real_maps++;	1674	real_maps++;
1707	}	1675	}
1708	LOG(llevDebug,"free_all_maps: Freed %d maps\n", real_maps);	1676	LOG(llevDebug,"free_all_maps: Freed %d maps\n", real_maps);
1709	}	1677	}
1710		1678
1711	/* change_map_light() - used to change map light level (darkness)	1679	/* change_map_light() - used to change map light level (darkness)
…		…
1725	return 0;	1693	return 0;
1726	}	1694	}
1727		1695
1728	/* inform all players on the map */	1696	/* inform all players on the map */
1729	if (change>0)	1697	if (change>0)
1730	new_info_map(NDI_BLACK|NDI_UNIQUE, m,"It becomes darker.");	1698	new_info_map(NDI_BLACK|NDI_UNIQUE, m,"It becomes darker.");
1731	else	1699	else
1732	new_info_map(NDI_BLACK|NDI_UNIQUE, m,"It becomes brighter.");	1700	new_info_map(NDI_BLACK|NDI_UNIQUE, m,"It becomes brighter.");
1733		1701
1734	/* Do extra checking. since m->darkness is a unsigned value,	1702	/* Do extra checking. since m->darkness is a unsigned value,
1735	* we need to be extra careful about negative values.	1703	* we need to be extra careful about negative values.
1736	* In general, the checks below are only needed if change	1704	* In general, the checks below are only needed if change
1737	* is not +/-1	1705	* is not +/-1
…		…
1755	void update_position (mapstruct *m, int x, int y) {	1723	void update_position (mapstruct *m, int x, int y) {
1756	object *tmp, *last = NULL;	1724	object *tmp, *last = NULL;
1757	uint8 flags = 0, oldflags, light=0, anywhere=0;	1725	uint8 flags = 0, oldflags, light=0, anywhere=0;
1758	New_Face *top,*floor, *middle;	1726	New_Face *top,*floor, *middle;
1759	object *top_obj, *floor_obj, *middle_obj;	1727	object *top_obj, *floor_obj, *middle_obj;
1760	MoveType move_block=0, move_slow=0, move_on=0, move_off=0, move_allow=0;	1728	MoveType move_block=0, move_slow=0, move_on=0, move_off=0, move_allow=0;
1761		1729
1762	oldflags = GET_MAP_FLAGS(m,x,y);	1730	oldflags = GET_MAP_FLAGS(m,x,y);
1763	if (!(oldflags & P_NEED_UPDATE)) {	1731	if (!(oldflags & P_NEED_UPDATE)) {
1764	LOG(llevDebug,"update_position called with P_NEED_UPDATE not set: %s (%d, %d)\n",	1732	LOG(llevDebug,"update_position called with P_NEED_UPDATE not set: %s (%d, %d)\n",
1765	m->path, x, y);	1733	m->path, x, y);
1766	return;	1734	return;
1767	}	1735	}
1768		1736
1769	middle=blank_face;	1737	middle=blank_face;
1770	top=blank_face;	1738	top=blank_face;
1771	floor=blank_face;	1739	floor=blank_face;
…		…
1774	top_obj = NULL;	1742	top_obj = NULL;
1775	floor_obj = NULL;	1743	floor_obj = NULL;
1776		1744
1777	for (tmp = get_map_ob (m, x, y); tmp; last = tmp, tmp = tmp->above) {	1745	for (tmp = get_map_ob (m, x, y); tmp; last = tmp, tmp = tmp->above) {
1778		1746
1779	/* This could be made additive I guess (two lights better than	1747	/* This could be made additive I guess (two lights better than
1780	* one). But if so, it shouldn't be a simple additive - 2	1748	* one). But if so, it shouldn't be a simple additive - 2
1781	* light bulbs do not illuminate twice as far as once since	1749	* light bulbs do not illuminate twice as far as once since
1782	* it is a disapation factor that is squared (or is it cubed?)	1750	* it is a disapation factor that is squared (or is it cubed?)
1783	*/	1751	*/
1784	if (tmp->glow_radius > light) light = tmp->glow_radius;	1752	if (tmp->glow_radius > light) light = tmp->glow_radius;
1785		1753
1786	/* This call is needed in order to update objects the player	1754	/* This call is needed in order to update objects the player
1787	* is standing in that have animations (ie, grass, fire, etc).	1755	* is standing in that have animations (ie, grass, fire, etc).
1788	* However, it also causes the look window to be re-drawn	1756	* However, it also causes the look window to be re-drawn
1789	* 3 times each time the player moves, because many of the	1757	* 3 times each time the player moves, because many of the
1790	* functions the move_player calls eventualy call this.	1758	* functions the move_player calls eventualy call this.
1791	*	1759	*
1792	* Always put the player down for drawing.	1760	* Always put the player down for drawing.
1793	*/	1761	*/
1794	if (!tmp->invisible) {	1762	if (!tmp->invisible) {
1795	if ((tmp->type==PLAYER || QUERY_FLAG(tmp, FLAG_MONSTER))) {	1763	if ((tmp->type==PLAYER || QUERY_FLAG(tmp, FLAG_MONSTER))) {
1796	top = tmp->face;	1764	top = tmp->face;
1797	top_obj = tmp;	1765	top_obj = tmp;
1798	}	1766	}
1799	else if (QUERY_FLAG(tmp,FLAG_IS_FLOOR)) {	1767	else if (QUERY_FLAG(tmp,FLAG_IS_FLOOR)) {
1800	/* If we got a floor, that means middle and top were below it,	1768	/* If we got a floor, that means middle and top were below it,
1801	* so should not be visible, so we clear them.	1769	* so should not be visible, so we clear them.
1802	*/	1770	*/
1803	middle=blank_face;	1771	middle=blank_face;
1804	top=blank_face;	1772	top=blank_face;
1805	floor = tmp->face;	1773	floor = tmp->face;
1806	floor_obj = tmp;	1774	floor_obj = tmp;
1807	}	1775	}
1808	/* Flag anywhere have high priority */	1776	/* Flag anywhere have high priority */
1809	else if (QUERY_FLAG(tmp, FLAG_SEE_ANYWHERE)) {	1777	else if (QUERY_FLAG(tmp, FLAG_SEE_ANYWHERE)) {
1810	middle = tmp->face;	1778	middle = tmp->face;
1811		1779
1812	middle_obj = tmp;	1780	middle_obj = tmp;
1813	anywhere =1;	1781	anywhere =1;
1814	}	1782	}
1815	/* Find the highest visible face around. If equal	1783	/* Find the highest visible face around. If equal
1816	* visibilities, we still want the one nearer to the	1784	* visibilities, we still want the one nearer to the
1817	* top	1785	* top
1818	*/	1786	*/
1819	else if (middle == blank_face || (tmp->face->visibility > middle->visibility && !anywhere)) {	1787	else if (middle == blank_face || (tmp->face->visibility > middle->visibility && !anywhere)) {
1820	middle = tmp->face;	1788	middle = tmp->face;
1821	middle_obj = tmp;	1789	middle_obj = tmp;
1822	}	1790	}
1823	}	1791	}
1824	if (tmp==tmp->above) {	1792	if (tmp==tmp->above) {
1825	LOG(llevError, "Error in structure of map\n");	1793	LOG(llevError, "Error in structure of map\n");
1826	exit (-1);	1794	exit (-1);
1827	}	1795	}
1828		1796
1829	move_slow |= tmp->move_slow;	1797	move_slow |= tmp->move_slow;
1830	move_block |= tmp->move_block;	1798	move_block |= tmp->move_block;
1831	move_on |= tmp->move_on;	1799	move_on |= tmp->move_on;
1832	move_off |= tmp->move_off;	1800	move_off |= tmp->move_off;
1833	move_allow |= tmp->move_allow;	1801	move_allow |= tmp->move_allow;
1834		1802
1835	if (QUERY_FLAG(tmp,FLAG_ALIVE))	1803	if (QUERY_FLAG(tmp,FLAG_ALIVE))
1836	flags |= P_IS_ALIVE;	1804	flags |= P_IS_ALIVE;
1837	if (QUERY_FLAG(tmp,FLAG_NO_MAGIC))	1805	if (QUERY_FLAG(tmp,FLAG_NO_MAGIC))
1838	flags |= P_NO_MAGIC;	1806	flags |= P_NO_MAGIC;
1839	if (QUERY_FLAG(tmp,FLAG_DAMNED))	1807	if (QUERY_FLAG(tmp,FLAG_DAMNED))
1840	flags |= P_NO_CLERIC;	1808	flags |= P_NO_CLERIC;
1841	if (tmp->type == SAFE_GROUND)	1809	if (tmp->type == SAFE_GROUND)
1842	flags |= P_SAFE | P_NO_CLERIC | P_NO_MAGIC;	1810	flags |= P_SAFE | P_NO_CLERIC | P_NO_MAGIC;
1843		1811
1844	if (QUERY_FLAG(tmp,FLAG_BLOCKSVIEW))	1812	if (QUERY_FLAG(tmp,FLAG_BLOCKSVIEW))
1845	flags |= P_BLOCKSVIEW;	1813	flags |= P_BLOCKSVIEW;
1846	} /* for stack of objects */	1814	} /* for stack of objects */
1847		1815
1848	/* we don't want to rely on this function to have accurate flags, but	1816	/* we don't want to rely on this function to have accurate flags, but
1849	* since we're already doing the work, we calculate them here.	1817	* since we're already doing the work, we calculate them here.
1850	* if they don't match, logic is broken someplace.	1818	* if they don't match, logic is broken someplace.
1851	*/	1819	*/
1852	if (((oldflags & ~(P_NEED_UPDATE|P_NO_ERROR)) != flags) &&	1820	if (((oldflags & ~(P_NEED_UPDATE|P_NO_ERROR)) != flags) &&
1853	(!(oldflags & P_NO_ERROR))) {	1821	(!(oldflags & P_NO_ERROR))) {
1854	LOG(llevDebug,"update_position: updated flags do not match old flags: %s (old=%d,new=%d) %x != %x\n",	1822	LOG(llevDebug,"update_position: updated flags do not match old flags: %s (old=%d,new=%d) %x != %x\n",
1855	m->path, x, y,	1823	m->path, x, y,
1856	(oldflags & ~P_NEED_UPDATE), flags);	1824	(oldflags & ~P_NEED_UPDATE), flags);
1857	}	1825	}
1858	SET_MAP_FLAGS(m, x, y, flags);	1826	SET_MAP_FLAGS(m, x, y, flags);
1859	SET_MAP_MOVE_BLOCK(m, x, y, move_block & ~move_allow);	1827	SET_MAP_MOVE_BLOCK(m, x, y, move_block & ~move_allow);
1860	SET_MAP_MOVE_ON(m, x, y, move_on);	1828	SET_MAP_MOVE_ON(m, x, y, move_on);
…		…
1882	* 2) middle is set, need to set top.	1850	* 2) middle is set, need to set top.
1883	* 3) neither middle or top is set - need to set both.	1851	* 3) neither middle or top is set - need to set both.
1884	*/	1852	*/
1885		1853
1886	for (tmp=last; tmp; tmp=tmp->below) {	1854	for (tmp=last; tmp; tmp=tmp->below) {
1887	/* Once we get to a floor, stop, since we already have a floor object */	1855	/* Once we get to a floor, stop, since we already have a floor object */
1888	if (QUERY_FLAG(tmp,FLAG_IS_FLOOR)) break;	1856	if (QUERY_FLAG(tmp,FLAG_IS_FLOOR)) break;
1889		1857
1890	/* If two top faces are already set, quit processing */	1858	/* If two top faces are already set, quit processing */
1891	if ((top != blank_face) && (middle != blank_face)) break;	1859	if ((top != blank_face) && (middle != blank_face)) break;
1892		1860
1893	/* Only show visible faces, unless its the editor - show all */	1861	/* Only show visible faces, unless its the editor - show all */
1894	if (!tmp->invisible || editor) {	1862	if (!tmp->invisible || editor) {
1895	/* Fill in top if needed */	1863	/* Fill in top if needed */
1896	if (top == blank_face) {	1864	if (top == blank_face) {
1897	top = tmp->face;	1865	top = tmp->face;
1898	top_obj = tmp;	1866	top_obj = tmp;
1899	if (top == middle) middle=blank_face;	1867	if (top == middle) middle=blank_face;
1900	} else {	1868	} else {
1901	/* top is already set - we should only get here if	1869	/* top is already set - we should only get here if
1902	* middle is not set	1870	* middle is not set
1903	*	1871	*
1904	* Set the middle face and break out, since there is nothing	1872	* Set the middle face and break out, since there is nothing
1905	* more to fill in. We don't check visiblity here, since	1873	* more to fill in. We don't check visiblity here, since
1906	*	1874	*
1907	*/	1875	*/
1908	if (tmp->face != top ) {	1876	if (tmp->face != top ) {
1909	middle = tmp->face;	1877	middle = tmp->face;
1910	middle_obj = tmp;	1878	middle_obj = tmp;
1911	break;	1879	break;
1912	}	1880	}
1913	}	1881	}
1914	}	1882	}
1915	}	1883	}
1916	if (middle == floor) middle = blank_face;	1884	if (middle == floor) middle = blank_face;
1917	if (top == middle) middle = blank_face;	1885	if (top == middle) middle = blank_face;
1918	SET_MAP_FACE(m,x,y,top,0);	1886	SET_MAP_FACE(m,x,y,top,0);
1919	if(top != blank_face)	1887	if(top != blank_face)
…		…
1959		1927
1960	orig_map->tile_map[tile_num] = ready_map_name(path, 0);	1928	orig_map->tile_map[tile_num] = ready_map_name(path, 0);
1961		1929
1962	/* need to do a strcmp here as the orig_map->path is not a shared string */	1930	/* need to do a strcmp here as the orig_map->path is not a shared string */
1963	if (orig_map->tile_map[tile_num]->tile_path[dest_tile] &&	1931	if (orig_map->tile_map[tile_num]->tile_path[dest_tile] &&
1964	!strcmp(orig_map->tile_map[tile_num]->tile_path[dest_tile], orig_map->path))	1932	!strcmp(orig_map->tile_map[tile_num]->tile_path[dest_tile], orig_map->path))
1965	orig_map->tile_map[tile_num]->tile_map[dest_tile] = orig_map;	1933	orig_map->tile_map[tile_num]->tile_map[dest_tile] = orig_map;
1966		1934
1967	return orig_map->tile_map[tile_num];	1935	return orig_map->tile_map[tile_num];
1968	}	1936	}
1969		1937
1970	/* this returns TRUE if the coordinates (x,y) are out of	1938	/* this returns TRUE if the coordinates (x,y) are out of
…		…
1985	* map loads fail below, it could happen.	1953	* map loads fail below, it could happen.
1986	*/	1954	*/
1987	if (!m) return 0;	1955	if (!m) return 0;
1988		1956
1989	if (x<0) {	1957	if (x<0) {
1990	if (!m->tile_path[3]) return 1;	1958	if (!m->tile_path[3]) return 1;
1991	if (!m->tile_map[3] || m->tile_map[3]->in_memory != MAP_IN_MEMORY) {	1959	if (!m->tile_map[3] || m->tile_map[3]->in_memory != MAP_IN_MEMORY) {
1992	load_and_link_tiled_map(m, 3);	1960	load_and_link_tiled_map(m, 3);
1993	}	1961	}
1994	return (out_of_map(m->tile_map[3], x + MAP_WIDTH(m->tile_map[3]), y));	1962	return (out_of_map(m->tile_map[3], x + MAP_WIDTH(m->tile_map[3]), y));
1995	}	1963	}
1996	if (x>=MAP_WIDTH(m)) {	1964	if (x>=MAP_WIDTH(m)) {
1997	if (!m->tile_path[1]) return 1;	1965	if (!m->tile_path[1]) return 1;
1998	if (!m->tile_map[1] || m->tile_map[1]->in_memory != MAP_IN_MEMORY) {	1966	if (!m->tile_map[1] || m->tile_map[1]->in_memory != MAP_IN_MEMORY) {
1999	load_and_link_tiled_map(m, 1);	1967	load_and_link_tiled_map(m, 1);
2000	}	1968	}
2001	return (out_of_map(m->tile_map[1], x - MAP_WIDTH(m), y));	1969	return (out_of_map(m->tile_map[1], x - MAP_WIDTH(m), y));
2002	}	1970	}
2003	if (y<0) {	1971	if (y<0) {
2004	if (!m->tile_path[0]) return 1;	1972	if (!m->tile_path[0]) return 1;
2005	if (!m->tile_map[0] || m->tile_map[0]->in_memory != MAP_IN_MEMORY) {	1973	if (!m->tile_map[0] || m->tile_map[0]->in_memory != MAP_IN_MEMORY) {
2006	load_and_link_tiled_map(m, 0);	1974	load_and_link_tiled_map(m, 0);
2007	}	1975	}
2008	return (out_of_map(m->tile_map[0], x, y + MAP_HEIGHT(m->tile_map[0])));	1976	return (out_of_map(m->tile_map[0], x, y + MAP_HEIGHT(m->tile_map[0])));
2009	}	1977	}
2010	if (y>=MAP_HEIGHT(m)) {	1978	if (y>=MAP_HEIGHT(m)) {
2011	if (!m->tile_path[2]) return 1;	1979	if (!m->tile_path[2]) return 1;
2012	if (!m->tile_map[2] || m->tile_map[2]->in_memory != MAP_IN_MEMORY) {	1980	if (!m->tile_map[2] || m->tile_map[2]->in_memory != MAP_IN_MEMORY) {
2013	load_and_link_tiled_map(m, 2);	1981	load_and_link_tiled_map(m, 2);
2014	}	1982	}
2015	return (out_of_map(m->tile_map[2], x, y - MAP_HEIGHT(m)));	1983	return (out_of_map(m->tile_map[2], x, y - MAP_HEIGHT(m)));
2016	}	1984	}
2017		1985
2018	/* Simple case - coordinates are within this local	1986	/* Simple case - coordinates are within this local
2019	* map.	1987	* map.
2020	*/	1988	*/
…		…
2031	*/	1999	*/
2032	mapstruct *get_map_from_coord(mapstruct *m, sint16 *x, sint16 *y)	2000	mapstruct *get_map_from_coord(mapstruct *m, sint16 *x, sint16 *y)
2033	{	2001	{
2034		2002
2035	if (*x<0) {	2003	if (*x<0) {
2036	if (!m->tile_path[3]) return NULL;	2004	if (!m->tile_path[3]) return NULL;
2037	if (!m->tile_map[3] || m->tile_map[3]->in_memory != MAP_IN_MEMORY)	2005	if (!m->tile_map[3] || m->tile_map[3]->in_memory != MAP_IN_MEMORY)
2038	load_and_link_tiled_map(m, 3);	2006	load_and_link_tiled_map(m, 3);
2039		2007
2040	*x += MAP_WIDTH(m->tile_map[3]);	2008	*x += MAP_WIDTH(m->tile_map[3]);
2041	return (get_map_from_coord(m->tile_map[3], x, y));	2009	return (get_map_from_coord(m->tile_map[3], x, y));
2042	}	2010	}
2043	if (*x>=MAP_WIDTH(m)) {	2011	if (*x>=MAP_WIDTH(m)) {
2044	if (!m->tile_path[1]) return NULL;	2012	if (!m->tile_path[1]) return NULL;
2045	if (!m->tile_map[1] || m->tile_map[1]->in_memory != MAP_IN_MEMORY)	2013	if (!m->tile_map[1] || m->tile_map[1]->in_memory != MAP_IN_MEMORY)
2046	load_and_link_tiled_map(m, 1);	2014	load_and_link_tiled_map(m, 1);
2047		2015
2048	*x -= MAP_WIDTH(m);	2016	*x -= MAP_WIDTH(m);
2049	return (get_map_from_coord(m->tile_map[1], x, y));	2017	return (get_map_from_coord(m->tile_map[1], x, y));
2050	}	2018	}
2051	if (*y<0) {	2019	if (*y<0) {
2052	if (!m->tile_path[0]) return NULL;	2020	if (!m->tile_path[0]) return NULL;
2053	if (!m->tile_map[0] || m->tile_map[0]->in_memory != MAP_IN_MEMORY)	2021	if (!m->tile_map[0] || m->tile_map[0]->in_memory != MAP_IN_MEMORY)
2054	load_and_link_tiled_map(m, 0);	2022	load_and_link_tiled_map(m, 0);
2055		2023
2056	*y += MAP_HEIGHT(m->tile_map[0]);	2024	*y += MAP_HEIGHT(m->tile_map[0]);
2057	return (get_map_from_coord(m->tile_map[0], x, y));	2025	return (get_map_from_coord(m->tile_map[0], x, y));
2058	}	2026	}
2059	if (*y>=MAP_HEIGHT(m)) {	2027	if (*y>=MAP_HEIGHT(m)) {
2060	if (!m->tile_path[2]) return NULL;	2028	if (!m->tile_path[2]) return NULL;
2061	if (!m->tile_map[2] || m->tile_map[2]->in_memory != MAP_IN_MEMORY)	2029	if (!m->tile_map[2] || m->tile_map[2]->in_memory != MAP_IN_MEMORY)
2062	load_and_link_tiled_map(m, 2);	2030	load_and_link_tiled_map(m, 2);
2063		2031
2064	*y -= MAP_HEIGHT(m);	2032	*y -= MAP_HEIGHT(m);
2065	return (get_map_from_coord(m->tile_map[2], x, y));	2033	return (get_map_from_coord(m->tile_map[2], x, y));
2066	}	2034	}
2067		2035
2068	/* Simple case - coordinates are within this local	2036	/* Simple case - coordinates are within this local
2069	* map.	2037	* map.
2070	*/	2038	*/
…		…
2214	retval->distance_x = 32767;	2182	retval->distance_x = 32767;
2215	retval->distance_y = 32767;	2183	retval->distance_y = 32767;
2216	retval->direction = 0;	2184	retval->direction = 0;
2217	retval->part = 0;	2185	retval->part = 0;
2218	} else {	2186	} else {
2219	retval->distance_x += op2->x-x;	2187	retval->distance_x += op2->x-x;
2220	retval->distance_y += op2->y-y;	2188	retval->distance_y += op2->y-y;
2221		2189
2222	retval->part = NULL;	2190	retval->part = NULL;
2223	retval->distance = isqrt(retval->distance_x*retval->distance_x+retval->distance_y*retval->distance_y);	2191	retval->distance = isqrt(retval->distance_x*retval->distance_x+retval->distance_y*retval->distance_y);
2224	retval->direction = find_dir_2(-retval->distance_x, -retval->distance_y);	2192	retval->direction = find_dir_2(-retval->distance_x, -retval->distance_y);
2225	}	2193	}

Diff Legend

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