Swing & Threading Help Please - Java Discussion Boards

Just edit the original to tell others that you have moved it.

Hi, everyone
May I ask a questions??
C++ is my first language but I now I need to learn Java.
C++ supports multiple inheritance.
Example:
Class c
Protected class a(), class b()
{

}

But Java doesn't support multiple inheritance.
Java use interface to implement multiple inheritance.
My question is how to use interface to achieve multiple inheritance.
Thank you very much.

tzungshian wrote:
Java use interface to implement multiple inheritance.

No it does not, Java does not support multiple inheritance. See Why Multiple Inheritance is Not Supported in Java - Java Tutorial Blog[^].

Thank you very much!!!

Please guys, can anyone guide me on how i can go about creating a GPA calculator with a good GUI. It should be able to tell if one can reach a certain grade point before graduation based on a student's previous current GPA and remaining courses left before graduating... Thanks guys!!

Yes, just work through The Java Tutorials[^].

Hello,

How do I catch an exception from a future event handler?

I'd like to do the following:

Java

public static void main(String[] args) {
                    
        Wait wait = new Wait(5000); //5 seconds

        try
        {
            wait.StartWait(); //return immediately
            Thread.sleep(10000); //10 seconds
            wait.StopWait();
        }
        catch (Exception e)
        {
            System.out.print("Timer timed out.");
        }

        System.out.print("Success!");        
    }

Here is my StartWait method:

Java

public void StartWait() throws ExecutionException, InterruptedException, TimeoutException, Exception {
       
        executor = new NonBlockingExecutor(Executors.newSingleThreadExecutor());
 
        NonBlockingFuture<Integer> future = executor.submitNonBlocking(new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                Thread.sleep(iTimeout);
                throw new TimeoutException("Timer Elapsed.");
            }
        });
 
        future.setHandler(new FutureHandler<Integer>() {
            @Override
            public void onSuccess(Integer value) {
                 System.out.println("Task completed successfully.");
            }
 
            @Override
            public void onFailure(Throwable e) throws Exception {
                System.out.println(e.getMessage());
                StopWait();
                throw new Exception(e.getMessage());
            }
        });
    }

However, the exception thrown in the overridden onFailure method does not get caught in main.

Any suggestions?

I am using this implementation of a non-blocking future:

Java - Implement Java Non Blocking Futures

Thank you.

williamj

I am currently beyond frustrated with my current active project. I thought it would be simple, but has done nothing but create a desire to pull my hair out.

Here's the issue: I'm writing a version of Yacht (a dice game on which a particular name-brand dice game, also starting with Y, is based) that allows the person to play against a computer. So far, all free versions of the game I have come across either are solitaire, or only allow for human vs. human. I've got the AI figured out, but I want things like the dice rolls, and what have you to display appropriately on the GUI, but the GUI freezes because of threading issues. I have tried multiple times to rewrite the program to correct this, but nothing I have tried seems to work (event listeners, Swing Workers, creating new threads, etc.). The code I am showing you is the closest I've managed to come, since the end result (scoring-wise) is correct.

Any help in getting this to run the way I want it to would be appreciated.

Here's the main class for the game. I'll also provide the AI routine as well, as that is what is supposed to interact with the GUI. The GUI should respond to the AI as though it were a human interacting with it, and the 1st (human) player's score should show up before the AI begins to play. Neither of these things are happening.

Java

public class Yacht {

	// Game Images
	private final ImageIcon   yachtIcon = new ImageIcon(this.getClass().getResource("images/yacht.png"));
	private final ImageIcon[] dieFaces  = {
		new ImageIcon(this.getClass().getResource("images/0.png")),
		new ImageIcon(this.getClass().getResource("images/1.png")),
		new ImageIcon(this.getClass().getResource("images/2.png")),
		new ImageIcon(this.getClass().getResource("images/3.png")),
		new ImageIcon(this.getClass().getResource("images/4.png")),
		new ImageIcon(this.getClass().getResource("images/5.png")),
		new ImageIcon(this.getClass().getResource("images/6.png"))
	};
	private final ImageIcon[] sDieFaces = {
		new ImageIcon(this.getClass().getResource("images/0_selected.png")),
		new ImageIcon(this.getClass().getResource("images/1_selected.png")),
		new ImageIcon(this.getClass().getResource("images/2_selected.png")),
		new ImageIcon(this.getClass().getResource("images/3_selected.png")),
		new ImageIcon(this.getClass().getResource("images/4_selected.png")),
		new ImageIcon(this.getClass().getResource("images/5_selected.png")),
		new ImageIcon(this.getClass().getResource("images/6_selected.png"))
	};

	private ButtonGroup          playerOptGroup;
	private JButton              newGameButton;
	private JButton              rollButton;
	private JButton[]            upperScoreButton = new JButton[6];
	private JButton[]            lowerScoreButton = new JButton[7];
	private JFrame               frame;
	private JLabel[]             scoreHeader      = new JLabel[5];
	private JLabel[]             upperScoreLabel  = new JLabel[9];
	private JLabel[]             lowerScoreLabel  = new JLabel[10];
	private JLabel[][]           upperScoreValue  = new JLabel[4][9];
	private JLabel[][]           lowerScoreValue  = new JLabel[4][10];
	private JMenu                gameMenu;
	private JMenu                helpMenu;
	private JMenu                optionsMenu;
	private JMenuBar             menuBar;
	private JMenuItem            aboutItem;
	private JMenuItem            exitItem;
	private JMenuItem            newGameItem;
	private JMenuItem            rulesItem;
	private JPanel               dicePanel;
	private JPanel               scoreButtonPanel;
	private JPanel               scorePanel;
	private JRadioButtonMenuItem optSinglePlayer;
	private JRadioButtonMenuItem optTwoPlayer;
	private JSeparator           gameSeparator;
	private JSeparator           helpSeparator;
	private JToggleButton[]      dice             = new JToggleButton[Game.DICE.getNumDice()];

	private boolean[] diceList;
	private int       rollCount;
	private Player[]  player = {Game.PLAYER, Game.BOT, Game.MIN, Game.MAX};
	private int       currentPlayer;
	private boolean   singlePlayer;
	private int       turnCount;

	private final int      NUM_TURNS         = 13;
	private	final String[] UPPER_BUTTON_TEXT = {
		"Aces", "Twos", "Threes","Fours", "Fives", "Sixes"
	};
	private final String[] LOWER_BUTTON_TEXT = {
		"3 of a Kind", "4 of a Kind", "Full House",
		"Sm. Straight", "Lg. Straight", "Yacht", "Chance"
	};

	public static Yacht window;

