games/hack/hack.cmd.c

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