home *** CD-ROM | disk | FTP | other *** search
/ rtsi.com / 2014.01.www.rtsi.com.tar / www.rtsi.com / OS9 / TOP / USR / SRC / yahtzee.t.Z / yahtzee.t / get_m.c < prev    next >
Text File  |  1988-07-28  |  4KB  |  201 lines
  1. /* get_m.c
  2.  *    contains routine to get the given players hold pattern
  3.  *    for the current dice.
  4.  */
  5. #include <stdio.h>
  6. #include <curses.h>
  7. #include "defs.h"
  8.  
  9. #define NTOP 6
  10.  
  11. extern int machine[max_players], diey[Five_Dice], diex[Five_Dice];
  12. extern int scoreboard[max_players][max_marks];
  13. extern WINDOW *screen;
  14.  
  15. static int human_available[13], human_avail_count;
  16.  
  17. /* call the relevant move routine based on whether player is human or
  18.  * computer simulation */
  19. get_move(player, dice, hold)
  20.  
  21. int player, dice[Five_Dice], hold[Five_Dice];
  22.  
  23.     {
  24.     dis_dice(dice, hold);
  25.     machine[player] ? computer_move(player, dice, hold) :
  26.         human_move(player, dice, hold);
  27.     dis_dice(dice, hold);
  28.     }
  29.  
  30. /* prompt human for which dice to hold */
  31. human_move(player, dice, hold)
  32.  
  33. int player, dice[Five_Dice], hold[Five_Dice];
  34.  
  35.     {
  36.     int i, cur_dice = 0;
  37.     char ch;
  38.  
  39.     do
  40.         {
  41.  
  42. /* put cursor in middle of current dice */
  43.         wmove(screen, diey[cur_dice] + 2, diex[cur_dice] + 4);
  44. #ifndef SYS5_3
  45.  
  46. /* System 5.3 Curses performs better if it isn't forced to refresh
  47.  * directly before a getch */
  48.         wrefresh(screen);
  49. #endif
  50.  
  51. /* get user input */
  52.         ch = wgetch(screen);
  53.         switch(ch)
  54.             {
  55.  
  56. /* toggles dice between held and free */
  57.             case ' ' : hold[cur_dice] = ! hold[cur_dice];
  58.                    dis_dice(dice, hold);
  59.                    ++cur_dice;
  60.                    cur_dice = wrap(cur_dice, 0, 4);
  61.                    break;
  62.  
  63. /* move cursor left */
  64.             case 'h' : --cur_dice;
  65.                    cur_dice = wrap(cur_dice, 0, 4);
  66.                    break;
  67.  
  68. /* move cursor right */
  69.             case 'l' : ++cur_dice;
  70.                    cur_dice = wrap(cur_dice, 0, 4);
  71.                    break;
  72.  
  73. /* hold all dice and quit this procedure by setting ch to
  74.  * loop termination character */
  75.             case 'a' : for (i = 0; i < Five_Dice; ++i)
  76.                     hold[i] = TRUE;
  77.                    ch = '\n';
  78.                    break;
  79.  
  80. /* human player request for computer simulation recommendation */
  81.             case 'r' : computer_move(player, dice, hold);
  82.                    dis_dice(dice, hold);
  83.                    break;
  84.  
  85. /* display score that can be obtained with the current dice */
  86.             case 't' : dice_values(screen, player, dice);
  87.                    break;
  88.  
  89.             case 'q' : dis_score((WINDOW *) 0);
  90.                    yahtzee_exit(0);
  91.                    break;
  92.             case '?' : help_out(2, screen);
  93.                    break;
  94.             case 's' : dis_score(screen);
  95.                    break;
  96.             case Form_Feed : redraw(screen);
  97.                    break;
  98.             case 'b' : rools(screen);
  99.                    break;
  100.             case '!' : shell(screen);
  101.                    break;
  102.             case 'v' : version(screen);
  103.                    break;
  104. #if defined(SYS5) || defined(SYS5_3)
  105.             case '$' : shwin(screen);
  106.                    break;
  107.             case '\n' : break;
  108.             default : flash();
  109.                   break;
  110. #endif
  111.             }
  112.         } while (ch != '\n');
  113.     }
  114.  
  115. extern char side[sidey][sidex];
  116.  
  117. /* select which category to place the dice */
  118. int human_select(player, dice)
  119.  
  120. int player, dice[Five_Dice];
  121.  
  122.     {
  123.     int side_no = 0, best;
  124.     char ch;
  125.  
  126.     do
  127.         {
  128.         wmove(screen, human_available[side_no] + NTOP, 0);
  129. #ifndef SYS5_3
  130.         wrefresh(screen);
  131. #endif
  132.         ch = wgetch(screen);
  133.         switch(ch)
  134.             {
  135.  
  136. /* move up one category */
  137.             case 'k' : --side_no;
  138.                    side_no = wrap(side_no, 0,
  139.                     human_avail_count - 1);
  140.                    break;
  141.  
  142. /* move down one category */
  143.             case 'j' : ++side_no;
  144.                    side_no = wrap(side_no, 0,
  145.                     human_avail_count - 1);
  146.                    break;
  147.  
  148. /* get computer's recommendation of best category */
  149.             case 'r' : best = computer_select(player, dice,
  150.                     human_available, human_avail_count);
  151.                    side_no = 0;
  152.                    while (side_no < human_avail_count &&
  153.                     human_available[side_no] != best)
  154.                     ++side_no;
  155.                    break;
  156.  
  157. /* display score that can be obtained with the current dice */
  158.             case 't' : dice_values(screen, player, dice);
  159.                    break;
  160.  
  161.             case 'q' : dis_score((WINDOW *) 0);
  162.                    yahtzee_exit(0);
  163.                    break;
  164.             case '?' : help_out(3, screen);
  165.                    break;
  166.             case 's' : dis_score(screen);
  167.                    break;
  168.             case Form_Feed : redraw(screen);
  169.                    break;
  170.             case 'b' : rools(screen);
  171.                    break;
  172.             case '!' : shell(screen);
  173.                    break;
  174.             case 'v' : version(screen);
  175.                    break;
  176. #if defined(SYS5) || defined(SYS5_3)
  177.             case '$' : shwin(screen);
  178.                    break;
  179.             case '\n' : break;
  180.             default : flash();
  181.                   break;
  182. #endif
  183.             }
  184.         } while (ch != '\n');
  185.     return(human_available[side_no]);
  186.     }
  187.  
  188. /* form the list of categories available to the given player */
  189. human_availability(player)
  190.  
  191. int player;
  192.  
  193.     {
  194.     int i;
  195.  
  196.     human_avail_count = 0;
  197.     for (i = 1; i < 14; ++i)
  198.         if (scoreboard[player][i] == category_available)
  199.             human_available[human_avail_count++] = i;
  200.     }
  201.