	/**
	 * Launch the application.
	 */
	public static void main(String[] args) {
		// Set up the game
		new Game();

		// Set the look and feel
		try {
			UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
		} catch (ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException e) {
			System.out.println("System interface not available.");
		}

		// Run the game
		EventQueue.invokeLater(new Runnable() {
			@Override
			public void run() {
				try {
					window = new Yacht();
					window.frame.setVisible(true);
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		});
	}

	/**
	 * Create the application.
	 */
	public Yacht() {
		rollCount     = Game.getMaxRolls();
		currentPlayer = 0;
		singlePlayer  = true;
		turnCount     = NUM_TURNS;
		initialize();
		updateScoreSheet(2);
		updateScoreSheet(3);
	}

	private void newGame() {
		newGame(singlePlayer);
	}

	private void newGame(boolean singlePlayer) {
		currentPlayer     = 0;
		this.singlePlayer = singlePlayer;
		turnCount         = NUM_TURNS;
		resetDicePanel();
		resetRollButton();

		scoreHeader[4].setText("");

		for (int i = 0; i < player.length; i++) {
			player[i].resetScores();

			for (int j = 0; j < 10; j++) {
				if (j < 9) {
					upperScoreValue[i][j].setText("");
				}

				lowerScoreValue[i][j].setText("");
			}
		}

		updateScoreSheet(2);
		updateScoreSheet(3);

		if (singlePlayer) {
			scoreHeader[1].setEnabled(false);
			scoreHeader[2].setEnabled(true);
			scoreHeader[3].setEnabled(true);

			for (int i = 0; i < 10; i++) {
				if (i < 9) {
					upperScoreValue[1][i].setEnabled(false);
					upperScoreValue[2][i].setEnabled(true);
					upperScoreValue[3][i].setEnabled(true);
				}

				lowerScoreValue[1][i].setEnabled(false);
				lowerScoreValue[2][i].setEnabled(true);
				lowerScoreValue[3][i].setEnabled(true);
			}
		} else {
			scoreHeader[1].setEnabled(true);
			scoreHeader[2].setEnabled(false);
			scoreHeader[3].setEnabled(false);

			for (int i = 0; i < 10; i++) {
				if (i < 9) {
					upperScoreValue[1][i].setEnabled(true);
					upperScoreValue[2][i].setEnabled(false);
					upperScoreValue[3][i].setEnabled(false);
				}

				lowerScoreValue[1][i].setEnabled(true);
				lowerScoreValue[2][i].setEnabled(false);
				lowerScoreValue[3][i].setEnabled(false);
			}
		}

		resetScoreButtons();
	}

	/**
	 * Initialize the contents of the frame.
	 */
	private void initialize() {
		frame = new JFrame("Yacht");
		frame.setResizable(false);
		frame.setBounds(100, 100, 475, 522);
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		frame.setIconImage(yachtIcon.getImage());
		frame.getContentPane().setLayout(null);

		menuBar = new JMenuBar();
		frame.setJMenuBar(menuBar);

		gameMenu = new JMenu("Game");
		gameMenu.setMnemonic('g');
		menuBar.add(gameMenu);

		newGameItem = new JMenuItem("New Game");
		newGameItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_N, InputEvent.ALT_MASK));
		newGameItem.setMnemonic('n');
		newGameItem.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent arg0) {
				newGame();
			}
		});
		gameMenu.add(newGameItem);

		gameSeparator = new JSeparator();
		gameMenu.add(gameSeparator);

		exitItem = new JMenuItem("Exit");
		exitItem.setMnemonic('x');
		exitItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_F4, InputEvent.ALT_MASK));
		exitItem.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent arg0) {
				System.exit(0);
			}
		});
		gameMenu.add(exitItem);

		optionsMenu = new JMenu("Options");
		optionsMenu.setMnemonic('o');
		menuBar.add(optionsMenu);

		playerOptGroup = new ButtonGroup();

		optSinglePlayer = new JRadioButtonMenuItem("Solitaire");
		optSinglePlayer.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_1, InputEvent.ALT_MASK));
		optSinglePlayer.setMnemonic('s');
		optSinglePlayer.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent arg0) {
				newGame(true);
			}
		});
		optionsMenu.add(optSinglePlayer);
		playerOptGroup.add(optSinglePlayer);

		optTwoPlayer = new JRadioButtonMenuItem("Human vs. PC");
		optTwoPlayer.setMnemonic('h');
		optTwoPlayer.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_2, InputEvent.ALT_MASK));
		optTwoPlayer.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent arg0) {
				newGame(false);
			}
		});
		optionsMenu.add(optTwoPlayer);
		playerOptGroup.add(optTwoPlayer);

		optSinglePlayer.setSelected(true);

		helpMenu = new JMenu("Help");
		menuBar.add(helpMenu);

		rulesItem = new JMenuItem("Rules");
		rulesItem.setMnemonic('r');
		rulesItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_F1, 0));
		rulesItem.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent arg0) {
				JOptionPane.showMessageDialog(frame.getRootPane(), "<html><h1>Rules</h1><ul><li>Roll the dice up to 3 times per turn to get the best hand possible.</li><li>Click the button for where you want to score your turn.</li><li>Once turns are complete, your final score is evaluated.<ul><li><b>Solitaire:</b> Your final score is expressed as a negative number if<br>you score less than the minimum hand, represented as Even<br>if you score the same as the minimum hand, and shown as a<br>percentage of the maximum if you score above the minimum hand.</li><li><b>Human vs. PC</b>: The player (You or Bot) with the higher score wins.</li></ul></li></ul>", "Yacht Rules", JOptionPane.PLAIN_MESSAGE);
			}
		});
		helpMenu.add(rulesItem);

		helpSeparator = new JSeparator();
		helpMenu.add(helpSeparator);

		aboutItem = new JMenuItem("About");
		aboutItem.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_A, InputEvent.ALT_MASK));
		aboutItem.setMnemonic('a');
		aboutItem.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent arg0) {
				JOptionPane.showMessageDialog(frame.getRootPane(), "<html><center><h1>Yacht</h1><h3>Alpha Release</h3><h3>Author: PCGuyIV</h3><br><p>Licensed under GNU General Public License ver. 3</p>", "About Yacht", JOptionPane.PLAIN_MESSAGE);
			}
		});
		helpMenu.add(aboutItem);

		int x      =  0;
		int y      =  0;
		int width  = 64;
		int height = 64;
		int gap    =  5;
		int pWidth = width * Game.DICE.getNumDice() + gap * (Game.DICE.getNumDice() - 1);

		dicePanel = new JPanel();
		dicePanel.setBounds(10, 10, pWidth, height);
		dicePanel.setLayout(null);
		frame.getContentPane().add(dicePanel);

		for (int i = 0; i < Game.DICE.getNumDice(); i++) {
			dice[i] = new JToggleButton("");
			dice[i].setIcon(dieFaces[Game.DICE.getResult(i)]);
			dice[i].setBounds(x, y, width, height);
			dice[i].setEnabled(false);
			switch (i) {
				case 0:
					dice[i].addItemListener(new ItemListener() {
						@Override
						public void itemStateChanged(ItemEvent ev) {
							if (ev.getStateChange() == ItemEvent.SELECTED) {
								dice[0].setIcon(sDieFaces[Game.DICE.getResult(0)]);
							} else if (ev.getStateChange() == ItemEvent.DESELECTED) {
								dice[0].setIcon(dieFaces[Game.DICE.getResult(0)]);
							}
						}
					});
					break;
				case 1:
					dice[i].addItemListener(new ItemListener() {
						@Override
						public void itemStateChanged(ItemEvent ev) {
							if (ev.getStateChange() == ItemEvent.SELECTED) {
								dice[1].setIcon(sDieFaces[Game.DICE.getResult(1)]);
							} else if (ev.getStateChange() == ItemEvent.DESELECTED) {
								dice[1].setIcon(dieFaces[Game.DICE.getResult(1)]);
							}
						}
					});
					break;
				case 2:
					dice[i].addItemListener(new ItemListener() {
						@Override
						public void itemStateChanged(ItemEvent ev) {
							if (ev.getStateChange() == ItemEvent.SELECTED) {
								dice[2].setIcon(sDieFaces[Game.DICE.getResult(2)]);
							} else if (ev.getStateChange() == ItemEvent.DESELECTED) {
								dice[2].setIcon(dieFaces[Game.DICE.getResult(2)]);
							}
						}
					});
					break;
				case 3:
					dice[i].addItemListener(new ItemListener() {
						@Override
						public void itemStateChanged(ItemEvent ev) {
							if (ev.getStateChange() == ItemEvent.SELECTED) {
								dice[3].setIcon(sDieFaces[Game.DICE.getResult(3)]);
							} else if (ev.getStateChange() == ItemEvent.DESELECTED) {
								dice[3].setIcon(dieFaces[Game.DICE.getResult(3)]);
							}
						}
					});
					break;
				case 4:
					dice[i].addItemListener(new ItemListener() {
						@Override
						public void itemStateChanged(ItemEvent ev) {
							if (ev.getStateChange() == ItemEvent.SELECTED) {
								dice[4].setIcon(sDieFaces[Game.DICE.getResult(4)]);
							} else if (ev.getStateChange() == ItemEvent.DESELECTED) {
								dice[4].setIcon(dieFaces[Game.DICE.getResult(4)]);
							}
						}
					});
					break;
				default:
					dice[i].addItemListener(new ItemListener() {
						@Override
						public void itemStateChanged(ItemEvent ev) {
							if (ev.getStateChange() == ItemEvent.SELECTED) {
								dice[0].setIcon(sDieFaces[0]);
							} else if (ev.getStateChange() == ItemEvent.DESELECTED) {
								dice[0].setIcon(dieFaces[0]);
							}
						}
					});
					break;
			}
			dicePanel.add(dice[i]);
			x += width + gap;
		}

		rollButton = new JButton(Integer.toString(rollCount) + " Rolls");
		rollButton.setToolTipText("Roll them bones!");
		rollButton.setBounds(355, 10, 101, 64);
		rollButton.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent arg0) {
				Vector<Integer> diceList = new Vector<Integer>();
				boolean[]       rollList = updateDicePanel();

				diceList.removeAllElements();

				for (int i = 0; i < Game.DICE.getNumDice(); i++) {
					if (rollList[i]) {
						diceList.addElement(i);
					}
				}

				int[] dieList = new int[diceList.size()];

				for (int i = 0; i < diceList.size(); i++) {
					dieList[i] = diceList.elementAt(i);
				}

				Game.DICE.rollDice(dieList);
				rollList = updateDicePanel();
				Game.evaluateRoll();
				rollCount--;
				if (rollCount > 1 || rollCount < 1) {
					rollButton.setText(Integer.toString(rollCount) + " Rolls");
					if (rollCount < 1) {
						rollButton.setEnabled(false);
					}
				} else if (rollCount == 1) {
					rollButton.setText(Integer.toString(rollCount) + " Roll");
				}

				updateScoreButtons();
			}
		});
		frame.getContentPane().add(rollButton);

		scoreButtonPanel = new JPanel();
		scoreButtonPanel.setBounds(10, 80, 190, 340);
		frame.getContentPane().add(scoreButtonPanel);
		scoreButtonPanel.setLayout(null);

		x      =   0;
		y      =   0;
		width  = 190;
		height =  25;

		for (int i = 0; i < 6; i++) {
			upperScoreButton[i] = new JButton(UPPER_BUTTON_TEXT[i]);
			upperScoreButton[i].setEnabled(false);
			upperScoreButton[i].setBounds(x, y, width, height);
			scoreButtonPanel.add(upperScoreButton[i]);
			y += height;
		}

		y += 5;
		for (int i = 0; i < 7; i++) {
			lowerScoreButton[i] = new JButton(LOWER_BUTTON_TEXT[i]);
			lowerScoreButton[i].setEnabled(false);
			lowerScoreButton[i].setBounds(x, y, width, height);
			scoreButtonPanel.add(lowerScoreButton[i]);
			y += height;
		}

		upperScoreButton[0].addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent arg0) {
				player[currentPlayer].getScore().setAces(Game.getAcesVal());
				nextTurn();
			}
		});
		upperScoreButton[1].addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent arg0) {
				player[currentPlayer].getScore().setTwos(Game.getTwosVal());
				nextTurn();
			}
		});
		upperScoreButton[2].addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent arg0) {
				player[currentPlayer].getScore().setThrees(Game.getThreesVal());
				nextTurn();
			}
		});
		upperScoreButton[3].addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent arg0) {
				player[currentPlayer].getScore().setFours(Game.getFoursVal());
				nextTurn();
			}
		});
		upperScoreButton[4].addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent arg0) {
				player[currentPlayer].getScore().setFives(Game.getFivesVal());
				nextTurn();
			}
		});
		upperScoreButton[5].addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent arg0) {
				player[currentPlayer].getScore().setSixes(Game.getSixesVal());
				nextTurn();
			}
		});

		lowerScoreButton[0].addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent arg0) {
				player[currentPlayer].getScore().setThreeOfAKind(Game.getTOAKVal());
				nextTurn();
			}
		});
		lowerScoreButton[1].addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent arg0) {
				player[currentPlayer].getScore().setFourOfAKind(Game.getFOAKVal());
				nextTurn();
			}
		});
		lowerScoreButton[2].addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent arg0) {
				player[currentPlayer].getScore().setFullHouse(Game.hasFullHouse());
				nextTurn();
			}
		});
		lowerScoreButton[3].addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent arg0) {
				player[currentPlayer].getScore().setSmStraight(Game.hasSmStraight());
				nextTurn();
			}
		});
		lowerScoreButton[4].addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent arg0) {
				player[currentPlayer].getScore().setLgStraight(Game.hasLgStraight());
				nextTurn();
			}
		});
		lowerScoreButton[5].addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent arg0) {
				player[currentPlayer].getScore().setYacht(Game.hasYacht());
				nextTurn();
			}
		});
		lowerScoreButton[6].addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent arg0) {
				player[currentPlayer].getScore().setChance(Game.getChanceVal());
				nextTurn();
			}
		});

		scorePanel = new JPanel();
		scorePanel.setBounds(210, 80, 250, 395);
		frame.getContentPane().add(scorePanel);
		scorePanel.setLayout(null);

		x      = 94;
		y      =  0;
		width  = 39;
		height = 20;
		scoreHeader[0] = new JLabel("You");
		scoreHeader[0].setBounds(x, y, width, height);
		scoreHeader[0].setBorder(new LineBorder(new Color(0, 0, 0)));
		scoreHeader[0].setHorizontalAlignment(SwingConstants.CENTER);
		scoreHeader[0].setVerticalAlignment(SwingConstants.CENTER);
		scorePanel.add(scoreHeader[0]);

		x += width - 1;
		scoreHeader[1] = new JLabel("Bot");
		if (singlePlayer) {
			scoreHeader[1].setEnabled(false);
		}
		scoreHeader[1].setBounds(x, y, width, height);
		scoreHeader[1].setBorder(new LineBorder(new Color(0, 0, 0)));
		scoreHeader[1].setHorizontalAlignment(SwingConstants.CENTER);
		scoreHeader[1].setVerticalAlignment(SwingConstants.CENTER);
		scorePanel.add(scoreHeader[1]);

		x += width - 1;
		scoreHeader[2] = new JLabel("Min");
		if (!singlePlayer) {
			scoreHeader[2].setEnabled(false);
		}
		scoreHeader[2].setBounds(x, y, width, height);
		scoreHeader[2].setBorder(new LineBorder(new Color(0, 0, 0)));
		scoreHeader[2].setHorizontalAlignment(SwingConstants.CENTER);
		scoreHeader[2].setVerticalAlignment(SwingConstants.CENTER);
		scorePanel.add(scoreHeader[2]);

		x += width - 1;
		scoreHeader[3] = new JLabel("Max");
		if (!singlePlayer) {
			scoreHeader[3].setEnabled(false);
		}
		scoreHeader[3].setBounds(x, y, width, height);
		scoreHeader[3].setBorder(new LineBorder(new Color(0, 0, 0)));
		scoreHeader[3].setHorizontalAlignment(SwingConstants.CENTER);
		scoreHeader[3].setVerticalAlignment(SwingConstants.CENTER);
		scorePanel.add(scoreHeader[3]);

		x      =  0;
		width  = 95;
		scoreHeader[4] = new JLabel();
		scoreHeader[4].setBackground(new Color(255, 255, 255));
		scoreHeader[4].setOpaque(true);
		scoreHeader[4].setForeground(new Color(255, 0, 0));
		scoreHeader[4].setBorder(new LineBorder(new Color(0, 0, 0)));
		scoreHeader[4].setHorizontalAlignment(SwingConstants.CENTER);
		scoreHeader[4].setVerticalAlignment(SwingConstants.CENTER);
		scoreHeader[4].setBounds(x, y, width, height);
		scorePanel.add(scoreHeader[4]);

		y      = 19;
		height = 20;

		for (int i = 0; i < 9; i++) {
			switch (i) {
				case 6:
					upperScoreLabel[i] = new JLabel(" Upper Subtotal:");
					break;
				case 7:
					upperScoreLabel[i] = new JLabel(" 63+ BONUS (" + Integer.toString(Score.getBonusValue()) + "):");
					break;
				case 8:
					upperScoreLabel[i] = new JLabel(" Upper Total:");
					break;
				default:
					upperScoreLabel[i] = new JLabel(" " + UPPER_BUTTON_TEXT[i] + ":");
					break;
			}
			upperScoreLabel[i].setFont(new Font("Dialog", Font.PLAIN, 10));
			upperScoreLabel[i].setBorder(new LineBorder(new Color(0, 0, 0)));
			upperScoreLabel[i].setBounds(x, y, width, height);
			upperScoreLabel[i].setVerticalAlignment(SwingConstants.CENTER);
			scorePanel.add(upperScoreLabel[i]);
			y += height - 1;
		}

		y += 5;

		for (int i = 0; i < 10; i++) {
			switch (i) {
				case 7:
					lowerScoreLabel[i] = new JLabel(" Lower Total:");
					break;
				case 8:
					lowerScoreLabel[i] = new JLabel(" Upper Total:");
					break;
				case 9:
					lowerScoreLabel[i] = new JLabel(" Grand Total:");
					break;
				default:
					lowerScoreLabel[i] = new JLabel(" " + LOWER_BUTTON_TEXT[i] + ":");
			}
			lowerScoreLabel[i].setFont(new Font("Dialog", Font.PLAIN, 10));
			lowerScoreLabel[i].setBorder(new LineBorder(new Color(0, 0, 0)));
			lowerScoreLabel[i].setBounds(x, y, width, height);
			lowerScoreLabel[i].setVerticalAlignment(SwingConstants.CENTER);
			scorePanel.add(lowerScoreLabel[i]);
			y += height - 1;
		}

		x      = 94;
		width  = 39;
		height = 20;

		for (int i = 0; i < 4; i++) {
			y = 19;

			for (int j = 0; j < 9; j++) {
				upperScoreValue[i][j] = new JLabel();
				upperScoreValue[i][j].setBorder(new LineBorder(new Color(0, 0, 0)));
				upperScoreValue[i][j].setBackground(new Color(255, 255, 255));
				upperScoreValue[i][j].setOpaque(true);
				upperScoreValue[i][j].setBounds(x, y, width, height);
				upperScoreValue[i][j].setHorizontalAlignment(SwingConstants.CENTER);
				upperScoreValue[i][j].setVerticalAlignment(SwingConstants.CENTER);
				if (i == 1) {
					upperScoreValue[i][j].setEnabled(false);
				}
				scorePanel.add(upperScoreValue[i][j]);
				y += height - 1;
			}

			y += 5;

			for (int j = 0; j < 10; j++) {
				lowerScoreValue[i][j] = new JLabel();
				lowerScoreValue[i][j].setBorder(new LineBorder(new Color(0, 0, 0)));
				lowerScoreValue[i][j].setBackground(new Color(255, 255, 255));
				lowerScoreValue[i][j].setOpaque(true);
				lowerScoreValue[i][j].setBounds(x, y, width, height);
				lowerScoreValue[i][j].setHorizontalAlignment(SwingConstants.CENTER);
				lowerScoreValue[i][j].setVerticalAlignment(SwingConstants.CENTER);
				if (i == 1) {
					lowerScoreValue[i][j].setEnabled(false);
				}
				scorePanel.add(lowerScoreValue[i][j]);
				y += height - 1;
			}

			x += width - 1;
		}

		newGameButton = new JButton("New Game");
		newGameButton.setBounds(10, 420, 190, 45);
		newGameButton.addActionListener(new ActionListener() {
			@Override
			public void actionPerformed(ActionEvent arg0) {
				newGame();
			}
		});
		frame.getContentPane().add(newGameButton);

	}

	private boolean[] updateDicePanel() {
		diceList = new boolean[Game.DICE.getNumDice()];

		for (int i = 0; i < Game.DICE.getNumDice(); i++) {
			if (!dice[i].isEnabled()) {
				dice[i].setEnabled(true);
			}

			if (dice[i].isSelected()) {
				diceList[i] = false;
				dice[i].setIcon(sDieFaces[Game.DICE.getResult(i)]);
			} else {
				diceList[i] = true;
				dice[i].setIcon(dieFaces[Game.DICE.getResult(i)]);
			}
		}

		return diceList;
	}

	private void resetDicePanel() {
		for (int i = 0; i < Game.DICE.getNumDice(); i++) {
			if (dice[i].isSelected()) {
				dice[i].doClick();
			}

			dice[i].setEnabled(false);
		}
	}

	private void resetRollButton() {
		rollCount = Game.getMaxRolls();
		rollButton.setEnabled(true);
		rollButton.setText(Integer.toString(rollCount) + " Rolls");

	}

	private void nextTurn() {
		player[currentPlayer].getScore().updateTotals();
		updateScoreSheet();

		if (!singlePlayer && currentPlayer == 0) {
			currentPlayer = 1;
		} else if (!singlePlayer) {
			currentPlayer = 0;
			turnCount--;
		} else {
			turnCount--;
		}

		for (int i = 0; i < Game.DICE.getNumDice(); i++) {

			if (dice[i].isSelected()) {
				dice[i].doClick();
			}

			dice[i].setEnabled(false);
		}

		resetScoreButtons();

		if (turnCount < 1) {
			showGameResults();
		} else {
			resetRollButton();
			checkForBot();
		}

	}

	private void resetScoreButtons() {
		for (int i = 0; i < 6; i++) {
			upperScoreButton[i].setEnabled(false);
			upperScoreButton[i].setText(UPPER_BUTTON_TEXT[i]);
			lowerScoreButton[i].setEnabled(false);
			lowerScoreButton[i].setText(LOWER_BUTTON_TEXT[i]);
		}

		lowerScoreButton[6].setEnabled(false);
		lowerScoreButton[6].setText(LOWER_BUTTON_TEXT[6]);
	}

	private void updateScoreButtons() {
		if (player[currentPlayer].getScore().getAces() < 0) {
			upperScoreButton[0].setEnabled(true);
			upperScoreButton[0].setText(UPPER_BUTTON_TEXT[0] + ": " + Integer.toString(Game.getAcesVal()));
		} else {
			upperScoreButton[0].setEnabled(false);
			upperScoreButton[0].setText(UPPER_BUTTON_TEXT[0]);
		}

		if (player[currentPlayer].getScore().getTwos() < 0) {
			upperScoreButton[1].setEnabled(true);
			upperScoreButton[1].setText(UPPER_BUTTON_TEXT[1] + ": " + Integer.toString(Game.getTwosVal()));
		} else {
			upperScoreButton[1].setEnabled(false);
			upperScoreButton[1].setText(UPPER_BUTTON_TEXT[1]);
		}

		if (player[currentPlayer].getScore().getThrees() < 0) {
			upperScoreButton[2].setEnabled(true);
			upperScoreButton[2].setText(UPPER_BUTTON_TEXT[2] + ": " + Integer.toString(Game.getThreesVal()));
		} else {
			upperScoreButton[2].setEnabled(false);
			upperScoreButton[2].setText(UPPER_BUTTON_TEXT[2]);
		}

		if (player[currentPlayer].getScore().getFours() < 0) {
			upperScoreButton[3].setEnabled(true);
			upperScoreButton[3].setText(UPPER_BUTTON_TEXT[3] + ": " + Integer.toString(Game.getFoursVal()));
		} else {
			upperScoreButton[3].setEnabled(false);
			upperScoreButton[3].setText(UPPER_BUTTON_TEXT[3]);
		}

		if (player[currentPlayer].getScore().getFives() < 0) {
			upperScoreButton[4].setEnabled(true);
			upperScoreButton[4].setText(UPPER_BUTTON_TEXT[4] + ": " + Integer.toString(Game.getFivesVal()));
		} else {
			upperScoreButton[4].setEnabled(false);
			upperScoreButton[4].setText(UPPER_BUTTON_TEXT[4]);
		}

		if (player[currentPlayer].getScore().getSixes() < 0) {
			upperScoreButton[5].setEnabled(true);
			upperScoreButton[5].setText(UPPER_BUTTON_TEXT[5] + ": " + Integer.toString(Game.getSixesVal()));
		} else {
			upperScoreButton[5].setEnabled(false);
			upperScoreButton[5].setText(UPPER_BUTTON_TEXT[5]);
		}

		if (player[currentPlayer].getScore().getThreeOfAKind() < 0) {
			lowerScoreButton[0].setEnabled(true);
			lowerScoreButton[0].setText(LOWER_BUTTON_TEXT[0] + ": " + Integer.toString(Game.getTOAKVal()));
		} else {
			lowerScoreButton[0].setEnabled(false);
			lowerScoreButton[0].setText(LOWER_BUTTON_TEXT[0]);
		}

		if (player[currentPlayer].getScore().getFourOfAKind() < 0) {
			lowerScoreButton[1].setEnabled(true);
			lowerScoreButton[1].setText(LOWER_BUTTON_TEXT[1] + ": " + Integer.toString(Game.getFOAKVal()));
		} else {
			lowerScoreButton[1].setEnabled(false);
			lowerScoreButton[1].setText(LOWER_BUTTON_TEXT[1]);
		}

		if (player[currentPlayer].getScore().getFullHouse() < 0) {
			lowerScoreButton[2].setEnabled(true);
			lowerScoreButton[2].setText(LOWER_BUTTON_TEXT[2] + ": " + Integer.toString(Game.getFHVal()));
		} else {
			lowerScoreButton[2].setEnabled(false);
			lowerScoreButton[2].setText(LOWER_BUTTON_TEXT[2]);
		}

		if (player[currentPlayer].getScore().getSmStraight() < 0) {
			lowerScoreButton[3].setEnabled(true);
			lowerScoreButton[3].setText(LOWER_BUTTON_TEXT[3] + ": " + Integer.toString(Game.getSSVal()));
		} else {
			lowerScoreButton[3].setEnabled(false);
			lowerScoreButton[3].setText(LOWER_BUTTON_TEXT[3]);
		}

		if (player[currentPlayer].getScore().getLgStraight() < 0) {
			lowerScoreButton[4].setEnabled(true);
			lowerScoreButton[4].setText(LOWER_BUTTON_TEXT[4] + ": " + Integer.toString(Game.getLSVal()));
		} else {
			lowerScoreButton[4].setEnabled(false);
			lowerScoreButton[4].setText(LOWER_BUTTON_TEXT[4]);
		}

		if (player[currentPlayer].getScore().getYacht() < 0) {
			lowerScoreButton[5].setEnabled(true);
			lowerScoreButton[5].setText(LOWER_BUTTON_TEXT[5] + ": " + Integer.toString(Game.getYachtVal()));
		} else {
			lowerScoreButton[5].setEnabled(false);
			lowerScoreButton[5].setText(LOWER_BUTTON_TEXT[5]);
		}

		if (player[currentPlayer].getScore().getChance() < 0) {
			lowerScoreButton[6].setEnabled(true);
			lowerScoreButton[6].setText(LOWER_BUTTON_TEXT[6] + ": " + Integer.toString(Game.getChanceVal()));
		} else {
			lowerScoreButton[6].setEnabled(false);
			lowerScoreButton[6].setText(LOWER_BUTTON_TEXT[6]);
		}
	}

	private void updateScoreSheet() {
		updateScoreSheet(currentPlayer);
	}

	private void updateScoreSheet(int playerNum) {
		player[playerNum].getScore().updateTotals();

		int[] uScore = {
			player[playerNum].getScore().getAces(),
			player[playerNum].getScore().getTwos(),
			player[playerNum].getScore().getThrees(),
			player[playerNum].getScore().getFours(),
			player[playerNum].getScore().getFives(),
			player[playerNum].getScore().getSixes(),
			player[playerNum].getScore().getUpperSubtotal(),
			player[playerNum].getScore().getBonus(),
			player[playerNum].getScore().getUpperTotal()
		};
		int[] lScore = {
			player[playerNum].getScore().getThreeOfAKind(),
			player[playerNum].getScore().getFourOfAKind(),
			player[playerNum].getScore().getFullHouse(),
			player[playerNum].getScore().getSmStraight(),
			player[playerNum].getScore().getLgStraight(),
			player[playerNum].getScore().getYacht(),
			player[playerNum].getScore().getChance(),
			player[playerNum].getScore().getLowerTotal(),
			player[playerNum].getScore().getUpperTotal(),
			player[playerNum].getScore().getGrandTotal()
		};

		for (int i = 0; i < 10; i++) {
			if (i < 9) {
				if (uScore[i] >= 0) {
					upperScoreValue[playerNum][i].setText(Integer.toString(uScore[i]));
				} else {
					upperScoreValue[playerNum][i].setText("");
				}
			}

			if (lScore[i] >= 0) {
				lowerScoreValue[playerNum][i].setText(Integer.toString(lScore[i]));
			} else {
				lowerScoreValue[playerNum][i].setText("");
			}
		}

	}

	private void showGameResults() {
		if (singlePlayer) {
			if (player[0].getScore().getGrandTotal() < player[2].getScore().getGrandTotal()) {
				scoreHeader[4].setText(Integer.toString(player[0].getScore().getGrandTotal() - player[2].getScore().getGrandTotal()));
			} else if (player[0].getScore().getGrandTotal() > player[2].getScore().getGrandTotal()) {
				scoreHeader[4].setText(Integer.toString(Math.round(100 * (player[0].getScore().getGrandTotal() / player[3].getScore().getGrandTotal()))));
			} else {
				scoreHeader[4].setText("Even");
			}
		} else if (player[0].getScore().getGrandTotal() > player[1].getScore().getGrandTotal()) {
			scoreHeader[4].setText("You win!");
		} else {
			scoreHeader[4].setText("Bot won.");
		}

		JOptionPane.showMessageDialog(frame.getRootPane(), "<html><center><h3>Final Result</h3></center><center><h1>" + scoreHeader[4].getText() + "</h1></center>", "Game Over", JOptionPane.PLAIN_MESSAGE);
	}

	private void checkForBot() {
		if (!singlePlayer && currentPlayer == 1 && turnCount > 0) {
			Bot.play();
		}
	}

	public JFrame getFrame() {
		return frame;
	}

	public ImageIcon[] getDieFaces() {
		return dieFaces;
	}

	public ImageIcon[] getSDieFaces() {
		return sDieFaces;
	}

	public ImageIcon getDieFace(int die) {
		return dieFaces[die];
	}

	public ImageIcon getSDieFace(int die) {
		return sDieFaces[die];
	}

	public JButton getRollButton() {
		return rollButton;
	}

	public JToggleButton[] getDiceButtons() {
		return dice;
	}

	public JToggleButton getDieButton(int btnNum) {
		return dice[btnNum];
	}

	public JButton[] getUpperScoreButtons() {
		return upperScoreButton;
	}

	public JButton[] getLowerScoreButtons() {
		return lowerScoreButton;
	}

	public JButton getUpperScoreButton(int btnNum) {
		return upperScoreButton[btnNum];
	}

	public JButton getLowerScoreButton(int btnNum) {
		return lowerScoreButton[btnNum];
	}

	public int getCurrentPlayer() {
		return currentPlayer;
	}

	public boolean[] getDiceList() {
		return diceList;
	}

	public Player[] getPlayers() {
		return player;
	}

	public Player getPlayer(int playerNum) {
		return player[playerNum];
	}

	public int getRollCount() {
		return rollCount;
	}

	public int getTurnCount() {
		return turnCount;
	}

}

