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