[ViewVC] Diff of: cvs/deliantra/server/common/map.C

Comparing deliantra/server/common/map.C (file contents):
Revision 1.88 by root, Fri Feb 16 19:43:40 2007 UTC vs.
Revision 1.121 by root, Sat Aug 25 22:19:26 2007 UTC

…		…
1	/*	1	/*
2	* CrossFire, A Multiplayer game for X-windows	2	* This file is part of Crossfire TRT, the Roguelike Realtime MORPG.
3	*	3	*
4	* Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team	4	* Copyright (©) 2005,2006,2007 Marc Alexander Lehmann / Robin Redeker / the Crossfire TRT team
5	* Copyright (C) 2001-2003 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2001-2003,2007 Mark Wedel & Crossfire Development Team
6	* Copyright (C) 1992 Frank Tore Johansen	6	* Copyright (©) 1992,2007 Frank Tore Johansen
7	*	7	*
8	* This program is free software; you can redistribute it and/or modify	8	* Crossfire TRT is free software: you can redistribute it and/or modify
9	* it under the terms of the GNU General Public License as published by	9	* it under the terms of the GNU General Public License as published by
10	* the Free Software Foundation; either version 2 of the License, or	10	* the Free Software Foundation, either version 3 of the License, or
11	* (at your option) any later version.	11	* (at your option) any later version.
12	*	12	*
13	* This program is distributed in the hope that it will be useful,	13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.	16	* GNU General Public License for more details.
17	*	17	*
18	* You should have received a copy of the GNU General Public License	18	* You should have received a copy of the GNU General Public License
19	* along with this program; if not, write to the Free Software	19	* along with this program. If not, see <http://www.gnu.org/licenses/>.
20	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21	*	20	*
22	* The authors can be reached via e-mail at <crossfire@schmorp.de>	21	* The authors can be reached via e-mail to <crossfire@schmorp.de>
23	*/	22	*/
24		23
25	#include <unistd.h>	24	#include <unistd.h>
26		25
27	#include "global.h"	26	#include "global.h"
28	#include "funcpoint.h"	27	#include "funcpoint.h"
29		28
30	#include "loader.h"	29	#include "loader.h"
31		30
32	#include "path.h"	31	#include "path.h"
33
34	/*
35	* This makes a path absolute outside the world of Crossfire.
36	* In other words, it prepends LIBDIR/MAPDIR/ to the given path
37	* and returns the pointer to a static array containing the result.
38	* it really should be called create_mapname
39	*/
40	const char *
41	create_pathname (const char *name)
42	{
43	static char buf[8192];
44	snprintf (buf, sizeof (buf), "%s/%s/%s", settings.datadir, settings.mapdir, name);
45	return buf;
46	}
47
48	/*
49	* This function checks if a file with the given path exists.
50	* -1 is returned if it fails, otherwise the mode of the file
51	* is returned.
52	* It tries out all the compression suffixes listed in the uncomp[] array.
53	*
54	* If prepend_dir is set, then we call create_pathname (which prepends
55	* libdir & mapdir). Otherwise, we assume the name given is fully
56	* complete.
57	* Only the editor actually cares about the writablity of this -
58	* the rest of the code only cares that the file is readable.
59	* when the editor goes away, the call to stat should probably be
60	* replaced by an access instead (similar to the windows one, but
61	* that seems to be missing the prepend_dir processing
62	*/
63	int
64	check_path (const char *name, int prepend_dir)
65	{
66	char buf[MAX_BUF];
67
68	char *endbuf;
69	struct stat statbuf;
70	int mode = 0;
71
72	if (prepend_dir)
73	assign (buf, create_pathname (name));
74	else
75	assign (buf, name);
76
77	/* old method (strchr(buf, '\0')) seemd very odd to me -
78	* this method should be equivalant and is clearer.
79	* Can not use strcat because we need to cycle through
80	* all the names.
81	*/
82	endbuf = buf + strlen (buf);
83
84	if (stat (buf, &statbuf))
85	return -1;
86	if (!S_ISREG (statbuf.st_mode))
87	return (-1);
88
89	if (((statbuf.st_mode & S_IRGRP) && getegid () == statbuf.st_gid) \|\|
90	((statbuf.st_mode & S_IRUSR) && geteuid () == statbuf.st_uid) \|\| (statbuf.st_mode & S_IROTH))
91	mode \|= 4;
92
93	if ((statbuf.st_mode & S_IWGRP && getegid () == statbuf.st_gid) \|\|
94	(statbuf.st_mode & S_IWUSR && geteuid () == statbuf.st_uid) \|\| (statbuf.st_mode & S_IWOTH))
95	mode \|= 2;
96
97	return (mode);
98	}
99		32
100	/* This rolls up wall, blocks_magic, blocks_view, etc, all into	33	/* This rolls up wall, blocks_magic, blocks_view, etc, all into
101	* one function that just returns a P_.. value (see map.h)	34	* one function that just returns a P_.. value (see map.h)
102	* it will also do map translation for tiled maps, returning	35	* it will also do map translation for tiled maps, returning
103	* new values into newmap, nx, and ny. Any and all of those	36	* new values into newmap, nx, and ny. Any and all of those
174	* let the player through (inventory checkers for example)	107	* let the player through (inventory checkers for example)
175	*/	108	*/
176	if (!(mflags & P_IS_ALIVE) && !OB_TYPE_MOVE_BLOCK (ob, blocked))	109	if (!(mflags & P_IS_ALIVE) && !OB_TYPE_MOVE_BLOCK (ob, blocked))
177	return 0;	110	return 0;
178		111
179	if (ob->head != NULL)
180	ob = ob->head;	112	ob = ob->head_ ();
181		113
182	/* We basically go through the stack of objects, and if there is	114	/* We basically go through the stack of objects, and if there is
183	* some other object that has NO_PASS or FLAG_ALIVE set, return	115	* some other object that has NO_PASS or FLAG_ALIVE set, return
184	* true. If we get through the entire stack, that must mean	116	* true. If we get through the entire stack, that must mean
185	* ob is blocking it, so return 0.	117	* ob is blocking it, so return 0.
…		…
215	else	147	else
216	{	148	{
217	/* Broke apart a big nasty if into several here to make	149	/* Broke apart a big nasty if into several here to make
218	* this more readable. first check - if the space blocks	150	* this more readable. first check - if the space blocks
219	* movement, can't move here.	151	* movement, can't move here.
220	* second - if a monster, can't move there, unles it is a	152	* second - if a monster, can't move there, unless it is a
221	* hidden dm	153	* hidden dm
222	*/	154	*/
223	if (OB_MOVE_BLOCK (ob, tmp))	155	if (OB_MOVE_BLOCK (ob, tmp))
224	return 1;	156	return 1;
225	if (QUERY_FLAG (tmp, FLAG_ALIVE) && tmp->head != ob && tmp != ob &&	157
226	tmp->type != DOOR && !(QUERY_FLAG (tmp, FLAG_WIZ) && tmp->contr->hidden))	158	if (tmp->flag [FLAG_ALIVE]
		159	&& tmp->head_ () != ob
		160	&& tmp != ob
		161	&& tmp->type != DOOR
		162	&& !(tmp->flag [FLAG_WIZ] && tmp->contr->hidden))
