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

Comparing deliantra/server/common/map.C (file contents):
Revision 1.178 by root, Sun Nov 29 09:41:27 2009 UTC vs.
Revision 1.190 by root, Sun Apr 18 05:55:04 2010 UTC

…		…
1	/*	1	/*
2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.	2	* This file is part of Deliantra, the Roguelike Realtime MMORPG.
3	*	3	*
4	* Copyright (©) 2005,2006,2007,2008,2009 Marc Alexander Lehmann / Robin Redeker / the Deliantra team	4	* Copyright (©) 2005,2006,2007,2008,2009,2010 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (©) 2001-2003,2007 Mark Wedel & Crossfire Development Team	5	* Copyright (©) 2001-2003 Mark Wedel & Crossfire Development Team
6	* Copyright (©) 1992,2007 Frank Tore Johansen	6	* Copyright (©) 1992 Frank Tore Johansen
7	*	7	*
8	* Deliantra is free software: you can redistribute it and/or modify it under	8	* Deliantra is free software: you can redistribute it and/or modify it under
9	* the terms of the Affero GNU General Public License as published by the	9	* the terms of the Affero GNU General Public License as published by the
10	* Free Software Foundation, either version 3 of the License, or (at your	10	* Free Software Foundation, either version 3 of the License, or (at your
11	* option) any later version.	11	* option) any later version.
23	*/	23	*/
24		24
25	#include <unistd.h>	25	#include <unistd.h>
26		26
27	#include "global.h"	27	#include "global.h"
28	#include "loader.h"
29	#include "path.h"	28	#include "path.h"
30		29
31	//+GPL	30	//+GPL
32		31
33	sint8 maptile::outdoor_darkness;	32	sint8 maptile::outdoor_darkness;
…		…
111	/* We basically go through the stack of objects, and if there is	110	/* We basically go through the stack of objects, and if there is
112	* some other object that has NO_PASS or FLAG_ALIVE set, return	111	* some other object that has NO_PASS or FLAG_ALIVE set, return
113	* true. If we get through the entire stack, that must mean	112	* true. If we get through the entire stack, that must mean
114	* ob is blocking it, so return 0.	113	* ob is blocking it, so return 0.
115	*/	114	*/
116	for (object *tmp = ms.bot; tmp; tmp = tmp->above)	115	for (object *tmp = ms.top; tmp; tmp = tmp->below)
117	{	116	{
118	if (OB_MOVE_BLOCK (ob, tmp))	117	if (OB_MOVE_BLOCK (ob, tmp))
119	{	118	{
120	if (INVOKE_OBJECT (BLOCKED_MOVE, tmp, ob))	119	if (INVOKE_OBJECT (BLOCKED_MOVE, tmp, ob))
121	if (RESULT_INT (0))	120	if (RESULT_INT (0))
…		…
145	return 1; // unconditional block	144	return 1; // unconditional block
146		145
147	} else {	146	} else {
148	// space does not block the ob, directly, but	147	// space does not block the ob, directly, but
149	// anything alive that is not a door still	148	// anything alive that is not a door still
150	// blocks anything but wizards.	149	// blocks anything
151		150
152	if (tmp->flag [FLAG_ALIVE]	151	if (tmp->flag [FLAG_ALIVE]
153	&& tmp->head_ () != ob
154	&& tmp != ob
155	&& tmp->type != DOOR	152	&& tmp->type != DOOR
156	&& !tmp->flag [FLAG_WIZPASS])	153	&& tmp->head_ () != ob) //TODO: maybe move these check up?
157	return 1;	154	return 1;
158	}	155	}
159	}	156	}
160		157
161	return 0;	158	return 0;
162	}	159	}
163		160
164	/*	161	/*
165	* Returns qthe blocking object if the given object can't fit in the given	162	* Returns the blocking object if the given object can't fit in the given
166	* spot. This is meant for multi space objects - for single space objecs,	163	* spot. This is meant for multi space objects - for single space objecs,
167	* just calling get_map_blocked and checking that against movement type	164	* just calling get_map_blocked and checking that against movement type
168	* of object. This function goes through all the parts of the multipart	165	* of object. This function goes through all the parts of the multipart
169	* object and makes sure they can be inserted.	166	* object and makes sure they can be inserted.
170	*	167	*
…		…
424	return false;	421	return false;
425		422
426	return freezer.save (path);	423	return freezer.save (path);
427	}	424	}
428		425
429	maptile::maptile ()	426	void
		427	maptile::init ()
430	{	428	{
431	in_memory = MAP_SWAPPED;	429	in_memory = MAP_SWAPPED;
432		430
433	/* The maps used to pick up default x and y values from the	431	/* The maps used to pick up default x and y values from the
434	* map archetype. Mimic that behaviour.	432	* map archetype. Mimic that behaviour.
435	*/	433	*/
436	width = 16;	434	width = 16;
437	height = 16;	435	height = 16;
438	timeout = 300;	436	timeout = 300;
439	max_items = MAX_ITEM_PER_ACTION;	437	max_items = MAX_ITEM_PER_ACTION;
440	max_volume = 2000000; // 2m³	438	max_volume = 2000000; // 2m³
441	}
442
443	maptile::maptile (int w, int h)
444	{
445	in_memory = MAP_SWAPPED;
446
447	width = w;
448	height = h;
449	reset_timeout = 0;	439	reset_timeout = 0;
450	timeout = 300;
451	enter_x = 0;	440	enter_x = 0;
452	enter_y = 0;	441	enter_y = 0;
		442	}
		443
		444	maptile::maptile ()
		445	{
		446	init ();
		447	}
		448
		449	maptile::maptile (int w, int h)
		450	{
		451	init ();
		452
		453	width = w;
		454	height = h;
453		455
454	alloc ();	456	alloc ();
455	}	457	}
456		458
457	/*	459	/*
…		…
664	case KW_end:	666	case KW_end:
665	thawer.next ();	667	thawer.next ();
666	return true;	668	return true;
667		669
668	default:	670	default:
669	if (!thawer.parse_error ("map", 0))	671	if (!thawer.parse_error ("map"))
670	return false;	672	return false;
671	break;	673	break;
672	}	674	}
673		675
674	thawer.next ();	676	thawer.next ();
…		…
692	int unique = 0;	694	int unique = 0;
693	for (object *op = spaces [i].bot; op; )	695	for (object *op = spaces [i].bot; op; )
694	{	696	{
695	object *above = op->above;	697	object *above = op->above;
696		698
697	if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE))	699	if (op->flag [FLAG_IS_FLOOR] && op->flag [FLAG_UNIQUE])
698	unique = 1;	700	unique = 1;
699		701
700	if (op->head_ () == op && (QUERY_FLAG (op, FLAG_UNIQUE) \|\| unique))	702	if (op->head_ () == op && (op->flag [FLAG_UNIQUE] \|\| unique))
701	op->destroy ();	703	op->destroy ();
702		704
703	op = above;	705	op = above;
704	}	706	}
705	}	707	}
…		…
855	for (mapspace *ms = spaces + size (); ms-- > spaces; )	857	for (mapspace *ms = spaces + size (); ms-- > spaces; )
856	for (object above, op = ms->bot; op; op = above)	858	for (object above, op = ms->bot; op; op = above)
857	{	859	{
858	above = op->above;	860	above = op->above;
859		861
		862	// do not decay anything above unique floor tiles (yet :)
		863	if (op->flag [FLAG_IS_FLOOR] && op->flag [FLAG_UNIQUE])
		864	break;
		865
860	bool destroy = 0;	866	bool destroy = 0;
861		867
862	// do not decay anything above unique floor tiles (yet :)	868	if (op->flag [FLAG_IS_FLOOR]
863	if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE))	869	\|\| op->flag [FLAG_OBJ_ORIGINAL]
864	break;	870	\|\| op->flag [FLAG_UNIQUE]
865		871	\|\| op->flag [FLAG_OVERLAY_FLOOR]
866	if (QUERY_FLAG (op, FLAG_IS_FLOOR)	872	\|\| op->flag [FLAG_UNPAID]
867	\|\| QUERY_FLAG (op, FLAG_OBJ_ORIGINAL)
868	\|\| QUERY_FLAG (op, FLAG_UNIQUE)
869	\|\| QUERY_FLAG (op, FLAG_OVERLAY_FLOOR)
870	\|\| QUERY_FLAG (op, FLAG_UNPAID)
871	\|\| op->is_alive ())	873	\|\| op->is_alive ())
872	; // do not decay	874	; // do not decay
873	else if (op->is_weapon ())	875	else if (op->is_weapon ())
874	{	876	{
875	op->stats.dam--;	877	op->stats.dam--;
…		…
931	sint64 total_exp = 0;	933	sint64 total_exp = 0;
932		934
933	for (mapspace *ms = spaces + size (); ms-- > spaces; )	935	for (mapspace *ms = spaces + size (); ms-- > spaces; )
934	for (object *op = ms->bot; op; op = op->above)	936	for (object *op = ms->bot; op; op = op->above)
935	{	937	{
936	if (QUERY_FLAG (op, FLAG_MONSTER))	938	if (op->flag [FLAG_MONSTER])
937	{	939	{
938	total_exp += op->stats.exp;	940	total_exp += op->stats.exp;
939	monster_cnt++;	941	monster_cnt++;
940	}	942	}
941		943
942	if (QUERY_FLAG (op, FLAG_GENERATOR))	944	if (op->flag [FLAG_GENERATOR])
943	{	945	{
944	total_exp += op->stats.exp;	946	total_exp += op->stats.exp;
945		947
946	if (archetype *at = op->other_arch)	948	if (archetype *at = op->other_arch)
947	{	949	{
…		…
1129	*/	1131	*/
1130		1132
1131	for (object *tmp = last; tmp; tmp = tmp->below)	1133	for (object *tmp = last; tmp; tmp = tmp->below)
1132	{	1134	{
1133	/* Once we get to a floor, stop, since we already have a floor object */	1135	/* Once we get to a floor, stop, since we already have a floor object */
1134	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))	1136	if (tmp->flag [FLAG_IS_FLOOR])
1135	break;	1137	break;
1136		1138
1137	/* If two top faces are already set, quit processing */	1139	/* If two top faces are already set, quit processing */
1138	if (top && middle)	1140	if (top && middle)
1139	break;	1141	break;
…		…
1422	*	1424	*
1423	* currently, the only flag supported (0x1) is don't translate for	1425	* currently, the only flag supported (0x1) is don't translate for
1424	* closest body part of 'op1'	1426	* closest body part of 'op1'
1425	*/	1427	*/
1426	void	1428	void
1427	get_rangevector (object op1, object op2, rv_vector * retval, int flags)	1429	get_rangevector (object op1, object op2, rv_vector *retval, int flags)
1428	{	1430	{
1429	if (!adjacent_map (op1->map, op2->map, &retval->distance_x, &retval->distance_y))	1431	if (!adjacent_map (op1->map, op2->map, &retval->distance_x, &retval->distance_y))
1430	{	1432	{
1431	/* be conservative and fill in _some_ data */	1433	/* be conservative and fill in _some_ data */
1432	retval->distance = 10000;	1434	retval->distance = 10000;
1433	retval->distance_x = 10000;	1435	retval->distance_x = 10000;
1434	retval->distance_y = 10000;	1436	retval->distance_y = 10000;
1435	retval->direction = 0;	1437	retval->direction = 0;
1436	retval->part = 0;	1438	retval->part = 0;
1437	}	1439	}
1438	else	1440	else
1439	{	1441	{
1440	object *best;
1441
1442	retval->distance_x += op2->x - op1->x;	1442	retval->distance_x += op2->x - op1->x;
1443	retval->distance_y += op2->y - op1->y;	1443	retval->distance_y += op2->y - op1->y;
1444		1444
1445	best = op1;	1445	object *best = op1;
		1446
1446	/* If this is multipart, find the closest part now */	1447	/* If this is multipart, find the closest part now */
1447	if (!(flags & 0x1) && op1->more)	1448	if (!(flags & 1) && op1->more)
1448	{	1449	{
1449	int best_distance = retval->distance_x * retval->distance_x + retval->distance_y * retval->distance_y, tmpi;	1450	int best_distance = retval->distance_x * retval->distance_x + retval->distance_y * retval->distance_y, tmpi;
1450		1451
1451	/* we just take the offset of the piece to head to figure	1452	/* we just take the offset of the piece to head to figure
1452	* distance instead of doing all that work above again	1453	* distance instead of doing all that work above again
…		…
1565	*/	1566	*/
1566	for (int i = 1000; --i;)	1567	for (int i = 1000; --i;)
1567	{	1568	{
1568	object *pick = at (gen (width), gen (height)).bot;	1569	object *pick = at (gen (width), gen (height)).bot;
1569		1570
1570	// do not prefer big monsters just because they are big.	1571	// must be head: do not prefer big monsters just because they are big.
1571	if (pick && pick->is_head ())	1572	if (pick && pick->is_head ())
1572	return pick->head_ ();	1573	return pick;
1573	}	1574	}
1574		1575
1575	// instead of crashing in the unlikely(?) case, try to return something	1576	// instead of crashing in the unlikely(?) case, try to return something
1576	return archetype::find (shstr_bug);	1577	return archetype::find (shstr_bug);
1577	}	1578	}
…		…
1610		1611
1611	if (distance <= MAX_SOUND_DISTANCE)	1612	if (distance <= MAX_SOUND_DISTANCE)
1612	ns->send_msg (NDI_GREY \| NDI_DEF, SAY_CHANNEL, msg);	1613	ns->send_msg (NDI_GREY \| NDI_DEF, SAY_CHANNEL, msg);
1613	}	1614	}
1614	}	1615	}
		1616
		1617	dynbuf mapwalk_buf (sizeof (maprect) * 25, sizeof (maprect) * 25);
