I need a little help calculating odds for a roulette game.. i'm not sure why someone would bet 1:1 odds.. to me, that just means you win your money back without making a profit.

also, 1:1+bet back doesn't seem any different than betting 2:1.. this is how I calculate it: wins = bet + bet; which is no different than how I would calculate 2:1 odds: wins = bet *2.

``````single number        35:1 + bet back
column bet            2:1 + bet back
low numbers   1-18    1:1 + bet back
high numbers 19-36    1:1 + bet back
evens                 1:1
odds                  1:1
red                   1:1
black                 1:1``````

Here is the code if anyone want to help me beta test. Critiques good or bad are much appreciated:

Program runs best in a 'windowed' dos console as opposed to 'full-screen'

``````#include<windows.h>
#include<iostream>
#include<cctype>
#include<cstdlib>
#include<ctime>

using namespace std;

class Roulette
{
public:

Roulette();

void board_display();
void prompt();
void place_bet();
void set_bet(int choice);
void set_bet(int menu_choice, int number, int amount);
void set_chip(int);
void set_chip(int, int);
void spin_the_wheel();
void win_or_lose();
void reset();
bool quit();
void gotoxy(int x, int y);

bool win_straight_up();   //35:1 + bet back
bool win_column();        // 2:1 + bet back
bool win_low();           // 1:1 + bet back
bool win_high();          // 1:1 + bet back
bool win_even();          // 1:1
bool win_odd();           // 1:1
bool win_red();           // 1:1
bool win_black();         // 1:1
bool is_black(int);

void input_error();
void bet_error();
void domain_error();
void cap_error();

private:

bool is_bet,
is_quit;

int  total,
available,
winnings,
winner,
bet_array_side[9],
bet_array_number[36],
zero_coords_x[2],
zero_coords_y[2],
side_coords_x[6],
side_coords_y[6],
num_coords_x[36],
num_coords_y[36],
col_coords_x[3],
col_coords_y[3];

};

int main()
{
Roulette myRoulette;

myRoulette.board_display();

do{
myRoulette.prompt();

}while(!myRoulette.quit());

return 0;
}

//////////////////////////////////////////////
///////////////////// Function Definitions //
////////////////////////////////////////////

Roulette::Roulette()
{
is_bet  = FALSE;
is_quit = FALSE;
total  = 2500;
available = 200;
winnings = 0;

srand((unsigned)time(NULL));

for(int i=0; i<9; i++)

bet_array_side[i] = 0;

for(int i=0; i<36; i++)

bet_array_number[i] = 0;

for(int i=0, x=8; i<2; i++, x+=15)
{
zero_coords_x[i] = x;
zero_coords_y[i] = 6;
}

for(int i=0, y=13; i<6; i++, y+=8)
{
side_coords_x[i] = 35;
side_coords_y[i] = y;
}

for(int i=0, x=5, y=10; i<36; i++, x+=10)
{
if(x>26)
{
x = 5;
y+= 4;
}

num_coords_x[i] = x;
num_coords_y[i] = y;
}

for(int i=0, x=8; i<3; i++, x+=10)
{
col_coords_x[i] = x;
col_coords_y[i] = 56;
}
}

