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.30 by root, Mon Apr 21 23:35:24 2008 UTC vs.
Revision 1.36 by root, Mon Dec 8 15:40:13 2008 UTC

… …
194#endif 194#endif
195 /* we need to adjust to the fact that the socket 195 /* we need to adjust to the fact that the socket
196 * code wants the los to start from the 0,0 196 * code wants the los to start from the 0,0
197 * and not be relative to middle of los array. 197 * and not be relative to middle of los array.
198 */ 198 */
199 op->contr->blocked_los[ax][ay] = 100; 199 op->contr->blocked_los[ax][ay] = LOS_BLOCKED;
200 set_wall (op, dx, dy); 200 set_wall (op, dx, dy);
201 } 201 }
202} 202}
203 203
204/* 204/*
… …
232 232
233 /* If this space is already blocked, prune the processing - presumably 233 /* If this space is already blocked, prune the processing - presumably
234 * whatever has set this space to be blocked has done the work and already 234 * whatever has set this space to be blocked has done the work and already
235 * done the dependency chain. 235 * done the dependency chain.
236 */ 236 */
237 if (op->contr->blocked_los[ax][ay] == 100) 237 if (op->contr->blocked_los[ax][ay] == LOS_BLOCKED)
238 return; 238 return;
239
240 239
241 if (get_map_flags (op->map, NULL, op->x + x - MAP_CLIENT_X / 2, op->y + y - MAP_CLIENT_Y / 2, NULL, NULL) & (P_BLOCKSVIEW | P_OUT_OF_MAP)) 240 if (get_map_flags (op->map, NULL, op->x + x - MAP_CLIENT_X / 2, op->y + y - MAP_CLIENT_Y / 2, NULL, NULL) & (P_BLOCKSVIEW | P_OUT_OF_MAP))
242 set_wall (op, x, y); 241 set_wall (op, x, y);
243} 242}
244 243
… …
313 return 1; 312 return 1;
314 313
315 return 0; 314 return 0;
316} 315}
317 316
317/* radius, distance => lightness adjust */
318static sint8 darkness[MAX_LIGHT_RADIUS * 2 + 1][MAX_LIGHT_RADIUS * 3 / 2 + 1];
319
320static struct darkness_init
321{
322 darkness_init ()
323 {
324 for (int radius = -MAX_LIGHT_RADIUS; radius <= MAX_LIGHT_RADIUS; ++radius)
325 for (int distance = 0; distance <= MAX_LIGHT_RADIUS * 3 / 2; ++distance)
326 {
327 // max intensity
328 int intensity = min (LOS_MAX, abs (radius) + 1);
329
330 // actual intensity
331 intensity = max (0, lerp_rd (distance, 0, abs (radius) + 1, intensity, 0));
332
333 darkness [radius + MAX_LIGHT_RADIUS][distance] = radius < 0
334 ? min (3, intensity)
335 : LOS_MAX - intensity;
336 }
337 }
338} darkness_init;
339
318static void 340static void
319expand_lighted_sight (object *op) 341expand_lighted_sight (object *op)
320{ 342{
321 int x, y, darklevel, ax, ay, basex, basey, mflags, light, x1, y1; 343 int x, y, darklevel, basex, basey, mflags, light, x1, y1;
322 maptile *m = op->map; 344 maptile *m = op->map;
323 sint16 nx, ny; 345 sint16 nx, ny;
324 346
325 darklevel = m->darkness; 347 darklevel = m->darkness;
326 348
327 /* If the player can see in the dark, lower the darklevel for him */ 349 /* If the player can see in the dark, lower the darklevel for him */
328 if (QUERY_FLAG (op, FLAG_SEE_IN_DARK)) 350 if (QUERY_FLAG (op, FLAG_SEE_IN_DARK))
329 darklevel -= 2; 351 darklevel -= LOS_MAX / 2;
330 352
331 /* add light, by finding all (non-null) nearby light sources, then 353 /* add light, by finding all (non-null) nearby light sources, then
332 * mark those squares specially. If the darklevel<1, there is no 354 * mark those squares specially. If the darklevel<1, there is no
333 * reason to do this, so we skip this function 355 * reason to do this, so we skip this function
334 */ 356 */
… …
343 { 365 {
344 LOG (llevError, "Map darkness for %s on %s is too high (%d)\n", &op->name, &op->map->path, darklevel); 366 LOG (llevError, "Map darkness for %s on %s is too high (%d)\n", &op->name, &op->map->path, darklevel);
345 darklevel = MAX_DARKNESS; 367 darklevel = MAX_DARKNESS;
346 } 368 }
347 369
348 /* First, limit player furthest (unlighted) vision */ 370 /* first, make everything totally dark */
349 for (x = 0; x < op->contr->ns->mapx; x++) 371 for (x = 0; x < op->contr->ns->mapx; x++)
350 for (y = 0; y < op->contr->ns->mapy; y++) 372 for (y = 0; y < op->contr->ns->mapy; y++)
351 if (op->contr->blocked_los[x][y] != 100) 373 if (op->contr->blocked_los[x][y] != LOS_BLOCKED)
352 op->contr->blocked_los[x][y] = MAX_LIGHT_RADII; 374 op->contr->blocked_los[x][y] = LOS_MAX;
353 375
354 /* the spaces[] darkness value contains the information we need. 376 int half_x = op->contr->ns->mapx / 2;
377 int half_y = op->contr->ns->mapy / 2;
378
379 int min_x = op->x - half_x - MAX_LIGHT_RADIUS;
380 int min_y = op->y - half_y - MAX_LIGHT_RADIUS;
381 int max_x = op->x + half_x + MAX_LIGHT_RADIUS;
382 int max_y = op->y + half_y + MAX_LIGHT_RADIUS;
383
384 int pass2 = 0; // negative lights have an extra pass
385
386 /*
355 * Only process the area of interest. 387 * Only process the area of interest.
356 * the basex, basey values represent the position in the op->contr->blocked_los 388 * the basex, basey values represent the position in the op->contr->blocked_los
357 * array. Its easier to just increment them here (and start with the right 389 * array. Its easier to just increment them here (and start with the right
358 * value) than to recalculate them down below. 390 * value) than to recalculate them down below.
359 */ 391 */
360 for (x = (op->x - op->contr->ns->mapx / 2 - MAX_LIGHT_RADII), basex = -MAX_LIGHT_RADII; 392 for (int x = min_x, basex = -MAX_LIGHT_RADIUS; x <= max_x; x++, basex++)
361 x <= (op->x + op->contr->ns->mapx / 2 + MAX_LIGHT_RADII); x++, basex++) 393 for (int y = min_y, basey = -MAX_LIGHT_RADIUS; y <= max_y; y++, basey++)
362 {
363
364 for (y = (op->y - op->contr->ns->mapy / 2 - MAX_LIGHT_RADII), basey = -MAX_LIGHT_RADII;
365 y <= (op->y + op->contr->ns->mapy / 2 + MAX_LIGHT_RADII); y++, basey++)
366 { 394 {
395 maptile *m = op->map;
396 sint16 nx = x;
397 sint16 ny = y;
398
399 if (!xy_normalise (m, nx, ny))
400 continue;
401
402 mapspace &ms = m->at (nx, ny);
403 ms.update ();
404 sint8 light = ms.light;
405
406 if (expect_false (light))
407 if (light < 0)
408 pass2 = 1;
409 else
410 {
411 /* This space is providing light, so we need to brighten up the
412 * spaces around here.
413 */
414 const sint8 *darkness_table = darkness [light + MAX_LIGHT_RADIUS];
415
416 for (int ax = max (0, basex - light); ax <= min (basex + light, op->contr->ns->mapx - 1); ax++)
417 for (int ay = max (0, basey - light); ay <= min (basey + light, op->contr->ns->mapy - 1); ay++)
418 if (op->contr->blocked_los[ax][ay] != LOS_BLOCKED)
419 min_it (op->contr->blocked_los[ax][ay], darkness_table [idistance (ax - basex, ay - basey)]);
420 }
421 }
422
423 // psosibly do 2nd pass for rare negative glow radii
424 if (expect_false (pass2))
425 for (x = min_x, basex = -MAX_LIGHT_RADIUS; x <= max_x; x++, basex++)
426 for (y = min_y, basey = -MAX_LIGHT_RADIUS; y <= max_y; y++, basey++)
427 {
367 m = op->map; 428 maptile *m = op->map;
368 nx = x; 429 sint16 nx = x;
369 ny = y; 430 sint16 ny = y;
370 431
371 mflags = get_map_flags (m, &m, nx, ny, &nx, &ny); 432 if (!xy_normalise (m, nx, ny))
372
373 if (mflags & P_OUT_OF_MAP)
374 continue; 433 continue;
375 434
376 /* This space is providing light, so we need to brighten up the 435 mapspace &ms = m->at (nx, ny);
377 * spaces around here. 436 ms.update ();
378 */ 437 sint8 light = ms.light;
379 light = GET_MAP_LIGHT (m, nx, ny); 438
380 if (light != 0) 439 if (expect_false (light < 0))
381 { 440 {
382#if 0 441 const sint8 *darkness_table = darkness [light + MAX_LIGHT_RADIUS];
383 LOG (llevDebug, "expand_lighted_sight: Found light at x=%d, y=%d, basex=%d, basey=%d\n", x, y, basex, basey);
384#endif
385 for (ax = basex - light; ax <= basex + light; ax++)
386 {
387 if (ax < 0 || ax >= op->contr->ns->mapx)
388 continue;
389 442
390 for (ay = basey - light; ay <= basey + light; ay++) 443 for (int ax = max (0, basex + light); ax <= min (basex - light, op->contr->ns->mapx - 1); ax++)
391 { 444 for (int ay = max (0, basey + light); ay <= min (basey - light, op->contr->ns->mapy - 1); ay++)
392 if (ay < 0 || ay >= op->contr->ns->mapy)
393 continue;
394
395 /* If the space is fully blocked, do nothing. Otherwise, we
396 * brighten the space. The further the light is away from the
397 * source (basex-x), the less effect it has. Though light used
398 * to dim in a square manner, it now dims in a circular manner
399 * using the the pythagorean theorem. glow_radius still
400 * represents the radius
401 */
402 if (op->contr->blocked_los[ax][ay] != 100) 445 if (op->contr->blocked_los[ax][ay] != LOS_BLOCKED)
403 { 446 max_it (op->contr->blocked_los[ax][ay], darkness_table [idistance (ax - basex, ay - basey)]);
404 x1 = abs (basex - ax) * abs (basex - ax);
405 y1 = abs (basey - ay) * abs (basey - ay);
406
407 if (light > 0) op->contr->blocked_los[ax][ay] -= max (light - isqrt (x1 + y1), 0);
408 if (light < 0) op->contr->blocked_los[ax][ay] -= min (light + isqrt (x1 + y1), 0);
409 }
410 }
411 }
412 } 447 }
413 } 448 }
414 }
415 449
416 /* Outdoor should never really be completely pitch black dark like 450 /* Outdoor should never really be completely pitch black dark like
417 * a dungeon, so let the player at least see a little around themselves 451 * a dungeon, so let the player at least see a little around themselves
418 */ 452 */
419 if (op->map->outdoor && darklevel > (MAX_DARKNESS - 3)) 453 if (op->map->outdoor && darklevel > MAX_DARKNESS - 3)
420 { 454 {
421 if (op->contr->blocked_los[op->contr->ns->mapx / 2][op->contr->ns->mapy / 2] > (MAX_DARKNESS - 3)) 455 if (op->contr->blocked_los[op->contr->ns->mapx / 2][op->contr->ns->mapy / 2] > (LOS_MAX - 3))
422 op->contr->blocked_los[op->contr->ns->mapx / 2][op->contr->ns->mapy / 2] = MAX_DARKNESS - 3; 456 op->contr->blocked_los[op->contr->ns->mapx / 2][op->contr->ns->mapy / 2] = LOS_MAX - 3;
423 457
424 for (x = -1; x <= 1; x++) 458 for (x = -1; x <= 1; x++)
425 for (y = -1; y <= 1; y++) 459 for (y = -1; y <= 1; y++)
426 {
427 if (op->contr->blocked_los[x + op->contr->ns->mapx / 2][y + op->contr->ns->mapy / 2] > (MAX_DARKNESS - 2)) 460 if (op->contr->blocked_los[x + op->contr->ns->mapx / 2][y + op->contr->ns->mapy / 2] > (LOS_MAX - 2))
428 op->contr->blocked_los[x + op->contr->ns->mapx / 2][y + op->contr->ns->mapy / 2] = MAX_DARKNESS - 2; 461 op->contr->blocked_los[x + op->contr->ns->mapx / 2][y + op->contr->ns->mapy / 2] = LOS_MAX - 2;
429 }
430 } 462 }
431 463
432 /* grant some vision to the player, based on the darklevel */ 464 /* grant some vision to the player, based on the darklevel */
433 for (x = darklevel - MAX_DARKNESS; x < MAX_DARKNESS + 1 - darklevel; x++) 465 for (x = darklevel - MAX_DARKNESS; x < MAX_DARKNESS + 1 - darklevel; x++)
434 for (y = darklevel - MAX_DARKNESS; y < MAX_DARKNESS + 1 - darklevel; y++) 466 for (y = darklevel - MAX_DARKNESS; y < MAX_DARKNESS + 1 - darklevel; y++)
435 if (!(op->contr->blocked_los[x + op->contr->ns->mapx / 2][y + op->contr->ns->mapy / 2] == 100)) 467 if (!(op->contr->blocked_los[x + op->contr->ns->mapx / 2][y + op->contr->ns->mapy / 2] == LOS_BLOCKED))
436 op->contr->blocked_los[x + op->contr->ns->mapx / 2][y + op->contr->ns->mapy / 2] -= 468 op->contr->blocked_los[x + op->contr->ns->mapx / 2][y + op->contr->ns->mapy / 2] -=
437 MAX (0, 6 - darklevel - MAX (abs (x), abs (y))); 469 max (0, 6 - darklevel - max (abs (x), abs (y)));
438} 470}
439 471
440/* blinded_sight() - sets all veiwable squares to blocked except 472/* blinded_sight() - sets all viewable squares to blocked except
441 * for the one the central one that the player occupies. A little 473 * for the one the central one that the player occupies. A little
442 * odd that you can see yourself (and what your standing on), but 474 * odd that you can see yourself (and what your standing on), but
443 * really need for any reasonable game play. 475 * really need for any reasonable game play.
444 */ 476 */
445static void 477static void
… …
447{ 479{
448 int x, y; 480 int x, y;
449 481
450 for (x = 0; x < op->contr->ns->mapx; x++) 482 for (x = 0; x < op->contr->ns->mapx; x++)
451 for (y = 0; y < op->contr->ns->mapy; y++) 483 for (y = 0; y < op->contr->ns->mapy; y++)
452 op->contr->blocked_los[x][y] = 100; 484 op->contr->blocked_los[x][y] = LOS_BLOCKED;
453 485
454 op->contr->blocked_los[op->contr->ns->mapx / 2][op->contr->ns->mapy / 2] = 0; 486 op->contr->blocked_los[op->contr->ns->mapx / 2][op->contr->ns->mapy / 2] = 0;
455} 487}
456 488
457/* 489/*

Diff Legend

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