home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / games / volume13 / okbridge / part06 / scoring.c < prev   
C/C++ Source or Header  |  1992-01-12  |  6KB  |  222 lines
  1. /* scoring.c -- scoring functions for the bridge program.
  2.  ! 
  3.  ! Copyright (C) 1990,1991 by Matthew Clegg
  4.  ! 
  5.  ! This program may be copied and distributed freely.  Please do not
  6.  ! charge money for this program or for any program derived from it.
  7.  ! If you modify this program, then include a notice stating plainly
  8.  ! that your program is derived from the okbridge program and is not
  9.  ! the same as the official okbridge program.
  10.  !
  11.  ! I welcome any suggestions for improvement to okbridge, and 
  12.  ! I would be especially happy to receive improved source code.
  13.  ! If you have comments or suggestions, or if you would like to
  14.  ! join the okbridge mailing list, then write to
  15.  !
  16.  !   mclegg@cs.ucsd.edu
  17.  !
  18.  *
  19.  * This file defines the functions used for computing scores.
  20.  * We provide functions for scoring according to the rules of
  21.  * rubber bridge as well as according to the rules of Chicago style
  22.  * bridge.  Instead of being passed parameters, these functions
  23.  * obtain most of their information from the global variables
  24.  * defined in globals.h.
  25.  *
  26.  * I would like to thank Tom Kronmiller for supplying the code
  27.  * for scoring according to the Chicago rules.  Thanks Tom!
  28.  */
  29.  
  30. #include "globals.h"
  31.  
  32.  
  33. static int  first_trick   [] = {20, 20, 30, 30, 40};
  34. static int  subseq_tricks [] = {20, 20, 30, 30, 30};
  35.  
  36.  
  37. int Rubber_score_above (extra)
  38.      int extra;
  39. /* int Rubber_score_above (int extra, int vulnerable); */
  40. /* Computes the above-the-line score for the current contract assuming
  41.  * that 'extra' many tricks below the required number were taken.
  42.  * Returns the computed above-the-line score.
  43.  */
  44. {
  45.   int above = 0;  /* computed above-the-line points. */
  46.   int vul;        /* true if contracting team is vulnerable. */
  47.  
  48.   vul = vulnerable[side_of(declarer)];
  49.   if (doubled || redoubled) {
  50.     above = 100 * extra;
  51.     if (vul)       above *= 2;
  52.     if (redoubled) above *= 2;
  53.     above += 50;
  54.   } else
  55.     above = subseq_tricks[trump_suit] * extra;
  56.  
  57.   if (contract == 6)
  58.     above += vul? 750: 500;
  59.   else if (contract == 7)
  60.     above += vul? 1500: 1000;
  61.   return (above);
  62.     
  63. };
  64.  
  65. int Rubber_score_below ()
  66. /* int Rubber_score_below (void); */
  67. /* Computes the below-the-line score for the current contract,
  68.  * assuming that it was made.
  69.  */
  70. {
  71.   int below = 0;  /* computed below-the-line points. */
  72.  
  73.   below  = first_trick[trump_suit] + 
  74.     (contract - 1) * subseq_tricks[trump_suit];
  75.   if (redoubled)
  76.     below *= 4;
  77.   else if (doubled)
  78.     below *= 2;
  79.   return (below);
  80. };
  81.  
  82.  
  83. int Rubber_score_set (down)
  84.      int down;
  85. /* int Rubber_score_set (int down); */
  86. /* Computes the penalty score for the current contract assuming that
  87.  * 'down' too few tricks were taken.  Returns the score.
  88.  */
  89. {
  90.   int penalty = 0;  /* computed penalty points. */
  91.   int vul;          /* true if contracting team is vulnerable. */
  92.  
  93.   vul = vulnerable[side_of(declarer)];
  94.   down -= 1;
  95.   if (doubled || redoubled) {
  96.     if (vul) penalty = 200 + 300 * down;
  97.     else     penalty = 100 + 200 * down;
  98.     if (redoubled) penalty *= 2;
  99.   } else {
  100.     if (vul) penalty = 100 + 100 * down;
  101.     else     penalty =  50 +  50 * down;
  102.   };
  103.   return (penalty);
  104. };
  105.  
  106.  
  107. int Chicago_score_made (extra, vulnerable)
  108.      int extra, vulnerable;
  109. /* int Chicago_score_made (int extra, int vulnerable); */
  110. /* Computes the score for the current contract assuming that it was made
  111.  * and that an additional 'extra' tricks were taken.  'vulnerable' is a
  112.  * boolean flag which indicates whether the declaring team was
  113.  * vulnerable.  Returns the score.
  114.  */
  115. {
  116.     int result = 0, perTrick;
  117.  
  118.  
  119.     /* How much is making the bid worth? */
  120.     perTrick = (MINOR(trump_suit))? 20:30;
  121.     result = perTrick * contract;
  122.     if (trump_suit == SUIT_NOTRUMP)    result += 10;
  123.     if (redoubled)                  result *= 4;
  124.     else if (doubled)               result *= 2;
  125.       
  126.     /* Was it a game we made? */
  127.     if (result >= 100)        result += (!vulnerable)? 300:500;
  128. /*    else                    result += 50; */
  129.  
  130.     /* Was it a slam we made? */
  131.     if (contract == 6)        result += (!vulnerable)? 500:750;
  132.     if (contract == 7)        result += (!vulnerable)? 1000:1500;
  133.  
  134.     /* Were we insulted by a double? */
  135.     if (redoubled)                  result += 100;
  136.     else if (doubled)               result += 50;
  137.  
  138.     /* How much do we get for overtricks? */
  139.     if (redoubled)
  140.             result += (extra * 100) * (vulnerable? 4: 2);
  141.     else if (doubled)
  142.             result += (extra * 100) * (vulnerable? 2: 1);
  143.     else
  144.         result += extra * perTrick;
  145.  
  146.     return (result);
  147. }
  148.  
  149.  
  150. int Chicago_score_set (down, vulnerable)
  151.      int down, vulnerable;
  152. /* int Chicago_score_set (int down, int vulnerable); */
  153. /* Computes the score for the current contract assuming that it was
  154.  * set and that 'down' too few tricks were taken.  'vulnerable' is
  155.  * a boolean flag which indicates whether the declaring team was
  156.  * vulnerable.  Returns the score.
  157.  *
  158.  * written by Tom Kronmiller
  159.  */
  160. {
  161.     int result = 0;
  162.  
  163.     if (!doubled)
  164.     {
  165.         result = 50 * down;
  166.         if (vulnerable) result *= 2;
  167.     }
  168.     else
  169.     {
  170.         switch (down)
  171.         {
  172.             case 1:
  173.                 result = (!vulnerable)? 100:200;
  174.                 break;
  175.             case 2:
  176.                 result = (!vulnerable)? 300:500;
  177.                 break;
  178.             case 3:
  179.                 result = (!vulnerable)? 500:800;
  180.                 break;
  181.             default:
  182.                 result = 500 + (300*(down-3)) 
  183.                   + ((!vulnerable)? 0:300);
  184.                 break;
  185.         }
  186.         if (redoubled) result *= 2;
  187.     }
  188.     return (result);
  189. }
  190.  
  191.  
  192. int Duplicate_score_made (extra, vulnerable)
  193.      int extra, vulnerable;
  194. /* int Duplicate_score_made (int extra, int vulnerable); */
  195. /* Computes the score for the current contract assuming that it was made
  196.  * and that an additional 'extra' tricks were taken.  'vulnerable' is a
  197.  * boolean flag which indicates whether the declaring team was
  198.  * vulnerable.  Returns the score.
  199.  */
  200. {
  201.     int score;
  202.  
  203.     score = Chicago_score_made (extra, vulnerable);
  204.     if (score < 300)
  205.         score += 50;
  206.     return (score);
  207.     
  208. }
  209.  
  210. int Duplicate_score_set (down, vulnerable)
  211.      int down, vulnerable;
  212. /* int Duplicate_score_set (int down, int vulnerable); */
  213. /* Computes the score for the current contract assuming that it was
  214.  * set and that 'down' too few tricks were taken.  'vulnerable' is
  215.  * a boolean flag which indicates whether the declaring team was
  216.  * vulnerable.  Returns the score.
  217.  */
  218. {
  219.     return (Chicago_score_set(down, vulnerable));
  220. };
  221.  
  222.