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.39 by root, Thu Dec 18 07:01:31 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 */
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)
… …
315 299
316 return 0; 300 return 0;
317} 301}
318 302
319/* radius, distance => lightness adjust */ 303/* radius, distance => lightness adjust */
320static sint8 darkness[MAX_LIGHT_RADIUS * 2 + 1][MAX_LIGHT_RADIUS + 1]; 304static sint8 darkness[MAX_LIGHT_RADIUS * 2 + 1][MAX_LIGHT_RADIUS * 3 / 2 + 1];
321 305
322static struct darkness_init 306static struct darkness_init
323{ 307{
324 darkness_init () 308 darkness_init ()
325 { 309 {
326 for (int radius = -MAX_LIGHT_RADIUS; radius <= MAX_LIGHT_RADIUS; ++radius) 310 for (int radius = -MAX_LIGHT_RADIUS; radius <= MAX_LIGHT_RADIUS; ++radius)
327 for (int distance = 0; distance <= MAX_LIGHT_RADIUS; ++distance) 311 for (int distance = 0; distance <= MAX_LIGHT_RADIUS * 3 / 2; ++distance)
328 { 312 {
329 // max intensity 313 // max intensity
330 int intensity = min (MAX_DARKNESS_LOS, abs (radius) + 1); 314 int intensity = min (LOS_MAX, abs (radius) + 1);
331 315
332 // actual intensity 316 // actual intensity
333 intensity = max (0, lerp_rd (distance, 0, abs (radius) + 1, intensity, 0)); 317 intensity = max (0, lerp_rd (distance, 0, abs (radius) + 1, intensity, 0));
334 318
335 darkness [radius + MAX_LIGHT_RADIUS][distance] = radius < 0 319 darkness [radius + MAX_LIGHT_RADIUS][distance] = radius < 0
336 ? intensity 320 ? min (3, intensity)
337 : MAX_DARKNESS_LOS - intensity; 321 : LOS_MAX - intensity;
338 } 322 }
339 } 323 }
340} darkness_init; 324} darkness_init;
341 325
326sint8
327los_brighten (sint8 b, sint8 l)
328{
329 return b == LOS_BLOCKED ? b : min (b, l);
330}
331
332sint8
333los_brighten_blocked (sint8 b, sint8 l)
334{
335 return min (b, l);
336}
337
338sint8
339los_darken (sint8 b, sint8 l)
340{
341 return max (b, l);
342}
343
344template<sint8 change_it (sint8, sint8)>
345static void
346apply_light (object *op, int basex, int basey, int light, const sint8 *darkness_table)
347{
348 // min or max the ciruclar area around basex, basey
349 player *pl = op->contr;
350
351 int ax0 = max (0, basex - light);
352 int ay0 = max (0, basey - light);
353 int ax1 = min (basex + light, pl->ns->mapx - 1);
354 int ay1 = min (basey + light, pl->ns->mapy - 1);
355
356 for (int ax = ax0; ax <= ax1; ax++)
357 for (int ay = ay0; ay <= ay1; ay++)
358 pl->blocked_los[ax][ay] =
359 change_it (pl->blocked_los[ax][ay], darkness_table [idistance (ax - basex, ay - basey)]);
360}
361
362/* add light, by finding all (non-null) nearby light sources, then
363 * mark those squares specially.
364 */
342static void 365static void
343expand_lighted_sight (object *op) 366expand_lighted_sight (object *op)
344{ 367{
345 int x, y, darklevel, basex, basey, mflags, light, x1, y1; 368 int darklevel, mflags, light, x1, y1;
346 maptile *m = op->map; 369 maptile *m = op->map;
347 sint16 nx, ny; 370 sint16 nx, ny;
348 371
349 darklevel = m->darkness; 372 darklevel = m->darkness;
350 373
351 /* If the player can see in the dark, lower the darklevel for him */ 374 /* If the player can see in the dark, lower the darklevel for him */
352 if (QUERY_FLAG (op, FLAG_SEE_IN_DARK)) 375 if (QUERY_FLAG (op, FLAG_SEE_IN_DARK))
353 darklevel -= MAX_DARKNESS_LOS / 2; 376 darklevel -= LOS_MAX / 2;
354
355 /* add light, by finding all (non-null) nearby light sources, then
356 * mark those squares specially. If the darklevel<1, there is no
357 * reason to do this, so we skip this function
358 */
359
360 if (darklevel < 1)
361 return;
362 377
363 /* Do a sanity check. If not valid, some code below may do odd 378 /* Do a sanity check. If not valid, some code below may do odd
364 * things. 379 * things.
365 */ 380 */
366 if (darklevel > MAX_DARKNESS) 381 if (darklevel > MAX_DARKNESS)
367 { 382 {
368 LOG (llevError, "Map darkness for %s on %s is too high (%d)\n", &op->name, &op->map->path, darklevel); 383 LOG (llevError, "Map darkness for %s on %s is too high (%d)\n", &op->name, &op->map->path, darklevel);
369 darklevel = MAX_DARKNESS; 384 darklevel = MAX_DARKNESS;
370 } 385 }
371 386
372 /* first, make everything totally dark */
373 for (x = 0; x < op->contr->ns->mapx; x++)
374 for (y = 0; y < op->contr->ns->mapy; y++)
375 if (op->contr->blocked_los[x][y] != 100)
376 op->contr->blocked_los[x][y] = MAX_DARKNESS_LOS;
377
378 int half_x = op->contr->ns->mapx / 2; 387 int half_x = op->contr->ns->mapx / 2;
379 int half_y = op->contr->ns->mapy / 2; 388 int half_y = op->contr->ns->mapy / 2;
380 389
381 int min_x = op->x - half_x - MAX_LIGHT_RADIUS; 390 int min_x = op->x - half_x - MAX_LIGHT_RADIUS;
382 int min_y = op->y - half_y - MAX_LIGHT_RADIUS; 391 int min_y = op->y - half_y - MAX_LIGHT_RADIUS;
383 int max_x = op->x + half_x + MAX_LIGHT_RADIUS; 392 int max_x = op->x + half_x + MAX_LIGHT_RADIUS;
384 int max_y = op->y + half_y + MAX_LIGHT_RADIUS; 393 int max_y = op->y + half_y + MAX_LIGHT_RADIUS;
385 394
386 int pass2 = 0; // negative lights have an extra pass 395 int pass2 = 0; // negative lights have an extra pass
387 396
388 /* 397 if (darklevel < 1)
398 pass2 = 1;
399 else
400 {
401 /* first, make everything totally dark */
402 for (int x = 0; x < op->contr->ns->mapx; x++)
403 for (int y = 0; y < op->contr->ns->mapy; y++)
404 if (op->contr->blocked_los[x][y] != LOS_BLOCKED)
405 op->contr->blocked_los[x][y] = LOS_MAX;
406
407 /*
389 * Only process the area of interest. 408 * Only process the area of interest.
390 * the basex, basey values represent the position in the op->contr->blocked_los 409 * the basex, basey values represent the position in the op->contr->blocked_los
391 * array. Its easier to just increment them here (and start with the right 410 * array. Its easier to just increment them here (and start with the right
392 * value) than to recalculate them down below. 411 * value) than to recalculate them down below.
393 */ 412 */
394 for (int x = min_x, basex = -MAX_LIGHT_RADIUS; x <= max_x; x++, basex++) 413 for (int x = min_x, basex = -MAX_LIGHT_RADIUS; x <= max_x; x++, basex++)
395 for (int y = min_y, basey = -MAX_LIGHT_RADIUS; y <= max_y; y++, basey++) 414 for (int y = min_y, basey = -MAX_LIGHT_RADIUS; y <= max_y; y++, basey++)
415 {
416 maptile *m = op->map;
417 sint16 nx = x;
418 sint16 ny = y;
419
420 if (!xy_normalise (m, nx, ny))
421 continue;
422
423 mapspace &ms = m->at (nx, ny);
424 ms.update ();
425 sint8 light = ms.light;
426
427 if (expect_false (light))
428 if (light < 0)
429 pass2 = 1;
430 else
431 apply_light<los_brighten> (op, basex, basey, light, darkness [light + MAX_LIGHT_RADIUS]);
432 }
433
434 /* grant some vision to the player, based on the darklevel */
435 /* for outdoor maps, ensure some mininum visibility radius */
396 { 436 {
397 maptile *m = op->map; 437 int light = clamp (MAX_DARKNESS - darklevel, op->map->outdoor ? 2 : 0, MAX_LIGHT_RADIUS);
398 sint16 nx = x;
399 sint16 ny = y;
400 438
401 if (!xy_normalise (m, nx, ny)) 439 apply_light<los_brighten_blocked> (op, half_x, half_y, light, darkness [light + MAX_LIGHT_RADIUS]);
402 continue;
403
404 mapspace &ms = m->at (nx, ny);
405 ms.update ();
406 sint8 light = ms.light;
407
408 if (expect_false (light))
409 if (light < 0)
410 pass2 = 1;
411 else
412 {
413 /* This space is providing light, so we need to brighten up the
414 * spaces around here.
415 */
416 const sint8 *darkness_table = darkness [light + MAX_LIGHT_RADIUS];
417
418 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++)
420 if (op->contr->blocked_los[ax][ay] != 100)
421 min_it (op->contr->blocked_los[ax][ay], darkness_table [idistance (ax - basex, ay - basey)]);
422 }
423 } 440 }
441 }
424 442
425 // psosibly do 2nd pass for rare negative glow radii 443 // possibly do 2nd pass for rare negative glow radii
444 // for effect, those are always considered to be stronger than anything else
445 // but they can't darken a place completely
426 if (pass2) 446 if (pass2)
427 for (x = min_x, basex = -MAX_LIGHT_RADIUS; x <= max_x; x++, basex++) 447 for (int 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++) 448 for (int y = min_y, basey = -MAX_LIGHT_RADIUS; y <= max_y; y++, basey++)
429 { 449 {
430 maptile *m = op->map; 450 maptile *m = op->map;
431 sint16 nx = x; 451 sint16 nx = x;
432 sint16 ny = y; 452 sint16 ny = y;
433 453
… …
437 mapspace &ms = m->at (nx, ny); 457 mapspace &ms = m->at (nx, ny);
438 ms.update (); 458 ms.update ();
439 sint8 light = ms.light; 459 sint8 light = ms.light;
440 460
441 if (expect_false (light < 0)) 461 if (expect_false (light < 0))
442 { 462 apply_light<los_darken> (op, basex, basey, -light, darkness [light + MAX_LIGHT_RADIUS]);
443 const sint8 *darkness_table = darkness [light + MAX_LIGHT_RADIUS];
444
445 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++)
447 if (op->contr->blocked_los[ax][ay] != 100)
448 max_it (op->contr->blocked_los[ax][ay], darkness_table [idistance (ax - basex, ay - basey)]);
449 }
450 }
451
452 /* Outdoor should never really be completely pitch black dark like
453 * a dungeon, so let the player at least see a little around themselves
454 */
455 if (op->map->outdoor && darklevel > MAX_DARKNESS - 3)
456 {
457 if (op->contr->blocked_los[op->contr->ns->mapx / 2][op->contr->ns->mapy / 2] > (MAX_DARKNESS - 3))
458 op->contr->blocked_los[op->contr->ns->mapx / 2][op->contr->ns->mapy / 2] = MAX_DARKNESS - 3;
459
460 for (x = -1; x <= 1; x++)
461 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))
464 op->contr->blocked_los[x + op->contr->ns->mapx / 2][y + op->contr->ns->mapy / 2] = MAX_DARKNESS - 2;
465 } 463 }
466 }
467
468 /* grant some vision to the player, based on the darklevel */
469 for (x = darklevel - MAX_DARKNESS; x < MAX_DARKNESS + 1 - darklevel; x++)
470 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))
472 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)));
474} 464}
475 465
476/* blinded_sight() - sets all viewable squares to blocked except 466/* blinded_sight() - sets all viewable squares to blocked except
477 * for the one the central one that the player occupies. A little 467 * for the one the central one that the player occupies. A little
478 * odd that you can see yourself (and what your standing on), but 468 * odd that you can see yourself (and what your standing on), but
… …
483{ 473{
484 int x, y; 474 int x, y;
485 475
486 for (x = 0; x < op->contr->ns->mapx; x++) 476 for (x = 0; x < op->contr->ns->mapx; x++)
487 for (y = 0; y < op->contr->ns->mapy; y++) 477 for (y = 0; y < op->contr->ns->mapy; y++)
488 op->contr->blocked_los[x][y] = 100; 478 op->contr->blocked_los[x][y] = LOS_BLOCKED;
489 479
490 op->contr->blocked_los[op->contr->ns->mapx / 2][op->contr->ns->mapy / 2] = 0; 480 op->contr->blocked_los[op->contr->ns->mapx / 2][op->contr->ns->mapy / 2] = 0;
491} 481}
492 482
493/* 483/*

Diff Legend

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