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.40 by root, Fri Dec 19 17:52:50 2008 UTC vs.
Revision 1.54 by root, Sat Dec 27 07:50:05 2008 UTC

… …
19 * along with this program. If not, see <http://www.gnu.org/licenses/>. 19 * along with this program. If not, see <http://www.gnu.org/licenses/>.
20 * 20 *
21 * The authors can be reached via e-mail to <support@deliantra.net> 21 * The authors can be reached via e-mail to <support@deliantra.net>
22 */ 22 */
23 23
24/* Nov 95 - inserted USE_LIGHTING code stuff in here - b.t. */
25
26#include <global.h> 24#include <global.h>
27#include <math.h> 25#include <cmath>
28 26
29/* Distance must be less than this for the object to be blocked. 27#define SEE_IN_DARK_RADIUS 3
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
32 * block view in our tables.
33 * .4 or less lets you see through walls. .5 is about right.
34 */
35#define SPACE_BLOCK 0.5
36 28
37typedef struct blstr 29// los flags
38{ 30enum {
39 int x[4], y[4]; 31 FLG_XI = 0x01, // we have an x-parent
40 int index; 32 FLG_YI = 0x02, // we have an y-parent
41} blocks; 33 FLG_BLOCKED = 0x04, // this space blocks the view
34 FLG_QUEUED = 0x80 // already queued in queue, or border
35};
42 36
43// 31/32 == a speed hack 37struct los_info
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.
47blocks block[MAP_CLIENT_X][MAP_CLIENT_Y == 31 ? 32 : MAP_CLIENT_Y];
48
49static void expand_lighted_sight (object *op);
50
51/*
52 * Used to initialise the array used by the LOS routines.
53 * What this sets if that x,y blocks the view of bx,by
54 * This then sets up a relation - for example, something
55 * at 5,4 blocks view at 5,3 which blocks view at 5,2
56 * etc. So when we check 5,4 and find it block, we have
57 * the data to know that 5,3 and 5,2 and 5,1 should also
58 * be blocked.
59 */
60
61static void
62set_block (int x, int y, int bx, int by)
63{ 38{
64 int index = block[x][y].index, i; 39 uint8 flags; // FLG_xxx
40 uint8 culled; // culled from "tree"
41 uint8 visible;
42 uint8 pad0;
65 43
66 /* Due to flipping, we may get duplicates - better safe than sorry. 44 sint8 xo, yo; // obscure angle
67 */ 45 sint8 xe, ye; // angle deviation
68 for (i = 0; i < index; i++) 46};
69 {
70 if (block[x][y].x[i] == bx && block[x][y].y[i] == by)
71 return;
72 }
73 47
74 block[x][y].x[index] = bx; 48// temporary storage for the los algorithm,
75 block[x][y].y[index] = by; 49// one los_info for each lightable map space
76 block[x][y].index++; 50static los_info los[MAP_CLIENT_X][MAP_CLIENT_Y];
77#ifdef LOS_DEBUG
78 LOG (llevDebug, "setblock: added %d %d -> %d %d (%d)\n", x, y, bx, by, block[x][y].index);
79#endif
80}
81 51
82/* 52struct point
83 * initialises the array used by the LOS routines.
84 */
85
86/* since we are only doing the upper left quadrant, only
87 * these spaces could possibly get blocked, since these
88 * are the only ones further out that are still possibly in the
89 * sightline.
90 */
91void
92init_block (void)
93{ 53{
94 static int block_x[3] = { -1, -1, 0 },
95 block_y[3] = { -1, 0, -1 };
96
97 for (int x = 0; x < MAP_CLIENT_X; x++)
98 for (int y = 0; y < MAP_CLIENT_Y; y++)
99 block[x][y].index = 0;
100
101 /* The table should be symmetric, so only do the upper left
102 * quadrant - makes the processing easier.
103 */
104 for (int x = 1; x <= MAP_CLIENT_X / 2; x++)
105 {
106 for (int y = 1; y <= MAP_CLIENT_Y / 2; y++)
107 {
108 for (int i = 0; i < 3; i++)
109 {
110 int dx = x + block_x[i];
111 int dy = y + block_y[i];
112
113 /* center space never blocks */
114 if (x == MAP_CLIENT_X / 2 && y == MAP_CLIENT_Y / 2)
115 continue;
116
117 /* If its a straight line, its blocked */
118 if ((dx == x && x == MAP_CLIENT_X / 2) || (dy == y && y == MAP_CLIENT_Y / 2))
119 {
120 /* For simplicity, we mirror the coordinates to block the other
121 * quadrants.
122 */
123 set_block (x, y, dx, dy);
124 if (x == MAP_CLIENT_X / 2)
125 set_block (x, MAP_CLIENT_Y - y - 1, dx, MAP_CLIENT_Y - dy - 1);
126 else if (y == MAP_CLIENT_Y / 2)
127 set_block (MAP_CLIENT_X - x - 1, y, MAP_CLIENT_X - dx - 1, dy);
128 }
129 else
130 {
131 float d1, r, s, l;
132
133 /* We use the algorithm that found out how close the point
134 * (x,y) is to the line from dx,dy to the center of the viewable
135 * area. l is the distance from x,y to the line.
136 * r is more a curiosity - it lets us know what direction (left/right)
137 * the line is off
138 */
139
140 d1 = (powf (MAP_CLIENT_X / 2 - dx, 2.f) + powf (MAP_CLIENT_Y / 2 - dy, 2.f));
141 r = ((dy - y) * (dy - MAP_CLIENT_Y / 2) - (dx - x) * (MAP_CLIENT_X / 2 - dx)) / d1;
142 s = ((dy - y) * (MAP_CLIENT_X / 2 - dx) - (dx - x) * (MAP_CLIENT_Y / 2 - dy)) / d1;
143 l = fabs (sqrtf (d1) * s);
144
145 if (l <= SPACE_BLOCK)
146 {
147 /* For simplicity, we mirror the coordinates to block the other
148 * quadrants.
149 */
150 set_block (x, y, dx, dy);
151 set_block (MAP_CLIENT_X - x - 1, y, MAP_CLIENT_X - dx - 1, dy);
152 set_block (x, MAP_CLIENT_Y - y - 1, dx, MAP_CLIENT_Y - dy - 1);
153 set_block (MAP_CLIENT_X - x - 1, MAP_CLIENT_Y - y - 1, MAP_CLIENT_X - dx - 1, MAP_CLIENT_Y - dy - 1);
154 }
155 }
156 }
157 }
158 }
159}
160
161/*
162 * Used to initialise the array used by the LOS routines.
163 * x,y are indexes into the blocked[][] array.
164 * This recursively sets the blocked line of sight view.
165 * From the blocked[][] array, we know for example
166 * that if some particular space is blocked, it blocks
167 * the view of the spaces 'behind' it, and those blocked
168 * spaces behind it may block other spaces, etc.
169 * In this way, the chain of visibility is set.
170 */
171static void
172set_wall (object *op, int x, int y)
173{
174 for (int i = 0; i < block[x][y].index; i++)
175 {
176 int dx = block[x][y].x[i], dy = block[x][y].y[i], ax, ay;
177
178 /* ax, ay are the values as adjusted to be in the
179 * socket look structure.
180 */
181 ax = dx - (MAP_CLIENT_X - op->contr->ns->mapx) / 2;
182 ay = dy - (MAP_CLIENT_Y - op->contr->ns->mapy) / 2;
183
184 if (ax < 0 || ax >= op->contr->ns->mapx || ay < 0 || ay >= op->contr->ns->mapy)
185 continue;
186#if 0
187 LOG (llevDebug, "blocked %d %d -> %d %d\n", dx, dy, ax, ay);
188#endif
189 /* we need to adjust to the fact that the socket
190 * code wants the los to start from the 0,0
191 * and not be relative to middle of los array.
192 */
193 op->contr->blocked_los[ax][ay] = LOS_BLOCKED;
194 set_wall (op, dx, dy);
195 }
196}
197
198/*
199 * Used to initialise the array used by the LOS routines.
200 * op is the object, x and y values based on MAP_CLIENT_X and Y.
201 * this is because they index the blocked[][] arrays.
202 */
203static void
204check_wall (object *op, int x, int y)
205{
206 int ax, ay; 54 sint8 x, y;
55};
207 56
208 if (!block[x][y].index) 57// minimum size, but must be a power of two
209 return; 58#define QUEUE_LENGTH ((MAP_CLIENT_X + MAP_CLIENT_Y) * 2)
210 59
211 /* ax, ay are coordinates as indexed into the look window */ 60// a queue of spaces to calculate
212 ax = x - (MAP_CLIENT_X - op->contr->ns->mapx) / 2; 61static point queue [QUEUE_LENGTH];
213 ay = y - (MAP_CLIENT_Y - op->contr->ns->mapy) / 2; 62static int q1, q2; // queue start, end
214
215 /* If the converted coordinates are outside the viewable
216 * area for the client, return now.
217 */
218 if (ax < 0 || ay < 0 || ax >= op->contr->ns->mapx || ay >= op->contr->ns->mapy)
219 return;
220
221#if 0
222 LOG (llevDebug, "check_wall, ax,ay=%d, %d x,y = %d, %d blocksview = %d, %d\n",
223 ax, ay, x, y, op->x + x - MAP_CLIENT_X / 2, op->y + y - MAP_CLIENT_Y / 2);
224#endif
225
226 /* If this space is already blocked, prune the processing - presumably
227 * whatever has set this space to be blocked has done the work and already
228 * done the dependency chain.
229 */
230 if (op->contr->blocked_los[ax][ay] == LOS_BLOCKED)
231 return;
232
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))
234 set_wall (op, x, y);
235}
236 63
237/* 64/*
238 * Clears/initialises the los-array associated to the player 65 * Clears/initialises the los-array associated to the player
239 * controlling the object. 66 * controlling the object.
240 */ 67 */
241
242void 68void
243clear_los (player *pl) 69player::clear_los (sint8 value)
244{ 70{
245 /* This is safer than using the ns->mapx, mapy because 71 memset (los, value, sizeof (los));
246 * we index the blocked_los as a 2 way array, so clearing
247 * the first z spaces may not not cover the spaces we are
248 * actually going to use
249 */
250 memset (pl->blocked_los, 0, MAP_CLIENT_X * MAP_CLIENT_Y);
251} 72}
252 73
253/* 74// enqueue a single mapspace, but only if it hasn't
254 * expand_sight goes through the array of what the given player is 75// been enqueued yet.
255 * able to see, and expands the visible area a bit, so the player will,
256 * to a certain degree, be able to see into corners.
257 * This is somewhat suboptimal, would be better to improve the formula.
258 */
259static void 76static void
260expand_sight (object *op) 77enqueue (sint8 dx, sint8 dy, uint8 flags = 0)
261{ 78{
262 for (int x = 1; x < op->contr->ns->mapx - 1; x++) /* loop over inner squares */ 79 sint8 x = LOS_X0 + dx;
263 for (int y = 1; y < op->contr->ns->mapy - 1; y++) 80 sint8 y = LOS_Y0 + dy;
264 if (!op->contr->blocked_los[x][y] && 81
265 !(get_map_flags (op->map, NULL, 82 los_info &l = los[x][y];
266 op->x - op->contr->ns->mapx / 2 + x, 83
267 op->y - op->contr->ns->mapy / 2 + y, NULL, NULL) & (P_BLOCKSVIEW | P_OUT_OF_MAP))) 84 l.flags |= flags;
85
86 if (l.flags & FLG_QUEUED)
87 return;
88
89 l.flags |= FLG_QUEUED;
90
91 queue[q1].x = dx;
92 queue[q1].y = dy;
93
94 q1 = (q1 + 1) & (QUEUE_LENGTH - 1);
95}
96
97// run the los algorithm
98// this is a variant of a spiral los algorithm taken from
99// http://www.geocities.com/temerra/los_rays.html
100// which has been simplified and changed considerably, but
101// still is basically the same algorithm.
102static void
103calculate_los (player *pl)
104{
105 {
106 memset (los, 0, sizeof (los));
107
108 // we keep one line for ourselves, for the border flag
109 // so the client area is actually MAP_CLIENT_(X|Y) - 2
110 int half_x = min (LOS_X0 - 1, pl->ns->mapx / 2);
111 int half_y = min (LOS_Y0 - 1, pl->ns->mapy / 2);
112
113 // create borders, the corners are not touched
114 for (int dx = -half_x; dx <= half_x; ++dx)
115 los [dx + LOS_X0][LOS_Y0 - (half_y + 1)].flags =
116 los [dx + LOS_X0][LOS_Y0 + (half_y + 1)].flags = FLG_QUEUED;
117
118 for (int dy = -half_y; dy <= half_y; ++dy)
119 los [LOS_X0 - (half_x + 1)][dy + LOS_Y0].flags =
120 los [LOS_X0 + (half_x + 1)][dy + LOS_Y0].flags = FLG_QUEUED;
121
122 // now reset the los area and also add blocked flags
123 // which supposedly is faster than doing it inside the
124 // spiral path algorithm below, except when very little
125 // area is visible, in which case it is slower. which evens
126 // out los calculation times between large and small los maps.
127 // apply_lights also iterates over this area, maybe these
128 // two passes could be combined somehow.
129 unordered_mapwalk (pl->observe, -half_x, -half_y, half_x, half_y)
268 { 130 {
269 for (int i = 1; i <= 8; i += 1) 131 los_info &l = los [LOS_X0 + dx][LOS_Y0 + dy];
270 { /* mark all directions */ 132 l.flags = m->at (nx, ny).flags () & P_BLOCKSVIEW ? FLG_BLOCKED : 0;
271 int dx = x + freearr_x[i]; 133 }
272 int dy = y + freearr_y[i]; 134 }
273 135
274 if (op->contr->blocked_los[dx][dy] > 0) /* for any square blocked */ 136 q1 = 0; q2 = 0; // initialise queue, not strictly required
275 op->contr->blocked_los[dx][dy] = -1; 137 enqueue (0, 0); // enqueue center
138
139 // treat the origin specially
140 los[LOS_X0][LOS_Y0].visible = 1;
141 pl->los[LOS_X0][LOS_Y0] = 0;
142
143 // loop over all enqueued points until the queue is empty
144 // the order in which this is done ensures that we
145 // never touch a mapspace whose input spaces we haven't checked
146 // yet.
147 while (q1 != q2)
148 {
149 sint8 dx = queue[q2].x;
150 sint8 dy = queue[q2].y;
151
152 q2 = (q2 + 1) & (QUEUE_LENGTH - 1);
153
154 sint8 x = LOS_X0 + dx;
155 sint8 y = LOS_Y0 + dy;
156
157 los_info &l = los[x][y];
158
159 if (expect_true (l.flags & (FLG_XI | FLG_YI)))
160 {
161 l.culled = 1;
162 l.xo = l.yo = l.xe = l.ye = 0;
163
164 // check contributing spaces, first horizontal
165 if (expect_true (l.flags & FLG_XI))
166 {
167 los_info *xi = &los[x - sign (dx)][y];
168
169 // don't cull unless obscured
170 l.culled &= !xi->visible;
171
172 /* merge input space */
173 if (expect_false (xi->xo || xi->yo))
174 {
175 // The X input can provide two main pieces of information:
176 // 1. Progressive X obscurity.
177 // 2. Recessive Y obscurity.
178
179 // Progressive X obscurity, favouring recessive input angle
180 if (xi->xe > 0 && l.xo == 0)
181 {
182 l.xe = xi->xe - xi->yo;
183 l.ye = xi->ye + xi->yo;
184 l.xo = xi->xo;
185 l.yo = xi->yo;
186 }
187
188 // Recessive Y obscurity
189 if (xi->ye <= 0 && xi->yo > 0 && xi->xe > 0)
190 {
191 l.ye = xi->yo + xi->ye;
192 l.xe = xi->xe - xi->yo;
193 l.xo = xi->xo;
194 l.yo = xi->yo;
195 }
196 }
276 } 197 }
198
199 // check contributing spaces, last vertical, identical structure
200 if (expect_true (l.flags & FLG_YI))
201 {
202 los_info *yi = &los[x][y - sign (dy)];
203
204 // don't cull unless obscured
205 l.culled &= !yi->visible;
206
207 /* merge input space */
208 if (expect_false (yi->yo || yi->xo))
209 {
210 // The Y input can provide two main pieces of information:
211 // 1. Progressive Y obscurity.
212 // 2. Recessive X obscurity.
213
214 // Progressive Y obscurity, favouring recessive input angle
215 if (yi->ye > 0 && l.yo == 0)
216 {
217 l.ye = yi->ye - yi->xo;
218 l.xe = yi->xe + yi->xo;
219 l.yo = yi->yo;
220 l.xo = yi->xo;
221 }
222
223 // Recessive X obscurity
224 if (yi->xe <= 0 && yi->xo > 0 && yi->ye > 0)
225 {
226 l.xe = yi->xo + yi->xe;
227 l.ye = yi->ye - yi->xo;
228 l.yo = yi->yo;
229 l.xo = yi->xo;
230 }
231 }
232 }
233
234 if (l.flags & FLG_BLOCKED)
235 {
236 l.xo = l.xe = abs (dx);
237 l.yo = l.ye = abs (dy);
238
239 // we obscure dependents, but might be visible
240 // copy the los from the square towards the player,
241 // so outward diagonal corners are lit.
242 pl->los[x][y] = los[x - sign0 (dx)][y - sign0 (dy)].visible ? 0 : LOS_BLOCKED;
243
244 l.visible = false;
245 }
246 else
247 {
248 // we are not blocked, so calculate visibility, by checking
249 // whether we are inside or outside the shadow
250 l.visible = (l.xe <= 0 || l.xe > l.xo)
251 && (l.ye <= 0 || l.ye > l.yo);
252
253 pl->los[x][y] = l.culled ? LOS_BLOCKED
254 : l.visible ? 0
255 : 3;
256 }
257
277 } 258 }
278 259
279 expand_lighted_sight (op); 260 // Expands by the unit length in each component's current direction.
280 261 // If a component has no direction, then it is expanded in both of its
281 /* clear mark squares */ 262 // positive and negative directions.
282 for (int x = 0; x < op->contr->ns->mapx; x++) 263 if (!l.culled)
283 for (int y = 0; y < op->contr->ns->mapy; y++) 264 {
284 if (op->contr->blocked_los[x][y] < 0) 265 if (dx >= 0) enqueue (dx + 1, dy, FLG_XI);
285 op->contr->blocked_los[x][y] = 0; 266 if (dx <= 0) enqueue (dx - 1, dy, FLG_XI);
267 if (dy >= 0) enqueue (dx, dy + 1, FLG_YI);
268 if (dy <= 0) enqueue (dx, dy - 1, FLG_YI);
269 }
270 }
286} 271}
287 272
288/* returns true if op carries one or more lights 273/* returns true if op carries one or more lights
289 * This is a trivial function now days, but it used to 274 * This is a trivial function now days, but it used to
290 * be a bit longer. Probably better for callers to just 275 * be a bit longer. Probably better for callers to just
… …
299 284
300 return 0; 285 return 0;
301} 286}
302 287
303/* radius, distance => lightness adjust */ 288/* radius, distance => lightness adjust */
304static sint8 darkness[MAX_LIGHT_RADIUS * 2 + 1][MAX_LIGHT_RADIUS * 3 / 2 + 1]; 289static sint8 light_atten[MAX_LIGHT_RADIUS * 2 + 1][MAX_LIGHT_RADIUS * 3 / 2 + 1];
290static sint8 vision_atten[MAX_DARKNESS + SEE_IN_DARK_RADIUS + 1][(MAX_DARKNESS + SEE_IN_DARK_RADIUS) * 3 / 2 + 1];
305 291
306static struct darkness_init 292static struct los_init
307{ 293{
308 darkness_init () 294 los_init ()
309 { 295 {
296 assert (("QUEUE_LENGTH, MAP_CLIENT_X and MAP_CLIENT_Y *must* be powers of two",
297 !(QUEUE_LENGTH & (QUEUE_LENGTH - 1))));
298
299 /* for lights */
310 for (int radius = -MAX_LIGHT_RADIUS; radius <= MAX_LIGHT_RADIUS; ++radius) 300 for (int radius = -MAX_LIGHT_RADIUS; radius <= MAX_LIGHT_RADIUS; ++radius)
311 for (int distance = 0; distance <= MAX_LIGHT_RADIUS * 3 / 2; ++distance) 301 for (int distance = 0; distance <= MAX_LIGHT_RADIUS * 3 / 2; ++distance)
312 { 302 {
313 // max intensity 303 // max intensity
314 int intensity = min (LOS_MAX, abs (radius) + 1); 304 int intensity = min (LOS_MAX, abs (radius) + 1);
315 305
316 // actual intensity 306 // actual intensity
317 intensity = max (0, lerp_rd (distance, 0, abs (radius) + 1, intensity, 0)); 307 intensity = max (0, lerp_rd (distance, 0, abs (radius) + 1, intensity, 0));
318 308
319 darkness [radius + MAX_LIGHT_RADIUS][distance] = radius < 0 309 light_atten [radius + MAX_LIGHT_RADIUS][distance] = radius < 0
320 ? min (3, intensity) 310 ? min (3, intensity)
321 : LOS_MAX - intensity; 311 : LOS_MAX - intensity;
322 } 312 }
313
314 /* for general vision */
315 for (int radius = 0; radius <= MAX_DARKNESS + SEE_IN_DARK_RADIUS; ++radius)
316 for (int distance = 0; distance <= (MAX_DARKNESS + SEE_IN_DARK_RADIUS) * 3 / 2; ++distance)
317 vision_atten [radius][distance] = distance <= radius ? 3 : 4;
323 } 318 }
324} darkness_init; 319} los_init;
325 320
326sint8 321sint8
327los_brighten (sint8 b, sint8 l) 322los_brighten (sint8 b, sint8 l)
328{ 323{
329 return b == LOS_BLOCKED ? b : min (b, l); 324 return b == LOS_BLOCKED ? b : min (b, l);
… …
335 return max (b, l); 330 return max (b, l);
336} 331}
337 332
338template<sint8 change_it (sint8, sint8)> 333template<sint8 change_it (sint8, sint8)>
339static void 334static void
340apply_light (object *op, int basex, int basey, int light, const sint8 *darkness_table) 335apply_light (player *pl, int dx, int dy, int light, const sint8 *atten_table)
341{ 336{
342 // min or max the ciruclar area around basex, basey 337 // min or max the circular area around basex, basey
343 player *pl = op->contr; 338 dx += LOS_X0;
339 dy += LOS_Y0;
344 340
341 int hx = pl->ns->mapx / 2;
342 int hy = pl->ns->mapy / 2;
343
345 int ax0 = max (0, basex - light); 344 int ax0 = max (LOS_X0 - hx, dx - light);
346 int ay0 = max (0, basey - light); 345 int ay0 = max (LOS_Y0 - hy, dy - light);
347 int ax1 = min (basex + light, pl->ns->mapx - 1); 346 int ax1 = min (dx + light, LOS_X0 + hx);
348 int ay1 = min (basey + light, pl->ns->mapy - 1); 347 int ay1 = min (dy + light, LOS_Y0 + hy);
349 348
350 for (int ax = ax0; ax <= ax1; ax++) 349 for (int ax = ax0; ax <= ax1; ax++)
351 for (int ay = ay0; ay <= ay1; ay++) 350 for (int ay = ay0; ay <= ay1; ay++)
352 pl->blocked_los[ax][ay] = 351 pl->los[ax][ay] =
353 change_it (pl->blocked_los[ax][ay], darkness_table [idistance (ax - basex, ay - basey)]); 352 change_it (pl->los[ax][ay], atten_table [idistance (ax - dx, ay - dy)]);
354} 353}
355 354
356/* add light, by finding all (non-null) nearby light sources, then 355/* add light, by finding all (non-null) nearby light sources, then
357 * mark those squares specially. 356 * mark those squares specially.
358 */ 357 */
359static void 358static void
360expand_lighted_sight (object *op) 359apply_lights (player *pl)
361{ 360{
362 int darklevel, mflags, light, x1, y1; 361 object *op = pl->observe;
363 maptile *m = op->map; 362 int darklevel = op->map->darklevel ();
364 sint16 nx, ny;
365 363
366 darklevel = m->darkness;
367
368 /* If the player can see in the dark, lower the darklevel for him */
369 if (QUERY_FLAG (op, FLAG_SEE_IN_DARK))
370 darklevel -= LOS_MAX / 2;
371
372 /* Do a sanity check. If not valid, some code below may do odd
373 * things.
374 */
375 if (darklevel > MAX_DARKNESS)
376 {
377 LOG (llevError, "Map darkness for %s on %s is too high (%d)\n", &op->name, &op->map->path, darklevel);
378 darklevel = MAX_DARKNESS;
379 }
380
381 int half_x = op->contr->ns->mapx / 2; 364 int half_x = pl->ns->mapx / 2;
382 int half_y = op->contr->ns->mapy / 2; 365 int half_y = pl->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 366
389 int pass2 = 0; // negative lights have an extra pass 367 int pass2 = 0; // negative lights have an extra pass
390 368
369 maprect *rects = pl->observe->map->split_to_tiles (
370 pl->observe->x - half_x - MAX_LIGHT_RADIUS,
371 pl->observe->y - half_y - MAX_LIGHT_RADIUS,
372 pl->observe->x + half_x + MAX_LIGHT_RADIUS + 1,
373 pl->observe->y + half_y + MAX_LIGHT_RADIUS + 1
374 );
375
391 if (darklevel < 1) 376 if (!darklevel)
392 pass2 = 1; 377 pass2 = 1;
393 else 378 else
394 { 379 {
395 /* first, make everything totally dark */ 380 /* first, make everything totally dark */
396 for (int x = 0; x < op->contr->ns->mapx; x++) 381 for (int dx = -half_x; dx <= half_x; dx++)
397 for (int y = 0; y < op->contr->ns->mapy; y++) 382 for (int dy = -half_x; dy <= half_y; dy++)
398 if (op->contr->blocked_los[x][y] != LOS_BLOCKED) 383 max_it (pl->los[dx + LOS_X0][dy + LOS_Y0], LOS_MAX);
399 op->contr->blocked_los[x][y] = LOS_MAX;
400 384
401 /* 385 /*
402 * Only process the area of interest. 386 * Only process the area of interest.
403 * the basex, basey values represent the position in the op->contr->blocked_los 387 * the basex, basey values represent the position in the op->contr->los
404 * array. Its easier to just increment them here (and start with the right 388 * array. Its easier to just increment them here (and start with the right
405 * value) than to recalculate them down below. 389 * value) than to recalculate them down below.
406 */ 390 */
407 for (int x = min_x, basex = -MAX_LIGHT_RADIUS; x <= max_x; x++, basex++) 391 for (maprect *r = rects; r->m; ++r)
408 for (int y = min_y, basey = -MAX_LIGHT_RADIUS; y <= max_y; y++, basey++) 392 rect_mapwalk (r, 0, 0)
409 { 393 {
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); 394 mapspace &ms = m->at (nx, ny);
418 ms.update (); 395 ms.update ();
419 sint8 light = ms.light; 396 sint8 light = ms.light;
420 397
421 if (expect_false (light)) 398 if (expect_false (light))
422 if (light < 0) 399 if (light < 0)
423 pass2 = 1; 400 pass2 = 1;
424 else 401 else
425 apply_light<los_brighten> (op, basex, basey, light, darkness [light + MAX_LIGHT_RADIUS]); 402 apply_light<los_brighten> (pl, dx - pl->observe->x, dy - pl->observe->y, light, light_atten [light + MAX_LIGHT_RADIUS]);
426 } 403 }
427 404
428 /* grant some vision to the player, based on the darklevel */ 405 /* grant some vision to the player, based on the darklevel */
429 /* for outdoor maps, ensure some mininum visibility radius */
430 { 406 {
431 int light = clamp (MAX_DARKNESS - darklevel, op->map->outdoor ? 2 : 0, MAX_LIGHT_RADIUS); 407 int light = clamp (MAX_DARKNESS - darklevel, 0, MAX_DARKNESS);
432 408
433 apply_light<los_brighten> (op, half_x, half_y, light, darkness [light + MAX_LIGHT_RADIUS]); 409 /* If the player can see in the dark, lower the darklevel for him */
410 if (op->flag [FLAG_SEE_IN_DARK])
411 light += SEE_IN_DARK_RADIUS;
412
413 apply_light<los_brighten> (pl, 0, 0, light, vision_atten [light]);
434 } 414 }
435 } 415 }
436 416
437 // possibly do 2nd pass for rare negative glow radii 417 // possibly do 2nd pass for rare negative glow radii
438 // for effect, those are always considered to be stronger than anything else 418 // for effect, those are always considered to be stronger than anything else
439 // but they can't darken a place completely 419 // but they can't darken a place completely
440 if (pass2) 420 if (pass2)
441 for (int x = min_x, basex = -MAX_LIGHT_RADIUS; x <= max_x; x++, basex++) 421 for (maprect *r = rects; r->m; ++r)
442 for (int y = min_y, basey = -MAX_LIGHT_RADIUS; y <= max_y; y++, basey++) 422 rect_mapwalk (r, 0, 0)
443 { 423 {
444 maptile *m = op->map;
445 sint16 nx = x;
446 sint16 ny = y;
447
448 if (!xy_normalise (m, nx, ny))
449 continue;
450
451 mapspace &ms = m->at (nx, ny); 424 mapspace &ms = m->at (nx, ny);
452 ms.update (); 425 ms.update ();
453 sint8 light = ms.light; 426 sint8 light = ms.light;
454 427
455 if (expect_false (light < 0)) 428 if (expect_false (light < 0))
456 apply_light<los_darken> (op, basex, basey, -light, darkness [light + MAX_LIGHT_RADIUS]); 429 apply_light<los_darken> (pl, dx - pl->observe->x, dy - pl->observe->y, -light, light_atten [light + MAX_LIGHT_RADIUS]);
457 } 430 }
458} 431}
459 432
460/* blinded_sight() - sets all viewable squares to blocked except 433/* blinded_sight() - sets all viewable squares to blocked except
461 * for the one the central one that the player occupies. A little 434 * for the one the central one that the player occupies. A little
462 * odd that you can see yourself (and what your standing on), but 435 * odd that you can see yourself (and what your standing on), but
463 * really need for any reasonable game play. 436 * really need for any reasonable game play.
464 */ 437 */
465static void 438static void
466blinded_sight (object *op) 439blinded_sight (player *pl)
467{ 440{
468 int x, y; 441 pl->los[LOS_X0][LOS_Y0] = 1;
469
470 for (x = 0; x < op->contr->ns->mapx; x++)
471 for (y = 0; y < op->contr->ns->mapy; y++)
472 op->contr->blocked_los[x][y] = LOS_BLOCKED;
473
474 op->contr->blocked_los[op->contr->ns->mapx / 2][op->contr->ns->mapy / 2] = 0;
475} 442}
476 443
477/* 444/*
478 * update_los() recalculates the array which specifies what is 445 * update_los() recalculates the array which specifies what is
479 * visible for the given player-object. 446 * visible for the given player-object.
480 */ 447 */
481void 448void
482update_los (object *op) 449player::update_los ()
483{ 450{
484 int dx = op->contr->ns->mapx / 2, dy = op->contr->ns->mapy / 2, x, y; 451 if (ob->flag [FLAG_REMOVED])//D really needed?
485
486 if (QUERY_FLAG (op, FLAG_REMOVED))
487 return; 452 return;
488 453
489 clear_los (op->contr); 454 if (ob->flag [FLAG_WIZLOOK])
490 455 clear_los (0);
491 if (QUERY_FLAG (op, FLAG_WIZ) /* ||XRAYS(op) */ ) 456 else if (observe->flag [FLAG_BLIND]) /* player is blind */
492 return; 457 {
493 458 clear_los ();
494 /* For larger maps, this is more efficient than the old way which
495 * used the chaining of the block array. Since many space views could
496 * be blocked by different spaces in front, this mean that a lot of spaces
497 * could be examined multile times, as each path would be looked at.
498 */
499 for (x = (MAP_CLIENT_X - op->contr->ns->mapx) / 2 - 1; x < (MAP_CLIENT_X + op->contr->ns->mapx) / 2 + 1; x++)
500 for (y = (MAP_CLIENT_Y - op->contr->ns->mapy) / 2 - 1; y < (MAP_CLIENT_Y + op->contr->ns->mapy) / 2 + 1; y++)
501 check_wall (op, x, y);
502
503 /* do the los of the player. 3 (potential) cases */
504 if (QUERY_FLAG (op, FLAG_BLIND)) /* player is blind */
505 blinded_sight (op); 459 blinded_sight (this);
460 }
506 else 461 else
507 expand_sight (op); 462 {
463 clear_los ();
464 calculate_los (this);
465 apply_lights (this);
466 }
508 467
509 //TODO: no range-checking whatsoever :( 468 if (observe->flag [FLAG_XRAYS])
510 if (QUERY_FLAG (op, FLAG_XRAYS))
511 for (int x = -2; x <= 2; x++) 469 for (int dx = -2; dx <= 2; dx++)
512 for (int y = -2; y <= 2; y++) 470 for (int dy = -2; dy <= 2; dy++)
513 op->contr->blocked_los[dx + x][dy + y] = 0; 471 min_it (los[dx + LOS_X0][dy + LOS_Y0], 1);
514} 472}
515 473
516/* update all_map_los is like update_all_los below, 474/* update all_map_los is like update_all_los below,
517 * but updates everyone on the map, no matter where they 475 * but updates everyone on the map, no matter where they
518 * are. This generally should not be used, as a per 476 * are. This generally should not be used, as a per
… …
525 * change_map_light function 483 * change_map_light function
526 */ 484 */
527void 485void
528update_all_map_los (maptile *map) 486update_all_map_los (maptile *map)
529{ 487{
530 for_all_players (pl) 488 for_all_players_on_map (pl, map)
531 if (pl->ob && pl->ob->map == map)
532 pl->do_los = 1; 489 pl->do_los = 1;
533} 490}
534 491
535/* 492/*
536 * This function makes sure that update_los() will be called for all 493 * This function makes sure that update_los() will be called for all
537 * players on the given map within the next frame. 494 * players on the given map within the next frame.
… …
545 * map is the map that changed, x and y are the coordinates. 502 * map is the map that changed, x and y are the coordinates.
546 */ 503 */
547void 504void
548update_all_los (const maptile *map, int x, int y) 505update_all_los (const maptile *map, int x, int y)
549{ 506{
507 // no need to do anything if we don't have darkness
508 if (map->darklevel () <= 0)
509 return;
510
511 map->at (x, y).invalidate ();
512
550 for_all_players (pl) 513 for_all_players (pl)
551 { 514 {
552 /* Player should not have a null map, but do this 515 /* Player should not have a null map, but do this
553 * check as a safety 516 * check as a safety
554 */ 517 */
… …
563 * player can't be on another map that may be closer, 526 * player can't be on another map that may be closer,
564 * so by setting it up this way, we trim processing 527 * so by setting it up this way, we trim processing
565 * some. 528 * some.
566 */ 529 */
567 if (pl->ob->map == map) 530 if (pl->ob->map == map)
568 {
569 if ((abs (pl->ob->x - x) <= pl->ns->mapx / 2) && (abs (pl->ob->y - y) <= pl->ns->mapy / 2)) 531 if ((abs (pl->ob->x - x) <= pl->ns->mapx / 2) && (abs (pl->ob->y - y) <= pl->ns->mapy / 2))
570 pl->do_los = 1; 532 pl->do_los = 1;
571 }
572 533
573 /* Now we check to see if player is on adjacent 534 /* Now we check to see if player is on adjacent
574 * maps to the one that changed and also within 535 * maps to the one that changed and also within
575 * view. The tile_maps[] could be null, but in that 536 * view. The tile_maps[] could be null, but in that
576 * case it should never match the pl->ob->map, so 537 * case it should never match the pl->ob->map, so
… …
606 pl->do_los = 1; 567 pl->do_los = 1;
607 } 568 }
608 } 569 }
609} 570}
610 571
572static const int season_darkness[5][HOURS_PER_DAY] = {
573 /*0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 1 2 3 4 5 6 7 8 9 10 11 12 13 */
574 { 5, 5, 4, 4, 4, 4, 4, 3, 3, 3, 3, 2, 2, 1, 1, 0, 0, 0, 0, 1, 2, 2, 2, 3, 3, 4, 4, 5 },
575 { 5, 5, 4, 4, 4, 4, 3, 3, 3, 2, 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4 },
576 { 5, 4, 4, 4, 4, 3, 3, 2, 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 2, 3, 4, 4 },
577 { 4, 4, 4, 4, 3, 3, 2, 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 2, 3, 4 },
578 { 5, 5, 4, 4, 4, 3, 3, 3, 2, 2, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4 }
579};
580
611/* 581/*
612 * Debug-routine which dumps the array which specifies the visible 582 * Tell players the time and compute the darkness level for all maps in the game.
613 * area of a player. Triggered by the z key in DM mode. 583 * MUST be called exactly once per hour.
614 */ 584 */
615void 585void
616print_los (object *op) 586maptile::adjust_daylight ()
617{ 587{
618 int x, y; 588 timeofday_t tod;
619 char buf[50], buf2[10];
620 589
621 strcpy (buf, " "); 590 get_tod (&tod);
622 591
623 for (x = 0; x < op->contr->ns->mapx; x++) 592 // log the time to log-1 every hour, and to chat every day
624 { 593 {
625 sprintf (buf2, "%2d", x); 594 char todbuf[512];
626 strcat (buf, buf2); 595
596 format_tod (todbuf, sizeof (todbuf), &tod);
597
598 for_all_players (pl)
599 pl->ns->send_msg (NDI_GREY, tod.hour == 15 ? CHAT_CHANNEL : LOG_CHANNEL, todbuf);
627 } 600 }
628 601
629 new_draw_info (NDI_UNIQUE, 0, op, buf); 602 /* If the light level isn't changing, no reason to do all
603 * the work below.
604 */
605 sint8 new_darkness = season_darkness[tod.season][tod.hour];
630 606
631 for (y = 0; y < op->contr->ns->mapy; y++) 607 if (new_darkness == maptile::outdoor_darkness)
632 { 608 return;
633 sprintf (buf, "%2d:", y);
634 609
635 for (x = 0; x < op->contr->ns->mapx; x++) 610 new_draw_info (NDI_GREY | NDI_UNIQUE | NDI_ALL, 1, 0,
636 { 611 new_darkness > maptile::outdoor_darkness
637 sprintf (buf2, " %1d", op->contr->blocked_los[x][y]); 612 ? "It becomes darker."
638 strcat (buf, buf2); 613 : "It becomes brighter.");
639 }
640 614
641 new_draw_info (NDI_UNIQUE, 0, op, buf); 615 maptile::outdoor_darkness = new_darkness;
642 } 616
617 // we simply update the los for all players, which is unnecessarily
618 // costly, but should do for the moment.
619 for_all_players (pl)
620 pl->do_los = 1;
643} 621}
644 622
645/* 623/*
646 * make_sure_seen: The object is supposed to be visible through walls, thus 624 * make_sure_seen: The object is supposed to be visible through walls, thus
647 * check if any players are nearby, and edit their LOS array. 625 * check if any players are nearby, and edit their LOS array.
648 */ 626 */
649
650void 627void
651make_sure_seen (const object *op) 628make_sure_seen (const object *op)
652{ 629{
653 for_all_players (pl) 630 for_all_players (pl)
654 if (pl->ob->map == op->map && 631 if (pl->ob->map == op->map &&
655 pl->ob->y - pl->ns->mapy / 2 <= op->y && 632 pl->ob->y - pl->ns->mapy / 2 <= op->y &&
656 pl->ob->y + pl->ns->mapy / 2 >= op->y && pl->ob->x - pl->ns->mapx / 2 <= op->x && pl->ob->x + pl->ns->mapx / 2 >= op->x) 633 pl->ob->y + pl->ns->mapy / 2 >= op->y && pl->ob->x - pl->ns->mapx / 2 <= op->x && pl->ob->x + pl->ns->mapx / 2 >= op->x)
657 pl->blocked_los[pl->ns->mapx / 2 + op->x - pl->ob->x][pl->ns->mapy / 2 + op->y - pl->ob->y] = 0; 634 pl->los[op->x - pl->ob->x + LOS_X0][op->y - pl->ob->y + LOS_Y0] = 0;
658} 635}
659 636
660/* 637/*
661 * make_sure_not_seen: The object which is supposed to be visible through 638 * make_sure_not_seen: The object which is supposed to be visible through
662 * walls has just been removed from the map, so update the los of any 639 * walls has just been removed from the map, so update the los of any
663 * players within its range 640 * players within its range
664 */ 641 */
665
666void 642void
667make_sure_not_seen (const object *op) 643make_sure_not_seen (const object *op)
668{ 644{
669 for_all_players (pl) 645 for_all_players (pl)
670 if (pl->ob->map == op->map && 646 if (pl->ob->map == op->map &&
671 pl->ob->y - pl->ns->mapy / 2 <= op->y && 647 pl->ob->y - pl->ns->mapy / 2 <= op->y &&
672 pl->ob->y + pl->ns->mapy / 2 >= op->y && pl->ob->x - pl->ns->mapx / 2 <= op->x && pl->ob->x + pl->ns->mapx / 2 >= op->x) 648 pl->ob->y + pl->ns->mapy / 2 >= op->y && pl->ob->x - pl->ns->mapx / 2 <= op->x && pl->ob->x + pl->ns->mapx / 2 >= op->x)
673 pl->do_los = 1; 649 pl->do_los = 1;
674} 650}
651

Diff Legend

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