home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format 115 / af115sub.adf / yahzee.lzx / yahzee / rules.c < prev    next >
C/C++ Source or Header  |  1998-06-03  |  11KB  |  441 lines
  1. /*
  2.  * rules.c
  3.  * =======
  4.  * Definition of game rules.
  5.  *
  6.  * Copyright (C) 1994-1998 Håkan L. Younes (lorens@hem.passagen.se)
  7.  */
  8.  
  9. #include <string.h>
  10. #include <exec/types.h>
  11. #include "localize.h"
  12. #include "game.h"
  13. #include "rules.h"
  14.  
  15.  
  16. const UBYTE   label_msg[] = {
  17.    MSG_ACES_LABEL, MSG_TWOS_LABEL, MSG_THREES_LABEL, MSG_FOURS_LABEL,
  18.    MSG_FIVES_LABEL, MSG_SIXES_LABEL, MSG_UPPERTOTAL_LABEL, MSG_BONUS_LABEL,
  19.    MSG_ONEPAIR_LABEL, MSG_TWOPAIRS_LABEL, MSG_THREEPAIRS_LABEL,
  20.    MSG_THREEKIND_LABEL, MSG_FOURKIND_LABEL, MSG_FIVEKIND_LABEL,
  21.    MSG_SMSTRAIGHT_LABEL, MSG_LGSTRAIGHT_LABEL, MSG_FULLSTRAIGHT_LABEL,
  22.    MSG_FULLHOUSE_LABEL, MSG_HOUSE_LABEL, MSG_TOWER_LABEL, MSG_CHANCE_LABEL,
  23.    MSG_YAHZEE_LABEL, MSG_TOTAL_LABEL, MSG_SAVEDROLLS_LABEL
  24. };
  25.  
  26.  
  27. static void calc_trad_original (UBYTE dice[], UBYTE score[]);
  28. static void calc_amer_original (UBYTE dice[], UBYTE score[]);
  29. static void calc_trad_maxi (UBYTE dice[], UBYTE score[]);
  30. static void calc_amer_maxi (UBYTE dice[], UBYTE score[]);
  31.  
  32. const game   game_definition[MAX_GAMETYPES] = {
  33.    {  {  { 1, 1, 1, 1, 1, 1, 1, 1,
  34.            1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0 },
  35.          5, calc_trad_original, 63, 50, MSG_YAHZEE_LABEL },
  36.       {  { 1, 1, 1, 1, 1, 1, 1, 1,
  37.            0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0 },
  38.          5, calc_amer_original, 63, 35, MSG_YAHZEE_LABEL } },
  39.    {  {  { 1, 1, 1, 1, 1, 1, 1, 1,
  40.            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
  41.          6, calc_trad_maxi, 84, 100, MSG_MAXIYAHZEE_LABEL },
  42.       {  { 1, 1, 1, 1, 1, 1, 1, 1,
  43.            0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
  44.          6, calc_amer_maxi, 84, 70, MSG_MAXIYAHZEE_LABEL } }
  45. };
  46.  
  47.  
  48. static void
  49. calc_trad_original (
  50.    UBYTE   dice[],
  51.    UBYTE   score[])
  52. {
  53.    UBYTE   kind_count[6];
  54.    register UBYTE   n;
  55.    register UBYTE   pair1 = 0, pair2 = 0, tripple = 0;
  56.    
  57.    /* initialize kind_count and calculate chance */
  58.    score[CHANCE] = 0;
  59.    for (n = 0; n < 6; ++n)
  60.       kind_count[n] = 0;
  61.    for (n = 0; n < 5; ++n)
  62.    {
  63.       score[CHANCE] += dice[n];
  64.       ++kind_count[dice[n] - 1];
  65.    }
  66.    
  67.    score[FOUR_OF_A_KIND] = 0;
  68.    score[YAHZEE] = 0;
  69.    /* aces, twos, threes, fours, fives, sixes, 4 of a kind and yahzee */
  70.    for (n = 0; n < 6; ++n)
  71.    {
  72.       score[n] = kind_count[n] * (n + 1);
  73.       if (kind_count[n] >= 4)
  74.          score[FOUR_OF_A_KIND] = 4 * (n + 1);
  75.       if (kind_count[n] == 5)
  76.          score[YAHZEE] = 50;
  77.    }
  78.    
  79.    /* small and large straight */
  80.    for (n = 1; n < 6 && kind_count[n] == 1; ++n)
  81.       ;
  82.    score[SM_STRAIGHT] = (n == 5) ? 15 : 0;
  83.    score[LG_STRAIGHT] = (n == 6) ? 20 : 0;
  84.    
  85.    /* 1 pair, 2 pairs, 3 of a kind and full house */
  86.    for (n = 0; n < 6; ++n)
  87.    {
  88.       if (kind_count[n] >= 2)
  89.       {
  90.          if (pair1)
  91.             pair2 = n + 1;
  92.          else
  93.             pair1 = n + 1;
  94.       }
  95.       if (kind_count[n] >= 3)
  96.       {
  97.          tripple = n + 1;
  98.          if (pair1 == tripple)
  99.          {
  100.             pair1 = pair2;
  101.             pair2 = tripple;
  102.          }
  103.       }
  104.    }
  105.    score[ONE_PAIR] = (pair1 > pair2) ? 2 * pair1 : 2 * pair2;
  106.    score[TWO_PAIRS] = (pair1 && pair2) ? 2 * (pair1 + pair2) : 0;
  107.    score[THREE_OF_A_KIND] = 3 * tripple;
  108.    score[FULL_HOUSE] = (pair1 && tripple) ? 2 * pair1 + 3 * tripple : 0;
  109. }
  110.  
  111. static void
  112. calc_amer_original (
  113.    UBYTE   dice[],
  114.    UBYTE   score[])
  115. {
  116.    UBYTE   kind_count[6];
  117.    register UBYTE   n, straight = 0;
  118.    register UBYTE   pair1 = 0, pair2 = 0, tripple = 0;
  119.    
  120.    /* initialize kind_count and calculate chance */
  121.    score[CHANCE] = 0;
  122.    for (n = 0; n < 6; ++n)
  123.       kind_count[n] = 0;
  124.    for (n = 0; n < 5; ++n)
  125.    {
  126.       score[CHANCE] += dice[n];
  127.       ++kind_count[dice[n] - 1];
  128.    }
  129.    
  130.    score[FOUR_OF_A_KIND] = 0;
  131.    score[YAHZEE] = 0;
  132.    /* aces, twos, threes, fours, fives, sixes, 4 of a kind and yahzee */
  133.    for (n = 0; n < 6; ++n)
  134.    {
  135.       score[n] = kind_count[n] * (n + 1);
  136.       if (kind_count[n] >= 4)
  137.          score[FOUR_OF_A_KIND] = score[CHANCE];
  138.       if (kind_count[n] == 5)
  139.          score[YAHZEE] = 50;
  140.    }
  141.    
  142.    /* small and large straight */
  143.    score[SM_STRAIGHT] = 0;
  144.    score[LG_STRAIGHT] = 0;
  145.    for (n = 0; n < 6; ++n)
  146.    {
  147.       if (kind_count[n] == 0)
  148.          straight = 0;
  149.       else
  150.          ++straight;
  151.       if (straight == 4)
  152.          score[SM_STRAIGHT] = 30;
  153.       if (straight == 5)
  154.          score[LG_STRAIGHT] = 40;
  155.    }
  156.    
  157.    /* 3 of a kind and full house */
  158.    for (n = 0; n < 6; ++n)
  159.    {
  160.       if (kind_count[n] >= 2)
  161.       {
  162.          if (pair1)
  163.             pair2 = n + 1;
  164.          else
  165.             pair1 = n + 1;
  166.       }
  167.       if (kind_count[n] >= 3)
  168.       {
  169.          tripple = n + 1;
  170.          if (pair1 == tripple)
  171.          {
  172.             pair1 = pair2;
  173.             pair2 = tripple;
  174.          }
  175.       }
  176.    }
  177.    score[THREE_OF_A_KIND] = (tripple) ? score[CHANCE] : 0;
  178.    score[FULL_HOUSE] = (pair1 && tripple) ? 25 : 0;
  179. }
  180.  
  181. static void
  182. calc_trad_maxi (
  183.    UBYTE   dice[],
  184.    UBYTE   score[])
  185. {
  186.    UBYTE   kind_count[6];
  187.    register UBYTE   n;
  188.    register UBYTE   pair[3] = { 0, 0, 0 };
  189.    register UBYTE   tripple1 = 0, tripple2 = 0, quad = 0;
  190.    
  191.    /* initialize kind_count and calculate chance */
  192.    score[CHANCE] = 0;
  193.    for (n = 0; n < 6; ++n)
  194.       kind_count[n] = 0;
  195.    for (n = 0; n < 6; ++n)
  196.    {
  197.       score[CHANCE] += dice[n];
  198.       ++kind_count[dice[n] - 1];
  199.    }
  200.    
  201.    score[FIVE_OF_A_KIND] = 0;
  202.    score[YAHZEE] = 0;
  203.    /* aces, twos, threes, fours, fives, sixes, 5 of a kind and yahzee */
  204.    for (n = 0; n < 6; ++n)
  205.    {
  206.       score[n] = kind_count[n] * (n + 1);
  207.       if (kind_count[n] >= 5)
  208.          score[FIVE_OF_A_KIND] = 5 * (n + 1);
  209.       if (kind_count[n] == 6)
  210.          score[YAHZEE] = 100;
  211.    }
  212.    
  213.    /* small, large and full straight */
  214.    for (n = 1; n < 6 && kind_count[n] >= 1; ++n)
  215.       ;
  216.    score[SM_STRAIGHT] = (n >= 5 && kind_count[0] >= 1) ? 15 : 0;
  217.    score[LG_STRAIGHT] = (n == 6) ? 20 : 0;
  218.    score[FULL_STRAIGHT] = (n == 6 && kind_count[0] >= 1) ? 21 : 0;
  219.    
  220.    /* 1 pair, 2 pairs, 3 pairs, 3 of a kind, 4 of a kind, */
  221.    /* full house, house and tower                         */
  222.    for (n = 0; n < 6; ++n)
  223.    {
  224.       if (kind_count[n] >= 2)
  225.       {
  226.          if (pair[1])
  227.             pair[2] = n + 1;
  228.          else if (pair[0])
  229.             pair[1] = n + 1;
  230.          else
  231.             pair[0] = n + 1;
  232.       }
  233.       if (kind_count[n] >= 3)
  234.       {
  235.          if (tripple1)
  236.             tripple2 = n + 1;
  237.          else
  238.             tripple1 = n + 1;
  239.       }
  240.       if (kind_count[n] >= 4)
  241.          quad = n + 1;
  242.    }
  243.    score[ONE_PAIR] = 2 * pair[0];
  244.    for (n = 1; n <= 2; ++n)
  245.       if (pair[n])
  246.          score[ONE_PAIR] = 2 * pair[n];
  247.    score[TWO_PAIRS] = (pair[1]) ? ((pair[2]) ? 2 * (pair[2] + pair[1]) :
  248.                                                2 * (pair[0] + pair[1])) : 0;
  249.    score[THREE_PAIRS] = (pair[2]) ? 2 * (pair[0] + pair[1] + pair[2]) : 0;
  250.    score[THREE_OF_A_KIND] = (tripple2) ? 3 * tripple2 : 3 * tripple1;
  251.    score[FOUR_OF_A_KIND] = 4 * quad;
  252.    score[FULL_HOUSE] = 0;
  253.    if (score[THREE_OF_A_KIND])
  254.       for (n = 0; n <= 2; ++n)
  255.          if (pair[n] && pair[n] != score[THREE_OF_A_KIND] / 3)
  256.                score[FULL_HOUSE] = 2 * pair[n] + score[THREE_OF_A_KIND];
  257.    score[HOUSE] = (tripple2) ? 3 * (tripple1 + tripple2) : 0;
  258.    score[TOWER] = 0;
  259.    if (quad)
  260.       for (n = 0; n <= 2; ++n)
  261.          if (pair[n] && pair[n] != quad)
  262.             score[TOWER] = 2 * pair[n] + 4 * quad;
  263. }
  264.  
  265. static void
  266. calc_amer_maxi (
  267.    UBYTE   dice[],
  268.    UBYTE   score[])
  269. {
  270.    UBYTE   kind_count[6];
  271.    register UBYTE   n, straight = 0;
  272.    register UBYTE   pair[3] = { 0, 0, 0 };
  273.    register UBYTE   tripple1 = 0, tripple2 = 0, quad = 0;
  274.    
  275.    /* initialize kind_count and calculate chance */
  276.    score[CHANCE] = 0;
  277.    for (n = 0; n < 6; ++n)
  278.       kind_count[n] = 0;
  279.    for (n = 0; n < 6; ++n)
  280.    {
  281.       score[CHANCE] += dice[n];
  282.       ++kind_count[dice[n] - 1];
  283.    }
  284.    
  285.    score[FIVE_OF_A_KIND] = 0;
  286.    score[YAHZEE] = 0;
  287.    /* aces, twos, threes, fours, fives, sixes, 5 of a kind and yahzee */
  288.    for (n = 0; n < 6; ++n)
  289.    {
  290.       score[n] = kind_count[n] * (n + 1);
  291.       if (kind_count[n] >= 5)
  292.          score[FIVE_OF_A_KIND] = score[CHANCE];
  293.       if (kind_count[n] == 6)
  294.          score[YAHZEE] = 100;
  295.    }
  296.    
  297.    /* small, large and full straight */
  298.    score[SM_STRAIGHT] = 0;
  299.    score[LG_STRAIGHT] = 0;
  300.    score[FULL_STRAIGHT] = 0;
  301.    for (n = 0; n < 6; ++n)
  302.    {
  303.       if (kind_count[n] == 0)
  304.          straight = 0;
  305.       else
  306.          ++straight;
  307.       if (straight == 4)
  308.          score[SM_STRAIGHT] = 30;
  309.       if (straight == 5)
  310.          score[LG_STRAIGHT] = 40;
  311.       if (straight == 6)
  312.          score[FULL_STRAIGHT] = 50;
  313.    }
  314.    
  315.    /* 3 of a kind, 4 of a kind, full house, house, tower */
  316.    for (n = 0; n < 6; ++n)
  317.    {
  318.       if (kind_count[n] >= 2)
  319.       {
  320.          if (pair[1])
  321.             pair[2] = n + 1;
  322.          else if (pair[0])
  323.             pair[1] = n + 1;
  324.          else
  325.             pair[0] = n + 1;
  326.       }
  327.       if (kind_count[n] >= 3)
  328.       {
  329.          if (tripple1)
  330.             tripple2 = n + 1;
  331.          else
  332.             tripple1 = n + 1;
  333.       }
  334.       if (kind_count[n] >= 4)
  335.          quad = n + 1;
  336.    }
  337.    score[THREE_OF_A_KIND] = (tripple2 || tripple1) ? score[CHANCE] : 0;
  338.    score[FOUR_OF_A_KIND] = (quad) ? score[CHANCE] : 0;
  339.    score[FULL_HOUSE] = 0;
  340.    if (tripple1)
  341.       for (n = 0; n <= 2; ++n)
  342.          if (pair[n] && pair[n] != ((tripple2) ? tripple2 : tripple1))
  343.                score[FULL_HOUSE] = 25;
  344.    score[HOUSE] = (tripple2) ? 30 : 0;
  345.    score[TOWER] = 0;
  346.    if (quad)
  347.       for (n = 0; n <= 2; ++n)
  348.          if (pair[n] && pair[n] != quad)
  349.             score[TOWER] = 35;
  350. }
  351.  
  352. static UBYTE
  353. num_labels (
  354.    struct rules  *rules)
  355. {
  356.    register UBYTE   n, count = 0;
  357.    
  358.    for (n = 0; n < MAX_LABELS; ++n)
  359.       if (rules->labels[n])
  360.          ++count;
  361.    
  362.    return count;
  363. }
  364.  
  365.  
  366. UBYTE
  367. game_number (
  368.    struct rules  *rules)
  369. {
  370.    if (rules == &game_definition[1][1])
  371.       return 3;
  372.    else if (rules == &game_definition[1][0])
  373.       return 2;
  374.    else if (rules == &game_definition[0][1])
  375.       return 1;
  376.    else
  377.       return 0;
  378. }
  379.  
  380. UBYTE
  381. num_upper_labels (
  382.    struct rules  *rules)
  383. {
  384.    return (UBYTE)(num_labels (rules) / 2);
  385. }
  386.  
  387. UBYTE
  388. num_lower_labels (
  389.    struct rules  *rules)
  390. {
  391.    return (UBYTE)(num_labels (rules) - num_upper_labels (rules));
  392. }
  393.  
  394. UBYTE
  395. upper_label_len (
  396.    struct rules  *rules)
  397. {
  398.    UBYTE   label_len = 0, temp, limit;
  399.    register UBYTE   n;
  400.    
  401.    limit = num_upper_labels (rules);
  402.    for (n = 0; n < limit; ++n)
  403.    {
  404.       if (!rules->labels[n])
  405.          ++limit;
  406.       else
  407.       {
  408.          temp = strlen (localized_string (label_msg[n]));
  409.          if (temp > label_len)
  410.             label_len = temp;
  411.       }
  412.    }
  413.    
  414.    return label_len;
  415. }
  416.  
  417. UBYTE
  418. lower_label_len (
  419.    struct rules  *rules)
  420. {
  421.    UBYTE   label_len = 0, temp, limit;
  422.    register UBYTE   n;
  423.    
  424.    limit = num_upper_labels (rules);
  425.    for (n = 0; n < limit; ++n)
  426.       if (!rules->labels[n])
  427.          ++limit;
  428.    for (n = limit; n < MAX_LABELS; ++n)
  429.    {
  430.       if (rules->labels[n])
  431.       {
  432.          temp = strlen (localized_string ((n == YAHZEE) ? rules->yahzee_label :
  433.                                           label_msg[n]));
  434.          if (temp > label_len)
  435.             label_len = temp;
  436.       }
  437.    }
  438.    
  439.    return label_len;
  440. }
  441.