home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / games / volume12 / mdg / part03 / input.c < prev    next >
C/C++ Source or Header  |  1991-03-04  |  15KB  |  914 lines
  1. /*
  2.     MDG Multiuser Dungeon Game -- input.c reader-task
  3.     
  4.     MDG is Copyright 1990 John C. Gonnerman
  5.     This program is subject to the general MDG 
  6.     copyright statement (see enclosed file, Copyright).
  7. */
  8.  
  9. static char *sccsvers = "@(#) input.c\t(1.5)\tcreated 1/3/91";
  10.  
  11. #include <curses.h>
  12. #include <fcntl.h>
  13. #include <signal.h>
  14. #include <string.h>
  15. #include <ctype.h>
  16.  
  17. #include <sys/types.h>
  18. #include <sys/stat.h>
  19. #include <sys/ipc.h>
  20. #include <sys/msg.h>
  21. #include <sys/sem.h>
  22.  
  23. #include "setup.h"
  24. #include "struct.h"
  25. #include "messages.h"
  26. #include "effect.h"
  27.  
  28. #define GOD1PROMPT \
  29.     "God Power: r)eveal, m)ap, s)tats, t)itle, l)ink, or i)tem? "
  30.  
  31. char *gates = "={}:;-|";
  32.  
  33. char *progname;
  34.  
  35. struct player_seg *pseg;
  36. struct map_seg *mseg;
  37.  
  38. extern int errno;
  39. extern char *sys_errlist[];
  40.  
  41. extern char *spell_names[];
  42.  
  43. int pid, dqid, gseg_id, playernum, player_indx;
  44. char handle[20];
  45.  
  46. char old_buf[35] = "";
  47.  
  48. struct game_msg *gseg;
  49.  
  50.  
  51. input_process()
  52. {
  53.     int ch;
  54.     void input_exit();
  55.  
  56.     strcpy(gseg->buf, WELCOME);
  57.     tell_viewer();
  58.  
  59.     signal(SIGHUP, input_exit);
  60.  
  61.     while((ch = getchar()) != EOF)
  62.         send_message(ch);
  63. }
  64.  
  65.  
  66. void input_exit(sig)
  67. int sig;
  68. {
  69.     shmdt(gseg);
  70.  
  71.     exit(0);
  72. }
  73.  
  74.  
  75. send_t_message(ch)
  76. int ch;
  77. {
  78.     struct dmessage msg_buf;
  79.     int in_ch, item_indx;
  80.  
  81.     msg_buf.msg_type = 1L;
  82.     msg_buf.playernum = playernum;
  83.  
  84.     switch(ch) {
  85.  
  86.     case '\f' :
  87.         redraw_scr();
  88.         break;
  89.  
  90.     case 'n' : /* next */
  91.         gseg->trader_offset += 10;
  92.         tell_viewer();
  93.         break;
  94.  
  95.     case 'p' : /* previous */
  96.         if(gseg->trader_offset > 0)
  97.             gseg->trader_offset -= 10;
  98.         tell_viewer();
  99.         break;
  100.  
  101.     case 'b' : /* buy */
  102.         msg_buf.cmd = 'B';
  103.  
  104.         strcpy(gseg->buf, "buy what? (0-9) ");
  105.         tell_viewer();
  106.  
  107.         in_ch = getchar() - '0';
  108.  
  109.         gseg->buf[0] = '\0';
  110.         tell_viewer();
  111.  
  112.         if(in_ch < 0 || in_ch > 9)
  113.             break;
  114.  
  115.         if((msg_buf.arg = trader_item(in_ch)) == -1)
  116.             break;
  117.  
  118.         tell_daemon(&msg_buf);
  119.  
  120.         break;
  121.  
  122.     case 'v' : /* value */
  123.         strcpy(gseg->buf, "value what? (1-7) ");
  124.         tell_viewer();
  125.  
  126.         in_ch = getchar() - '0';
  127.  
  128.         if((item_indx = find_item(player_indx, in_ch)) >= 0) {
  129.             sprintf(gseg->buf, "%s is worth %d\n",
  130.                 pseg->itm[item_indx].name,
  131.                 pseg->itm[item_indx].value);
  132.             tell_viewer();
  133.         }
  134.  
  135.         break;
  136.  
  137.     case 's' : /* sell */
  138.         strcpy(gseg->buf, "sell what? (1-7) ");
  139.         tell_viewer();
  140.  
  141.         in_ch = getchar() - '0';
  142.  
  143.         if((item_indx = find_item(player_indx, in_ch)) >= 0) {
  144.             msg_buf.cmd = 'S';
  145.             msg_buf.arg = item_indx;
  146.             tell_daemon(&msg_buf);
  147.         }
  148.  
  149.         gseg->buf[0] = '\0';
  150.         tell_viewer();
  151.  
  152.         break;
  153.  
  154.     case 'l' : /* leave */
  155.         msg_buf.cmd = 'L';
  156.         tell_daemon(&msg_buf);
  157.         break;
  158.     }
  159. }
  160.  
  161.  
  162. send_message(ch)
  163. int ch;
  164. {
  165.     struct dmessage msg_buf;
  166.     int in_ch, item_indx;
  167.  
  168.     if(gseg->trader_offset >= 0) {
  169.         send_t_message(ch);
  170.         return;
  171.     }
  172.  
  173.     msg_buf.msg_type = 1L;
  174.     msg_buf.playernum = playernum;
  175.  
  176.     if(isupper(ch)) {
  177.         msg_buf.cmd = 'c';
  178.         msg_buf.subcmd = ch - 'A';
  179.         if((msg_buf.arg = get_spell_arg(tolower(ch))) == -1) {
  180.             strcpy(gseg->buf, "* aborted *");
  181.             tell_viewer();
  182.             return;
  183.         }
  184.         get_spell_text(tolower(ch), msg_buf.text);
  185.         tell_daemon(&msg_buf);
  186.  
  187.     } else switch(ch) {
  188.  
  189.     case '\n' :
  190.     case '\r' :
  191.         gseg->buf[0] = '\0';
  192.         tell_viewer();
  193.         break;
  194.  
  195.     case '\f' :
  196.         redraw_scr();
  197.         break;
  198.  
  199.     case '*' :
  200.     case '?' :
  201.         help();
  202.         break;
  203.  
  204.     case ';' :
  205.         telltime();
  206.         break;
  207.  
  208.     case 't' : /* take */
  209.     case '0' :
  210.         msg_buf.cmd = 't';
  211.         tell_daemon(&msg_buf);
  212.         break;
  213.  
  214.     case 'k' :
  215.     case '8' :
  216.         msg_buf.cmd = 'm';
  217.         msg_buf.subcmd = L_NORTH;
  218.         tell_daemon(&msg_buf);
  219.         break;
  220.  
  221.     case 'j' :
  222.     case '2' :
  223.         msg_buf.cmd = 'm';
  224.         msg_buf.subcmd = L_SOUTH;
  225.         tell_daemon(&msg_buf);
  226.         break;
  227.  
  228.     case 'l' :
  229.     case '6' :
  230.         msg_buf.cmd = 'm';
  231.         msg_buf.subcmd = L_EAST;
  232.         tell_daemon(&msg_buf);
  233.         break;
  234.  
  235.     case 'h' :
  236.     case '4' :
  237.         msg_buf.cmd = 'm';
  238.         msg_buf.subcmd = L_WEST;
  239.         tell_daemon(&msg_buf);
  240.         break;
  241.  
  242.     case 'y' :
  243.     case '7' :
  244.         msg_buf.cmd = 'm';
  245.         msg_buf.subcmd = L_NWEST;
  246.         tell_daemon(&msg_buf);
  247.         break;
  248.  
  249.     case 'u' :
  250.     case '9' :
  251.         msg_buf.cmd = 'm';
  252.         msg_buf.subcmd = L_NEAST;
  253.         tell_daemon(&msg_buf);
  254.         break;
  255.  
  256.     case 'b' :
  257.     case '1' :
  258.         msg_buf.cmd = 'm';
  259.         msg_buf.subcmd = L_SWEST;
  260.         tell_daemon(&msg_buf);
  261.         break;
  262.  
  263.     case 'n' :
  264.     case '3' :
  265.         msg_buf.cmd = 'm';
  266.         msg_buf.subcmd = L_SEAST;
  267.         tell_daemon(&msg_buf);
  268.         break;
  269.  
  270.     case 'e' : /* enter */
  271.     case '5' :
  272.         msg_buf.cmd = 'e';
  273.         tell_daemon(&msg_buf);
  274.         break;
  275.  
  276.     case 'd' : /* drop */
  277.     case '/' : /* drop */
  278.         strcpy(gseg->buf, "drop what? (0-7) ");
  279.         tell_viewer();
  280.  
  281.         in_ch = getchar() - '0';
  282.  
  283.         if(in_ch == 0) {
  284.             strcpy(gseg->buf, "drop gold where? (hjkl) ");
  285.             tell_viewer();
  286.             if((msg_buf.subcmd = get_dir()) != -1
  287.             && (msg_buf.arg = get_amount()) > 0) {
  288.                 msg_buf.cmd = 'D';
  289.                 tell_daemon(&msg_buf);
  290.             }
  291.         } else if(in_ch > 0 && in_ch <= PMAX_ITEMS)
  292.             if((item_indx = find_item(player_indx, in_ch)) >= 0) {
  293.                 sprintf(gseg->buf, 
  294.                     "drop %d where? (hjkl) ", in_ch);
  295.                 tell_viewer();
  296.                 if((msg_buf.subcmd = get_dir()) != -1) {
  297.                     msg_buf.cmd = 'd';
  298.                     msg_buf.arg = item_indx;
  299.                     tell_daemon(&msg_buf);
  300.                 }
  301.             }
  302.  
  303.         gseg->buf[0] = '\0';
  304.         tell_viewer();
  305.  
  306.         break;
  307.  
  308.     case ')' : /* cast */
  309.     case 'c' : /* cast */
  310.         strcpy(gseg->buf, "cast which spell? (a-z) ");
  311.         tell_viewer();
  312.  
  313.         in_ch = tolower(getchar());
  314.  
  315.         if(in_ch >= 'a' && in_ch <= 'z') {
  316.             msg_buf.cmd = 'c';
  317.             msg_buf.subcmd = in_ch - 'a';
  318.             if((msg_buf.arg = get_spell_arg(in_ch)) == -1) {
  319.                 strcpy(gseg->buf, "* aborted *");
  320.                 tell_viewer();
  321.                 return;
  322.             }
  323.             get_spell_text(in_ch, msg_buf.text);
  324.             tell_daemon(&msg_buf);
  325.         }
  326.  
  327.         gseg->buf[0] = '\0';
  328.         tell_viewer();
  329.  
  330.         break;
  331.  
  332.     case 'g' : /* god power */
  333.         if(pseg->p[player_indx].createpts < 1)
  334.             break;
  335.  
  336.         strcpy(gseg->buf, GOD1PROMPT);
  337.         tell_viewer();
  338.  
  339.         in_ch = tolower(getchar());
  340.  
  341.         get_god_cmd(in_ch);
  342.  
  343.         gseg->buf[0] = '\0';
  344.         tell_viewer();
  345.  
  346.         break;
  347.  
  348.     case 'v' : /* verbose */
  349.         
  350.         msg_buf.cmd = 'v';
  351.         tell_daemon(&msg_buf);
  352.  
  353.         break;
  354.  
  355.     case '(' : /* activate */
  356.     case 'a' : /* activate */
  357.         strcpy(gseg->buf, "activate what? (1-7) ");
  358.         tell_viewer();
  359.  
  360.         in_ch = getchar() - '0';
  361.  
  362.         activate_it(in_ch);
  363.  
  364.         gseg->buf[0] = '\0';
  365.         tell_viewer();
  366.  
  367.         break;
  368.  
  369.     case '!' : /* activate 1 */
  370.  
  371.         activate_it(1);
  372.         break;
  373.  
  374.     case '@' : /* activate 2 */
  375.  
  376.         activate_it(2);
  377.         break;
  378.  
  379.     case '#' : /* activate 3 */
  380.  
  381.         activate_it(3);
  382.         break;
  383.  
  384.     case '$' : /* activate 4 */
  385.  
  386.         activate_it(4);
  387.         break;
  388.  
  389.     case '%' : /* activate 5 */
  390.  
  391.         activate_it(5);
  392.         break;
  393.  
  394.     case '^' : /* activate 6 */
  395.  
  396.         activate_it(6);
  397.         break;
  398.  
  399.     case '&' : /* activate 7 */
  400.  
  401.         activate_it(7);
  402.         break;
  403.  
  404.     case 'w' : /* write */
  405.         strcpy(gseg->buf, "write what? (1-7) ");
  406.         tell_viewer();
  407.  
  408.         in_ch = getchar() - '1';
  409.  
  410.         write_it(in_ch);
  411.  
  412.         gseg->buf[0] = '\0';
  413.         tell_viewer();
  414.  
  415.         break;
  416.  
  417.     case '.' : /* say */
  418.     case 's' : /* say */
  419.         say_it();
  420.         break;
  421.  
  422.     case '+' : /* partner */
  423.     case 'p' : /* partner */
  424.         partner();
  425.         break;
  426.     }
  427. }
  428.  
  429.  
  430. activate_it(in_ch)
  431. int in_ch;
  432. {
  433.     struct dmessage msg_buf;
  434.     int item_indx;
  435.  
  436.     if(in_ch > 0 && in_ch <= PMAX_ITEMS) {
  437.         item_indx = find_item(player_indx, in_ch);
  438.  
  439.         if(item_indx >= 0) {
  440.             msg_buf.msg_type = 1L;
  441.             msg_buf.playernum = playernum;
  442.             msg_buf.cmd = 'u';
  443.             msg_buf.subcmd = item_indx;
  444.             msg_buf.arg = get_use_dir(item_indx);
  445.             tell_daemon(&msg_buf);
  446.         }
  447.     }
  448. }
  449.  
  450.  
  451. partner()
  452. {
  453.     struct dmessage msg_buf;
  454.     int pard;
  455.  
  456.     strcpy(gseg->buf, "partner with who? ");
  457.     tell_viewer();
  458.  
  459.     pard = toupper(getchar()) - '1';
  460.  
  461.     gseg->buf[0] = '\0';
  462.     tell_viewer();
  463.  
  464.     msg_buf.msg_type = 1L;
  465.     msg_buf.playernum = playernum;
  466.     msg_buf.cmd = 'p';
  467.     msg_buf.subcmd = pard;
  468.     tell_daemon(&msg_buf);
  469. }
  470.  
  471.  
  472. write_it(ch)
  473. int ch;
  474. {
  475.     struct dmessage msg_buf;
  476.     int i_indx;
  477.  
  478.     if(ch < 0 || ch > 6)
  479.         return;
  480.  
  481.     i_indx = pseg->p[player_indx].items[ch];
  482.  
  483.     if(i_indx < 0 || pseg->itm[i_indx].type != NOTE)
  484.         return;
  485.  
  486.     msg_buf.msg_type = 1L;
  487.     msg_buf.playernum = playernum;
  488.  
  489.     msg_buf.cmd = 'w';
  490.     msg_buf.arg = i_indx;
  491.     get_message(msg_buf.text);
  492.  
  493.     if(msg_buf.text[0] != '\0')
  494.         tell_daemon(&msg_buf);
  495. }
  496.  
  497.  
  498. say_it()
  499. {
  500.     struct dmessage msg_buf;
  501.  
  502.     msg_buf.msg_type = 1L;
  503.     msg_buf.playernum = playernum;
  504.  
  505.     msg_buf.cmd = 's';
  506.     get_message(msg_buf.text);
  507.  
  508.     if(msg_buf.text[0] != '\0')
  509.         tell_daemon(&msg_buf);
  510. }
  511.  
  512.  
  513. get_message(text)
  514. char *text;
  515. {
  516.     char inbuf[35];
  517.     int pos, ch;
  518.  
  519.     pos = 0;
  520.     ch = '\0';
  521.     inbuf[0] = '\0';
  522.     text[0] = '\0';
  523.  
  524.     while(ch != '\n' && ch != '\r') {
  525.         strcpy(gseg->buf, "Message (^R = Recall, ESC = Cancel) : ");
  526.         strcat(gseg->buf, inbuf);
  527.         strcat(gseg->buf, "_");
  528.         tell_viewer();
  529.  
  530.         ch = getchar();
  531.  
  532.         switch(ch) {
  533.         case '\033' :
  534.             inbuf[pos] = '\0';
  535.             gseg->buf[0] = '\0';
  536.             tell_viewer();
  537.             return;
  538.         case '\b' :
  539.             if(pos)
  540.                 pos--;
  541.             inbuf[pos] = '\0';
  542.             break;
  543.         case '\n' :
  544.         case '\r' :
  545.         case '\f' :
  546.         case '\t' :
  547.             break;
  548.         case '\022' :
  549.             strcpy(inbuf, old_buf);
  550.             pos = strlen(inbuf);
  551.             break;
  552.         default :
  553.             if(isprint(ch) && pos < 30) {
  554.                 inbuf[pos++] = ch;
  555.                 inbuf[pos] = '\0';
  556.             }
  557.             break;
  558.         }
  559.     }
  560.  
  561.     gseg->buf[0] = '\0';
  562.     tell_viewer();
  563.  
  564.     strcpy(text, inbuf);
  565.     strcpy(old_buf, inbuf);
  566. }
  567.  
  568.  
  569. int get_amount()
  570. {
  571.     char inbuf[9];
  572.     int pos, ch;
  573.  
  574.     pos = 0;
  575.     ch = '\0';
  576.     inbuf[0] = '\0';
  577.  
  578.     while(ch != '\n' && ch != '\r') {
  579.         sprintf(gseg->buf, "How much? (ESC to cancel): %s_", inbuf);
  580.         tell_viewer();
  581.  
  582.         ch = getchar();
  583.  
  584.         switch(ch) {
  585.         case '\033' :
  586.             gseg->buf[0] = '\0';
  587.             tell_viewer();
  588.             return;
  589.         case '\b' :
  590.             if(pos)
  591.                 pos--;
  592.             inbuf[pos] = '\0';
  593.             break;
  594.         case '\n' :
  595.         case '\r' :
  596.         case '\f' :
  597.         case '\t' :
  598.             break;
  599.         default :
  600.             if(isdigit(ch) && pos < 7) {
  601.                 inbuf[pos++] = ch;
  602.                 inbuf[pos] = '\0';
  603.             }
  604.             break;
  605.         }
  606.     }
  607.  
  608.     return atoi(inbuf);
  609. }
  610.  
  611.  
  612. int get_dir()
  613. {
  614.     switch(tolower(getchar())) {
  615.     case 'h' :
  616.     case '4' :
  617.         return L_WEST;
  618.     case 'j' :
  619.     case '2' :
  620.         return L_SOUTH;
  621.     case 'k' :
  622.     case '8' :
  623.         return L_NORTH;
  624.     case 'l' :
  625.     case '6' :
  626.         return L_EAST;
  627.     case 'y' :
  628.     case '7' :
  629.         return L_NWEST;
  630.     case 'b' :
  631.     case '1' :
  632.         return L_SWEST;
  633.     case 'n' :
  634.     case '3' :
  635.         return L_SEAST;
  636.     case 'u' :
  637.     case '9' :
  638.         return L_NEAST;
  639.     }
  640.  
  641.     return -1;
  642. }
  643.  
  644.  
  645. get_use_dir(indx)
  646. int indx;
  647. {
  648.     if(pseg->itm[indx].type == WEAPON
  649.     || pseg->itm[indx].type == SHIELD
  650.     || pseg->itm[indx].type == ARMOR
  651.     || pseg->itm[indx].type == NOTE)
  652.         return 0;
  653.  
  654.     if(pseg->itm[indx].type == MISSILE) {
  655.         sprintf(gseg->buf, "fire %s which way? (hjkl) ",
  656.             pseg->itm[indx].name);
  657.         tell_viewer();
  658.         return get_dir();
  659.     }
  660.  
  661.     switch(pseg->itm[indx].effect) {
  662.     case TELEPORT :
  663.     case HEALING :
  664.         return 0;
  665.     case FIREBALLS : /* fireball */
  666.     case LIGHTNING : /* lightning */
  667.     case COLD : /* cold */
  668.         sprintf(gseg->buf, "activate %s which way? (hjkl) ",
  669.             pseg->itm[indx].name);
  670.         tell_viewer();
  671.         return get_dir();
  672.     default :
  673.         return 0;
  674.     }
  675. }
  676.  
  677.  
  678. get_spell_text(spell, text)
  679. int spell;
  680. char *text;
  681. {
  682.     switch(spell) {
  683.     case 'w' :
  684.         get_message(text);
  685.         break;
  686.     }
  687. }
  688.  
  689.  
  690. int get_spell_arg(spell)
  691. int spell;
  692. {
  693.     int in_ch, item_indx;
  694.  
  695.     switch(spell) {
  696.     case 'c' : /* cold */
  697.     case 'f' : /* fireball */
  698.     case 'l' : /* lightning */
  699.     case 'm' : /* missile */
  700.     case 'r' : /* death ray */
  701.         sprintf(gseg->buf, "cast %s which way? (hjkl) ",
  702.             spell_names[spell - 'a']);
  703.         tell_viewer();
  704.         return get_dir();
  705.  
  706.     case 'n' : /* nightmare */
  707.     case 's' : /* seek */
  708.     case 'y' : /* yank */
  709.         sprintf(gseg->buf, "%s who? ",
  710.             spell_names[spell - 'a']);
  711.         tell_viewer();
  712.         in_ch = getchar();
  713.         return (isdigit(in_ch) ? in_ch - '1' : -1);
  714.  
  715.     case 'o' : /* obscure */
  716.         strcpy(gseg->buf, "obscure what item? (0-7) ");
  717.         tell_viewer();
  718.         in_ch = getchar() - '0';
  719.         if(in_ch == 0)
  720.             return -1;
  721.         if(in_ch > 0 && in_ch <= PMAX_ITEMS)
  722.             item_indx = find_item(player_indx, in_ch);
  723.         return item_indx;
  724.  
  725.     case 'v' : /* verify */
  726.         strcpy(gseg->buf, "verify what item? (0-7) ");
  727.         tell_viewer();
  728.         in_ch = getchar() - '0';
  729.         if(in_ch == 0)
  730.             return -1;
  731.         if(in_ch > 0 && in_ch <= PMAX_ITEMS)
  732.             item_indx = find_item(player_indx, in_ch);
  733.         return item_indx;
  734.  
  735.     case 'w' : /* whisper */
  736.         strcpy(gseg->buf, "whisper to who? ");
  737.         tell_viewer();
  738.         in_ch = getchar();
  739.         return (isdigit(in_ch) ? in_ch - '1' : -1);
  740.  
  741.     default :
  742.         return 0;
  743.     }
  744. }
  745.  
  746.  
  747. redraw_scr()
  748. {
  749.     gseg->clear_ok = 1;
  750.  
  751.     tell_viewer();
  752. }
  753.  
  754.  
  755. tell_daemon(mptr)
  756. struct dmessage *mptr;
  757. {
  758.     msgsnd(dqid, mptr, DMSGSIZ, IPC_NOWAIT);
  759. }
  760.  
  761.  
  762. tell_viewer()
  763. {
  764.     struct sembuf ops[1];
  765.  
  766.     ops[0].sem_num = player_indx;
  767.     ops[0].sem_op = 1;
  768.     ops[0].sem_flg = 0;
  769.  
  770.     semop(pseg->sid, ops, 1);
  771. }
  772.  
  773.  
  774. int find_item(p_indx, p_item_indx)
  775. int p_indx, p_item_indx;
  776. {
  777.     int i, cnt;
  778.  
  779.     cnt = 0;
  780.  
  781.     if(p_item_indx < 1 || p_item_indx > PMAX_ITEMS)
  782.         return -1;
  783.  
  784.     return pseg->p[p_indx].items[p_item_indx - 1];
  785. }
  786.  
  787.  
  788. get_god_cmd(ch)
  789. int ch;
  790. {
  791.     struct dmessage msg_buf;
  792.     char in_ch;
  793.     int item_indx;
  794.  
  795.     msg_buf.msg_type = 1L;
  796.     msg_buf.playernum = playernum;
  797.     msg_buf.cmd = 'g';
  798.     msg_buf.subcmd = ch;
  799.  
  800.     switch(ch) {
  801.     case 'l' :
  802.         strcpy(gseg->buf, "God Power: r)emember or c)reate? ");
  803.         tell_viewer();
  804.         msg_buf.arg = tolower(getchar());
  805.         if(msg_buf.arg == 'c') {
  806.             strcpy(gseg->buf, "God Power: select link 1-7? ");
  807.             tell_viewer();
  808.             msg_buf.ext_arg = getchar() - '1';
  809.             if(msg_buf.ext_arg > 6 || msg_buf.ext_arg < 0)
  810.                 msg_buf.ext_arg = 0;
  811.         }
  812.         tell_daemon(&msg_buf);
  813.         break;
  814.  
  815.     case 'm' :
  816.         strcpy(gseg->buf, "God Power: which way? (hjkl) ");
  817.         tell_viewer();
  818.         msg_buf.arg = get_dir();
  819.         strcpy(gseg->buf, "God Power: change to what code? ");
  820.         tell_viewer();
  821.         if((msg_buf.ext_arg = getchar()) == '=')
  822.             msg_buf.ext_arg = get_gate();
  823.         tell_daemon(&msg_buf);
  824.         break;
  825.  
  826.     case 's' :
  827.         strcpy(gseg->buf, 
  828.             "God Power: l)evel, j)ump inhibit, i)llumination? ");
  829.         tell_viewer();
  830.         msg_buf.arg = tolower(getchar());
  831.         strcpy(gseg->buf, "God Power: + (more) or - (less)? ");
  832.         msg_buf.ext_arg = getchar();
  833.         tell_daemon(&msg_buf);
  834.         break;
  835.  
  836.     case 't' :
  837.         msg_buf.arg = pseg->p[player_indx].loc.sector;
  838.         get_message(msg_buf.text);
  839.         tell_daemon(&msg_buf);
  840.         break;
  841.  
  842.     case 'r' :
  843.         tell_daemon(&msg_buf);
  844.         break;
  845.  
  846.     case 'i' :
  847.         strcpy(gseg->buf, "God Power: which item? ");
  848.         tell_viewer();
  849.         in_ch = getchar() - '0';
  850.         if((item_indx = find_item(player_indx, in_ch)) < 0)
  851.             break;
  852.         msg_buf.arg = item_indx;
  853.         strcpy(gseg->buf, 
  854.             "God Power: n)ame, r)eveal, a)lter, or c)urse item? ");
  855.         tell_viewer();
  856.         in_ch = tolower(getchar());
  857.  
  858.         if(in_ch == 'a') {
  859.             msg_buf.subcmd = in_ch;
  860.             msg_buf.ext_arg = get_item_stat(item_indx);
  861.             tell_daemon(&msg_buf);
  862.         } else if(in_ch == 'n') {
  863.             msg_buf.subcmd = in_ch;
  864.             get_message(msg_buf.text);
  865.             tell_daemon(&msg_buf);
  866.         } else if(in_ch == 'r') {
  867.             tell_daemon(&msg_buf);
  868.         } else if(in_ch == 'c') {
  869.             msg_buf.subcmd = 'a';
  870.             msg_buf.ext_arg = 'c';
  871.             tell_daemon(&msg_buf);
  872.         }
  873.  
  874.         break;
  875.     }
  876. }
  877.  
  878.  
  879. int get_item_stat(i_indx)
  880. int i_indx;
  881. {
  882.     strcpy(gseg->buf, "God Power: alter v)alue or r)ange? ");
  883.     tell_viewer();
  884.  
  885.     return tolower(getchar());
  886. }
  887.  
  888.  
  889. int get_gate()
  890. {
  891.     strcpy(gseg->buf, "God Power: select gate number 1-7 > ");
  892.     tell_viewer();
  893.  
  894.     switch(getchar()) {
  895.     case '2' :
  896.         return '{';
  897.     case '3' :
  898.         return '}';
  899.     case '4' :
  900.         return ':';
  901.     case '5' :
  902.         return ';';
  903.     case '6' :
  904.         return '-';
  905.     case '7' :
  906.         return '|';
  907.     default :
  908.         return '=';
  909.     }
  910. }
  911.  
  912.  
  913. /* end of file. */
  914.