hack/hack.cmd.c

   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 }