ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/common/los.C
(Generate patch)

Comparing deliantra/server/common/los.C (file contents):
Revision 1.58 by root, Thu Jan 8 22:35:00 2009 UTC vs.
Revision 1.77 by root, Sat Nov 17 23:40:00 2018 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 (©) 2017,2018 Marc Alexander Lehmann / the Deliantra team
4 * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team 5 * Copyright (©) 2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016 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 * 6 *
8 * Deliantra is free software: you can redistribute it and/or modify 7 * 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 8 * 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 9 * Free Software Foundation, either version 3 of the License, or (at your
11 * (at your option) any later version. 10 * option) any later version.
12 * 11 *
13 * This program is distributed in the hope that it will be useful, 12 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details. 15 * GNU General Public License for more details.
17 * 16 *
18 * You should have received a copy of the GNU General Public License 17 * 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/>. 18 * and the GNU General Public License along with this program. If not, see
19 * <http://www.gnu.org/licenses/>.
20 * 20 *
21 * The authors can be reached via e-mail to <support@deliantra.net> 21 * The authors can be reached via e-mail to <support@deliantra.net>
22 */ 22 */
23 23
24#include <global.h> 24#include <global.h>
25#include <cmath> 25#include <cmath>
… …
33 FLG_YI = 0x02, // we have an y-parent 33 FLG_YI = 0x02, // we have an y-parent
34 FLG_BLOCKED = 0x04, // this space blocks the view 34 FLG_BLOCKED = 0x04, // this space blocks the view
35 FLG_QUEUED = 0x80 // already queued in queue, or border 35 FLG_QUEUED = 0x80 // already queued in queue, or border
36}; 36};
37 37
38// it is important for performance reasons that this structure
39// has a size easily computable by the cpu (*8 is perfect).
40// it is possible to move culled and visible into flags, at
41// some speed loss.
38struct los_info 42struct los_info
39{ 43{
40 uint8 flags; // FLG_xxx 44 uint8 flags; // FLG_xxx
41 uint8 culled; // culled from "tree" 45 uint8 culled; // culled from "tree"
42 uint8 visible; 46 uint8 visible;
… …
48 52
49// temporary storage for the los algorithm, 53// temporary storage for the los algorithm,
50// one los_info for each lightable map space 54// one los_info for each lightable map space
51static los_info los[MAP_CLIENT_X][MAP_CLIENT_Y]; 55static los_info los[MAP_CLIENT_X][MAP_CLIENT_Y];
52 56
53struct point 57struct point8
54{ 58{
55 sint8 x, y; 59 sint8 x, y;
56}; 60};
57 61
58// minimum size, but must be a power of two 62// minimum size, but must be a power of two
59#define QUEUE_LENGTH ((MAP_CLIENT_X + MAP_CLIENT_Y) * 2) 63#define QUEUE_LENGTH ((MAP_CLIENT_X + MAP_CLIENT_Y) * 2)
60 64
61// a queue of spaces to calculate 65// a queue of spaces to calculate
62static point queue [QUEUE_LENGTH]; 66static point8 queue [QUEUE_LENGTH];
63static int q1, q2; // queue start, end 67static int q1, q2; // queue start, end
64 68
65/* 69/*
66 * Clears/initialises the los-array associated to the player 70 * Clears/initialises the los-array associated to the player
67 * controlling the object. 71 * controlling the object.
… …
82 86
83 los_info &l = los[x][y]; 87 los_info &l = los[x][y];
84 88
85 l.flags |= flags; 89 l.flags |= flags;
86 90
87 if (l.flags & FLG_QUEUED) 91 if (expect_false (l.flags & FLG_QUEUED))
88 return; 92 return;
89 93
90 l.flags |= FLG_QUEUED; 94 l.flags |= FLG_QUEUED;
91 95
92 queue[q1].x = dx; 96 queue[q1].x = dx;
… …
125 // spiral path algorithm below, except when very little 129 // spiral path algorithm below, except when very little
126 // area is visible, in which case it is slower. which evens 130 // area is visible, in which case it is slower. which evens
127 // out los calculation times between large and small los maps. 131 // out los calculation times between large and small los maps.
128 // apply_lights also iterates over this area, maybe these 132 // apply_lights also iterates over this area, maybe these
129 // two passes could be combined somehow. 133 // two passes could be combined somehow.
130 unordered_mapwalk (pl->observe, -half_x, -half_y, half_x, half_y) 134 unordered_mapwalk (mapwalk_buf, pl->viewpoint, -half_x, -half_y, half_x, half_y)
131 { 135 {
132 los_info &l = los [LOS_X0 + dx][LOS_Y0 + dy]; 136 los_info &l = los [LOS_X0 + dx][LOS_Y0 + dy];
133 l.flags = m->at (nx, ny).flags () & P_BLOCKSVIEW ? FLG_BLOCKED : 0; 137 l.flags = m->at (nx, ny).flags () & P_BLOCKSVIEW ? FLG_BLOCKED : 0;
134 } 138 }
135 } 139 }
… …
171 l.culled &= !xi->visible; 175 l.culled &= !xi->visible;
172 176
173 /* merge input space */ 177 /* merge input space */
174 if (expect_false (xi->xo || xi->yo)) 178 if (expect_false (xi->xo || xi->yo))
175 { 179 {
176 // The X input can provide two main pieces of information: 180 // The X input can provide two main pieces of information:
177 // 1. Progressive X obscurity. 181 // 1. Progressive X obscurity.
178 // 2. Recessive Y obscurity. 182 // 2. Recessive Y obscurity.
179 183
180 // Progressive X obscurity, favouring recessive input angle 184 // Progressive X obscurity, favouring recessive input angle
181 if (xi->xe > 0 && l.xo == 0) 185 if (xi->xe > 0 && l.xo == 0)
… …
206 l.culled &= !yi->visible; 210 l.culled &= !yi->visible;
207 211
208 /* merge input space */ 212 /* merge input space */
209 if (expect_false (yi->yo || yi->xo)) 213 if (expect_false (yi->yo || yi->xo))
210 { 214 {
211 // The Y input can provide two main pieces of information: 215 // The Y input can provide two main pieces of information:
212 // 1. Progressive Y obscurity. 216 // 1. Progressive Y obscurity.
213 // 2. Recessive X obscurity. 217 // 2. Recessive X obscurity.
214 218
215 // Progressive Y obscurity, favouring recessive input angle 219 // Progressive Y obscurity, favouring recessive input angle
216 if (yi->ye > 0 && l.yo == 0) 220 if (yi->ye > 0 && l.yo == 0)
… …
257 } 261 }
258 262
259 } 263 }
260 264
261 // Expands by the unit length in each component's current direction. 265 // Expands by the unit length in each component's current direction.
262 // If a component has no direction, then it is expanded in both of its 266 // If a component has no direction, then it is expanded in both of its
263 // positive and negative directions. 267 // positive and negative directions.
264 if (!l.culled) 268 if (!l.culled)
265 { 269 {
266 if (dx >= 0) enqueue (dx + 1, dy, FLG_XI); 270 if (dx >= 0) enqueue (dx + 1, dy, FLG_XI);
267 if (dx <= 0) enqueue (dx - 1, dy, FLG_XI); 271 if (dx <= 0) enqueue (dx - 1, dy, FLG_XI);
… …
288 { 292 {
289 // max intensity 293 // max intensity
290 int intensity = min (LOS_MAX, abs (radius) + 1); 294 int intensity = min (LOS_MAX, abs (radius) + 1);
291 295
292 // actual intensity 296 // actual intensity
293 intensity = max (0, lerp_rd (distance, 0, abs (radius) + 1, intensity, 0)); 297 intensity = max (0, lerp_ru (distance, 0, abs (radius) + 1, intensity, 0));
294 298
295 light_atten [radius + MAX_LIGHT_RADIUS][distance] = radius < 0 299 light_atten [radius + MAX_LIGHT_RADIUS][distance] = radius < 0
296 ? min (3, intensity) 300 ? min (3, intensity)
297 : LOS_MAX - intensity; 301 : LOS_MAX - intensity;
298 } 302 }
… …
302 for (int distance = 0; distance <= MAX_VISION * 3 / 2; ++distance) 306 for (int distance = 0; distance <= MAX_VISION * 3 / 2; ++distance)
303 vision_atten [radius][distance] = distance <= radius ? clamp (lerp (radius, 0, MAX_DARKNESS, 3, 0), 0, 3) : 4; 307 vision_atten [radius][distance] = distance <= radius ? clamp (lerp (radius, 0, MAX_DARKNESS, 3, 0), 0, 3) : 4;
304 } 308 }
305} los_init; 309} los_init;
306 310
311// the following functions cannot be static, due to c++ stupidity :/
312namespace {
313 // brighten area, ignore los
307sint8 314 sint8
315 los_brighten_nolos (sint8 b, sint8 l)
316 {
317 return min (b, l);
318 }
319
320 // brighten area, but respect los
321 sint8
308los_brighten (sint8 b, sint8 l) 322 los_brighten (sint8 b, sint8 l)
309{ 323 {
310 return b == LOS_BLOCKED ? b : min (b, l); 324 return b == LOS_BLOCKED ? b : min (b, l);
311} 325 }
312 326
327 // darken area, respect los
313sint8 328 sint8
314los_darken (sint8 b, sint8 l) 329 los_darken (sint8 b, sint8 l)
315{ 330 {
316 return max (b, l); 331 return max (b, l);
317} 332 }
333};
318 334
319template<sint8 change_it (sint8, sint8)> 335template<sint8 change_it (sint8, sint8)>
320static void 336static void
321apply_light (player *pl, int dx, int dy, int light, const sint8 *atten_table) 337apply_light (player *pl, int dx, int dy, int light, const sint8 *atten_table)
322{ 338{
… …
336 for (int ay = ay0; ay <= ay1; ay++) 352 for (int ay = ay0; ay <= ay1; ay++)
337 pl->los[ax][ay] = 353 pl->los[ax][ay] =
338 change_it (pl->los[ax][ay], atten_table [idistance (ax - dx, ay - dy)]); 354 change_it (pl->los[ax][ay], atten_table [idistance (ax - dx, ay - dy)]);
339} 355}
340 356
341/* add light, by finding all (non-null) nearby light sources, then 357/* add light, by finding all (non-null) nearby light sources, then
342 * mark those squares specially. 358 * mark those squares specially.
343 */ 359 */
344static void 360static void
345apply_lights (player *pl) 361apply_lights (player *pl)
346{ 362{
347 object *op = pl->observe; 363 object *op = pl->viewpoint;
348 int darklevel = op->map->darklevel (); 364 int darklevel = op->map->darklevel ();
349 365
350 int half_x = pl->ns->mapx / 2; 366 int half_x = pl->ns->mapx / 2;
351 int half_y = pl->ns->mapy / 2; 367 int half_y = pl->ns->mapy / 2;
352 368
353 int pass2 = 0; // negative lights have an extra pass 369 int pass2 = 0; // negative lights have an extra pass
354 370
355 maprect *rects = pl->observe->map->split_to_tiles ( 371 maprect *rects = pl->viewpoint->map->split_to_tiles (
372 mapwalk_buf,
356 pl->observe->x - half_x - MAX_LIGHT_RADIUS, 373 pl->viewpoint->x - half_x - MAX_LIGHT_RADIUS,
357 pl->observe->y - half_y - MAX_LIGHT_RADIUS, 374 pl->viewpoint->y - half_y - MAX_LIGHT_RADIUS,
358 pl->observe->x + half_x + MAX_LIGHT_RADIUS + 1, 375 pl->viewpoint->x + half_x + MAX_LIGHT_RADIUS + 1,
359 pl->observe->y + half_y + MAX_LIGHT_RADIUS + 1 376 pl->viewpoint->y + half_y + MAX_LIGHT_RADIUS + 1
360 ); 377 );
361 378
362 /* If the player can see in the dark, increase light/vision radius */ 379 /* If the player can see in the dark, increase light/vision radius */
363 int bonus = op->flag [FLAG_SEE_IN_DARK] ? SEE_IN_DARK_RADIUS : 0; 380 int bonus = op->flag [FLAG_SEE_IN_DARK] ? SEE_IN_DARK_RADIUS : 0;
364 381
… …
388 if (light < 0) 405 if (light < 0)
389 pass2 = 1; 406 pass2 = 1;
390 else 407 else
391 { 408 {
392 light = clamp (light + bonus, 0, MAX_LIGHT_RADIUS); 409 light = clamp (light + bonus, 0, MAX_LIGHT_RADIUS);
393 apply_light<los_brighten> (pl, dx - pl->observe->x, dy - pl->observe->y, light, light_atten [light + MAX_LIGHT_RADIUS]); 410 apply_light<los_brighten> (pl, dx - pl->viewpoint->x, dy - pl->viewpoint->y, light, light_atten [light + MAX_LIGHT_RADIUS]);
394 } 411 }
395 } 412 }
396 413
397 /* grant some vision to the player, based on outside, outdoor, and darklevel */ 414 /* grant some vision to the player, based on outside, outdoor, and darklevel */
398 { 415 {
… …
403 else if (op->map->darkness > 0) // outdoor and darkness > 0 => use darkness as max radius 420 else if (op->map->darkness > 0) // outdoor and darkness > 0 => use darkness as max radius
404 light = lerp_rd (maptile::outdoor_darkness + 0, 0, MAX_DARKNESS, MAX_DARKNESS - op->map->darkness, 0); 421 light = lerp_rd (maptile::outdoor_darkness + 0, 0, MAX_DARKNESS, MAX_DARKNESS - op->map->darkness, 0);
405 else // outdoor and darkness <= 0 => start wide and decrease quickly 422 else // outdoor and darkness <= 0 => start wide and decrease quickly
406 light = lerp (maptile::outdoor_darkness + op->map->darkness, 0, MAX_DARKNESS, MAX_VISION, 2); 423 light = lerp (maptile::outdoor_darkness + op->map->darkness, 0, MAX_DARKNESS, MAX_VISION, 2);
407 424
408 light = clamp (light, 0, MAX_VISION); 425 light = clamp (light + bonus, 0, MAX_VISION);
409 426
410 apply_light<los_brighten> (pl, 0, 0, light, vision_atten [light]); 427 apply_light<los_brighten> (pl, 0, 0, light, vision_atten [light]);
411 } 428 }
412 } 429 }
430
431 // when we fly high, we have some minimum viewable area around us, like x-ray
432 if (op->move_type & MOVE_FLY_HIGH)
433 apply_light<los_brighten_nolos> (pl, 0, 0, 9, vision_atten [9]);
413 434
414 // possibly do 2nd pass for rare negative glow radii 435 // possibly do 2nd pass for rare negative glow radii
415 // for effect, those are always considered to be stronger than anything else 436 // for effect, those are always considered to be stronger than anything else
416 // but they can't darken a place completely 437 // but they can't darken a place completely
417 if (pass2) 438 if (pass2)
… …
423 sint8 light = ms.light; 444 sint8 light = ms.light;
424 445
425 if (expect_false (light < 0)) 446 if (expect_false (light < 0))
426 { 447 {
427 light = clamp (light - bonus, 0, MAX_DARKNESS); 448 light = clamp (light - bonus, 0, MAX_DARKNESS);
428 apply_light<los_darken> (pl, dx - pl->observe->x, dy - pl->observe->y, -light, light_atten [light + MAX_LIGHT_RADIUS]); 449 apply_light<los_darken> (pl, dx - pl->viewpoint->x, dy - pl->viewpoint->y, -light, light_atten [light + MAX_LIGHT_RADIUS]);
429 } 450 }
430 } 451 }
431} 452}
432 453
433/* blinded_sight() - sets all viewable squares to blocked except 454/* blinded_sight() - sets all viewable squares to blocked except
434 * for the one the central one that the player occupies. A little 455 * for the one the central one that the player occupies. A little
435 * odd that you can see yourself (and what your standing on), but 456 * odd that you can see yourself (and what your standing on), but
436 * really need for any reasonable game play. 457 * really need for any reasonable game play.
437 */ 458 */
438static void 459static void
… …
451 if (ob->flag [FLAG_REMOVED])//D really needed? 472 if (ob->flag [FLAG_REMOVED])//D really needed?
452 return; 473 return;
453 474
454 if (ob->flag [FLAG_WIZLOOK]) 475 if (ob->flag [FLAG_WIZLOOK])
455 clear_los (0); 476 clear_los (0);
456 else if (observe->flag [FLAG_BLIND]) /* player is blind */ 477 else if (viewpoint->flag [FLAG_BLIND]) /* player is blind */
457 { 478 {
458 clear_los (); 479 clear_los ();
459 blinded_sight (this); 480 blinded_sight (this);
460 } 481 }
461 else 482 else
… …
463 clear_los (); 484 clear_los ();
464 calculate_los (this); 485 calculate_los (this);
465 apply_lights (this); 486 apply_lights (this);
466 } 487 }
467 488
468 if (observe->flag [FLAG_XRAYS]) 489 if (viewpoint->flag [FLAG_XRAYS])
469 for (int dx = -2; dx <= 2; dx++) 490 for (int dx = -2; dx <= 2; dx++)
470 for (int dy = -2; dy <= 2; dy++) 491 for (int dy = -2; dy <= 2; dy++)
471 min_it (los[dx + LOS_X0][dy + LOS_Y0], 1); 492 min_it (los[dx + LOS_X0][dy + LOS_Y0], 1);
472} 493}
473 494
… …
502 * map is the map that changed, x and y are the coordinates. 523 * map is the map that changed, x and y are the coordinates.
503 */ 524 */
504void 525void
505update_all_los (const maptile *map, int x, int y) 526update_all_los (const maptile *map, int x, int y)
506{ 527{
507 // no need to do anything if we don't have darkness
508 if (map->darklevel () <= 0)
509 return;
510
511 map->at (x, y).invalidate (); 528 map->at (x, y).invalidate ();
512 529
513 for_all_players (pl) 530 for_all_players (pl)
514 { 531 {
515 /* Player should not have a null map, but do this 532 /* Player should not have a null map, but do this
516 * check as a safety 533 * check as a safety
517 */ 534 */
518 if (!pl->ob || !pl->ob->map || !pl->ns) 535 if (!pl->ob || !pl->ob->map || !pl->ns)
519 continue; 536 continue;
520 537
521 /* Same map is simple case - see if pl is close enough. 538 rv_vector rv;
522 * Note in all cases, we did the check for same map first, 539
523 * and then see if the player is close enough and update 540 get_rangevector_from_mapcoord (pl->ob->map, x, y, pl->ob, &rv);
524 * los if that is the case. If the player is on the
525 * corresponding map, but not close enough, then the
526 * player can't be on another map that may be closer,
527 * so by setting it up this way, we trim processing
528 * some.
529 */ 541
530 if (pl->ob->map == map) 542 if ((abs (rv.distance_x) <= pl->ns->mapx / 2) && (abs (rv.distance_y) <= pl->ns->mapy / 2))
531 if ((abs (pl->ob->x - x) <= pl->ns->mapx / 2) && (abs (pl->ob->y - y) <= pl->ns->mapy / 2))
532 pl->do_los = 1; 543 pl->do_los = 1;
533
534 /* Now we check to see if player is on adjacent
535 * maps to the one that changed and also within
536 * view. The tile_maps[] could be null, but in that
537 * case it should never match the pl->ob->map, so
538 * we want ever try to dereference any of the data in it.
539 *
540 * The logic for 0 and 3 is to see how far the player is
541 * from the edge of the map (height/width) - pl->ob->(x,y)
542 * and to add current position on this map - that gives a
543 * distance.
544 * For 1 and 2, we check to see how far the given
545 * coordinate (x,y) is from the corresponding edge,
546 * and then add the players location, which gives
547 * a distance.
548 */
549 else if (pl->ob->map == map->tile_map[0])
550 {
551 if ((abs (pl->ob->x - x) <= pl->ns->mapx / 2) && (abs (y + map->tile_map[0]->height - pl->ob->y) <= pl->ns->mapy / 2))
552 pl->do_los = 1;
553 }
554 else if (pl->ob->map == map->tile_map[2])
555 {
556 if ((abs (pl->ob->x - x) <= pl->ns->mapx / 2) && (abs (pl->ob->y + map->height - y) <= pl->ns->mapy / 2))
557 pl->do_los = 1;
558 }
559 else if (pl->ob->map == map->tile_map[1])
560 {
561 if ((abs (pl->ob->x + map->width - x) <= pl->ns->mapx / 2) && (abs (pl->ob->y - y) <= pl->ns->mapy / 2))
562 pl->do_los = 1;
563 }
564 else if (pl->ob->map == map->tile_map[3])
565 {
566 if ((abs (x + map->tile_map[3]->width - pl->ob->x) <= pl->ns->mapx / 2) && (abs (pl->ob->y - y) <= pl->ns->mapy / 2))
567 pl->do_los = 1;
568 }
569 } 544 }
570} 545}
571 546
572static const int season_darkness[5][HOURS_PER_DAY] = { 547static const int season_darkness[5][HOURS_PER_DAY] = {
573 /*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 */ 548 /*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 */

Diff Legend

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