void Roulette::board_display()
{
cout << " _____________________________ "
<< "\n|      ___     |   ___   ___  |"
<< "\n|     |   |    |  |   | |   | |"
<< "\n|     |   |    |  |   | |   | |"
<< "\n|     |___|    |  |___| |___| |"
<< "\n|              |              |"
<< "\n|______________|______________|_________ "
<< "\n|         |         |         |         |"
<< "\n|    1    |    2    |    3    |  *LOW*  |"
<< "\n|         |         |         |         |"
<< "\n|_________|_________|_________|  1 - 18 |"
<< "\n|         |         |         |         |            ________________"
<< "\n|    4    |    5    |    6    |         |           /   The Wheel.   \\"
<< "\n|         |         |         |         |          /  ______________  \\"
<< "\n|_________|_________|_________|_________|         |  |              |  |"
<< "\n|         |         |         |         |         |  |              |  |"
<< "\n|    7    |    8    |    9    | *EVEN*  |         |  |______________|  |"
<< "\n|         |         |         |         |         |   ______________   |"
<< "\n|_________|_________|_________|         |         |  |              |  |"
<< "\n|         |         |         |         |         |  |              |  |"
<< "\n|    10   |    11   |    12   |         |         |  |______________|  |"
<< "\n|         |         |         |         |         |                    |"
<< "\n|_________|_________|_________|_________|          \\   Total \$        /"
<< "\n|         |         |         |         |           \\________________/"
<< "\n|    13   |    14   |    15   |  *RED*  |"
<< "\n|         |         |         |         |"
<< "\n|_________|_________|_________|         |"
<< "\n|         |         |         |         |"
<< "\n|    16   |    17   |    18   |         |"
<< "\n|         |         |         |         |"
<< "\n|_________|_________|_________|_________|"
<< "\n|         |         |         |         |"
<< "\n|    19   |    20   |    21   | *BLACK* |"
<< "\n|         |         |         |         |"
<< "\n|_________|_________|_________|         |"
<< "\n|         |         |         |         |"
<< "\n|    22   |    23   |    24   |         |"
<< "\n|         |         |         |         |"
<< "\n|_________|_________|_________|_________|"
<< "\n|         |         |         |         |"
<< "\n|    25   |    26   |    27   |  *ODD*  |"
<< "\n|         |         |         |         |"
<< "\n|_________|_________|_________|         |"
<< "\n|         |         |         |         |"
<< "\n|    28   |    29   |    30   |         |"
<< "\n|         |         |         |         |"
<< "\n|_________|_________|_________|_________|"
<< "\n|         |         |         |         |"
<< "\n|    31   |    32   |    33   | *HIGH*  |"
<< "\n|         |         |         |         |"
<< "\n|_________|_________|_________| 19 - 36 |"
<< "\n|         |         |         |         |"
<< "\n|    34   |    35   |    36   |         |"
<< "\n|         |         |         |         |"
<< "\n|_________|_________|_________|_________|"
<< "\n|   2:1   |   2:1   |   2:1   |"
<< "\n|_________|_________|_________|";

gotoxy(62,22);  cout << total;
}

void Roulette::prompt()
{

gotoxy(50,35); cout << "      Main Menu       ";
gotoxy(50,36); cout << "--------------------- ";
gotoxy(50,38); cout << "1. Place Bet          ";
gotoxy(50,39); cout << "2. Spin the wheel     ";
gotoxy(50,40); cout << "3. Quit               ";
gotoxy(50,41); cout << "                      ";
gotoxy(50,42); cout << "                      ";
gotoxy(50,43); cout << "                      ";
gotoxy(50,44); cout << "                      ";
gotoxy(50,45); cout << "                      ";
gotoxy(50,46); cout << "                      ";
gotoxy(50,47); cout << "                      ";
gotoxy(50,48); cout << "                      ";
gotoxy(50,49); cout << "                      ";
gotoxy(50,50); cout << "                      ";
gotoxy(50,51); cout << "                      ";
gotoxy(50,52); cout << "                            ";
gotoxy(50,53); cout << "                            ";
gotoxy(50,54); cout << "                            ";
gotoxy(50,55); cout << "                            ";
gotoxy(50,56); cout << "                            ";

gotoxy(50,42); cout << "Enter ye' choice: ";

{
case 1:  place_bet();                           break;
case 2:  is_bet?spin_the_wheel():bet_error();   break;
case 3:  is_quit=TRUE;quit();                   break;
default:  input_error();                         break;
}
}

void Roulette::place_bet()
{
number=0,
bet_amt=0;

gotoxy(54,26); cout << "               ";
gotoxy(62,10); cout << "                ";
gotoxy(50,39); cout << "1.  Double Zero      ";
gotoxy(50,35); cout << "      Bet Menu       ";
gotoxy(50,36); cout << "---------------------";
gotoxy(50,38); cout << "0.  Zero             ";
gotoxy(50,40); cout << "2.  Straight-up      ";
gotoxy(50,41); cout << "3.  Left Column      ";
gotoxy(50,42); cout << "4.  Middle Column    ";
gotoxy(50,43); cout << "5.  Right Column     ";
gotoxy(50,44); cout << "6.  Low  Numbers     ";
gotoxy(50,45); cout << "7.  High Numbers     ";
gotoxy(50,46); cout << "8.  Evens            ";
gotoxy(50,47); cout << "9.  Odds             ";
gotoxy(50,48); cout << "10. Red              ";
gotoxy(50,49); cout << "11. Black            ";

gotoxy(50,51); cout << "Enter ye' choice: ";

domain_error();

else

}

void Roulette::set_bet(int choice)
{
int bet_amt=0;

cin.ignore();
gotoxy(50,53); cout << "\$200 Limit Per Turn";
gotoxy(50,54); cout << '\$' << available << " available to bet.";
gotoxy(50,56); cout << "Enter Amount: ";
gotoxy(64,56); cin >> bet_amt;

if(bet_amt > available)

cap_error();

total -= bet_amt;
available -= bet_amt;
bet_array_side[choice-3] = bet_amt;

gotoxy(62,22);  cout << "      ";
gotoxy(62,22);  cout << total;

is_bet = TRUE;
set_chip(choice);
}