Here's the AI routine. (In both of these, I've omitted the import statements, as those are correct for the program as it stands. If necessary, I can provide them.)

Java

public class Bot {

	private static boolean         needsSingleVal,   needsPairVal, needsLowPairVal;
	private static boolean         needsHighPairVal, needsTOAKVal, needsFOAKVal;
	private static boolean         needsYachtVal,    scored;
	private static boolean[]       needsDiceVals;
	private static int             single, pair, lowPair, highPair;
	private static int             toak,   foak, yacht,   cp;
	private static int[]           diceVals;
	private static JButton[]       lowerBtn = Yacht.window.getLowerScoreButtons();
	private static JButton[]       upperBtn = Yacht.window.getUpperScoreButtons();
	private static JToggleButton[] dice     = Yacht.window.getDiceButtons();
	private static Player[]        player   = Yacht.window.getPlayers();

	public static void play() {
		scored = false;
		cp     = Yacht.window.getCurrentPlayer();

		System.out.println("Turn #" + Integer.toString(14 - Yacht.window.getTurnCount()));
		System.out.println("Pre Bot Roll: " + Game.DICE.toString());

		do {
			Yacht.window.getRollButton().doClick(250);
			System.out.println("Bot Roll #" + Integer.toString(3 - Yacht.window.getRollCount()) + ": " + Game.DICE.toString());

			single = lowPair = highPair = toak = foak = yacht = 0;
			needsSingleVal = needsLowPairVal = needsHighPairVal = false;
			needsTOAKVal = needsFOAKVal = needsYachtVal = false;

			needsDiceVals = new boolean[] {false, false, false, false, false};

			diceVals = Arrays.copyOf(Game.DICE.getResults(), Game.DICE.getNumDice());

			Arrays.sort(diceVals);

			for (int i = 0; i < Game.DICE.getNumDice(); i++) {
				needsDiceVals[i] = needsVal(diceVals[i]);
			}


			for (int i = 0; i < Game.DICE.getSides(); i++) {
				switch (Game.getValCount()[i]) {
					case 5:
						single = lowPair = highPair = toak = foak = yacht = i + 1;
						needsYachtVal = needsVal(single);
						break;
					case 4:
						lowPair = toak = foak = i + 1;
						needsFOAKVal = needsVal(foak);
						break;
					case 3:
						if (lowPair == 0) {
							lowPair = toak = i + 1;
						} else {
							highPair = toak = i + 1;
						}

						needsTOAKVal = needsVal(toak);
						break;
					case 2:
						if (lowPair == 0) {
							lowPair = i + 1;
							needsLowPairVal = needsVal(lowPair);
						} else {
							highPair = i + 1;
							needsHighPairVal = needsVal(highPair);
						}
					case 1:
						single = i + 1;
						needsSingleVal = needsVal(single);
						break;
					default:
						break;
				}
			}

			if (lowPair > 0 && highPair == 0) {
				pair         = lowPair;
				needsPairVal = needsVal(pair);
			} else if (highPair > 0 && needsVal(highPair)) {
				pair         = highPair;
				needsPairVal = true;
			} else if (needsVal(lowPair)) {
				pair         = lowPair;
				needsPairVal = true;
			} else {
				pair         = 0;
				needsPairVal = false;
			}

			if (Game.hasYacht()) {
				if (player[cp].getScore().getYacht() < 0) {
					scored = true;
					lowerBtn[5].doClick(250);
					pause();
				} else if (needsYachtVal) {
					scored = true;
					pushUpperButton(yacht);
				} else if (Game.DICE.getTotal() > 25) {
					if (player[cp].getScore().getFourOfAKind() < 0) {
						scored = true;
						lowerBtn[1].doClick(250);
						pause();
					} else if (player[cp].getScore().getThreeOfAKind() < 0) {
						scored = true;
						lowerBtn[0].doClick(250);
						pause();
					} else if (player[cp].getScore().getChance() < 0) {
						scored = true;
						lowerBtn[6].doClick(250);
						pause();
					} else if (player[cp].getScore().getFullHouse() < 0) {
						scored = true;
						lowerBtn[2].doClick(250);
						pause();
					} else if (Yacht.window.getRollCount() > 0) {
						selectDice();
					} else {
						scored = true;
						zeroScore();
					}
				} else if (Game.DICE.getTotal() == 25) {
					if (player[cp].getScore().getFourOfAKind() < 0) {
						scored = true;
						lowerBtn[1].doClick(250);
						pause();
					} else if (player[cp].getScore().getFullHouse() < 0) {
						scored = true;
						lowerBtn[2].doClick(250);
						pause();
					} else if (player[cp].getScore().getThreeOfAKind() < 0) {
						scored = true;
						lowerBtn[0].doClick(250);
						pause();
					} else if (player[cp].getScore().getChance() < 0) {
						scored = true;
						lowerBtn[6].doClick(250);
						pause();
					} else if (Yacht.window.getRollCount() > 0) {
						selectDice();
					} else {
						scored = true;
						zeroScore();
					}
				} else {
					if (player[cp].getScore().getFullHouse() < 0) {
						scored = true;
						lowerBtn[2].doClick(250);
						pause();
					} else if (player[cp].getScore().getFourOfAKind() < 0) {
						scored = true;
						lowerBtn[1].doClick(250);
						pause();
					} else if (player[cp].getScore().getThreeOfAKind() < 0) {
						scored = true;
						lowerBtn[0].doClick(250);
						pause();
					} else if (Yacht.window.getRollCount() > 0) {
						selectDice();
					} else if (player[cp].getScore().getChance() < 0) {
						scored = true;
						lowerBtn[6].doClick(250);
						pause();
					} else {
						scored = true;
						zeroScore();
					}
				}
			} else if (Game.hasFourOfAKind()) {
				if (Yacht.window.getRollCount() > 0) {
					if (player[cp].getScore().getYacht()     < 0 || needsFOAKVal ||
						player[cp].getScore().getFullHouse() < 0) {
						selectDice("fourOfAKind");
					} else if (player[cp].getScore().getFourOfAKind() < 0) {
						if (single == 6) {
							scored = true;
							lowerBtn[1].doClick(250);
							pause();
						} else {
							selectDice("fourOfAKind");
						}
					} else if (needsSingleVal) {
						selectDice();
					}
				} else if (needsFOAKVal) {
					scored = true;
					pushUpperButton(foak);
				} else if (player[cp].getScore().getFourOfAKind() < 0) {
					scored = true;
					lowerBtn[1].doClick(250);
					pause();
				} else if (player[cp].getScore().getThreeOfAKind() < 0) {
					scored = true;
					lowerBtn[0].doClick(250);
					pause();
				} else if (player[cp].getScore().getChance() < 0) {
					scored = true;
					lowerBtn[1].doClick(250);
					pause();
				} else if (needsSingleVal) {
					scored = true;
					pushUpperButton(single);
				} else {
					scored = true;
					zeroScore();
				}
			} else if (Game.hasFullHouse()) {
				needsPairVal = false;
				pair         = 0;

				if (toak > lowPair) {
					pair = lowPair;
				} else {
					pair = highPair;
				}

				needsPairVal = needsVal(pair);

				if (player[cp].getScore().getFullHouse() < 0) {
					scored = true;
					lowerBtn[2].doClick(250);
					pause();
				} else if (Yacht.window.getRollCount() > 0) {
					if (player[cp].getScore().getYacht()       < 0 || needsTOAKVal ||
						player[cp].getScore().getFourOfAKind() < 0) {
						selectDice("threeOfAKind");
					} else if (player[cp].getScore().getThreeOfAKind() < 0) {
						if (pair == 6) {
							scored = true;
							lowerBtn[0].doClick(250);
							pause();
						} else {
							selectDice("threeOfAKind");
						}
					} else if (needsPairVal) {
						selectDice("pair");
					} else {
						selectDice();
					}
				} else if (needsTOAKVal) {
					scored = true;
					pushUpperButton(toak);
				} else if (player[cp].getScore().getThreeOfAKind() < 0) {
					scored = true;
					lowerBtn[0].doClick(250);
					pause();
				} else if (player[cp].getScore().getChance() < 0) {
					scored = true;
					lowerBtn[6].doClick(250);
					pause();
				} else if (needsPairVal) {
					scored = true;
					pushUpperButton(pair);
				} else {
					scored = true;
					zeroScore();
				}
			} else if (Game.hasThreeOfAKind()) {
				int     lowSingle         = 0,     highSingle         = 0;
				boolean needsLowSingleVal = false, needsHighSingleVal = false;

				for (int i = 0; i < Game.DICE.getSides(); i++) {
					if (Game.getValCount()[i] == 1) {
						if (lowSingle == 0) {
							lowSingle         = i + 1;
							needsLowSingleVal = needsVal(lowSingle);
						} else {
							highSingle         = i + 1;
							needsHighSingleVal = needsVal(highSingle);
						}
					}
				}

				if (Yacht.window.getRollCount() > 0) {
					if (player[cp].getScore().getYacht()        < 0 || needsTOAKVal ||
						player[cp].getScore().getFourOfAKind()  < 0 ||
						player[cp].getScore().getFullHouse()    < 0 ||
						player[cp].getScore().getThreeOfAKind() < 0) {
						selectDice("threeOfAKind");
					} else {
						selectDice();
					}
				} else if (needsTOAKVal) {
					scored = true;
					pushUpperButton(toak);
				} else if (player[cp].getScore().getThreeOfAKind() < 0) {
					scored = true;
					lowerBtn[0].doClick(250);
					pause();
				} else if (player[cp].getScore().getChance() < 0) {
					scored = true;
					lowerBtn[6].doClick(250);
					pause();
				} else if (needsLowSingleVal) {
					scored = true;
					pushUpperButton(lowSingle);
				} else if (needsHighSingleVal) {
					scored = true;
					pushUpperButton(highSingle);
				} else {
					scored = true;
					zeroScore();
				}
			} else if (Game.hasLgStraight()) {
				if (player[cp].getScore().getLgStraight() < 0) {
					scored = true;
					lowerBtn[4].doClick(250);
					pause();
				} else if (player[cp].getScore().getSmStraight() < 0) {
					scored = true;
					lowerBtn[3].doClick(250);
					pause();
				} else if (Yacht.window.getRollCount() > 0) {
					selectDice();
				} else if (player[cp].getScore().getChance() < 0) {
					scored = true;
					lowerBtn[6].doClick(250);
					pause();
				} else {
					for (int i = 0; i < Game.DICE.getNumDice(); i++) {
						if (needsDiceVals[i]) {
							scored = true;
							pushUpperButton(diceVals[i]);
							break;
						}
					}

					if (!scored) {
						scored = true;
						zeroScore();
					}
				}
			} else if (Game.hasSmStraight()) {
				if (Yacht.window.getRollCount() > 0) {
					if (player[cp].getScore().getLgStraight() < 0) {
						selectDice("smStraight");
					} else if (player[cp].getScore().getSmStraight() < 0) {
						scored = true;
						lowerBtn[3].doClick(250);
						pause();
					} else if (needsPairVal) {
						selectDice("pair");
					} else {
						selectDice();
					}
				} else if (player[cp].getScore().getSmStraight() < 0) {
					scored = true;
					lowerBtn[3].doClick(250);
					pause();
				} else if (player[cp].getScore().getChance() < 0) {
					scored = true;
					lowerBtn[6].doClick(250);
					pause();
				} else if (needsPairVal) {
					scored = true;
					pushUpperButton(pair);
				} else {
					for (int i = 0; i < Game.DICE.getNumDice(); i++) {
						if (needsDiceVals[i]) {
							scored = true;
							pushUpperButton(diceVals[i]);
							break;
						}
					}

					if (!scored) {
						scored = true;
						zeroScore();
					}
				}
			} else if (highPair > 0) {
				if (Yacht.window.getRollCount() > 0) {
					if (player[cp].getScore().getYacht()        < 0 || needsHighPairVal ||
						player[cp].getScore().getFourOfAKind()  < 0 ||
						player[cp].getScore().getThreeOfAKind() < 0) {
						selectDice("highPair");
					} else if (player[cp].getScore().getFullHouse() < 0) {
						selectDice("twoPair");
					} else if (needsLowPairVal) {
						selectDice("lowPair");
					} else {
						selectDice();
					}
				} else if (player[cp].getScore().getChance() < 0) {
					scored = true;
					lowerBtn[6].doClick(250);
				} else if (needsLowPairVal) {
					scored = true;
					pushUpperButton(lowPair);
				} else if (needsHighPairVal) {
					pushUpperButton(highPair);
				} else if (needsSingleVal) {
					scored = true;
					pushUpperButton(single);
				} else {
					scored = true;
					zeroScore();
				}
			} else if (pair > 0) {
				if (Yacht.window.getRollCount() > 0) {
					if (player[cp].getScore().getYacht()        < 0 || needsPairVal ||
						player[cp].getScore().getFourOfAKind()  < 0 ||
						player[cp].getScore().getThreeOfAKind() < 0 ||
						player[cp].getScore().getFullHouse()    < 0) {
						selectDice("pair");
					} else {
						selectDice();
					}
				} else if (player[cp].getScore().getChance() < 0) {
					scored = true;
					lowerBtn[6].doClick(250);
				} else if (needsPairVal) {
					scored = true;
					pushUpperButton(pair);
				} else {
					for (int i = 0; i < Game.DICE.getNumDice(); i++) {
						if (needsDiceVals[i]) {
							scored = true;
							pushUpperButton(diceVals[i]);
							break;
						}
					}

					if (!scored) {
						scored = true;
						zeroScore();
					}
				}
			} else {
				if (Yacht.window.getRollCount() > 0) {
					selectDice();
				} else if (player[cp].getScore().getChance() < 0) {
					scored = true;
					lowerBtn[6].doClick(250);
				} else {
					for (int i = 0; i < Game.DICE.getNumDice(); i++) {
						if (needsDiceVals[i]) {
							scored = true;
							pushUpperButton(diceVals[i]);
							break;
						}
					}

					if (!scored) {
						scored = true;
						zeroScore();
					}
				}
			}
		} while (Yacht.window.getRollCount() > 0 && !scored);
	}

