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.33 by root, Thu Dec 4 03:48:37 2008 UTC vs.
Revision 1.38 by root, Thu Dec 18 05:13:38 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_DARKNESS_LOS 4 /* 4 == totally dark */
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 */ 279 if (op->map->darkness > 0) /* player is on a dark map */
294 expand_lighted_sight (op); 280 expand_lighted_sight (op);
295 281
296 /* clear mark squares */ 282 /* clear mark squares */
297 for (x = 0; x < op->contr->ns->mapx; x++) 283 for (int x = 0; x < op->contr->ns->mapx; x++)
298 for (y = 0; y < op->contr->ns->mapy; y++) 284 for (int y = 0; y < op->contr->ns->mapy; y++)
299 if (op->contr->blocked_los[x][y] < 0) 285 if (op->contr->blocked_los[x][y] < 0)
300 op->contr->blocked_los[x][y] = 0; 286 op->contr->blocked_los[x][y] = 0;
301} 287}
302 288
303/* returns true if op carries one or more lights 289/* returns true if op carries one or more lights
304 * This is a trivial function now days, but it used to 290 * This is a trivial function now days, but it used to
305 * be a bit longer. Probably better for callers to just 291 * be a bit longer. Probably better for callers to just
306 * check the op->glow_radius instead of calling this. 292 * check the op->glow_radius instead of calling this.
307 */ 293 */
308
309int 294int
310has_carried_lights (const object *op) 295has_carried_lights (const object *op)
311{ 296{
312 /* op may glow! */ 297 /* op may glow! */
313 if (op->glow_radius > 0) 298 if (op->glow_radius > 0)
… …
315 300
316 return 0; 301 return 0;
317} 302}
318 303
319/* radius, distance => lightness adjust */ 304/* radius, distance => lightness adjust */
320static sint8 darkness[MAX_LIGHT_RADIUS * 2 + 1][MAX_LIGHT_RADIUS + 1]; 305static sint8 darkness[MAX_LIGHT_RADIUS * 2 + 1][MAX_LIGHT_RADIUS * 3 / 2 + 1];
321 306
322static struct darkness_init 307static struct darkness_init
323{ 308{
324 darkness_init () 309 darkness_init ()
325 { 310 {
326 for (int radius = -MAX_LIGHT_RADIUS; radius <= MAX_LIGHT_RADIUS; ++radius) 311 for (int radius = -MAX_LIGHT_RADIUS; radius <= MAX_LIGHT_RADIUS; ++radius)
327 for (int distance = 0; distance <= MAX_LIGHT_RADIUS; ++distance) 312 for (int distance = 0; distance <= MAX_LIGHT_RADIUS * 3 / 2; ++distance)
328 { 313 {
329 // max intensity 314 // max intensity
330 int intensity = min (MAX_DARKNESS_LOS, abs (radius) + 1); 315 int intensity = min (LOS_MAX, abs (radius) + 1);
331 316
332 // actual intensity 317 // actual intensity
333 intensity = max (0, lerp_rd (distance, 0, abs (radius) + 1, intensity, 0)); 318 intensity = max (0, lerp_rd (distance, 0, abs (radius) + 1, intensity, 0));
334 319
335 darkness [radius + MAX_LIGHT_RADIUS][distance] = radius < 0 320 darkness [radius + MAX_LIGHT_RADIUS][distance] = radius < 0
336 ? intensity 321 ? min (3, intensity)
337 : MAX_DARKNESS_LOS - intensity; 322 : LOS_MAX - intensity;
338 } 323 }
339 } 324 }
340} darkness_init; 325} darkness_init;
341 326
342static void 327static void
… …
348 333
349 darklevel = m->darkness; 334 darklevel = m->darkness;
350 335
351 /* If the player can see in the dark, lower the darklevel for him */ 336 /* If the player can see in the dark, lower the darklevel for him */
352 if (QUERY_FLAG (op, FLAG_SEE_IN_DARK)) 337 if (QUERY_FLAG (op, FLAG_SEE_IN_DARK))
353 darklevel -= MAX_DARKNESS_LOS / 2; 338 darklevel -= LOS_MAX / 2;
354 339
355 /* add light, by finding all (non-null) nearby light sources, then 340 /* add light, by finding all (non-null) nearby light sources, then
356 * mark those squares specially. If the darklevel<1, there is no 341 * mark those squares specially. If the darklevel<1, there is no
357 * reason to do this, so we skip this function 342 * reason to do this, so we skip this function
358 */ 343 */
… …
370 } 355 }
371 356
372 /* first, make everything totally dark */ 357 /* first, make everything totally dark */
373 for (x = 0; x < op->contr->ns->mapx; x++) 358 for (x = 0; x < op->contr->ns->mapx; x++)
374 for (y = 0; y < op->contr->ns->mapy; y++) 359 for (y = 0; y < op->contr->ns->mapy; y++)
375 if (op->contr->blocked_los[x][y] != 100) 360 if (op->contr->blocked_los[x][y] != LOS_BLOCKED)
376 op->contr->blocked_los[x][y] = MAX_DARKNESS_LOS; 361 op->contr->blocked_los[x][y] = LOS_MAX;
377 362
378 int half_x = op->contr->ns->mapx / 2; 363 int half_x = op->contr->ns->mapx / 2;
379 int half_y = op->contr->ns->mapy / 2; 364 int half_y = op->contr->ns->mapy / 2;
380 365
381 int min_x = op->x - half_x - MAX_LIGHT_RADIUS; 366 int min_x = op->x - half_x - MAX_LIGHT_RADIUS;
… …
415 */ 400 */
416 const sint8 *darkness_table = darkness [light + MAX_LIGHT_RADIUS]; 401 const sint8 *darkness_table = darkness [light + MAX_LIGHT_RADIUS];
417 402
418 for (int ax = max (0, basex - light); ax <= min (basex + light, op->contr->ns->mapx - 1); ax++) 403 for (int ax = max (0, basex - light); ax <= min (basex + light, op->contr->ns->mapx - 1); ax++)
419 for (int ay = max (0, basey - light); ay <= min (basey + light, op->contr->ns->mapy - 1); ay++) 404 for (int ay = max (0, basey - light); ay <= min (basey + light, op->contr->ns->mapy - 1); ay++)
420 if (op->contr->blocked_los[ax][ay] != 100) 405 if (op->contr->blocked_los[ax][ay] != LOS_BLOCKED)
421 min_it (op->contr->blocked_los[ax][ay], darkness_table [idistance (ax - basex, ay - basey)]); 406 min_it (op->contr->blocked_los[ax][ay], darkness_table [idistance (ax - basex, ay - basey)]);
422 } 407 }
423 } 408 }
424 409
425 // psosibly do 2nd pass for rare negative glow radii 410 // possibly do 2nd pass for rare negative glow radii
426 if (pass2) 411 if (expect_false (pass2))
427 for (x = min_x, basex = -MAX_LIGHT_RADIUS; x <= max_x; x++, basex++) 412 for (x = min_x, basex = -MAX_LIGHT_RADIUS; x <= max_x; x++, basex++)
428 for (y = min_y, basey = -MAX_LIGHT_RADIUS; y <= max_y; y++, basey++) 413 for (y = min_y, basey = -MAX_LIGHT_RADIUS; y <= max_y; y++, basey++)
429 { 414 {
430 maptile *m = op->map; 415 maptile *m = op->map;
431 sint16 nx = x; 416 sint16 nx = x;
… …
442 { 427 {
443 const sint8 *darkness_table = darkness [light + MAX_LIGHT_RADIUS]; 428 const sint8 *darkness_table = darkness [light + MAX_LIGHT_RADIUS];
444 429
445 for (int ax = max (0, basex + light); ax <= min (basex - light, op->contr->ns->mapx - 1); ax++) 430 for (int ax = max (0, basex + light); ax <= min (basex - light, op->contr->ns->mapx - 1); ax++)
446 for (int ay = max (0, basey + light); ay <= min (basey - light, op->contr->ns->mapy - 1); ay++) 431 for (int ay = max (0, basey + light); ay <= min (basey - light, op->contr->ns->mapy - 1); ay++)
447 if (op->contr->blocked_los[ax][ay] != 100) 432 if (op->contr->blocked_los[ax][ay] != LOS_BLOCKED)
448 max_it (op->contr->blocked_los[ax][ay], darkness_table [idistance (ax - basex, ay - basey)]); 433 max_it (op->contr->blocked_los[ax][ay], darkness_table [idistance (ax - basex, ay - basey)]);
449 } 434 }
450 } 435 }
451 436
452 /* Outdoor should never really be completely pitch black dark like 437 /* Outdoor should never really be completely pitch black dark like
453 * a dungeon, so let the player at least see a little around themselves 438 * a dungeon, so let the player at least see a little around themselves
454 */ 439 */
455 if (op->map->outdoor && darklevel > MAX_DARKNESS - 3) 440 if (op->map->outdoor && darklevel > MAX_DARKNESS - 3)
456 { 441 {
457 if (op->contr->blocked_los[op->contr->ns->mapx / 2][op->contr->ns->mapy / 2] > (MAX_DARKNESS - 3)) 442 if (op->contr->blocked_los[op->contr->ns->mapx / 2][op->contr->ns->mapy / 2] > (LOS_MAX - 3))
458 op->contr->blocked_los[op->contr->ns->mapx / 2][op->contr->ns->mapy / 2] = MAX_DARKNESS - 3; 443 op->contr->blocked_los[op->contr->ns->mapx / 2][op->contr->ns->mapy / 2] = LOS_MAX - 3;
459 444
460 for (x = -1; x <= 1; x++) 445 for (x = -1; x <= 1; x++)
461 for (y = -1; y <= 1; y++) 446 for (y = -1; y <= 1; y++)
462 {
463 if (op->contr->blocked_los[x + op->contr->ns->mapx / 2][y + op->contr->ns->mapy / 2] > (MAX_DARKNESS - 2)) 447 if (op->contr->blocked_los[x + op->contr->ns->mapx / 2][y + op->contr->ns->mapy / 2] > (LOS_MAX - 2))
464 op->contr->blocked_los[x + op->contr->ns->mapx / 2][y + op->contr->ns->mapy / 2] = MAX_DARKNESS - 2; 448 op->contr->blocked_los[x + op->contr->ns->mapx / 2][y + op->contr->ns->mapy / 2] = LOS_MAX - 2;
465 }
466 } 449 }
467 450
468 /* grant some vision to the player, based on the darklevel */ 451 /* grant some vision to the player, based on the darklevel */
469 for (x = darklevel - MAX_DARKNESS; x < MAX_DARKNESS + 1 - darklevel; x++) 452 for (x = darklevel - MAX_DARKNESS; x < MAX_DARKNESS + 1 - darklevel; x++)
470 for (y = darklevel - MAX_DARKNESS; y < MAX_DARKNESS + 1 - darklevel; y++) 453 for (y = darklevel - MAX_DARKNESS; y < MAX_DARKNESS + 1 - darklevel; y++)
471 if (!(op->contr->blocked_los[x + op->contr->ns->mapx / 2][y + op->contr->ns->mapy / 2] == 100)) 454 if (!(op->contr->blocked_los[x + op->contr->ns->mapx / 2][y + op->contr->ns->mapy / 2] == LOS_BLOCKED))
472 op->contr->blocked_los[x + op->contr->ns->mapx / 2][y + op->contr->ns->mapy / 2] -= 455 op->contr->blocked_los[x + op->contr->ns->mapx / 2][y + op->contr->ns->mapy / 2] -=
473 max (0, 6 - darklevel - max (abs (x), abs (y))); 456 max (0, 6 - darklevel - max (abs (x), abs (y)));
474} 457}
475 458
476/* blinded_sight() - sets all viewable squares to blocked except 459/* blinded_sight() - sets all viewable squares to blocked except
… …
483{ 466{
484 int x, y; 467 int x, y;
485 468
486 for (x = 0; x < op->contr->ns->mapx; x++) 469 for (x = 0; x < op->contr->ns->mapx; x++)
487 for (y = 0; y < op->contr->ns->mapy; y++) 470 for (y = 0; y < op->contr->ns->mapy; y++)
488 op->contr->blocked_los[x][y] = 100; 471 op->contr->blocked_los[x][y] = LOS_BLOCKED;
489 472
490 op->contr->blocked_los[op->contr->ns->mapx / 2][op->contr->ns->mapy / 2] = 0; 473 op->contr->blocked_los[op->contr->ns->mapx / 2][op->contr->ns->mapy / 2] = 0;
491} 474}
492 475
493/* 476/*

Diff Legend

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