void Roulette::set_bet(int choice, int number, int bet_amt)
{
gotoxy(50,51); cout << "Enter a number 1-36: ";

cin >> number;

if(number < 1 || number > 36)

domain_error();

cin.ignore();
gotoxy(50,53); cout << "\$200 Limit Per Turn";
gotoxy(50,54); cout << '\$' << available << " available to bet.";
gotoxy(50,56); cout << "Enter Amount: ";
gotoxy(64,56); cin >> bet_amt;

if(bet_amt > available)

cap_error();

total -= bet_amt;
available -= bet_amt;
bet_array_number[number-1] = bet_amt;

gotoxy(62,22);  cout << "      ";
gotoxy(62,22);  cout << total;

is_bet = TRUE;
set_chip(choice, number);
}

void Roulette::set_chip(int pos)
{
char chip = 1;

switch(pos)
{
case 0:  gotoxy(zero_coords_x[0], zero_coords_y[0]);  cout << chip;
break;
case 1:  gotoxy(zero_coords_x[1], zero_coords_y[1]);  cout << chip;
break;
case 3:  gotoxy(col_coords_x[0], col_coords_y[0]);    cout << chip;
break;
case 4:  gotoxy(col_coords_x[1], col_coords_y[1]);    cout << chip;
break;
case 5:  gotoxy(col_coords_x[2], col_coords_y[2]);    cout << chip;
break;
case 6:  gotoxy(side_coords_x[0], side_coords_y[0]);  cout << chip;
break;
case 7:  gotoxy(side_coords_x[5], side_coords_y[5]);  cout << chip;
break;
case 8:  gotoxy(side_coords_x[1], side_coords_y[1]);  cout << chip;
break;
case 9:  gotoxy(side_coords_x[4], side_coords_y[4]);  cout << chip;
break;
case 10: gotoxy(side_coords_x[2], side_coords_y[2]);  cout << chip;
break;
case 11: gotoxy(side_coords_x[3], side_coords_y[3]);  cout << chip;
break;
}

prompt();
}

void Roulette::set_chip(int pos, int number)
{
char chip = 1;

gotoxy(num_coords_x[number-1], num_coords_y[number-1]);
cout << chip;

prompt();
}

void Roulette::spin_the_wheel()
{
int turn=0;
int snooze=75;
int target=0;
gotoxy(56,15); cout << "   ZERO    ";
gotoxy(60,19); cout << "0 ";

Sleep(snooze);

gotoxy(56,15); cout << "DOUBLE ZERO";
gotoxy(60,19); cout << "00";

Sleep(snooze);

for(int i=1; i<37; i++)
{
if(is_black(i))
{
gotoxy(56,15); cout << "   BLACK   ";
gotoxy(60,19); cout << "  ";
gotoxy(60,19); cout << i;
}
else
{
gotoxy(56,15); cout << "   RED     ";
gotoxy(60,19); cout << "  ";
gotoxy(60,19); cout << i;
}

Sleep(snooze);
}

//Random Number
target = rand()%38+1;

if(is_black(target))
{
gotoxy(56,15); cout << "   BLACK   ";
gotoxy(60,19); cout << "  ";
gotoxy(60,19); cout << target;
}
else
{
gotoxy(56,15); cout << "   RED     ";
gotoxy(60,19); cout << "  ";
gotoxy(60,19); cout << target;
}
if(target == 37)
{
gotoxy(56,15); cout << "   ZERO    ";
gotoxy(60,19); cout << "0 ";
}
else if(target == 38)
{
gotoxy(56,15); cout << "DOUBLE ZERO";
gotoxy(60,19); cout << "00";
}

winner = target;
win_or_lose();
}

void Roulette::win_or_lose()
{
int snooze = 2000;

if(is_quit)

return;

win_straight_up();   //35:1 + bet back
win_column();        // 2:1 + bet back
win_low();           // 1:1 + bet back
win_high();          // 1:1 + bet back
win_even();          // 1:1
win_odd();           // 1:1
win_red();           // 1:1
win_black();

if(winnings)
{
gotoxy(54,26); cout << "                ";
gotoxy(54,26); cout << "You WIN: \$" << winnings;
}
else
{
gotoxy(54,26); cout << "                ";
gotoxy(56,26); cout << "No Wins.";
}

total += winnings;
gotoxy(62,22);  cout << "      ";
gotoxy(62,22);  cout << total;
Sleep(snooze);
reset();
}

bool Roulette::win_straight_up()
{

if(!bet_array_number[winner-1])

return FALSE;

else
{
winnings += bet_array_number[winner-1] * 35 + bet_array_number[winner-1];
return TRUE;
}
}