	public static void pause() {
		pause(1000);
	}

	private static void pause(long time) {
		long t1, t2;
		t2 = System.currentTimeMillis();

		do {
			t1 = System.currentTimeMillis();
		} while (t1 - t2 < time);
	}

	private static void selectDice() {
		selectDice("");
	}

	private static void selectDice(String currHand) {
		for (int i = 0; i < Game.DICE.getNumDice(); i++) {
			dice[i].setSelected(false);
		}

		switch (currHand) {
			case "smStraight":
				boolean ace   = false;
				boolean two   = false;
				boolean three = false;
				boolean four  = false;
				boolean five  = false;
				boolean six   = false;

				for (int i = 0; i < Game.DICE.getNumDice(); i++) {
					switch (Game.DICE.getResult(i)) {
						case 1:
							if (diceVals[0] == 1 && !ace) {
								ace = true;
								dice[i].setSelected(true);
							} else {
								dice[i].setSelected(false);
							}

							break;
						case 2:
							if (diceVals[0] <= 2 && !two) {
								two = true;
								dice[i].setSelected(true);
							} else {
								dice[i].setSelected(false);
							}

							break;
						case 3:
							if (!three) {
								three = true;
								dice[i].setSelected(true);
							} else {
								dice[i].setSelected(false);
							}

							break;
						case 4:
							if (!four) {
								four = true;
								dice[i].setSelected(true);
							} else {
								dice[i].setSelected(false);
							}

							break;
						case 5:
							if (diceVals[4] >= 5 && !five) {
								five = true;
								dice[i].setSelected(true);
							} else {
								dice[i].setSelected(false);
							}
							break;
						case 6:
							if (diceVals[4] == 6 && !six) {
								six = true;
								dice[i].setSelected(true);
							} else {
								dice[i].setSelected(false);
							}
							break;
						default:
							break;
					}
				}

				break;
			case "threeOfAKind":
			case "fourOfAKind":
			case "highPair":
			case "lowPair":
			case "pair":
				int val;

				switch (currHand) {
					case "threeOfAKind":
						System.out.println("Selecting 3 of a Kind...");
						val = toak;
						break;
					case "fourOfAKind":
						System.out.println("Selecting 4 of a Kind...");
						val = foak;
						break;
					case "highPair":
						System.out.println("Selecting High Pair...");
						val = highPair;
						break;
					case "lowPair":
						System.out.println("Selecting Low Pair...");
						val = lowPair;
						break;
					default:
						System.out.println("Selecting Pair...");
						val = pair;
						break;
				}

				for (int i = 0; i < Game.DICE.getNumDice(); i++) {
					if (Game.DICE.getResult(i) == val) {
						dice[i].setSelected(true);
					} else {
						dice[i].setSelected(false);
					}
				}

				break;
			case "twoPair":
				System.out.println("Selecting Two Pair...");
				for (int i = 0; i < Game.DICE.getNumDice(); i++) {
					if ((Game.DICE.getResult(i) == highPair || Game.DICE.getResult(i) == lowPair)) {
						dice[i].setSelected(true);
					} else {
						dice[i].setSelected(false);
					}
				}

				break;
			default:
				int die = Game.DICE.getNumDice() - 1;

				single         = 0;
				needsSingleVal = false;

				for (int i = 0; i < Game.DICE.getNumDice(); i++) {
					if (needsDiceVals[die - i]) {
						single = diceVals[die - i];
						needsSingleVal = true;
						break;
					}
				}

				if (needsSingleVal) {
					System.out.println("Selecting " + Integer.toString(single) + "'s...");
					for (int i = 0; i < Game.DICE.getNumDice(); i++) {
						if (Game.DICE.getResult(i) == single) {
							dice[i].setSelected(true);
						} else {
							dice[i].setSelected(false);
						}
					}
				} else {
					System.out.println("Rolling all dice...");
					for (int i = 0; i < Game.DICE.getNumDice(); i++) {
						dice[i].setSelected(false);
					}
				}

				break;
		}
	}

