<mosaic.cnfolio.com>
PROGRAM
  1. /*
  2. PSUEDOCODE
  3.  
  4. START
  5.    Set counter to 0
  6.    WHILE counter is less than 8
  7.       IF counter is even
  8.          THEN
  9.             Read Bet number
  10.             IF bet number contains no numbers
  11.                THEN
  12.                   Display input error
  13.             END IF
  14.                  
  15.             IF bet number is negative
  16.                THEN
  17.                   Display negative error message
  18.                   Change number to absolute value
  19.           END IF
  20.             IF bet number is decimal
  21.                THEN
  22.                   Display decimal error message
  23.                   Change to nearest whole number
  24.             END IF
  25.             IF bet number is larger than 36
  26.                THEN
  27.                   Change to max bet number value (36)
  28.             END IF
  29.             IF bet number contains letters
  30.                THEN
  31.                   Filter characters
  32.                   Change bet number to numbers left after filter
  33.             END IF
  34.            
  35.       ELSE
  36.          Read bet amount
  37.          IF bet amount contains no numbers
  38.             THEN
  39.                Display input error
  40.          END IF
  41.          IF bet amount is negative
  42.             THEN
  43.                Diplay relevant error message
  44.                Change bet amount to absolute value
  45.          END IF
  46.          IF bet number contains letters
  47.                THEN
  48.                   Filter characters
  49.                   Change bet number to numbers left after filter
  50.          END IF
  51.       END IF
  52.          
  53.             
  54.       Display user bet amount and bet number
  55.       Roll random number
  56.  
  57.       IF bet number is equal to random number OR bet number  is in bet type list of wins
  58.          THEN
  59.             Calculate win amount
  60.             Display win amount, random number and bet number
  61.             Add win to sum
  62.       ELSE
  63.             Calculate loss
  64.             Display loss amount, random number and bet number
  65.             Subtract loss from sum     
  66.       Add 1 to counter
  67.    END WHILE
  68.    Display total losses/wins and amount lost/won
  69.    
  70. END
  71. */
  72.  
  73. #include <stdio.h>
  74. #include <stdlib.h>
  75. #include <string.h>
  76. #include <time.h>
  77.  
  78.  
  79. #define PLAYS 4         /* This value determines how many bets the player is making or spins of the roulette wheel, */
  80.  
  81.  
  82. float inputfilter ( char [], int );
  83. float wincalc ( float, int, int);
  84.  
  85. int main (void){
  86.    
  87.    char *input[] = {'\0'};
  88.    char betnum[PLAYS][18] = {'\0'};
  89.    char *winnum[] = {'\0'};
  90.    
  91.    float betamount[PLAYS] = {0};
  92.    float betprofit[PLAYS] = {0};
  93.    float winnings = 0;
  94.    
  95.    int filter[PLAYS];
  96.    int winhold;
  97.  
  98.    short displaytype = 0;
  99.    short i, j, count;
  100.                
  101.    srand(time(NULL));         /* starts rand() seed at the current time, makes rand() actually produce a random */
  102.      
  103.     printf("Place your bet:\n ");
  104.          printf("Bet types available:\n \t   \
  105.          1. Number\t 6. FirstDozen \t    11. ThirdColumn\n\
  106.          2. Red \t   7. SecondDozen\t    12. FirstHalf\n\
  107.          3. Black \t 8. ThirdDozen\t     13. SecondHalf\n\
  108.          4. Top \t   9. FirstColumn\t    \n\
  109.          5. Row \t   10. SecondColumn\n\n");
  110.  
  111.    for(i = 0; i <= PLAYS-1; i++)  /* takes input from user in form: bet amount - number to be bet on */
  112.    { 
  113.       for (j = 0; j <= 1; j++)
  114.       {
  115.       count += 1;
  116.       if ((count % 2) != 0)   /* number to bet on */
  117.       {
  118.          scanf(" %s ", &input);
  119.          filter[i] = inputfilter(input, count);
  120.          switch(filter[i]){                     /* This section converts the value returned from inputfilter() into a string to be used for printing further down.                                             */
  121.             case 37: strcpy(betnum[i], "00");
  122.                   break;
  123.             case 38: strcpy(betnum[i], "Red");
  124.                   break;
  125.             case 39: strcpy(betnum[i], "Black");
  126.                   break;
  127.             case 40: strcpy(betnum[i], "Split");   
  128.                   break;
  129.             case 41: strcpy(betnum[i], "Street");
  130.                   break;
  131.             case 42: strcpy(betnum[i], "Corner");
  132.                   break;
  133.             case 43: strcpy(betnum[i], "Double street");
  134.                   break;
  135.             case 44: strcpy(betnum[i], "Trio");
  136.                   break;
  137.             case 45: strcpy(betnum[i], "Basket");
  138.                   break;
  139.             case 46: strcpy(betnum[i], "Topline");
  140.                   break;
  141.             case 47: strcpy(betnum[i], "Row");
  142.                   break;
  143.             case 48: strcpy(betnum[i],"The First Dozen");
  144.                   break;
  145.             case 49: strcpy(betnum[i],"The Second Dozen");
  146.                   break;
  147.             case 50: strcpy(betnum[i],"The Third Dozen");
  148.                   break;
  149.             case 51: strcpy(betnum[i],"The First Column");
  150.                   break;
  151.             case 52: strcpy(betnum[i],"The Second Column");
  152.                   break;
  153.             case 53: strcpy(betnum[i],"The Third Column");
  154.                   break;
  155.             case 54: strcpy(betnum[i],"The First Half")
  156.                   break;
  157.             case 55: strcpy(betnum[i],"The Second Half");   
  158.                   break;
  159.             case 99: strcpy(betnum[i],"Invalid bet")
  160.                   break;
  161.             default: sprintf(betnum[i], "%d", filter[i]);
  162.                   break;   
  163.    }
  164.       }
  165.       else if ((count % 2 )== 0) /*amount to bet */
  166.       {
  167.          printf("\nEnter Amount to bet: ");
  168.          scanf(" %s ", &input);
  169.          printf("\n");
  170.          betamount[i] = inputfilter(input, count);
  171.             
  172.       }
  173.      }
  174.    winhold = rand() % 38;         /* random number generation */
  175.    switch(winhold){        /* Stores the winning number as a string, case 37 catches the 00 bet */
  176.       case 37: strcpy(winnum, "00");
  177.             break;
  178.       default: sprintf(winnum, "%d", winhold);
  179.             break;
  180.    printf("Player bet %6.2f on %s\n", betamount[i], betnum[i]);
  181.  
  182.    }
  183.    
  184.    printf("Rolling.... The winning number was: %s\n", winnum);
  185.  
  186.    betprofit[i] = wincalc(betamount[i], filter[i], winhold); /* Determines the win/loss of each bet and stores in betprofit at index i */
  187.    
  188.    winnings += betprofit[i];    /* Keeps track of the total sum of losses and winnings*/
  189.    
  190.    
  191.    if(betprofit[i] > betamount[i])
  192.       {
  193.          printf("Player made %6.2f with their bet on %s\n\n", betprofit[i], betnum[i]);
  194.       }
  195.    else
  196.       {
  197.          printf("Player lost %6.2f with their bet on %s\n", fabs(betprofit[i]), betnum[i]);
  198.       }
  199.    printf("Subtotal: %0.2f\n\n", winnings);
  200.    
  201.    } 
  202.    for(i = 0; i< PLAYS;i++)
  203.    {
  204.       if(betprofit[i] <= 0)printf("Bet %d: %0.2f on %s cost the player %0.2f\n", i+1, betamount[i], betnum[i], fabs(betprofit[i]));
  205.      
  206.       else printf("Bet %d: %0.2f on %s earned the player %0.2f\n", i+1, betamount[i], betnum[i], betprofit[i]);
  207.      
  208.    }
  209.    if(winnings < 0)printf("In total, the player lost %0.2f", fabs(winnings));
  210.    
  211.    else if(winnings == 0)printf("The player broke even.");
  212.    
  213.    else printf("In total, the player won %0.2f", winnings);
  214. }
  215.  
  216.  
  217. float inputfilter ( char *input, int inputnum ){
  218.    
  219.    /*    This function handles all error checking for the input of the program and returns a float.
  220.       The function does not directly manipulate the string and instead appends numbers to a float based on its position in the input string, using the pow() function.
  221.          1. Finds where the decimal in a string is. Provides user with error for decimals found in input when "inputnum" is set to an even number (bet number)
  222.          2. Finds out if the number is negative and presents an error if that happens
  223.          3. Removes alphabetic and punctuation characters
  224.          4. Converts leftover numerical value to a float and returns it for use.
  225.          5. Will return a rounded number if inputnum is an even integer.
  226.          6. Will compare bet number input with an array of bet types handled by the program, returns a relevant number
  227.          
  228.                      38 = red
  229.                      39 = black
  230.                      46 = top line
  231.                      47 = Row
  232.                      48 = columnOne
  233.                      49 = columnTwo
  234.                      50 = columnThree
  235.                      51 = 1st dozen
  236.                      52 = 2nd dozen
  237.                      53 = 3rd dozen
  238.                      54 = first half
  239.                      55 = second half
  240.                      
  241.                      NOT IMPLEMENTED -- Requires a more refined version of inputfilter() to handle word+number bets and a way of retunring them effectively
  242.                      40 = split
  243.                      41 = street
  244.                      42 = corner/square
  245.                      43 = six line/double street
  246.                      44 = trio
  247.                      45 = basket
  248.    */
  249.    
  250.    
  251.    short i = 0, k = 0, digitcount = 0, character = 0, negativeflag = 255, numbercount = 1, decimalflag = 0;
  252.    float numval = 0;
  253.    char doubleZero [2] = {"00"};
  254.    char* bet[] = {"red", "black", "split", "street", "corner", "double", "trio", "basket", "top", "row", "firstdozen", "seconddozen", "thirddozen", "firstcolumn", "secondcolumn", "thirdcolumn", "firsthalf", "secondhalf"};
  255.    
  256.  
  257.    for(i = 0; i < strlen(input);i++)   /* checks input array for numbers and punctuation, used in determining decimal numbers */
  258.    { 
  259.       if(isdigit(input[i]))digitcount += 1;
  260.       else if(isalpha(input[i])) character += 1;
  261.       else if(ispunct(input[i]))
  262.          {
  263.          if(input[i] == '.')
  264.          {           
  265.             if (i < strlen(input) && decimalflag < 1) decimalflag = i-character; /* Gathers position of decimal number and prevents numbers ending in decimals messing with powers later on */
  266.             else if (decimalflag >= 1 && (inputnum % 2) != 0 )
  267.             {
  268.                printf("ERROR: More than one decimal detected. Returning best guess\n");
  269.                   
  270.             }
  271.             character += 1;
  272.          }
  273.          else if(input[i] == '-')
  274.          { 
  275.             character += 1;
  276.             negativeflag = i - character; /* gathers position of negative in string */
  277.          }
  278.       
  279.          }
  280.       else
  281.          character +=1;
  282.    }
  283.    
  284.    if (input[0] == '.')numbercount += (strlen(input) - character);
  285.    for(i = 0; i < strlen(input);i++)         
  286.    { 
  287.       if(isdigit(input[i]))
  288.       {
  289.          if (decimalflag){
  290.             numval += (input[i]-'0') * pow(10, decimalflag - numbercount); /* changes the char type to float and formats it partly for returning to main as a bet */
  291.             numbercount +=1;                        /* i.e. 123fac.123, decimal position = (7 -  non digit characters so far), then nondigit counter +=1 */
  292.          }                                  /*so 1 * 10^(6-4), then 2 * 10^(6-5), 3*10^(6-6), 1*10^(-6-7) 1*10^(-6-8) 1*10^-(6-9)*/
  293.                                                             /*should give the result 123.123 */
  294.          else
  295.          {
  296.             numval += (input[i]-'0') * pow(10, digitcount - numbercount);
  297.             numbercount += 1;
  298.          }
  299.       }
  300.       
  301.       
  302.       
  303.    }
  304.    if (negativeflag < 255 && input[0] == '-')printf("ERROR: Negative number detecte Returning absolute value.\n");
  305.    if (inputnum %2){
  306.       if (input [0] == '.' || decimalflag) printf("ERROR: Decimal in bet number. Returning nearest whole number\n");
  307.    }
  308.       
  309.  
  310.    
  311.    if((inputnum % 2))         /* Test to see which type of input we're on, amount bet or bet number ---  true = bet number, false = bet amount*/
  312.    {
  313.       for(i = 0; i < strlen(input); i++){
  314.          input[i] = tolower(input[i]);
  315.       }
  316.       for(i = 0; i < 18; i++){                     /*checks to see if special bets were entered and then returns relevant value(check bets[]) for special cases */
  317.          if(!strcmp(input, bet[i]))return (38+i)
  318.       }
  319.       if (digitcount == 0){
  320.          printf("ERROR: No valid input.\n ");
  321.          return 99;             
  322.       }
  323.       if(!strcmp(input, doubleZero))
  324.       {
  325.          return numval = 37/*captures 00 bet */
  326.       }
  327.       if (numval > 36)
  328.          {
  329.             printf("ERROR: Bet number higher than maximum, returning nearest value\n");
  330.             return 36;
  331.          } 
  332.       if((numval - ((int) numval)) == 0){
  333.          return numval;
  334.       } 
  335.       if((numval - ((int) numval)) < 0.5) /* rounding for bet number*/
  336.       {
  337.          return (int) numval;
  338.       }
  339.       else return (int)numval+1;
  340.    }
  341.    else {
  342.     if (digitcount == 0)
  343.       {
  344.          printf("ERROR: No valid input.\n");
  345.       }
  346.    return numval;
  347. }
  348. }
  349.  
  350.  
  351. float wincalc ( float betamount, int betnumber, int winnum){
  352.    
  353.    /* when implemented, will calculate gained or lost money based on bet type. Default bettype (0) will take the betnumber, otherwise will try to deal with other betamount returns lost or gained value
  354.       Table of bettypes:   38 = red
  355.                      39 = black
  356.                      46 = top line
  357.                      47 = Row
  358.                      48 = 1st dozen
  359.                      49 = 2nd dozen
  360.                      50 = 3rd dozen
  361.                      51 = columnOne
  362.                      52 = columnTwo
  363.                      53 = columnThree
  364.                      54 = first half
  365.                      55 = second half
  366.                      
  367.                      NOT IMPLEMENTED BELOW THIS POINT --- These bets require additional input data from the user
  368.                      40 = split
  369.                      41 = street
  370.                      42 = corner/square
  371.                      43 = six line/double street
  372.                      44 = trio
  373.                      45 = basket    
  374.    */
  375.    
  376.    int *red[] = {1, 3, 5, 7, 9, 12,14, 16, 18, 19, 21, 23,25, 27, 30, 32, 34, 36};
  377.    int *black[] = {2, 4, 6, 8, 10, 11, 13, 15, 17, 20, 22, 24, 26, 28, 29, 31, 33, 35};
  378.    int *top[] = {0, 1, 2, 3};
  379.    
  380.    short i;
  381.    
  382.    switch(betnumber){                        
  383.       case 38: for(i = 0; i < 18; i++)      /* red */
  384.             {
  385.                if (winnum == red[i]){
  386.                   return betamount*2;
  387.                }
  388.             }
  389.             return (-betamount);
  390.             
  391.       case 39: for(i = 0; i < 18; i++)      /*black*/
  392.             {
  393.                if (winnum == black[i]){
  394.                   return (betamount*2);
  395.                }
  396.             }
  397.             return (-betamount);
  398.       case 40:                                     /* split*/
  399.       case 41:                                     /* street*/
  400.       case 42:                                     /* corner*/
  401.       case 43:                                     /*six line*/
  402.       case 44:            /*trio*/
  403.       case 45:                                     /*basket*/
  404.       case 46: for(i = 0; i < 4; i++){      /*Top line*/
  405.             if(winnum == top[i] || winnum == 37)
  406.                {
  407.                return (betamount * 7);
  408.                }
  409.             }
  410.             return (-betamount);
  411.          
  412.       case 47: if(winnum == 0 || winnum == 37)        /*Row*/
  413.                {
  414.                return (betamount*18);
  415.                }
  416.             return (-betamount);
  417.             
  418.       case 48: if(winnum <= 12 && winnum != 0 && winnum != 37)    /*1st dozen */
  419.             {
  420.                return (betamount * 3);
  421.             }
  422.             return (-betamount);
  423.             
  424.       case 49: if(winnum >= 13 && winnum <= 24 && winnum != 0 && winnum != 37) /*2nd dozen*/
  425.             {
  426.                return (betamount * 3);
  427.             }
  428.             return (-betamount);
  429.             
  430.       case 50: if(winnum >= 25 && winnum <= 36 && winnum != 0 && winnum != 37) /*3rd dozen*/
  431.             {
  432.                return (betamount * 3);
  433.             }
  434.             return (-betamount);
  435.             
  436.       case 51if ((winnum % 3) == 1 && winnum != 0 && winnum != 37)    /*Column one*/
  437.                {
  438.                   return (betamount*3);
  439.                }
  440.             return (-betamount);
  441.             
  442.       case 52: if ((winnum % 3) == 2 && winnum != 0 && winnum != 37)  /*Column two*/
  443.                {
  444.                   return (betamount*3);
  445.                }
  446.             return (-betamount);
  447.             
  448.       case 53: if(winnum % 3 == 0 && winnum != 0 && winnum != 37) /*Column three*/
  449.                {
  450.                   return (betamount*3);
  451.                }
  452.             return (-betamount);
  453.             
  454.       case 54: if(winnum < 19 && winnum != 0 && winnum != 37)    /*first half*/
  455.             {
  456.                return (betamount * 2);
  457.             }
  458.             return (-betamount);
  459.             
  460.       case 55:if(winnum > 18 && winnum != 0 && winnum != 37)      /*second half*/
  461.             {
  462.                return (betamount * 2);
  463.             }
  464.             return (-betamount);
  465.       default: if(betnumber == winnum)return betamount*35;    /*Single number bet*/
  466.             else return (-betamount);
  467.       
  468.    }             
  469.    
  470. }