ROULETTE SOURCE CODE
// author: anthony f. ortiz program: roulette.java
import java.applet.Applet;
import java.awt.*;
import java.math.*;
public class roulette extends Applet
{
private Label [] menu = new Label [9];
private Label bet_label, win1, win2, lose1, lose2, counter1, counter2;
private TextField bet_textfield;
private Button spin, clear_bets, reset;
private String [] r_str1 = new String [3];
private String [] r_str2 = new String [6];
private int bet, pay, lost, counter, number_of_bets, roulette_pick;
private int ballx, bally;
private int picks [] = new int [37];
private int bets [] = new int [37];
private int roulette_board [][] = new int [157][5];
private int roulette_wheel [][] = new int [38][5];
public void init ()
{
load_strings ();
load_labels ();
load_table ();
load_wheel ();
}
public void start ()
{
counter = 1000;
counter2.setText ("" + counter);
counter2.invalidate ();
counter2.validate ();
initialize_values ();
display_screen ();
}
// load the strings used for the roulette table.
public void load_strings ()
{
r_str1 [0] = "1st 12";
r_str1 [1] = "2nd 12";
r_str1 [2] = "3rd 12";
r_str2 [0] = "1to18";
r_str2 [1] = "even";
r_str2 [2] = "red";
r_str2 [3] = "black";
r_str2 [4] = "odd";
r_str2 [5] = "19to16";
}
// load the components (buttons, labels, and textfields).
public void load_labels ()
{
Color color = new Color (0, 128, 0);
setBackground (color);
setForeground (Color.white);
Font font = new Font ("Courier", Font.BOLD, 10);
setFont (font);
setLayout (null);
menu [0] = new Label (" bets odds pays ");
menu [1] = new Label (" straight (one number): 38 to 1 35 to 1");
menu [2] = new Label (" split (line between two numbers): 19 to 1 17 to 1");
menu [3] = new Label (" street (edge of row of three numbers): 38 to 3 11 to 1");
menu [4] = new Label (" square (intersection between four numbers): 19 to 2 8 to 1");
menu [5] = new Label ("line 0-00 (line between 00, 00, and 1, 2, 3): 38 to 5 6 to 1");
menu [6] = new Label (" line (line between two rows, six numbers): 19 to 3 5 to 1");
menu [7] = new Label (" dozens, columns: 38 to 12 2 to 1");
menu [8] = new Label (" red/black, odd/even, 1-18/19-36: 19 to 9 1 to 1");
bet_label = new Label ("bet 1-5:");
bet_textfield = new TextField ("");
win1 = new Label ("you won:");
win2 = new Label ("");
lose1 = new Label ("you lost:");
lose2 = new Label ("");
counter1 = new Label ("counter:");
counter2 = new Label ("");
spin = new Button ("spin");
clear_bets = new Button ("clear bets");
reset = new Button ("reset");
}
// put the coordinates of square areas of the roulette board in a
// array called roulette_board. thus, the user can click on any
// of these regions and the amount they bet will show up on the
// roulette board.
public void load_table ()
{
int c = 0;
// major part of board.
for (int i = 0; i < 12; i++)
{
for (int j = 0; j < 3; j++)
{
roulette_board [c * 2][0] = 540 + j * 25 + 10;
roulette_board [c * 2][1] = 95 + i * 25 + 10;
roulette_board [c * 2][2] = 540 + j * 25 + 20;
roulette_board [c * 2][3] = 95 + i * 25 + 20;
roulette_board [c * 2][4] = 35;
roulette_board [c * 2 + 1][0] = 540 + j * 25 + 23;
roulette_board [c * 2 + 1][1] = 95 + i * 25 + 10;
roulette_board [c * 2 + 1][2] = 540 + j * 25 + 33;
roulette_board [c * 2 + 1][3] = 95 + i * 25 + 20;
if (j <= 1)
{
roulette_board [c * 2 + 1][4] = 17;
}
else
{
roulette_board [c * 2 + 1][4] = 11;
}
c++;
}
}
for (int i = 0; i < 11; i++)
{
for (int j = 0; j < 3; j++)
{
roulette_board [c * 2][0] = 540 + j * 25 + 10;
roulette_board [c * 2][1] = 108 + i * 25 + 10;
roulette_board [c * 2][2] = 540 + j * 25 + 20;
roulette_board [c * 2][3] = 108 + i * 25 + 20;
roulette_board [c * 2][4] = 17;
roulette_board [c * 2 + 1][0] = 540 + j * 25 + 23;
roulette_board [c * 2 + 1][1] = 108 + i * 25 + 10;
roulette_board [c * 2 + 1][2] = 540 + j * 25 + 33;
roulette_board [c * 2 + 1][3] = 108 + i * 25 + 20;
if (j <= 1)
{
roulette_board [c * 2 + 1][4] = 8;
}
else
{
roulette_board [c * 2 + 1][4] = 5;
}
c++;
}
}
c = c * 2;
// 2 to 1.
for (int i = 0; i < 3; i++)
{
roulette_board [c][0] = 540 + i * 25 + 10;
roulette_board [c][1] = 395 + 10;
roulette_board [c][2] = 540 + i * 25 + 20;
roulette_board [c][3] = 395 + 20;
roulette_board [c][4] = 2;
c++;
}
// 1 to 18, even, red, black, odd, 19 to 36.
for (int i = 0; i < 6; i++)
{
roulette_board [c][0] = 440 + 10;
roulette_board [c][1] = 95 + 50 * i + 10;
roulette_board [c][2] = 440 + 40;
roulette_board [c][3] = 95 + 50 * i + 35;
roulette_board [c][4] = 1;
c++;
}
// 1st 12, 2nd 12, 3rd 12.
for (int i = 0; i < 3; i++)
{
roulette_board [c][0] = 490 + 10;
roulette_board [c][1] = 95 + 100 * i + 10;
roulette_board [c][2] = 490 + 40;
roulette_board [c][3] = 95 + 100 * i + 85;
roulette_board [c][4] = 2;
c++;
}
// 0, 00.
for (int i = 0; i < 3; i++)
{
roulette_board [c][0] = 540 + i * 20 + 15;
roulette_board [c][1] = 70 + 10;
roulette_board [c][2] = 540 + i * 20 + 25;
roulette_board [c][3] = 70 + 20;
if (i == 0 || i == 3)
{
roulette_board [c][4] = 35;
}
else
{
roulette_board [c][4] = 19;
}
c++;
}
for (int i = 0; i < 3; i++)
{
roulette_board [c][0] = 540 + i * 25 + 23;
roulette_board [c][1] = 84 + 10;
roulette_board [c][2] = 540 + i * 25 + 33;
roulette_board [c][3] = 84 + 20;
if (i >= 2)
{
roulette_board [c][4] = 11;
}
else
{
roulette_board [c][4] = 6;
}
c++;
}
roulette_board [c][0] = 540 + 25 + 10;
roulette_board [c][1] = 84 + 10;
roulette_board [c][2] = 540 + 25 + 20;
roulette_board [c][3] = 84 + 20;
roulette_board [c][4] = 11;
}
// load the numbers for the roulette wheel.
public void load_wheel ()
{
int numbers [] = new int [38];
numbers [0] = 16;
numbers [1] = 4;
numbers [2] = 23;
numbers [3] = 35;
numbers [4] = 14;
numbers [5] = 2;
numbers [6] = -1;
numbers [7] = 28;
numbers [8] = 9;
numbers [9] = 26;
numbers [10] = 30;
numbers [11] = 11;
numbers [12] = 7;
numbers [13] = 20;
numbers [14] = 32;
numbers [15] = 17;
numbers [16] = 5;
numbers [17] = 22;
numbers [18] = 34;
numbers [19] = 15;
numbers [20] = 3;
numbers [21] = 24;
numbers [22] = 36;
numbers [23] = 13;
numbers [24] = 1;
numbers [25] = -2;
numbers [26] = 27;
numbers [27] = 10;
numbers [28] = 25;
numbers [29] = 29;
numbers [30] = 12;
numbers [31] = 8;
numbers [32] = 19;
numbers [33] = 31;
numbers [34] = 18;
numbers [35] = 6;
numbers [36] = 21;
numbers [37] = 33;
int i = 0;
for (int j = 0; j < 3; j++)
{
roulette_wheel [j][0] = 200 + i * 15;
roulette_wheel [j][1] = 205 - i * 15;
roulette_wheel [j][2] = 15;
roulette_wheel [j][3] = 15;
roulette_wheel [j][4] = numbers [j];
i++;
}
i = 0;
for (int j = 3; j < 10; j++)
{
roulette_wheel [j][0] = 245 + i * 15;
roulette_wheel [j][1] = 160;
roulette_wheel [j][2] = 15;
roulette_wheel [j][3] = 15;
roulette_wheel [j][4] = numbers [j];
i++;
}
i = 0;
for (int j = 10; j < 13; j++)
{
roulette_wheel [j][0] = 350 + i * 15;
roulette_wheel [j][1] = 175 + i * 15;
roulette_wheel [j][2] = 15;
roulette_wheel [j][3] = 15;
roulette_wheel [j][4] = numbers [j];
i++;
}
i = 0;
for (int j = 13; j < 19; j++)
{
roulette_wheel [j][0] = 395;
roulette_wheel [j][1] = 220 + i * 15;
roulette_wheel [j][2] = 15;
roulette_wheel [j][3] = 15;
roulette_wheel [j][4] = numbers [j];
i++;
}
i = 0;
for (int j = 19; j < 22; j++)
{
roulette_wheel [j][0] = 380 - i * 15;
roulette_wheel [j][1] = 310 + i * 15;
roulette_wheel [j][2] = 15;
roulette_wheel [j][3] = 15;
roulette_wheel [j][4] = numbers [j];
i++;
}
i = 0;
for (int j = 22; j < 29; j++)
{
roulette_wheel [j][0] = 335 - i * 15;
roulette_wheel [j][1] = 355;
roulette_wheel [j][2] = 15;
roulette_wheel [j][3] = 15;
roulette_wheel [j][4] = numbers [j];
i++;
}
i = 0;
for (int j = 29; j < 32; j++)
{
roulette_wheel [j][0] = 230 - i * 15;
roulette_wheel [j][1] = 340 - i * 15;
roulette_wheel [j][2] = 15;
roulette_wheel [j][3] = 15;
roulette_wheel [j][4] = numbers [j];
i++;
}
i = 0;
for (int j = 32; j < 38; j++)
{
roulette_wheel [j][0] = 185;
roulette_wheel [j][1] = 295 - i * 15;
roulette_wheel [j][2] = 15;
roulette_wheel [j][3] = 15;
roulette_wheel [j][4] = numbers [j];
i++;
}
}
// draw the roulette board and the roulette wheel.
public void paint (Graphics g)
{
int c = 0;
// draw roulette board.
// 1 to 18, even, red, black, odd, 19 to 36.
for (int i = 0; i < 6; i++)
{
g.drawRect (440, 90 + 50 * i, 50, 50);
if (r_str2 [i] == "red")
{
g.setColor (Color.red);
}
else if (r_str2 [i] == "black")
{
g.setColor (Color.black);
}
g.drawString (r_str2 [i], 440 + 6, 90 + 50 * i + 30);
g.setColor (Color.white);
}
// 1st 12, 2nd 12, 3rd 12.
for (int i = 0; i < 3; i++)
{
g.drawRect (490, 90 + i * 100, 50, 100);
g.drawString (r_str1 [i], 490 + 8, 90 + i * 100 + 55);
}
// 0, 00.
for (int i = 0; i < 2; i++)
{
if (i == 0)
{
g.drawRect (540, 65, 37, 25);
g.drawString ("0", 540 + 15, 65 + 17);
}
else
{
g.drawRect (540 + 37, 65, 38, 25);
g.drawString ("00", 540 + 15 + 34, 65 + 17);
}
}
// 1-36 and their colors.
for (int i = 0; i < 12; i++)
{
for (int j = 0; j < 3; j++)
{
c++;
g.drawRect (540 + j * 25, 90 + 25 * i, 25, 25);
if (c == 1 || c == 3 || c == 5 || c == 7 || c == 9 ||
c == 12 || c == 14 || c == 16 || c == 18 || c == 19 ||
c == 21 || c == 23 || c == 25 || c == 27 || c == 30 ||
c == 32 || c == 34 || c == 36)
{
g.setColor (Color.red);
}
else
{
g.setColor (Color.black);
}
if (c <= 9)
{
g.drawString ("" + c, 540 + j * 25 + 10, 90 + i * 25 + 17);
}
else
{
g.drawString ("" + c, 540 + j * 25 + 6, 90 + i * 25 + 17);
}
g.setColor (Color.white);
}
}
// 2 to 1.
for (int i = 0; i < 3; i++)
{
g.drawRect (540 + i * 25, 390, 25, 25);
g.drawString ("2to1", 540 + i * 25 + 1, 390 + 17);
}
// draw the roulette wheel.
for (int i = 0; i < 38; i++)
{
g.drawRect (roulette_wheel [i][0], roulette_wheel [i][1],
roulette_wheel [i][2], roulette_wheel [i][3]);
if (i % 2 == 0 && roulette_wheel [i][4] > 0)
{
g.setColor (Color.red);
if (roulette_wheel [i][4] >= 10)
{
g.drawString ("" + roulette_wheel [i][4],
roulette_wheel [i][0] + 2,
roulette_wheel [i][1] + 11);
}
else
{
g.drawString ("" + roulette_wheel [i][4],
roulette_wheel [i][0] + 5,
roulette_wheel [i][1] + 11);
}
}
else if (i % 2 == 1 && roulette_wheel [i][4] > 0)
{
g.setColor (Color.black);
if (roulette_wheel [i][4] >= 10)
{
g.drawString ("" + roulette_wheel [i][4],
roulette_wheel [i][0] + 2,
roulette_wheel [i][1] + 11);
}
else
{
g.drawString ("" + roulette_wheel [i][4],
roulette_wheel [i][0] + 5,
roulette_wheel [i][1] + 11);
}
}
else if (roulette_wheel [i][4] == -1)
{
g.drawString ("0", roulette_wheel [i][0] + 5,
roulette_wheel [i][1] + 11);
}
else
{
g.drawString ("00",roulette_wheel [i][0] + 2,
roulette_wheel [i][1] + 11);
}
g.setColor (Color.white);
}
// draw the ball if you hit spin and there is a call to repaint.
if (ballx > 0)
{
g.drawOval (ballx, bally, 13, 13);
}
// draw the number if you hit spin and there is a call to repaint.
if (roulette_pick == 1 || roulette_pick == 3 || roulette_pick == 5 ||
roulette_pick == 7 || roulette_pick == 9 || roulette_pick == 12 ||
roulette_pick == 14 || roulette_pick == 16 || roulette_pick == 18 ||
roulette_pick == 19 || roulette_pick == 21 || roulette_pick == 23 ||
roulette_pick == 25 || roulette_pick == 27 || roulette_pick == 30 ||
roulette_pick == 32 || roulette_pick == 34 || roulette_pick == 36)
{
g.setColor (Color.red);
g.drawString ("" + roulette_pick, 290, 270);
}
else if (roulette_pick >=1)
{
g.setColor (Color.black);
g.drawString ("" + roulette_pick, 290, 270);
}
else if (roulette_pick == -1)
{
g.drawString ("0", 290, 270);
}
else if (roulette_pick == -2)
{
g.drawString ("00", 290, 270);
}
g.setColor (Color.white);
// draw bet if their is a bet on the table and their is a call
// to repaint.
if (number_of_bets >= 1)
{
for (int i = 0; i < number_of_bets; i++)
{
g.drawString ("" + bets [i], roulette_board [picks [i]][0],
roulette_board [picks [i]][1]);
}
}
}
// initialize starting values.
public void initialize_values ()
{
bet = 1;
pay = 0;
lost = 0;
number_of_bets = 0;
roulette_pick = 0;
ballx = 0;
bally = 0;
for (int i = 0; i < picks.length; i++)
{
picks [i] = 0;
bets [i] = 0;
}
bet_textfield.enable (true);
bet_textfield.setText ("" + bet);
win2.setText ("");
win2.invalidate ();
win2.validate ();
lose2.setText ("");
lose2.invalidate ();
lose2.validate ();
spin.enable (true);
clear_bets.enable (true);
reset.enable (false);
}
// display the components (buttons, labels, and textfields).
public void display_screen ()
{
for (int i = 0; i < 9; i++)
{
menu [i].reshape (5, 5 + i * 15, 425, 10);
add (menu [i]);
}
bet_label.reshape (5, 160, 75, 10);
add (bet_label);
bet_textfield.reshape (80, 155, 75, 25);
add (bet_textfield);
win1.reshape (5, 195, 75, 10);
add (win1);
win2.reshape (80, 195, 70, 10);
add (win2);
lose1.reshape (5, 230, 75, 10);
add (lose1);
lose2.reshape (80, 230, 70, 10);
add (lose2);
counter1.reshape (5, 265, 75, 10);
add (counter1);
counter2.reshape (80, 265, 75, 10);
add (counter2);
spin.reshape (80, 300, 75, 25);
add (spin);
clear_bets.reshape (80, 335, 75, 25);
add (clear_bets);
reset.reshape (80, 370, 75, 25);
add (reset);
}
// spin the roulette wheel.
public void spin_wheel ()
{
int x = 0;
int y = 0;
Color color = new Color (0, 128, 0);
// pick 0, 00, or 1 thru 36.
roulette_pick = (int) (Math.random () * 37);
if (roulette_pick == 0)
{
roulette_pick = (int) (Math.random () * 2);
if (roulette_pick == 0)
{
roulette_pick = -2;
}
else
{
roulette_pick = -1;
}
}
// spin the wheel 10 times.
for (int j = 0; j < 10; j++)
{
for (int k = 0; k < 38; k++)
{
if (k >= 0 && k <= 2)
{
x = roulette_wheel [k][0] + 16;
y = roulette_wheel [k][1] + 16;
}
else if (k >= 3 && k <= 9)
{
x = roulette_wheel [k][0] + 1;
y = roulette_wheel [k][1] + 16;
}
else if (k >= 10 && k <= 12)
{
x = roulette_wheel [k][0] - 16;
y = roulette_wheel [k][1] + 16;
}
else if (k >= 13 && k <= 18)
{
x = roulette_wheel [k][0] - 16;
y = roulette_wheel [k][1] + 1;
}
else if (k >= 19 && k <= 21)
{
x = roulette_wheel [k][0] - 16;
y = roulette_wheel [k][1] - 16;
}
else if (k >= 22 && k <= 28)
{
x = roulette_wheel [k][0] + 1;
y = roulette_wheel [k][1] - 16;
}
else if (k >= 29 && k <= 31)
{
x = roulette_wheel [k][0] + 16;
y = roulette_wheel [k][1] - 16;
}
else if (k >= 32 && k <= 37)
{
x = roulette_wheel [k][0] + 16;
y = roulette_wheel [k][1] + 1;
}
setForeground (Color.white);
getGraphics ().drawOval (x, y, 13, 13);
setForeground (color);
getGraphics ().drawOval (x, y, 13, 13);
if (j == 9 && roulette_wheel [k][4] == roulette_pick)
{
ballx = x;
bally = y;
setForeground (Color.white);
getGraphics ().drawOval (x, y, 13, 13);
break;
}
}
}
// place the lucky number in the middle of the roulette wheel.
if (roulette_pick == -1)
{
getGraphics ().drawString ("0", 290, 270);
}
else if (roulette_pick == -2)
{
getGraphics ().drawString ("00", 290, 270);
}
else if (roulette_pick == 1 || roulette_pick == 3 ||
roulette_pick == 5 || roulette_pick == 7 ||
roulette_pick == 9 || roulette_pick == 12 ||
roulette_pick == 14 || roulette_pick == 16 ||
roulette_pick == 18 || roulette_pick == 19 ||
roulette_pick == 21 || roulette_pick == 23 ||
roulette_pick == 25 || roulette_pick == 27 ||
roulette_pick == 30 || roulette_pick == 32 ||
roulette_pick == 34 || roulette_pick == 36)
{
setForeground (Color.red);
getGraphics ().drawString ("" + roulette_pick, 290, 270);
}
else
{
setForeground (Color.black);
getGraphics ().drawString ("" + roulette_pick, 290, 270);
}
setForeground (Color.white);
}
// calculate the winnings of the user's hand and display the winnings,
// losings, and the updated counter.
public void pay_winner ()
{
int initial_bets = 0;
for (int i = 0; i < number_of_bets; i++)
{
if ((roulette_pick - 1) * 2 == picks [i])
{
pay = pay + bets [i] * roulette_board [picks [i]][4];
}
else if ((picks [i] == 1 && roulette_pick >= 1 && roulette_pick <= 2) ||
(picks [i] == 7 && roulette_pick >= 4 && roulette_pick <= 5) ||
(picks [i] == 13 && roulette_pick >= 7 && roulette_pick <= 8) ||
(picks [i] == 19 && roulette_pick >= 10 && roulette_pick <= 11) ||
(picks [i] == 25 && roulette_pick >= 13 && roulette_pick <= 14) ||
(picks [i] == 31 && roulette_pick >= 16 && roulette_pick <= 17) ||
(picks [i] == 37 && roulette_pick >= 19 && roulette_pick <= 20) ||
(picks [i] == 43 && roulette_pick >= 22 && roulette_pick <= 23) ||
(picks [i] == 49 && roulette_pick >= 25 && roulette_pick <= 26) ||
(picks [i] == 55 && roulette_pick >= 28 && roulette_pick <= 29) ||
(picks [i] == 61 && roulette_pick >= 31 && roulette_pick <= 32) ||
(picks [i] == 67 && roulette_pick >= 34 && roulette_pick <= 35))
{
pay = pay + bets [i] * roulette_board [picks [i]][4];
}
else if ((picks [i] == 3 && roulette_pick >= 2 && roulette_pick <= 3) ||
(picks [i] == 9 && roulette_pick >= 5 && roulette_pick <= 6) ||
(picks [i] == 15 && roulette_pick >= 8 && roulette_pick <= 9) ||
(picks [i] == 21 && roulette_pick >= 11 && roulette_pick <= 12) ||
(picks [i] == 27 && roulette_pick >= 14 && roulette_pick <= 15) ||
(picks [i] == 33 && roulette_pick >= 17 && roulette_pick <= 18) ||
(picks [i] == 39 && roulette_pick >= 20 && roulette_pick <= 21) ||
(picks [i] == 45 && roulette_pick >= 23 && roulette_pick <= 24) ||
(picks [i] == 51 && roulette_pick >= 26 && roulette_pick <= 27) ||
(picks [i] == 57 && roulette_pick >= 29 && roulette_pick <= 30) ||
(picks [i] == 63 && roulette_pick >= 32 && roulette_pick <= 33) ||
(picks [i] == 69 && roulette_pick >= 35 && roulette_pick <= 36))
{
pay = pay + bets [i] * roulette_board [picks [i]][4];
}
else if ((picks [i] == 5 && roulette_pick >= 1 && roulette_pick <= 3) ||
(picks [i] == 11 && roulette_pick >= 4 && roulette_pick <= 6) ||
(picks [i] == 17 && roulette_pick >= 7 && roulette_pick <= 9) ||
(picks [i] == 23 && roulette_pick >= 10 && roulette_pick <= 12) ||
(picks [i] == 29 && roulette_pick >= 13 && roulette_pick <= 15) ||
(picks [i] == 35 && roulette_pick >= 16 && roulette_pick <= 18) ||
(picks [i] == 41 && roulette_pick >= 19 && roulette_pick <= 21) ||
(picks [i] == 47 && roulette_pick >= 22 && roulette_pick <= 24) ||
(picks [i] == 53 && roulette_pick >= 25 && roulette_pick <= 27) ||
(picks [i] == 59 && roulette_pick >= 28 && roulette_pick <= 30) ||
(picks [i] == 65 && roulette_pick >= 31 && roulette_pick <= 33) ||
(picks [i] == 71 && roulette_pick >= 34 && roulette_pick <= 36))
{
pay = pay + bets [i] * roulette_board [picks [i]][4];
}
else if ((picks [i] == 72) && (roulette_pick == 1 || roulette_pick == 4) ||
(picks [i] == 78) && (roulette_pick == 4 || roulette_pick == 7) ||
(picks [i] == 84) && (roulette_pick == 7 || roulette_pick == 10) ||
(picks [i] == 90) && (roulette_pick == 10 || roulette_pick == 13) ||
(picks [i] == 96) && (roulette_pick == 13 || roulette_pick == 16) ||
(picks [i] == 102) && (roulette_pick == 16 || roulette_pick == 19) ||
(picks [i] == 108) && (roulette_pick == 19 || roulette_pick == 22) ||
(picks [i] == 114) && (roulette_pick == 22 || roulette_pick == 25) ||
(picks [i] == 120) && (roulette_pick == 25 || roulette_pick == 28) ||
(picks [i] == 126) && (roulette_pick == 28 || roulette_pick == 31) ||
(picks [i] == 132) && (roulette_pick == 31 || roulette_pick == 34))
{
pay = pay + bets [i] * roulette_board [picks [i]][4];
}
else if ((picks [i] == 73) && (roulette_pick == 1 || roulette_pick == 2 ||
roulette_pick == 4 || roulette_pick == 5) ||
(picks [i] == 79) && (roulette_pick == 4 || roulette_pick == 5 ||
roulette_pick == 7 || roulette_pick == 8) ||
(picks [i] == 85) && (roulette_pick == 7 || roulette_pick == 8 ||
roulette_pick == 10 || roulette_pick == 11) ||
(picks [i] == 91) && (roulette_pick == 10 || roulette_pick == 11 ||
roulette_pick == 13 || roulette_pick == 14) ||
(picks [i] == 97) && (roulette_pick == 13 || roulette_pick == 14 ||
roulette_pick == 16 || roulette_pick == 17) ||
(picks [i] == 103) && (roulette_pick == 16 || roulette_pick == 17 ||
roulette_pick == 19 || roulette_pick == 20) ||
(picks [i] == 109) && (roulette_pick == 19 || roulette_pick == 20 ||
roulette_pick == 22 || roulette_pick == 23) ||
(picks [i] == 115) && (roulette_pick == 22 || roulette_pick == 23 ||
roulette_pick == 25 || roulette_pick == 26) ||
(picks [i] == 121) && (roulette_pick == 25 || roulette_pick == 26 ||
roulette_pick == 28 || roulette_pick == 29) ||
(picks [i] == 127) && (roulette_pick == 28 || roulette_pick == 29 ||
roulette_pick == 31 || roulette_pick == 32) ||
(picks [i] == 133) && (roulette_pick == 31 || roulette_pick == 32 ||
roulette_pick == 34 || roulette_pick == 34))
{
pay = pay + bets [i] * roulette_board [picks [i]][4];
}
else if ((picks [i] == 74) && (roulette_pick == 2 || roulette_pick == 5) ||
(picks [i] == 80) && (roulette_pick == 5 || roulette_pick == 8) ||
(picks [i] == 86) && (roulette_pick == 8 || roulette_pick == 11) ||
(picks [i] == 92) && (roulette_pick == 11 || roulette_pick == 14) ||
(picks [i] == 98) && (roulette_pick == 14 || roulette_pick == 17) ||
(picks [i] == 104) && (roulette_pick == 17 || roulette_pick == 20) ||
(picks [i] == 110) && (roulette_pick == 20 || roulette_pick == 23) ||
(picks [i] == 116) && (roulette_pick == 23 || roulette_pick == 26) ||
(picks [i] == 122) && (roulette_pick == 26 || roulette_pick == 29) ||
(picks [i] == 128) && (roulette_pick == 29 || roulette_pick == 32) ||
(picks [i] == 134) && (roulette_pick == 32 || roulette_pick == 35))
{
pay = pay + bets [i] * roulette_board [picks [i]][4];
}
else if ((picks [i] == 75) && (roulette_pick == 2 || roulette_pick == 3 ||
roulette_pick == 5 || roulette_pick == 6) ||
(picks [i] == 81) && (roulette_pick == 5 || roulette_pick == 6 ||
roulette_pick == 8 || roulette_pick == 9) ||
(picks [i] == 87) && (roulette_pick == 8 || roulette_pick == 9 ||
roulette_pick == 11 || roulette_pick == 12) ||
(picks [i] == 93) && (roulette_pick == 11 || roulette_pick == 12 ||
roulette_pick == 14 || roulette_pick == 15) ||
(picks [i] == 99) && (roulette_pick == 14 || roulette_pick == 15 ||
roulette_pick == 17 || roulette_pick == 18) ||
(picks [i] == 105) && (roulette_pick == 17 || roulette_pick == 18 ||
roulette_pick == 20 || roulette_pick == 21) ||
(picks [i] == 111) && (roulette_pick == 20 || roulette_pick == 21 ||
roulette_pick == 23 || roulette_pick == 24) ||
(picks [i] == 117) && (roulette_pick == 23 || roulette_pick == 24 ||
roulette_pick == 26 || roulette_pick == 27) ||
(picks [i] == 123) && (roulette_pick == 26 || roulette_pick == 27 ||
roulette_pick == 29 || roulette_pick == 30) ||
(picks [i] == 129) && (roulette_pick == 29 || roulette_pick == 30 ||
roulette_pick == 32 || roulette_pick == 33) ||
(picks [i] == 135) && (roulette_pick == 32 || roulette_pick == 33 ||
roulette_pick == 35 || roulette_pick == 36))
{
pay = pay + bets [i] * roulette_board [picks [i]][4];
}
else if ((picks [i] == 76) && (roulette_pick == 3 || roulette_pick == 6) ||
(picks [i] == 82) && (roulette_pick == 6 || roulette_pick == 9) ||
(picks [i] == 88) && (roulette_pick == 9 || roulette_pick == 12) ||
(picks [i] == 94) && (roulette_pick == 12 || roulette_pick == 15) ||
(picks [i] == 100) && (roulette_pick == 15 || roulette_pick == 18) ||
(picks [i] == 106) && (roulette_pick == 18 || roulette_pick == 21) ||
(picks [i] == 112) && (roulette_pick == 21 || roulette_pick == 24) ||
(picks [i] == 118) && (roulette_pick == 24 || roulette_pick == 27) ||
(picks [i] == 124) && (roulette_pick == 27 || roulette_pick == 30) ||
(picks [i] == 130) && (roulette_pick == 30 || roulette_pick == 33) ||
(picks [i] == 136) && (roulette_pick == 33 || roulette_pick == 36))
{
pay = pay + bets [i] * roulette_board [picks [i]][4];
}
else if ((picks [i] == 77 && roulette_pick >= 1 && roulette_pick <= 6) ||
(picks [i] == 83 && roulette_pick >= 4 && roulette_pick <= 9) ||
(picks [i] == 89 && roulette_pick >= 7 && roulette_pick <= 12) ||
(picks [i] == 95 && roulette_pick >= 10 && roulette_pick <= 15) ||
(picks [i] == 101 && roulette_pick >= 13 && roulette_pick <= 18) ||
(picks [i] == 107 && roulette_pick >= 16 && roulette_pick <= 21) ||
(picks [i] == 113 && roulette_pick >= 19 && roulette_pick <= 24) ||
(picks [i] == 119 && roulette_pick >= 22 && roulette_pick <= 27) ||
(picks [i] == 125 && roulette_pick >= 25 && roulette_pick <= 30) ||
(picks [i] == 131 && roulette_pick >= 28 && roulette_pick <= 33) ||
(picks [i] == 137 && roulette_pick >= 31 && roulette_pick <= 36))
{
pay = pay + bets [i] * roulette_board [picks [i]][4];
}
else if ((picks [i] == 138) && (roulette_pick == 1 || roulette_pick == 4 ||
roulette_pick == 7 || roulette_pick == 10 ||
roulette_pick == 13 || roulette_pick == 16 ||
roulette_pick == 19 || roulette_pick == 22 ||
roulette_pick == 25 || roulette_pick == 28 ||
roulette_pick == 31 || roulette_pick == 34 ))
{
pay = pay + bets [i] * roulette_board [picks [i]][4];
}
else if ((picks [i] == 139) && (roulette_pick == 2 || roulette_pick == 5 ||
roulette_pick == 8 || roulette_pick == 11 ||
roulette_pick == 14 || roulette_pick == 17 ||
roulette_pick == 20 || roulette_pick == 23 ||
roulette_pick == 26 || roulette_pick == 29 ||
roulette_pick == 32 || roulette_pick == 35))
{
pay = pay + bets [i] * roulette_board [picks [i]][4];
}
else if ((picks [i] == 140) && (roulette_pick == 3 || roulette_pick == 6 ||
roulette_pick == 9 || roulette_pick == 12 ||
roulette_pick == 15 || roulette_pick == 18 ||
roulette_pick == 21 || roulette_pick == 24 ||
roulette_pick == 27 || roulette_pick == 30 ||
roulette_pick == 33 || roulette_pick == 36))
{
pay = pay + bets [i] * roulette_board [picks [i]][4];
}
else if (roulette_pick >= 1 && roulette_pick <= 18 && picks [i] == 141)
{
pay = pay + bets [i] * roulette_board [picks [i]][4];
}
else if (picks [i] == 142 && roulette_pick > 0 && roulette_pick % 2 == 0)
{
pay = pay + bets [i] * roulette_board [picks [i]][4];
}
else if ((picks [i] == 143) && (roulette_pick == 1 || roulette_pick == 3 ||
roulette_pick == 5 || roulette_pick == 7 ||
roulette_pick == 9 || roulette_pick == 12 ||
roulette_pick == 14 || roulette_pick == 16 ||
roulette_pick == 18 || roulette_pick == 19 ||
roulette_pick == 21 || roulette_pick == 23 ||
roulette_pick == 25 || roulette_pick == 27 ||
roulette_pick == 30 || roulette_pick == 32 ||
roulette_pick == 34 || roulette_pick == 36))
{
pay = pay + bets [i] * roulette_board [picks [i]][4];
}
else if ((picks [i] == 144) && (roulette_pick == 2 || roulette_pick == 4 ||
roulette_pick == 6 || roulette_pick == 8 ||
roulette_pick == 10 || roulette_pick == 11 ||
roulette_pick == 13 || roulette_pick == 15 ||
roulette_pick == 17 || roulette_pick == 20 ||
roulette_pick == 22 || roulette_pick == 24 ||
roulette_pick == 26 || roulette_pick == 28 ||
roulette_pick == 29 || roulette_pick == 31 ||
roulette_pick == 33 || roulette_pick == 35))
{
pay = pay + bets [i] * roulette_board [picks [i]][4];
}
else if (picks [i] == 145 && roulette_pick > 0 && roulette_pick % 2 != 0)
{
pay = pay + bets [i] * roulette_board [picks [i]][4];
}
else if (roulette_pick >= 19 && roulette_pick <= 36 && picks [i] == 146)
{
pay = pay + bets [i] * roulette_board [picks [i]][4];
}
else if (roulette_pick >= 1 && roulette_pick <= 12 && picks [i] == 147)
{
pay = pay + bets [i] * roulette_board [picks [i]][4];
}
else if (roulette_pick >= 13 && roulette_pick <= 24 && picks [i] == 148)
{
pay = pay + bets [i] * roulette_board [picks [i]][4];
}
else if (roulette_pick >= 25 && roulette_pick <= 36 && picks [i] == 149)
{
pay = pay + bets [i] * roulette_board [picks [i]][4];
}
else if ((picks [i] == 150 || picks [i] == 152) && roulette_pick < 0)
{
pay = pay + bets [i] * roulette_board [picks [i]][4];
}
else if (picks [i] == 151 && roulette_pick < 0)
{
pay = pay + bets [i] * roulette_board [picks [i]][4];
}
else if ((picks [i] == 153) && (roulette_pick == -1 || roulette_pick == 1 ||
roulette_pick == 2) ||
(picks [i] == 156) && (roulette_pick == -1 || roulette_pick == -2 ||
roulette_pick == 2) ||
(picks [i] == 154) && (roulette_pick == -2 || roulette_pick == 2 ||
roulette_pick == 3))
{
pay = pay + bets [i] * roulette_board [picks [i]][4];
}
else if ((picks [i] == 155) && (roulette_pick == -1 || roulette_pick == -2 ||
roulette_pick == 1 || roulette_pick == 2 ||
roulette_pick == 3))
{
pay = pay + bets [i] * roulette_board [picks [i]][4];
}
else
{
pay = pay;
lost = lost + bets [i];
}
}
for (int i = 0; i < number_of_bets; i++)
{
initial_bets = initial_bets + bets [i];
}
counter = counter + pay - initial_bets;
win2.setText ("" + pay);
win2.invalidate ();
win2.validate ();
lose2.setText ("" + lost);
lose2.invalidate ();
lose2.validate ();
counter2.setText ("" + counter);
counter2.invalidate ();
counter2.validate ();
}
// spin the wheel, clear the bets from the roulette table, or
// reset the game.
public boolean action (Event event, Object object)
{
if (event.target == spin && number_of_bets >= 1)
{
bet_textfield.enable (false);
spin.enable (false);
clear_bets.enable (false);
reset.enable (true);
spin_wheel ();
pay_winner ();
return (true);
}
else if (event.target == clear_bets && number_of_bets >= 1)
{
number_of_bets = 0;
repaint ();
return (true);
}
else if (event.target == reset)
{
initialize_values ();
repaint ();
return (true);
}
else
{
return (false);
}
}
// place the bet on the roulette table.
public boolean mouseDown (Event e, int x, int y)
{
if (spin.isEnabled () == true && number_of_bets <= 36)
{
load_table ();
for (int c = 0; c < 157; c++)
{
if (roulette_board [c][0] <= x && roulette_board [c][1] <= y &&
roulette_board [c][2] >= x && roulette_board [c][3] >= y)
{
number_of_bets++;
picks [number_of_bets - 1] = c;
bets [number_of_bets - 1] = bet;
getGraphics ().drawString ("" + bet,
roulette_board [c][0],
roulette_board [c][1]);
break;
}
}
return (true);
}
else
{
return (false);
}
}
// bet from 1 to 5 coins.
public boolean keyUp (Event event, int key)
{
if (event.target == bet_textfield)
{
if (key > 53 || key < 49)
{
bet_textfield.setText ("1");
}
else
{
bet = key - 48;
bet_textfield.setText (bet + "");
}
return (true);
}
else
{
return (false);
}
}
}
BACK TO ROULETTE APPLET.