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

Comparing deliantra/server/common/map.C (file contents):
Revision 1.181 by root, Sat Jan 16 13:41:37 2010 UTC vs.
Revision 1.200 by root, Fri May 7 19:46:18 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,2010 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.
77	/* Make sure the coordinates are valid - they should be, as caller should	77	/* Make sure the coordinates are valid - they should be, as caller should
78	* have already checked this.	78	* have already checked this.
79	*/	79	*/
80	if (OUT_OF_REAL_MAP (m, sx, sy))	80	if (OUT_OF_REAL_MAP (m, sx, sy))
81	{	81	{
82	LOG (llevError, "blocked_link: Passed map, x, y coordinates outside of map\n");	82	LOG (llevError \| logBacktrace, "blocked_link: Passed map, x, y coordinates outside of map\n");
83	return 1;	83	return 1;
84	}	84	}
85		85
86	mapspace &ms = m->at (sx, sy);	86	mapspace &ms = m->at (sx, sy);
87		87
…		…
90		90
91	/* If space is currently not blocked by anything, no need to	91	/* If space is currently not blocked by anything, no need to
92	* go further. Not true for players - all sorts of special	92	* go further. Not true for players - all sorts of special
93	* things we need to do for players.	93	* things we need to do for players.
94	*/	94	*/
95	if (ob->type != PLAYER && !(mflags & P_IS_ALIVE) && (blocked == 0))	95	if (ob->type != PLAYER && !(mflags & P_IS_ALIVE) && blocked == 0)
96	return 0;	96	return 0;
97		97
98	/* if there isn't anything alive on this space, and this space isn't	98	/* if there isn't anything alive on this space, and this space isn't
99	* otherwise blocked, we can return now. Only if there is a living	99	* otherwise blocked, we can return now. Only if there is a living
100	* creature do we need to investigate if it is part of this creature	100	* creature do we need to investigate if it is part of this creature
…		…
110	/* 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
111	* 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
112	* true. If we get through the entire stack, that must mean	112	* true. If we get through the entire stack, that must mean
113	* ob is blocking it, so return 0.	113	* ob is blocking it, so return 0.
114	*/	114	*/
115	for (object *tmp = ms.bot; tmp; tmp = tmp->above)	115	for (object *tmp = ms.top; tmp; tmp = tmp->below)
116	{	116	{
117	if (OB_MOVE_BLOCK (ob, tmp))	117	if (OB_MOVE_BLOCK (ob, tmp))
118	{	118	{
119	if (INVOKE_OBJECT (BLOCKED_MOVE, tmp, ob))	119	if (INVOKE_OBJECT (BLOCKED_MOVE, tmp, ob))
120	if (RESULT_INT (0))	120	if (RESULT_INT (0))
…		…
144	return 1; // unconditional block	144	return 1; // unconditional block
145		145
146	} else {	146	} else {
147	// space does not block the ob, directly, but	147	// space does not block the ob, directly, but
148	// anything alive that is not a door still	148	// anything alive that is not a door still
149	// blocks anything but wizards.	149	// blocks anything
150		150
151	if (tmp->flag [FLAG_ALIVE]	151	if (tmp->flag [FLAG_ALIVE]
152	&& tmp->head_ () != ob
153	&& tmp != ob
154	&& tmp->type != DOOR)	152	&& tmp->type != DOOR
		153	&& tmp->head_ () != ob) //TODO: maybe move these check up?
155	return 1;	154	return 1;
156	}	155	}
157	}	156	}
158		157
159	return 0;	158	return 0;
160	}	159	}
161		160
162	/*	161	/*
163	* 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
164	* 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,
165	* just calling get_map_blocked and checking that against movement type	164	* just calling get_map_blocked and checking that against movement type
166	* 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
167	* object and makes sure they can be inserted.	166	* object and makes sure they can be inserted.
168	*	167	*
…		…
312	case KW_arch:	311	case KW_arch:
313	if (object *op = object::read (f, this))	312	if (object *op = object::read (f, this))
314	{	313	{
315	// TODO: why?	314	// TODO: why?
316	if (op->inv)	315	if (op->inv)
		316	{
		317	op->carrying = 0;
317	op->update_weight ();	318	op->update_weight ();
		319	}
318		320
319	if (IN_RANGE_EXC (op->x, 0, width) && IN_RANGE_EXC (op->y, 0, height))	321	if (IN_RANGE_EXC (op->x, 0, width) && IN_RANGE_EXC (op->y, 0, height))
320	{	322	{
321	// we insert manually because	323	// we insert manually because
322	// a) its way faster	324	// a) its way faster
…		…
422	return false;	424	return false;
423		425
424	return freezer.save (path);	426	return freezer.save (path);
425	}	427	}
426		428
427	maptile::maptile ()	429	void
		430	maptile::init ()
428	{	431	{
429	in_memory = MAP_SWAPPED;	432	in_memory = MAP_SWAPPED;
430		433
431	/* The maps used to pick up default x and y values from the	434	/* The maps used to pick up default x and y values from the
432	* map archetype. Mimic that behaviour.	435	* map archetype. Mimic that behaviour.
433	*/	436	*/
434	width = 16;	437	width = 16;
435	height = 16;	438	height = 16;
436	timeout = 300;	439	timeout = 300;
437	max_items = MAX_ITEM_PER_ACTION;	440	max_items = MAX_ITEM_PER_ACTION;
438	max_volume = 2000000; // 2m³	441	max_volume = 2000000; // 2m³
439	}
440
441	maptile::maptile (int w, int h)
442	{
443	in_memory = MAP_SWAPPED;
444
445	width = w;
446	height = h;
447	reset_timeout = 0;	442	reset_timeout = 0;
448	timeout = 300;
449	enter_x = 0;	443	enter_x = 0;
450	enter_y = 0;	444	enter_y = 0;
		445	}
		446
		447	maptile::maptile ()
		448	{
		449	init ();
		450	}
		451
		452	maptile::maptile (int w, int h)
		453	{
		454	init ();
		455
		456	width = w;
		457	height = h;
451		458
452	alloc ();	459	alloc ();
453	}	460	}
454		461
455	/*	462	/*
…		…
555	* the map (or something equivilent) into output_string. */	562	* the map (or something equivilent) into output_string. */
556	static const char *	563	static const char *
557	print_shop_string (maptile *m)	564	print_shop_string (maptile *m)
558	{	565	{
559	static dynbuf_text buf; buf.clear ();	566	static dynbuf_text buf; buf.clear ();
		567	bool first = true;
560		568
561	for (int i = 0; i < m->shopitems[0].index; i++)	569	for (int i = 0; i < m->shopitems[0].index; i++)
562	{	570	{
		571	if (!first)
		572	buf << ';';
		573
		574	first = false;
		575
563	if (m->shopitems[i].typenum)	576	if (m->shopitems[i].typenum)
564	{	577	{
565	if (m->shopitems[i].strength)	578	if (m->shopitems[i].strength)
566	buf.printf ("%s:%d;", m->shopitems[i].name, m->shopitems[i].strength);	579	buf.printf ("%s:%d", m->shopitems[i].name, m->shopitems[i].strength);
567	else	580	else
568	buf.printf ("%s;", m->shopitems[i].name);	581	buf.printf ("%s", m->shopitems[i].name);
569	}	582	}
570	else	583	else
571	{	584	{
572	if (m->shopitems[i].strength)	585	if (m->shopitems[i].strength)
573	buf.printf ("*:%d;", m->shopitems[i].strength);	586	buf.printf ("*:%d", m->shopitems[i].strength);
574	else	587	else
575	buf.printf ("*");	588	buf.printf ("*");
576	}	589	}
577	}	590	}
578		591
…		…
634	case KW_per_player: thawer.get (per_player); break;	647	case KW_per_player: thawer.get (per_player); break;
635	case KW_per_party: thawer.get (per_party); break;	648	case KW_per_party: thawer.get (per_party); break;
636	case KW_no_reset: thawer.get (no_reset); break;	649	case KW_no_reset: thawer.get (no_reset); break;
637	case KW_no_drop: thawer.get (no_drop); break;	650	case KW_no_drop: thawer.get (no_drop); break;
638		651
639	case KW_region: default_region = region::find (thawer.get_str ()); break;	652	case KW_region: thawer.get (default_region); break;
640	case KW_shopitems: shopitems = parse_shop_string (thawer.get_str ()); break;	653	case KW_shopitems: shopitems = parse_shop_string (thawer.get_str ()); break;
641		654
642	// old names new names	655	// old names new names
643	case KW_hp: case KW_enter_x: thawer.get (enter_x); break;	656	case KW_hp: case KW_enter_x: thawer.get (enter_x); break;
644	case KW_sp: case KW_enter_y: thawer.get (enter_y); break;	657	case KW_sp: case KW_enter_y: thawer.get (enter_y); break;
…		…
662	case KW_end:	675	case KW_end:
663	thawer.next ();	676	thawer.next ();
664	return true;	677	return true;
665		678
666	default:	679	default:
667	if (!thawer.parse_error ("map", 0))	680	if (!thawer.parse_error ("map"))
668	return false;	681	return false;
669	break;	682	break;
670	}	683	}
671		684
672	thawer.next ();	685	thawer.next ();
…		…
690	int unique = 0;	703	int unique = 0;
691	for (object *op = spaces [i].bot; op; )	704	for (object *op = spaces [i].bot; op; )
692	{	705	{
693	object *above = op->above;	706	object *above = op->above;
694		707
695	if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE))	708	if (op->flag [FLAG_IS_FLOOR] && op->flag [FLAG_UNIQUE])
696	unique = 1;	709	unique = 1;
697		710
698	if (op->head_ () == op && (QUERY_FLAG (op, FLAG_UNIQUE) \|\| unique))	711	if (op->head_ () == op && (op->flag [FLAG_UNIQUE] \|\| unique))
699	op->destroy ();	712	op->destroy ();
700		713
701	op = above;	714	op = above;
702	}	715	}
703	}	716	}
…		…
854	for (object above, op = ms->bot; op; op = above)	867	for (object above, op = ms->bot; op; op = above)
855	{	868	{
856	above = op->above;	869	above = op->above;
857		870
858	// do not decay anything above unique floor tiles (yet :)	871	// do not decay anything above unique floor tiles (yet :)
859	if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE))	872	if (op->flag [FLAG_IS_FLOOR] && op->flag [FLAG_UNIQUE])
860	break;	873	break;
861		874
862	bool destroy = 0;	875	bool destroy = 0;
863		876
864	if (QUERY_FLAG (op, FLAG_IS_FLOOR)	877	if (op->flag [FLAG_IS_FLOOR]
865	\|\| QUERY_FLAG (op, FLAG_OBJ_ORIGINAL)	878	\|\| op->flag [FLAG_OBJ_ORIGINAL]
866	\|\| QUERY_FLAG (op, FLAG_UNIQUE)	879	\|\| op->flag [FLAG_UNIQUE]
867	\|\| QUERY_FLAG (op, FLAG_OVERLAY_FLOOR)	880	\|\| op->flag [FLAG_OVERLAY_FLOOR]
868	\|\| QUERY_FLAG (op, FLAG_UNPAID)	881	\|\| op->flag [FLAG_UNPAID]
869	\|\| op->is_alive ())	882	\|\| op->is_alive ())
870	; // do not decay	883	; // do not decay
871	else if (op->is_weapon ())	884	else if (op->is_weapon ())
872	{	885	{
873	op->stats.dam--;	886	op->stats.dam--;
…		…
929	sint64 total_exp = 0;	942	sint64 total_exp = 0;
930		943
931	for (mapspace *ms = spaces + size (); ms-- > spaces; )	944	for (mapspace *ms = spaces + size (); ms-- > spaces; )
932	for (object *op = ms->bot; op; op = op->above)	945	for (object *op = ms->bot; op; op = op->above)
933	{	946	{
934	if (QUERY_FLAG (op, FLAG_MONSTER))	947	if (op->flag [FLAG_MONSTER])
935	{	948	{
936	total_exp += op->stats.exp;	949	total_exp += op->stats.exp;
937	monster_cnt++;	950	monster_cnt++;
938	}	951	}
939		952
940	if (QUERY_FLAG (op, FLAG_GENERATOR))	953	if (op->flag [FLAG_GENERATOR])
941	{	954	{
942	total_exp += op->stats.exp;	955	total_exp += op->stats.exp;
943		956
944	if (archetype *at = op->other_arch)	957	if (archetype *at = op->other_arch)
945	{	958	{
…		…
1127	*/	1140	*/
1128		1141
1129	for (object *tmp = last; tmp; tmp = tmp->below)	1142	for (object *tmp = last; tmp; tmp = tmp->below)
1130	{	1143	{
1131	/* Once we get to a floor, stop, since we already have a floor object */	1144	/* Once we get to a floor, stop, since we already have a floor object */
1132	if (QUERY_FLAG (tmp, FLAG_IS_FLOOR))	1145	if (tmp->flag [FLAG_IS_FLOOR])
1133	break;	1146	break;
1134		1147
1135	/* If two top faces are already set, quit processing */	1148	/* If two top faces are already set, quit processing */
1136	if (top && middle)	1149	if (top && middle)
1137	break;	1150	break;
…		…
1304	/**	1317	/**
1305	* Return whether map2 is adjacent to map1. If so, store the distance from	1318	* Return whether map2 is adjacent to map1. If so, store the distance from
1306	* map1 to map2 in dx/dy.	1319	* map1 to map2 in dx/dy.
1307	*/	1320	*/
1308	int	1321	int
1309	adjacent_map (const maptile map1, const maptile map2, int dx, int dy)	1322	adjacent_map (maptile map1, maptile map2, int dx, int dy)
1310	{	1323	{
1311	if (!map1 \|\| !map2)	1324	if (!map1 \|\| !map2)
1312	return 0;	1325	return 0;
1313		1326
1314	//TODO: this doesn't actually check correctly when intermediate maps are not loaded	1327	//TODO: this doesn't actually check correctly when intermediate maps are not loaded
…		…
1316	if (map1 == map2)	1329	if (map1 == map2)
1317	{	1330	{
1318	*dx = 0;	1331	*dx = 0;
1319	*dy = 0;	1332	*dy = 0;
1320	}	1333	}
1321	else if (map1->tile_map[0] == map2)	1334	else if (map1->tile_available (0, false) == map2)
1322	{ /* up */	1335	{ /* up */
1323	*dx = 0;	1336	*dx = 0;
1324	*dy = -map2->height;	1337	*dy = -map2->height;
1325	}	1338	}
1326	else if (map1->tile_map[1] == map2)	1339	else if (map1->tile_available (1, false) == map2)
1327	{ /* right */	1340	{ /* right */
1328	*dx = map1->width;	1341	*dx = map1->width;
1329	*dy = 0;	1342	*dy = 0;
1330	}	1343	}
1331	else if (map1->tile_map[2] == map2)	1344	else if (map1->tile_available (2, false) == map2)
1332	{ /* down */	1345	{ /* down */
1333	*dx = 0;	1346	*dx = 0;
1334	*dy = map1->height;	1347	*dy = map1->height;
1335	}	1348	}
1336	else if (map1->tile_map[3] == map2)	1349	else if (map1->tile_available (3, false) == map2)
1337	{ /* left */	1350	{ /* left */
1338	*dx = -map2->width;	1351	*dx = -map2->width;
1339	*dy = 0;	1352	*dy = 0;
1340	}	1353	}
1341	else if (map1->tile_map[0] && map1->tile_map[0]->tile_map[1] == map2)	1354	else if (map1->tile_map[0] && map1->tile_map[0]->tile_available (1, false) == map2)
1342	{ /* up right */	1355	{ /* up right */
1343	*dx = map1->tile_map[0]->width;	1356	*dx = map1->tile_map[0]->width;
1344	*dy = -map1->tile_map[0]->height;	1357	*dy = -map1->tile_map[0]->height;
1345	}	1358	}
1346	else if (map1->tile_map[0] && map1->tile_map[0]->tile_map[3] == map2)	1359	else if (map1->tile_map[0] && map1->tile_map[0]->tile_available (3, false) == map2)
1347	{ /* up left */	1360	{ /* up left */
1348	*dx = -map2->width;	1361	*dx = -map2->width;
1349	*dy = -map1->tile_map[0]->height;	1362	*dy = -map1->tile_map[0]->height;
1350	}	1363	}
1351	else if (map1->tile_map[1] && map1->tile_map[1]->tile_map[0] == map2)	1364	else if (map1->tile_map[1] && map1->tile_map[1]->tile_available (0, false) == map2)
1352	{ /* right up */	1365	{ /* right up */
1353	*dx = map1->width;	1366	*dx = map1->width;
1354	*dy = -map2->height;	1367	*dy = -map2->height;
1355	}	1368	}
1356	else if (map1->tile_map[1] && map1->tile_map[1]->tile_map[2] == map2)	1369	else if (map1->tile_map[1] && map1->tile_map[1]->tile_available (2, false) == map2)
1357	{ /* right down */	1370	{ /* right down */
1358	*dx = map1->width;	1371	*dx = map1->width;
1359	*dy = map1->tile_map[1]->height;	1372	*dy = map1->tile_map[1]->height;
1360	}	1373	}
1361	else if (map1->tile_map[2] && map1->tile_map[2]->tile_map[1] == map2)	1374	else if (map1->tile_map[2] && map1->tile_map[2]->tile_available (1, false) == map2)
1362	{ /* down right */	1375	{ /* down right */
1363	*dx = map1->tile_map[2]->width;	1376	*dx = map1->tile_map[2]->width;
1364	*dy = map1->height;	1377	*dy = map1->height;
1365	}	1378	}
1366	else if (map1->tile_map[2] && map1->tile_map[2]->tile_map[3] == map2)	1379	else if (map1->tile_map[2] && map1->tile_map[2]->tile_available (3, false) == map2)
1367	{ /* down left */	1380	{ /* down left */
1368	*dx = -map2->width;	1381	*dx = -map2->width;
1369	*dy = map1->height;	1382	*dy = map1->height;
1370	}	1383	}
1371	else if (map1->tile_map[3] && map1->tile_map[3]->tile_map[0] == map2)	1384	else if (map1->tile_map[3] && map1->tile_map[3]->tile_available (0, false) == map2)
1372	{ /* left up */	1385	{ /* left up */
1373	*dx = -map1->tile_map[3]->width;	1386	*dx = -map1->tile_map[3]->width;
1374	*dy = -map2->height;	1387	*dy = -map2->height;
1375	}	1388	}
1376	else if (map1->tile_map[3] && map1->tile_map[3]->tile_map[2] == map2)	1389	else if (map1->tile_map[3] && map1->tile_map[3]->tile_available (2, false) == map2)
1377	{ /* left down */	1390	{ /* left down */
1378	*dx = -map1->tile_map[3]->width;	1391	*dx = -map1->tile_map[3]->width;
1379	*dy = map1->tile_map[3]->height;	1392	*dy = map1->tile_map[3]->height;
1380	}	1393	}
1381	else	1394	else
…		…
1420	*	1433	*
1421	* currently, the only flag supported (0x1) is don't translate for	1434	* currently, the only flag supported (0x1) is don't translate for
1422	* closest body part of 'op1'	1435	* closest body part of 'op1'
1423	*/	1436	*/
1424	void	1437	void
1425	get_rangevector (object op1, object op2, rv_vector * retval, int flags)	1438	get_rangevector (object op1, object op2, rv_vector *retval, int flags)
1426	{	1439	{
1427	if (!adjacent_map (op1->map, op2->map, &retval->distance_x, &retval->distance_y))	1440	if (!adjacent_map (op1->map, op2->map, &retval->distance_x, &retval->distance_y))
1428	{	1441	{
1429	/* be conservative and fill in _some_ data */	1442	/* be conservative and fill in _some_ data */
1430	retval->distance = 10000;	1443	retval->distance = 10000;
1431	retval->distance_x = 10000;	1444	retval->distance_x = 10000;
1432	retval->distance_y = 10000;	1445	retval->distance_y = 10000;
1433	retval->direction = 0;	1446	retval->direction = 0;
1434	retval->part = 0;	1447	retval->part = 0;
1435	}	1448	}
1436	else	1449	else
1437	{	1450	{
1438	object *best;
1439
1440	retval->distance_x += op2->x - op1->x;	1451	retval->distance_x += op2->x - op1->x;
1441	retval->distance_y += op2->y - op1->y;	1452	retval->distance_y += op2->y - op1->y;
1442		1453
1443	best = op1;	1454	object *best = op1;
		1455
1444	/* If this is multipart, find the closest part now */	1456	/* If this is multipart, find the closest part now */
1445	if (!(flags & 0x1) && op1->more)	1457	if (!(flags & 1) && op1->more)
1446	{	1458	{
1447	int best_distance = retval->distance_x * retval->distance_x + retval->distance_y * retval->distance_y, tmpi;	1459	int best_distance = idistance (retval->distance_x, retval->distance_y);
1448		1460
1449	/* we just take the offset of the piece to head to figure	1461	/* we just take the offset of the piece to head to figure
1450	* distance instead of doing all that work above again	1462	* distance instead of doing all that work above again
1451	* since the distance fields we set above are positive in the	1463	* since the distance fields we set above are positive in the
1452	* same axis as is used for multipart objects, the simply arithmetic	1464	* same axis as is used for multipart objects, the simply arithmetic
1453	* below works.	1465	* below works.
1454	*/	1466	*/
1455	for (object *tmp = op1->more; tmp; tmp = tmp->more)	1467	for (object *tmp = op1->more; tmp; tmp = tmp->more)
1456	{	1468	{
1457	tmpi = (op1->x - tmp->x + retval->distance_x) * (op1->x - tmp->x + retval->distance_x) +	1469	int tmpi = idistance (op1->x - tmp->x + retval->distance_x, op1->y - tmp->y + retval->distance_y);
1458	(op1->y - tmp->y + retval->distance_y) * (op1->y - tmp->y + retval->distance_y);	1470
1459	if (tmpi < best_distance)	1471	if (tmpi < best_distance)
1460	{	1472	{
1461	best_distance = tmpi;	1473	best_distance = tmpi;
1462	best = tmp;	1474	best = tmp;
1463	}	1475	}
1464	}	1476	}
1465		1477
1466	if (best != op1)	1478	if (best != op1)
1467	{	1479	{
1468	retval->distance_x += op1->x - best->x;	1480	retval->distance_x += op1->x - best->x;
1469	retval->distance_y += op1->y - best->y;	1481	retval->distance_y += op1->y - best->y;
1470	}	1482	}
1471	}	1483	}
1472		1484
1473	retval->part = best;	1485	retval->part = best;
1474	retval->distance = upos_max (abs (retval->distance_x), abs (retval->distance_y));	1486	retval->distance = upos_max (abs (retval->distance_x), abs (retval->distance_y));
1475	retval->direction = find_dir_2 (-retval->distance_x, -retval->distance_y);	1487	retval->direction = find_dir_2 (retval->distance_x, retval->distance_y);
1476	}	1488	}
1477	}	1489	}
1478		1490
1479	/* this is basically the same as get_rangevector above, but instead of	1491	/* this is basically the same as get_rangevector above, but instead of
1480	* the first parameter being an object, it instead is the map	1492	* the first parameter being an object, it instead is the map
…		…
1485	* be more consistant with the above function and also in case they are needed	1497	* be more consistant with the above function and also in case they are needed
1486	* for something in the future. Also, since no object is pasted, the best	1498	* for something in the future. Also, since no object is pasted, the best
1487	* field of the rv_vector is set to NULL.	1499	* field of the rv_vector is set to NULL.
1488	*/	1500	*/
1489	void	1501	void
1490	get_rangevector_from_mapcoord (const maptile m, int x, int y, const object op2, rv_vector *retval, int flags)	1502	get_rangevector_from_mapcoord (maptile m, int x, int y, const object op2, rv_vector *retval, int flags)
1491	{	1503	{
1492	if (!adjacent_map (m, op2->map, &retval->distance_x, &retval->distance_y))	1504	if (!adjacent_map (m, op2->map, &retval->distance_x, &retval->distance_y))
1493	{	1505	{
1494	/* be conservative and fill in _some_ data */	1506	/* be conservative and fill in _some_ data */
1495	retval->distance = 100000;	1507	retval->distance = 100000;
1496	retval->distance_x = 32767;	1508	retval->distance_x = 32767;
1497	retval->distance_y = 32767;	1509	retval->distance_y = 32767;
1498	retval->direction = 0;	1510	retval->direction = 0;
1499	retval->part = 0;	1511	retval->part = 0;
1500	}	1512	}
1501	else	1513	else
1502	{	1514	{
1503	retval->distance_x += op2->x - x;	1515	retval->distance_x += op2->x - x;
1504	retval->distance_y += op2->y - y;	1516	retval->distance_y += op2->y - y;
1505		1517
1506	retval->part = 0;	1518	retval->part = 0;
1507	retval->distance = upos_max (abs (retval->distance_x), abs (retval->distance_y));	1519	retval->distance = upos_max (abs (retval->distance_x), abs (retval->distance_y));
1508	retval->direction = find_dir_2 (-retval->distance_x, -retval->distance_y);	1520	retval->direction = find_dir_2 (retval->distance_x, retval->distance_y);
1509	}	1521	}
1510	}	1522	}
1511		1523
1512	/* Returns true of op1 and op2 are effectively on the same map	1524	/* Returns true of op1 and op2 are effectively on the same map
1513	* (as related to map tiling). Note that this looks for a path from	1525	* (as related to map tiling). Note that this looks for a path from
…		…
1563	*/	1575	*/
1564	for (int i = 1000; --i;)	1576	for (int i = 1000; --i;)
1565	{	1577	{
1566	object *pick = at (gen (width), gen (height)).bot;	1578	object *pick = at (gen (width), gen (height)).bot;
1567		1579
1568	// do not prefer big monsters just because they are big.	1580	// must be head: do not prefer big monsters just because they are big.
1569	if (pick && pick->is_head ())	1581	if (pick && pick->is_head ())
1570	return pick->head_ ();	1582	return pick;
1571	}	1583	}
1572		1584
1573	// instead of crashing in the unlikely(?) case, try to return something	1585	// instead of crashing in the unlikely(?) case, try to return something
1574	return archetype::find (shstr_bug);	1586	return archetype::find (shstr_bug);
1575	}	1587	}
…		…
1608		1620
1609	if (distance <= MAX_SOUND_DISTANCE)	1621	if (distance <= MAX_SOUND_DISTANCE)
1610	ns->send_msg (NDI_GREY \| NDI_DEF, SAY_CHANNEL, msg);	1622	ns->send_msg (NDI_GREY \| NDI_DEF, SAY_CHANNEL, msg);
1611	}	1623	}
1612	}	1624	}
		1625
		1626	dynbuf mapwalk_buf (sizeof (maprect) * 25, sizeof (maprect) * 25);
1613		1627
1614	static void	1628	static void
1615	split_to_tiles (dynbuf &buf, maptile *m, int x0, int y0, int x1, int y1, int dx, int dy)	1629	split_to_tiles (dynbuf &buf, maptile *m, int x0, int y0, int x1, int y1, int dx, int dy)
1616	{	1630	{
1617	// clip to map to the left	1631	// clip to map to the left
…		…
1673	r->dx = dx;	1687	r->dx = dx;
1674	r->dy = dy;	1688	r->dy = dy;
1675	}	1689	}
1676		1690
1677	maprect *	1691	maprect *
1678	maptile::split_to_tiles (int x0, int y0, int x1, int y1)	1692	maptile::split_to_tiles (dynbuf &buf, int x0, int y0, int x1, int y1)
1679	{	1693	{
1680	static dynbuf buf (sizeof (maprect) * 8, sizeof (maprect) * 8);
1681	buf.clear ();	1694	buf.clear ();
1682		1695
1683	::split_to_tiles (buf, this, x0, y0, x1, y1, 0, 0);	1696	::split_to_tiles (buf, this, x0, y0, x1, y1, 0, 0);
1684		1697
1685	// add end marker	1698	// add end marker

Diff Legend

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

Comparing deliantra/server/common/map.C (file contents): Revision 1.181 by root, Sat Jan 16 13:41:37 2010 UTC vs. Revision 1.200 by root, Fri May 7 19:46:18 2010 UTC

Diff Legend

Comparing deliantra/server/common/map.C (file contents):
Revision 1.181 by root, Sat Jan 16 13:41:37 2010 UTC vs.
Revision 1.200 by root, Fri May 7 19:46:18 2010 UTC