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.21 by root, Thu Feb 15 03:19:02 2007 UTC vs.
Revision 1.40 by root, Fri Dec 19 17:52:50 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];
43 int index; 40 int index;
44} blocks; 41} blocks;
45 42
43// 31/32 == a speed hack
44// we would like to use 32 for speed, but the code loops endlessly
45// then, reason not yet identified, so only make the array use 32,
46// not the define's.
46blocks block[MAP_CLIENT_X][MAP_CLIENT_Y]; 47blocks block[MAP_CLIENT_X][MAP_CLIENT_Y == 31 ? 32 : MAP_CLIENT_Y];
47 48
48static void expand_lighted_sight (object *op); 49static void expand_lighted_sight (object *op);
49 50
50/* 51/*
51 * Used to initialise the array used by the LOS routines. 52 * Used to initialise the array used by the LOS routines.
… …
85/* since we are only doing the upper left quadrant, only 86/* since we are only doing the upper left quadrant, only
86 * these spaces could possibly get blocked, since these 87 * these spaces could possibly get blocked, since these
87 * 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
88 * sightline. 89 * sightline.
89 */ 90 */
90
91void 91void
92init_block (void) 92init_block (void)
93{ 93{
94 int x, y, dx, dy, i;
95 static int block_x[3] = { -1, -1, 0 }, block_y[3] = 94 static int block_x[3] = { -1, -1, 0 },
96 { 95 block_y[3] = { -1, 0, -1 };
97 -1, 0, -1};
98 96
99 for (x = 0; x < MAP_CLIENT_X; x++) 97 for (int x = 0; x < MAP_CLIENT_X; x++)
100 for (y = 0; y < MAP_CLIENT_Y; y++) 98 for (int y = 0; y < MAP_CLIENT_Y; y++)
101 {
102 block[x][y].index = 0; 99 block[x][y].index = 0;
103 }
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
… …
125 /* For simplicity, we mirror the coordinates to block the other 120 /* For simplicity, we mirror the coordinates to block the other
126 * quadrants. 121 * quadrants.
127 */ 122 */
128 set_block (x, y, dx, dy); 123 set_block (x, y, dx, dy);
129 if (x == MAP_CLIENT_X / 2) 124 if (x == MAP_CLIENT_X / 2)
130 {
131 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);
132 }
133 else if (y == MAP_CLIENT_Y / 2) 126 else if (y == MAP_CLIENT_Y / 2)
134 {
135 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);
136 }
137 } 128 }
138 else 129 else
139 { 130 {
140 float d1, r, s, l; 131 float d1, r, s, l;
141 132
142 /* We use the algorihm that found out how close the point 133 /* We use the algorithm that found out how close the point
143 * (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
144 * area. l is the distance from x,y to the line. 135 * area. l is the distance from x,y to the line.
145 * 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)
146 * the line is off 137 * the line is off
147 */ 138 */
148 139
149 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));
150 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;
151 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;
152 l = FABS (sqrt (d1) * s); 143 l = fabs (sqrtf (d1) * s);
153 144
154 if (l <= SPACE_BLOCK) 145 if (l <= SPACE_BLOCK)
155 { 146 {
156 /* For simplicity, we mirror the coordinates to block the other 147 /* For simplicity, we mirror the coordinates to block the other
157 * quadrants. 148 * quadrants.
… …
175 * that if some particular space is blocked, it blocks 166 * that if some particular space is blocked, it blocks
176 * the view of the spaces 'behind' it, and those blocked 167 * the view of the spaces 'behind' it, and those blocked
177 * spaces behind it may block other spaces, etc. 168 * spaces behind it may block other spaces, etc.
178 * In this way, the chain of visibility is set. 169 * In this way, the chain of visibility is set.
179 */ 170 */
180
181static void 171static void
182set_wall (object *op, int x, int y) 172set_wall (object *op, int x, int y)
183{ 173{
184 int i;
185
186 for (i = 0; i < block[x][y].index; i++) 174 for (int i = 0; i < block[x][y].index; i++)
187 { 175 {
188 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;
189 177
190 /* ax, ay are the values as adjusted to be in the 178 /* ax, ay are the values as adjusted to be in the
191 * socket look structure. 179 * socket look structure.
… …
200#endif 188#endif
201 /* we need to adjust to the fact that the socket 189 /* we need to adjust to the fact that the socket
202 * code wants the los to start from the 0,0 190 * code wants the los to start from the 0,0
203 * and not be relative to middle of los array. 191 * and not be relative to middle of los array.
204 */ 192 */
205 op->contr->blocked_los[ax][ay] = 100; 193 op->contr->blocked_los[ax][ay] = LOS_BLOCKED;
206 set_wall (op, dx, dy); 194 set_wall (op, dx, dy);
207 } 195 }
208} 196}
209 197
210/* 198/*
211 * Used to initialise the array used by the LOS routines. 199 * Used to initialise the array used by the LOS routines.
212 * 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.
213 * this is because they index the blocked[][] arrays. 201 * this is because they index the blocked[][] arrays.
214 */ 202 */
215
216static void 203static void
217check_wall (object *op, int x, int y) 204check_wall (object *op, int x, int y)
218{ 205{
219 int ax, ay; 206 int ax, ay;
220 207
… …
238 225
239 /* If this space is already blocked, prune the processing - presumably 226 /* If this space is already blocked, prune the processing - presumably
240 * 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
241 * done the dependency chain. 228 * done the dependency chain.
242 */ 229 */
243 if (op->contr->blocked_los[ax][ay] == 100) 230 if (op->contr->blocked_los[ax][ay] == LOS_BLOCKED)
244 return; 231 return;
245
246 232
247 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))
248 set_wall (op, x, y); 234 set_wall (op, x, y);
249} 235}
250 236
… …
252 * Clears/initialises the los-array associated to the player 238 * Clears/initialises the los-array associated to the player
253 * controlling the object. 239 * controlling the object.
254 */ 240 */
255 241
256void 242void
257clear_los (object *op) 243clear_los (player *pl)
258{ 244{
259 /* This is safer than using the ns->mapx, mapy because 245 /* This is safer than using the ns->mapx, mapy because
260 * 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
261 * 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
262 * actually going to use 248 * actually going to use
263 */ 249 */
264 (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);
265} 251}
266 252
267/* 253/*
268 * 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
269 * 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,
270 * to a certain degree, be able to see into corners. 256 * to a certain degree, be able to see into corners.
271 * This is somewhat suboptimal, would be better to improve the formula. 257 * This is somewhat suboptimal, would be better to improve the formula.
272 */ 258 */
273
274static void 259static void
275expand_sight (object *op) 260expand_sight (object *op)
276{ 261{
277 int i, x, y, dx, dy;
278
279 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 */
280 for (y = 1; y < op->contr->ns->mapy - 1; y++) 263 for (int y = 1; y < op->contr->ns->mapy - 1; y++)
281 {
282 if (!op->contr->blocked_los[x][y] && 264 if (!op->contr->blocked_los[x][y] &&
283 !(get_map_flags (op->map, NULL, 265 !(get_map_flags (op->map, NULL,
284 op->x - op->contr->ns->mapx / 2 + x, 266 op->x - op->contr->ns->mapx / 2 + x,
285 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)))
286 { 268 {
287
288 for (i = 1; i <= 8; i += 1) 269 for (int i = 1; i <= 8; i += 1)
289 { /* mark all directions */ 270 { /* mark all directions */
290 dx = x + freearr_x[i]; 271 int dx = x + freearr_x[i];
291 dy = y + freearr_y[i]; 272 int dy = y + freearr_y[i];
273
292 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 */
293 op->contr->blocked_los[dx][dy] = -1; 275 op->contr->blocked_los[dx][dy] = -1;
294 } 276 }
295 } 277 }
296 }
297 278
298 if (op->map->darkness > 0) /* player is on a dark map */
299 expand_lighted_sight (op); 279 expand_lighted_sight (op);
300 280
301 /* clear mark squares */ 281 /* clear mark squares */
302 for (x = 0; x < op->contr->ns->mapx; x++) 282 for (int x = 0; x < op->contr->ns->mapx; x++)
303 for (y = 0; y < op->contr->ns->mapy; y++) 283 for (int y = 0; y < op->contr->ns->mapy; y++)
304 if (op->contr->blocked_los[x][y] < 0) 284 if (op->contr->blocked_los[x][y] < 0)
305 op->contr->blocked_los[x][y] = 0; 285 op->contr->blocked_los[x][y] = 0;
306} 286}
307 287
308/* returns true if op carries one or more lights 288/* returns true if op carries one or more lights
309 * This is a trivial function now days, but it used to 289 * This is a trivial function now days, but it used to
310 * be a bit longer. Probably better for callers to just 290 * be a bit longer. Probably better for callers to just
311 * check the op->glow_radius instead of calling this. 291 * check the op->glow_radius instead of calling this.
312 */ 292 */
313
314int 293int
315has_carried_lights (const object *op) 294has_carried_lights (const object *op)
316{ 295{
317 /* op may glow! */ 296 /* op may glow! */
318 if (op->glow_radius > 0) 297 if (op->glow_radius > 0)
319 return 1; 298 return 1;
320 299
321 return 0; 300 return 0;
322} 301}
323 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 */
324static void 359static void
325expand_lighted_sight (object *op) 360expand_lighted_sight (object *op)
326{ 361{
327 int x, y, darklevel, ax, ay, basex, basey, mflags, light, x1, y1; 362 int darklevel, mflags, light, x1, y1;
328 maptile *m = op->map; 363 maptile *m = op->map;
329 sint16 nx, ny; 364 sint16 nx, ny;
330 365
331 darklevel = m->darkness; 366 darklevel = m->darkness;
332 367
333 /* 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 */
334 if (QUERY_FLAG (op, FLAG_SEE_IN_DARK)) 369 if (QUERY_FLAG (op, FLAG_SEE_IN_DARK))
335 darklevel -= 2; 370 darklevel -= LOS_MAX / 2;
336
337 /* add light, by finding all (non-null) nearby light sources, then
338 * mark those squares specially. If the darklevel<1, there is no
339 * reason to do this, so we skip this function
340 */
341
342 if (darklevel < 1)
343 return;
344 371
345 /* 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
346 * things. 373 * things.
347 */ 374 */
348 if (darklevel > MAX_DARKNESS) 375 if (darklevel > MAX_DARKNESS)
349 { 376 {
350 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);
351 darklevel = MAX_DARKNESS; 378 darklevel = MAX_DARKNESS;
352 } 379 }
353 380
354 /* 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 */
355 for (x = 0; x < op->contr->ns->mapx; x++) 396 for (int x = 0; x < op->contr->ns->mapx; x++)
356 for (y = 0; y < op->contr->ns->mapy; y++) 397 for (int y = 0; y < op->contr->ns->mapy; y++)
357 if (op->contr->blocked_los[x][y] != 100) 398 if (op->contr->blocked_los[x][y] != LOS_BLOCKED)
358 op->contr->blocked_los[x][y] = MAX_LIGHT_RADII; 399 op->contr->blocked_los[x][y] = LOS_MAX;
359 400
360 /* the spaces[] darkness value contains the information we need. 401 /*
361 * Only process the area of interest. 402 * Only process the area of interest.
362 * 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
363 * 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
364 * value) than to recalculate them down below. 405 * value) than to recalculate them down below.
365 */ 406 */
366 for (x = (op->x - op->contr->ns->mapx / 2 - MAX_LIGHT_RADII), basex = -MAX_LIGHT_RADII; 407 for (int x = min_x, basex = -MAX_LIGHT_RADIUS; x <= max_x; x++, basex++)
367 x <= (op->x + op->contr->ns->mapx / 2 + MAX_LIGHT_RADII); x++, basex++) 408 for (int y = min_y, basey = -MAX_LIGHT_RADIUS; y <= max_y; y++, basey++)
368 {
369
370 for (y = (op->y - op->contr->ns->mapy / 2 - MAX_LIGHT_RADII), basey = -MAX_LIGHT_RADII;
371 y <= (op->y + op->contr->ns->mapy / 2 + MAX_LIGHT_RADII); y++, basey++)
372 { 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 {
373 m = op->map; 444 maptile *m = op->map;
374 nx = x; 445 sint16 nx = x;
375 ny = y; 446 sint16 ny = y;
376 447
377 mflags = get_map_flags (m, &m, nx, ny, &nx, &ny); 448 if (!xy_normalise (m, nx, ny))
378
379 if (mflags & P_OUT_OF_MAP)
380 continue; 449 continue;
381 450
382 /* This space is providing light, so we need to brighten up the 451 mapspace &ms = m->at (nx, ny);
383 * spaces around here. 452 ms.update ();
384 */ 453 sint8 light = ms.light;
385 light = GET_MAP_LIGHT (m, nx, ny);
386 if (light != 0)
387 {
388#if 0
389 LOG (llevDebug, "expand_lighted_sight: Found light at x=%d, y=%d, basex=%d, basey=%d\n", x, y, basex, basey);
390#endif
391 for (ax = basex - light; ax <= basex + light; ax++)
392 {
393 if (ax < 0 || ax >= op->contr->ns->mapx)
394 continue;
395 454
396 for (ay = basey - light; ay <= basey + light; ay++) 455 if (expect_false (light < 0))
397 { 456 apply_light<los_darken> (op, basex, basey, -light, darkness [light + MAX_LIGHT_RADIUS]);
398 if (ay < 0 || ay >= op->contr->ns->mapy)
399 continue;
400
401 /* If the space is fully blocked, do nothing. Otherwise, we
402 * brighten the space. The further the light is away from the
403 * source (basex-x), the less effect it has. Though light used
404 * to dim in a square manner, it now dims in a circular manner
405 * using the the pythagorean theorem. glow_radius still
406 * represents the radius
407 */
408 if (op->contr->blocked_los[ax][ay] != 100)
409 {
410 x1 = abs (basex - ax) * abs (basex - ax);
411 y1 = abs (basey - ay) * abs (basey - ay);
412
413 if (light > 0) op->contr->blocked_los[ax][ay] -= max (light - isqrt (x1 + y1), 0);
414 if (light < 0) op->contr->blocked_los[ax][ay] -= min (light + isqrt (x1 + y1), 0);
415 }
416 }
417 }
418 }
419 }
420 }
421
422 /* Outdoor should never really be completely pitch black dark like
423 * a dungeon, so let the player at least see a little around themselves
424 */
425 if (op->map->outdoor && darklevel > (MAX_DARKNESS - 3))
426 {
427 if (op->contr->blocked_los[op->contr->ns->mapx / 2][op->contr->ns->mapy / 2] > (MAX_DARKNESS - 3))
428 op->contr->blocked_los[op->contr->ns->mapx / 2][op->contr->ns->mapy / 2] = MAX_DARKNESS - 3;
429
430 for (x = -1; x <= 1; x++)
431 for (y = -1; y <= 1; y++)
432 {
433 if (op->contr->blocked_los[x + op->contr->ns->mapx / 2][y + op->contr->ns->mapy / 2] > (MAX_DARKNESS - 2))
434 op->contr->blocked_los[x + op->contr->ns->mapx / 2][y + op->contr->ns->mapy / 2] = MAX_DARKNESS - 2;
435 } 457 }
436 }
437
438 /* grant some vision to the player, based on the darklevel */
439 for (x = darklevel - MAX_DARKNESS; x < MAX_DARKNESS + 1 - darklevel; x++)
440 for (y = darklevel - MAX_DARKNESS; y < MAX_DARKNESS + 1 - darklevel; y++)
441 if (!(op->contr->blocked_los[x + op->contr->ns->mapx / 2][y + op->contr->ns->mapy / 2] == 100))
442 op->contr->blocked_los[x + op->contr->ns->mapx / 2][y + op->contr->ns->mapy / 2] -=
443 MAX (0, 6 - darklevel - MAX (abs (x), abs (y)));
444} 458}
445 459
446/* blinded_sight() - sets all veiwable squares to blocked except 460/* blinded_sight() - sets all viewable squares to blocked except
447 * 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
448 * 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 * really need for any reasonable game play. 463 * really need for any reasonable game play.
450 */ 464 */
451static void 465static void
… …
453{ 467{
454 int x, y; 468 int x, y;
455 469
456 for (x = 0; x < op->contr->ns->mapx; x++) 470 for (x = 0; x < op->contr->ns->mapx; x++)
457 for (y = 0; y < op->contr->ns->mapy; y++) 471 for (y = 0; y < op->contr->ns->mapy; y++)
458 op->contr->blocked_los[x][y] = 100; 472 op->contr->blocked_los[x][y] = LOS_BLOCKED;
459 473
460 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;
461} 475}
462 476
463/* 477/*
464 * update_los() recalculates the array which specifies what is 478 * update_los() recalculates the array which specifies what is
465 * visible for the given player-object. 479 * visible for the given player-object.
466 */ 480 */
467
468void 481void
469update_los (object *op) 482update_los (object *op)
470{ 483{
471 int dx = op->contr->ns->mapx / 2, dy = op->contr->ns->mapy / 2, x, y; 484 int dx = op->contr->ns->mapx / 2, dy = op->contr->ns->mapy / 2, x, y;
472 485
473 if (QUERY_FLAG (op, FLAG_REMOVED)) 486 if (QUERY_FLAG (op, FLAG_REMOVED))
474 return; 487 return;
475 488
476 clear_los (op); 489 clear_los (op->contr);
490
477 if (QUERY_FLAG (op, FLAG_WIZ) /* ||XRAYS(op) */ ) 491 if (QUERY_FLAG (op, FLAG_WIZ) /* ||XRAYS(op) */ )
478 return; 492 return;
479 493
480 /* For larger maps, this is more efficient than the old way which 494 /* For larger maps, this is more efficient than the old way which
481 * used the chaining of the block array. Since many space views could 495 * used the chaining of the block array. Since many space views could

Diff Legend

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