home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / games / volume2 / umoria / part15 / io.c next >
C/C++ Source or Header  |  1987-11-05  |  9KB  |  497 lines
  1. #include <curses.h>
  2. #ifdef USG
  3. #include <string.h>
  4. #else
  5. #include <strings.h>
  6. #include <sgtty.h>
  7. #include <sys/wait.h>
  8. #endif
  9. #include <sys/types.h>
  10. #include <sys/ioctl.h>
  11. #include <sys/file.h>
  12.  
  13. #include "constants.h"
  14. #include "types.h"
  15. #include "externs.h"
  16.  
  17. #ifdef sun   /* correct SUN stupidity in the stdio.h file */
  18. char *sprintf();
  19. #endif
  20.  
  21. vtype pad_output;   /* static output string for the pad function */
  22.  
  23. char *getenv();
  24.  
  25. #ifdef USG
  26. void exit();
  27. unsigned sleep();
  28. #endif
  29. #ifdef ultrix
  30. void exit();
  31. void sleep();
  32. #endif
  33.  
  34. #ifdef USG
  35. /* no local special characters */
  36. #else
  37. struct ltchars save_special_chars;
  38. #endif
  39.  
  40. /* initializes curses routines */
  41. init_curses()
  42. {
  43. #ifdef USG
  44.   /* no local special characters */
  45. #else
  46.   struct ltchars buf;
  47. #endif
  48.  
  49. #ifdef USG
  50.   if (initscr() == NULL)
  51. #else
  52.   if (initscr() == ERR)
  53. #endif
  54.     {
  55.       (void) printf("error allocating screen in curses package\n");
  56.       exit_game();
  57.     }
  58.   clear();
  59. #ifdef USG
  60.   saveterm();
  61. #endif
  62. #ifdef ultrix
  63.   crmode();
  64. #else
  65.   cbreak();
  66. #endif
  67.   noecho();
  68. #ifndef BUGGY_CURSES
  69.   nonl();
  70. #endif
  71.   /* save old settings of the local special characters */
  72. #ifdef USG
  73.   /* no local special characters */
  74. #else
  75.   (void) ioctl(0, TIOCGLTC, (char *)&save_special_chars);
  76.   /* disable all of the local special characters except the suspend char */
  77.   /* have to disable ^Y for tunneling */
  78.   buf.t_suspc = (char)26;  /* control-Z */
  79.   buf.t_dsuspc = (char)-1;
  80.   buf.t_rprntc = (char)-1;
  81.   buf.t_flushc = (char)-1;
  82.   buf.t_werasc = (char)-1;
  83.   buf.t_lnextc = (char)-1;
  84.   (void) ioctl(0, TIOCSLTC, (char *)&buf);
  85. #endif
  86. }
  87.  
  88.  
  89. /* Dump IO to buffer                    -RAK-    */
  90. put_buffer(out_str, row, col)
  91. char *out_str;
  92. int row, col;
  93. {
  94.   vtype tmp_str;
  95.  
  96.   if (mvaddstr(row, col, out_str) == ERR)
  97.     {
  98.       (void) sprintf(tmp_str, "error row = %d col = %d\n", row, col);
  99.       prt(tmp_str, 0, 0);
  100.       (void) sleep(2);
  101.     }
  102.   refresh();
  103. }
  104.  
  105.  
  106. /* Dump the IO buffer to terminal            -RAK-    */
  107. /* NOTE: Source is PUTQIO.MAR                    */
  108. put_qio()
  109. {
  110.   refresh();
  111. }
  112.  
  113.  
  114. shell_out()
  115. {
  116.   int val;
  117.   char *str;
  118. #ifdef USG
  119.   /* no local special characters */
  120. #else
  121.   struct ltchars buf;
  122. #endif
  123.  
  124. #ifndef BUGGY_CURSES
  125.   nl();
  126. #endif
  127. #ifdef ultrix
  128.   nocrmode();
  129. #else
  130.   nocbreak();
  131. #endif
  132.   echo();
  133.   val = fork();
  134.   if (val == 0)
  135.     {
  136. #ifdef USG
  137.       /* no local special characters */
  138.       resetterm();
  139. #else
  140.       (void) ioctl(0, TIOCSLTC, (char *)&save_special_chars);
  141. #endif
  142.       if (str = getenv("SHELL"))
  143.     (void) execl(str, str, (char *) 0);
  144.       else
  145.     (void) execl("/bin/sh", "sh", (char *) 0);
  146.       msg_print("Cannot execute shell");
  147.       exit(1);
  148.     }
  149.   if (val == -1)
  150.     {
  151.       msg_print("Fork failed. Try again.");
  152.       return;
  153.     }
  154. #ifdef USG
  155.   (void) wait((int *) 0);
  156. #else
  157.   (void) wait((union wait *) 0);
  158. #endif
  159.   really_clear_screen();
  160. #ifdef ultrix
  161.   crmode();
  162. #else
  163.   cbreak();
  164. #endif
  165.   noecho();
  166. #ifndef BUGGY_CURSES
  167.   nonl();
  168. #endif
  169.   /* disable all of the local special characters except the suspend char */
  170.   /* have to disable ^Y for tunneling */
  171. #ifdef USG
  172.   /* no local special characters */
  173. #else
  174.   buf.t_suspc = (char)26;  /* control-Z */
  175.   buf.t_dsuspc = (char)-1;
  176.   buf.t_rprntc = (char)-1;
  177.   buf.t_flushc = (char)-1;
  178.   buf.t_werasc = (char)-1;
  179.   buf.t_lnextc = (char)-1;
  180.   (void) ioctl(0, TIOCSLTC, (char *)&buf);
  181. #endif
  182. }
  183.  
  184. exit_game()
  185. {
  186.   /* restore the saved values of the local special chars */
  187.   put_qio();    /* Dump any remaining buffer    */
  188.   endwin();     /* exit curses */
  189.   echo();
  190. #ifndef BUGGY_CURSES
  191.   nl();
  192. #endif
  193. #ifdef ultrix
  194.   nocrmode();
  195. #else
  196.   nocbreak();
  197. #endif
  198. #ifdef USG
  199.   /* no local special characters */
  200.   resetterm();
  201. #else
  202.   (void) ioctl(0, TIOCSLTC, (char *)&save_special_chars);
  203. #endif
  204.   exit(0);    /* exit from game        */
  205. }
  206.  
  207.  
  208. /* Gets single character from keyboard and returns        */
  209. inkey(ch)
  210. char *ch;
  211. {
  212.   put_qio();            /* Dump IO buffer        */
  213.   *ch = getch();
  214.   msg_flag = FALSE;
  215. }
  216.  
  217.  
  218. /* Flush the buffer                    -RAK-    */
  219. flush()
  220. {
  221. #ifdef USG
  222.   (void) ioctl(0, TCFLSH, 0);  /* flush the input queue */
  223. #else
  224.   int arg;
  225.  
  226.   arg = FREAD;
  227.   (void) ioctl(0, TIOCFLUSH, (char *)&arg);   /* flush all input */
  228. #endif
  229.  
  230.   /* Now flush                */
  231.   refresh();
  232. }
  233.  
  234.  
  235. /* Flush buffer before input                -RAK-    */
  236. inkey_flush(x)
  237. char *x;
  238. {
  239.   put_qio();    /* Dup the IO buffer    */
  240.   if (!wizard1)  flush();
  241.   inkey(x);
  242. }
  243.  
  244.  
  245. /* Clears given line of text                -RAK-    */
  246. erase_line(row, col)
  247. int row;
  248. int col;
  249. {
  250.   move(row, col);
  251.   clrtoeol();
  252.   refresh();
  253. }
  254.  
  255.  
  256. /* Clears screen at given row, column                */
  257. clear_screen(row, col)
  258. int row, col;
  259. {
  260.   int i;
  261.  
  262.   for (i = 1; i <= 23; i++)
  263.     used_line[i] = FALSE;
  264.   move(row, col);
  265.   clrtobot();
  266.   put_qio();    /* Dump the Clear Sequence    */
  267.   msg_flag = FALSE;
  268. }
  269.  
  270.  
  271. /* Clears entire screen, even if there are characters that curses
  272.    does not know about */
  273. really_clear_screen()
  274. {
  275.   int i;
  276.  
  277.   for (i = 1; i <= 23; i++)
  278.     used_line[i] = FALSE;
  279.   clear();
  280.   put_qio();    /* Dump the Clear Sequence    */
  281.   msg_flag = FALSE;
  282. }
  283.  
  284.  
  285. /* Outputs a line to a given interpolated y, x position    -RAK-    */
  286. print(str_buff, row, col)
  287. char *str_buff;
  288. int row;
  289. int col;
  290. {
  291.   row -= panel_row_prt;/* Real co-ords convert to screen positions */
  292.   col -= panel_col_prt;
  293.   used_line[row] = TRUE;
  294.   put_buffer(str_buff, row, col);
  295. }
  296.  
  297.  
  298. /* Outputs a line to a given y, x position        -RAK-    */
  299. prt(str_buff, row, col)
  300. char *str_buff;
  301. int row;
  302. int col;
  303. {
  304.   move(row, col);
  305.   clrtoeol();
  306.   put_buffer(str_buff, row, col);
  307. }
  308.  
  309.  
  310. /* Outputs message to top line of screen                */
  311. msg_print(str_buff)
  312. char *str_buff;
  313. {
  314.   int old_len;
  315.   char in_char;
  316.  
  317.   if (msg_flag) 
  318.     {
  319.       old_len = strlen(old_msg) + 1;
  320.       put_buffer(" -more-", msg_line, old_len);
  321.       do
  322.     {
  323.       inkey(&in_char);
  324.     }
  325.       while ((in_char != ' ') && (in_char != '\033'));
  326.     }
  327.   move(msg_line, msg_line);
  328.   clrtoeol();
  329.   put_buffer(str_buff, msg_line, msg_line);
  330.   (void) strcpy(old_msg, str_buff);
  331.   msg_flag = TRUE;
  332. }
  333.  
  334.  
  335. /* Prompts (optional) and returns ord value of input char    */
  336. /* Function returns false if <ESCAPE> is input    */
  337. get_com(prompt, command)
  338. char *prompt;
  339. char *command;
  340. {
  341.   int com_val;
  342.   int res;
  343.  
  344.   if (strlen(prompt) > 1)
  345.     prt(prompt, 0, 0);
  346.   inkey(command);
  347.   com_val = (*command);
  348.   switch(com_val)
  349.     {
  350.     case 27:
  351.       res = FALSE;
  352.       break;
  353.     default:
  354.       res = TRUE;
  355.       break;
  356.     }
  357.   erase_line(msg_line, msg_line);
  358.   msg_flag = FALSE;
  359.   return(res);
  360. }
  361.  
  362.  
  363. /* Gets a string terminated by <RETURN>                */
  364. /* Function returns false if <ESCAPE>, CNTL/(Y, C, Z) is input    */
  365. int get_string(in_str, row, column, slen)
  366. char *in_str;
  367. int row, column, slen;
  368. {
  369.   int start_col, end_col, i;
  370.   char x;
  371.   vtype tmp;
  372.   int flag, abort;
  373.  
  374.   abort = FALSE;
  375.   flag  = FALSE;
  376.   in_str[0] = '\0';
  377.   put_buffer(pad(in_str, " ", slen), row, column);
  378.   put_buffer("\0", row, column);
  379.   start_col = column;
  380.   end_col = column + slen - 1;
  381.   do
  382.     {
  383.       inkey(&x);
  384.       switch(x)
  385.     {
  386.     case 27:
  387.       abort = TRUE;
  388.       break;
  389.     case 10: case 13:
  390.       flag  = TRUE;
  391.       break;
  392.     case 127: case 8:
  393.       if (column > start_col) 
  394.         {
  395.           column--;
  396.           put_buffer(" \b", row, column);
  397.           in_str[strlen(in_str)-1] = '\0';
  398.         }
  399.       break;
  400.     default:
  401.       (void) sprintf(tmp, "%c", x);
  402.       put_buffer(tmp, row, column);
  403.       (void) strcat(in_str, tmp);
  404.       column++;
  405.       if (column > end_col) 
  406.         flag = TRUE;
  407.       break;
  408.     }
  409.     }
  410.   while ((!flag) && (!abort));
  411.   if (abort) 
  412.     return(FALSE);
  413.   else
  414.     {            /* Remove trailing blanks    */
  415.       i = strlen(in_str);
  416.       if (i > 0)
  417.     {
  418.       while ((in_str[i] == ' ') && (i > 0))
  419.         i--;
  420.       in_str[i+1] = '\0';
  421.     }
  422.     }
  423.   return(TRUE);
  424. }
  425.  
  426.  
  427. /* Return integer value of hex string            -RAK-    */
  428. int get_hex_value(row, col, slen)
  429. int row, col, slen;
  430. {
  431.   vtype tmp_str;
  432.   int hex_value;
  433.  
  434.   hex_value = 0;
  435.   if (get_string(tmp_str, row, col, slen)) 
  436.     if (strlen(tmp_str) <= 8) 
  437.       {
  438.     (void) sscanf(tmp_str, "%x", &hex_value);
  439.       }
  440.   return(hex_value);
  441. }
  442.  
  443.  
  444. /* Pauses for user response before returning        -RAK-    */
  445. pause_line(prt_line)
  446. int prt_line;
  447. {
  448.   char dummy;
  449.  
  450.   prt("[Press any key to continue]", prt_line, 23);
  451.   inkey(&dummy);
  452.   erase_line(23, 0);
  453. }
  454.  
  455.  
  456. /* Pauses for user response before returning        -RAK-    */
  457. /* NOTE: Delay is for players trying to roll up "perfect"    */
  458. /*    characters.  Make them wait a bit...            */
  459. pause_exit(prt_line, delay)
  460. int prt_line;
  461. int delay;
  462. {
  463.   char dummy;
  464.  
  465.   prt("[Press any key to continue, or ESC to exit]", prt_line, 10);
  466.   inkey(&dummy);
  467.   switch(dummy)
  468.     {
  469.     case 27:
  470.       erase_line(prt_line, 0);
  471.       if (delay > 0)  (void) sleep((unsigned)delay);
  472.       exit_game();
  473.       break;
  474.     default:
  475.       break;
  476.     }
  477.   erase_line(prt_line, 0);
  478. }
  479.  
  480.  
  481. /* pad a string with fill characters to specified length */
  482. char *pad(string, fill, filllength)
  483. char *string;
  484. char *fill;
  485. int filllength;
  486. {
  487.   int length;
  488.   int i;
  489.  
  490.   (void) strcpy(pad_output, string);
  491.   length = strlen(pad_output);
  492.   for (i = length; i < filllength; i++)
  493.     pad_output[i] = *fill;
  494.   pad_output[i] = '\0';
  495.   return(pad_output);
  496. }
  497.