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

Comparing deliantra/server/common/los.C (file contents):
Revision 1.50 by root, Tue Dec 23 22:04:17 2008 UTC vs.
Revision 1.72 by root, Tue Jan 3 11:25:31 2012 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 Marc Alexander Lehmann / Robin Redeker / the Deliantra team	4	* Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5	* Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
6	* Copyright (©) 1992,2007 Frank Tore Johansen
7	*	5	*
8	* Deliantra is free software: you can redistribute it and/or modify	6	* Deliantra is free software: you can redistribute it and/or modify it under
9	* it under the terms of the GNU General Public License as published by	7	* the terms of the Affero GNU General Public License as published by the
10	* the Free Software Foundation, either version 3 of the License, or	8	* Free Software Foundation, either version 3 of the License, or (at your
11	* (at your option) any later version.	9	* option) any later version.
12	*	10	*
13	* This program is distributed in the hope that it will be useful,	11	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.	14	* GNU General Public License for more details.
17	*	15	*
18	* You should have received a copy of the GNU General Public License	16	* You should have received a copy of the Affero GNU General Public License
19	* along with this program. If not, see <http://www.gnu.org/licenses/>.	17	* and the GNU General Public License along with this program. If not, see
		18	* <http://www.gnu.org/licenses/>.
20	*	19	*
21	* The authors can be reached via e-mail to <support@deliantra.net>	20	* The authors can be reached via e-mail to <support@deliantra.net>
22	*/	21	*/
23		22
24	#include <global.h>	23	#include <global.h>
25	#include <cmath>	24	#include <cmath>
		25
		26	#define SEE_IN_DARK_RADIUS 2
		27	#define MAX_VISION 10 // maximum visible radius
26		28
27	// los flags	29	// los flags
28	enum {	30	enum {
29	FLG_XI = 0x01, // we have an x-parent	31	FLG_XI = 0x01, // we have an x-parent
30	FLG_YI = 0x02, // we have an y-parent	32	FLG_YI = 0x02, // we have an y-parent
31	FLG_BLOCKED = 0x04, // this space blocks the view	33	FLG_BLOCKED = 0x04, // this space blocks the view
32	FLG_QUEUED = 0x80 // already queued in queue, or border	34	FLG_QUEUED = 0x80 // already queued in queue, or border
33	};	35	};
34		36
		37	// it is important for performance reasons that this structure
		38	// has a size easily computable by the cpu (*8 is perfect).
		39	// it is possible to move culled and visible into flags, at
		40	// some speed loss.
