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.31 by root, Thu Dec 4 01:07:35 2008 UTC vs.
Revision 1.40 by root, Fri Dec 19 17:52:50 2008 UTC

… …
30 * An object is 1.0 wide, so if set to 0.5, it means the object 30 * An object is 1.0 wide, so if set to 0.5, it means the object
31 * that blocks half the view (0.0 is complete block) will 31 * that blocks half the view (0.0 is complete block) will
32 * block view in our tables. 32 * block view in our tables.
33 * .4 or less lets you see through walls. .5 is about right. 33 * .4 or less lets you see through walls. .5 is about right.
34 */ 34 */
35
36#define SPACE_BLOCK 0.5 35#define SPACE_BLOCK 0.5
37#define MAX_UNLIGHTED_VISION 4
38 36
39typedef struct blstr 37typedef struct blstr
40{ 38{
41 int x[4], y[4]; 39 int x[4], y[4];
42 int index; 40 int index;
… …
88/* since we are only doing the upper left quadrant, only 86/* since we are only doing the upper left quadrant, only
89 * these spaces could possibly get blocked, since these 87 * these spaces could possibly get blocked, since these
90 * are the only ones further out that are still possibly in the 88 * are the only ones further out that are still possibly in the
91 * sightline. 89 * sightline.
92 */ 90 */
93
94void 91void
95init_block (void) 92init_block (void)
96{ 93{
97 int x, y, dx, dy, i;
98 static int block_x[3] = { -1, -1, 0 }, 94 static int block_x[3] = { -1, -1, 0 },
99 block_y[3] = { -1, 0, -1 }; 95 block_y[3] = { -1, 0, -1 };
100 96
101 for (x = 0; x < MAP_CLIENT_X; x++) 97 for (int x = 0; x < MAP_CLIENT_X; x++)
102 for (y = 0; y < MAP_CLIENT_Y; y++) 98 for (int y = 0; y < MAP_CLIENT_Y; y++)
103 block[x][y].index = 0; 99 block[x][y].index = 0;
104
105 100
106 /* The table should be symmetric, so only do the upper left 101 /* The table should be symmetric, so only do the upper left
107 * quadrant - makes the processing easier. 102 * quadrant - makes the processing easier.
108 */ 103 */
109 for (x = 1; x <= MAP_CLIENT_X / 2; x++) 104 for (int x = 1; x <= MAP_CLIENT_X / 2; x++)
110 { 105 {
111 for (y = 1; y <= MAP_CLIENT_Y / 2; y++) 106 for (int y = 1; y <= MAP_CLIENT_Y / 2; y++)
112 { 107 {
113 for (i = 0; i < 3; i++) 108 for (int i = 0; i < 3; i++)
114 { 109 {
115 dx = x + block_x[i]; 110 int dx = x + block_x[i];
116 dy = y + block_y[i]; 111 int dy = y + block_y[i];
117 112
118 /* center space never blocks */ 113 /* center space never blocks */
119 if (x == MAP_CLIENT_X / 2 && y == MAP_CLIENT_Y / 2) 114 if (x == MAP_CLIENT_X / 2 && y == MAP_CLIENT_Y / 2)
120 continue; 115 continue;
121 116
… …
133 } 128 }
134 else 129 else
135 { 130 {
136 float d1, r, s, l; 131 float d1, r, s, l;
137 132
138 /* We use the algorihm that found out how close the point 133 /* We use the algorithm that found out how close the point
139 * (x,y) is to the line from dx,dy to the center of the viewable 134 * (x,y) is to the line from dx,dy to the center of the viewable
140 * area. l is the distance from x,y to the line. 135 * area. l is the distance from x,y to the line.
141 * r is more a curiosity - it lets us know what direction (left/right) 136 * r is more a curiosity - it lets us know what direction (left/right)
142 * the line is off 137 * the line is off
143 */ 138 */
144 139
145 d1 = (float) (pow (MAP_CLIENT_X / 2 - dx, 2.f) + pow (MAP_CLIENT_Y / 2 - dy, 2.f)); 140 d1 = (powf (MAP_CLIENT_X / 2 - dx, 2.f) + powf (MAP_CLIENT_Y / 2 - dy, 2.f));
146 r = (float) ((dy - y) * (dy - MAP_CLIENT_Y / 2) - (dx - x) * (MAP_CLIENT_X / 2 - dx)) / d1; 141 r = ((dy - y) * (dy - MAP_CLIENT_Y / 2) - (dx - x) * (MAP_CLIENT_X / 2 - dx)) / d1;
147 s = (float) ((dy - y) * (MAP_CLIENT_X / 2 - dx) - (dx - x) * (MAP_CLIENT_Y / 2 - dy)) / d1; 142 s = ((dy - y) * (MAP_CLIENT_X / 2 - dx) - (dx - x) * (MAP_CLIENT_Y / 2 - dy)) / d1;
148 l = FABS (sqrt (d1) * s); 143 l = fabs (sqrtf (d1) * s);
149 144
150 if (l <= SPACE_BLOCK) 145 if (l <= SPACE_BLOCK)
151 { 146 {
152 /* For simplicity, we mirror the coordinates to block the other 147 /* For simplicity, we mirror the coordinates to block the other
153 * quadrants. 148 * quadrants.
… …
174 * In this way, the chain of visibility is set. 169 * In this way, the chain of visibility is set.
175 */ 170 */
176static void 171static void
177set_wall (object *op, int x, int y) 172set_wall (object *op, int x, int y)
178{ 173{
179 int i;
180
181 for (i = 0; i < block[x][y].index; i++) 174 for (int i = 0; i < block[x][y].index; i++)
182 { 175 {
183 int dx = block[x][y].x[i], dy = block[x][y].y[i], ax, ay; 176 int dx = block[x][y].x[i], dy = block[x][y].y[i], ax, ay;
184 177
185 /* ax, ay are the values as adjusted to be in the 178 /* ax, ay are the values as adjusted to be in the
186 * socket look structure. 179 * socket look structure.
… …
195#endif 188#endif
196 /* we need to adjust to the fact that the socket 189 /* we need to adjust to the fact that the socket
197 * code wants the los to start from the 0,0 190 * code wants the los to start from the 0,0
198 * and not be relative to middle of los array. 191 * and not be relative to middle of los array.
199 */ 192 */
200 op->contr->blocked_los[ax][ay] = 100; 193 op->contr->blocked_los[ax][ay] = LOS_BLOCKED;
201 set_wall (op, dx, dy); 194 set_wall (op, dx, dy);
202 } 195 }
203} 196}
204 197
205/* 198/*
206 * Used to initialise the array used by the LOS routines. 199 * Used to initialise the array used by the LOS routines.
207 * op is the object, x and y values based on MAP_CLIENT_X and Y. 200 * op is the object, x and y values based on MAP_CLIENT_X and Y.
208 * this is because they index the blocked[][] arrays. 201 * this is because they index the blocked[][] arrays.
209 */ 202 */
210
211static void 203static void
212check_wall (object *op, int x, int y) 204check_wall (object *op, int x, int y)
213{ 205{
214 int ax, ay; 206 int ax, ay;
215 207
… …
233 225
234 /* If this space is already blocked, prune the processing - presumably 226 /* If this space is already blocked, prune the processing - presumably
235 * whatever has set this space to be blocked has done the work and already 227 * whatever has set this space to be blocked has done the work and already
236 * done the dependency chain. 228 * done the dependency chain.
237 */ 229 */
238 if (op->contr->blocked_los[ax][ay] == 100) 230 if (op->contr->blocked_los[ax][ay] == LOS_BLOCKED)
239 return; 231 return;
240
241 232
242 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)) 233 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))
243 set_wall (op, x, y); 234 set_wall (op, x, y);
244} 235}
245 236
… …
263 * expand_sight goes through the array of what the given player is 254 * expand_sight goes through the array of what the given player is
264 * able to see, and expands the visible area a bit, so the player will, 255 * able to see, and expands the visible area a bit, so the player will,
265 * to a certain degree, be able to see into corners. 256 * to a certain degree, be able to see into corners.
266 * This is somewhat suboptimal, would be better to improve the formula. 257 * This is somewhat suboptimal, would be better to improve the formula.
267 */ 258 */
268
269static void 259static void
270expand_sight (object *op) 260expand_sight (object *op)
271{ 261{
272 int i, x, y, dx, dy;
273
274 for (x = 1; x < op->contr->ns->mapx - 1; x++) /* loop over inner squares */ 262 for (int x = 1; x < op->contr->ns->mapx - 1; x++) /* loop over inner squares */
275 for (y = 1; y < op->contr->ns->mapy - 1; y++) 263 for (int y = 1; y < op->contr->ns->mapy - 1; y++)
276 {
277 if (!op->contr->blocked_los[x][y] && 264 if (!op->contr->blocked_los[x][y] &&
278 !(get_map_flags (op->map, NULL, 265 !(get_map_flags (op->map, NULL,
279 op->x - op->contr->ns->mapx / 2 + x, 266 op->x - op->contr->ns->mapx / 2 + x,
280 op->y - op->contr->ns->mapy / 2 + y, NULL, NULL) & (P_BLOCKSVIEW | P_OUT_OF_MAP))) 267 op->y - op->contr->ns->mapy / 2 + y, NULL, NULL) & (P_BLOCKSVIEW | P_OUT_OF_MAP)))
281 { 268 {
282
283 for (i = 1; i <= 8; i += 1) 269 for (int i = 1; i <= 8; i += 1)
284 { /* mark all directions */ 270 { /* mark all directions */
285 dx = x + freearr_x[i]; 271 int dx = x + freearr_x[i];
286 dy = y + freearr_y[i]; 272 int dy = y + freearr_y[i];
273
287 if (op->contr->blocked_los[dx][dy] > 0) /* for any square blocked */ 274 if (op->contr->blocked_los[dx][dy] > 0) /* for any square blocked */
288 op->contr->blocked_los[dx][dy] = -1; 275 op->contr->blocked_los[dx][dy] = -1;
289 } 276 }
290 } 277 }
291 }
292 278
293 if (op->map->darkness > 0) /* player is on a dark map */
294 expand_lighted_sight (op); 279 expand_lighted_sight (op);
295 280
296 /* clear mark squares */ 281 /* clear mark squares */
297 for (x = 0; x < op->contr->ns->mapx; x++) 282 for (int x = 0; x < op->contr->ns->mapx; x++)
298 for (y = 0; y < op->contr->ns->mapy; y++) 283 for (int y = 0; y < op->contr->ns->mapy; y++)
299 if (op->contr->blocked_los[x][y] < 0) 284 if (op->contr->blocked_los[x][y] < 0)
300 op->contr->blocked_los[x][y] = 0; 285 op->contr->blocked_los[x][y] = 0;
301} 286}
302 287
303/* returns true if op carries one or more lights 288/* returns true if op carries one or more lights
304 * This is a trivial function now days, but it used to 289 * This is a trivial function now days, but it used to
305 * be a bit longer. Probably better for callers to just 290 * be a bit longer. Probably better for callers to just
306 * check the op->glow_radius instead of calling this. 291 * check the op->glow_radius instead of calling this.
307 */ 292 */
308
309int 293int
310has_carried_lights (const object *op) 294has_carried_lights (const object *op)
311{ 295{
312 /* op may glow! */ 296 /* op may glow! */
313 if (op->glow_radius > 0) 297 if (op->glow_radius > 0)
314 return 1; 298 return 1;
315 299
316 return 0; 300 return 0;
317} 301}
318 302
303/* radius, distance => lightness adjust */
304static sint8 darkness[MAX_LIGHT_RADIUS * 2 + 1][MAX_LIGHT_RADIUS * 3 / 2 + 1];
305
306static struct darkness_init
307{
308 darkness_init ()
309 {
310 for (int radius = -MAX_LIGHT_RADIUS; radius <= MAX_LIGHT_RADIUS; ++radius)
311 for (int distance = 0; distance <= MAX_LIGHT_RADIUS * 3 / 2; ++distance)
312 {
313 // max intensity
314 int intensity = min (LOS_MAX, abs (radius) + 1);
315
316 // actual intensity
317 intensity = max (0, lerp_rd (distance, 0, abs (radius) + 1, intensity, 0));
318
319 darkness [radius + MAX_LIGHT_RADIUS][distance] = radius < 0
320 ? min (3, intensity)
321 : LOS_MAX - intensity;
322 }
323 }
324} darkness_init;
325
326sint8
327los_brighten (sint8 b, sint8 l)
328{
329 return b == LOS_BLOCKED ? b : min (b, l);
330}
331
332sint8
333los_darken (sint8 b, sint8 l)
334{
335 return max (b, l);
336}
337
338template<sint8 change_it (sint8, sint8)>
339static void
340apply_light (object *op, int basex, int basey, int light, const sint8 *darkness_table)
341{
342 // min or max the ciruclar area around basex, basey
343 player *pl = op->contr;
344
345 int ax0 = max (0, basex - light);
346 int ay0 = max (0, basey - light);
347 int ax1 = min (basex + light, pl->ns->mapx - 1);
348 int ay1 = min (basey + light, pl->ns->mapy - 1);
349
350 for (int ax = ax0; ax <= ax1; ax++)
351 for (int ay = ay0; ay <= ay1; ay++)
352 pl->blocked_los[ax][ay] =
353 change_it (pl->blocked_los[ax][ay], darkness_table [idistance (ax - basex, ay - basey)]);
354}
355
356/* add light, by finding all (non-null) nearby light sources, then
357 * mark those squares specially.
358 */
319static void 359static void
320expand_lighted_sight (object *op) 360expand_lighted_sight (object *op)
321{ 361{
322 int x, y, darklevel, ax, ay, basex, basey, mflags, light, x1, y1; 362 int darklevel, mflags, light, x1, y1;
323 maptile *m = op->map; 363 maptile *m = op->map;
324 sint16 nx, ny; 364 sint16 nx, ny;
325 365
326 darklevel = m->darkness; 366 darklevel = m->darkness;
327 367
328 /* If the player can see in the dark, lower the darklevel for him */ 368 /* If the player can see in the dark, lower the darklevel for him */
329 if (QUERY_FLAG (op, FLAG_SEE_IN_DARK)) 369 if (QUERY_FLAG (op, FLAG_SEE_IN_DARK))
330 darklevel -= 2; 370 darklevel -= LOS_MAX / 2;
331
332 /* add light, by finding all (non-null) nearby light sources, then
333 * mark those squares specially. If the darklevel<1, there is no
334 * reason to do this, so we skip this function
335 */
336
337 if (darklevel < 1)
338 return;
339 371
340 /* Do a sanity check. If not valid, some code below may do odd 372 /* Do a sanity check. If not valid, some code below may do odd
341 * things. 373 * things.
342 */ 374 */
343 if (darklevel > MAX_DARKNESS) 375 if (darklevel > MAX_DARKNESS)
344 { 376 {
345 LOG (llevError, "Map darkness for %s on %s is too high (%d)\n", &op->name, &op->map->path, darklevel); 377 LOG (llevError, "Map darkness for %s on %s is too high (%d)\n", &op->name, &op->map->path, darklevel);
346 darklevel = MAX_DARKNESS; 378 darklevel = MAX_DARKNESS;
347 } 379 }
348 380
349 /* First, limit player furthest (unlighted) vision */ 381 int half_x = op->contr->ns->mapx / 2;
382 int half_y = op->contr->ns->mapy / 2;
383
384 int min_x = op->x - half_x - MAX_LIGHT_RADIUS;
385 int min_y = op->y - half_y - MAX_LIGHT_RADIUS;
386 int max_x = op->x + half_x + MAX_LIGHT_RADIUS;
387 int max_y = op->y + half_y + MAX_LIGHT_RADIUS;
388
389 int pass2 = 0; // negative lights have an extra pass
390
391 if (darklevel < 1)
392 pass2 = 1;
393 else
394 {
395 /* first, make everything totally dark */
350 for (x = 0; x < op->contr->ns->mapx; x++) 396 for (int x = 0; x < op->contr->ns->mapx; x++)
351 for (y = 0; y < op->contr->ns->mapy; y++) 397 for (int y = 0; y < op->contr->ns->mapy; y++)
352 if (op->contr->blocked_los[x][y] != 100) 398 if (op->contr->blocked_los[x][y] != LOS_BLOCKED)
353 op->contr->blocked_los[x][y] = MAX_UNLIGHTED_VISION; 399 op->contr->blocked_los[x][y] = LOS_MAX;
354 400
355 /* the spaces[] darkness value contains the information we need. 401 /*
356 * Only process the area of interest. 402 * Only process the area of interest.
357 * the basex, basey values represent the position in the op->contr->blocked_los 403 * the basex, basey values represent the position in the op->contr->blocked_los
358 * array. Its easier to just increment them here (and start with the right 404 * array. Its easier to just increment them here (and start with the right
359 * value) than to recalculate them down below. 405 * value) than to recalculate them down below.
360 */ 406 */
361 for (x = (op->x - op->contr->ns->mapx / 2 - MAX_LIGHT_RADIUS), basex = -MAX_LIGHT_RADIUS; 407 for (int x = min_x, basex = -MAX_LIGHT_RADIUS; x <= max_x; x++, basex++)
362 x <= (op->x + op->contr->ns->mapx / 2 + MAX_LIGHT_RADIUS); x++, basex++) 408 for (int y = min_y, basey = -MAX_LIGHT_RADIUS; y <= max_y; y++, basey++)
363 {
364
365 for (y = (op->y - op->contr->ns->mapy / 2 - MAX_LIGHT_RADIUS), basey = -MAX_LIGHT_RADIUS;
366 y <= (op->y + op->contr->ns->mapy / 2 + MAX_LIGHT_RADIUS); y++, basey++)
367 { 409 {
410 maptile *m = op->map;
411 sint16 nx = x;
412 sint16 ny = y;
413
414 if (!xy_normalise (m, nx, ny))
415 continue;
416
417 mapspace &ms = m->at (nx, ny);
418 ms.update ();
419 sint8 light = ms.light;
420
421 if (expect_false (light))
422 if (light < 0)
423 pass2 = 1;
424 else
425 apply_light<los_brighten> (op, basex, basey, light, darkness [light + MAX_LIGHT_RADIUS]);
426 }
427
428 /* grant some vision to the player, based on the darklevel */
429 /* for outdoor maps, ensure some mininum visibility radius */
430 {
431 int light = clamp (MAX_DARKNESS - darklevel, op->map->outdoor ? 2 : 0, MAX_LIGHT_RADIUS);
432
433 apply_light<los_brighten> (op, half_x, half_y, light, darkness [light + MAX_LIGHT_RADIUS]);
434 }
435 }
436
437 // possibly do 2nd pass for rare negative glow radii
438 // for effect, those are always considered to be stronger than anything else
439 // but they can't darken a place completely
440 if (pass2)
441 for (int x = min_x, basex = -MAX_LIGHT_RADIUS; x <= max_x; x++, basex++)
442 for (int y = min_y, basey = -MAX_LIGHT_RADIUS; y <= max_y; y++, basey++)
443 {
368 m = op->map; 444 maptile *m = op->map;
369 nx = x; 445 sint16 nx = x;
370 ny = y; 446 sint16 ny = y;
371 447
372 mflags = get_map_flags (m, &m, nx, ny, &nx, &ny); 448 if (!xy_normalise (m, nx, ny))
373
374 if (mflags & P_OUT_OF_MAP)
375 continue; 449 continue;
376 450
377 /* This space is providing light, so we need to brighten up the 451 mapspace &ms = m->at (nx, ny);
378 * spaces around here. 452 ms.update ();
379 */ 453 sint8 light = ms.light;
380 light = GET_MAP_LIGHT (m, nx, ny);
381 if (light)
382 {
383#if 0
384 LOG (llevDebug, "expand_lighted_sight: Found light at x=%d, y=%d, basex=%d, basey=%d\n", x, y, basex, basey);
385#endif
386 for (ax = basex - light; ax <= basex + light; ax++)
387 {
388 if (ax < 0 || ax >= op->contr->ns->mapx)
389 continue;
390 454
391 x1 = (basex - ax) * (basex - ax); 455 if (expect_false (light < 0))
392 456 apply_light<los_darken> (op, basex, basey, -light, darkness [light + MAX_LIGHT_RADIUS]);
393 for (ay = basey - light; ay <= basey + light; ay++)
394 {
395 if (ay < 0 || ay >= op->contr->ns->mapy)
396 continue;
397
398 /* If the space is fully blocked, do nothing. Otherwise, we
399 * brighten the space. The further the light is away from the
400 * source (basex-x), the less effect it has. Though light used
401 * to dim in a square manner, it now dims in a roughly circular
402 * manner. glow_radius still represents the radius.
403 */
404 if (op->contr->blocked_los[ax][ay] != 100)
405 {
406 y1 = (basey - ay) * (basey - ay);
407
408 op->contr->blocked_los[ax][ay] -= light > 0
409 ? max (light - isqrt (x1 + y1), 0)
410 : min (light + isqrt (x1 + y1), 0);
411 }
412 }
413 }
414 }
415 }
416 }
417
418 /* Outdoor should never really be completely pitch black dark like
419 * a dungeon, so let the player at least see a little around themselves
420 */
421 if (op->map->outdoor && darklevel > MAX_DARKNESS - 3)
422 {
423 if (op->contr->blocked_los[op->contr->ns->mapx / 2][op->contr->ns->mapy / 2] > (MAX_DARKNESS - 3))
424 op->contr->blocked_los[op->contr->ns->mapx / 2][op->contr->ns->mapy / 2] = MAX_DARKNESS - 3;
425
426 for (x = -1; x <= 1; x++)
427 for (y = -1; y <= 1; y++)
428 {
429 if (op->contr->blocked_los[x + op->contr->ns->mapx / 2][y + op->contr->ns->mapy / 2] > (MAX_DARKNESS - 2))
430 op->contr->blocked_los[x + op->contr->ns->mapx / 2][y + op->contr->ns->mapy / 2] = MAX_DARKNESS - 2;
431 } 457 }
432 }
433
434 /* grant some vision to the player, based on the darklevel */
435 for (x = darklevel - MAX_DARKNESS; x < MAX_DARKNESS + 1 - darklevel; x++)
436 for (y = darklevel - MAX_DARKNESS; y < MAX_DARKNESS + 1 - darklevel; y++)
437 if (!(op->contr->blocked_los[x + op->contr->ns->mapx / 2][y + op->contr->ns->mapy / 2] == 100))
438 op->contr->blocked_los[x + op->contr->ns->mapx / 2][y + op->contr->ns->mapy / 2] -=
439 MAX (0, 6 - darklevel - MAX (abs (x), abs (y)));
440} 458}
441 459
442/* blinded_sight() - sets all viewable squares to blocked except 460/* blinded_sight() - sets all viewable squares to blocked except
443 * for the one the central one that the player occupies. A little 461 * for the one the central one that the player occupies. A little
444 * odd that you can see yourself (and what your standing on), but 462 * odd that you can see yourself (and what your standing on), but
… …
449{ 467{
450 int x, y; 468 int x, y;
451 469
452 for (x = 0; x < op->contr->ns->mapx; x++) 470 for (x = 0; x < op->contr->ns->mapx; x++)
453 for (y = 0; y < op->contr->ns->mapy; y++) 471 for (y = 0; y < op->contr->ns->mapy; y++)
454 op->contr->blocked_los[x][y] = 100; 472 op->contr->blocked_los[x][y] = LOS_BLOCKED;
455 473
456 op->contr->blocked_los[op->contr->ns->mapx / 2][op->contr->ns->mapy / 2] = 0; 474 op->contr->blocked_los[op->contr->ns->mapx / 2][op->contr->ns->mapy / 2] = 0;
457} 475}
458 476
459/* 477/*

Diff Legend

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