	private static boolean needsVal(int val) {
		switch (val) {
			case 1:
				if (player[cp].getScore().getAces() < 0) {
					return true;
				} else {
					return false;
				}
			case 2:
				if (player[cp].getScore().getTwos() < 0) {
					return true;
				} else {
					return false;
				}
			case 3:
				if (player[cp].getScore().getThrees() < 0) {
					return true;
				} else {
					return false;
				}
			case 4:
				if (player[cp].getScore().getFours() < 0) {
					return true;
				} else {
					return false;
				}
			case 5:
				if (player[cp].getScore().getFives() < 0) {
					return true;
				} else {
					return false;
				}
			case 6:
				if (player[cp].getScore().getSixes() < 0) {
					return true;
				} else {
					return false;
				}
			default:
				return false;
		}
	}

	private static void pushUpperButton(int btnNum) {
		switch (btnNum) {
			case 1:
				upperBtn[0].doClick(250);
				pause();
				break;
			case 2:
				upperBtn[1].doClick(250);
				pause();
				break;
			case 3:
				upperBtn[2].doClick(250);
				pause();
				break;
			case 4:
				upperBtn[3].doClick(250);
				pause();
				break;
			case 5:
				upperBtn[4].doClick(250);
				pause();
				break;
			case 6:
				upperBtn[5].doClick(250);
				pause();
				break;
			default:
				break;
		}
	}

