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.4 by root, Sun Sep 10 16:00:23 2006 UTC vs.
Revision 1.16 by pippijn, Sat Jan 6 14:42:29 2007 UTC

1
2/*
3 * static char *rcsid_los_c =
4 * "$Id: los.C,v 1.4 2006/09/10 16:00:23 root Exp $";
5 */
6
7/* 1/*
8 CrossFire, A Multiplayer game for X-windows 2 CrossFire, A Multiplayer game for X-windows
9 3
4 Copyright (C) 2005, 2006, 2007 Marc Lehmann & Crossfire+ Development Team
10 Copyright (C) 2002 Mark Wedel & Crossfire Development Team 5 Copyright (C) 2002 Mark Wedel & Crossfire Development Team
11 Copyright (C) 1992 Frank Tore Johansen 6 Copyright (C) 1992 Frank Tore Johansen
12 7
13 This program is free software; you can redistribute it and/or modify 8 This program is free software; you can redistribute it and/or modify
14 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
… …
22 17
23 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
24 along with this program; if not, write to the Free Software 19 along with this program; if not, write to the Free Software
25 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 21
27 The authors can be reached via e-mail at crossfire-devel@real-time.com 22 The authors can be reached via e-mail at <crossfire@schmorp.de>
28*/ 23*/
29 24
30/* Nov 95 - inserted USE_LIGHTING code stuff in here - b.t. */ 25/* Nov 95 - inserted USE_LIGHTING code stuff in here - b.t. */
31 26
32#include <global.h> 27#include <global.h>
… …
150 * area. l is the distance from x,y to the line. 145 * area. l is the distance from x,y to the line.
151 * r is more a curiosity - it lets us know what direction (left/right) 146 * r is more a curiosity - it lets us know what direction (left/right)
152 * the line is off 147 * the line is off
153 */ 148 */
154 149
155 d1 = (float) (pow (MAP_CLIENT_X / 2 - dx, 2) + pow (MAP_CLIENT_Y / 2 - dy, 2)); 150 d1 = (float) (pow (MAP_CLIENT_X / 2 - dx, 2.f) + pow (MAP_CLIENT_Y / 2 - dy, 2.f));
156 r = (float) ((dy - y) * (dy - MAP_CLIENT_Y / 2) - (dx - x) * (MAP_CLIENT_X / 2 - dx)) / d1; 151 r = (float) ((dy - y) * (dy - MAP_CLIENT_Y / 2) - (dx - x) * (MAP_CLIENT_X / 2 - dx)) / d1;
157 s = (float) ((dy - y) * (MAP_CLIENT_X / 2 - dx) - (dx - x) * (MAP_CLIENT_Y / 2 - dy)) / d1; 152 s = (float) ((dy - y) * (MAP_CLIENT_X / 2 - dx) - (dx - x) * (MAP_CLIENT_Y / 2 - dy)) / d1;
158 l = FABS (sqrt (d1) * s); 153 l = FABS (sqrt (d1) * s);
159 154
160 if (l <= SPACE_BLOCK) 155 if (l <= SPACE_BLOCK)
… …
194 int dx = block[x][y].x[i], dy = block[x][y].y[i], ax, ay; 189 int dx = block[x][y].x[i], dy = block[x][y].y[i], ax, ay;
195 190
196 /* ax, ay are the values as adjusted to be in the 191 /* ax, ay are the values as adjusted to be in the
197 * socket look structure. 192 * socket look structure.
198 */ 193 */
199 ax = dx - (MAP_CLIENT_X - op->contr->socket.mapx) / 2; 194 ax = dx - (MAP_CLIENT_X - op->contr->ns->mapx) / 2;
200 ay = dy - (MAP_CLIENT_Y - op->contr->socket.mapy) / 2; 195 ay = dy - (MAP_CLIENT_Y - op->contr->ns->mapy) / 2;
201 196
202 if (ax < 0 || ax >= op->contr->socket.mapx || ay < 0 || ay >= op->contr->socket.mapy) 197 if (ax < 0 || ax >= op->contr->ns->mapx || ay < 0 || ay >= op->contr->ns->mapy)
203 continue; 198 continue;
204#if 0 199#if 0
205 LOG (llevDebug, "blocked %d %d -> %d %d\n", dx, dy, ax, ay); 200 LOG (llevDebug, "blocked %d %d -> %d %d\n", dx, dy, ax, ay);
206#endif 201#endif
207 /* we need to adjust to the fact that the socket 202 /* we need to adjust to the fact that the socket
… …
226 221
227 if (!block[x][y].index) 222 if (!block[x][y].index)
228 return; 223 return;
229 224
230 /* ax, ay are coordinates as indexed into the look window */ 225 /* ax, ay are coordinates as indexed into the look window */
231 ax = x - (MAP_CLIENT_X - op->contr->socket.mapx) / 2; 226 ax = x - (MAP_CLIENT_X - op->contr->ns->mapx) / 2;
232 ay = y - (MAP_CLIENT_Y - op->contr->socket.mapy) / 2; 227 ay = y - (MAP_CLIENT_Y - op->contr->ns->mapy) / 2;
233 228
234 /* If the converted coordinates are outside the viewable 229 /* If the converted coordinates are outside the viewable
235 * area for the client, return now. 230 * area for the client, return now.
236 */ 231 */
237 if (ax < 0 || ay < 0 || ax >= op->contr->socket.mapx || ay >= op->contr->socket.mapy) 232 if (ax < 0 || ay < 0 || ax >= op->contr->ns->mapx || ay >= op->contr->ns->mapy)
238 return; 233 return;
239 234
240#if 0 235#if 0
241 LOG (llevDebug, "check_wall, ax,ay=%d, %d x,y = %d, %d blocksview = %d, %d\n", 236 LOG (llevDebug, "check_wall, ax,ay=%d, %d x,y = %d, %d blocksview = %d, %d\n",
242 ax, ay, x, y, op->x + x - MAP_CLIENT_X / 2, op->y + y - MAP_CLIENT_Y / 2); 237 ax, ay, x, y, op->x + x - MAP_CLIENT_X / 2, op->y + y - MAP_CLIENT_Y / 2);
… …
260 */ 255 */
261 256
262void 257void
263clear_los (object *op) 258clear_los (object *op)
264{ 259{
265 /* This is safer than using the socket->mapx, mapy because 260 /* This is safer than using the ns->mapx, mapy because
266 * we index the blocked_los as a 2 way array, so clearing 261 * we index the blocked_los as a 2 way array, so clearing
267 * the first z spaces may not not cover the spaces we are 262 * the first z spaces may not not cover the spaces we are
268 * actually going to use 263 * actually going to use
269 */ 264 */
270 (void) memset ((void *) op->contr->blocked_los, 0, MAP_CLIENT_X * MAP_CLIENT_Y); 265 (void) memset ((void *) op->contr->blocked_los, 0, MAP_CLIENT_X * MAP_CLIENT_Y);
… …
280static void 275static void
281expand_sight (object *op) 276expand_sight (object *op)
282{ 277{
283 int i, x, y, dx, dy; 278 int i, x, y, dx, dy;
284 279
285 for (x = 1; x < op->contr->socket.mapx - 1; x++) /* loop over inner squares */ 280 for (x = 1; x < op->contr->ns->mapx - 1; x++) /* loop over inner squares */
286 for (y = 1; y < op->contr->socket.mapy - 1; y++) 281 for (y = 1; y < op->contr->ns->mapy - 1; y++)
287 { 282 {
288 if (!op->contr->blocked_los[x][y] && 283 if (!op->contr->blocked_los[x][y] &&
289 !(get_map_flags (op->map, NULL, 284 !(get_map_flags (op->map, NULL,
290 op->x - op->contr->socket.mapx / 2 + x, 285 op->x - op->contr->ns->mapx / 2 + x,
291 op->y - op->contr->socket.mapy / 2 + y, NULL, NULL) & (P_BLOCKSVIEW | P_OUT_OF_MAP))) 286 op->y - op->contr->ns->mapy / 2 + y, NULL, NULL) & (P_BLOCKSVIEW | P_OUT_OF_MAP)))
292 { 287 {
293 288
294 for (i = 1; i <= 8; i += 1) 289 for (i = 1; i <= 8; i += 1)
295 { /* mark all directions */ 290 { /* mark all directions */
296 dx = x + freearr_x[i]; 291 dx = x + freearr_x[i];
… …
299 op->contr->blocked_los[dx][dy] = -1; 294 op->contr->blocked_los[dx][dy] = -1;
300 } 295 }
301 } 296 }
302 } 297 }
303 298
304 if (MAP_DARKNESS (op->map) > 0) /* player is on a dark map */ 299 if (op->map->darkness > 0) /* player is on a dark map */
305 expand_lighted_sight (op); 300 expand_lighted_sight (op);
306 301
307 302
308 /* clear mark squares */ 303 /* clear mark squares */
309 for (x = 0; x < op->contr->socket.mapx; x++) 304 for (x = 0; x < op->contr->ns->mapx; x++)
310 for (y = 0; y < op->contr->socket.mapy; y++) 305 for (y = 0; y < op->contr->ns->mapy; y++)
311 if (op->contr->blocked_los[x][y] < 0) 306 if (op->contr->blocked_los[x][y] < 0)
312 op->contr->blocked_los[x][y] = 0; 307 op->contr->blocked_los[x][y] = 0;
313} 308}
314 309
315 310
… …
333 328
334static void 329static void
335expand_lighted_sight (object *op) 330expand_lighted_sight (object *op)
336{ 331{
337 int x, y, darklevel, ax, ay, basex, basey, mflags, light, x1, y1; 332 int x, y, darklevel, ax, ay, basex, basey, mflags, light, x1, y1;
338 mapstruct *m = op->map; 333 maptile *m = op->map;
339 sint16 nx, ny; 334 sint16 nx, ny;
340 335
341 darklevel = MAP_DARKNESS (m); 336 darklevel = m->darkness;
342 337
343 /* If the player can see in the dark, lower the darklevel for him */ 338 /* If the player can see in the dark, lower the darklevel for him */
344 if (QUERY_FLAG (op, FLAG_SEE_IN_DARK)) 339 if (QUERY_FLAG (op, FLAG_SEE_IN_DARK))
345 darklevel -= 2; 340 darklevel -= 2;
346 341
… …
355 /* Do a sanity check. If not valid, some code below may do odd 350 /* Do a sanity check. If not valid, some code below may do odd
356 * things. 351 * things.
357 */ 352 */
358 if (darklevel > MAX_DARKNESS) 353 if (darklevel > MAX_DARKNESS)
359 { 354 {
360 LOG (llevError, "Map darkness for %s on %s is too high (%d)\n", &op->name, op->map->path, darklevel); 355 LOG (llevError, "Map darkness for %s on %s is too high (%d)\n", &op->name, &op->map->path, darklevel);
361 darklevel = MAX_DARKNESS; 356 darklevel = MAX_DARKNESS;
362 } 357 }
363 358
364 /* First, limit player furthest (unlighted) vision */ 359 /* First, limit player furthest (unlighted) vision */
365 for (x = 0; x < op->contr->socket.mapx; x++) 360 for (x = 0; x < op->contr->ns->mapx; x++)
366 for (y = 0; y < op->contr->socket.mapy; y++) 361 for (y = 0; y < op->contr->ns->mapy; y++)
367 if (op->contr->blocked_los[x][y] != 100) 362 if (op->contr->blocked_los[x][y] != 100)
368 op->contr->blocked_los[x][y] = MAX_LIGHT_RADII; 363 op->contr->blocked_los[x][y] = MAX_LIGHT_RADII;
369 364
370 /* the spaces[] darkness value contains the information we need. 365 /* the spaces[] darkness value contains the information we need.
371 * Only process the area of interest. 366 * Only process the area of interest.
372 * the basex, basey values represent the position in the op->contr->blocked_los 367 * the basex, basey values represent the position in the op->contr->blocked_los
373 * array. Its easier to just increment them here (and start with the right 368 * array. Its easier to just increment them here (and start with the right
374 * value) than to recalculate them down below. 369 * value) than to recalculate them down below.
375 */ 370 */
376 for (x = (op->x - op->contr->socket.mapx / 2 - MAX_LIGHT_RADII), basex = -MAX_LIGHT_RADII; 371 for (x = (op->x - op->contr->ns->mapx / 2 - MAX_LIGHT_RADII), basex = -MAX_LIGHT_RADII;
377 x <= (op->x + op->contr->socket.mapx / 2 + MAX_LIGHT_RADII); x++, basex++) 372 x <= (op->x + op->contr->ns->mapx / 2 + MAX_LIGHT_RADII); x++, basex++)
378 { 373 {
379 374
380 for (y = (op->y - op->contr->socket.mapy / 2 - MAX_LIGHT_RADII), basey = -MAX_LIGHT_RADII; 375 for (y = (op->y - op->contr->ns->mapy / 2 - MAX_LIGHT_RADII), basey = -MAX_LIGHT_RADII;
381 y <= (op->y + op->contr->socket.mapy / 2 + MAX_LIGHT_RADII); y++, basey++) 376 y <= (op->y + op->contr->ns->mapy / 2 + MAX_LIGHT_RADII); y++, basey++)
382 { 377 {
383 m = op->map; 378 m = op->map;
384 nx = x; 379 nx = x;
385 ny = y; 380 ny = y;
386 381
… …
398#if 0 393#if 0
399 LOG (llevDebug, "expand_lighted_sight: Found light at x=%d, y=%d, basex=%d, basey=%d\n", x, y, basex, basey); 394 LOG (llevDebug, "expand_lighted_sight: Found light at x=%d, y=%d, basex=%d, basey=%d\n", x, y, basex, basey);
400#endif 395#endif
401 for (ax = basex - light; ax <= basex + light; ax++) 396 for (ax = basex - light; ax <= basex + light; ax++)
402 { 397 {
403 if (ax < 0 || ax >= op->contr->socket.mapx) 398 if (ax < 0 || ax >= op->contr->ns->mapx)
404 continue; 399 continue;
405 for (ay = basey - light; ay <= basey + light; ay++) 400 for (ay = basey - light; ay <= basey + light; ay++)
406 { 401 {
407 if (ay < 0 || ay >= op->contr->socket.mapy) 402 if (ay < 0 || ay >= op->contr->ns->mapy)
408 continue; 403 continue;
409 404
410 /* If the space is fully blocked, do nothing. Otherwise, we 405 /* If the space is fully blocked, do nothing. Otherwise, we
411 * brighten the space. The further the light is away from the 406 * brighten the space. The further the light is away from the
412 * source (basex-x), the less effect it has. Though light used 407 * source (basex-x), the less effect it has. Though light used
… …
432 /* Outdoor should never really be completely pitch black dark like 427 /* Outdoor should never really be completely pitch black dark like
433 * a dungeon, so let the player at least see a little around themselves 428 * a dungeon, so let the player at least see a little around themselves
434 */ 429 */
435 if (op->map->outdoor && darklevel > (MAX_DARKNESS - 3)) 430 if (op->map->outdoor && darklevel > (MAX_DARKNESS - 3))
436 { 431 {
437 if (op->contr->blocked_los[op->contr->socket.mapx / 2][op->contr->socket.mapy / 2] > (MAX_DARKNESS - 3)) 432 if (op->contr->blocked_los[op->contr->ns->mapx / 2][op->contr->ns->mapy / 2] > (MAX_DARKNESS - 3))
438 op->contr->blocked_los[op->contr->socket.mapx / 2][op->contr->socket.mapy / 2] = MAX_DARKNESS - 3; 433 op->contr->blocked_los[op->contr->ns->mapx / 2][op->contr->ns->mapy / 2] = MAX_DARKNESS - 3;
439 434
440 for (x = -1; x <= 1; x++) 435 for (x = -1; x <= 1; x++)
441 for (y = -1; y <= 1; y++) 436 for (y = -1; y <= 1; y++)
442 { 437 {
443 if (op->contr->blocked_los[x + op->contr->socket.mapx / 2][y + op->contr->socket.mapy / 2] > (MAX_DARKNESS - 2)) 438 if (op->contr->blocked_los[x + op->contr->ns->mapx / 2][y + op->contr->ns->mapy / 2] > (MAX_DARKNESS - 2))
444 op->contr->blocked_los[x + op->contr->socket.mapx / 2][y + op->contr->socket.mapy / 2] = MAX_DARKNESS - 2; 439 op->contr->blocked_los[x + op->contr->ns->mapx / 2][y + op->contr->ns->mapy / 2] = MAX_DARKNESS - 2;
445 } 440 }
446 } 441 }
447 /* grant some vision to the player, based on the darklevel */ 442 /* grant some vision to the player, based on the darklevel */
448 for (x = darklevel - MAX_DARKNESS; x < MAX_DARKNESS + 1 - darklevel; x++) 443 for (x = darklevel - MAX_DARKNESS; x < MAX_DARKNESS + 1 - darklevel; x++)
449 for (y = darklevel - MAX_DARKNESS; y < MAX_DARKNESS + 1 - darklevel; y++) 444 for (y = darklevel - MAX_DARKNESS; y < MAX_DARKNESS + 1 - darklevel; y++)
450 if (!(op->contr->blocked_los[x + op->contr->socket.mapx / 2][y + op->contr->socket.mapy / 2] == 100)) 445 if (!(op->contr->blocked_los[x + op->contr->ns->mapx / 2][y + op->contr->ns->mapy / 2] == 100))
451 op->contr->blocked_los[x + op->contr->socket.mapx / 2][y + op->contr->socket.mapy / 2] -= 446 op->contr->blocked_los[x + op->contr->ns->mapx / 2][y + op->contr->ns->mapy / 2] -=
452 MAX (0, 6 - darklevel - MAX (abs (x), abs (y))); 447 MAX (0, 6 - darklevel - MAX (abs (x), abs (y)));
453} 448}
454 449
455/* blinded_sight() - sets all veiwable squares to blocked except 450/* blinded_sight() - sets all veiwable squares to blocked except
456 * for the one the central one that the player occupies. A little 451 * for the one the central one that the player occupies. A little
… …
461static void 456static void
462blinded_sight (object *op) 457blinded_sight (object *op)
463{ 458{
464 int x, y; 459 int x, y;
465 460
466 for (x = 0; x < op->contr->socket.mapx; x++) 461 for (x = 0; x < op->contr->ns->mapx; x++)
467 for (y = 0; y < op->contr->socket.mapy; y++) 462 for (y = 0; y < op->contr->ns->mapy; y++)
468 op->contr->blocked_los[x][y] = 100; 463 op->contr->blocked_los[x][y] = 100;
469 464
470 op->contr->blocked_los[op->contr->socket.mapx / 2][op->contr->socket.mapy / 2] = 0; 465 op->contr->blocked_los[op->contr->ns->mapx / 2][op->contr->ns->mapy / 2] = 0;
471} 466}
472 467
473/* 468/*
474 * update_los() recalculates the array which specifies what is 469 * update_los() recalculates the array which specifies what is
475 * visible for the given player-object. 470 * visible for the given player-object.
476 */ 471 */
477 472
478void 473void
479update_los (object *op) 474update_los (object *op)
480{ 475{
481 int dx = op->contr->socket.mapx / 2, dy = op->contr->socket.mapy / 2, x, y; 476 int dx = op->contr->ns->mapx / 2, dy = op->contr->ns->mapy / 2, x, y;
482 477
483 if (QUERY_FLAG (op, FLAG_REMOVED)) 478 if (QUERY_FLAG (op, FLAG_REMOVED))
484 return; 479 return;
485 480
486 clear_los (op); 481 clear_los (op);
… …
490 /* For larger maps, this is more efficient than the old way which 485 /* For larger maps, this is more efficient than the old way which
491 * used the chaining of the block array. Since many space views could 486 * used the chaining of the block array. Since many space views could
492 * be blocked by different spaces in front, this mean that a lot of spaces 487 * be blocked by different spaces in front, this mean that a lot of spaces
493 * could be examined multile times, as each path would be looked at. 488 * could be examined multile times, as each path would be looked at.
494 */ 489 */
495 for (x = (MAP_CLIENT_X - op->contr->socket.mapx) / 2 - 1; x < (MAP_CLIENT_X + op->contr->socket.mapx) / 2 + 1; x++) 490 for (x = (MAP_CLIENT_X - op->contr->ns->mapx) / 2 - 1; x < (MAP_CLIENT_X + op->contr->ns->mapx) / 2 + 1; x++)
496 for (y = (MAP_CLIENT_Y - op->contr->socket.mapy) / 2 - 1; y < (MAP_CLIENT_Y + op->contr->socket.mapy) / 2 + 1; y++) 491 for (y = (MAP_CLIENT_Y - op->contr->ns->mapy) / 2 - 1; y < (MAP_CLIENT_Y + op->contr->ns->mapy) / 2 + 1; y++)
497 check_wall (op, x, y); 492 check_wall (op, x, y);
498 493
499 494
500 /* do the los of the player. 3 (potential) cases */ 495 /* do the los of the player. 3 (potential) cases */
501 if (QUERY_FLAG (op, FLAG_BLIND)) /* player is blind */ 496 if (QUERY_FLAG (op, FLAG_BLIND)) /* player is blind */
… …
513 } 508 }
514} 509}
515 510
516/* update all_map_los is like update_all_los below, 511/* update all_map_los is like update_all_los below,
517 * but updates everyone on the map, no matter where they 512 * but updates everyone on the map, no matter where they
518 * are. This generally should not be used, as a per 513 * are. This generally should not be used, as a per
519 * specific map change doesn't make much sense when tiling 514 * specific map change doesn't make much sense when tiling
520 * is considered (lowering darkness would certainly be a 515 * is considered (lowering darkness would certainly be a
521 * strange effect if done on a tile map, as it makes 516 * strange effect if done on a tile map, as it makes
522 * the distinction between maps much more obvious to the 517 * the distinction between maps much more obvious to the
523 * players, which is should not be. 518 * players, which is should not be.
524 * Currently, this function is called from the 519 * Currently, this function is called from the
525 * change_map_light function 520 * change_map_light function
526 */ 521 */
527void 522void
528update_all_map_los (mapstruct *map) 523update_all_map_los (maptile *map)
529{ 524{
530 player *pl; 525 for_all_players (pl)
531
532 for (pl = first_player; pl != NULL; pl = pl->next)
533 {
534 if (pl->ob->map == map) 526 if (pl->ob && pl->ob->map == map)
535 pl->do_los = 1; 527 pl->do_los = 1;
536 }
537} 528}
538
539 529
540/* 530/*
541 * This function makes sure that update_los() will be called for all 531 * This function makes sure that update_los() will be called for all
542 * players on the given map within the next frame. 532 * players on the given map within the next frame.
543 * It is triggered by removal or inserting of objects which blocks 533 * It is triggered by removal or inserting of objects which blocks
… …
547 * means that just being on the same map is not sufficient - the 537 * means that just being on the same map is not sufficient - the
548 * space that changes must be withing your viewable area. 538 * space that changes must be withing your viewable area.
549 * 539 *
550 * map is the map that changed, x and y are the coordinates. 540 * map is the map that changed, x and y are the coordinates.
551 */ 541 */
552
553void 542void
554update_all_los (const mapstruct *map, int x, int y) 543update_all_los (const maptile *map, int x, int y)
555{ 544{
556 player *pl; 545 for_all_players (pl)
557
558 for (pl = first_player; pl != NULL; pl = pl->next)
559 { 546 {
560 /* Player should not have a null map, but do this 547 /* Player should not have a null map, but do this
561 * check as a safety 548 * check as a safety
562 */ 549 */
563 if (!pl->ob->map) 550 if (!pl->ob || !pl->ob->map || !pl->ns)
564 continue; 551 continue;
565 552
566 /* Same map is simple case - see if pl is close enough. 553 /* Same map is simple case - see if pl is close enough.
567 * Note in all cases, we did the check for same map first, 554 * Note in all cases, we did the check for same map first,
568 * and then see if the player is close enough and update 555 * and then see if the player is close enough and update
… …
572 * so by setting it up this way, we trim processing 559 * so by setting it up this way, we trim processing
573 * some. 560 * some.
574 */ 561 */
575 if (pl->ob->map == map) 562 if (pl->ob->map == map)
576 { 563 {
577 if ((abs (pl->ob->x - x) <= pl->socket.mapx / 2) && (abs (pl->ob->y - y) <= pl->socket.mapy / 2)) 564 if ((abs (pl->ob->x - x) <= pl->ns->mapx / 2) && (abs (pl->ob->y - y) <= pl->ns->mapy / 2))
578 pl->do_los = 1; 565 pl->do_los = 1;
579 } 566 }
567
580 /* Now we check to see if player is on adjacent 568 /* Now we check to see if player is on adjacent
581 * maps to the one that changed and also within 569 * maps to the one that changed and also within
582 * view. The tile_maps[] could be null, but in that 570 * view. The tile_maps[] could be null, but in that
583 * case it should never match the pl->ob->map, so 571 * case it should never match the pl->ob->map, so
584 * we want ever try to dereference any of the data in it. 572 * we want ever try to dereference any of the data in it.
585 */ 573 *
586
587 /* The logic for 0 and 3 is to see how far the player is 574 * The logic for 0 and 3 is to see how far the player is
588 * from the edge of the map (height/width) - pl->ob->(x,y) 575 * from the edge of the map (height/width) - pl->ob->(x,y)
589 * and to add current position on this map - that gives a 576 * and to add current position on this map - that gives a
590 * distance. 577 * distance.
591 * For 1 and 2, we check to see how far the given 578 * For 1 and 2, we check to see how far the given
592 * coordinate (x,y) is from the corresponding edge, 579 * coordinate (x,y) is from the corresponding edge,
593 * and then add the players location, which gives 580 * and then add the players location, which gives
594 * a distance. 581 * a distance.
595 */ 582 */
596 else if (pl->ob->map == map->tile_map[0]) 583 else if (pl->ob->map == map->tile_map[0])
597 { 584 {
598 if ((abs (pl->ob->x - x) <= pl->socket.mapx / 2) && (abs (y + MAP_HEIGHT (map->tile_map[0]) - pl->ob->y) <= pl->socket.mapy / 2)) 585 if ((abs (pl->ob->x - x) <= pl->ns->mapx / 2) && (abs (y + map->tile_map[0]->height - pl->ob->y) <= pl->ns->mapy / 2))
599 pl->do_los = 1; 586 pl->do_los = 1;
600 } 587 }
601 else if (pl->ob->map == map->tile_map[2]) 588 else if (pl->ob->map == map->tile_map[2])
602 { 589 {
603 if ((abs (pl->ob->x - x) <= pl->socket.mapx / 2) && (abs (pl->ob->y + MAP_HEIGHT (map) - y) <= pl->socket.mapy / 2)) 590 if ((abs (pl->ob->x - x) <= pl->ns->mapx / 2) && (abs (pl->ob->y + map->height - y) <= pl->ns->mapy / 2))
604 pl->do_los = 1; 591 pl->do_los = 1;
605 } 592 }
606 else if (pl->ob->map == map->tile_map[1]) 593 else if (pl->ob->map == map->tile_map[1])
607 { 594 {
608 if ((abs (pl->ob->x + MAP_WIDTH (map) - x) <= pl->socket.mapx / 2) && (abs (pl->ob->y - y) <= pl->socket.mapy / 2)) 595 if ((abs (pl->ob->x + map->width - x) <= pl->ns->mapx / 2) && (abs (pl->ob->y - y) <= pl->ns->mapy / 2))
609 pl->do_los = 1; 596 pl->do_los = 1;
610 } 597 }
611 else if (pl->ob->map == map->tile_map[3]) 598 else if (pl->ob->map == map->tile_map[3])
612 { 599 {
613 if ((abs (x + MAP_WIDTH (map->tile_map[3]) - pl->ob->x) <= pl->socket.mapx / 2) && (abs (pl->ob->y - y) <= pl->socket.mapy / 2)) 600 if ((abs (x + map->tile_map[3]->width - pl->ob->x) <= pl->ns->mapx / 2) && (abs (pl->ob->y - y) <= pl->ns->mapy / 2))
614 pl->do_los = 1; 601 pl->do_los = 1;
615 } 602 }
616 } 603 }
617} 604}
618 605
619/* 606/*
620 * Debug-routine which dumps the array which specifies the visible 607 * Debug-routine which dumps the array which specifies the visible
621 * area of a player. Triggered by the z key in DM mode. 608 * area of a player. Triggered by the z key in DM mode.
622 */ 609 */
623
624void 610void
625print_los (object *op) 611print_los (object *op)
626{ 612{
627 int x, y; 613 int x, y;
628 char buf[50], buf2[10]; 614 char buf[50], buf2[10];
629 615
630 strcpy (buf, " "); 616 strcpy (buf, " ");
617
631 for (x = 0; x < op->contr->socket.mapx; x++) 618 for (x = 0; x < op->contr->ns->mapx; x++)
632 { 619 {
633 sprintf (buf2, "%2d", x); 620 sprintf (buf2, "%2d", x);
634 strcat (buf, buf2); 621 strcat (buf, buf2);
635 } 622 }
623
636 new_draw_info (NDI_UNIQUE, 0, op, buf); 624 new_draw_info (NDI_UNIQUE, 0, op, buf);
625
637 for (y = 0; y < op->contr->socket.mapy; y++) 626 for (y = 0; y < op->contr->ns->mapy; y++)
638 { 627 {
639 sprintf (buf, "%2d:", y); 628 sprintf (buf, "%2d:", y);
629
640 for (x = 0; x < op->contr->socket.mapx; x++) 630 for (x = 0; x < op->contr->ns->mapx; x++)
641 { 631 {
642 sprintf (buf2, " %1d", op->contr->blocked_los[x][y]); 632 sprintf (buf2, " %1d", op->contr->blocked_los[x][y]);
643 strcat (buf, buf2); 633 strcat (buf, buf2);
644 } 634 }
635
645 new_draw_info (NDI_UNIQUE, 0, op, buf); 636 new_draw_info (NDI_UNIQUE, 0, op, buf);
646 } 637 }
647} 638}
648 639
649/* 640/*
… …
652 */ 643 */
653 644
654void 645void
655make_sure_seen (const object *op) 646make_sure_seen (const object *op)
656{ 647{
657 player *pl; 648 for_all_players (pl)
658
659 for (pl = first_player; pl; pl = pl->next)
660 if (pl->ob->map == op->map && 649 if (pl->ob->map == op->map &&
661 pl->ob->y - pl->socket.mapy / 2 <= op->y && 650 pl->ob->y - pl->ns->mapy / 2 <= op->y &&
662 pl->ob->y + pl->socket.mapy / 2 >= op->y && pl->ob->x - pl->socket.mapx / 2 <= op->x && pl->ob->x + pl->socket.mapx / 2 >= op->x) 651 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)
663 pl->blocked_los[pl->socket.mapx / 2 + op->x - pl->ob->x][pl->socket.mapy / 2 + op->y - pl->ob->y] = 0; 652 pl->blocked_los[pl->ns->mapx / 2 + op->x - pl->ob->x][pl->ns->mapy / 2 + op->y - pl->ob->y] = 0;
664} 653}
665 654
666/* 655/*
667 * make_sure_not_seen: The object which is supposed to be visible through 656 * make_sure_not_seen: The object which is supposed to be visible through
668 * walls has just been removed from the map, so update the los of any 657 * walls has just been removed from the map, so update the los of any
… …
670 */ 659 */
671 660
672void 661void
673make_sure_not_seen (const object *op) 662make_sure_not_seen (const object *op)
674{ 663{
675 player *pl; 664 for_all_players (pl)
676
677 for (pl = first_player; pl; pl = pl->next)
678 if (pl->ob->map == op->map && 665 if (pl->ob->map == op->map &&
679 pl->ob->y - pl->socket.mapy / 2 <= op->y && 666 pl->ob->y - pl->ns->mapy / 2 <= op->y &&
680 pl->ob->y + pl->socket.mapy / 2 >= op->y && pl->ob->x - pl->socket.mapx / 2 <= op->x && pl->ob->x + pl->socket.mapx / 2 >= op->x) 667 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)
681 pl->do_los = 1; 668 pl->do_los = 1;
682} 669}

Diff Legend

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