gdb - Local mods (compile)
[dragonfly.git] / games / hack / hack.pri.c
1 /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
2 /* hack.pri.c - version 1.0.3 */
3 /* $FreeBSD: src/games/hack/hack.pri.c,v 1.5 1999/11/16 10:26:37 marcel Exp $ */
4 /* $DragonFly: src/games/hack/hack.pri.c,v 1.5 2006/08/21 19:45:32 pavalos Exp $ */
5
6 #include "hack.h"
7 #include <curses.h>
8 xchar scrlx, scrhx, scrly, scrhy;       /* corners of new area on screen */
9
10 extern char *CD;
11
12 #ifdef NEWSCR
13 static void     pobj(struct obj *);
14 #endif
15 static void     cornbot(int);
16
17 void
18 swallowed(void)
19 {
20         char ulook[] = { "|@|" };
21
22         ulook[1] = u.usym;
23
24         cls();
25         curs(u.ux - 1, u.uy + 1);
26         fputs("/-\\", stdout);
27         curx = u.ux + 2;
28         curs(u.ux - 1, u.uy + 2);
29         fputs(ulook, stdout);
30         curx = u.ux + 2;
31         curs(u.ux - 1, u.uy + 3);
32         fputs("\\-/", stdout);
33         curx = u.ux + 2;
34         u.udispl = 1;
35         u.udisx = u.ux;
36         u.udisy = u.uy;
37 }
38
39 /* VARARGS1 */
40 boolean panicking;
41
42 void
43 panic(const char *str, ...)
44 {
45         va_list ap;
46
47         if (panicking++)        /* avoid loops - this should never happen*/
48                 exit(1);
49         home();
50         puts(" Suddenly, the dungeon collapses.");
51         fputs(" ERROR:  ", stdout);
52         va_start(ap, str);
53         vprintf(str, ap);
54         va_end(ap);
55 #ifdef DEBUG
56 #ifdef UNIX
57         if (!fork())
58                 abort();        /* generate core dump */
59 #endif /* UNIX */
60 #endif /* DEBUG */
61         more();                 /* contains a fflush() */
62         done("panicked");
63 }
64
65 void
66 atl(int x, int y, char ch)
67 {
68         struct rm *crm = &levl[x][y];
69
70         if (x < 0 || x > COLNO - 1 || y < 0 || y > ROWNO - 1) {
71                 impossible("atl(%d,%d,%c)", x, y, ch);
72                 return;
73         }
74         if (crm->seen && crm->scrsym == ch)
75                 return;
76         crm->scrsym = ch;
77         crm->new = 1;
78         on_scr(x, y);
79 }
80
81 void
82 on_scr(int x, int y)
83 {
84         if (x < scrlx)
85                 scrlx = x;
86         if (x > scrhx)
87                 scrhx = x;
88         if (y < scrly)
89                 scrly = y;
90         if (y > scrhy)
91                 scrhy = y;
92 }
93
94 /* call: (x,y) - display
95  *      (-1,0) - close (leave last symbol)
96  *      (-1,-1)- close (undo last symbol)
97  *      (-1,let)-open: initialize symbol
98  *      (-2,let)-change let
99  */
100
101 void
102 tmp_at(schar x, schar y)
103 {
104         static schar prevx, prevy;
105         static char let;
106
107         if ((int)x == -2) {             /* change let call */
108                 let = y;
109                 return;
110         }
111         if ((int)x == -1 && (int)y >= 0) {      /* open or close call */
112                 let = y;
113                 prevx = -1;
114                 return;
115         }
116         if (prevx >= 0 && cansee(prevx, prevy)) {
117                 delay_output(50);
118                 prl(prevx, prevy);      /* in case there was a monster */
119                 at(prevx, prevy, levl[prevx][prevy].scrsym);
120         }
121         if (x >= 0) {                   /* normal call */
122                 if (cansee(x, y))
123                         at(x, y, let);
124                 prevx = x;
125                 prevy = y;
126         } else {                        /* close call */
127                 let = 0;
128                 prevx = -1;
129         }
130 }
131
132 /* like the previous, but the symbols are first erased on completion */
133 void
134 Tmp_at(schar x, schar y)
135 {
136         static char let;
137         static xchar cnt;
138         static coord tc[COLNO]; /* but watch reflecting beams! */
139         int xx, yy;
140
141         if ((int)x == -1) {
142                 if (y > 0) {    /* open call */
143                         let = y;
144                         cnt = 0;
145                         return;
146                 }
147                 /* close call (do not distinguish y==0 and y==-1) */
148                 while (cnt--) {
149                         xx = tc[cnt].x;
150                         yy = tc[cnt].y;
151                         prl(xx, yy);
152                         at(xx, yy, levl[xx][yy].scrsym);
153                 }
154                 cnt = let = 0;  /* superfluous */
155                 return;
156         }
157         if ((int)x == -2) {     /* change let call */
158                 let = y;
159                 return;
160         }
161         /* normal call */
162         if (cansee(x, y)) {
163                 if (cnt)
164                         delay_output(50);
165                 at(x, y, let);
166                 tc[cnt].x = x;
167                 tc[cnt].y = y;
168                 if (++cnt >= COLNO)
169                         panic("Tmp_at overflow?");
170                 levl[x][y].new = 0;     /* prevent pline-nscr erasing --- */
171         }
172 }
173
174 void
175 setclipped(void)
176 {
177         error("Hack needs a screen of size at least %d by %d.\n",
178               ROWNO + 2, COLNO);
179 }
180
181 void
182 at(xchar x, xchar y, char ch)
183 {
184 #ifndef lint
185         /* if xchar is unsigned, lint will complain about if (x < 0)  */
186         if (x < 0 || x > COLNO - 1 || y < 0 || y > ROWNO - 1) {
187                 impossible("At gets 0%o at %d %d.", ch, x, y);
188                 return;
189         }
190 #endif /* lint */
191         if (!ch) {
192                 impossible("At gets null at %d %d.", x, y);
193                 return;
194         }
195         y += 2;
196         curs(x, y);
197         putchar(ch);
198         curx++;
199 }
200
201 void
202 prme(void)
203 {
204         if (!Invisible)
205                 at(u.ux, u.uy, u.usym);
206 }
207
208 int
209 doredraw(void)
210 {
211         docrt();
212         return (0);
213 }
214
215 void
216 docrt(void)
217 {
218         int x, y;
219         struct rm *room;
220         struct monst *mtmp;
221
222         if (u.uswallow) {
223                 swallowed();
224                 return;
225         }
226         cls();
227
228 /* Some ridiculous code to get display of @ and monsters (almost) right */
229         if (!Invisible) {
230                 levl[(u.udisx = u.ux)][(u.udisy = u.uy)].scrsym = u.usym;
231                 levl[u.udisx][u.udisy].seen = 1;
232                 u.udispl = 1;
233         } else
234                 u.udispl = 0;
235
236         seemons();              /* reset old positions */
237         for (mtmp = fmon; mtmp; mtmp = mtmp->nmon)
238                 mtmp->mdispl = 0;
239         seemons();              /* force new positions to be shown */
240 /* This nonsense should disappear soon --------------------------------- */
241
242         for (y = 0; y < ROWNO; y++)
243                 for (x = 0; x < COLNO; x++)
244                         if ((room = &levl[x][y])->new) {
245                                 room->new = 0;
246                                 at(x, y, room->scrsym);
247                         } else if (room->seen)
248                                 at(x, y, room->scrsym);
249         scrlx = COLNO;
250         scrly = ROWNO;
251         scrhx = scrhy = 0;
252         flags.botlx = 1;
253         bot();
254 }
255
256 void
257 docorner(int xmin, int ymax)
258 {
259         int x, y;
260         struct rm *room;
261         struct monst *mtmp;
262
263         if (u.uswallow) {       /* Can be done more efficiently */
264                 swallowed();
265                 return;
266         }
267         seemons();              /* reset old positions */
268         for (mtmp = fmon; mtmp; mtmp = mtmp->nmon)
269                 if (mtmp->mx >= xmin && mtmp->my < ymax)
270                         mtmp->mdispl = 0;
271         seemons();              /* force new positions to be shown */
272
273         for (y = 0; y < ymax; y++) {
274                 if (y > ROWNO && CD)
275                         break;
276                 curs(xmin, y + 2);
277                 cl_end();
278                 if (y < ROWNO) {
279                         for (x = xmin; x < COLNO; x++) {
280                                 if ((room = &levl[x][y])->new) {
281                                         room->new = 0;
282                                         at(x, y, room->scrsym);
283                                 } else if (room->seen)
284                                         at(x, y, room->scrsym);
285                         }
286                 }
287         }
288         if (ymax > ROWNO) {
289                 cornbot(xmin - 1);
290                 if (ymax > ROWNO + 1 && CD) {
291                         curs(1, ROWNO + 3);
292                         cl_eos();
293                 }
294         }
295 }
296
297 void
298 curs_on_u(void)
299 {
300         curs(u.ux, u.uy + 2);
301 }
302
303 void
304 pru(void)
305 {
306         if (u.udispl && (Invisible || u.udisx != u.ux || u.udisy != u.uy))
307                 if (!vism_at(u.udisx, u.udisy))
308                         newsym(u.udisx, u.udisy);
309         if (Invisible) {
310                 u.udispl = 0;
311                 prl(u.ux, u.uy);
312         } else if (!u.udispl || u.udisx != u.ux || u.udisy != u.uy) {
313                 atl(u.ux, u.uy, u.usym);
314                 u.udispl = 1;
315                 u.udisx = u.ux;
316                 u.udisy = u.uy;
317         }
318         levl[u.ux][u.uy].seen = 1;
319 }
320
321 #ifndef NOWORM
322 extern struct wseg *m_atseg;
323 #endif /* NOWORM */
324
325 /* print a position that is visible for @ */
326 void
327 prl(int x, int y)
328 {
329         struct rm *room;
330         struct monst *mtmp;
331         struct obj *otmp;
332
333         if (x == u.ux && y == u.uy && (!Invisible)) {
334                 pru();
335                 return;
336         }
337         if (!isok(x, y))
338                 return;
339         room = &levl[x][y];
340         if ((!room->typ) ||
341             (IS_ROCK(room->typ) && levl[u.ux][u.uy].typ == CORR))
342                 return;
343         if ((mtmp = m_at(x, y)) && !mtmp->mhide &&
344             (!mtmp->minvis || See_invisible)) {
345 #ifndef NOWORM
346                 if (m_atseg)
347                         pwseg(m_atseg);
348                 else
349 #endif /* NOWORM */
350                         pmon(mtmp);
351         } else if ((otmp = o_at(x, y)) && room->typ != POOL)
352                 atl(x, y, otmp->olet);
353         else if (mtmp && (!mtmp->minvis || See_invisible)) {
354                 /* must be a hiding monster, but not hiding right now */
355                 /* assume for the moment that long worms do not hide */
356                 pmon(mtmp);
357         } else if (g_at(x, y) && room->typ != POOL)
358                 atl(x, y, '$');
359         else if (!room->seen || room->scrsym == ' ') {
360                 room->new = room->seen = 1;
361                 newsym(x, y);
362                 on_scr(x, y);
363         }
364         room->seen = 1;
365 }
366
367 char
368 news0(xchar x, xchar y)
369 {
370         struct obj *otmp;
371         struct trap *ttmp;
372         struct rm *room;
373         char tmp;
374
375         room = &levl[x][y];
376         if (!room->seen)
377                 tmp = ' ';
378         else if (room->typ == POOL)
379                 tmp = POOL_SYM;
380         else if (!Blind && (otmp = o_at(x, y)))
381                 tmp = otmp->olet;
382         else if (!Blind && g_at(x, y))
383                 tmp = '$';
384         else if (x == xupstair && y == yupstair)
385                 tmp = '<';
386         else if (x == xdnstair && y == ydnstair)
387                 tmp = '>';
388         else if ((ttmp = t_at(x, y)) && ttmp->tseen)
389                 tmp = '^';
390         else
391                 switch (room->typ) {
392                 case SCORR:
393                 case SDOOR:
394                         tmp = room->scrsym;     /* %% wrong after killing mimic ! */
395                         break;
396                 case HWALL:
397                         tmp = '-';
398                         break;
399                 case VWALL:
400                         tmp = '|';
401                         break;
402                 case LDOOR:
403                 case DOOR:
404                         tmp = '+';
405                         break;
406                 case CORR:
407                         tmp = CORR_SYM;
408                         break;
409                 case ROOM:
410                         if (room->lit || cansee(x, y) || Blind)
411                                 tmp = '.';
412                         else
413                                 tmp = ' ';
414                         break;
415                 default:
416                         tmp = ERRCHAR;
417                 }
418         return (tmp);
419 }
420
421 void
422 newsym(int x, int y)
423 {
424         atl(x, y, news0(x, y));
425 }
426
427 /* used with wand of digging (or pick-axe): fill scrsym and force display */
428 /* also when a POOL evaporates */
429 void
430 mnewsym(int x, int y)
431 {
432         struct rm *room;
433         char newscrsym;
434
435         if (!vism_at(x, y)) {
436                 room = &levl[x][y];
437                 newscrsym = news0(x, y);
438                 if (room->scrsym != newscrsym) {
439                         room->scrsym = newscrsym;
440                         room->seen = 0;
441                 }
442         }
443 }
444
445 void
446 nosee(int x, int y)
447 {
448         struct rm *room;
449
450         if (!isok(x, y))
451                 return;
452         room = &levl[x][y];
453         if (room->scrsym == '.' && !room->lit && !Blind) {
454                 room->scrsym = ' ';
455                 room->new = 1;
456                 on_scr(x, y);
457         }
458 }
459
460 #ifndef QUEST
461 void
462 prl1(int x, int y)
463 {
464         if (u.dx) {
465                 if (u.dy) {
466                         prl(x - (2 * u.dx), y);
467                         prl(x - u.dx, y);
468                         prl(x, y);
469                         prl(x, y - u.dy);
470                         prl(x, y - (2 * u.dy));
471                 } else {
472                         prl(x, y - 1);
473                         prl(x, y);
474                         prl(x, y + 1);
475                 }
476         } else {
477                 prl(x - 1, y);
478                 prl(x, y);
479                 prl(x + 1, y);
480         }
481 }
482
483 void
484 nose1(int x, int y)
485 {
486         if (u.dx) {
487                 if (u.dy) {
488                         nosee(x, u.uy);
489                         nosee(x, u.uy - u.dy);
490                         nosee(x, y);
491                         nosee(u.ux - u.dx, y);
492                         nosee(u.ux, y);
493                 } else {
494                         nosee(x, y - 1);
495                         nosee(x, y);
496                         nosee(x, y + 1);
497                 }
498         } else {
499                 nosee(x - 1, y);
500                 nosee(x, y);
501                 nosee(x + 1, y);
502         }
503 }
504 #endif /* QUEST */
505
506 bool
507 vism_at(int x, int y)
508 {
509         struct monst *mtmp;
510
511         return ((x == u.ux && y == u.uy && !Invisible)
512                 ? 1 :
513                 (mtmp = m_at(x, y))
514                 ? ((Blind && Telepat) || canseemon(mtmp)) :
515                 0);
516 }
517
518 #ifdef NEWSCR
519 static void
520 pobj(struct obj *obj)
521 {
522         int show = (!obj->oinvis || See_invisible) &&
523             cansee(obj->ox, obj->oy);
524
525         if (obj->odispl) {
526                 if (obj->odx != obj->ox || obj->ody != obj->oy || !show)
527                         if (!vism_at(obj->odx, obj->ody)) {
528                                 newsym(obj->odx, obj->ody);
529                                 obj->odispl = 0;
530                         }
531         }
532         if (show && !vism_at(obj->ox, obj->oy)) {
533                 atl(obj->ox, obj->oy, obj->olet);
534                 obj->odispl = 1;
535                 obj->odx = obj->ox;
536                 obj->ody = obj->oy;
537         }
538 }
539 #endif /* NEWSCR */
540
541 void
542 unpobj(struct obj *obj)
543 {
544         if (!vism_at(obj->ox, obj->oy))
545                 newsym(obj->ox, obj->oy);
546 }
547
548 void
549 seeobjs(void)
550 {
551         struct obj *obj, *obj2;
552
553         for (obj = fobj; obj; obj = obj2) {
554                 obj2 = obj->nobj;
555                 if (obj->olet == FOOD_SYM && obj->otyp >= CORPSE
556                     && obj->age + 250 < moves)
557                         delobj(obj);
558         }
559         for (obj = invent; obj; obj = obj2) {
560                 obj2 = obj->nobj;
561                 if (obj->olet == FOOD_SYM && obj->otyp >= CORPSE
562                     && obj->age + 250 < moves)
563                         useup(obj);
564         }
565 }
566
567 void
568 seemons(void)
569 {
570         struct monst *mtmp;
571
572         for (mtmp = fmon; mtmp; mtmp = mtmp->nmon) {
573                 if (mtmp->data->mlet == ';')
574                         mtmp->minvis = (u.ustuck != mtmp &&
575                             levl[mtmp->mx][mtmp->my].typ == POOL);
576                 pmon(mtmp);
577 #ifndef NOWORM
578                 if (mtmp->wormno)
579                         wormsee(mtmp->wormno);
580 #endif /* NOWORM */
581         }
582 }
583
584 void
585 pmon(struct monst *mon)
586 {
587         int show = (Blind && Telepat) || canseemon(mon);
588
589         if (mon->mdispl) {
590                 if (mon->mdx != mon->mx || mon->mdy != mon->my || !show)
591                         unpmon(mon);
592         }
593         if (show && !mon->mdispl) {
594                 atl(mon->mx, mon->my,
595                     (!mon->mappearance
596                     || u.uprops[PROP(RIN_PROTECTION_FROM_SHAPE_CHANGERS)].p_flgs
597                     ) ? mon->data->mlet : mon->mappearance);
598                 mon->mdispl = 1;
599                 mon->mdx = mon->mx;
600                 mon->mdy = mon->my;
601         }
602 }
603
604 void
605 unpmon(struct monst *mon)
606 {
607         if (mon->mdispl) {
608                 newsym(mon->mdx, mon->mdy);
609                 mon->mdispl = 0;
610         }
611 }
612
613 void
614 nscr(void)
615 {
616         int x, y;
617         struct rm *room;
618
619         if (u.uswallow || u.ux == FAR || flags.nscrinh)
620                 return;
621         pru();
622         for (y = scrly; y <= scrhy; y++)
623                 for (x = scrlx; x <= scrhx; x++)
624                         if ((room = &levl[x][y])->new) {
625                                 room->new = 0;
626                                 at(x, y, room->scrsym);
627                         }
628         scrhx = scrhy = 0;
629         scrlx = COLNO;
630         scrly = ROWNO;
631 }
632
633 /* 100 suffices for bot(); no relation with COLNO */
634 char oldbot[100], newbot[100];
635
636 static void
637 cornbot(int lth)
638 {
639         if (lth < (int)sizeof(oldbot)) {
640                 oldbot[lth] = 0;
641                 flags.botl = 1;
642         }
643 }
644
645 void
646 bot(void)
647 {
648         char *ob = oldbot, *nb = newbot;
649         int i;
650
651         if (flags.botlx)
652                 *ob = 0;
653         flags.botl = flags.botlx = 0;
654 #ifdef GOLD_ON_BOTL
655         sprintf(newbot,
656                 "Level %-2d  Gold %-5lu  Hp %3d(%d)  Ac %-2d  Str ",
657                 dlevel, u.ugold, u.uhp, u.uhpmax, u.uac);
658 #else
659         sprintf(newbot,
660                 "Level %-2d   Hp %3d(%d)   Ac %-2d   Str ",
661                 dlevel, u.uhp, u.uhpmax, u.uac);
662 #endif /* GOLD_ON_BOTL */
663         if (u.ustr > 18) {
664                 if (u.ustr > 117)
665                         strcat(newbot, "18/**");
666                 else
667                         sprintf(eos(newbot), "18/%02d", u.ustr - 18);
668         } else
669                 sprintf(eos(newbot), "%-2d   ", u.ustr);
670 #ifdef EXP_ON_BOTL
671         sprintf(eos(newbot), "  Exp %2d/%-5lu ", u.ulevel, u.uexp);
672 #else
673         sprintf(eos(newbot), "   Exp %2u  ", u.ulevel);
674 #endif /* EXP_ON_BOTL */
675         strcat(newbot, hu_stat[u.uhs]);
676         if (flags.time)
677                 sprintf(eos(newbot), "  %ld", moves);
678         if (strlen(newbot) >= COLNO) {
679                 char *bp0, *bp1;
680                 bp0 = bp1 = newbot;
681                 do {
682                         if (*bp0 != ' ' || bp0[1] != ' ' || bp0[2] != ' ')
683                                 *bp1++ = *bp0;
684                 } while (*bp0++);
685         }
686         for (i = 1; i < COLNO; i++) {
687                 if (*ob != *nb) {
688                         curs(i, ROWNO + 2);
689                         putchar(*nb ? *nb : ' ');
690                         curx++;
691                 }
692                 if (*ob)
693                         ob++;
694                 if (*nb)
695                         nb++;
696         }
697         strcpy(oldbot, newbot);
698 }
699
700 #ifdef WAN_PROBING
701 void
702 mstatusline(struct monst *mtmp)
703 {
704         pline("Status of %s: ", monnam(mtmp));
705         pline("Level %-2d  Gold %-5lu  Hp %3d(%d)  Ac %-2d  Dam %d",
706             mtmp->data->mlevel, mtmp->mgold, mtmp->mhp, mtmp->mhpmax,
707             mtmp->data->ac, (mtmp->data->damn + 1) * (mtmp->data->damd + 1));
708 }
709 #endif /* WAN_PROBING */
710
711 void
712 cls(void)
713 {
714         if (flags.toplin == 1)
715                 more();
716         flags.toplin = 0;
717
718         clear_screen();
719
720         flags.botlx = 1;
721 }