	private static void zeroScore() {
		if (player[cp].getScore().getChance() < 0) {
			lowerBtn[6].doClick();
			pause();
		} else if (player[cp].getScore().getLgStraight() < 0) {
			lowerBtn[4].doClick(250);
			pause();
		} else if (player[cp].getScore().getYacht() < 0) {
			lowerBtn[5].doClick(250);
			pause();
		} else if (player[cp].getScore().getSmStraight() < 0) {
			lowerBtn[3].doClick(250);
			pause();
		} else if (player[cp].getScore().getFullHouse() < 0) {
			lowerBtn[2].doClick(250);
			pause();
		} else if (player[cp].getScore().getFourOfAKind() < 0) {
			lowerBtn[1].doClick(250);
			pause();
		} else if (player[cp].getScore().getThreeOfAKind() < 0) {
			lowerBtn[0].doClick(250);
			pause();
		} else if (player[cp].getScore().getAces() < 0) {
			upperBtn[0].doClick(250);
			pause();
		} else if (player[cp].getScore().getTwos() < 0) {
			upperBtn[1].doClick(250);
			pause();
		} else if (player[cp].getScore().getThrees() < 0) {
			upperBtn[1].doClick(250);
			pause();
		} else if (player[cp].getScore().getFours() < 0) {
			upperBtn[1].doClick(250);
			pause();
		} else if (player[cp].getScore().getFives() < 0) {
			upperBtn[1].doClick(250);
			pause();
		} else {
			upperBtn[1].doClick(250);
			pause();
		}
	}

}