1615		1618
1616	static void	1619	static void
1617	split_to_tiles (dynbuf &buf, maptile *m, int x0, int y0, int x1, int y1, int dx, int dy)	1620	split_to_tiles (dynbuf &buf, maptile *m, int x0, int y0, int x1, int y1, int dx, int dy)
1618	{	1621	{
1619	// clip to map to the left	1622	// clip to map to the left
…		…
1675	r->dx = dx;	1678	r->dx = dx;
1676	r->dy = dy;	1679	r->dy = dy;
1677	}	1680	}
1678		1681
1679	maprect *	1682	maprect *
1680	maptile::split_to_tiles (int x0, int y0, int x1, int y1)	1683	maptile::split_to_tiles (dynbuf &buf, int x0, int y0, int x1, int y1)
1681	{	1684	{
1682	static dynbuf buf (sizeof (maprect) * 8, sizeof (maprect) * 8);
1683	buf.clear ();	1685	buf.clear ();
1684		1686
1685	::split_to_tiles (buf, this, x0, y0, x1, y1, 0, 0);	1687	::split_to_tiles (buf, this, x0, y0, x1, y1, 0, 0);
1686		1688
1687	// add end marker	1689	// add end marker

Diff Legend

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

Comparing deliantra/server/common/map.C (file contents): Revision 1.178 by root, Sun Nov 29 09:41:27 2009 UTC vs. Revision 1.190 by root, Sun Apr 18 05:55:04 2010 UTC

Diff Legend

Comparing deliantra/server/common/map.C (file contents):
Revision 1.178 by root, Sun Nov 29 09:41:27 2009 UTC vs.
Revision 1.190 by root, Sun Apr 18 05:55:04 2010 UTC