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