Sorry to have to say this, but I doubt that anyone is going to be able to offer much assistance with your program. There is far too much code there for anyone to begin to understand what it all does, and your problem description gives no clear clue as to where to even start looking. You need to narrow the problem down and provide more detail than "but the GUI freezes because of threading issues.". I am not sure why you would need threading in a simple game where each player makes a play in turn. Or what problem you would have with throwing dice, the simplest option is random numbers.

how to give the input on text box then all data fetch in remaining textbox automatically through database in jsp without press any button .

pls send code on my email id ankitraut05@gmail.com its very urgent.

I already gave you a suggestion at about java discussion - Web Development Discussion Boards - CodeProject[^]. No one is going to send you any code however many times you post this demand.

C#

import java.util.Scanner;
import java.util.Timer;
import java.util.TimerTask;

public  class StopWatch {
static int interval;
static Timer timer;

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    System.out.print("Input seconds => : ");
    String secs = sc.nextLine();
    int delay = 1000;
    int period = 1000;
    timer = new Timer();
    interval = Integer.parseInt(secs);
    System.out.println(secs);
    timer.scheduleAtFixedRate(new TimerTask() {

        public void run() {
            System.out.println(setInterval());

        }
    }, delay, period);
}

private static final int setInterval() {
    if (interval == 1)
        timer.cancel();
    return --interval;
}
}

