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