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.23 by root, Fri Feb 16 22:21:45 2007 UTC vs.
Revision 1.37 by root, Thu Dec 18 02:49:22 2008 UTC

1/* 1/*
2 * CrossFire, A Multiplayer game for X-windows 2 * This file is part of Deliantra, the Roguelike Realtime MMORPG.
3 * 3 *
4 * Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team 4 * Copyright (©) 2005,2006,2007,2008 Marc Alexander Lehmann / Robin Redeker / the Deliantra team
5 * Copyright (C) 2002 Mark Wedel & Crossfire Development Team 5 * Copyright (©) 2002,2007 Mark Wedel & Crossfire Development Team
6 * Copyright (C) 1992 Frank Tore Johansen 6 * Copyright (©) 1992,2007 Frank Tore Johansen
7 * 7 *
8 * This program is free software; you can redistribute it and/or modify 8 * Deliantra is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by 9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or 10 * the Free Software Foundation, either version 3 of the License, or
11 * (at your option) any later version. 11 * (at your option) any later version.
12 * 12 *
13 * This program is distributed in the hope that it will be useful, 13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details. 16 * GNU General Public License for more details.
17 * 17 *
18 * You should have received a copy of the GNU General Public License 18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software 19 * along with this program. If not, see <http://www.gnu.org/licenses/>.
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 * 20 *
22 * The authors can be reached via e-mail at <crossfire@schmorp.de> 21 * The authors can be reached via e-mail to <support@deliantra.net>
23 */ 22 */
24 23
25/* Nov 95 - inserted USE_LIGHTING code stuff in here - b.t. */ 24/* Nov 95 - inserted USE_LIGHTING code stuff in here - b.t. */
26 25
27#include <global.h> 26#include <global.h>
28#include <funcpoint.h>
29#include <math.h> 27#include <math.h>
30 28
31/* Distance must be less than this for the object to be blocked. 29/* Distance must be less than this for the object to be blocked.
32 * 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
33 * that blocks half the view (0.0 is complete block) will 31 * that blocks half the view (0.0 is complete block) will
34 * block view in our tables. 32 * block view in our tables.
35 * .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.
36 */ 34 */
37
38#define SPACE_BLOCK 0.5 35#define SPACE_BLOCK 0.5
39 36
40typedef struct blstr 37typedef struct blstr
41{ 38{
42 int x[4], y[4]; 39 int x[4], y[4];
… …
89/* since we are only doing the upper left quadrant, only 86/* since we are only doing the upper left quadrant, only
90 * these spaces could possibly get blocked, since these 87 * these spaces could possibly get blocked, since these
91 * 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
92 * sightline. 89 * sightline.
93 */ 90 */
94
95void 91void
96init_block (void) 92init_block (void)
97{ 93{
98 int x, y, dx, dy, i;
99 static int block_x[3] = { -1, -1, 0 }, block_y[3] = 94 static int block_x[3] = { -1, -1, 0 },
100 { 95 block_y[3] = { -1, 0, -1 };
101 -1, 0, -1};
102 96
103 for (x = 0; x < MAP_CLIENT_X; x++) 97 for (int x = 0; x < MAP_CLIENT_X; x++)
104 for (y = 0; y < MAP_CLIENT_Y; y++) 98 for (int y = 0; y < MAP_CLIENT_Y; y++)
105 {
106 block[x][y].index = 0; 99 block[x][y].index = 0;
107 }
108
109 100
110 /* The table should be symmetric, so only do the upper left 101 /* The table should be symmetric, so only do the upper left
111 * quadrant - makes the processing easier. 102 * quadrant - makes the processing easier.
112 */ 103 */
113 for (x = 1; x <= MAP_CLIENT_X / 2; x++) 104 for (int x = 1; x <= MAP_CLIENT_X / 2; x++)
114 { 105 {
115 for (y = 1; y <= MAP_CLIENT_Y / 2; y++) 106 for (int y = 1; y <= MAP_CLIENT_Y / 2; y++)
116 { 107 {
117 for (i = 0; i < 3; i++) 108 for (int i = 0; i < 3; i++)
118 { 109 {
119 dx = x + block_x[i]; 110 int dx = x + block_x[i];
120 dy = y + block_y[i]; 111 int dy = y + block_y[i];
121 112
122 /* center space never blocks */ 113 /* center space never blocks */
123 if (x == MAP_CLIENT_X / 2 && y == MAP_CLIENT_Y / 2) 114 if (x == MAP_CLIENT_X / 2 && y == MAP_CLIENT_Y / 2)
124 continue; 115 continue;
125 116
… …
129 /* For simplicity, we mirror the coordinates to block the other 120 /* For simplicity, we mirror the coordinates to block the other
130 * quadrants. 121 * quadrants.
131 */ 122 */
132 set_block (x, y, dx, dy); 123 set_block (x, y, dx, dy);
133 if (x == MAP_CLIENT_X / 2) 124 if (x == MAP_CLIENT_X / 2)
134 {
135 set_block (x, MAP_CLIENT_Y - y - 1, dx, MAP_CLIENT_Y - dy - 1); 125 set_block (x, MAP_CLIENT_Y - y - 1, dx, MAP_CLIENT_Y - dy - 1);
136 }
137 else if (y == MAP_CLIENT_Y / 2) 126 else if (y == MAP_CLIENT_Y / 2)
138 {
139 set_block (MAP_CLIENT_X - x - 1, y, MAP_CLIENT_X - dx - 1, dy); 127 set_block (MAP_CLIENT_X - x - 1, y, MAP_CLIENT_X - dx - 1, dy);
140 }
141 } 128 }
142 else 129 else
143 { 130 {
144 float d1, r, s, l; 131 float d1, r, s, l;
145 132
146 /* We use the algorihm that found out how close the point 133 /* We use the algorithm that found out how close the point
147 * (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
148 * area. l is the distance from x,y to the line. 135 * area. l is the distance from x,y to the line.
149 * 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)
150 * the line is off 137 * the line is off
151 */ 138 */
152 139
153 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));
154 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;
155 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;
156 l = FABS (sqrt (d1) * s); 143 l = fabs (sqrtf (d1) * s);
157 144
158 if (l <= SPACE_BLOCK) 145 if (l <= SPACE_BLOCK)
159 { 146 {
160 /* For simplicity, we mirror the coordinates to block the other 147 /* For simplicity, we mirror the coordinates to block the other
161 * quadrants. 148 * quadrants.
… …
179 * that if some particular space is blocked, it blocks 166 * that if some particular space is blocked, it blocks
180 * the view of the spaces 'behind' it, and those blocked 167 * the view of the spaces 'behind' it, and those blocked
181 * spaces behind it may block other spaces, etc. 168 * spaces behind it may block other spaces, etc.
182 * In this way, the chain of visibility is set. 169 * In this way, the chain of visibility is set.
183 */ 170 */
184
185static void 171static void
186set_wall (object *op, int x, int y) 172set_wall (object *op, int x, int y)
187{ 173{
188 int i;
189
190 for (i = 0; i < block[x][y].index; i++) 174 for (int i = 0; i < block[x][y].index; i++)
191 { 175 {
192 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;
193 177
194 /* ax, ay are the values as adjusted to be in the 178 /* ax, ay are the values as adjusted to be in the
195 * socket look structure. 179 * socket look structure.
… …
204#endif 188#endif
205 /* we need to adjust to the fact that the socket 189 /* we need to adjust to the fact that the socket
206 * code wants the los to start from the 0,0 190 * code wants the los to start from the 0,0
207 * and not be relative to middle of los array. 191 * and not be relative to middle of los array.
208 */ 192 */
209 op->contr->blocked_los[ax][ay] = 100; 193 op->contr->blocked_los[ax][ay] = LOS_BLOCKED;
210 set_wall (op, dx, dy); 194 set_wall (op, dx, dy);
211 } 195 }
212} 196}
213 197
214/* 198/*
215 * Used to initialise the array used by the LOS routines. 199 * Used to initialise the array used by the LOS routines.
216 * 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.
217 * this is because they index the blocked[][] arrays. 201 * this is because they index the blocked[][] arrays.
218 */ 202 */
219
220static void 203static void
221check_wall (object *op, int x, int y) 204check_wall (object *op, int x, int y)
222{ 205{
223 int ax, ay; 206 int ax, ay;
224 207
… …
242 225
243 /* If this space is already blocked, prune the processing - presumably 226 /* If this space is already blocked, prune the processing - presumably
244 * 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
245 * done the dependency chain. 228 * done the dependency chain.
246 */ 229 */
247 if (op->contr->blocked_los[ax][ay] == 100) 230 if (op->contr->blocked_los[ax][ay] == LOS_BLOCKED)
248 return; 231 return;
249
250 232
251 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))
252 set_wall (op, x, y); 234 set_wall (op, x, y);
253} 235}
254 236
… …
256 * Clears/initialises the los-array associated to the player 238 * Clears/initialises the los-array associated to the player
257 * controlling the object. 239 * controlling the object.
258 */ 240 */
259 241
260void 242void
261clear_los (object *op) 243clear_los (player *pl)
262{ 244{
263 /* This is safer than using the ns->mapx, mapy because 245 /* This is safer than using the ns->mapx, mapy because
264 * we index the blocked_los as a 2 way array, so clearing 246 * we index the blocked_los as a 2 way array, so clearing
265 * the first z spaces may not not cover the spaces we are 247 * the first z spaces may not not cover the spaces we are
266 * actually going to use 248 * actually going to use
267 */ 249 */
268 (void) memset ((void *) op->contr->blocked_los, 0, MAP_CLIENT_X * MAP_CLIENT_Y); 250 memset (pl->blocked_los, 0, MAP_CLIENT_X * MAP_CLIENT_Y);
269} 251}
270 252
271/* 253/*
272 * 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
273 * 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,
274 * to a certain degree, be able to see into corners. 256 * to a certain degree, be able to see into corners.
275 * This is somewhat suboptimal, would be better to improve the formula. 257 * This is somewhat suboptimal, would be better to improve the formula.
276 */ 258 */
277
278static void 259static void
279expand_sight (object *op) 260expand_sight (object *op)
280{ 261{
281 int i, x, y, dx, dy;
282
283 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 */
284 for (y = 1; y < op->contr->ns->mapy - 1; y++) 263 for (int y = 1; y < op->contr->ns->mapy - 1; y++)
285 {
286 if (!op->contr->blocked_los[x][y] && 264 if (!op->contr->blocked_los[x][y] &&
287 !(get_map_flags (op->map, NULL, 265 !(get_map_flags (op->map, NULL,
288 op->x - op->contr->ns->mapx / 2 + x, 266 op->x - op->contr->ns->mapx / 2 + x,
289 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)))
290 { 268 {
291
292 for (i = 1; i <= 8; i += 1) 269 for (int i = 1; i <= 8; i += 1)
293 { /* mark all directions */ 270 { /* mark all directions */
294 dx = x + freearr_x[i]; 271 int dx = x + freearr_x[i];
295 dy = y + freearr_y[i]; 272 int dy = y + freearr_y[i];
273
296 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 */
297 op->contr->blocked_los[dx][dy] = -1; 275 op->contr->blocked_los[dx][dy] = -1;
298 } 276 }
299 } 277 }
300 }
301 278
302 if (op->map->darkness > 0) /* player is on a dark map */ 279 if (op->map->darkness > 0) /* player is on a dark map */
303 expand_lighted_sight (op); 280 expand_lighted_sight (op);
304 281
305 /* clear mark squares */ 282 /* clear mark squares */
306 for (x = 0; x < op->contr->ns->mapx; x++) 283 for (int x = 0; x < op->contr->ns->mapx; x++)
307 for (y = 0; y < op->contr->ns->mapy; y++) 284 for (int y = 0; y < op->contr->ns->mapy; y++)
308 if (op->contr->blocked_los[x][y] < 0) 285 if (op->contr->blocked_los[x][y] < 0)
309 op->contr->blocked_los[x][y] = 0; 286 op->contr->blocked_los[x][y] = 0;
310} 287}
311 288
312/* returns true if op carries one or more lights 289/* returns true if op carries one or more lights
313 * This is a trivial function now days, but it used to 290 * This is a trivial function now days, but it used to
314 * be a bit longer. Probably better for callers to just 291 * be a bit longer. Probably better for callers to just
315 * check the op->glow_radius instead of calling this. 292 * check the op->glow_radius instead of calling this.
316 */ 293 */
317
318int 294int
319has_carried_lights (const object *op) 295has_carried_lights (const object *op)
320{ 296{
321 /* op may glow! */ 297 /* op may glow! */
322 if (op->glow_radius > 0) 298 if (op->glow_radius > 0)
323 return 1; 299 return 1;
324 300
325 return 0; 301 return 0;
326} 302}
327 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
328static void 327static void
329expand_lighted_sight (object *op) 328expand_lighted_sight (object *op)
330{ 329{
331 int x, y, darklevel, ax, ay, basex, basey, mflags, light, x1, y1; 330 int x, y, darklevel, basex, basey, mflags, light, x1, y1;
332 maptile *m = op->map; 331 maptile *m = op->map;
333 sint16 nx, ny; 332 sint16 nx, ny;
334 333
335 darklevel = m->darkness; 334 darklevel = m->darkness;
336 335
337 /* 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 */
338 if (QUERY_FLAG (op, FLAG_SEE_IN_DARK)) 337 if (QUERY_FLAG (op, FLAG_SEE_IN_DARK))
339 darklevel -= 2; 338 darklevel -= LOS_MAX / 2;
340 339
341 /* add light, by finding all (non-null) nearby light sources, then 340 /* add light, by finding all (non-null) nearby light sources, then
342 * mark those squares specially. If the darklevel<1, there is no 341 * mark those squares specially. If the darklevel<1, there is no
343 * reason to do this, so we skip this function 342 * reason to do this, so we skip this function
344 */ 343 */
… …
353 { 352 {
354 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);
355 darklevel = MAX_DARKNESS; 354 darklevel = MAX_DARKNESS;
356 } 355 }
357 356
358 /* First, limit player furthest (unlighted) vision */ 357 /* first, make everything totally dark */
359 for (x = 0; x < op->contr->ns->mapx; x++) 358 for (x = 0; x < op->contr->ns->mapx; x++)
360 for (y = 0; y < op->contr->ns->mapy; y++) 359 for (y = 0; y < op->contr->ns->mapy; y++)
361 if (op->contr->blocked_los[x][y] != 100) 360 if (op->contr->blocked_los[x][y] != LOS_BLOCKED)
362 op->contr->blocked_los[x][y] = MAX_LIGHT_RADII; 361 op->contr->blocked_los[x][y] = LOS_MAX;
363 362
364 /* 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 /*
365 * Only process the area of interest. 374 * Only process the area of interest.
366 * 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
367 * 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
368 * value) than to recalculate them down below. 377 * value) than to recalculate them down below.
369 */ 378 */
370 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++)
371 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++)
372 {
373
374 for (y = (op->y - op->contr->ns->mapy / 2 - MAX_LIGHT_RADII), basey = -MAX_LIGHT_RADII;
375 y <= (op->y + op->contr->ns->mapy / 2 + MAX_LIGHT_RADII); y++, basey++)
376 { 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 // psosibly 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 {
377 m = op->map; 415 maptile *m = op->map;
378 nx = x; 416 sint16 nx = x;
379 ny = y; 417 sint16 ny = y;
380 418
381 mflags = get_map_flags (m, &m, nx, ny, &nx, &ny); 419 if (!xy_normalise (m, nx, ny))
382
383 if (mflags & P_OUT_OF_MAP)
384 continue; 420 continue;
385 421
386 /* This space is providing light, so we need to brighten up the 422 mapspace &ms = m->at (nx, ny);
387 * spaces around here. 423 ms.update ();
388 */ 424 sint8 light = ms.light;
389 light = GET_MAP_LIGHT (m, nx, ny); 425
390 if (light != 0) 426 if (expect_false (light < 0))
391 { 427 {
392#if 0 428 const sint8 *darkness_table = darkness [light + MAX_LIGHT_RADIUS];
393 LOG (llevDebug, "expand_lighted_sight: Found light at x=%d, y=%d, basex=%d, basey=%d\n", x, y, basex, basey);
394#endif
395 for (ax = basex - light; ax <= basex + light; ax++)
396 {
397 if (ax < 0 || ax >= op->contr->ns->mapx)
398 continue;
399 429
400 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++)
401 { 431 for (int ay = max (0, basey + light); ay <= min (basey - light, op->contr->ns->mapy - 1); ay++)
402 if (ay < 0 || ay >= op->contr->ns->mapy)
403 continue;
404
405 /* If the space is fully blocked, do nothing. Otherwise, we
406 * brighten the space. The further the light is away from the
407 * source (basex-x), the less effect it has. Though light used
408 * to dim in a square manner, it now dims in a circular manner
409 * using the the pythagorean theorem. glow_radius still
410 * represents the radius
411 */
412 if (op->contr->blocked_los[ax][ay] != 100) 432 if (op->contr->blocked_los[ax][ay] != LOS_BLOCKED)
413 { 433 max_it (op->contr->blocked_los[ax][ay], darkness_table [idistance (ax - basex, ay - basey)]);
414 x1 = abs (basex - ax) * abs (basex - ax);
415 y1 = abs (basey - ay) * abs (basey - ay);
416
417 if (light > 0) op->contr->blocked_los[ax][ay] -= max (light - isqrt (x1 + y1), 0);
418 if (light < 0) op->contr->blocked_los[ax][ay] -= min (light + isqrt (x1 + y1), 0);
419 }
420 }
421 }
422 } 434 }
423 } 435 }
424 }
425 436
426 /* Outdoor should never really be completely pitch black dark like 437 /* Outdoor should never really be completely pitch black dark like
427 * 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
428 */ 439 */
429 if (op->map->outdoor && darklevel > (MAX_DARKNESS - 3)) 440 if (op->map->outdoor && darklevel > MAX_DARKNESS - 3)
430 { 441 {
431 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))
432 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;
433 444
434 for (x = -1; x <= 1; x++) 445 for (x = -1; x <= 1; x++)
435 for (y = -1; y <= 1; y++) 446 for (y = -1; y <= 1; y++)
436 {
437 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))
438 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;
439 }
440 } 449 }
441 450
442 /* grant some vision to the player, based on the darklevel */ 451 /* grant some vision to the player, based on the darklevel */
443 for (x = darklevel - MAX_DARKNESS; x < MAX_DARKNESS + 1 - darklevel; x++) 452 for (x = darklevel - MAX_DARKNESS; x < MAX_DARKNESS + 1 - darklevel; x++)
444 for (y = darklevel - MAX_DARKNESS; y < MAX_DARKNESS + 1 - darklevel; y++) 453 for (y = darklevel - MAX_DARKNESS; y < MAX_DARKNESS + 1 - darklevel; y++)
445 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))
446 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] -=
447 MAX (0, 6 - darklevel - MAX (abs (x), abs (y))); 456 max (0, 6 - darklevel - max (abs (x), abs (y)));
448} 457}
449 458
450/* blinded_sight() - sets all veiwable squares to blocked except 459/* blinded_sight() - sets all viewable squares to blocked except
451 * 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
452 * 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
453 * really need for any reasonable game play. 462 * really need for any reasonable game play.
454 */ 463 */
455static void 464static void
… …
457{ 466{
458 int x, y; 467 int x, y;
459 468
460 for (x = 0; x < op->contr->ns->mapx; x++) 469 for (x = 0; x < op->contr->ns->mapx; x++)
461 for (y = 0; y < op->contr->ns->mapy; y++) 470 for (y = 0; y < op->contr->ns->mapy; y++)
462 op->contr->blocked_los[x][y] = 100; 471 op->contr->blocked_los[x][y] = LOS_BLOCKED;
463 472
464 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;
465} 474}
466 475
467/* 476/*
468 * update_los() recalculates the array which specifies what is 477 * update_los() recalculates the array which specifies what is
469 * visible for the given player-object. 478 * visible for the given player-object.
470 */ 479 */
471
472void 480void
473update_los (object *op) 481update_los (object *op)
474{ 482{
475 int dx = op->contr->ns->mapx / 2, dy = op->contr->ns->mapy / 2, x, y; 483 int dx = op->contr->ns->mapx / 2, dy = op->contr->ns->mapy / 2, x, y;
476 484
477 if (QUERY_FLAG (op, FLAG_REMOVED)) 485 if (QUERY_FLAG (op, FLAG_REMOVED))
478 return; 486 return;
479 487
480 clear_los (op); 488 clear_los (op->contr);
489
481 if (QUERY_FLAG (op, FLAG_WIZ) /* ||XRAYS(op) */ ) 490 if (QUERY_FLAG (op, FLAG_WIZ) /* ||XRAYS(op) */ )
482 return; 491 return;
483 492
484 /* For larger maps, this is more efficient than the old way which 493 /* For larger maps, this is more efficient than the old way which
485 * used the chaining of the block array. Since many space views could 494 * used the chaining of the block array. Since many space views could

Diff Legend

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