home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / bsd_srcs / games / hack / hack.cmd.c < prev    next >
Encoding:
C/C++ Source or Header  |  1988-04-24  |  5.8 KB  |  303 lines
  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. }
  303.