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