227	return 1;	163	return 1;
228	}	164	}
229		165
230	}	166	}
231	return 0;	167	return 0;
…		…
273		209
274	/* don't have object, so don't know what types would block */	210	/* don't have object, so don't know what types would block */
275	return m1->at (sx, sy).move_block;	211	return m1->at (sx, sy).move_block;
276	}	212	}
277		213
278	for (tmp = ob->arch; tmp; tmp = tmp->more)	214	for (tmp = ob->arch; tmp; tmp = (archetype *)tmp->more)
279	{	215	{
280	flag = get_map_flags (m, &m1, x + tmp->clone.x, y + tmp->clone.y, &sx, &sy);	216	flag = get_map_flags (m, &m1, x + tmp->x, y + tmp->y, &sx, &sy);
281		217
282	if (flag & P_OUT_OF_MAP)	218	if (flag & P_OUT_OF_MAP)
283	return P_OUT_OF_MAP;	219	return P_OUT_OF_MAP;
284	if (flag & P_IS_ALIVE)	220	if (flag & P_IS_ALIVE)
285	return P_IS_ALIVE;	221	return P_IS_ALIVE;
…		…
344	}	280	}
345		281
346	/* link_multipart_objects go through all the objects on the map looking	282	/* link_multipart_objects go through all the objects on the map looking
347	* for objects whose arch says they are multipart yet according to the	283	* for objects whose arch says they are multipart yet according to the
348	* info we have, they only have the head (as would be expected when	284	* info we have, they only have the head (as would be expected when
349	* they are saved). We do have to look for the old maps that did save	285	* they are saved).
350	* the more sections and not re-add sections for them.
351	*/	286	*/
352	void	287	void
353	maptile::link_multipart_objects ()	288	maptile::link_multipart_objects ()
354	{	289	{
355	if (!spaces)	290	if (!spaces)
356	return;	291	return;
357		292
358	for (mapspace *ms = spaces + size (); ms-- > spaces; )	293	for (mapspace *ms = spaces + size (); ms-- > spaces; )
359	for (object *tmp = ms->bot; tmp; )	294	{
		295	object *op = ms->bot;
		296	while (op)
360	{	297	{
361	object *above = tmp->above;
362
363	/* already multipart - don't do anything more */	298	/* already multipart - don't do anything more */
364	if (!tmp->head && !tmp->more)	299	if (op->head_ () == op && !op->more && op->arch->more)
365	{
366	/* If there is nothing more to this object, this for loop
367	* won't do anything.
368	*/
369	archetype *at;
370	object last, op;
371	for (at = tmp->arch->more, last = tmp;
372	at;
373	at = at->more, last = op)
374	{	300	{
375	op = arch_to_object (at);	301	op->remove ();
		302	op->expand_tail ();
376		303
377	/* update x,y coordinates */	304	// FIXME: INS_ON_TOP is just a workaround for the pentagram vs.
378	op->x += tmp->x;	305	// multi-tile monster bug, where INS_ABOVE_FLOOR_ONLY put the monsters
379	op->y += tmp->y;	306	// below the pentagrams... hopefully INS_ON_TOP doesn't break anything
380	op->head = tmp;
381	op->map = this;
382	last->more = op;
383	op->name = tmp->name;
384	op->title = tmp->title;
385
386	/* we could link all the parts onto tmp, and then just
387	* call insert_ob_in_map once, but the effect is the same,
388	* as insert_ob_in_map will call itself with each part, and
389	* the coding is simpler to just to it here with each part.
390	*/
391	insert_ob_in_map (op, op->map, tmp, INS_NO_MERGE \| INS_ABOVE_FLOOR_ONLY \| INS_NO_WALK_ON);	307	insert (op, op->x, op->y, 0, INS_NO_MERGE \| INS_ON_TOP \| INS_NO_WALK_ON);
		308
		309	op = ms->bot; // we are mutating the mapspace too much with INS_ON_TOP
		310	// so we have to reset the iteration through the mapspace
392	}	311	}
		312	else
		313	op = op->above;
393	}	314	}
394
395	tmp = above;
396	}	315	}
397	}	316	}
398		317
399	/*	318	/*
400	* Loads (ands parses) the objects into a given map from the specified	319	* Loads (ands parses) the objects into a given map from the specified
401	* file pointer.	320	* file pointer.
…		…
403	bool	322	bool
404	maptile::_load_objects (object_thawer &f)	323	maptile::_load_objects (object_thawer &f)
405	{	324	{
406	for (;;)	325	for (;;)
407	{	326	{
408	coroapi::cede_every (1000); // cede once in a while	327	coroapi::cede_to_tick_every (100); // cede once in a while
409		328
410	switch (f.kw)	329	switch (f.kw)
411	{	330	{
412	case KW_arch:	331	case KW_arch:
413	if (object *op = object::read (f))	332	if (object *op = object::read (f, this))
414	{	333	{
415	if (op->inv)	334	if (op->inv)
416	sum_weight (op);	335	sum_weight (op);
417		336
418	insert_ob_in_map (op, this, op, INS_NO_MERGE \| INS_NO_WALK_ON \| INS_ON_TOP \| INS_MAP_LOAD);	337	insert_ob_in_map (op, this, op, INS_NO_MERGE \| INS_NO_WALK_ON \| INS_ON_TOP \| INS_MAP_LOAD);
…		…
436	}	355	}
437		356
438	void	357	void
439	maptile::activate ()	358	maptile::activate ()
440	{	359	{
441	if (!spaces)	360	if (spaces)
442	return;
443
444	for (mapspace *ms = spaces + size (); ms-- > spaces; )	361	for (mapspace *ms = spaces + size (); ms-- > spaces; )
445	for (object *op = ms->bot; op; op = op->above)	362	for (object *op = ms->bot; op; op = op->above)
446	op->activate_recursive ();	363	op->activate_recursive ();
447	}	364	}
448		365
449	void	366	void
450	maptile::deactivate ()	367	maptile::deactivate ()
451	{	368	{
452	if (!spaces)	369	if (spaces)
453	return;
454
455	for (mapspace *ms = spaces + size (); ms-- > spaces; )	370	for (mapspace *ms = spaces + size (); ms-- > spaces; )
456	for (object *op = ms->bot; op; op = op->above)	371	for (object *op = ms->bot; op; op = op->above)
457	op->deactivate_recursive ();	372	op->deactivate_recursive ();
458	}	373	}
459		374
460	bool	375	bool
461	maptile::_save_objects (object_freezer &f, int flags)	376	maptile::_save_objects (object_freezer &f, int flags)
462	{	377	{
463	static int cede_count = 0;	378	coroapi::cede_to_tick ();
464		379
465	if (flags & IO_HEADER)	380	if (flags & IO_HEADER)
466	_save_header (f);	381	_save_header (f);
467		382
468	if (!spaces)	383	if (!spaces)
469	return false;	384	return false;
470		385
471	for (int i = 0; i < size (); ++i)	386	for (int i = 0; i < size (); ++i)
472	{	387	{
473	#if 0 // temporarily disabled for improved(?) stability, schmorp #TODO#d#//D
474	if (cede_count >= 500)
475	{
476	cede_count = 0;
477	coroapi::cede ();
478	}
479	#endif
480
481	int unique = 0;	388	bool unique = 0;
		389
482	for (object *op = spaces [i].bot; op; op = op->above)	390	for (object *op = spaces [i].bot; op; op = op->above)
483	{	391	{
484	// count per-object, but cede only when modification-safe
485	cede_count++;
486
487	if (op->flag [FLAG_UNIQUE] && op->flag [FLAG_IS_FLOOR])	392	unique \|= op->flag [FLAG_UNIQUE] && op->flag [FLAG_IS_FLOOR];
488	unique = 1;
489		393
490	if (!op->can_map_save ())	394	if (expect_false (!op->can_map_save ()))
491	continue;	395	continue;
492		396
493	if (unique \|\| op->flag [FLAG_UNIQUE])	397	if (expect_false (unique \|\| op->flag [FLAG_UNIQUE]))
494	{	398	{
495	if (flags & IO_UNIQUES)	399	if (flags & IO_UNIQUES)
496	op->write (f);	400	op->write (f);
497	}	401	}
498	else if (flags & IO_OBJECTS)	402	else if (expect_true (flags & IO_OBJECTS))
499	op->write (f);	403	op->write (f);
500	}	404	}
501	}	405	}
		406
		407	coroapi::cede_to_tick ();
502		408
503	return true;	409	return true;
504	}	410	}
505		411
506	bool	412	bool
…		…
705	bool	611	bool
706	maptile::_load_header (object_thawer &thawer)	612	maptile::_load_header (object_thawer &thawer)
707	{	613	{
708	for (;;)	614	for (;;)
709	{	615	{
710	keyword kw = thawer.get_kv ();	616	thawer.next ();
711		617
712	switch (kw)	618	switch (thawer.kw)
713	{	619	{
714	case KW_msg:	620	case KW_msg:
715	thawer.get_ml (KW_endmsg, msg);	621	thawer.get_ml (KW_endmsg, msg);
716	break;	622	break;
717		623
…		…
749	case KW_winddir: thawer.get (winddir); break;	655	case KW_winddir: thawer.get (winddir); break;
750	case KW_sky: thawer.get (sky); break;	656	case KW_sky: thawer.get (sky); break;
751		657
752	case KW_per_player: thawer.get (per_player); break;	658	case KW_per_player: thawer.get (per_player); break;
753	case KW_per_party: thawer.get (per_party); break;	659	case KW_per_party: thawer.get (per_party); break;
		660	case KW_no_reset: thawer.get (no_reset); break;
754		661
755	case KW_region: default_region = region::find (thawer.get_str ()); break;	662	case KW_region: default_region = region::find (thawer.get_str ()); break;
756	case KW_shopitems: shopitems = parse_shop_string (thawer.get_str ()); break;	663	case KW_shopitems: shopitems = parse_shop_string (thawer.get_str ()); break;
757		664
758	// old names new names	665	// old names new names
…		…
769	case KW_tile_path_1: thawer.get (tile_path [0]); break;	676	case KW_tile_path_1: thawer.get (tile_path [0]); break;
770	case KW_tile_path_2: thawer.get (tile_path [1]); break;	677	case KW_tile_path_2: thawer.get (tile_path [1]); break;
771	case KW_tile_path_3: thawer.get (tile_path [2]); break;	678	case KW_tile_path_3: thawer.get (tile_path [2]); break;
772	case KW_tile_path_4: thawer.get (tile_path [3]); break;	679	case KW_tile_path_4: thawer.get (tile_path [3]); break;
773		680
		681	case KW_ERROR:
		682	set_key (thawer.kw_str, thawer.value);
		683	break;
		684
774	case KW_end:	685	case KW_end:
775	return true;	686	return true;
776		687
777	default:	688	default:
778	if (!thawer.parse_error ("map", 0))	689	if (!thawer.parse_error ("map", 0))
…		…
811	object *above = op->above;	722	object *above = op->above;
812		723
813	if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE))	724	if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE))
814	unique = 1;	725	unique = 1;
815		726
816	if (op->head == NULL && (QUERY_FLAG (op, FLAG_UNIQUE) \|\| unique))	727	if (op->head_ () == op && (QUERY_FLAG (op, FLAG_UNIQUE) \|\| unique))
817	{	728	{
818	op->destroy_inv (false);	729	op->destroy_inv (false);
819	op->destroy ();	730	op->destroy ();
820	}	731	}
821		732
…		…
835	if (name) MAP_OUT (name);	746	if (name) MAP_OUT (name);
836	MAP_OUT (swap_time);	747	MAP_OUT (swap_time);
837	MAP_OUT (reset_time);	748	MAP_OUT (reset_time);
838	MAP_OUT (reset_timeout);	749	MAP_OUT (reset_timeout);
839	MAP_OUT (fixed_resettime);	750	MAP_OUT (fixed_resettime);
		751	MAP_OUT (no_reset);
840	MAP_OUT (difficulty);	752	MAP_OUT (difficulty);
841		753
842	if (default_region) MAP_OUT2 (region, default_region->name);	754	if (default_region) MAP_OUT2 (region, default_region->name);
843		755
844	if (shopitems)	756	if (shopitems)
…		…
898	* Remove and free all objects in the given map.	810	* Remove and free all objects in the given map.
899	*/	811	*/
900	void	812	void
901	maptile::clear ()	813	maptile::clear ()
902	{	814	{
903	sfree (regions, size ()), regions = 0;	815	sfree (regions, size ()); regions = 0;
904	free (regionmap), regionmap = 0;	816	delete [] regionmap; regionmap = 0;
905		817
906	if (spaces)	818	if (spaces)
907	{	819	{
908	for (mapspace *ms = spaces + size (); ms-- > spaces; )	820	for (mapspace *ms = spaces + size (); ms-- > spaces; )
909	while (object *op = ms->bot)	821	while (object *op = ms->bot)
910	{	822	{
911	if (op->head)
912	op = op->head;	823	op = op->head_ ();
913
914	op->destroy_inv (false);	824	op->destroy_inv (false);
915	op->destroy ();	825	op->destroy ();
916	}	826	}
917		827
918	sfree (spaces, size ()), spaces = 0;	828	sfree (spaces, size ()), spaces = 0;
…		…
957	maptile::do_destroy ()	867	maptile::do_destroy ()
958	{	868	{
959	attachable::do_destroy ();	869	attachable::do_destroy ();
960		870
961	clear ();	871	clear ();
		872	}
		873
		874	/* decay and destroy perishable items in a map */
		875	void
		876	maptile::do_decay_objects ()
		877	{
		878	if (!spaces)
		879	return;
		880
		881	for (mapspace *ms = spaces + size (); ms-- > spaces; )
		882	for (object above, op = ms->bot; op; op = above)
		883	{
		884	above = op->above;
		885
		886	bool destroy = 0;
		887
		888	// do not decay anything above unique floor tiles (yet :)
		889	if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE))
		890	break;
		891
		892	if (QUERY_FLAG (op, FLAG_IS_FLOOR)
		893	\|\| QUERY_FLAG (op, FLAG_OBJ_ORIGINAL)
		894	\|\| QUERY_FLAG (op, FLAG_OBJ_SAVE_ON_OVL)
		895	\|\| QUERY_FLAG (op, FLAG_UNIQUE)
		896	\|\| QUERY_FLAG (op, FLAG_OVERLAY_FLOOR)
		897	\|\| QUERY_FLAG (op, FLAG_UNPAID)
		898	\|\| op->is_alive ())
		899	; // do not decay
		900	else if (op->is_weapon ())
		901	{
		902	op->stats.dam--;
		903	if (op->stats.dam < 0)
		904	destroy = 1;
		905	}
		906	else if (op->is_armor ())
		907	{
		908	op->stats.ac--;
		909	if (op->stats.ac < 0)
		910	destroy = 1;
		911	}
		912	else if (op->type == FOOD)
		913	{
		914	op->stats.food -= rndm (5, 20);
		915	if (op->stats.food < 0)
		916	destroy = 1;
		917	}
		918	else
		919	{
		920	int mat = op->materials;
		921
		922	if (mat & M_PAPER
		923	\|\| mat & M_LEATHER
		924	\|\| mat & M_WOOD
		925	\|\| mat & M_ORGANIC
		926	\|\| mat & M_CLOTH
		927	\|\| mat & M_LIQUID
		928	\|\| (mat & M_IRON && rndm (1, 5) == 1)
		929	\|\| (mat & M_GLASS && rndm (1, 2) == 1)
		930	\|\| ((mat & M_STONE \|\| mat & M_ADAMANT) && rndm (1, 10) == 1)
		931	\|\| ((mat & M_SOFT_METAL \|\| mat & M_BONE) && rndm (1, 3) == 1)
		932	\|\| (mat & M_ICE && temp > 32))
		933	destroy = 1;
		934	}
		935
		936	/* adjust overall chance below */
		937	if (destroy && rndm (0, 1))
		938	op->destroy ();
		939	}
962	}	940	}
963		941
964	/*	942	/*
965	* Updates every button on the map (by calling update_button() for them).	943	* Updates every button on the map (by calling update_button() for them).
966	*/	944	*/
…		…
1014	if (QUERY_FLAG (op, FLAG_GENERATOR))	992	if (QUERY_FLAG (op, FLAG_GENERATOR))
1015	{	993	{
1016	total_exp += op->stats.exp;	994	total_exp += op->stats.exp;
1017		995
1018	if (archetype *at = type_to_archetype (GENERATE_TYPE (op)))	996	if (archetype *at = type_to_archetype (GENERATE_TYPE (op)))
1019	total_exp += at->clone.stats.exp * 8;	997	total_exp += at->stats.exp * 8;
1020		998
1021	monster_cnt++;	999	monster_cnt++;
1022	}	1000	}
1023	}	1001	}
1024		1002
…		…
1079	void	1057	void
1080	mapspace::update_ ()	1058	mapspace::update_ ()
1081	{	1059	{
1082	object tmp, last = 0;	1060	object tmp, last = 0;
1083	uint8 flags = P_UPTODATE, light = 0, anywhere = 0;	1061	uint8 flags = P_UPTODATE, light = 0, anywhere = 0;
1084	facetile top, floor, *middle;
1085	object top_obj, floor_obj, *middle_obj;
1086	MoveType move_block = 0, move_slow = 0, move_on = 0, move_off = 0, move_allow = 0;	1062	MoveType move_block = 0, move_slow = 0, move_on = 0, move_off = 0, move_allow = 0;
1087		1063
1088	middle = blank_face;	1064	//object *middle = 0;
1089	top = blank_face;	1065	//object *top = 0;
1090	floor = blank_face;	1066	//object *floor = 0;
1091		1067	// this seems to generate better code than using locals, above
1092	middle_obj = 0;	1068	object *&top = faces_obj[0] = 0;
1093	top_obj = 0;	1069	object *&middle = faces_obj[1] = 0;
1094	floor_obj = 0;	1070	object *&floor = faces_obj[2] = 0;
1095		1071
1096	for (tmp = bot; tmp; last = tmp, tmp = tmp->above)	1072	for (tmp = bot; tmp; last = tmp, tmp = tmp->above)
1097	{	1073	{
1098	/* This could be made additive I guess (two lights better than	1074	/* This could be made additive I guess (two lights better than
1099	* one). But if so, it shouldn't be a simple additive - 2	1075	* one). But if so, it shouldn't be a simple additive - 2
…		…
1112	* Always put the player down for drawing.	1088	* Always put the player down for drawing.
1113	*/	1089	*/
1114	if (!tmp->invisible)	1090	if (!tmp->invisible)
1115	{	1091	{
1116	if ((tmp->type == PLAYER \|\| QUERY_FLAG (tmp, FLAG_MONSTER)))	1092	if ((tmp->type == PLAYER \|\| QUERY_FLAG (tmp, FLAG_MONSTER)))
1117	{
1118	top = tmp->face;
1119	top_obj = tmp;	1093	top = tmp;
1120	}
1121	else if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))	1094	else if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
1122	{	1095	{
1123	/* If we got a floor, that means middle and top were below it,	1096	/* If we got a floor, that means middle and top were below it,
1124	* so should not be visible, so we clear them.	1097	* so should not be visible, so we clear them.
1125	*/	1098	*/
1126	middle = blank_face;	1099	middle = 0;
1127	top = blank_face;	1100	top = 0;
1128	floor = tmp->face;
1129	floor_obj = tmp;	1101	floor = tmp;
1130	}	1102	}
1131	/* Flag anywhere have high priority */	1103	/* Flag anywhere have high priority */
1132	else if (QUERY_FLAG (tmp, FLAG_SEE_ANYWHERE))	1104	else if (QUERY_FLAG (tmp, FLAG_SEE_ANYWHERE))
1133	{	1105	{
1134	middle = tmp->face;
1135
1136	middle_obj = tmp;	1106	middle = tmp;
1137	anywhere = 1;	1107	anywhere = 1;
1138	}	1108	}
1139	/* Find the highest visible face around. If equal	1109	/* Find the highest visible face around. If equal
1140	* visibilities, we still want the one nearer to the	1110	* visibilities, we still want the one nearer to the
1141	* top	1111	* top
1142	*/	1112	*/
1143	else if (middle == blank_face \|\| (tmp->face->visibility > middle->visibility && !anywhere))	1113	else if (!middle \|\| (::faces [tmp->face].visibility > ::faces [middle->face].visibility && !anywhere))
1144	{
1145	middle = tmp->face;
1146	middle_obj = tmp;	1114	middle = tmp;
1147	}
1148	}	1115	}
1149		1116
1150	if (tmp == tmp->above)	1117	if (tmp == tmp->above)
1151	{	1118	{
1152	LOG (llevError, "Error in structure of map\n");	1119	LOG (llevError, "Error in structure of map\n");
…		…
1187	* middle face. This should not happen, as we already have the	1154	* middle face. This should not happen, as we already have the
1188	* else statement above so middle should not get set. OTOH, it	1155	* else statement above so middle should not get set. OTOH, it
1189	* may be possible for the faces to match but be different objects.	1156	* may be possible for the faces to match but be different objects.
1190	*/	1157	*/
1191	if (top == middle)	1158	if (top == middle)
1192	middle = blank_face;	1159	middle = 0;
1193		1160
1194	/* There are three posibilities at this point:	1161	/* There are three posibilities at this point:
1195	* 1) top face is set, need middle to be set.	1162	* 1) top face is set, need middle to be set.
1196	* 2) middle is set, need to set top.	1163	* 2) middle is set, need to set top.
1197	* 3) neither middle or top is set - need to set both.	1164	* 3) neither middle or top is set - need to set both.
…		…
1202	/* Once we get to a floor, stop, since we already have a floor object */	1169	/* Once we get to a floor, stop, since we already have a floor object */
1203	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))	1170	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))
1204	break;	1171	break;
1205		1172
1206	/* If two top faces are already set, quit processing */	1173	/* If two top faces are already set, quit processing */
1207	if ((top != blank_face) && (middle != blank_face))	1174	if (top && middle)
1208	break;	1175	break;
1209		1176
1210	/* Only show visible faces */	1177	/* Only show visible faces */
1211	if (!tmp->invisible)	1178	if (!tmp->invisible)
1212	{	1179	{
1213	/* Fill in top if needed */	1180	/* Fill in top if needed */
1214	if (top == blank_face)	1181	if (!top)
1215	{	1182	{
1216	top = tmp->face;
1217	top_obj = tmp;	1183	top = tmp;
1218	if (top == middle)	1184	if (top == middle)
1219	middle = blank_face;	1185	middle = 0;
1220	}	1186	}
1221	else	1187	else
1222	{	1188	{
1223	/* top is already set - we should only get here if	1189	/* top is already set - we should only get here if
1224	* middle is not set	1190	* middle is not set
1225	*	1191	*
1226	* Set the middle face and break out, since there is nothing	1192	* Set the middle face and break out, since there is nothing
1227	* more to fill in. We don't check visiblity here, since	1193	* more to fill in. We don't check visiblity here, since
1228	*	1194	*
1229	*/	1195	*/
1230	if (tmp->face != top)	1196	if (tmp != top)
1231	{	1197	{
1232	middle = tmp->face;
1233	middle_obj = tmp;	1198	middle = tmp;
1234	break;	1199	break;
1235	}	1200	}
1236	}	1201	}
1237	}	1202	}
1238	}	1203	}
1239		1204
1240	if (middle == floor)	1205	if (middle == floor)
1241	middle = blank_face;	1206	middle = 0;
1242		1207
1243	if (top == middle)	1208	if (top == middle)
1244	middle = blank_face;	1209	middle = 0;
1245		1210
1246	faces [0] = top; faces_obj [0] = top != blank_face ? top_obj : 0;	1211	#if 0
1247	faces [1] = middle; faces_obj [1] = middle != blank_face ? middle_obj : 0;	1212	faces_obj [0] = top;
1248	faces [2] = floor; faces_obj [2] = floor != blank_face ? floor_obj : 0;	1213	faces_obj [1] = middle;
		1214	faces_obj [2] = floor;
		1215	#endif
