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.66 by root, Fri Nov 6 13:03:34 2009 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 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>
… …
125 // spiral path algorithm below, except when very little 124 // spiral path algorithm below, except when very little
126 // area is visible, in which case it is slower. which evens 125 // area is visible, in which case it is slower. which evens
127 // out los calculation times between large and small los maps. 126 // out los calculation times between large and small los maps.
128 // apply_lights also iterates over this area, maybe these 127 // apply_lights also iterates over this area, maybe these
129 // two passes could be combined somehow. 128 // two passes could be combined somehow.
130 unordered_mapwalk (pl->observe, -half_x, -half_y, half_x, half_y) 129 unordered_mapwalk (pl->viewpoint, -half_x, -half_y, half_x, half_y)
131 { 130 {
132 los_info &l = los [LOS_X0 + dx][LOS_Y0 + dy]; 131 los_info &l = los [LOS_X0 + dx][LOS_Y0 + dy];
133 l.flags = m->at (nx, ny).flags () & P_BLOCKSVIEW ? FLG_BLOCKED : 0; 132 l.flags = m->at (nx, ny).flags () & P_BLOCKSVIEW ? FLG_BLOCKED : 0;
134 } 133 }
135 } 134 }
… …
288 { 287 {
289 // max intensity 288 // max intensity
290 int intensity = min (LOS_MAX, abs (radius) + 1); 289 int intensity = min (LOS_MAX, abs (radius) + 1);
291 290
292 // actual intensity 291 // actual intensity
293 intensity = max (0, lerp_rd (distance, 0, abs (radius) + 1, intensity, 0)); 292 intensity = max (0, lerp_ru (distance, 0, abs (radius) + 1, intensity, 0));
294 293
295 light_atten [radius + MAX_LIGHT_RADIUS][distance] = radius < 0 294 light_atten [radius + MAX_LIGHT_RADIUS][distance] = radius < 0
296 ? min (3, intensity) 295 ? min (3, intensity)
297 : LOS_MAX - intensity; 296 : LOS_MAX - intensity;
298 } 297 }
… …
302 for (int distance = 0; distance <= MAX_VISION * 3 / 2; ++distance) 301 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; 302 vision_atten [radius][distance] = distance <= radius ? clamp (lerp (radius, 0, MAX_DARKNESS, 3, 0), 0, 3) : 4;
304 } 303 }
305} los_init; 304} los_init;
306 305
306// the following functions cannot be static, due to c++ stupidity :/
307namespace {
308 // brighten area, ignore los
307sint8 309 sint8
310 los_brighten_nolos (sint8 b, sint8 l)
311 {
312 return min (b, l);
313 }
314
315 // brighten area, but respect los
316 sint8
308los_brighten (sint8 b, sint8 l) 317 los_brighten (sint8 b, sint8 l)
309{ 318 {
310 return b == LOS_BLOCKED ? b : min (b, l); 319 return b == LOS_BLOCKED ? b : min (b, l);
311} 320 }
312 321
322 // darken area, respect los
313sint8 323 sint8
314los_darken (sint8 b, sint8 l) 324 los_darken (sint8 b, sint8 l)
315{ 325 {
316 return max (b, l); 326 return max (b, l);
317} 327 }
328};
318 329
319template<sint8 change_it (sint8, sint8)> 330template<sint8 change_it (sint8, sint8)>
320static void 331static void
321apply_light (player *pl, int dx, int dy, int light, const sint8 *atten_table) 332apply_light (player *pl, int dx, int dy, int light, const sint8 *atten_table)
322{ 333{
… …
342 * mark those squares specially. 353 * mark those squares specially.
343 */ 354 */
344static void 355static void
345apply_lights (player *pl) 356apply_lights (player *pl)
346{ 357{
347 object *op = pl->observe; 358 object *op = pl->viewpoint;
348 int darklevel = op->map->darklevel (); 359 int darklevel = op->map->darklevel ();
349 360
350 int half_x = pl->ns->mapx / 2; 361 int half_x = pl->ns->mapx / 2;
351 int half_y = pl->ns->mapy / 2; 362 int half_y = pl->ns->mapy / 2;
352 363
353 int pass2 = 0; // negative lights have an extra pass 364 int pass2 = 0; // negative lights have an extra pass
354 365
355 maprect *rects = pl->observe->map->split_to_tiles ( 366 maprect *rects = pl->viewpoint->map->split_to_tiles (
356 pl->observe->x - half_x - MAX_LIGHT_RADIUS, 367 pl->viewpoint->x - half_x - MAX_LIGHT_RADIUS,
357 pl->observe->y - half_y - MAX_LIGHT_RADIUS, 368 pl->viewpoint->y - half_y - MAX_LIGHT_RADIUS,
358 pl->observe->x + half_x + MAX_LIGHT_RADIUS + 1, 369 pl->viewpoint->x + half_x + MAX_LIGHT_RADIUS + 1,
359 pl->observe->y + half_y + MAX_LIGHT_RADIUS + 1 370 pl->viewpoint->y + half_y + MAX_LIGHT_RADIUS + 1
360 ); 371 );
361 372
362 /* If the player can see in the dark, increase light/vision radius */ 373 /* 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; 374 int bonus = op->flag [FLAG_SEE_IN_DARK] ? SEE_IN_DARK_RADIUS : 0;
364 375
… …
388 if (light < 0) 399 if (light < 0)
389 pass2 = 1; 400 pass2 = 1;
390 else 401 else
391 { 402 {
392 light = clamp (light + bonus, 0, MAX_LIGHT_RADIUS); 403 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]); 404 apply_light<los_brighten> (pl, dx - pl->viewpoint->x, dy - pl->viewpoint->y, light, light_atten [light + MAX_LIGHT_RADIUS]);
394 } 405 }
395 } 406 }
396 407
397 /* grant some vision to the player, based on outside, outdoor, and darklevel */ 408 /* grant some vision to the player, based on outside, outdoor, and darklevel */
398 { 409 {
… …
403 else if (op->map->darkness > 0) // outdoor and darkness > 0 => use darkness as max radius 414 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); 415 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 416 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); 417 light = lerp (maptile::outdoor_darkness + op->map->darkness, 0, MAX_DARKNESS, MAX_VISION, 2);
407 418
408 light = clamp (light, 0, MAX_VISION); 419 light = clamp (light + bonus, 0, MAX_VISION);
409 420
410 apply_light<los_brighten> (pl, 0, 0, light, vision_atten [light]); 421 apply_light<los_brighten> (pl, 0, 0, light, vision_atten [light]);
411 } 422 }
412 } 423 }
424
425 // when we fly high, we have some minimum viewable area around us, like x-ray
426 if (op->move_type & MOVE_FLY_HIGH)
427 apply_light<los_brighten_nolos> (pl, 0, 0, 9, vision_atten [9]);
413 428
414 // possibly do 2nd pass for rare negative glow radii 429 // possibly do 2nd pass for rare negative glow radii
415 // for effect, those are always considered to be stronger than anything else 430 // for effect, those are always considered to be stronger than anything else
416 // but they can't darken a place completely 431 // but they can't darken a place completely
417 if (pass2) 432 if (pass2)
… …
423 sint8 light = ms.light; 438 sint8 light = ms.light;
424 439
425 if (expect_false (light < 0)) 440 if (expect_false (light < 0))
426 { 441 {
427 light = clamp (light - bonus, 0, MAX_DARKNESS); 442 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]); 443 apply_light<los_darken> (pl, dx - pl->viewpoint->x, dy - pl->viewpoint->y, -light, light_atten [light + MAX_LIGHT_RADIUS]);
429 } 444 }
430 } 445 }
431} 446}
432 447
433/* blinded_sight() - sets all viewable squares to blocked except 448/* blinded_sight() - sets all viewable squares to blocked except
… …
451 if (ob->flag [FLAG_REMOVED])//D really needed? 466 if (ob->flag [FLAG_REMOVED])//D really needed?
452 return; 467 return;
453 468
454 if (ob->flag [FLAG_WIZLOOK]) 469 if (ob->flag [FLAG_WIZLOOK])
455 clear_los (0); 470 clear_los (0);
456 else if (observe->flag [FLAG_BLIND]) /* player is blind */ 471 else if (viewpoint->flag [FLAG_BLIND]) /* player is blind */
457 { 472 {
458 clear_los (); 473 clear_los ();
459 blinded_sight (this); 474 blinded_sight (this);
460 } 475 }
461 else 476 else
… …
463 clear_los (); 478 clear_los ();
464 calculate_los (this); 479 calculate_los (this);
465 apply_lights (this); 480 apply_lights (this);
466 } 481 }
467 482
468 if (observe->flag [FLAG_XRAYS]) 483 if (viewpoint->flag [FLAG_XRAYS])
469 for (int dx = -2; dx <= 2; dx++) 484 for (int dx = -2; dx <= 2; dx++)
470 for (int dy = -2; dy <= 2; dy++) 485 for (int dy = -2; dy <= 2; dy++)
471 min_it (los[dx + LOS_X0][dy + LOS_Y0], 1); 486 min_it (los[dx + LOS_X0][dy + LOS_Y0], 1);
472} 487}
473 488
… …
502 * map is the map that changed, x and y are the coordinates. 517 * map is the map that changed, x and y are the coordinates.
503 */ 518 */
504void 519void
505update_all_los (const maptile *map, int x, int y) 520update_all_los (const maptile *map, int x, int y)
506{ 521{
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 (); 522 map->at (x, y).invalidate ();
512 523
513 for_all_players (pl) 524 for_all_players (pl)
514 { 525 {
515 /* Player should not have a null map, but do this 526 /* Player should not have a null map, but do this
516 * check as a safety 527 * check as a safety
517 */ 528 */
518 if (!pl->ob || !pl->ob->map || !pl->ns) 529 if (!pl->ob || !pl->ob->map || !pl->ns)
519 continue; 530 continue;
520 531
521 /* Same map is simple case - see if pl is close enough. 532 rv_vector rv;
522 * Note in all cases, we did the check for same map first, 533
523 * and then see if the player is close enough and update 534 get_rangevector_from_mapcoord (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 */ 535
530 if (pl->ob->map == map) 536 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; 537 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 } 538 }
570} 539}
571 540
572static const int season_darkness[5][HOURS_PER_DAY] = { 541static 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 */ 542 /*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