Return to hack.cmd.c CVS log

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

Annotation of 43BSDReno/games/hack/hack.cmd.c, revision 1.1

1.1     ! root        1: /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
        !             2: /* hack.cmd.c - version 1.0.3 */
        !             3: 
        !             4: #include       "hack.h"
        !             5: #include       "def.func_tab.h"
        !             6: 
        !             7: int doredraw(),doredotopl(),dodrop(),dodrink(),doread(),dosearch(),dopickup(),
        !             8: doversion(),doweararm(),dowearring(),doremarm(),doremring(),dopay(),doapply(),
        !             9: dosave(),dowield(),ddoinv(),dozap(),ddocall(),dowhatis(),doengrave(),dotele(),
        !            10: dohelp(),doeat(),doddrop(),do_mname(),doidtrap(),doprwep(),doprarm(),
        !            11: doprring(),doprgold(),dodiscovered(),dotypeinv(),dolook(),doset(),
        !            12: doup(), dodown(), done1(), donull(), dothrow(), doextcmd(), dodip(), dopray();
        !            13: #ifdef SHELL
        !            14: int dosh();
        !            15: #endif SHELL
        !            16: #ifdef SUSPEND
        !            17: int dosuspend();
        !            18: #endif SUSPEND
        !            19: 
        !            20: struct func_tab cmdlist[]={
        !            21:        '\020', doredotopl,
        !            22:        '\022', doredraw,
        !            23:        '\024', dotele,
        !            24: #ifdef SUSPEND
        !            25:        '\032', dosuspend,
        !            26: #endif SUSPEND
        !            27:        'a', doapply,
        !            28: /*     'A' : UNUSED */
        !            29: /*     'b', 'B' : go sw */
        !            30:        'c', ddocall,
        !            31:        'C', do_mname,
        !            32:        'd', dodrop,
        !            33:        'D', doddrop,
        !            34:        'e', doeat,
        !            35:        'E', doengrave,
        !            36: /*     'f', 'F' : multiple go (might become 'fight') */
        !            37: /*     'g', 'G' : UNUSED */
        !            38: /*     'h', 'H' : go west */
        !            39:        'I', dotypeinv,         /* Robert Viduya */
        !            40:        'i', ddoinv,
        !            41: /*     'j', 'J', 'k', 'K', 'l', 'L', 'm', 'M', 'n', 'N' : move commands */
        !            42: /*     'o', doopen,    */
        !            43:        'O', doset,
        !            44:        'p', dopay,
        !            45:        'P', dowearring,
        !            46:        'q', dodrink,
        !            47:        'Q', done1,
        !            48:        'r', doread,
        !            49:        'R', doremring,
        !            50:        's', dosearch,
        !            51:        'S', dosave,
        !            52:        't', dothrow,
        !            53:        'T', doremarm,
        !            54: /*     'u', 'U' : go ne */
        !            55:        'v', doversion,
        !            56: /*     'V' : UNUSED */
        !            57:        'w', dowield,
        !            58:        'W', doweararm,
        !            59: /*     'x', 'X' : UNUSED */
        !            60: /*     'y', 'Y' : go nw */
        !            61:        'z', dozap,
        !            62: /*     'Z' : UNUSED */
        !            63:        '<', doup,
        !            64:        '>', dodown,
        !            65:        '/', dowhatis,
        !            66:        '?', dohelp,
        !            67: #ifdef SHELL
        !            68:        '!', dosh,
        !            69: #endif SHELL
        !            70:        '.', donull,
        !            71:        ' ', donull,
        !            72:        ',', dopickup,
        !            73:        ':', dolook,
        !            74:        '^', doidtrap,
        !            75:        '\\', dodiscovered,             /* Robert Viduya */
        !            76:         WEAPON_SYM,  doprwep,
        !            77:         ARMOR_SYM,  doprarm,
        !            78:         RING_SYM,  doprring,
        !            79:        '$', doprgold,
        !            80:        '#', doextcmd,
        !            81:        0,0,0
        !            82: };
        !            83: 
        !            84: struct ext_func_tab extcmdlist[] = {
        !            85:        "dip", dodip,
        !            86:        "pray", dopray,
        !            87:        (char *) 0, donull
        !            88: };
        !            89: 
        !            90: extern char *parse(), lowc(), unctrl(), quitchars[];
        !            91: 
        !            92: rhack(cmd)
        !            93: register char *cmd;
        !            94: {
        !            95:        register struct func_tab *tlist = cmdlist;
        !            96:        boolean firsttime = FALSE;
        !            97:        register res;
        !            98: 
        !            99:        if(!cmd) {
        !           100:                firsttime = TRUE;
        !           101:                flags.nopick = 0;
        !           102:                cmd = parse();
        !           103:        }
        !           104:        if(!*cmd || (*cmd & 0377) == 0377 ||
        !           105:           (flags.no_rest_on_space && *cmd == ' ')){
        !           106:                bell();
        !           107:                flags.move = 0;
        !           108:                return;         /* probably we just had an interrupt */
        !           109:        }
        !           110:        if(movecmd(*cmd)) {
        !           111:        walk:
        !           112:                if(multi) flags.mv = 1;
        !           113:                domove();
        !           114:                return;
        !           115:        }
        !           116:        if(movecmd(lowc(*cmd))) {
        !           117:                flags.run = 1;
        !           118:        rush:
        !           119:                if(firsttime){
        !           120:                        if(!multi) multi = COLNO;
        !           121:                        u.last_str_turn = 0;
        !           122:                }
        !           123:                flags.mv = 1;
        !           124: #ifdef QUEST
        !           125:                if(flags.run >= 4) finddir();
        !           126:                if(firsttime){
        !           127:                        u.ux0 = u.ux + u.dx;
        !           128:                        u.uy0 = u.uy + u.dy;
        !           129:                }
        !           130: #endif QUEST
        !           131:                domove();
        !           132:                return;
        !           133:        }
        !           134:        if((*cmd == 'f' && movecmd(cmd[1])) || movecmd(unctrl(*cmd))) {
        !           135:                flags.run = 2;
        !           136:                goto rush;
        !           137:        }
        !           138:        if(*cmd == 'F' && movecmd(lowc(cmd[1]))) {
        !           139:                flags.run = 3;
        !           140:                goto rush;
        !           141:        }
        !           142:        if(*cmd == 'm' && movecmd(cmd[1])) {
        !           143:                flags.run = 0;
        !           144:                flags.nopick = 1;
        !           145:                goto walk;
        !           146:        }
        !           147:        if(*cmd == 'M' && movecmd(lowc(cmd[1]))) {
        !           148:                flags.run = 1;
        !           149:                flags.nopick = 1;
        !           150:                goto rush;
        !           151:        }
        !           152: #ifdef QUEST
        !           153:        if(*cmd == cmd[1] && (*cmd == 'f' || *cmd == 'F')) {
        !           154:                flags.run = 4;
        !           155:                if(*cmd == 'F') flags.run += 2;
        !           156:                if(cmd[2] == '-') flags.run += 1;
        !           157:                goto rush;
        !           158:        }
        !           159: #endif QUEST
        !           160:        while(tlist->f_char) {
        !           161:                if(*cmd == tlist->f_char){
        !           162:                        res = (*(tlist->f_funct))();
        !           163:                        if(!res) {
        !           164:                                flags.move = 0;
        !           165:                                multi = 0;
        !           166:                        }
        !           167:                        return;
        !           168:                }
        !           169:                tlist++;
        !           170:        }
        !           171:        { char expcmd[10];
        !           172:          register char *cp = expcmd;
        !           173:          while(*cmd && cp-expcmd < sizeof(expcmd)-2) {
        !           174:                if(*cmd >= 040 && *cmd < 0177)
        !           175:                        *cp++ = *cmd++;
        !           176:                else {
        !           177:                        *cp++ = '^';
        !           178:                        *cp++ = *cmd++ ^ 0100;
        !           179:                }
        !           180:          }
        !           181:          *cp++ = 0;
        !           182:          pline("Unknown command '%s'.", expcmd);
        !           183:        }
        !           184:        multi = flags.move = 0;
        !           185: }
        !           186: 
        !           187: doextcmd()     /* here after # - now read a full-word command */
        !           188: {
        !           189:        char buf[BUFSZ];
        !           190:        register struct ext_func_tab *efp = extcmdlist;
        !           191: 
        !           192:        pline("# ");
        !           193:        getlin(buf);
        !           194:        clrlin();
        !           195:        if(buf[0] == '\033')
        !           196:                return(0);
        !           197:        while(efp->ef_txt) {
        !           198:                if(!strcmp(efp->ef_txt, buf))
        !           199:                        return((*(efp->ef_funct))());
        !           200:                efp++;
        !           201:        }
        !           202:        pline("%s: unknown command.", buf);
        !           203:        return(0);
        !           204: }
        !           205: 
        !           206: char
        !           207: lowc(sym)
        !           208: char sym;
        !           209: {
        !           210:     return( (sym >= 'A' && sym <= 'Z') ? sym+'a'-'A' : sym );
        !           211: }
        !           212: 
        !           213: char
        !           214: unctrl(sym)
        !           215: char sym;
        !           216: {
        !           217:     return( (sym >= ('A' & 037) && sym <= ('Z' & 037)) ? sym + 0140 : sym );
        !           218: }
        !           219: 
        !           220: /* 'rogue'-like direction commands */
        !           221: char sdir[] = "hykulnjb><";
        !           222: schar xdir[10] = { -1,-1, 0, 1, 1, 1, 0,-1, 0, 0 };
        !           223: schar ydir[10] = {  0,-1,-1,-1, 0, 1, 1, 1, 0, 0 };
        !           224: schar zdir[10] = {  0, 0, 0, 0, 0, 0, 0, 0, 1,-1 };
        !           225: 
        !           226: movecmd(sym)   /* also sets u.dz, but returns false for <> */
        !           227: char sym;
        !           228: {
        !           229:        register char *dp;
        !           230: 
        !           231:        u.dz = 0;
        !           232:        if(!(dp = index(sdir, sym))) return(0);
        !           233:        u.dx = xdir[dp-sdir];
        !           234:        u.dy = ydir[dp-sdir];
        !           235:        u.dz = zdir[dp-sdir];
        !           236:        return(!u.dz);
        !           237: }
        !           238: 
        !           239: getdir(s)
        !           240: boolean s;
        !           241: {
        !           242:        char dirsym;
        !           243: 
        !           244:        if(s) pline("In what direction?");
        !           245:        dirsym = readchar();
        !           246:        if(!movecmd(dirsym) && !u.dz) {
        !           247:                if(!index(quitchars, dirsym))
        !           248:                        pline("What a strange direction!");
        !           249:                return(0);
        !           250:        }
        !           251:        if(Confusion && !u.dz)
        !           252:                confdir();
        !           253:        return(1);
        !           254: }
        !           255: 
        !           256: confdir()
        !           257: {
        !           258:        register x = rn2(8);
        !           259:        u.dx = xdir[x];
        !           260:        u.dy = ydir[x];
        !           261: }
        !           262: 
        !           263: #ifdef QUEST
        !           264: finddir(){
        !           265: register int i, ui = u.di;
        !           266:        for(i = 0; i <= 8; i++){
        !           267:                if(flags.run & 1) ui++; else ui += 7;
        !           268:                ui %= 8;
        !           269:                if(i == 8){
        !           270:                        pline("Not near a wall.");
        !           271:                        flags.move = multi = 0;
        !           272:                        return(0);
        !           273:                }
        !           274:                if(!isroom(u.ux+xdir[ui], u.uy+ydir[ui]))
        !           275:                        break;
        !           276:        }
        !           277:        for(i = 0; i <= 8; i++){
        !           278:                if(flags.run & 1) ui += 7; else ui++;
        !           279:                ui %= 8;
        !           280:                if(i == 8){
        !           281:                        pline("Not near a room.");
        !           282:                        flags.move = multi = 0;
        !           283:                        return(0);
        !           284:                }
        !           285:                if(isroom(u.ux+xdir[ui], u.uy+ydir[ui]))
        !           286:                        break;
        !           287:        }
        !           288:        u.di = ui;
        !           289:        u.dx = xdir[ui];
        !           290:        u.dy = ydir[ui];
        !           291: }
        !           292: 
        !           293: isroom(x,y)  register x,y; {           /* what about POOL? */
        !           294:        return(isok(x,y) && (levl[x][y].typ == ROOM ||
        !           295:                                (levl[x][y].typ >= LDOOR && flags.run >= 6)));
        !           296: }
        !           297: #endif QUEST
        !           298: 
        !           299: isok(x,y) register x,y; {
        !           300:        /* x corresponds to curx, so x==1 is the first column. Ach. %% */
        !           301:        return(x >= 1 && x <= COLNO-1 && y >= 0 && y <= ROWNO-1);
        !           302: }

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