1249	}	1216	}
1250		1217
1251	uint64	1218	uint64
1252	mapspace::volume () const	1219	mapspace::volume () const
1253	{	1220	{
…		…
1257	vol += op->volume ();	1224	vol += op->volume ();
1258		1225
1259	return vol;	1226	return vol;
1260	}	1227	}
1261		1228
1262	/* this updates the orig_map->tile_map[tile_num] value after finding	1229	bool
1263	* the map. It also takes care of linking back the freshly found	1230	maptile::tile_available (int dir, bool load)
1264	* maps tile_map values if it tiles back to this one. It returns
1265	* the value of orig_map->tile_map[tile_num].
1266	*/
1267	static inline maptile *
1268	find_and_link (maptile *orig_map, int tile_num)
1269	{	1231	{
1270	maptile *mp = orig_map->tile_map [tile_num];	1232	if (!tile_path[dir])
		1233	return 0;
1271		1234
1272	if (!mp)	1235	if (tile_map[dir] && (!load \|\| tile_map[dir]->in_memory == MAP_IN_MEMORY))
1273	{	1236	return 1;
1274	mp = orig_map->find_sync (orig_map->tile_path [tile_num], orig_map);
1275		1237
1276	if (!mp)	1238	if ((tile_map[dir] = find_async (tile_path[dir], this, load)))
1277	{	1239	return 1;
1278	// emergency mode, manufacture a dummy map, this creates a memleak, but thats fine
1279	LOG (llevError, "FATAL: cannot load tiled map %s from %s, leaking memory and worse!\n",
1280	&orig_map->tile_path[tile_num], &orig_map->path);
1281	mp = new maptile (1, 1);
1282	mp->alloc ();
1283	mp->in_memory = MAP_IN_MEMORY;
1284	}
1285	}
1286		1240
1287	int dest_tile = (tile_num + 2) % 4;
1288
1289	orig_map->tile_map [tile_num] = mp;
1290
1291	// optimisation: back-link map to origin map if euclidean
1292	//TODO: non-euclidean maps MUST GO
1293	if (orig_map->tile_map[tile_num]->tile_path[dest_tile] == orig_map->path)
1294	orig_map->tile_map[tile_num]->tile_map[dest_tile] = orig_map;
1295
1296	return mp;	1241	return 0;
1297	}
1298
1299	static inline void
1300	load_and_link (maptile *orig_map, int tile_num)
1301	{
1302	find_and_link (orig_map, tile_num)->load_sync ();
1303	}	1242	}
1304		1243
1305	/* this returns TRUE if the coordinates (x,y) are out of	1244	/* this returns TRUE if the coordinates (x,y) are out of
1306	* map m. This function also takes into account any	1245	* map m. This function also takes into account any
1307	* tiling considerations, loading adjacant maps as needed.	1246	* tiling considerations, loading adjacant maps as needed.
…		…
1320	if (!m)	1259	if (!m)
1321	return 0;	1260	return 0;
1322		1261
1323	if (x < 0)	1262	if (x < 0)
1324	{	1263	{
1325	if (!m->tile_path[3])	1264	if (!m->tile_available (3))
1326	return 1;	1265	return 1;
1327		1266
1328	if (!m->tile_map[3] \|\| m->tile_map[3]->in_memory != MAP_IN_MEMORY)
1329	find_and_link (m, 3);
1330
1331	return out_of_map (m->tile_map[3], x + m->tile_map[3]->width, y);	1267	return out_of_map (m->tile_map[3], x + m->tile_map[3]->width, y);
1332	}	1268	}
1333		1269
1334	if (x >= m->width)	1270	if (x >= m->width)
1335	{	1271	{
1336	if (!m->tile_path[1])	1272	if (!m->tile_available (1))
1337	return 1;	1273	return 1;
1338		1274
1339	if (!m->tile_map[1] \|\| m->tile_map[1]->in_memory != MAP_IN_MEMORY)
1340	find_and_link (m, 1);
1341
1342	return out_of_map (m->tile_map[1], x - m->width, y);	1275	return out_of_map (m->tile_map[1], x - m->width, y);
1343	}	1276	}
1344		1277
1345	if (y < 0)	1278	if (y < 0)
1346	{	1279	{
1347	if (!m->tile_path[0])	1280	if (!m->tile_available (0))
1348	return 1;	1281	return 1;
1349		1282
1350	if (!m->tile_map[0] \|\| m->tile_map[0]->in_memory != MAP_IN_MEMORY)
1351	find_and_link (m, 0);
1352
1353	return out_of_map (m->tile_map[0], x, y + m->tile_map[0]->height);	1283	return out_of_map (m->tile_map[0], x, y + m->tile_map[0]->height);
1354	}	1284	}
1355		1285
1356	if (y >= m->height)	1286	if (y >= m->height)
1357	{	1287	{
1358	if (!m->tile_path[2])	1288	if (!m->tile_available (2))
1359	return 1;	1289	return 1;
1360
1361	if (!m->tile_map[2] \|\| m->tile_map[2]->in_memory != MAP_IN_MEMORY)
1362	find_and_link (m, 2);
1363		1290
1364	return out_of_map (m->tile_map[2], x, y - m->height);	1291	return out_of_map (m->tile_map[2], x, y - m->height);
1365	}	1292	}
1366		1293
1367	/* Simple case - coordinates are within this local	1294	/* Simple case - coordinates are within this local
…		…
1381	maptile *	1308	maptile *
1382	maptile::xy_find (sint16 &x, sint16 &y)	1309	maptile::xy_find (sint16 &x, sint16 &y)
1383	{	1310	{
1384	if (x < 0)	1311	if (x < 0)
1385	{	1312	{
1386	if (!tile_path[3])	1313	if (!tile_available (3))
1387	return 0;	1314	return 0;
1388		1315
1389	find_and_link (this, 3);
1390	x += tile_map[3]->width;	1316	x += tile_map[3]->width;
1391	return tile_map[3]->xy_find (x, y);	1317	return tile_map[3]->xy_find (x, y);
1392	}	1318	}
1393		1319
1394	if (x >= width)	1320	if (x >= width)
1395	{	1321	{
1396	if (!tile_path[1])	1322	if (!tile_available (1))
1397	return 0;	1323	return 0;
1398		1324
1399	find_and_link (this, 1);
1400	x -= width;	1325	x -= width;
1401	return tile_map[1]->xy_find (x, y);	1326	return tile_map[1]->xy_find (x, y);
1402	}	1327	}
1403		1328
1404	if (y < 0)	1329	if (y < 0)
1405	{	1330	{
1406	if (!tile_path[0])	1331	if (!tile_available (0))
1407	return 0;	1332	return 0;
1408		1333
1409	find_and_link (this, 0);
1410	y += tile_map[0]->height;	1334	y += tile_map[0]->height;
1411	return tile_map[0]->xy_find (x, y);	1335	return tile_map[0]->xy_find (x, y);
1412	}	1336	}
1413		1337
1414	if (y >= height)	1338	if (y >= height)
1415	{	1339	{
1416	if (!tile_path[2])	1340	if (!tile_available (2))
1417	return 0;	1341	return 0;
1418		1342
1419	find_and_link (this, 2);
1420	y -= height;	1343	y -= height;
1421	return tile_map[2]->xy_find (x, y);	1344	return tile_map[2]->xy_find (x, y);
1422	}	1345	}
1423		1346
1424	/* Simple case - coordinates are within this local	1347	/* Simple case - coordinates are within this local
…		…
1435	adjacent_map (const maptile map1, const maptile map2, int dx, int dy)	1358	adjacent_map (const maptile map1, const maptile map2, int dx, int dy)
1436	{	1359	{
1437	if (!map1 \|\| !map2)	1360	if (!map1 \|\| !map2)
1438	return 0;	1361	return 0;
1439		1362
1440	//TODO: this doesn't actually check corretcly when intermediate maps are not loaded	1363	//TODO: this doesn't actually check correctly when intermediate maps are not loaded
1441	//fix: compare paths instead (this is likely faster, too!)	1364	//fix: compare paths instead (this is likely faster, too!)
1442	if (map1 == map2)	1365	if (map1 == map2)
1443	{	1366	{
1444	*dx = 0;	1367	*dx = 0;
1445	*dy = 0;	1368	*dy = 0;
…		…
1673	return default_region;	1596	return default_region;
1674		1597
1675	return ::region::default_region ();	1598	return ::region::default_region ();
1676	}	1599	}
1677		1600
		1601	/* picks a random object from a style map.
		1602	* Redone by MSW so it should be faster and not use static
		1603	* variables to generate tables.
		1604	*/
		1605	object *
		1606	maptile::pick_random_object () const
		1607	{
		1608	/* while returning a null object will result in a crash, that
		1609	* is actually preferable to an infinite loop. That is because
		1610	* most servers will automatically restart in case of crash.
		1611	* Change the logic on getting the random space - shouldn't make
		1612	* any difference, but this seems clearer to me.
		1613	*/
		1614	for (int i = 1000; --i;)
		1615	{
		1616	object *pick = at (rndm (width), rndm (height)).bot;
1678		1617
		1618	// do not prefer big monsters just because they are big.
		1619	if (pick && pick->head_ () == pick)
		1620	return pick->head_ ();
		1621	}
		1622
		1623	// instead of crashing in the unlikely(?) case, try to return something
		1624	return get_archetype ("blocked");
		1625	}
		1626
		1627	void
		1628	maptile::play_sound (faceidx sound, int x, int y) const
		1629	{
		1630	if (!sound)
		1631	return;
		1632
		1633	for_all_players (pl)
		1634	if (pl->ob->map == this)
		1635	if (client *ns = pl->ns)
		1636	{
		1637	int dx = x - pl->ob->x;
		1638	int dy = y - pl->ob->y;
		1639
		1640	int distance = idistance (dx, dy);
		1641
		1642	if (distance <= MAX_SOUND_DISTANCE)
		1643	ns->play_sound (sound, dx, dy);
		1644	}
		1645	}
		1646

Diff Legend

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

Comparing deliantra/server/common/map.C (file contents): Revision 1.88 by root, Fri Feb 16 19:43:40 2007 UTC vs. Revision 1.121 by root, Sat Aug 25 22:19:26 2007 UTC

Diff Legend

Comparing deliantra/server/common/map.C (file contents):
Revision 1.88 by root, Fri Feb 16 19:43:40 2007 UTC vs.
Revision 1.121 by root, Sat Aug 25 22:19:26 2007 UTC