bool Roulette::win_column()
{
if(!bet_array_side[0] && !bet_array_side[1] && !bet_array_side[2])

return FALSE;

for(int i=0, j=1; i<3; i++, j++)
{
if(bet_array_side[i])
{
for(int k=j; k<37; k+=3)
{
if(winner == k)
{
winnings += bet_array_side[i] * 2 + bet_array_side[i];
return TRUE;
}
}
}
}
return FALSE;
}

bool Roulette::win_low()
{
if(!bet_array_side[3])

return FALSE;

else if(winner > 0 && winner < 19)
{
winnings += bet_array_side[3] + bet_array_side[3];
return TRUE;
}
else

return FALSE;
}

bool Roulette::win_high()
{
if(!bet_array_side[4])

return FALSE;

else if(winner > 18)
{
winnings += bet_array_side[4] + bet_array_side[4];
return TRUE;
}
else

return FALSE;
}

bool Roulette::win_even()
{
if(!bet_array_side[5])

return FALSE;

else if(winner%2+1)
{
winnings += bet_array_side[5];
return TRUE;
}
else

return FALSE;
}

bool Roulette::win_odd()
{
if(!bet_array_side[6])

return FALSE;

else if(winner%2)
{
winnings += bet_array_side[6];
return TRUE;
}
else

return FALSE;
}

bool Roulette::win_red()
{
if(!bet_array_side[7])

return FALSE;

else if(!is_black(winner))
{
winnings += bet_array_side[7];
return TRUE;
}
else

return FALSE;
}

bool Roulette::win_black()
{
if(!bet_array_side[8])

return FALSE;

else if(is_black(winner))
{
winnings += bet_array_side[8];
return TRUE;
}
else

return FALSE;
}

bool Roulette::is_black(int number)
{
if(number<11 && !(number%2) || number>10 && number<18 && number%2 ||
number>19 && number<29 && !(number%2) || number>28 && number<36 && number%2)

return true;

else

return false;
}

void Roulette::reset()
{
winnings  = 0;
available = 200;
is_bet  = FALSE;

for(int i=0; i<9; i++)

bet_array_side[i] = 0;

for(int i=0; i<36; i++)

bet_array_number[i] = 0;

for(int i=0; i<2; i++)
{
gotoxy(zero_coords_x[i], zero_coords_y[i]); cout << '_';
}
for(int i=0; i<6; i++)
{
gotoxy(side_coords_x[i], side_coords_y[i]);  cout << ' ';
}
for(int i=0; i<36; i++)
{
gotoxy(num_coords_x[i], num_coords_y[i]);   cout << '_';
}
for(int i=0; i<3; i++)
{
gotoxy(col_coords_x[i], col_coords_y[i]);   cout << '_';
}

gotoxy(54,26); cout << "              ";
}

bool Roulette::quit()
{
return is_quit;
}

void Roulette::gotoxy(int x, int y)
{
COORD coord;
coord.X = x;
coord.Y = y;
SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), coord);
}

void Roulette::input_error()
{
gotoxy(50,44); cout << "\aInvalid Entry! ";
Sleep(1500);
prompt();
}

void Roulette::cap_error()
{
gotoxy(50,56); cout << "\aBet amount exceeds \$200 limit! ";
Sleep(1500);
gotoxy(50,51); cout << "                     ";
gotoxy(50,53); cout << "                                 ";
gotoxy(50,54); cout << "                                 ";
gotoxy(50,56); cout << "                                 ";

place_bet();
}

void Roulette::domain_error()
{
gotoxy(50,53); cout << "\aEntry does not fall within specified range. ";
Sleep(1500);
gotoxy(50,51); cout << "                                             ";
gotoxy(50,53); cout << "                                             ";
place_bet();
}

void Roulette::bet_error()
{
gotoxy(50,44); cout << "\aYou must place a bet before spinning the wheel! ";
Sleep(1500);
gotoxy(50,44); cout << "                                                  ";
prompt();
}``````

## All 3 Replies

gotoxy isn't portable for a start.

Is it really necessary?

At the risk of stating the obvious
http://en.wikipedia.org/wiki/Roulette

Maybe a little research on the nature of the probabilities (and the odds, which are not the same thing) is in order.

I need a little help calculating odds for a roulette game.. i'm not sure why someone would bet 1:1 odds.. to me, that just means you win your money back without making a profit

No, that's not what it means. 1:1 refers only to your winnings. Whatever amount you initially forked out is always retained (Provided that you didn't lose). The only time you don't get your money/chips/etc back is when the bank wins (which, as you probably realise, happens more often)

Be a part of the DaniWeb community

We're a friendly, industry-focused community of developers, IT pros, digital marketers, and technology enthusiasts meeting, learning, and sharing knowledge.