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

Diff Legend

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