35	struct los_info	41	struct los_info
36	{	42	{
37	uint8 flags; // FLG_xxx	43	uint8 flags; // FLG_xxx
38	uint8 culled; // culled from "tree"	44	uint8 culled; // culled from "tree"
39	uint8 visible;	45	uint8 visible;
79		85
80	los_info &l = los[x][y];	86	los_info &l = los[x][y];
81		87
82	l.flags \|= flags;	88	l.flags \|= flags;
83		89
84	if (l.flags & FLG_QUEUED)	90	if (expect_false (l.flags & FLG_QUEUED))
85	return;	91	return;
86		92
87	l.flags \|= FLG_QUEUED;	93	l.flags \|= FLG_QUEUED;
88		94
89	queue[q1].x = dx;	95	queue[q1].x = dx;
…		…
99	// still is basically the same algorithm.	105	// still is basically the same algorithm.
100	static void	106	static void
101	calculate_los (player *pl)	107	calculate_los (player *pl)
102	{	108	{
103	{	109	{
		110	memset (los, 0, sizeof (los));
		111
104	// we keep one line for ourselves, for the border flag	112	// we keep one line for ourselves, for the border flag
105	// so the client area is actually MAP_CLIENT_(X\|Y) - 2	113	// so the client area is actually MAP_CLIENT_(X\|Y) - 2
106	int half_x = min (LOS_X0 - 1, pl->ns->mapx / 2);	114	int half_x = min (LOS_X0 - 1, pl->ns->mapx / 2);
107	int half_y = min (LOS_Y0 - 1, pl->ns->mapy / 2);	115	int half_y = min (LOS_Y0 - 1, pl->ns->mapy / 2);
108		116
…		…
116	los [LOS_X0 + (half_x + 1)][dy + LOS_Y0].flags = FLG_QUEUED;	124	los [LOS_X0 + (half_x + 1)][dy + LOS_Y0].flags = FLG_QUEUED;
117		125
118	// now reset the los area and also add blocked flags	126	// now reset the los area and also add blocked flags
119	// which supposedly is faster than doing it inside the	127	// which supposedly is faster than doing it inside the
120	// spiral path algorithm below, except when very little	128	// spiral path algorithm below, except when very little
121	// area is visible, in which case it is slower, evening	129	// area is visible, in which case it is slower. which evens
122	// out los calculation times between large and small los maps.	130	// out los calculation times between large and small los maps.
123	// apply_lights also iterates over this area, maybe these	131	// apply_lights also iterates over this area, maybe these
124	// two passes could be combined somehow.	132	// two passes could be combined somehow.
125	rectangular_mapspace_iterate_begin (pl->observe, -half_x, half_x, -half_y, half_y)	133	unordered_mapwalk (mapwalk_buf, pl->viewpoint, -half_x, -half_y, half_x, half_y)
		134	{
126	los_info &l = los [LOS_X0 + dx][LOS_Y0 + dy];	135	los_info &l = los [LOS_X0 + dx][LOS_Y0 + dy];
127	l.flags = m && m->at (nx, ny).flags () & P_BLOCKSVIEW ? FLG_BLOCKED : 0;	136	l.flags = m->at (nx, ny).flags () & P_BLOCKSVIEW ? FLG_BLOCKED : 0;
128	rectangular_mapspace_iterate_end	137	}
129	}	138	}
130		139
131	q1 = 0; q2 = 0; // initialise queue, not strictly required	140	q1 = 0; q2 = 0; // initialise queue, not strictly required
132	enqueue (0, 0); // enqueue center	141	enqueue (0, 0); // enqueue center
133		142
…		…
263	if (dy <= 0) enqueue (dx, dy - 1, FLG_YI);	272	if (dy <= 0) enqueue (dx, dy - 1, FLG_YI);
264	}	273	}
265	}	274	}
266	}	275	}
267		276
268	/* returns true if op carries one or more lights
269	* This is a trivial function now days, but it used to
270	* be a bit longer. Probably better for callers to just
271	* check the op->glow_radius instead of calling this.
272	*/
273	int
274	has_carried_lights (const object *op)
275	{
276	/* op may glow! */
277	if (op->glow_radius > 0)
278	return 1;
279
280	return 0;
281	}
282
283	/* radius, distance => lightness adjust */	277	/* radius, distance => lightness adjust */
284	static sint8 light_atten[MAX_LIGHT_RADIUS * 2 + 1][MAX_LIGHT_RADIUS * 3 / 2 + 1];	278	static sint8 light_atten[MAX_LIGHT_RADIUS * 2 + 1][MAX_LIGHT_RADIUS * 3 / 2 + 1];
285	static sint8 vision_atten[MAX_DARKNESS + 1][MAX_DARKNESS * 3 / 2 + 1];	279	static sint8 vision_atten[MAX_VISION + 1][MAX_VISION * 3 / 2 + 1];
286		280
287	static struct los_init	281	static struct los_init
288	{	282	{
289	los_init ()	283	los_init ()
290	{	284	{
…		…
297	{	291	{
298	// max intensity	292	// max intensity
299	int intensity = min (LOS_MAX, abs (radius) + 1);	293	int intensity = min (LOS_MAX, abs (radius) + 1);
300		294
301	// actual intensity	295	// actual intensity
302	intensity = max (0, lerp_rd (distance, 0, abs (radius) + 1, intensity, 0));	296	intensity = max (0, lerp_ru (distance, 0, abs (radius) + 1, intensity, 0));
303		297
304	light_atten [radius + MAX_LIGHT_RADIUS][distance] = radius < 0	298	light_atten [radius + MAX_LIGHT_RADIUS][distance] = radius < 0
305	? min (3, intensity)	299	? min (3, intensity)
306	: LOS_MAX - intensity;	300	: LOS_MAX - intensity;
307	}	301	}
308		302
309	/* for general vision */	303	/* for general vision */
310	for (int radius = 0; radius <= MAX_DARKNESS; ++radius)	304	for (int radius = 0; radius <= MAX_VISION; ++radius)
311	for (int distance = 0; distance <= MAX_DARKNESS * 3 / 2; ++distance)	305	for (int distance = 0; distance <= MAX_VISION * 3 / 2; ++distance)
312	{	306	vision_atten [radius][distance] = distance <= radius ? clamp (lerp (radius, 0, MAX_DARKNESS, 3, 0), 0, 3) : 4;
313	vision_atten [radius][distance] = distance <= radius ? 3 : 4;
314	}
315	}	307	}
316	} los_init;	308	} los_init;
317		309
		310	// the following functions cannot be static, due to c++ stupidity :/
		311	namespace {
		312	// brighten area, ignore los
318	sint8	313	sint8
		314	los_brighten_nolos (sint8 b, sint8 l)
		315	{
		316	return min (b, l);
		317	}
		318
		319	// brighten area, but respect los
		320	sint8
319	los_brighten (sint8 b, sint8 l)	321	los_brighten (sint8 b, sint8 l)
320	{	322	{
321	return b == LOS_BLOCKED ? b : min (b, l);	323	return b == LOS_BLOCKED ? b : min (b, l);
322	}	324	}
323		325
		326	// darken area, respect los
324	sint8	327	sint8
325	los_darken (sint8 b, sint8 l)	328	los_darken (sint8 b, sint8 l)
326	{	329	{
327	return max (b, l);	330	return max (b, l);
328	}	331	}
		332	};
