Return to hack.do_name.c CVS log

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

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

1.1     ! root        1: /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
        !             2: /* hack.do_name.c - version 1.0.3 */
        !             3: 
        !             4: #include "hack.h"
        !             5: #include <stdio.h>
        !             6: extern char plname[];
        !             7: 
        !             8: coord
        !             9: getpos(force,goal) int force; char *goal; {
        !            10: register cx,cy,i,c;
        !            11: extern char sdir[];            /* defined in hack.c */
        !            12: extern schar xdir[], ydir[];   /* idem */
        !            13: extern char *visctrl();                /* see below */
        !            14: coord cc;
        !            15:        pline("(For instructions type a ?)");
        !            16:        cx = u.ux;
        !            17:        cy = u.uy;
        !            18:        curs(cx,cy+2);
        !            19:        while((c = readchar()) != '.'){
        !            20:                for(i=0; i<8; i++) if(sdir[i] == c){
        !            21:                        if(1 <= cx + xdir[i] && cx + xdir[i] <= COLNO)
        !            22:                                cx += xdir[i];
        !            23:                        if(0 <= cy + ydir[i] && cy + ydir[i] <= ROWNO-1)
        !            24:                                cy += ydir[i];
        !            25:                        goto nxtc;
        !            26:                }
        !            27:                if(c == '?'){
        !            28:                        pline("Use [hjkl] to move the cursor to %s.", goal);
        !            29:                        pline("Type a . when you are at the right place.");
        !            30:                } else {
        !            31:                        pline("Unknown direction: '%s' (%s).",
        !            32:                                visctrl(c),
        !            33:                                force ? "use hjkl or ." : "aborted");
        !            34:                        if(force) goto nxtc;
        !            35:                        cc.x = -1;
        !            36:                        cc.y = 0;
        !            37:                        return(cc);
        !            38:                }
        !            39:        nxtc:   ;
        !            40:                curs(cx,cy+2);
        !            41:        }
        !            42:        cc.x = cx;
        !            43:        cc.y = cy;
        !            44:        return(cc);
        !            45: }
        !            46: 
        !            47: do_mname(){
        !            48: char buf[BUFSZ];
        !            49: coord cc;
        !            50: register int cx,cy,lth,i;
        !            51: register struct monst *mtmp, *mtmp2;
        !            52: extern char *lmonnam();
        !            53:        cc = getpos(0, "the monster you want to name");
        !            54:        cx = cc.x;
        !            55:        cy = cc.y;
        !            56:        if(cx < 0) return(0);
        !            57:        mtmp = m_at(cx,cy);
        !            58:        if(!mtmp){
        !            59:            if(cx == u.ux && cy == u.uy)
        !            60:                pline("This ugly monster is called %s and cannot be renamed.",
        !            61:                    plname);
        !            62:            else
        !            63:                pline("There is no monster there.");
        !            64:            return(1);
        !            65:        }
        !            66:        if(mtmp->mimic){
        !            67:            pline("I see no monster there.");
        !            68:            return(1);
        !            69:        }
        !            70:        if(!cansee(cx,cy)) {
        !            71:            pline("I cannot see a monster there.");
        !            72:            return(1);
        !            73:        }
        !            74:        pline("What do you want to call %s? ", lmonnam(mtmp));
        !            75:        getlin(buf);
        !            76:        clrlin();
        !            77:        if(!*buf || *buf == '\033')
        !            78:                return(1);
        !            79:        lth = strlen(buf)+1;
        !            80:        if(lth > 63){
        !            81:                buf[62] = 0;
        !            82:                lth = 63;
        !            83:        }
        !            84:        mtmp2 = newmonst(mtmp->mxlth + lth);
        !            85:        *mtmp2 = *mtmp;
        !            86:        for(i=0; i<mtmp->mxlth; i++)
        !            87:                ((char *) mtmp2->mextra)[i] = ((char *) mtmp->mextra)[i];
        !            88:        mtmp2->mnamelth = lth;
        !            89:        (void) strcpy(NAME(mtmp2), buf);
        !            90:        replmon(mtmp,mtmp2);
        !            91:        return(1);
        !            92: }
        !            93: 
        !            94: /*
        !            95:  * This routine changes the address of  obj . Be careful not to call it
        !            96:  * when there might be pointers around in unknown places. For now: only
        !            97:  * when  obj  is in the inventory.
        !            98:  */
        !            99: do_oname(obj) register struct obj *obj; {
        !           100: register struct obj *otmp, *otmp2;
        !           101: register lth;
        !           102: char buf[BUFSZ];
        !           103:        pline("What do you want to name %s? ", doname(obj));
        !           104:        getlin(buf);
        !           105:        clrlin();
        !           106:        if(!*buf || *buf == '\033')
        !           107:                return;
        !           108:        lth = strlen(buf)+1;
        !           109:        if(lth > 63){
        !           110:                buf[62] = 0;
        !           111:                lth = 63;
        !           112:        }
        !           113:        otmp2 = newobj(lth);
        !           114:        *otmp2 = *obj;
        !           115:        otmp2->onamelth = lth;
        !           116:        (void) strcpy(ONAME(otmp2), buf);
        !           117: 
        !           118:        setworn((struct obj *) 0, obj->owornmask);
        !           119:        setworn(otmp2, otmp2->owornmask);
        !           120: 
        !           121:        /* do freeinv(obj); etc. by hand in order to preserve
        !           122:           the position of this object in the inventory */
        !           123:        if(obj == invent) invent = otmp2;
        !           124:        else for(otmp = invent; ; otmp = otmp->nobj){
        !           125:                if(!otmp)
        !           126:                        panic("Do_oname: cannot find obj.");
        !           127:                if(otmp->nobj == obj){
        !           128:                        otmp->nobj = otmp2;
        !           129:                        break;
        !           130:                }
        !           131:        }
        !           132:        /* obfree(obj, otmp2);  /* now unnecessary: no pointers on bill */
        !           133:        free((char *) obj);     /* let us hope nobody else saved a pointer */
        !           134: }
        !           135: 
        !           136: ddocall()
        !           137: {
        !           138:        register struct obj *obj;
        !           139: 
        !           140:        pline("Do you want to name an individual object? [ny] ");
        !           141:        switch(readchar()) {
        !           142:        case '\033':
        !           143:                break;
        !           144:        case 'y':
        !           145:                obj = getobj("#", "name");
        !           146:                if(obj) do_oname(obj);
        !           147:                break;
        !           148:        default:
        !           149:                obj = getobj("?!=/", "call");
        !           150:                if(obj) docall(obj);
        !           151:        }
        !           152:        return(0);
        !           153: }
        !           154: 
        !           155: docall(obj)
        !           156: register struct obj *obj;
        !           157: {
        !           158:        char buf[BUFSZ];
        !           159:        struct obj otemp;
        !           160:        register char **str1;
        !           161:        extern char *xname();
        !           162:        register char *str;
        !           163: 
        !           164:        otemp = *obj;
        !           165:        otemp.quan = 1;
        !           166:        otemp.onamelth = 0;
        !           167:        str = xname(&otemp);
        !           168:        pline("Call %s %s: ", index(vowels,*str) ? "an" : "a", str);
        !           169:        getlin(buf);
        !           170:        clrlin();
        !           171:        if(!*buf || *buf == '\033')
        !           172:                return;
        !           173:        str = newstring(strlen(buf)+1);
        !           174:        (void) strcpy(str,buf);
        !           175:        str1 = &(objects[obj->otyp].oc_uname);
        !           176:        if(*str1) free(*str1);
        !           177:        *str1 = str;
        !           178: }
        !           179: 
        !           180: char *ghostnames[] = {         /* these names should have length < PL_NSIZ */
        !           181:        "adri", "andries", "andreas", "bert", "david", "dirk", "emile",
        !           182:        "frans", "fred", "greg", "hether", "jay", "john", "jon", "kay",
        !           183:        "kenny", "maud", "michiel", "mike", "peter", "robert", "ron",
        !           184:        "tom", "wilmar"
        !           185: };
        !           186: 
        !           187: char *
        !           188: xmonnam(mtmp, vb) register struct monst *mtmp; int vb; {
        !           189: static char buf[BUFSZ];                /* %% */
        !           190: extern char *shkname();
        !           191:        if(mtmp->mnamelth && !vb) {
        !           192:                (void) strcpy(buf, NAME(mtmp));
        !           193:                return(buf);
        !           194:        }
        !           195:        switch(mtmp->data->mlet) {
        !           196:        case ' ':
        !           197:                { register char *gn = (char *) mtmp->mextra;
        !           198:                  if(!*gn) {            /* might also look in scorefile */
        !           199:                    gn = ghostnames[rn2(SIZE(ghostnames))];
        !           200:                    if(!rn2(2)) (void)
        !           201:                      strcpy((char *) mtmp->mextra, !rn2(5) ? plname : gn);
        !           202:                  }
        !           203:                  (void) sprintf(buf, "%s's ghost", gn);
        !           204:                }
        !           205:                break;
        !           206:        case '@':
        !           207:                if(mtmp->isshk) {
        !           208:                        (void) strcpy(buf, shkname(mtmp));
        !           209:                        break;
        !           210:                }
        !           211:                /* fall into next case */
        !           212:        default:
        !           213:                (void) sprintf(buf, "the %s%s",
        !           214:                        mtmp->minvis ? "invisible " : "",
        !           215:                        mtmp->data->mname);
        !           216:        }
        !           217:        if(vb && mtmp->mnamelth) {
        !           218:                (void) strcat(buf, " called ");
        !           219:                (void) strcat(buf, NAME(mtmp));
        !           220:        }
        !           221:        return(buf);
        !           222: }
        !           223: 
        !           224: char *
        !           225: lmonnam(mtmp) register struct monst *mtmp; {
        !           226:        return(xmonnam(mtmp, 1));
        !           227: }
        !           228: 
        !           229: char *
        !           230: monnam(mtmp) register struct monst *mtmp; {
        !           231:        return(xmonnam(mtmp, 0));
        !           232: }
        !           233: 
        !           234: char *
        !           235: Monnam(mtmp) register struct monst *mtmp; {
        !           236: register char *bp = monnam(mtmp);
        !           237:        if('a' <= *bp && *bp <= 'z') *bp += ('A' - 'a');
        !           238:        return(bp);
        !           239: }
        !           240: 
        !           241: char *
        !           242: amonnam(mtmp,adj)
        !           243: register struct monst *mtmp;
        !           244: register char *adj;
        !           245: {
        !           246:        register char *bp = monnam(mtmp);
        !           247:        static char buf[BUFSZ];         /* %% */
        !           248: 
        !           249:        if(!strncmp(bp, "the ", 4)) bp += 4;
        !           250:        (void) sprintf(buf, "the %s %s", adj, bp);
        !           251:        return(buf);
        !           252: }
        !           253: 
        !           254: char *
        !           255: Amonnam(mtmp, adj)
        !           256: register struct monst *mtmp;
        !           257: register char *adj;
        !           258: {
        !           259:        register char *bp = amonnam(mtmp,adj);
        !           260: 
        !           261:        *bp = 'T';
        !           262:        return(bp);
        !           263: }
        !           264: 
        !           265: char *
        !           266: Xmonnam(mtmp) register struct monst *mtmp; {
        !           267: register char *bp = Monnam(mtmp);
        !           268:        if(!strncmp(bp, "The ", 4)) {
        !           269:                bp += 2;
        !           270:                *bp = 'A';
        !           271:        }
        !           272:        return(bp);
        !           273: }
        !           274: 
        !           275: char *
        !           276: visctrl(c)
        !           277: char c;
        !           278: {
        !           279: static char ccc[3];
        !           280:        if(c < 040) {
        !           281:                ccc[0] = '^';
        !           282:                ccc[1] = c + 0100;
        !           283:                ccc[2] = 0;
        !           284:        } else {
        !           285:                ccc[0] = c;
        !           286:                ccc[1] = 0;
        !           287:        }
        !           288:        return(ccc);
        !           289: }

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