Source:NetHack 3.6.2/src/display.c

From NetHackWiki
Jump to navigation Jump to search

Below is the full text to display.c from the source code of NetHack 3.6.2. To link to a particular line, write [[Source:NetHack 3.6.2/src/display.c#line12]], for example.

The NetHack General Public License applies to screenshots, source code and other content from NetHack.

This content was modified from the original NetHack source code distribution (by splitting up NetHack content between wiki pages, and possibly further editing). See the page history for a list of who changed it, and on what dates.

1. /* NetHack 3.6	display.c	$NHDT-Date: 1556835736 2019/05/02 22:22:16 $  $NHDT-Branch: NetHack-3.6.2-beta01 $:$NHDT-Revision: 1.101 $ */
2. /* Copyright (c) Dean Luick, with acknowledgements to Kevin Darcy */
3. /* and Dave Cohrs, 1990.                                          */
4. /* NetHack may be freely redistributed.  See license for details. */
5. 
6. /*
7.  *                      THE NEW DISPLAY CODE
8.  *
9.  * The old display code has been broken up into three parts: vision, display,
10.  * and drawing.  Vision decides what locations can and cannot be physically
11.  * seen by the hero.  Display decides _what_ is displayed at a given location.
12.  * Drawing decides _how_ to draw a monster, fountain, sword, etc.
13.  *
14.  * The display system uses information from the vision system to decide
15.  * what to draw at a given location.  The routines for the vision system
16.  * can be found in vision.c and vision.h.  The routines for display can
17.  * be found in this file (display.c) and display.h.  The drawing routines
18.  * are part of the window port.  See doc/window.doc for the drawing
19.  * interface.
20.  *
21.  * The display system deals with an abstraction called a glyph.  Anything
22.  * that could possibly be displayed has a unique glyph identifier.
23.  *
24.  * What is seen on the screen is a combination of what the hero remembers
25.  * and what the hero currently sees.  Objects and dungeon features (walls
26.  * doors, etc) are remembered when out of sight.  Monsters and temporary
27.  * effects are not remembered.  Each location on the level has an
28.  * associated glyph.  This is the hero's _memory_ of what he or she has
29.  * seen there before.
30.  *
31.  * Display rules:
32.  *
33.  *      If the location is in sight, display in order:
34.  *              visible (or sensed) monsters
35.  *              visible objects
36.  *              known traps
37.  *              background
38.  *
39.  *      If the location is out of sight, display in order:
40.  *              sensed monsters (via telepathy or persistent detection)
41.  *              warning (partly-sensed monster shown as an abstraction)
42.  *              memory
43.  *
44.  *      "Remembered, unseen monster" is handled like an object rather
45.  *      than a monster, and stays displayed whether or not it is in sight.
46.  *      It is removed when a visible or sensed or warned-of monster gets
47.  *      shown at its location or when searching or fighting reveals that
48.  *      no monster is there.
49.  *
50.  *
51.  * Here is a list of the major routines in this file to be used externally:
52.  *
53.  * newsym
54.  *
55.  * Possibly update the screen location (x,y).  This is the workhorse routine.
56.  * It is always correct --- where correct means following the in-sight/out-
57.  * of-sight rules.  **Most of the code should use this routine.**  This
58.  * routine updates the map and displays monsters.
59.  *
60.  *
61.  * map_background
62.  * map_object
63.  * map_trap
64.  * map_invisible
65.  * unmap_object
66.  *
67.  * If you absolutely must override the in-sight/out-of-sight rules, there
68.  * are two possibilities.  First, you can mess with vision to force the
69.  * location in sight then use newsym(), or you can  use the map_* routines.
70.  * The first has not been tried [no need] and the second is used in the
71.  * detect routines --- detect object, magic mapping, etc.  The map_*
72.  * routines *change* what the hero remembers.  All changes made by these
73.  * routines will be sticky --- they will survive screen redraws.  Do *not*
74.  * use these for things that only temporarily change the screen.  These
75.  * routines are also used directly by newsym().  unmap_object is used to
76.  * clear a remembered object when/if detection reveals it isn't there.
77.  *
78.  *
79.  * show_glyph
80.  *
81.  * This is direct (no processing in between) buffered access to the screen.
82.  * Temporary screen effects are run through this and its companion,
83.  * flush_screen().  There is yet a lower level routine, print_glyph(),
84.  * but this is unbuffered and graphic dependent (i.e. it must be surrounded
85.  * by graphic set-up and tear-down routines).  Do not use print_glyph().
86.  *
87.  *
88.  * see_monsters
89.  * see_objects
90.  * see_traps
91.  *
92.  * These are only used when something affects all of the monsters or
93.  * objects or traps.  For objects and traps, the only thing is hallucination.
94.  * For monsters, there are hallucination and changing from/to blindness, etc.
95.  *
96.  *
97.  * tmp_at
98.  *
99.  * This is a useful interface for displaying temporary items on the screen.
100.  * Its interface is different than previously, so look at it carefully.
101.  *
102.  *
103.  *
104.  * Parts of the rm structure that are used:
105.  *
106.  *      typ     - What is really there.
107.  *      glyph   - What the hero remembers.  This will never be a monster.
108.  *                Monsters "float" above this.
109.  *      lit     - True if the position is lit.  An optimization for
110.  *                lit/unlit rooms.
111.  *      waslit  - True if the position was *remembered* as lit.
112.  *      seenv   - A vector of bits representing the directions from which the
113.  *                hero has seen this position.  The vector's primary use is
114.  *                determining how walls are seen.  E.g. a wall sometimes looks
115.  *                like stone on one side, but is seen as wall from the other.
116.  *                Other uses are for unmapping detected objects and felt
117.  *                locations, where we need to know if the hero has ever
118.  *                seen the location.
119.  *      flags   - Additional information for the typ field.  Different for
120.  *                each typ.
121.  *      horizontal - Indicates whether the wall or door is horizontal or
122.  *                vertical.
123.  */
124. #include "hack.h"
125. 
126. STATIC_DCL void FDECL(display_monster,
127.                       (XCHAR_P, XCHAR_P, struct monst *, int, XCHAR_P));
128. STATIC_DCL int FDECL(swallow_to_glyph, (int, int));
129. STATIC_DCL void FDECL(display_warning, (struct monst *));
130. 
131. STATIC_DCL int FDECL(check_pos, (int, int, int));
132. STATIC_DCL int FDECL(get_bk_glyph, (XCHAR_P, XCHAR_P));
133. STATIC_DCL int FDECL(tether_glyph, (int, int));
134. 
135. /*#define WA_VERBOSE*/ /* give (x,y) locations for all "bad" spots */
136. #ifdef WA_VERBOSE
137. STATIC_DCL boolean FDECL(more_than_one, (int, int, int, int, int));
138. #endif
139. 
140. STATIC_DCL int FDECL(set_twall, (int, int, int, int, int, int, int, int));
141. STATIC_DCL int FDECL(set_wall, (int, int, int));
142. STATIC_DCL int FDECL(set_corn, (int, int, int, int, int, int, int, int));
143. STATIC_DCL int FDECL(set_crosswall, (int, int));
144. STATIC_DCL void FDECL(set_seenv, (struct rm *, int, int, int, int));
145. STATIC_DCL void FDECL(t_warn, (struct rm *));
146. STATIC_DCL int FDECL(wall_angle, (struct rm *));
147. 
148. #define remember_topology(x, y) (lastseentyp[x][y] = levl[x][y].typ)
149. 
150. /*
151.  * magic_map_background()
152.  *
153.  * This function is similar to map_background (see below) except we pay
154.  * attention to and correct unexplored, lit ROOM and CORR spots.
155.  */
156. void
157. magic_map_background(x, y, show)
158. xchar x, y;
159. int show;
160. {
161.     int glyph = back_to_glyph(x, y); /* assumes hero can see x,y */
162.     struct rm *lev = &levl[x][y];
163. 
164.     /*
165.      * Correct for out of sight lit corridors and rooms that the hero
166.      * doesn't remember as lit.
167.      */
168.     if (!cansee(x, y) && !lev->waslit) {
169.         /* Floor spaces are dark if unlit.  Corridors are dark if unlit. */
170.         if (lev->typ == ROOM && glyph == cmap_to_glyph(S_room))
171.             glyph = cmap_to_glyph((flags.dark_room && iflags.use_color)
172.                                       ? (DARKROOMSYM)
173.                                       : S_stone);
174.         else if (lev->typ == CORR && glyph == cmap_to_glyph(S_litcorr))
175.             glyph = cmap_to_glyph(S_corr);
176.     }
177.     if (level.flags.hero_memory)
178.         lev->glyph = glyph;
179.     if (show)
180.         show_glyph(x, y, glyph);
181. 
182.     remember_topology(x, y);
183. }
184. 
185. /*
186.  * The routines map_background(), map_object(), and map_trap() could just
187.  * as easily be:
188.  *
189.  *      map_glyph(x,y,glyph,show)
190.  *
191.  * Which is called with the xx_to_glyph() in the call.  Then I can get
192.  * rid of 3 routines that don't do very much anyway.  And then stop
193.  * having to create fake objects and traps.  However, I am reluctant to
194.  * make this change.
195.  */
196. /* FIXME: some of these use xchars for x and y, and some use ints.  Make
197.  * this consistent.
198.  */
199. 
200. /*
201.  * map_background()
202.  *
203.  * Make the real background part of our map.  This routine assumes that
204.  * the hero can physically see the location.  Update the screen if directed.
205.  */
206. void
207. map_background(x, y, show)
208. register xchar x, y;
209. register int show;
210. {
211.     register int glyph = back_to_glyph(x, y);
212. 
213.     if (level.flags.hero_memory)
214.         levl[x][y].glyph = glyph;
215.     if (show)
216.         show_glyph(x, y, glyph);
217. }
218. 
219. /*
220.  * map_trap()
221.  *
222.  * Map the trap and print it out if directed.  This routine assumes that the
223.  * hero can physically see the location.
224.  */
225. void
226. map_trap(trap, show)
227. register struct trap *trap;
228. register int show;
229. {
230.     register int x = trap->tx, y = trap->ty;
231.     register int glyph = trap_to_glyph(trap, newsym_rn2);
232. 
233.     if (level.flags.hero_memory)
234.         levl[x][y].glyph = glyph;
235.     if (show)
236.         show_glyph(x, y, glyph);
237. }
238. 
239. /*
240.  * map_object()
241.  *
242.  * Map the given object.  This routine assumes that the hero can physically
243.  * see the location of the object.  Update the screen if directed.
244.  */
245. void
246. map_object(obj, show)
247. register struct obj *obj;
248. register int show;
249. {
250.     register int x = obj->ox, y = obj->oy;
251.     register int glyph = obj_to_glyph(obj, newsym_rn2);
252. 
253.     if (level.flags.hero_memory) {
254.         /* MRKR: While hallucinating, statues are seen as random monsters */
255.         /*       but remembered as random objects.                        */
256. 
257.         if (Hallucination && obj->otyp == STATUE) {
258.             levl[x][y].glyph = random_obj_to_glyph(newsym_rn2);
259.         } else {
260.             levl[x][y].glyph = glyph;
261.         }
262.     }
263.     if (show)
264.         show_glyph(x, y, glyph);
265. }
266. 
267. /*
268.  * map_invisible()
269.  *
270.  * Make the hero remember that a square contains an invisible monster.
271.  * This is a special case in that the square will continue to be displayed
272.  * this way even when the hero is close enough to see it.  To get rid of
273.  * this and display the square's actual contents, use unmap_object() followed
274.  * by newsym() if necessary.
275.  */
276. void
277. map_invisible(x, y)
278. register xchar x, y;
279. {
280.     if (x != u.ux || y != u.uy) { /* don't display I at hero's location */
281.         if (level.flags.hero_memory)
282.             levl[x][y].glyph = GLYPH_INVISIBLE;
283.         show_glyph(x, y, GLYPH_INVISIBLE);
284.     }
285. }
286. 
287. boolean
288. unmap_invisible(x, y)
289. int x, y;
290. {
291.     if (isok(x,y) && glyph_is_invisible(levl[x][y].glyph)) {
292.         unmap_object(x, y);
293.         newsym(x, y);
294.         return TRUE;
295.     }
296.     return FALSE;
297. }
298. 
299. 
300. /*
301.  * unmap_object()
302.  *
303.  * Remove something from the map when the hero realizes it's not there any
304.  * more.  Replace it with background or known trap, but not with any other
305.  * If this is used for detection, a full screen update is imminent anyway;
306.  * if this is used to get rid of an invisible monster notation, we might have
307.  * to call newsym().
308.  */
309. void
310. unmap_object(x, y)
311. register int x, y;
312. {
313.     register struct trap *trap;
314. 
315.     if (!level.flags.hero_memory)
316.         return;
317. 
318.     if ((trap = t_at(x, y)) != 0 && trap->tseen && !covers_traps(x, y)) {
319.         map_trap(trap, 0);
320.     } else if (levl[x][y].seenv) {
321.         struct rm *lev = &levl[x][y];
322. 
323.         map_background(x, y, 0);
324. 
325.         /* turn remembered dark room squares dark */
326.         if (!lev->waslit && lev->glyph == cmap_to_glyph(S_room)
327.             && lev->typ == ROOM)
328.             lev->glyph = cmap_to_glyph(S_stone);
329.     } else {
330.         levl[x][y].glyph = cmap_to_glyph(S_stone); /* default val */
331.     }
332. }
333. 
334. /*
335.  * map_location()
336.  *
337.  * Make whatever at this location show up.  This is only for non-living
338.  * things.  This will not handle feeling invisible objects correctly.
339.  *
340.  * Internal to display.c, this is a #define for speed.
341.  */
342. #define _map_location(x, y, show) \
343.     {                                                                       \
344.         register struct obj *obj;                                           \
345.         register struct trap *trap;                                         \
346.                                                                             \
347.         if ((obj = vobj_at(x, y)) && !covers_objects(x, y))                 \
348.             map_object(obj, show);                                          \
349.         else if ((trap = t_at(x, y)) && trap->tseen && !covers_traps(x, y)) \
350.             map_trap(trap, show);                                           \
351.         else                                                                \
352.             map_background(x, y, show);                                     \
353.                                                                             \
354.         remember_topology(x, y);                                            \
355.     }
356. 
357. void
358. map_location(x, y, show)
359. int x, y, show;
360. {
361.     _map_location(x, y, show);
362. }
363. 
364. #define DETECTED 2
365. #define PHYSICALLY_SEEN 1
366. #define is_worm_tail(mon) ((mon) && ((x != (mon)->mx) || (y != (mon)->my)))
367. 
368. /*
369.  * display_monster()
370.  *
371.  * Note that this is *not* a map_XXXX() function!  Monsters sort of float
372.  * above everything.
373.  *
374.  * Yuck.  Display body parts by recognizing that the display position is
375.  * not the same as the monster position.  Currently the only body part is
376.  * a worm tail.
377.  *
378.  */
379. STATIC_OVL void
380. display_monster(x, y, mon, sightflags, worm_tail)
381. register xchar x, y;        /* display position */
382. register struct monst *mon; /* monster to display */
383. int sightflags;             /* 1 if the monster is physically seen;
384.                                2 if detected using Detect_monsters */
385. xchar worm_tail;            /* mon is actually a worm tail */
386. {
387.     boolean mon_mimic = (M_AP_TYPE(mon) != M_AP_NOTHING);
388.     int sensed = (mon_mimic && (Protection_from_shape_changers
389.                                 || sensemon(mon)));
390.     /*
391.      * We must do the mimic check first.  If the mimic is mimicing something,
392.      * and the location is in sight, we have to change the hero's memory
393.      * so that when the position is out of sight, the hero remembers what
394.      * the mimic was mimicing.
395.      */
396. 
397.     if (mon_mimic && (sightflags == PHYSICALLY_SEEN)) {
398.         switch (M_AP_TYPE(mon)) {
399.         default:
400.             impossible("display_monster:  bad m_ap_type value [ = %d ]",
401.                        (int) mon->m_ap_type);
402.             /*FALLTHRU*/
403.         case M_AP_NOTHING:
404.             show_glyph(x, y, mon_to_glyph(mon, newsym_rn2));
405.             break;
406. 
407.         case M_AP_FURNITURE: {
408.             /*
409.              * This is a poor man's version of map_background().  I can't
410.              * use map_background() because we are overriding what is in
411.              * the 'typ' field.  Maybe have map_background()'s parameters
412.              * be (x,y,glyph) instead of just (x,y).
413.              *
414.              * mappearance is currently set to an S_ index value in
415.              * makemon.c.
416.              */
417.             int sym = mon->mappearance, glyph = cmap_to_glyph(sym);
418. 
419.             levl[x][y].glyph = glyph;
420.             if (!sensed) {
421.                 show_glyph(x, y, glyph);
422.                 /* override real topology with mimic's fake one */
423.                 lastseentyp[x][y] = cmap_to_type(sym);
424.             }
425.             break;
426.         }
427. 
428.         case M_AP_OBJECT: {
429.             /* Make a fake object to send to map_object(). */
430.             struct obj obj;
431. 
432.             obj = zeroobj;
433.             obj.ox = x;
434.             obj.oy = y;
435.             obj.otyp = mon->mappearance;
436.             /* might be mimicing a corpse or statue */
437.             obj.corpsenm = has_mcorpsenm(mon) ? MCORPSENM(mon) : PM_TENGU;
438.             map_object(&obj, !sensed);
439.             break;
440.         }
441. 
442.         case M_AP_MONSTER:
443.             show_glyph(x, y,
444.                        monnum_to_glyph(what_mon((int) mon->mappearance,
445.                                                 rn2_on_display_rng)));
446.             break;
447.         }
448.     }
449. 
450.     /* If mimic is unsuccessfully mimicing something, display the monster. */
451.     if (!mon_mimic || sensed) {
452.         int num;
453. 
454.         /* [ALI] Only use detected glyphs when monster wouldn't be
455.          * visible by any other means.
456.          *
457.          * There are no glyphs for "detected pets" so we have to
458.          * decide whether to display such things as detected or as tame.
459.          * If both are being highlighted in the same way, it doesn't
460.          * matter, but if not, showing them as pets is preferrable.
461.          */
462.         if (mon->mtame && !Hallucination) {
463.             if (worm_tail)
464.                 num = petnum_to_glyph(PM_LONG_WORM_TAIL);
465.             else
466.                 num = pet_to_glyph(mon, rn2_on_display_rng);
467.         } else if (sightflags == DETECTED) {
468.             if (worm_tail)
469.                 num = detected_monnum_to_glyph(
470.                              what_mon(PM_LONG_WORM_TAIL, rn2_on_display_rng));
471.             else
472.                 num = detected_mon_to_glyph(mon, rn2_on_display_rng);
473.         } else {
474.             if (worm_tail)
475.                 num = monnum_to_glyph(
476.                              what_mon(PM_LONG_WORM_TAIL, rn2_on_display_rng));
477.             else
478.                 num = mon_to_glyph(mon, rn2_on_display_rng);
479.         }
480.         show_glyph(x, y, num);
481.     }
482. }
483. 
484. /*
485.  * display_warning()
486.  *
487.  * This is also *not* a map_XXXX() function!  Monster warnings float
488.  * above everything just like monsters do, but only if the monster
489.  * is not showing.
490.  *
491.  * Do not call for worm tails.
492.  */
493. STATIC_OVL void
494. display_warning(mon)
495. register struct monst *mon;
496. {
497.     int x = mon->mx, y = mon->my;
498.     int glyph;
499. 
500.     if (mon_warning(mon)) {
501.         int wl = Hallucination ?
502.             rn2_on_display_rng(WARNCOUNT - 1) + 1 : warning_of(mon);
503.         glyph = warning_to_glyph(wl);
504.     } else if (MATCH_WARN_OF_MON(mon)) {
505.         glyph = mon_to_glyph(mon, rn2_on_display_rng);
506.     } else {
507.         impossible("display_warning did not match warning type?");
508.         return;
509.     }
510.     /* warning glyph is drawn on the monster layer; unseen
511.        monster glyph is drawn on the object/trap/floor layer;
512.        if we see a 'warning' move onto 'remembered, unseen' we
513.        need to explicitly remove that in order for it to not
514.        reappear when the warned-of monster moves off that spot */
515.     if (glyph_is_invisible(levl[x][y].glyph))
516.         unmap_object(x, y);
517.     show_glyph(x, y, glyph);
518. }
519. 
520. int
521. warning_of(mon)
522. struct monst *mon;
523. {
524.     int wl = 0, tmp = 0;
525. 
526.     if (mon_warning(mon)) {
527.         tmp = (int) (mon->m_lev / 4);    /* match display.h */
528.         wl = (tmp > WARNCOUNT - 1) ? WARNCOUNT - 1 : tmp;
529.     }
530.     return wl;
531. }
532. 
533. 
534. /*
535.  * feel_newsym()
536.  *
537.  * When hero knows what happened to location, even when blind.
538.  */
539. void
540. feel_newsym(x, y)
541. xchar x, y;
542. {
543.     if (Blind)
544.         feel_location(x, y);
545.     else
546.         newsym(x, y);
547. }
548. 
549. 
550. /*
551.  * feel_location()
552.  *
553.  * Feel the given location.  This assumes that the hero is blind and that
554.  * the given position is either the hero's or one of the eight squares
555.  * adjacent to the hero (except for a boulder push).
556.  * If an invisible monster has gone away, that will be discovered.  If an
557.  * invisible monster has appeared, this will _not_ be discovered since
558.  * searching only finds one monster per turn so we must check that separately.
559.  */
560. void
561. feel_location(x, y)
562. xchar x, y;
563. {
564.     struct rm *lev;
565.     struct obj *boulder;
566.     register struct monst *mon;
567. 
568.     if (!isok(x, y))
569.         return;
570.     lev = &(levl[x][y]);
571.     /* If hero's memory of an invisible monster is accurate, we want to keep
572.      * him from detecting the same monster over and over again on each turn.
573.      * We must return (so we don't erase the monster).  (We must also, in the
574.      * search function, be sure to skip over previously detected 'I's.)
575.      */
576.     if (glyph_is_invisible(lev->glyph) && m_at(x, y))
577.         return;
578. 
579.     /* The hero can't feel non pool locations while under water
580.        except for lava and ice. */
581.     if (Underwater && !Is_waterlevel(&u.uz)
582.         && !is_pool_or_lava(x, y) && !is_ice(x, y))
583.         return;
584. 
585.     /* Set the seen vector as if the hero had seen it.
586.        It doesn't matter if the hero is levitating or not. */
587.     set_seenv(lev, u.ux, u.uy, x, y);
588. 
589.     if (!can_reach_floor(FALSE)) {
590.         /*
591.          * Levitation Rules.  It is assumed that the hero can feel the state
592.          * of the walls around herself and can tell if she is in a corridor,
593.          * room, or doorway.  Boulders are felt because they are large enough.
594.          * Anything else is unknown because the hero can't reach the ground.
595.          * This makes things difficult.
596.          *
597.          * Check (and display) in order:
598.          *
599.          *      + Stone, walls, and closed doors.
600.          *      + Boulders.  [see a boulder before a doorway]
601.          *      + Doors.
602.          *      + Room/water positions
603.          *      + Everything else (hallways!)
604.          */
605.         if (IS_ROCK(lev->typ)
606.             || (IS_DOOR(lev->typ)
607.                 && (lev->doormask & (D_LOCKED | D_CLOSED)))) {
608.             map_background(x, y, 1);
609.         } else if ((boulder = sobj_at(BOULDER, x, y)) != 0) {
610.             map_object(boulder, 1);
611.         } else if (IS_DOOR(lev->typ)) {
612.             map_background(x, y, 1);
613.         } else if (IS_ROOM(lev->typ) || IS_POOL(lev->typ)) {
614.             boolean do_room_glyph;
615. 
616.             /*
617.              * An open room or water location.  Normally we wouldn't touch
618.              * this, but we have to get rid of remembered boulder symbols.
619.              * This will only occur in rare occasions when the hero goes
620.              * blind and doesn't find a boulder where expected (something
621.              * came along and picked it up).  We know that there is not a
622.              * boulder at this location.  Show fountains, pools, etc.
623.              * underneath if already seen.  Otherwise, show the appropriate
624.              * floor symbol.
625.              *
626.              * Similarly, if the hero digs a hole in a wall or feels a
627.              * location that used to contain an unseen monster.  In these
628.              * cases, there's no reason to assume anything was underneath,
629.              * so just show the appropriate floor symbol.  If something was
630.              * embedded in the wall, the glyph will probably already
631.              * reflect that.  Don't change the symbol in this case.
632.              *
633.              * This isn't quite correct.  If the boulder was on top of some
634.              * other objects they should be seen once the boulder is removed.
635.              * However, we have no way of knowing that what is there now
636.              * was there then.  So we let the hero have a lapse of memory.
637.              * We could also just display what is currently on the top of the
638.              * object stack (if anything).
639.              */
640.             do_room_glyph = FALSE;
641.             if (lev->glyph == objnum_to_glyph(BOULDER)
642.                 || glyph_is_invisible(lev->glyph)) {
643.                 if (lev->typ != ROOM && lev->seenv)
644.                     map_background(x, y, 1);
645.                 else
646.                     do_room_glyph = TRUE;
647.             } else if (lev->glyph >= cmap_to_glyph(S_stone)
648.                        && lev->glyph < cmap_to_glyph(S_darkroom)) {
649.                 do_room_glyph = TRUE;
650.             }
651.             if (do_room_glyph) {
652.                 lev->glyph = (flags.dark_room && iflags.use_color
653.                               && !Is_rogue_level(&u.uz))
654.                                  ? cmap_to_glyph(S_darkroom)
655.                                  : (lev->waslit ? cmap_to_glyph(S_room)
656.                                                 : cmap_to_glyph(S_stone));
657.                 show_glyph(x, y, lev->glyph);
658.             }
659.         } else {
660.             /* We feel it (I think hallways are the only things left). */
661.             map_background(x, y, 1);
662.             /* Corridors are never felt as lit (unless remembered that way) */
663.             /* (lit_corridor only).                                         */
664.             if (lev->typ == CORR && lev->glyph == cmap_to_glyph(S_litcorr)
665.                 && !lev->waslit)
666.                 show_glyph(x, y, lev->glyph = cmap_to_glyph(S_corr));
667.             else if (lev->typ == ROOM && flags.dark_room && iflags.use_color
668.                      && lev->glyph == cmap_to_glyph(S_room))
669.                 show_glyph(x, y, lev->glyph = cmap_to_glyph(S_darkroom));
670.         }
671.     } else {
672.         _map_location(x, y, 1);
673. 
674.         if (Punished) {
675.             /*
676.              * A ball or chain is only felt if it is first on the object
677.              * location list.  Otherwise, we need to clear the felt bit ---
678.              * something has been dropped on the ball/chain.  If the bit is
679.              * not cleared, then when the ball/chain is moved it will drop
680.              * the wrong glyph.
681.              */
682.             if (uchain->ox == x && uchain->oy == y) {
683.                 if (level.objects[x][y] == uchain)
684.                     u.bc_felt |= BC_CHAIN;
685.                 else
686.                     u.bc_felt &= ~BC_CHAIN; /* do not feel the chain */
687.             }
688.             if (!carried(uball) && uball->ox == x && uball->oy == y) {
689.                 if (level.objects[x][y] == uball)
690.                     u.bc_felt |= BC_BALL;
691.                 else
692.                     u.bc_felt &= ~BC_BALL; /* do not feel the ball */
693.             }
694.         }
695. 
696.         /* Floor spaces are dark if unlit.  Corridors are dark if unlit. */
697.         if (lev->typ == ROOM && lev->glyph == cmap_to_glyph(S_room)
698.             && (!lev->waslit || (flags.dark_room && iflags.use_color)))
699.             show_glyph(x, y, lev->glyph = cmap_to_glyph(
700.                                  flags.dark_room ? S_darkroom : S_stone));
701.         else if (lev->typ == CORR && lev->glyph == cmap_to_glyph(S_litcorr)
702.                  && !lev->waslit)
703.             show_glyph(x, y, lev->glyph = cmap_to_glyph(S_corr));
704.     }
705.     /* draw monster on top if we can sense it */
706.     if ((x != u.ux || y != u.uy) && (mon = m_at(x, y)) != 0 && sensemon(mon))
707.         display_monster(x, y, mon,
708.                         (tp_sensemon(mon) || MATCH_WARN_OF_MON(mon))
709.                             ? PHYSICALLY_SEEN
710.                             : DETECTED,
711.                         is_worm_tail(mon));
712. }
713. 
714. /*
715.  * newsym()
716.  *
717.  * Possibly put a new glyph at the given location.
718.  */
719. void
720. newsym(x, y)
721. register int x, y;
722. {
723.     register struct monst *mon;
724.     register struct rm *lev = &(levl[x][y]);
725.     register int see_it;
726.     register xchar worm_tail;
727. 
728.     if (in_mklev)
729.         return;
730. #ifdef HANGUPHANDLING
731.     if (program_state.done_hup)
732.         return;
733. #endif
734. 
735.     /* only permit updating the hero when swallowed */
736.     if (u.uswallow) {
737.         if (x == u.ux && y == u.uy)
738.             display_self();
739.         return;
740.     }
741.     if (Underwater && !Is_waterlevel(&u.uz)) {
742.         /* when underwater, don't do anything unless <x,y> is an
743.            adjacent water or lava or ice position */
744.         if (!(is_pool_or_lava(x, y) || is_ice(x, y)) || distu(x, y) > 2)
745.             return;
746.     }
747. 
748.     /* Can physically see the location. */
749.     if (cansee(x, y)) {
750.         NhRegion *reg = visible_region_at(x, y);
751.         /*
752.          * Don't use templit here:  E.g.
753.          *
754.          *      lev->waslit = !!(lev->lit || templit(x,y));
755.          *
756.          * Otherwise we have the "light pool" problem, where non-permanently
757.          * lit areas just out of sight stay remembered as lit.  They should
758.          * re-darken.
759.          *
760.          * Perhaps ALL areas should revert to their "unlit" look when
761.          * out of sight.
762.          */
763.         lev->waslit = (lev->lit != 0); /* remember lit condition */
764. 
765.         /* normal region shown only on accessible positions, but poison clouds
766.          * also shown above lava, pools and moats.
767.          */
768.         if (reg && (ACCESSIBLE(lev->typ)
769.                     || (reg->glyph == cmap_to_glyph(S_poisoncloud)
770.                         && is_pool_or_lava(x, y)))) {
771.             show_region(reg, x, y);
772.             return;
773.         }
774. 
775.         if (x == u.ux && y == u.uy) {
776.             int see_self = canspotself();
777. 
778.             /* update map information for <u.ux,u.uy> (remembered topology
779.                and object/known trap/terrain glyph) but only display it if
780.                hero can't see him/herself, then show self if appropriate */
781.             _map_location(x, y, !see_self);
782.             if (see_self)
783.                 display_self();
784.         } else {
785.             mon = m_at(x, y);
786.             worm_tail = is_worm_tail(mon);
787.             see_it = mon && (mon_visible(mon)
788.                              || (!worm_tail && (tp_sensemon(mon)
789.                                                 || MATCH_WARN_OF_MON(mon))));
790.             if (mon && (see_it || (!worm_tail && Detect_monsters))) {
791.                 if (mon->mtrapped) {
792.                     struct trap *trap = t_at(x, y);
793.                     int tt = trap ? trap->ttyp : NO_TRAP;
794. 
795.                     /* if monster is in a physical trap, you see trap too */
796.                     if (tt == BEAR_TRAP || is_pit(tt) || tt == WEB)
797.                         trap->tseen = 1;
798.                 }
799.                 _map_location(x, y, 0); /* map under the monster */
800.                 /* also gets rid of any invisibility glyph */
801.                 display_monster(x, y, mon,
802.                                 see_it ? PHYSICALLY_SEEN : DETECTED,
803.                                 worm_tail);
804.             } else if (mon && mon_warning(mon) && !is_worm_tail(mon)) {
805.                 display_warning(mon);
806.             } else if (glyph_is_invisible(lev->glyph)) {
807.                 map_invisible(x, y);
808.             } else
809.                 _map_location(x, y, 1); /* map the location */\
810.         }
811. 
812.     /* Can't see the location. */
813.     } else {
814.         if (x == u.ux && y == u.uy) {
815.             feel_location(u.ux, u.uy); /* forces an update */
816. 
817.             if (canspotself())
818.                 display_self();
819.         } else if ((mon = m_at(x, y)) != 0
820.                    && ((see_it = (tp_sensemon(mon) || MATCH_WARN_OF_MON(mon)
821.                                   || (see_with_infrared(mon)
822.                                       && mon_visible(mon)))) != 0
823.                        || Detect_monsters)) {
824.             /* Seen or sensed monsters are printed every time.
825.                This also gets rid of any invisibility glyph. */
826.             display_monster(x, y, mon, see_it ? 0 : DETECTED,
827.                             is_worm_tail(mon) ? TRUE : FALSE);
828.         } else if (mon && mon_warning(mon) && !is_worm_tail(mon)) {
829.             display_warning(mon);
830. 
831.         /*
832.          * If the location is remembered as being both dark (waslit is false)
833.          * and lit (glyph is a lit room or lit corridor) then it was either:
834.          *
835.          *      (1) A dark location that the hero could see through night
836.          *          vision.
837.          *      (2) Darkened while out of the hero's sight.  This can happen
838.          *          when cursed scroll of light is read.
839.          *
840.          * In either case, we have to manually correct the hero's memory to
841.          * match waslit.  Deciding when to change waslit is non-trivial.
842.          *
843.          *  Note:  If flags.lit_corridor is set, then corridors act like room
844.          *         squares.  That is, they light up if in night vision range.
845.          *         If flags.lit_corridor is not set, then corridors will
846.          *         remain dark unless lit by a light spell and may darken
847.          *         again, as discussed above.
848.          *
849.          * These checks and changes must be here and not in back_to_glyph().
850.          * They are dependent on the position being out of sight.
851.          */
852.         } else if (Is_rogue_level(&u.uz)) {
853.             if (lev->glyph == cmap_to_glyph(S_litcorr) && lev->typ == CORR)
854.                 show_glyph(x, y, lev->glyph = cmap_to_glyph(S_corr));
855.             else if (lev->glyph == cmap_to_glyph(S_room) && lev->typ == ROOM
856.                      && !lev->waslit)
857.                 show_glyph(x, y, lev->glyph = cmap_to_glyph(S_stone));
858.             else
859.                 goto show_mem;
860.         } else if (!lev->waslit || (flags.dark_room && iflags.use_color)) {
861.             if (lev->glyph == cmap_to_glyph(S_litcorr) && lev->typ == CORR)
862.                 show_glyph(x, y, lev->glyph = cmap_to_glyph(S_corr));
863.             else if (lev->glyph == cmap_to_glyph(S_room) && lev->typ == ROOM)
864.                 show_glyph(x, y, lev->glyph = cmap_to_glyph(DARKROOMSYM));
865.             else
866.                 goto show_mem;
867.         } else {
868.  show_mem:
869.             show_glyph(x, y, lev->glyph);
870.         }
871.     }
872. }
873. 
874. #undef is_worm_tail
875. 
876. /*
877.  * shieldeff()
878.  *
879.  * Put magic shield pyrotechnics at the given location.  This *could* be
880.  * pulled into a platform dependent routine for fancier graphics if desired.
881.  */
882. void
883. shieldeff(x, y)
884. xchar x, y;
885. {
886.     register int i;
887. 
888.     if (!flags.sparkle)
889.         return;
890.     if (cansee(x, y)) { /* Don't see anything if can't see the location */
891.         for (i = 0; i < SHIELD_COUNT; i++) {
892.             show_glyph(x, y, cmap_to_glyph(shield_static[i]));
893.             flush_screen(1); /* make sure the glyph shows up */
894.             delay_output();
895.         }
896.         newsym(x, y); /* restore the old information */
897.     }
898. }
899. 
900. int
901. tether_glyph(x, y)
902. int x, y;
903. {
904.     int tdx, tdy;
905.     tdx = u.ux - x;
906.     tdy = u.uy - y;
907.     return zapdir_to_glyph(sgn(tdx),sgn(tdy), 2);
908. }
909. 
910. /*
911.  * tmp_at()
912.  *
913.  * Temporarily place glyphs on the screen.  Do not call delay_output().  It
914.  * is up to the caller to decide if it wants to wait [presently, everyone
915.  * but explode() wants to delay].
916.  *
917.  * Call:
918.  *      (DISP_BEAM,    glyph)   open, initialize glyph
919.  *      (DISP_FLASH,   glyph)   open, initialize glyph
920.  *      (DISP_ALWAYS,  glyph)   open, initialize glyph
921.  *      (DISP_CHANGE,  glyph)   change glyph
922.  *      (DISP_END,     0)       close & clean up (2nd argument doesn't matter)
923.  *      (DISP_FREEMEM, 0)       only used to prevent memory leak during exit)
924.  *      (x, y)                  display the glyph at the location
925.  *
926.  * DISP_BEAM   - Display the given glyph at each location, but do not erase
927.  *               any until the close call.
928.  * DISP_TETHER - Display a tether glyph at each location, and the tethered
929.  *               object at the farthest location, but do not erase any
930.  *               until the return trip or close.
931.  * DISP_FLASH  - Display the given glyph at each location, but erase the
932.  *               previous location's glyph.
933.  * DISP_ALWAYS - Like DISP_FLASH, but vision is not taken into account.
934.  */
935. 
936. #define TMP_AT_MAX_GLYPHS (COLNO * 2)
937. 
938. static struct tmp_glyph {
939.     coord saved[TMP_AT_MAX_GLYPHS]; /* previously updated positions */
940.     int sidx;                       /* index of next unused slot in saved[] */
941.     int style; /* either DISP_BEAM or DISP_FLASH or DISP_ALWAYS */
942.     int glyph; /* glyph to use when printing */
943.     struct tmp_glyph *prev;
944. } tgfirst;
945. 
946. void
947. tmp_at(x, y)
948. int x, y;
949. {
950.     static struct tmp_glyph *tglyph = (struct tmp_glyph *) 0;
951.     struct tmp_glyph *tmp;
952. 
953.     switch (x) {
954.     case DISP_BEAM:
955.     case DISP_ALL:
956.     case DISP_TETHER:
957.     case DISP_FLASH:
958.     case DISP_ALWAYS:
959.         if (!tglyph)
960.             tmp = &tgfirst;
961.         else /* nested effect; we need dynamic memory */
962.             tmp = (struct tmp_glyph *) alloc(sizeof *tmp);
963.         tmp->prev = tglyph;
964.         tglyph = tmp;
965.         tglyph->sidx = 0;
966.         tglyph->style = x;
967.         tglyph->glyph = y;
968.         flush_screen(0); /* flush buffered glyphs */
969.         return;
970. 
971.     case DISP_FREEMEM: /* in case game ends with tmp_at() in progress */
972.         while (tglyph) {
973.             tmp = tglyph->prev;
974.             if (tglyph != &tgfirst)
975.                 free((genericptr_t) tglyph);
976.             tglyph = tmp;
977.         }
978.         return;
979. 
980.     default:
981.         break;
982.     }
983. 
984.     if (!tglyph)
985.         panic("tmp_at: tglyph not initialized");
986. 
987.     switch (x) {
988.     case DISP_CHANGE:
989.         tglyph->glyph = y;
990.         break;
991. 
992.     case DISP_END:
993.         if (tglyph->style == DISP_BEAM || tglyph->style == DISP_ALL) {
994.             register int i;
995. 
996.             /* Erase (reset) from source to end */
997.             for (i = 0; i < tglyph->sidx; i++)
998.                 newsym(tglyph->saved[i].x, tglyph->saved[i].y);
999.         } else if (tglyph->style == DISP_TETHER) {
1000.             int i;
1001. 
1002.             if (y == BACKTRACK && tglyph->sidx > 1) {
1003.                 /* backtrack */
1004.                 for (i = tglyph->sidx - 1; i > 0; i--) {
1005.                     newsym(tglyph->saved[i].x, tglyph->saved[i].y);
1006.                     show_glyph(tglyph->saved[i - 1].x,
1007.                                tglyph->saved[i - 1].y, tglyph->glyph);
1008.                     flush_screen(0);   /* make sure it shows up */
1009.                     delay_output();
1010.                 }
1011.                 tglyph->sidx = 1;
1012.             }
1013.             for (i = 0; i < tglyph->sidx; i++)
1014.                 newsym(tglyph->saved[i].x, tglyph->saved[i].y);
1015.         } else {              /* DISP_FLASH or DISP_ALWAYS */
1016.             if (tglyph->sidx) /* been called at least once */
1017.                 newsym(tglyph->saved[0].x, tglyph->saved[0].y);
1018.         }
1019.         /* tglyph->sidx = 0; -- about to be freed, so not necessary */
1020.         tmp = tglyph->prev;
1021.         if (tglyph != &tgfirst)
1022.             free((genericptr_t) tglyph);
1023.         tglyph = tmp;
1024.         break;
1025. 
1026.     default: /* do it */
1027.         if (!isok(x, y))
1028.             break;
1029.         if (tglyph->style == DISP_BEAM || tglyph->style == DISP_ALL) {
1030.             if (tglyph->style != DISP_ALL && !cansee(x, y))
1031.                 break;
1032.             if (tglyph->sidx >= TMP_AT_MAX_GLYPHS)
1033.                 break; /* too many locations */
1034.             /* save pos for later erasing */
1035.             tglyph->saved[tglyph->sidx].x = x;
1036.             tglyph->saved[tglyph->sidx].y = y;
1037.             tglyph->sidx += 1;
1038.         } else if (tglyph->style == DISP_TETHER) {
1039.             if (tglyph->sidx >= TMP_AT_MAX_GLYPHS)
1040.                 break; /* too many locations */
1041.             if (tglyph->sidx) {
1042.                 int px, py;
1043. 
1044.                 px = tglyph->saved[tglyph->sidx-1].x;
1045.                 py = tglyph->saved[tglyph->sidx-1].y;
1046.                 show_glyph(px, py, tether_glyph(px, py));
1047.             }
1048.             /* save pos for later use or erasure */
1049.             tglyph->saved[tglyph->sidx].x = x;
1050.             tglyph->saved[tglyph->sidx].y = y;
1051.             tglyph->sidx += 1;
1052.         } else {                /* DISP_FLASH/ALWAYS */
1053.             if (tglyph->sidx) { /* not first call, so reset previous pos */
1054.                 newsym(tglyph->saved[0].x, tglyph->saved[0].y);
1055.                 tglyph->sidx = 0; /* display is presently up to date */
1056.             }
1057.             if (!cansee(x, y) && tglyph->style != DISP_ALWAYS)
1058.                 break;
1059.             tglyph->saved[0].x = x;
1060.             tglyph->saved[0].y = y;
1061.             tglyph->sidx = 1;
1062.         }
1063. 
1064.         show_glyph(x, y, tglyph->glyph); /* show it */
1065.         flush_screen(0);                 /* make sure it shows up */
1066.         break;
1067.     } /* end case */
1068. }
1069. 
1070. /*
1071.  * swallowed()
1072.  *
1073.  * The hero is swallowed.  Show a special graphics sequence for this.  This
1074.  * bypasses all of the display routines and messes with buffered screen
1075.  * directly.  This method works because both vision and display check for
1076.  * being swallowed.
1077.  */
1078. void
1079. swallowed(first)
1080. int first;
1081. {
1082.     static xchar lastx, lasty; /* last swallowed position */
1083.     int swallower, left_ok, rght_ok;
1084. 
1085.     if (first) {
1086.         cls();
1087.         bot();
1088.     } else {
1089.         register int x, y;
1090. 
1091.         /* Clear old location */
1092.         for (y = lasty - 1; y <= lasty + 1; y++)
1093.             for (x = lastx - 1; x <= lastx + 1; x++)
1094.                 if (isok(x, y))
1095.                     show_glyph(x, y, cmap_to_glyph(S_stone));
1096.     }
1097. 
1098.     swallower = monsndx(u.ustuck->data);
1099.     /* assume isok(u.ux,u.uy) */
1100.     left_ok = isok(u.ux - 1, u.uy);
1101.     rght_ok = isok(u.ux + 1, u.uy);
1102.     /*
1103.      *  Display the hero surrounded by the monster's stomach.
1104.      */
1105.     if (isok(u.ux, u.uy - 1)) {
1106.         if (left_ok)
1107.             show_glyph(u.ux - 1, u.uy - 1,
1108.                        swallow_to_glyph(swallower, S_sw_tl));
1109.         show_glyph(u.ux, u.uy - 1, swallow_to_glyph(swallower, S_sw_tc));
1110.         if (rght_ok)
1111.             show_glyph(u.ux + 1, u.uy - 1,
1112.                        swallow_to_glyph(swallower, S_sw_tr));
1113.     }
1114. 
1115.     if (left_ok)
1116.         show_glyph(u.ux - 1, u.uy, swallow_to_glyph(swallower, S_sw_ml));
1117.     display_self();
1118.     if (rght_ok)
1119.         show_glyph(u.ux + 1, u.uy, swallow_to_glyph(swallower, S_sw_mr));
1120. 
1121.     if (isok(u.ux, u.uy + 1)) {
1122.         if (left_ok)
1123.             show_glyph(u.ux - 1, u.uy + 1,
1124.                        swallow_to_glyph(swallower, S_sw_bl));
1125.         show_glyph(u.ux, u.uy + 1, swallow_to_glyph(swallower, S_sw_bc));
1126.         if (rght_ok)
1127.             show_glyph(u.ux + 1, u.uy + 1,
1128.                        swallow_to_glyph(swallower, S_sw_br));
1129.     }
1130. 
1131.     /* Update the swallowed position. */
1132.     lastx = u.ux;
1133.     lasty = u.uy;
1134. }
1135. 
1136. /*
1137.  * under_water()
1138.  *
1139.  * Similar to swallowed() in operation.  Shows hero when underwater
1140.  * except when in water level.  Special routines exist for that.
1141.  */
1142. void
1143. under_water(mode)
1144. int mode;
1145. {
1146.     static xchar lastx, lasty;
1147.     static boolean dela;
1148.     register int x, y;
1149. 
1150.     /* swallowing has a higher precedence than under water */
1151.     if (Is_waterlevel(&u.uz) || u.uswallow)
1152.         return;
1153. 
1154.     /* full update */
1155.     if (mode == 1 || dela) {
1156.         cls();
1157.         dela = FALSE;
1158. 
1159.     /* delayed full update */
1160.     } else if (mode == 2) {
1161.         dela = TRUE;
1162.         return;
1163. 
1164.     /* limited update */
1165.     } else {
1166.         for (y = lasty - 1; y <= lasty + 1; y++)
1167.             for (x = lastx - 1; x <= lastx + 1; x++)
1168.                 if (isok(x, y))
1169.                     show_glyph(x, y, cmap_to_glyph(S_stone));
1170.     }
1171. 
1172.     /*
1173.      * TODO?  Should this honor Xray radius rather than force radius 1?
1174.      */
1175. 
1176.     for (x = u.ux - 1; x <= u.ux + 1; x++)
1177.         for (y = u.uy - 1; y <= u.uy + 1; y++)
1178.             if (isok(x, y) && (is_pool_or_lava(x, y) || is_ice(x, y))) {
1179.                 if (Blind && !(x == u.ux && y == u.uy))
1180.                     show_glyph(x, y, cmap_to_glyph(S_stone));
1181.                 else
1182.                     newsym(x, y);
1183.             }
1184.     lastx = u.ux;
1185.     lasty = u.uy;
1186. }
1187. 
1188. /*
1189.  *      under_ground()
1190.  *
1191.  *      Very restricted display.  You can only see yourself.
1192.  */
1193. void
1194. under_ground(mode)
1195. int mode;
1196. {
1197.     static boolean dela;
1198. 
1199.     /* swallowing has a higher precedence than under ground */
1200.     if (u.uswallow)
1201.         return;
1202. 
1203.     /* full update */
1204.     if (mode == 1 || dela) {
1205.         cls();
1206.         dela = FALSE;
1207. 
1208.     /* delayed full update */
1209.     } else if (mode == 2) {
1210.         dela = TRUE;
1211.         return;
1212. 
1213.     /* limited update */
1214.     } else {
1215.         newsym(u.ux, u.uy);
1216.     }
1217. }
1218. 
1219. /* ======================================================================== */
1220. 
1221. /*
1222.  * Loop through all of the monsters and update them.  Called when:
1223.  *      + going blind & telepathic
1224.  *      + regaining sight & telepathic
1225.  *      + getting and losing infravision
1226.  *      + hallucinating
1227.  *      + doing a full screen redraw
1228.  *      + see invisible times out or a ring of see invisible is taken off
1229.  *      + when a potion of see invisible is quaffed or a ring of see
1230.  *        invisible is put on
1231.  *      + gaining telepathy when blind [givit() in eat.c, pleased() in pray.c]
1232.  *      + losing telepathy while blind [xkilled() in mon.c, attrcurse() in
1233.  *        sit.c]
1234.  */
1235. void
1236. see_monsters()
1237. {
1238.     register struct monst *mon;
1239.     int new_warn_obj_cnt = 0;
1240. 
1241.     if (defer_see_monsters)
1242.         return;
1243. 
1244.     for (mon = fmon; mon; mon = mon->nmon) {
1245.         if (DEADMONSTER(mon))
1246.             continue;
1247.         newsym(mon->mx, mon->my);
1248.         if (mon->wormno)
1249.             see_wsegs(mon);
1250.         if (Warn_of_mon && (context.warntype.obj & mon->data->mflags2) != 0L)
1251.             new_warn_obj_cnt++;
1252.     }
1253.     /*
1254.      * Make Sting glow blue or stop glowing if required.
1255.      */
1256.     if (new_warn_obj_cnt != warn_obj_cnt) {
1257.         Sting_effects(new_warn_obj_cnt);
1258.         warn_obj_cnt = new_warn_obj_cnt;
1259.     }
1260. 
1261.     /* when mounted, hero's location gets caught by monster loop */
1262.     if (!u.usteed)
1263.         newsym(u.ux, u.uy);
1264. }
1265. 
1266. /*
1267.  * Block/unblock light depending on what a mimic is mimicing and if it's
1268.  * invisible or not.  Should be called only when the state of See_invisible
1269.  * changes.
1270.  */
1271. void
1272. set_mimic_blocking()
1273. {
1274.     register struct monst *mon;
1275. 
1276.     for (mon = fmon; mon; mon = mon->nmon) {
1277.         if (DEADMONSTER(mon))
1278.             continue;
1279.         if (mon->minvis && is_lightblocker_mappear(mon)) {
1280.             if (See_invisible)
1281.                 block_point(mon->mx, mon->my);
1282.             else
1283.                 unblock_point(mon->mx, mon->my);
1284.         }
1285.     }
1286. }
1287. 
1288. /*
1289.  * Loop through all of the object *locations* and update them.  Called when
1290.  *      + hallucinating.
1291.  */
1292. void
1293. see_objects()
1294. {
1295.     register struct obj *obj;
1296.     for (obj = fobj; obj; obj = obj->nobj)
1297.         if (vobj_at(obj->ox, obj->oy) == obj)
1298.             newsym(obj->ox, obj->oy);
1299. }
1300. 
1301. /*
1302.  * Update hallucinated traps.
1303.  */
1304. void
1305. see_traps()
1306. {
1307.     struct trap *trap;
1308.     int glyph;
1309. 
1310.     for (trap = ftrap; trap; trap = trap->ntrap) {
1311.         glyph = glyph_at(trap->tx, trap->ty);
1312.         if (glyph_is_trap(glyph))
1313.             newsym(trap->tx, trap->ty);
1314.     }
1315. }
1316. 
1317. /*
1318.  * Put the cursor on the hero.  Flush all accumulated glyphs before doing it.
1319.  */
1320. void
1321. curs_on_u()
1322. {
1323.     flush_screen(1); /* Flush waiting glyphs & put cursor on hero */
1324. }
1325. 
1326. int
1327. doredraw()
1328. {
1329.     docrt();
1330.     return 0;
1331. }
1332. 
1333. void
1334. docrt()
1335. {
1336.     register int x, y;
1337.     register struct rm *lev;
1338. 
1339.     if (!u.ux)
1340.         return; /* display isn't ready yet */
1341. 
1342.     if (u.uswallow) {
1343.         swallowed(1);
1344.         return;
1345.     }
1346.     if (Underwater && !Is_waterlevel(&u.uz)) {
1347.         under_water(1);
1348.         return;
1349.     }
1350.     if (u.uburied) {
1351.         under_ground(1);
1352.         return;
1353.     }
1354. 
1355.     /* shut down vision */
1356.     vision_recalc(2);
1357. 
1358.     /*
1359.      * This routine assumes that cls() does the following:
1360.      *      + fills the physical screen with the symbol for rock
1361.      *      + clears the glyph buffer
1362.      */
1363.     cls();
1364. 
1365.     /* display memory */
1366.     for (x = 1; x < COLNO; x++) {
1367.         lev = &levl[x][0];
1368.         for (y = 0; y < ROWNO; y++, lev++)
1369.             if (lev->glyph != cmap_to_glyph(S_stone))
1370.                 show_glyph(x, y, lev->glyph);
1371.     }
1372. 
1373.     /* see what is to be seen */
1374.     vision_recalc(0);
1375. 
1376.     /* overlay with monsters */
1377.     see_monsters();
1378. 
1379.     /* perm_invent */
1380.     update_inventory();
1381. 
1382.     context.botlx = 1; /* force a redraw of the bottom line */
1383. }
1384. 
1385. /* for panning beyond a clipped region; resend the current map data to
1386.    the interface rather than use docrt()'s regeneration of that data */
1387. void
1388. redraw_map()
1389. {
1390.     int x, y, glyph;
1391. 
1392.     /*
1393.      * Not sure whether this is actually necessary; save and restore did
1394.      * used to get much too involved with each dungeon level as it was
1395.      * read and written.
1396.      *
1397.      * !u.ux: display isn't ready yet; (restoring || !on_level()): was part
1398.      * of cliparound() but interface shouldn't access this much internals
1399.      */
1400.     if (!u.ux || restoring || !on_level(&u.uz0, &u.uz))
1401.         return;
1402. 
1403.     /*
1404.      * This yields sensible clipping when #terrain+getpos is in
1405.      * progress and the screen displays something other than what
1406.      * the map would currently be showing.
1407.      */
1408.     for (y = 0; y < ROWNO; ++y)
1409.         for (x = 1; x < COLNO; ++x) {
1410.             glyph = glyph_at(x, y); /* not levl[x][y].glyph */
1411.             print_glyph(WIN_MAP, x, y, glyph, get_bk_glyph(x, y));
1412.         }
1413.     flush_screen(1);
1414. }
1415. 
1416. /* ======================================================================== */
1417. /* Glyph Buffering (3rd screen) =========================================== */
1418. 
1419. typedef struct {
1420.     xchar new; /* perhaps move this bit into the rm structure. */
1421.     int glyph;
1422. } gbuf_entry;
1423. 
1424. static gbuf_entry gbuf[ROWNO][COLNO];
1425. static char gbuf_start[ROWNO];
1426. static char gbuf_stop[ROWNO];
1427. 
1428. /* FIXME: This is a dirty hack, because newsym() doesn't distinguish
1429.  * between object piles and single objects, it doesn't mark the location
1430.  * for update. */
1431. void
1432. newsym_force(x, y)
1433. register int x, y;
1434. {
1435.     newsym(x,y);
1436.     gbuf[y][x].new = 1;
1437.     if (gbuf_start[y] > x)
1438.         gbuf_start[y] = x;
1439.     if (gbuf_stop[y] < x)
1440.         gbuf_stop[y] = x;
1441. }
1442. 
1443. /*
1444.  * Store the glyph in the 3rd screen for later flushing.
1445.  */
1446. void
1447. show_glyph(x, y, glyph)
1448. int x, y, glyph;
1449. {
1450.     /*
1451.      * Check for bad positions and glyphs.
1452.      */
1453.     if (!isok(x, y)) {
1454.         const char *text;
1455.         int offset;
1456. 
1457.         /* column 0 is invalid, but it's often used as a flag, so ignore it */
1458.         if (x == 0)
1459.             return;
1460. 
1461.         /*
1462.          *  This assumes an ordering of the offsets.  See display.h for
1463.          *  the definition.
1464.          */
1465. 
1466.         if (glyph >= GLYPH_WARNING_OFF
1467.             && glyph < GLYPH_STATUE_OFF) { /* a warning */
1468.             text = "warning";
1469.             offset = glyph - GLYPH_WARNING_OFF;
1470.         } else if (glyph >= GLYPH_SWALLOW_OFF) { /* swallow border */
1471.             text = "swallow border";
1472.             offset = glyph - GLYPH_SWALLOW_OFF;
1473.         } else if (glyph >= GLYPH_ZAP_OFF) { /* zap beam */
1474.             text = "zap beam";
1475.             offset = glyph - GLYPH_ZAP_OFF;
1476.         } else if (glyph >= GLYPH_EXPLODE_OFF) { /* explosion */
1477.             text = "explosion";
1478.             offset = glyph - GLYPH_EXPLODE_OFF;
1479.         } else if (glyph >= GLYPH_CMAP_OFF) { /* cmap */
1480.             text = "cmap_index";
1481.             offset = glyph - GLYPH_CMAP_OFF;
1482.         } else if (glyph >= GLYPH_OBJ_OFF) { /* object */
1483.             text = "object";
1484.             offset = glyph - GLYPH_OBJ_OFF;
1485.         } else if (glyph >= GLYPH_RIDDEN_OFF) { /* ridden mon */
1486.             text = "ridden mon";
1487.             offset = glyph - GLYPH_RIDDEN_OFF;
1488.         } else if (glyph >= GLYPH_BODY_OFF) { /* a corpse */
1489.             text = "corpse";
1490.             offset = glyph - GLYPH_BODY_OFF;
1491.         } else if (glyph >= GLYPH_DETECT_OFF) { /* detected mon */
1492.             text = "detected mon";
1493.             offset = glyph - GLYPH_DETECT_OFF;
1494.         } else if (glyph >= GLYPH_INVIS_OFF) { /* invisible mon */
1495.             text = "invisible mon";
1496.             offset = glyph - GLYPH_INVIS_OFF;
1497.         } else if (glyph >= GLYPH_PET_OFF) { /* a pet */
1498.             text = "pet";
1499.             offset = glyph - GLYPH_PET_OFF;
1500.         } else { /* a monster */
1501.             text = "monster";
1502.             offset = glyph;
1503.         }
1504. 
1505.         impossible("show_glyph:  bad pos %d %d with glyph %d [%s %d].", x, y,
1506.                    glyph, text, offset);
1507.         return;
1508.     }
1509. 
1510.     if (glyph >= MAX_GLYPH) {
1511.         impossible("show_glyph:  bad glyph %d [max %d] at (%d,%d).", glyph,
1512.                    MAX_GLYPH, x, y);
1513.         return;
1514.     }
1515. 
1516.     if (gbuf[y][x].glyph != glyph || iflags.use_background_glyph) {
1517.         gbuf[y][x].glyph = glyph;
1518.         gbuf[y][x].new = 1;
1519.         if (gbuf_start[y] > x)
1520.             gbuf_start[y] = x;
1521.         if (gbuf_stop[y] < x)
1522.             gbuf_stop[y] = x;
1523.     }
1524. }
1525. 
1526. /*
1527.  * Reset the changed glyph borders so that none of the 3rd screen has
1528.  * changed.
1529.  */
1530. #define reset_glyph_bbox()             \
1531.     {                                  \
1532.         int i;                         \
1533.                                        \
1534.         for (i = 0; i < ROWNO; i++) {  \
1535.             gbuf_start[i] = COLNO - 1; \
1536.             gbuf_stop[i] = 0;          \
1537.         }                              \
1538.     }
1539. 
1540. static gbuf_entry nul_gbuf = { 0, cmap_to_glyph(S_stone) };
1541. /*
1542.  * Turn the 3rd screen into stone.
1543.  */
1544. void
1545. clear_glyph_buffer()
1546. {
1547.     register int x, y;
1548.     register gbuf_entry *gptr;
1549. 
1550.     for (y = 0; y < ROWNO; y++) {
1551.         gptr = &gbuf[y][0];
1552.         for (x = COLNO; x; x--) {
1553.             *gptr++ = nul_gbuf;
1554.         }
1555.     }
1556.     reset_glyph_bbox();
1557. }
1558. 
1559. /*
1560.  * Assumes that the indicated positions are filled with S_stone glyphs.
1561.  */
1562. void
1563. row_refresh(start, stop, y)
1564. int start, stop, y;
1565. {
1566.     register int x;
1567. 
1568.     for (x = start; x <= stop; x++)
1569.         if (gbuf[y][x].glyph != cmap_to_glyph(S_stone))
1570.             print_glyph(WIN_MAP, x, y, gbuf[y][x].glyph, get_bk_glyph(x, y));
1571. }
1572. 
1573. void
1574. cls()
1575. {
1576.     static boolean in_cls = 0;
1577. 
1578.     if (in_cls)
1579.         return;
1580.     in_cls = TRUE;
1581.     display_nhwindow(WIN_MESSAGE, FALSE); /* flush messages */
1582.     context.botlx = 1;                    /* force update of botl window */
1583.     clear_nhwindow(WIN_MAP);              /* clear physical screen */
1584. 
1585.     clear_glyph_buffer(); /* this is sort of an extra effort, but OK */
1586.     in_cls = FALSE;
1587. }
1588. 
1589. /*
1590.  * Synch the third screen with the display.
1591.  */
1592. void
1593. flush_screen(cursor_on_u)
1594. int cursor_on_u;
1595. {
1596.     /* Prevent infinite loops on errors:
1597.      *      flush_screen->print_glyph->impossible->pline->flush_screen
1598.      */
1599.     static int flushing = 0;
1600.     static int delay_flushing = 0;
1601.     register int x, y;
1602. 
1603.     if (cursor_on_u == -1)
1604.         delay_flushing = !delay_flushing;
1605.     if (delay_flushing)
1606.         return;
1607.     if (flushing)
1608.         return; /* if already flushing then return */
1609.     flushing = 1;
1610. #ifdef HANGUPHANDLING
1611.     if (program_state.done_hup)
1612.         return;
1613. #endif
1614. 
1615.     for (y = 0; y < ROWNO; y++) {
1616.         register gbuf_entry *gptr = &gbuf[y][x = gbuf_start[y]];
1617. 
1618.         for (; x <= gbuf_stop[y]; gptr++, x++)
1619.             if (gptr->new) {
1620.                 print_glyph(WIN_MAP, x, y, gptr->glyph, get_bk_glyph(x, y));
1621.                 gptr->new = 0;
1622.             }
1623.     }
1624. 
1625.     if (cursor_on_u)
1626.         curs(WIN_MAP, u.ux, u.uy); /* move cursor to the hero */
1627.     display_nhwindow(WIN_MAP, FALSE);
1628.     reset_glyph_bbox();
1629.     flushing = 0;
1630.     if (context.botl || context.botlx)
1631.         bot();
1632.     else if (iflags.time_botl)
1633.         timebot();
1634. }
1635. 
1636. /* ======================================================================== */
1637. 
1638. /*
1639.  * back_to_glyph()
1640.  *
1641.  * Use the information in the rm structure at the given position to create
1642.  * a glyph of a background.
1643.  *
1644.  * I had to add a field in the rm structure (horizontal) so that we knew
1645.  * if open doors and secret doors were horizontal or vertical.  Previously,
1646.  * the screen symbol had the horizontal/vertical information set at
1647.  * level generation time.
1648.  *
1649.  * I used the 'ladder' field (really doormask) for deciding if stairwells
1650.  * were up or down.  I didn't want to check the upstairs and dnstairs
1651.  * variables.
1652.  */
1653. int
1654. back_to_glyph(x, y)
1655. xchar x, y;
1656. {
1657.     int idx;
1658.     struct rm *ptr = &(levl[x][y]);
1659. 
1660.     switch (ptr->typ) {
1661.     case SCORR:
1662.     case STONE:
1663.         idx = level.flags.arboreal ? S_tree : S_stone;
1664.         break;
1665.     case ROOM:
1666.         idx = S_room;
1667.         break;
1668.     case CORR:
1669.         idx = (ptr->waslit || flags.lit_corridor) ? S_litcorr : S_corr;
1670.         break;
1671.     case HWALL:
1672.     case VWALL:
1673.     case TLCORNER:
1674.     case TRCORNER:
1675.     case BLCORNER:
1676.     case BRCORNER:
1677.     case CROSSWALL:
1678.     case TUWALL:
1679.     case TDWALL:
1680.     case TLWALL:
1681.     case TRWALL:
1682.     case SDOOR:
1683.         idx = ptr->seenv ? wall_angle(ptr) : S_stone;
1684.         break;
1685.     case DOOR:
1686.         if (ptr->doormask) {
1687.             if (ptr->doormask & D_BROKEN)
1688.                 idx = S_ndoor;
1689.             else if (ptr->doormask & D_ISOPEN)
1690.                 idx = (ptr->horizontal) ? S_hodoor : S_vodoor;
1691.             else /* else is closed */
1692.                 idx = (ptr->horizontal) ? S_hcdoor : S_vcdoor;
1693.         } else
1694.             idx = S_ndoor;
1695.         break;
1696.     case IRONBARS:
1697.         idx = S_bars;
1698.         break;
1699.     case TREE:
1700.         idx = S_tree;
1701.         break;
1702.     case POOL:
1703.     case MOAT:
1704.         idx = S_pool;
1705.         break;
1706.     case STAIRS:
1707.         idx = (ptr->ladder & LA_DOWN) ? S_dnstair : S_upstair;
1708.         break;
1709.     case LADDER:
1710.         idx = (ptr->ladder & LA_DOWN) ? S_dnladder : S_upladder;
1711.         break;
1712.     case FOUNTAIN:
1713.         idx = S_fountain;
1714.         break;
1715.     case SINK:
1716.         idx = S_sink;
1717.         break;
1718.     case ALTAR:
1719.         idx = S_altar;
1720.         break;
1721.     case GRAVE:
1722.         idx = S_grave;
1723.         break;
1724.     case THRONE:
1725.         idx = S_throne;
1726.         break;
1727.     case LAVAPOOL:
1728.         idx = S_lava;
1729.         break;
1730.     case ICE:
1731.         idx = S_ice;
1732.         break;
1733.     case AIR:
1734.         idx = S_air;
1735.         break;
1736.     case CLOUD:
1737.         idx = S_cloud;
1738.         break;
1739.     case WATER:
1740.         idx = S_water;
1741.         break;
1742.     case DBWALL:
1743.         idx = (ptr->horizontal) ? S_hcdbridge : S_vcdbridge;
1744.         break;
1745.     case DRAWBRIDGE_UP:
1746.         switch (ptr->drawbridgemask & DB_UNDER) {
1747.         case DB_MOAT:
1748.             idx = S_pool;
1749.             break;
1750.         case DB_LAVA:
1751.             idx = S_lava;
1752.             break;
1753.         case DB_ICE:
1754.             idx = S_ice;
1755.             break;
1756.         case DB_FLOOR:
1757.             idx = S_room;
1758.             break;
1759.         default:
1760.             impossible("Strange db-under: %d",
1761.                        ptr->drawbridgemask & DB_UNDER);
1762.             idx = S_room; /* something is better than nothing */
1763.             break;
1764.         }
1765.         break;
1766.     case DRAWBRIDGE_DOWN:
1767.         idx = (ptr->horizontal) ? S_hodbridge : S_vodbridge;
1768.         break;
1769.     default:
1770.         impossible("back_to_glyph:  unknown level type [ = %d ]", ptr->typ);
1771.         idx = S_room;
1772.         break;
1773.     }
1774. 
1775.     return cmap_to_glyph(idx);
1776. }
1777. 
1778. /*
1779.  * swallow_to_glyph()
1780.  *
1781.  * Convert a monster number and a swallow location into the correct glyph.
1782.  * If you don't want a patchwork monster while hallucinating, decide on
1783.  * a random monster in swallowed() and don't use what_mon() here.
1784.  */
1785. STATIC_OVL int
1786. swallow_to_glyph(mnum, loc)
1787. int mnum;
1788. int loc;
1789. {
1790.     if (loc < S_sw_tl || S_sw_br < loc) {
1791.         impossible("swallow_to_glyph: bad swallow location");
1792.         loc = S_sw_br;
1793.     }
1794.     return ((int) (what_mon(mnum, rn2_on_display_rng) << 3) |
1795.             (loc - S_sw_tl)) + GLYPH_SWALLOW_OFF;
1796. }
1797. 
1798. /*
1799.  * zapdir_to_glyph()
1800.  *
1801.  * Change the given zap direction and beam type into a glyph.  Each beam
1802.  * type has four glyphs, one for each of the symbols below.  The order of
1803.  * the zap symbols [0-3] as defined in rm.h are:
1804.  *
1805.  *      |  S_vbeam      ( 0, 1) or ( 0,-1)
1806.  *      -  S_hbeam      ( 1, 0) or (-1, 0)
1807.  *      \  S_lslant     ( 1, 1) or (-1,-1)
1808.  *      /  S_rslant     (-1, 1) or ( 1,-1)
1809.  */
1810. int
1811. zapdir_to_glyph(dx, dy, beam_type)
1812. register int dx, dy;
1813. int beam_type;
1814. {
1815.     if (beam_type >= NUM_ZAP) {
1816.         impossible("zapdir_to_glyph:  illegal beam type");
1817.         beam_type = 0;
1818.     }
1819.     dx = (dx == dy) ? 2 : (dx && dy) ? 3 : dx ? 1 : 0;
1820. 
1821.     return ((int) ((beam_type << 2) | dx)) + GLYPH_ZAP_OFF;
1822. }
1823. 
1824. /*
1825.  * Utility routine for dowhatis() used to find out the glyph displayed at
1826.  * the location.  This isn't necessarily the same as the glyph in the levl
1827.  * structure, so we must check the "third screen".
1828.  */
1829. int
1830. glyph_at(x, y)
1831. xchar x, y;
1832. {
1833.     if (x < 0 || y < 0 || x >= COLNO || y >= ROWNO)
1834.         return cmap_to_glyph(S_room); /* XXX */
1835.     return gbuf[y][x].glyph;
1836. }
1837. 
1838. /*
1839.  * This will be used to get the glyph for the background so that
1840.  * it can potentially be merged into graphical window ports to
1841.  * improve the appearance of stuff on dark room squares and the
1842.  * plane of air etc.
1843.  *
1844.  * Until that is working correctly in the branch, however, for now
1845.  * we just return NO_GLYPH as an indicator to ignore it.
1846.  *
1847.  * [This should be using background as recorded for #overview rather
1848.  * than current data from the map.]
1849.  */
1850. 
1851. STATIC_OVL int
1852. get_bk_glyph(x, y)
1853. xchar x, y;
1854. {
1855.     int idx, bkglyph = NO_GLYPH;
1856.     struct rm *lev = &levl[x][y];
1857. 
1858.     if (iflags.use_background_glyph && lev->seenv != 0
1859.         && gbuf[y][x].glyph != cmap_to_glyph(S_stone)) {
1860.         switch (lev->typ) {
1861.         case SCORR:
1862.         case STONE:
1863.             idx = level.flags.arboreal ? S_tree : S_stone;
1864.             break;
1865.         case ROOM:
1866.            idx = S_room;
1867.            break;
1868.         case CORR:
1869.            idx = (lev->waslit || flags.lit_corridor) ? S_litcorr : S_corr;
1870.            break;
1871.         case ICE:
1872.            idx = S_ice;
1873.            break;
1874.         case AIR:
1875.            idx = S_air;
1876.            break;
1877.         case CLOUD:
1878.            idx = S_cloud;
1879.            break;
1880.         case POOL:
1881.         case MOAT:
1882.            idx = S_pool;
1883.            break;
1884.         case WATER:
1885.            idx = S_water;
1886.            break;
1887.         case LAVAPOOL:
1888.            idx = S_lava;
1889.            break;
1890.         default:
1891.            idx = S_room;
1892.            break;
1893.         }
1894. 
1895.         if (!cansee(x, y) && (!lev->waslit || flags.dark_room)) {
1896.             /* Floor spaces are dark if unlit.  Corridors are dark if unlit. */
1897.             if (lev->typ == CORR && idx == S_litcorr)
1898.                 idx = S_corr;
1899.             else if (idx == S_room)
1900.                 idx = (flags.dark_room && iflags.use_color)
1901.                          ? DARKROOMSYM : S_stone;
1902.         }
1903. 
1904.         if (idx != S_room)
1905.             bkglyph = cmap_to_glyph(idx);
1906.     }
1907.     return bkglyph;
1908. }
1909. 
1910. /* ------------------------------------------------------------------------ */
1911. /* Wall Angle ------------------------------------------------------------- */
1912. 
1913. #ifdef WA_VERBOSE
1914. 
1915. static const char *FDECL(type_to_name, (int));
1916. static void FDECL(error4, (int, int, int, int, int, int));
1917. 
1918. static int bad_count[MAX_TYPE]; /* count of positions flagged as bad */
1919. static const char *type_names[MAX_TYPE] = {
1920.     "STONE", "VWALL", "HWALL", "TLCORNER", "TRCORNER", "BLCORNER", "BRCORNER",
1921.     "CROSSWALL", "TUWALL", "TDWALL", "TLWALL", "TRWALL", "DBWALL", "TREE",
1922.     "SDOOR", "SCORR", "POOL", "MOAT", "WATER", "DRAWBRIDGE_UP", "LAVAPOOL",
1923.     "IRON_BARS", "DOOR", "CORR", "ROOM", "STAIRS", "LADDER", "FOUNTAIN",
1924.     "THRONE", "SINK", "GRAVE", "ALTAR", "ICE", "DRAWBRIDGE_DOWN", "AIR",
1925.     "CLOUD"
1926. };
1927. 
1928. static const char *
1929. type_to_name(type)
1930. int type;
1931. {
1932.     return (type < 0 || type >= MAX_TYPE) ? "unknown" : type_names[type];
1933. }
1934. 
1935. static void
1936. error4(x, y, a, b, c, dd)
1937. int x, y, a, b, c, dd;
1938. {
1939.     pline("set_wall_state: %s @ (%d,%d) %s%s%s%s",
1940.           type_to_name(levl[x][y].typ), x, y,
1941.           a ? "1" : "", b ? "2" : "", c ? "3" : "", dd ? "4" : "");
1942.     bad_count[levl[x][y].typ]++;
1943. }
1944. #endif /* WA_VERBOSE */
1945. 
1946. /*
1947.  * Return 'which' if position is implies an unfinished exterior.  Return
1948.  * zero otherwise.  Unfinished implies outer area is rock or a corridor.
1949.  *
1950.  * Things that are ambiguous: lava
1951.  */
1952. STATIC_OVL int
1953. check_pos(x, y, which)
1954. int x, y, which;
1955. {
1956.     int type;
1957. 
1958.     if (!isok(x, y))
1959.         return which;
1960.     type = levl[x][y].typ;
1961.     if (IS_ROCK(type) || type == CORR || type == SCORR)
1962.         return which;
1963.     return 0;
1964. }
1965. 
1966. /* Return TRUE if more than one is non-zero. */
1967. /*ARGSUSED*/
1968. #ifdef WA_VERBOSE
1969. STATIC_OVL boolean
1970. more_than_one(x, y, a, b, c)
1971. int x, y, a, b, c;
1972. {
1973.     if ((a && (b | c)) || (b && (a | c)) || (c && (a | b))) {
1974.         error4(x, y, a, b, c, 0);
1975.         return TRUE;
1976.     }
1977.     return FALSE;
1978. }
1979. #else
1980. #define more_than_one(x, y, a, b, c) \
1981.     (((a) && ((b) | (c))) || ((b) && ((a) | (c))) || ((c) && ((a) | (b))))
1982. #endif
1983. 
1984. /* Return the wall mode for a T wall. */
1985. STATIC_OVL int
1986. set_twall(x0, y0, x1, y1, x2, y2, x3, y3)
1987. int x0, y0; /* used #if WA_VERBOSE */
1988. int x1, y1, x2, y2, x3, y3;
1989. {
1990.     int wmode, is_1, is_2, is_3;
1991. 
1992. #ifndef WA_VERBOSE
1993.     /* non-verbose more_than_one() doesn't use these */
1994.     nhUse(x0);
1995.     nhUse(y0);
1996. #endif
1997. 
1998.     is_1 = check_pos(x1, y1, WM_T_LONG);
1999.     is_2 = check_pos(x2, y2, WM_T_BL);
2000.     is_3 = check_pos(x3, y3, WM_T_BR);
2001.     if (more_than_one(x0, y0, is_1, is_2, is_3)) {
2002.         wmode = 0;
2003.     } else {
2004.         wmode = is_1 + is_2 + is_3;
2005.     }
2006.     return wmode;
2007. }
2008. 
2009. /* Return wall mode for a horizontal or vertical wall. */
2010. STATIC_OVL int
2011. set_wall(x, y, horiz)
2012. int x, y, horiz;
2013. {
2014.     int wmode, is_1, is_2;
2015. 
2016.     if (horiz) {
2017.         is_1 = check_pos(x, y - 1, WM_W_TOP);
2018.         is_2 = check_pos(x, y + 1, WM_W_BOTTOM);
2019.     } else {
2020.         is_1 = check_pos(x - 1, y, WM_W_LEFT);
2021.         is_2 = check_pos(x + 1, y, WM_W_RIGHT);
2022.     }
2023.     if (more_than_one(x, y, is_1, is_2, 0)) {
2024.         wmode = 0;
2025.     } else {
2026.         wmode = is_1 + is_2;
2027.     }
2028.     return wmode;
2029. }
2030. 
2031. /* Return a wall mode for a corner wall. (x4,y4) is the "inner" position. */
2032. STATIC_OVL int
2033. set_corn(x1, y1, x2, y2, x3, y3, x4, y4)
2034. int x1, y1, x2, y2, x3, y3, x4, y4;
2035. {
2036.     int wmode, is_1, is_2, is_3, is_4;
2037. 
2038.     is_1 = check_pos(x1, y1, 1);
2039.     is_2 = check_pos(x2, y2, 1);
2040.     is_3 = check_pos(x3, y3, 1);
2041.     is_4 = check_pos(x4, y4, 1); /* inner location */
2042. 
2043.     /*
2044.      * All 4 should not be true.  So if the inner location is rock,
2045.      * use it.  If all of the outer 3 are true, use outer.  We currently
2046.      * can't cover the case where only part of the outer is rock, so
2047.      * we just say that all the walls are finished (if not overridden
2048.      * by the inner section).
2049.      */
2050.     if (is_4) {
2051.         wmode = WM_C_INNER;
2052.     } else if (is_1 && is_2 && is_3)
2053.         wmode = WM_C_OUTER;
2054.     else
2055.         wmode = 0; /* finished walls on all sides */
2056. 
2057.     return wmode;
2058. }
2059. 
2060. /* Return mode for a crosswall. */
2061. STATIC_OVL int
2062. set_crosswall(x, y)
2063. int x, y;
2064. {
2065.     int wmode, is_1, is_2, is_3, is_4;
2066. 
2067.     is_1 = check_pos(x - 1, y - 1, 1);
2068.     is_2 = check_pos(x + 1, y - 1, 1);
2069.     is_3 = check_pos(x + 1, y + 1, 1);
2070.     is_4 = check_pos(x - 1, y + 1, 1);
2071. 
2072.     wmode = is_1 + is_2 + is_3 + is_4;
2073.     if (wmode > 1) {
2074.         if (is_1 && is_3 && (is_2 + is_4 == 0)) {
2075.             wmode = WM_X_TLBR;
2076.         } else if (is_2 && is_4 && (is_1 + is_3 == 0)) {
2077.             wmode = WM_X_BLTR;
2078.         } else {
2079. #ifdef WA_VERBOSE
2080.             error4(x, y, is_1, is_2, is_3, is_4);
2081. #endif
2082.             wmode = 0;
2083.         }
2084.     } else if (is_1)
2085.         wmode = WM_X_TL;
2086.     else if (is_2)
2087.         wmode = WM_X_TR;
2088.     else if (is_3)
2089.         wmode = WM_X_BR;
2090.     else if (is_4)
2091.         wmode = WM_X_BL;
2092. 
2093.     return wmode;
2094. }
2095. 
2096. /* Called from mklev.  Scan the level and set the wall modes. */
2097. void
2098. set_wall_state()
2099. {
2100.     int x, y;
2101.     int wmode;
2102.     struct rm *lev;
2103. 
2104. #ifdef WA_VERBOSE
2105.     for (x = 0; x < MAX_TYPE; x++)
2106.         bad_count[x] = 0;
2107. #endif
2108. 
2109.     for (x = 0; x < COLNO; x++)
2110.         for (lev = &levl[x][0], y = 0; y < ROWNO; y++, lev++) {
2111.             switch (lev->typ) {
2112.             case SDOOR:
2113.                 wmode = set_wall(x, y, (int) lev->horizontal);
2114.                 break;
2115.             case VWALL:
2116.                 wmode = set_wall(x, y, 0);
2117.                 break;
2118.             case HWALL:
2119.                 wmode = set_wall(x, y, 1);
2120.                 break;
2121.             case TDWALL:
2122.                 wmode = set_twall(x, y, x, y - 1, x - 1, y + 1, x + 1, y + 1);
2123.                 break;
2124.             case TUWALL:
2125.                 wmode = set_twall(x, y, x, y + 1, x + 1, y - 1, x - 1, y - 1);
2126.                 break;
2127.             case TLWALL:
2128.                 wmode = set_twall(x, y, x + 1, y, x - 1, y - 1, x - 1, y + 1);
2129.                 break;
2130.             case TRWALL:
2131.                 wmode = set_twall(x, y, x - 1, y, x + 1, y + 1, x + 1, y - 1);
2132.                 break;
2133.             case TLCORNER:
2134.                 wmode =
2135.                     set_corn(x - 1, y - 1, x, y - 1, x - 1, y, x + 1, y + 1);
2136.                 break;
2137.             case TRCORNER:
2138.                 wmode =
2139.                     set_corn(x, y - 1, x + 1, y - 1, x + 1, y, x - 1, y + 1);
2140.                 break;
2141.             case BLCORNER:
2142.                 wmode =
2143.                     set_corn(x, y + 1, x - 1, y + 1, x - 1, y, x + 1, y - 1);
2144.                 break;
2145.             case BRCORNER:
2146.                 wmode =
2147.                     set_corn(x + 1, y, x + 1, y + 1, x, y + 1, x - 1, y - 1);
2148.                 break;
2149.             case CROSSWALL:
2150.                 wmode = set_crosswall(x, y);
2151.                 break;
2152. 
2153.             default:
2154.                 wmode = -1; /* don't set wall info */
2155.                 break;
2156.             }
2157. 
2158.             if (wmode >= 0)
2159.                 lev->wall_info = (lev->wall_info & ~WM_MASK) | wmode;
2160.         }
2161. 
2162. #ifdef WA_VERBOSE
2163.     /* check if any bad positions found */
2164.     for (x = y = 0; x < MAX_TYPE; x++)
2165.         if (bad_count[x]) {
2166.             if (y == 0) {
2167.                 y = 1; /* only print once */
2168.                 pline("set_wall_type: wall mode problems with: ");
2169.             }
2170.             pline("%s %d;", type_names[x], bad_count[x]);
2171.         }
2172. #endif /* WA_VERBOSE */
2173. }
2174. 
2175. /* ------------------------------------------------------------------------ */
2176. /* This matrix is used here and in vision.c. */
2177. unsigned char seenv_matrix[3][3] = { { SV2, SV1, SV0 },
2178.                                      { SV3, SVALL, SV7 },
2179.                                      { SV4, SV5, SV6 } };
2180. 
2181. #define sign(z) ((z) < 0 ? -1 : ((z) > 0 ? 1 : 0))
2182. 
2183. /* Set the seen vector of lev as if seen from (x0,y0) to (x,y). */
2184. STATIC_OVL void
2185. set_seenv(lev, x0, y0, x, y)
2186. struct rm *lev;
2187. int x0, y0, x, y; /* from, to */
2188. {
2189.     int dx = x - x0, dy = y0 - y;
2190. 
2191.     lev->seenv |= seenv_matrix[sign(dy) + 1][sign(dx) + 1];
2192. }
2193. 
2194. /* Called by blackout(vault.c) when vault guard removes temporary corridor,
2195.    turning spot <x0,y0> back into stone; <x1,y1> is an adjacent spot. */
2196. void
2197. unset_seenv(lev, x0, y0, x1, y1)
2198. struct rm *lev;     /* &levl[x1][y1] */
2199. int x0, y0, x1, y1; /* from, to; abs(x1-x0)==1 && abs(y0-y1)==1 */
2200. {
2201.     int dx = x1 - x0, dy = y0 - y1;
2202. 
2203.     lev->seenv &= ~seenv_matrix[dy + 1][dx + 1];
2204. }
2205. 
2206. /* ------------------------------------------------------------------------ */
2207. 
2208. /* T wall types, one for each row in wall_matrix[][]. */
2209. #define T_d 0
2210. #define T_l 1
2211. #define T_u 2
2212. #define T_r 3
2213. 
2214. /*
2215.  * These are the column names of wall_matrix[][].  They are the "results"
2216.  * of a tdwall pattern match.  All T walls are rotated so they become
2217.  * a tdwall.  Then we do a single pattern match, but return the
2218.  * correct result for the original wall by using different rows for
2219.  * each of the wall types.
2220.  */
2221. #define T_stone 0
2222. #define T_tlcorn 1
2223. #define T_trcorn 2
2224. #define T_hwall 3
2225. #define T_tdwall 4
2226. 
2227. static const int wall_matrix[4][5] = {
2228.     { S_stone, S_tlcorn, S_trcorn, S_hwall, S_tdwall }, /* tdwall */
2229.     { S_stone, S_trcorn, S_brcorn, S_vwall, S_tlwall }, /* tlwall */
2230.     { S_stone, S_brcorn, S_blcorn, S_hwall, S_tuwall }, /* tuwall */
2231.     { S_stone, S_blcorn, S_tlcorn, S_vwall, S_trwall }, /* trwall */
2232. };
2233. 
2234. /* Cross wall types, one for each "solid" quarter.  Rows of cross_matrix[][].
2235.  */
2236. #define C_bl 0
2237. #define C_tl 1
2238. #define C_tr 2
2239. #define C_br 3
2240. 
2241. /*
2242.  * These are the column names for cross_matrix[][].  They express results
2243.  * in C_br (bottom right) terms.  All crosswalls with a single solid
2244.  * quarter are rotated so the solid section is at the bottom right.
2245.  * We pattern match on that, but return the correct result depending
2246.  * on which row we'ere looking at.
2247.  */
2248. #define C_trcorn 0
2249. #define C_brcorn 1
2250. #define C_blcorn 2
2251. #define C_tlwall 3
2252. #define C_tuwall 4
2253. #define C_crwall 5
2254. 
2255. static const int cross_matrix[4][6] = {
2256.     { S_brcorn, S_blcorn, S_tlcorn, S_tuwall, S_trwall, S_crwall },
2257.     { S_blcorn, S_tlcorn, S_trcorn, S_trwall, S_tdwall, S_crwall },
2258.     { S_tlcorn, S_trcorn, S_brcorn, S_tdwall, S_tlwall, S_crwall },
2259.     { S_trcorn, S_brcorn, S_blcorn, S_tlwall, S_tuwall, S_crwall },
2260. };
2261. 
2262. /* Print out a T wall warning and all interesting info. */
2263. STATIC_OVL void
2264. t_warn(lev)
2265. struct rm *lev;
2266. {
2267.     static const char warn_str[] = "wall_angle: %s: case %d: seenv = 0x%x";
2268.     const char *wname;
2269. 
2270.     if (lev->typ == TUWALL)
2271.         wname = "tuwall";
2272.     else if (lev->typ == TLWALL)
2273.         wname = "tlwall";
2274.     else if (lev->typ == TRWALL)
2275.         wname = "trwall";
2276.     else if (lev->typ == TDWALL)
2277.         wname = "tdwall";
2278.     else
2279.         wname = "unknown";
2280.     impossible(warn_str, wname, lev->wall_info & WM_MASK,
2281.                (unsigned int) lev->seenv);
2282. }
2283. 
2284. /*
2285.  * Return the correct graphics character index using wall type, wall mode,
2286.  * and the seen vector.  It is expected that seenv is non zero.
2287.  *
2288.  * All T-wall vectors are rotated to be TDWALL.  All single crosswall
2289.  * blocks are rotated to bottom right.  All double crosswall are rotated
2290.  * to W_X_BLTR.  All results are converted back.
2291.  *
2292.  * The only way to understand this is to take out pen and paper and
2293.  * draw diagrams.  See rm.h for more details on the wall modes and
2294.  * seen vector (SV).
2295.  */
2296. STATIC_OVL int
2297. wall_angle(lev)
2298. struct rm *lev;
2299. {
2300.     register unsigned int seenv = lev->seenv & 0xff;
2301.     const int *row;
2302.     int col, idx;
2303. 
2304. #define only(sv, bits) (((sv) & (bits)) && !((sv) & ~(bits)))
2305.     switch (lev->typ) {
2306.     case TUWALL:
2307.         row = wall_matrix[T_u];
2308.         seenv = (seenv >> 4 | seenv << 4) & 0xff; /* rotate to tdwall */
2309.         goto do_twall;
2310.     case TLWALL:
2311.         row = wall_matrix[T_l];
2312.         seenv = (seenv >> 2 | seenv << 6) & 0xff; /* rotate to tdwall */
2313.         goto do_twall;
2314.     case TRWALL:
2315.         row = wall_matrix[T_r];
2316.         seenv = (seenv >> 6 | seenv << 2) & 0xff; /* rotate to tdwall */
2317.         goto do_twall;
2318.     case TDWALL:
2319.         row = wall_matrix[T_d];
2320.  do_twall:
2321.         switch (lev->wall_info & WM_MASK) {
2322.         case 0:
2323.             if (seenv == SV4) {
2324.                 col = T_tlcorn;
2325.             } else if (seenv == SV6) {
2326.                 col = T_trcorn;
2327.             } else if (seenv & (SV3 | SV5 | SV7)
2328.                        || ((seenv & SV4) && (seenv & SV6))) {
2329.                 col = T_tdwall;
2330.             } else if (seenv & (SV0 | SV1 | SV2)) {
2331.                 col = (seenv & (SV4 | SV6) ? T_tdwall : T_hwall);
2332.             } else {
2333.                 t_warn(lev);
2334.                 col = T_stone;
2335.             }
2336.             break;
2337.         case WM_T_LONG:
2338.             if (seenv & (SV3 | SV4) && !(seenv & (SV5 | SV6 | SV7))) {
2339.                 col = T_tlcorn;
2340.             } else if (seenv & (SV6 | SV7) && !(seenv & (SV3 | SV4 | SV5))) {
2341.                 col = T_trcorn;
2342.             } else if ((seenv & SV5)
2343.                        || ((seenv & (SV3 | SV4)) && (seenv & (SV6 | SV7)))) {
2344.                 col = T_tdwall;
2345.             } else {
2346.                 /* only SV0|SV1|SV2 */
2347.                 if (!only(seenv, SV0 | SV1 | SV2))
2348.                     t_warn(lev);
2349.                 col = T_stone;
2350.             }
2351.             break;
2352.         case WM_T_BL:
2353. #if 0  /* older method, fixed */
2354.             if (only(seenv, SV4 | SV5)) {
2355.                 col = T_tlcorn;
2356.             } else if ((seenv & (SV0 | SV1 | SV2))
2357.                        && only(seenv, SV0 | SV1 | SV2 | SV6 | SV7)) {
2358.                 col = T_hwall;
2359.             } else if ((seenv & SV3)
2360.                        || ((seenv & (SV0 | SV1 | SV2))
2361.                            && (seenv & (SV4 | SV5)))) {
2362.                 col = T_tdwall;
2363.             } else {
2364.                 if (seenv != SV6)
2365.                     t_warn(lev);
2366.                 col = T_stone;
2367.             }
2368. #endif /* 0 */
2369.             if (only(seenv, SV4 | SV5))
2370.                 col = T_tlcorn;
2371.             else if ((seenv & (SV0 | SV1 | SV2 | SV7))
2372.                      && !(seenv & (SV3 | SV4 | SV5)))
2373.                 col = T_hwall;
2374.             else if (only(seenv, SV6))
2375.                 col = T_stone;
2376.             else
2377.                 col = T_tdwall;
2378.             break;
2379.         case WM_T_BR:
2380. #if 0  /* older method, fixed */
2381.             if (only(seenv, SV5 | SV6)) {
2382.                 col = T_trcorn;
2383.             } else if ((seenv & (SV0 | SV1 | SV2))
2384.                        && only(seenv, SV0 | SV1 | SV2 | SV3 | SV4)) {
2385.                 col = T_hwall;
2386.             } else if ((seenv & SV7)
2387.                        || ((seenv & (SV0 | SV1 | SV2))
2388.                            && (seenv & (SV5 | SV6)))) {
2389.                 col = T_tdwall;
2390.             } else {
2391.                 if (seenv != SV4)
2392.                     t_warn(lev);
2393.                 col = T_stone;
2394.             }
2395. #endif /* 0 */
2396.             if (only(seenv, SV5 | SV6))
2397.                 col = T_trcorn;
2398.             else if ((seenv & (SV0 | SV1 | SV2 | SV3))
2399.                      && !(seenv & (SV5 | SV6 | SV7)))
2400.                 col = T_hwall;
2401.             else if (only(seenv, SV4))
2402.                 col = T_stone;
2403.             else
2404.                 col = T_tdwall;
2405. 
2406.             break;
2407.         default:
2408.             impossible("wall_angle: unknown T wall mode %d",
2409.                        lev->wall_info & WM_MASK);
2410.             col = T_stone;
2411.             break;
2412.         }
2413.         idx = row[col];
2414.         break;
2415. 
2416.     case SDOOR:
2417.         if (lev->horizontal)
2418.             goto horiz;
2419.         /*FALLTHRU*/
2420.     case VWALL:
2421.         switch (lev->wall_info & WM_MASK) {
2422.         case 0:
2423.             idx = seenv ? S_vwall : S_stone;
2424.             break;
2425.         case 1:
2426.             idx = seenv & (SV1 | SV2 | SV3 | SV4 | SV5) ? S_vwall : S_stone;
2427.             break;
2428.         case 2:
2429.             idx = seenv & (SV0 | SV1 | SV5 | SV6 | SV7) ? S_vwall : S_stone;
2430.             break;
2431.         default:
2432.             impossible("wall_angle: unknown vwall mode %d",
2433.                        lev->wall_info & WM_MASK);
2434.             idx = S_stone;
2435.             break;
2436.         }
2437.         break;
2438. 
2439.     case HWALL:
2440.  horiz:
2441.         switch (lev->wall_info & WM_MASK) {
2442.         case 0:
2443.             idx = seenv ? S_hwall : S_stone;
2444.             break;
2445.         case 1:
2446.             idx = seenv & (SV3 | SV4 | SV5 | SV6 | SV7) ? S_hwall : S_stone;
2447.             break;
2448.         case 2:
2449.             idx = seenv & (SV0 | SV1 | SV2 | SV3 | SV7) ? S_hwall : S_stone;
2450.             break;
2451.         default:
2452.             impossible("wall_angle: unknown hwall mode %d",
2453.                        lev->wall_info & WM_MASK);
2454.             idx = S_stone;
2455.             break;
2456.         }
2457.         break;
2458. 
2459. #define set_corner(idx, lev, which, outer, inner, name)    \
2460.     switch ((lev)->wall_info & WM_MASK) {                  \
2461.     case 0:                                                \
2462.         idx = which;                                       \
2463.         break;                                             \
2464.     case WM_C_OUTER:                                       \
2465.         idx = seenv & (outer) ? which : S_stone;           \
2466.         break;                                             \
2467.     case WM_C_INNER:                                       \
2468.         idx = seenv & ~(inner) ? which : S_stone;          \
2469.         break;                                             \
2470.     default:                                               \
2471.         impossible("wall_angle: unknown %s mode %d", name, \
2472.                    (lev)->wall_info &WM_MASK);             \
2473.         idx = S_stone;                                     \
2474.         break;                                             \
2475.     }
2476. 
2477.     case TLCORNER:
2478.         set_corner(idx, lev, S_tlcorn, (SV3 | SV4 | SV5), SV4, "tlcorn");
2479.         break;
2480.     case TRCORNER:
2481.         set_corner(idx, lev, S_trcorn, (SV5 | SV6 | SV7), SV6, "trcorn");
2482.         break;
2483.     case BLCORNER:
2484.         set_corner(idx, lev, S_blcorn, (SV1 | SV2 | SV3), SV2, "blcorn");
2485.         break;
2486.     case BRCORNER:
2487.         set_corner(idx, lev, S_brcorn, (SV7 | SV0 | SV1), SV0, "brcorn");
2488.         break;
2489. 
2490.     case CROSSWALL:
2491.         switch (lev->wall_info & WM_MASK) {
2492.         case 0:
2493.             if (seenv == SV0)
2494.                 idx = S_brcorn;
2495.             else if (seenv == SV2)
2496.                 idx = S_blcorn;
2497.             else if (seenv == SV4)
2498.                 idx = S_tlcorn;
2499.             else if (seenv == SV6)
2500.                 idx = S_trcorn;
2501.             else if (!(seenv & ~(SV0 | SV1 | SV2))
2502.                      && (seenv & SV1 || seenv == (SV0 | SV2)))
2503.                 idx = S_tuwall;
2504.             else if (!(seenv & ~(SV2 | SV3 | SV4))
2505.                      && (seenv & SV3 || seenv == (SV2 | SV4)))
2506.                 idx = S_trwall;
2507.             else if (!(seenv & ~(SV4 | SV5 | SV6))
2508.                      && (seenv & SV5 || seenv == (SV4 | SV6)))
2509.                 idx = S_tdwall;
2510.             else if (!(seenv & ~(SV0 | SV6 | SV7))
2511.                      && (seenv & SV7 || seenv == (SV0 | SV6)))
2512.                 idx = S_tlwall;
2513.             else
2514.                 idx = S_crwall;
2515.             break;
2516. 
2517.         case WM_X_TL:
2518.             row = cross_matrix[C_tl];
2519.             seenv = (seenv >> 4 | seenv << 4) & 0xff;
2520.             goto do_crwall;
2521.         case WM_X_TR:
2522.             row = cross_matrix[C_tr];
2523.             seenv = (seenv >> 6 | seenv << 2) & 0xff;
2524.             goto do_crwall;
2525.         case WM_X_BL:
2526.             row = cross_matrix[C_bl];
2527.             seenv = (seenv >> 2 | seenv << 6) & 0xff;
2528.             goto do_crwall;
2529.         case WM_X_BR:
2530.             row = cross_matrix[C_br];
2531.  do_crwall:
2532.             if (seenv == SV4) {
2533.                 idx = S_stone;
2534.             } else {
2535.                 seenv = seenv & ~SV4; /* strip SV4 */
2536.                 if (seenv == SV0) {
2537.                     col = C_brcorn;
2538.                 } else if (seenv & (SV2 | SV3)) {
2539.                     if (seenv & (SV5 | SV6 | SV7))
2540.                         col = C_crwall;
2541.                     else if (seenv & (SV0 | SV1))
2542.                         col = C_tuwall;
2543.                     else
2544.                         col = C_blcorn;
2545.                 } else if (seenv & (SV5 | SV6)) {
2546.                     if (seenv & (SV1 | SV2 | SV3))
2547.                         col = C_crwall;
2548.                     else if (seenv & (SV0 | SV7))
2549.                         col = C_tlwall;
2550.                     else
2551.                         col = C_trcorn;
2552.                 } else if (seenv & SV1) {
2553.                     col = seenv & SV7 ? C_crwall : C_tuwall;
2554.                 } else if (seenv & SV7) {
2555.                     col = seenv & SV1 ? C_crwall : C_tlwall;
2556.                 } else {
2557.                     impossible("wall_angle: bottom of crwall check");
2558.                     col = C_crwall;
2559.                 }
2560. 
2561.                 idx = row[col];
2562.             }
2563.             break;
2564. 
2565.         case WM_X_TLBR:
2566.             if (only(seenv, SV1 | SV2 | SV3))
2567.                 idx = S_blcorn;
2568.             else if (only(seenv, SV5 | SV6 | SV7))
2569.                 idx = S_trcorn;
2570.             else if (only(seenv, SV0 | SV4))
2571.                 idx = S_stone;
2572.             else
2573.                 idx = S_crwall;
2574.             break;
2575. 
2576.         case WM_X_BLTR:
2577.             if (only(seenv, SV0 | SV1 | SV7))
2578.                 idx = S_brcorn;
2579.             else if (only(seenv, SV3 | SV4 | SV5))
2580.                 idx = S_tlcorn;
2581.             else if (only(seenv, SV2 | SV6))
2582.                 idx = S_stone;
2583.             else
2584.                 idx = S_crwall;
2585.             break;
2586. 
2587.         default:
2588.             impossible("wall_angle: unknown crosswall mode");
2589.             idx = S_stone;
2590.             break;
2591.         }
2592.         break;
2593. 
2594.     default:
2595.         impossible("wall_angle: unexpected wall type %d", lev->typ);
2596.         idx = S_stone;
2597.     }
2598.     return idx;
2599. }
2600. 
2601. /*display.c*/