Are you planning to give us any idea what the problem is?

It is not giving any error..please check again It runs fine on my machine Smile | :)

And you plan to tell us what errors and where ?

Patrice

“Everything should be made as simple as possible, but no simpler.” Albert Einstein

hi plz explain attribute dependency in rough sets using java.............

modified 21-Apr-16 1:32am.

I already answered this below. Please do not a) ask for code, or b) repost the same question.

plz any one send indiscernibility relation code in rough sets using java.................

See Forum Guidelines - PLEASE READ - Java Discussion Boards - CodeProject[^].

Hi,

I am working on a Java project. I want to get the content of a specific URL in an excel file.
i:e; Go to a given URL. there are different fields defined in the webpage, i:e: Name, ID, Address etc. I want to fetch these fields and store this information in an excel file.

Any help will be appreciated.

Regards,
mba

mbatra31 wrote:
Any help will be appreciated.

Help with what? You need to show what you have tried and what problems you are having.

Hi,

I am able to get the data from the web page into .html file or .txt file. But the problem is how to filter the data and get specific information which I want.
for example the data is in a .txt file spread over multiple lines. How to retrieve the specific fields from the file.
Here I am attaching the code which I have used:

C#

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;

public class GetContent {
    public static void main(String[] args) {

        URL url;

        try {
            // get URL content
            url = new URL("http://www.mims.com");
            URLConnection conn = url.openConnection();

            // open the stream and put it into BufferedReader
            BufferedReader br = new BufferedReader(
                               new InputStreamReader(conn.getInputStream()));

            String inputLine;

            //save to this filename
            String fileName = "E:\\sample.txt";
            File file = new File(fileName);

            if (!file.exists()) {
                file.createNewFile();
            }

            //use FileWriter to write file
            FileWriter fw = new FileWriter(file.getAbsoluteFile());
            BufferedWriter bw = new BufferedWriter(fw);

            while ((inputLine = br.readLine()) != null) {
                bw.write(inputLine);
            }

            bw.close();
            br.close();

        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

If you are just reading the HTML from the web page then you need to parse the data from the HTML. See java html parse - Google Search[^] for samples and suggestions.

Very New to Java, just learning arrays
I have an Object[] contents
Object [] contents = new Object[3];
so contents [1] = 3;
contents [2] = 3, 4, 5;
contents[3] = 5;

for (i = 0; i < contents.length; i++) {
System.out.println(contents);
//what I want to do is print content[2] as this
contents[2].1st element = 3
contents[2].2nd element = 4
contents[2].3rd element = 5

Please do not crosspost; I already gave you the answer in QA.