Return to hack.pri.c CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / games / hack

Annotation of 43BSDTahoe/games/hack/hack.pri.c, revision 1.1

1.1     ! root        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: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.