329		333
330	template<sint8 change_it (sint8, sint8)>	334	template<sint8 change_it (sint8, sint8)>
331	static void	335	static void
332	apply_light (player pl, int dx, int dy, int light, const sint8 atten_table)	336	apply_light (player pl, int dx, int dy, int light, const sint8 atten_table)
333	{	337	{
…		…
353	* mark those squares specially.	357	* mark those squares specially.
354	*/	358	*/
355	static void	359	static void
356	apply_lights (player *pl)	360	apply_lights (player *pl)
357	{	361	{
358	object *op = pl->observe;	362	object *op = pl->viewpoint;
359	int darklevel = op->map->darklevel ();	363	int darklevel = op->map->darklevel ();
360
361	/* If the player can see in the dark, lower the darklevel for him */
362	if (op->flag [FLAG_SEE_IN_DARK])
363	darklevel = max (0, darklevel - 2);
364		364
365	int half_x = pl->ns->mapx / 2;	365	int half_x = pl->ns->mapx / 2;
366	int half_y = pl->ns->mapy / 2;	366	int half_y = pl->ns->mapy / 2;
367		367
368	int pass2 = 0; // negative lights have an extra pass	368	int pass2 = 0; // negative lights have an extra pass
		369
		370	maprect *rects = pl->viewpoint->map->split_to_tiles (
		371	mapwalk_buf,
		372	pl->viewpoint->x - half_x - MAX_LIGHT_RADIUS,
		373	pl->viewpoint->y - half_y - MAX_LIGHT_RADIUS,
		374	pl->viewpoint->x + half_x + MAX_LIGHT_RADIUS + 1,
		375	pl->viewpoint->y + half_y + MAX_LIGHT_RADIUS + 1
		376	);
		377
		378	/* If the player can see in the dark, increase light/vision radius */
		379	int bonus = op->flag [FLAG_SEE_IN_DARK] ? SEE_IN_DARK_RADIUS : 0;
369		380
370	if (!darklevel)	381	if (!darklevel)
371	pass2 = 1;	382	pass2 = 1;
372	else	383	else
373	{	384	{
…		…
380	* Only process the area of interest.	391	* Only process the area of interest.
381	* the basex, basey values represent the position in the op->contr->los	392	* the basex, basey values represent the position in the op->contr->los
382	* array. Its easier to just increment them here (and start with the right	393	* array. Its easier to just increment them here (and start with the right
383	* value) than to recalculate them down below.	394	* value) than to recalculate them down below.
384	*/	395	*/
385	rectangular_mapspace_iterate_begin (pl->observe, -half_x - MAX_LIGHT_RADIUS, half_x + MAX_LIGHT_RADIUS, -half_y - MAX_LIGHT_RADIUS, half_y + MAX_LIGHT_RADIUS)	396	for (maprect *r = rects; r->m; ++r)
386	if (m)	397	rect_mapwalk (r, 0, 0)
387	{	398	{
388	mapspace &ms = m->at (nx, ny);	399	mapspace &ms = m->at (nx, ny);
389	ms.update ();	400	ms.update ();
390	sint8 light = ms.light;	401	sint8 light = ms.light;
391		402
392	if (expect_false (light))	403	if (expect_false (light))
393	if (light < 0)	404	if (light < 0)
394	pass2 = 1;	405	pass2 = 1;
395	else	406	else
		407	{
		408	light = clamp (light + bonus, 0, MAX_LIGHT_RADIUS);
396	apply_light<los_brighten> (pl, dx, dy, light, light_atten [light + MAX_LIGHT_RADIUS]);	409	apply_light<los_brighten> (pl, dx - pl->viewpoint->x, dy - pl->viewpoint->y, light, light_atten [light + MAX_LIGHT_RADIUS]);
		410	}
397	}	411	}
398	rectangular_mapspace_iterate_end
399		412
400	/* grant some vision to the player, based on the darklevel */	413	/* grant some vision to the player, based on outside, outdoor, and darklevel */
401	{	414	{
402	int light = clamp (MAX_DARKNESS - darklevel, 0, MAX_DARKNESS);	415	int light;
		416
		417	if (!op->map->outdoor) // not outdoor, darkness becomes light radius
		418	light = MAX_DARKNESS - op->map->darkness;
		419	else if (op->map->darkness > 0) // outdoor and darkness > 0 => use darkness as max radius
		420	light = lerp_rd (maptile::outdoor_darkness + 0, 0, MAX_DARKNESS, MAX_DARKNESS - op->map->darkness, 0);
		421	else // outdoor and darkness <= 0 => start wide and decrease quickly
		422	light = lerp (maptile::outdoor_darkness + op->map->darkness, 0, MAX_DARKNESS, MAX_VISION, 2);
		423
		424	light = clamp (light + bonus, 0, MAX_VISION);
403		425
404	apply_light<los_brighten> (pl, 0, 0, light, vision_atten [light]);	426	apply_light<los_brighten> (pl, 0, 0, light, vision_atten [light]);
405	}	427	}
406	}	428	}
		429
		430	// when we fly high, we have some minimum viewable area around us, like x-ray
		431	if (op->move_type & MOVE_FLY_HIGH)
		432	apply_light<los_brighten_nolos> (pl, 0, 0, 9, vision_atten [9]);
407		433
408	// possibly do 2nd pass for rare negative glow radii	434	// possibly do 2nd pass for rare negative glow radii
409	// for effect, those are always considered to be stronger than anything else	435	// for effect, those are always considered to be stronger than anything else
410	// but they can't darken a place completely	436	// but they can't darken a place completely
411	if (pass2)	437	if (pass2)
412	rectangular_mapspace_iterate_begin (pl->observe, -half_x - MAX_LIGHT_RADIUS, half_x + MAX_LIGHT_RADIUS, -half_y - MAX_LIGHT_RADIUS, half_y + MAX_LIGHT_RADIUS)	438	for (maprect *r = rects; r->m; ++r)
413	if (m)	439	rect_mapwalk (r, 0, 0)
414	{	440	{
415	mapspace &ms = m->at (nx, ny);	441	mapspace &ms = m->at (nx, ny);
416	ms.update ();	442	ms.update ();
417	sint8 light = ms.light;	443	sint8 light = ms.light;
418		444
419	if (expect_false (light < 0))	445	if (expect_false (light < 0))
		446	{
		447	light = clamp (light - bonus, 0, MAX_DARKNESS);
420	apply_light<los_darken> (pl, dx, dy, -light, light_atten [light + MAX_LIGHT_RADIUS]);	448	apply_light<los_darken> (pl, dx - pl->viewpoint->x, dy - pl->viewpoint->y, -light, light_atten [light + MAX_LIGHT_RADIUS]);
		449	}
421	}	450	}
422	rectangular_mapspace_iterate_end
423	}	451	}
424		452
425	/* blinded_sight() - sets all viewable squares to blocked except	453	/* blinded_sight() - sets all viewable squares to blocked except
426	* for the one the central one that the player occupies. A little	454	* for the one the central one that the player occupies. A little
427	* odd that you can see yourself (and what your standing on), but	455	* odd that you can see yourself (and what your standing on), but
…		…
443	if (ob->flag [FLAG_REMOVED])//D really needed?	471	if (ob->flag [FLAG_REMOVED])//D really needed?
444	return;	472	return;
445		473
446	if (ob->flag [FLAG_WIZLOOK])	474	if (ob->flag [FLAG_WIZLOOK])
447	clear_los (0);	475	clear_los (0);
448	else if (observe->flag [FLAG_BLIND]) /* player is blind */	476	else if (viewpoint->flag [FLAG_BLIND]) /* player is blind */
449	{	477	{
450	clear_los ();	478	clear_los ();
451	blinded_sight (this);	479	blinded_sight (this);
452	}	480	}
453	else	481	else
…		…
455	clear_los ();	483	clear_los ();
456	calculate_los (this);	484	calculate_los (this);
457	apply_lights (this);	485	apply_lights (this);
458	}	486	}
459		487
460	if (observe->flag [FLAG_XRAYS])	488	if (viewpoint->flag [FLAG_XRAYS])
461	for (int dx = -2; dx <= 2; dx++)	489	for (int dx = -2; dx <= 2; dx++)
462	for (int dy = -2; dy <= 2; dy++)	490	for (int dy = -2; dy <= 2; dy++)
463	min_it (los[dx + LOS_X0][dy + LOS_Y0], 1);	491	min_it (los[dx + LOS_X0][dy + LOS_Y0], 1);
464	}	492	}
465		493
…		…
504	* check as a safety	532	* check as a safety
505	*/	533	*/
506	if (!pl->ob \|\| !pl->ob->map \|\| !pl->ns)	534	if (!pl->ob \|\| !pl->ob->map \|\| !pl->ns)
507	continue;	535	continue;
508		536
509	/* Same map is simple case - see if pl is close enough.	537	rv_vector rv;
510	* Note in all cases, we did the check for same map first,	538
511	* and then see if the player is close enough and update	539	get_rangevector_from_mapcoord (pl->ob->map, x, y, pl->ob, &rv);
512	* los if that is the case. If the player is on the
513	* corresponding map, but not close enough, then the
514	* player can't be on another map that may be closer,
515	* so by setting it up this way, we trim processing
516	* some.
517	*/	540
518	if (pl->ob->map == map)	541	if ((abs (rv.distance_x) <= pl->ns->mapx / 2) && (abs (rv.distance_y) <= pl->ns->mapy / 2))
519	{
520	if ((abs (pl->ob->x - x) <= pl->ns->mapx / 2) && (abs (pl->ob->y - y) <= pl->ns->mapy / 2))
521	pl->do_los = 1;	542	pl->do_los = 1;
522	}
523
524	/* Now we check to see if player is on adjacent
525	* maps to the one that changed and also within
526	* view. The tile_maps[] could be null, but in that
527	* case it should never match the pl->ob->map, so
528	* we want ever try to dereference any of the data in it.
529	*
530	* The logic for 0 and 3 is to see how far the player is
531	* from the edge of the map (height/width) - pl->ob->(x,y)
532	* and to add current position on this map - that gives a
533	* distance.
534	* For 1 and 2, we check to see how far the given
535	* coordinate (x,y) is from the corresponding edge,
536	* and then add the players location, which gives
537	* a distance.
538	*/
539	else if (pl->ob->map == map->tile_map[0])
540	{
541	if ((abs (pl->ob->x - x) <= pl->ns->mapx / 2) && (abs (y + map->tile_map[0]->height - pl->ob->y) <= pl->ns->mapy / 2))
542	pl->do_los = 1;
543	}
544	else if (pl->ob->map == map->tile_map[2])
545	{
546	if ((abs (pl->ob->x - x) <= pl->ns->mapx / 2) && (abs (pl->ob->y + map->height - y) <= pl->ns->mapy / 2))
547	pl->do_los = 1;
548	}
549	else if (pl->ob->map == map->tile_map[1])
550	{
551	if ((abs (pl->ob->x + map->width - x) <= pl->ns->mapx / 2) && (abs (pl->ob->y - y) <= pl->ns->mapy / 2))
552	pl->do_los = 1;
553	}
554	else if (pl->ob->map == map->tile_map[3])
555	{
556	if ((abs (x + map->tile_map[3]->width - pl->ob->x) <= pl->ns->mapx / 2) && (abs (pl->ob->y - y) <= pl->ns->mapy / 2))
557	pl->do_los = 1;
558	}
559	}	543	}
560	}	544	}
561		545
562	static const int season_darkness[5][HOURS_PER_DAY] = {	546	static const int season_darkness[5][HOURS_PER_DAY] = {
563	/0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 1 2 3 4 5 6 7 8 9 10 11 12 13 /	547	/0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 1 2 3 4 5 6 7 8 9 10 11 12 13 /
…		…
636	if (pl->ob->map == op->map &&	620	if (pl->ob->map == op->map &&
637	pl->ob->y - pl->ns->mapy / 2 <= op->y &&	621	pl->ob->y - pl->ns->mapy / 2 <= op->y &&
638	pl->ob->y + pl->ns->mapy / 2 >= op->y && pl->ob->x - pl->ns->mapx / 2 <= op->x && pl->ob->x + pl->ns->mapx / 2 >= op->x)	622	pl->ob->y + pl->ns->mapy / 2 >= op->y && pl->ob->x - pl->ns->mapx / 2 <= op->x && pl->ob->x + pl->ns->mapx / 2 >= op->x)
639	pl->do_los = 1;	623	pl->do_los = 1;
640	}	624	}
		625

Diff Legend

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

Comparing deliantra/server/common/los.C (file contents): Revision 1.50 by root, Tue Dec 23 22:04:17 2008 UTC vs. Revision 1.72 by root, Tue Jan 3 11:25:31 2012 UTC

Diff Legend

Comparing deliantra/server/common/los.C (file contents):
Revision 1.50 by root, Tue Dec 23 22:04:17 2008 UTC vs.
Revision 1.72 by root, Tue Jan 3 11:25:31 2012 UTC