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