src/light.c

   1 /* NetHack 3.6  light.c $NHDT-Date: 1446191876 2015/10/30 07:57:56 $  $NHDT-Branch: master $:$NHDT-Revision: 1.28 $ */
   2 /* Copyright (c) Dean Luick, 1994                                       */
   3 /* NetHack may be freely redistributed.  See license for details.       */
   4
   5 /* JNetHack Copyright */
   6 /* For 3.6-, Copyright (c) SHIRAKATA Kentaro, 2002-2016            */
   7 /* JNetHack may be freely redistributed.  See license for details. */
   8
   9 #include "hack.h"
  10 #include "lev.h" /* for checking save modes */
  11
  12 /*
  13  * Mobile light sources.
  14  *
  15  * This implementation minimizes memory at the expense of extra
  16  * recalculations.
  17  *
  18  * Light sources are "things" that have a physical position and range.
  19  * They have a type, which gives us information about them.  Currently
  20  * they are only attached to objects and monsters.  Note well:  the
  21  * polymorphed-player handling assumes that both youmonst.m_id and
  22  * youmonst.mx will always remain 0.
  23  *
  24  * Light sources, like timers, either follow game play (RANGE_GLOBAL) or
  25  * stay on a level (RANGE_LEVEL).  Light sources are unique by their
  26  * (type, id) pair.  For light sources attached to objects, this id
  27  * is a pointer to the object.
  28  *
  29  * The major working function is do_light_sources(). It is called
  30  * when the vision system is recreating its "could see" array.  Here
  31  * we add a flag (TEMP_LIT) to the array for all locations that are lit
  32  * via a light source.  The bad part of this is that we have to
  33  * re-calculate the LOS of each light source every time the vision
  34  * system runs.  Even if the light sources and any topology (vision blocking
  35  * positions) have not changed.  The good part is that no extra memory
  36  * is used, plus we don't have to figure out how far the sources have moved,
  37  * or if the topology has changed.
  38  *
  39  * The structure of the save/restore mechanism is amazingly similar to
  40  * the timer save/restore.  This is because they both have the same
  41  * principals of having pointers into objects that must be recalculated
  42  * across saves and restores.
  43  */
  44
  45 /* flags */
  46 #define LSF_SHOW 0x1        /* display the light source */
  47 #define LSF_NEEDS_FIXUP 0x2 /* need oid fixup */
  48
  49 static light_source *light_base = 0;
  50
  51 STATIC_DCL void FDECL(write_ls, (int, light_source *));
  52 STATIC_DCL int FDECL(maybe_write_ls, (int, int, BOOLEAN_P));
  53
  54 /* imported from vision.c, for small circles */
  55 extern char circle_data[];
  56 extern char circle_start[];
  57
  58 /* Create a new light source.  */
  59 void
  60 new_light_source(x, y, range, type, id)
  61 xchar x, y;
  62 int range, type;
  63 anything *id;
  64 {
  65     light_source *ls;
  66
  67     if (range > MAX_RADIUS || range < 1) {
  68         impossible("new_light_source:  illegal range %d", range);
  69         return;
  70     }
  71
  72     ls = (light_source *) alloc(sizeof(light_source));
  73
  74     ls->next = light_base;
  75     ls->x = x;
  76     ls->y = y;
  77     ls->range = range;
  78     ls->type = type;
  79     ls->id = *id;
  80     ls->flags = 0;
  81     light_base = ls;
  82
  83     vision_full_recalc = 1; /* make the source show up */
  84 }
  85
  86 /*
  87  * Delete a light source. This assumes only one light source is attached
  88  * to an object at a time.
  89  */
  90 void
  91 del_light_source(type, id)
  92 int type;
  93 anything *id;
  94 {
  95     light_source *curr, *prev;
  96     anything tmp_id;
  97
  98     tmp_id = zeroany;
  99     /* need to be prepared for dealing a with light source which
 100        has only been partially restored during a level change
 101        (in particular: chameleon vs prot. from shape changers) */
 102     switch (type) {
 103     case LS_OBJECT:
 104         tmp_id.a_uint = id->a_obj->o_id;
 105         break;
 106     case LS_MONSTER:
 107         tmp_id.a_uint = id->a_monst->m_id;
 108         break;
 109     default:
 110         tmp_id.a_uint = 0;
 111         break;
 112     }
 113
 114     for (prev = 0, curr = light_base; curr; prev = curr, curr = curr->next) {
 115         if (curr->type != type)
 116             continue;
 117         if (curr->id.a_obj
 118             == ((curr->flags & LSF_NEEDS_FIXUP) ? tmp_id.a_obj : id->a_obj)) {
 119             if (prev)
 120                 prev->next = curr->next;
 121             else
 122                 light_base = curr->next;
 123
 124             free((genericptr_t) curr);
 125             vision_full_recalc = 1;
 126             return;
 127         }
 128     }
 129     impossible("del_light_source: not found type=%d, id=%s", type,
 130                fmt_ptr((genericptr_t) id->a_obj));
 131 }
 132
 133 /* Mark locations that are temporarily lit via mobile light sources. */
 134 void
 135 do_light_sources(cs_rows)
 136 char **cs_rows;
 137 {
 138     int x, y, min_x, max_x, max_y, offset;
 139     char *limits;
 140     short at_hero_range = 0;
 141     light_source *ls;
 142     char *row;
 143
 144     for (ls = light_base; ls; ls = ls->next) {
 145         ls->flags &= ~LSF_SHOW;
 146
 147         /*
 148          * Check for moved light sources.  It may be possible to
 149          * save some effort if an object has not moved, but not in
 150          * the current setup -- we need to recalculate for every
 151          * vision recalc.
 152          */
 153         if (ls->type == LS_OBJECT) {
 154             if (get_obj_location(ls->id.a_obj, &ls->x, &ls->y, 0))
 155                 ls->flags |= LSF_SHOW;
 156         } else if (ls->type == LS_MONSTER) {
 157             if (get_mon_location(ls->id.a_monst, &ls->x, &ls->y, 0))
 158                 ls->flags |= LSF_SHOW;
 159         }
 160
 161         /* minor optimization: don't bother with duplicate light sources */
 162         /* at hero */
 163         if (ls->x == u.ux && ls->y == u.uy) {
 164             if (at_hero_range >= ls->range)
 165                 ls->flags &= ~LSF_SHOW;
 166             else
 167                 at_hero_range = ls->range;
 168         }
 169
 170         if (ls->flags & LSF_SHOW) {
 171             /*
 172              * Walk the points in the circle and see if they are
 173              * visible from the center.  If so, mark'em.
 174              *
 175              * Kevin's tests indicated that doing this brute-force
 176              * method is faster for radius <= 3 (or so).
 177              */
 178             limits = circle_ptr(ls->range);
 179             if ((max_y = (ls->y + ls->range)) >= ROWNO)
 180                 max_y = ROWNO - 1;
 181             if ((y = (ls->y - ls->range)) < 0)
 182                 y = 0;
 183             for (; y <= max_y; y++) {
 184                 row = cs_rows[y];
 185                 offset = limits[abs(y - ls->y)];
 186                 if ((min_x = (ls->x - offset)) < 0)
 187                     min_x = 0;
 188                 if ((max_x = (ls->x + offset)) >= COLNO)
 189                     max_x = COLNO - 1;
 190
 191                 if (ls->x == u.ux && ls->y == u.uy) {
 192                     /*
 193                      * If the light source is located at the hero, then
 194                      * we can use the COULD_SEE bits already calculated
 195                      * by the vision system.  More importantly than
 196                      * this optimization, is that it allows the vision
 197                      * system to correct problems with clear_path().
 198                      * The function clear_path() is a simple LOS
 199                      * path checker that doesn't go out of its way
 200                      * make things look "correct".  The vision system
 201                      * does this.
 202                      */
 203                     for (x = min_x; x <= max_x; x++)
 204                         if (row[x] & COULD_SEE)
 205                             row[x] |= TEMP_LIT;
 206                 } else {
 207                     for (x = min_x; x <= max_x; x++)
 208                         if ((ls->x == x && ls->y == y)
 209                             || clear_path((int) ls->x, (int) ls->y, x, y))
 210                             row[x] |= TEMP_LIT;
 211                 }
 212             }
 213         }
 214     }
 215 }
 216
 217 /* (mon->mx == 0) implies migrating */
 218 #define mon_is_local(mon) ((mon)->mx > 0)
 219
 220 struct monst *
 221 find_mid(nid, fmflags)
 222 unsigned nid;
 223 unsigned fmflags;
 224 {
 225     struct monst *mtmp;
 226
 227     if (!nid)
 228         return &youmonst;
 229     if (fmflags & FM_FMON)
 230         for (mtmp = fmon; mtmp; mtmp = mtmp->nmon)
 231             if (!DEADMONSTER(mtmp) && mtmp->m_id == nid)
 232                 return mtmp;
 233     if (fmflags & FM_MIGRATE)
 234         for (mtmp = migrating_mons; mtmp; mtmp = mtmp->nmon)
 235             if (mtmp->m_id == nid)
 236                 return mtmp;
 237     if (fmflags & FM_MYDOGS)
 238         for (mtmp = mydogs; mtmp; mtmp = mtmp->nmon)
 239             if (mtmp->m_id == nid)
 240                 return mtmp;
 241     return (struct monst *) 0;
 242 }
 243
 244 /* Save all light sources of the given range. */
 245 void
 246 save_light_sources(fd, mode, range)
 247 int fd, mode, range;
 248 {
 249     int count, actual, is_global;
 250     light_source **prev, *curr;
 251
 252     if (perform_bwrite(mode)) {
 253         count = maybe_write_ls(fd, range, FALSE);
 254         bwrite(fd, (genericptr_t) &count, sizeof count);
 255         actual = maybe_write_ls(fd, range, TRUE);
 256         if (actual != count)
 257             panic("counted %d light sources, wrote %d! [range=%d]", count,
 258                   actual, range);
 259     }
 260
 261     if (release_data(mode)) {
 262         for (prev = &light_base; (curr = *prev) != 0;) {
 263             if (!curr->id.a_monst) {
 264                 impossible("save_light_sources: no id! [range=%d]", range);
 265                 is_global = 0;
 266             } else
 267                 switch (curr->type) {
 268                 case LS_OBJECT:
 269                     is_global = !obj_is_local(curr->id.a_obj);
 270                     break;
 271                 case LS_MONSTER:
 272                     is_global = !mon_is_local(curr->id.a_monst);
 273                     break;
 274                 default:
 275                     is_global = 0;
 276                     impossible("save_light_sources: bad type (%d) [range=%d]",
 277                                curr->type, range);
 278                     break;
 279                 }
 280             /* if global and not doing local, or vice versa, remove it */
 281             if (is_global ^ (range == RANGE_LEVEL)) {
 282                 *prev = curr->next;
 283                 free((genericptr_t) curr);
 284             } else {
 285                 prev = &(*prev)->next;
 286             }
 287         }
 288     }
 289 }
 290
 291 /*
 292  * Pull in the structures from disk, but don't recalculate the object
 293  * pointers.
 294  */
 295 void
 296 restore_light_sources(fd)
 297 int fd;
 298 {
 299     int count;
 300     light_source *ls;
 301
 302     /* restore elements */
 303     mread(fd, (genericptr_t) &count, sizeof count);
 304
 305     while (count-- > 0) {
 306         ls = (light_source *) alloc(sizeof(light_source));
 307         mread(fd, (genericptr_t) ls, sizeof(light_source));
 308         ls->next = light_base;
 309         light_base = ls;
 310     }
 311 }
 312
 313 /* Relink all lights that are so marked. */
 314 void
 315 relink_light_sources(ghostly)
 316 boolean ghostly;
 317 {
 318     char which;
 319     unsigned nid;
 320     light_source *ls;
 321
 322     for (ls = light_base; ls; ls = ls->next) {
 323         if (ls->flags & LSF_NEEDS_FIXUP) {
 324             if (ls->type == LS_OBJECT || ls->type == LS_MONSTER) {
 325                 if (ghostly) {
 326                     if (!lookup_id_mapping(ls->id.a_uint, &nid))
 327                         impossible("relink_light_sources: no id mapping");
 328                 } else
 329                     nid = ls->id.a_uint;
 330                 if (ls->type == LS_OBJECT) {
 331                     which = 'o';
 332                     ls->id.a_obj = find_oid(nid);
 333                 } else {
 334                     which = 'm';
 335                     ls->id.a_monst = find_mid(nid, FM_EVERYWHERE);
 336                 }
 337                 if (!ls->id.a_monst)
 338                     impossible("relink_light_sources: cant find %c_id %d",
 339                                which, nid);
 340             } else
 341                 impossible("relink_light_sources: bad type (%d)", ls->type);
 342
 343             ls->flags &= ~LSF_NEEDS_FIXUP;
 344         }
 345     }
 346 }
 347
 348 /*
 349  * Part of the light source save routine.  Count up the number of light
 350  * sources that would be written.  If write_it is true, actually write
 351  * the light source out.
 352  */
 353 STATIC_OVL int
 354 maybe_write_ls(fd, range, write_it)
 355 int fd, range;
 356 boolean write_it;
 357 {
 358     int count = 0, is_global;
 359     light_source *ls;
 360
 361     for (ls = light_base; ls; ls = ls->next) {
 362         if (!ls->id.a_monst) {
 363             impossible("maybe_write_ls: no id! [range=%d]", range);
 364             continue;
 365         }
 366         switch (ls->type) {
 367         case LS_OBJECT:
 368             is_global = !obj_is_local(ls->id.a_obj);
 369             break;
 370         case LS_MONSTER:
 371             is_global = !mon_is_local(ls->id.a_monst);
 372             break;
 373         default:
 374             is_global = 0;
 375             impossible("maybe_write_ls: bad type (%d) [range=%d]", ls->type,
 376                        range);
 377             break;
 378         }
 379         /* if global and not doing local, or vice versa, count it */
 380         if (is_global ^ (range == RANGE_LEVEL)) {
 381             count++;
 382             if (write_it)
 383                 write_ls(fd, ls);
 384         }
 385     }
 386
 387     return count;
 388 }
 389
 390 void
 391 light_sources_sanity_check()
 392 {
 393     light_source *ls;
 394     struct monst *mtmp;
 395     struct obj *otmp;
 396     unsigned int auint;
 397
 398     for (ls = light_base; ls; ls = ls->next) {
 399         if (!ls->id.a_monst)
 400             panic("insane light source: no id!");
 401         if (ls->type == LS_OBJECT) {
 402             otmp = (struct obj *) ls->id.a_obj;
 403             auint = otmp->o_id;
 404             if (find_oid(auint) != otmp)
 405                 panic("insane light source: can't find obj #%u!", auint);
 406         } else if (ls->type == LS_MONSTER) {
 407             mtmp = (struct monst *) ls->id.a_monst;
 408             auint = mtmp->m_id;
 409             if (find_mid(auint, FM_EVERYWHERE) != mtmp)
 410                 panic("insane light source: can't find mon #%u!", auint);
 411         } else {
 412             panic("insane light source: bad ls type %d", ls->type);
 413         }
 414     }
 415 }
 416
 417 /* Write a light source structure to disk. */
 418 STATIC_OVL void
 419 write_ls(fd, ls)
 420 int fd;
 421 light_source *ls;
 422 {
 423     anything arg_save;
 424     struct obj *otmp;
 425     struct monst *mtmp;
 426
 427     if (ls->type == LS_OBJECT || ls->type == LS_MONSTER) {
 428         if (ls->flags & LSF_NEEDS_FIXUP) {
 429             bwrite(fd, (genericptr_t) ls, sizeof(light_source));
 430         } else {
 431             /* replace object pointer with id for write, then put back */
 432             arg_save = ls->id;
 433             if (ls->type == LS_OBJECT) {
 434                 otmp = ls->id.a_obj;
 435                 ls->id = zeroany;
 436                 ls->id.a_uint = otmp->o_id;
 437                 if (find_oid((unsigned) ls->id.a_uint) != otmp)
 438                     impossible("write_ls: can't find obj #%u!",
 439                                ls->id.a_uint);
 440             } else { /* ls->type == LS_MONSTER */
 441                 mtmp = (struct monst *) ls->id.a_monst;
 442                 ls->id = zeroany;
 443                 ls->id.a_uint = mtmp->m_id;
 444                 if (find_mid((unsigned) ls->id.a_uint, FM_EVERYWHERE) != mtmp)
 445                     impossible("write_ls: can't find mon #%u!",
 446                                ls->id.a_uint);
 447             }
 448             ls->flags |= LSF_NEEDS_FIXUP;
 449             bwrite(fd, (genericptr_t) ls, sizeof(light_source));
 450             ls->id = arg_save;
 451             ls->flags &= ~LSF_NEEDS_FIXUP;
 452         }
 453     } else {
 454         impossible("write_ls: bad type (%d)", ls->type);
 455     }
 456 }
 457
 458 /* Change light source's ID from src to dest. */
 459 void
 460 obj_move_light_source(src, dest)
 461 struct obj *src, *dest;
 462 {
 463     light_source *ls;
 464
 465     for (ls = light_base; ls; ls = ls->next)
 466         if (ls->type == LS_OBJECT && ls->id.a_obj == src)
 467             ls->id.a_obj = dest;
 468     src->lamplit = 0;
 469     dest->lamplit = 1;
 470 }
 471
 472 /* return true if there exist any light sources */
 473 boolean
 474 any_light_source()
 475 {
 476     return (boolean) (light_base != (light_source *) 0);
 477 }
 478
 479 /*
 480  * Snuff an object light source if at (x,y).  This currently works
 481  * only for burning light sources.
 482  */
 483 void
 484 snuff_light_source(x, y)
 485 int x, y;
 486 {
 487     light_source *ls;
 488     struct obj *obj;
 489
 490     for (ls = light_base; ls; ls = ls->next)
 491         /*
 492          * Is this position check valid??? Can I assume that the positions
 493          * will always be correct because the objects would have been
 494          * updated with the last vision update?  [Is that recent enough???]
 495          */
 496         if (ls->type == LS_OBJECT && ls->x == x && ls->y == y) {
 497             obj = ls->id.a_obj;
 498             if (obj_is_burning(obj)) {
 499                 /* The only way to snuff Sunsword is to unwield it.  Darkness
 500                  * scrolls won't affect it.  (If we got here because it was
 501                  * dropped or thrown inside a monster, this won't matter
 502                  * anyway because it will go out when dropped.)
 503                  */
 504                 if (artifact_light(obj))
 505                     continue;
 506                 end_burn(obj, obj->otyp != MAGIC_LAMP);
 507                 /*
 508                  * The current ls element has just been removed (and
 509                  * ls->next is now invalid).  Return assuming that there
 510                  * is only one light source attached to each object.
 511                  */
 512                 return;
 513             }
 514         }
 515 }
 516
 517 /* Return TRUE if object sheds any light at all. */
 518 boolean
 519 obj_sheds_light(obj)
 520 struct obj *obj;
 521 {
 522     /* so far, only burning objects shed light */
 523     return obj_is_burning(obj);
 524 }
 525
 526 /* Return TRUE if sheds light AND will be snuffed by end_burn(). */
 527 boolean
 528 obj_is_burning(obj)
 529 struct obj *obj;
 530 {
 531     return (boolean) (obj->lamplit && (obj->otyp == MAGIC_LAMP
 532                                        || ignitable(obj)
 533                                        || artifact_light(obj)));
 534 }
 535
 536 /* copy the light source(s) attached to src, and attach it/them to dest */
 537 void
 538 obj_split_light_source(src, dest)
 539 struct obj *src, *dest;
 540 {
 541     light_source *ls, *new_ls;
 542
 543     for (ls = light_base; ls; ls = ls->next)
 544         if (ls->type == LS_OBJECT && ls->id.a_obj == src) {
 545             /*
 546              * Insert the new source at beginning of list.  This will
 547              * never interfere us walking down the list - we are already
 548              * past the insertion point.
 549              */
 550             new_ls = (light_source *) alloc(sizeof(light_source));
 551             *new_ls = *ls;
 552             if (Is_candle(src)) {
 553                 /* split candles may emit less light than original group */
 554                 ls->range = candle_light_range(src);
 555                 new_ls->range = candle_light_range(dest);
 556                 vision_full_recalc = 1; /* in case range changed */
 557             }
 558             new_ls->id.a_obj = dest;
 559             new_ls->next = light_base;
 560             light_base = new_ls;
 561             dest->lamplit = 1; /* now an active light source */
 562         }
 563 }
 564
 565 /* light source `src' has been folded into light source `dest';
 566    used for merging lit candles and adding candle(s) to lit candelabrum */
 567 void
 568 obj_merge_light_sources(src, dest)
 569 struct obj *src, *dest;
 570 {
 571     light_source *ls;
 572
 573     /* src == dest implies adding to candelabrum */
 574     if (src != dest)
 575         end_burn(src, TRUE); /* extinguish candles */
 576
 577     for (ls = light_base; ls; ls = ls->next)
 578         if (ls->type == LS_OBJECT && ls->id.a_obj == dest) {
 579             ls->range = candle_light_range(dest);
 580             vision_full_recalc = 1; /* in case range changed */
 581             break;
 582         }
 583 }
 584
 585 /* light source `obj' is being made brighter or dimmer */
 586 void
 587 obj_adjust_light_radius(obj, new_radius)
 588 struct obj *obj;
 589 int new_radius;
 590 {
 591     light_source *ls;
 592
 593     for (ls = light_base; ls; ls = ls->next)
 594         if (ls->type == LS_OBJECT && ls->id.a_obj == obj) {
 595             if (new_radius != ls->range)
 596                 vision_full_recalc = 1;
 597             ls->range = new_radius;
 598             return;
 599         }
 600     impossible("obj_adjust_light_radius: can't find %s", xname(obj));
 601 }
 602
 603 /* Candlelight is proportional to the number of candles;
 604    minimum range is 2 rather than 1 for playability. */
 605 int
 606 candle_light_range(obj)
 607 struct obj *obj;
 608 {
 609     int radius;
 610
 611     if (obj->otyp == CANDELABRUM_OF_INVOCATION) {
 612         /*
 613          *      The special candelabrum emits more light than the
 614          *      corresponding number of candles would.
 615          *       1..3 candles, range 2 (minimum range);
 616          *       4..6 candles, range 3 (normal lamp range);
 617          *          7 candles, range 4 (bright).
 618          */
 619         radius = (obj->spe < 4) ? 2 : (obj->spe < 7) ? 3 : 4;
 620     } else if (Is_candle(obj)) {
 621         /*
 622          *      Range is incremented by powers of 7 so that it will take
 623          *      wizard mode quantities of candles to get more light than
 624          *      from a lamp, without imposing an arbitrary limit.
 625          *       1..6   candles, range 2;
 626          *       7..48  candles, range 3;
 627          *      49..342 candles, range 4; &c.
 628          */
 629         long n = obj->quan;
 630
 631         radius = 1; /* always incremented at least once */
 632         do {
 633             radius++;
 634             n /= 7L;
 635         } while (n > 0L);
 636     } else {
 637         /* we're only called for lit candelabrum or candles */
 638         /* impossible("candlelight for %d?", obj->otyp); */
 639         radius = 3; /* lamp's value */
 640     }
 641     return radius;
 642 }
 643
 644 /* light emitting artifact's range depends upon its curse/bless state */
 645 int
 646 arti_light_radius(obj)
 647 struct obj *obj;
 648 {
 649     /*
 650      * Used by begin_burn() when setting up a new light source
 651      * (obj->lamplit will already be set by this point) and
 652      * also by bless()/unbless()/uncurse()/curse() to decide
 653      * whether to call obj_adjust_light_radius().
 654      */
 655
 656     /* sanity check [simplifies usage by bless()/curse()/&c] */
 657     if (!obj->lamplit || !artifact_light(obj))
 658         return 0;
 659
 660     /* cursed radius of 1 is not noticeable for an item that's
 661        carried by the hero but is if it's carried by a monster
 662        or left lit on the floor (not applicable for Sunsword) */
 663     return (obj->blessed ? 3 : !obj->cursed ? 2 : 1);
 664 }
 665
 666 /* adverb describing lit artifact's light; depends on curse/bless state */
 667 const char *
 668 arti_light_description(obj)
 669 struct obj *obj;
 670 {
 671     switch (arti_light_radius(obj)) {
 672     case 3:
 673 #if 0 /*JP*/
 674         return "brilliantly"; /* blessed */
 675 #else
 676         return "\83L\83\89\83L\83\89\82Æ"; /* blessed */
 677 #endif
 678     case 2:
 679 #if 0 /*JP*/
 680         return "brightly"; /* uncursed */
 681 #else
 682         return "\96¾\82é\82"; /* uncursed */
 683 #endif
 684     case 1:
 685 #if 0 /*JP*/
 686         return "dimly"; /* cursed */
 687 #else
 688         return "\94\96\88Ã\82"; /* cursed */
 689 #endif
 690     default:
 691         break;
 692     }
 693 /*JP
 694     return "strangely";
 695 */
 696     return "\95s\8ev\8bc\82É";
 697 }
 698
 699 int
 700 wiz_light_sources()
 701 {
 702     winid win;
 703     char buf[BUFSZ];
 704     light_source *ls;
 705
 706     win = create_nhwindow(NHW_MENU); /* corner text window */
 707     if (win == WIN_ERR)
 708         return 0;
 709
 710     Sprintf(buf, "Mobile light sources: hero @ (%2d,%2d)", u.ux, u.uy);
 711     putstr(win, 0, buf);
 712     putstr(win, 0, "");
 713
 714     if (light_base) {
 715         putstr(win, 0, "location range flags  type    id");
 716         putstr(win, 0, "-------- ----- ------ ----  -------");
 717         for (ls = light_base; ls; ls = ls->next) {
 718             Sprintf(buf, "  %2d,%2d   %2d   0x%04x  %s  %s", ls->x, ls->y,
 719                     ls->range, ls->flags,
 720                     (ls->type == LS_OBJECT
 721                        ? "obj"
 722                        : ls->type == LS_MONSTER
 723                           ? (mon_is_local(ls->id.a_monst)
 724                              ? "mon"
 725                              : (ls->id.a_monst == &youmonst)
 726                                 ? "you"
 727                                 /* migrating monster */
 728                                 : "<m>")
 729                           : "???"),
 730                     fmt_ptr(ls->id.a_void));
 731             putstr(win, 0, buf);
 732         }
 733     } else
 734         putstr(win, 0, "<none>");
 735
 736     display_nhwindow(win, FALSE);
 737     destroy_nhwindow(win);
 738
 739     return 0;
 740 }
 741
 742 /*light.c*/