Hi to all Java developers!!
I’m planning to develop a board game in an intranet environment for my Thesis, this game is somewhat similar to Checkers.
The game is called “Bataan: Battle of the Philippines”. I need some help on where to start or what to implement first. Any help or advice from you guys is a big help for me.
What have you done so far. Also, *internet. And we aren’t going to spoon feed you code if thats what you want.
Why can’t it be an intranet? Maybe they have several computers at home?
I’d suggest the Resource page to start with as it has a ton of information! http://www.java-gaming.org/index.php?action=resources 
Mike
I’ve done the board and put up the pieces on to it. I’m having a problem on making them move according to the mouseclicked by the user. These is my code so far:
import java.awt.;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.image.BufferedImage;
import java.io.;
import java.util.ArrayList;
import javax.imageio.ImageIO;
import javax.swing.*;
/*
To change this template, choose Tools | Templates
and open the template in the editor.
/
/*
@author Compendio
*/
public class Bataan extends JPanel implements MouseListener, ActionListener {
private BufferedImage img; // image for the background of the game interface.
boolean inGameState; // gives true or false if a game is in progress.
int currentPlayer; // the current player to move.
int rowSelected, colSelected; // the row and column of the selected piece of the current player.
private JButton newGameButton; // Button for starting a new game.
private JButton quitButton; // Button to quit a game.
private JLabel message; // Label for displaying messages to the user.
int numberofJapanese; // the number of Japanese pieces.
/* instance of the class Piece, the pieces and the moves
BataanMoves[] validMoves; //array containing all the valid moves for the current player.
/* The main method creates a new JFrame as the window
/* The class contructor sets all the properties of the class
and initializes the background image.
*/
public Bataan() {
Font F = new Font(“kristen ITC”, Font.BOLD, 15);
setLayout(null);
addMouseListener(this);
setVisible(true);
setSize(700, 700);
quitButton = new JButton(“Quit”);
quitButton.addActionListener(this);
newGameButton = new JButton(“New Game”);
newGameButton.addActionListener(this);
message = new JLabel("", JLabel.CENTER);
message.setFont(F);
message.setForeground(Color.white);
boardPiece = new Piece();
add(newGameButton);
add(quitButton);
add(message);
newGameButton.setFont(F);
quitButton.setFont(F);
newGameButton.setBounds(100, 60, 120, 30);
quitButton.setBounds(300, 60, 100, 30);
message.setBounds(80, 600, 400, 30);
try {
img = ImageIO.read(new File(
“D:/Documents/NetBeansProjects/MyProjects/build/classes/Images/war2.jpg”));
} catch (IOException e) {
e.printStackTrace();
}
quitButton.setEnabled(false);
}
//Method called when the user clicks one of the buttons.
public void actionPerformed(ActionEvent evt) {
Object src = evt.getSource();
if (src == newGameButton) {
NewGame();
} else if (src == quitButton) {
QuitGame();
}
}
/*Sets a new game, the starting properties and paints the
// Called when the user clicks the Quit button.
void QuitGame() {
if (currentPlayer == Piece.Japanese) {
GameisOver(“Japanese quits, American wins!”);
} else {
GameisOver(“American quits, Japanese wins!”);
}
}
// Sets the properties when the game is over.
void GameisOver(String str) {
message.setText(str);
newGameButton.setEnabled(true);
quitButton.setEnabled(false);
inGameState = false;
}
/**
public void mouseReleased(MouseEvent e) {
}
public void mouseEntered(MouseEvent e) {
}
public void mouseExited(MouseEvent e) {
}
public void mouseClicked(MouseEvent e) {
}
/*When a user clicks on the board, checks if it is a piece or
a square on the board then, it makes the move.
*/
void squareClicked(int r, int c) {
for (int i = 0; i < validMoves.length; i++)
if (validMoves[i].currentRow == r && validMoves[i].currentCol == c) {
rowSelected = r;
colSelected = c;
if (currentPlayer == Piece.American) {
message.setText("American: Make your move.");
} else {
message.setText("Japanese: Make your move.");
}
repaint();
return;
}
if (rowSelected < 0) {
message.setText(“Click the piece you want to move.”);
return;
}
for (int i = 0; i < validMoves.length; i++)
if (validMoves[i].currentRow == rowSelected && validMoves[i].currentCol == colSelected
&& validMoves[i].nxtRow == r && validMoves[i].nxtCol == c) {
MakeMove(validMoves[i]);
return;
}
message.setText(“Click the square you want to move to.”);
}
void MakeMove(BataanMoves move) {
boardPiece.piecedoMove(move);
if (move.aJump()) {
validMoves = boardPiece.getValidJumps(currentPlayer, move.nxtRow, move.nxtCol);
if (validMoves != null) {
message.setText("American: You must continue jumping.");
}
rowSelected = move.nxtRow;
colSelected = move.nxtCol;
repaint();
return;
}
if (currentPlayer == Piece.Japanese) {
currentPlayer = Piece.American;
validMoves = boardPiece.getValidMoves(currentPlayer);
if (validMoves[0].aJump()) {
message.setText("American: Make your move, you must jump.");
} else {
message.setText("American: Make your move.");
}
} else {
currentPlayer = Piece.Japanese;
validMoves = boardPiece.getValidMoves(currentPlayer);
message.setText("Japanese: Make your move.");
}
rowSelected = -1;
if(validMoves != null){
boolean sameSquare = true;
for(int i=1; i<validMoves.length; i++){
if(validMoves[i].currentRow != validMoves[0].currentRow || validMoves[i].currentCol != validMoves[0].currentCol){
sameSquare = false;
break;
}
}
if(sameSquare){
rowSelected = validMoves[0].currentRow;
colSelected = validMoves[0].currentCol;
}
}
repaint();
}
/* Draws the playing board for the game
ands add the right pieces to it.
*/
public void paintComponent(Graphics g) {
int[] xPoints = {100, 150, 150};
int[] yPoints = {150, 200, 150};
int[] xPoints2 = {350, 400, 350};
int[] yPoints2 = {200, 150, 150};
int nPoints = 3;
Graphics2D g2 = (Graphics2D) g;
g2.setStroke(new BasicStroke(5));
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
g2.drawImage(img, 0, 0, getWidth(), getHeight(), this);
for (int row = 0; row < 8; row++) {
for (int col = 0; col < 8; col++) {
if ((row == 0 && (col == 6 || col == 7))
|| (row == 1 && (col == 6 || col == 7))
|| (row == 6 && (col == 7 || col == 6))
|| (row == 7 && (col == 6 || col == 7))
|| (row == 0 && (col == 1 || col == 0))
|| (row == 1 && (col == 1 || col == 0))
|| (row == 6 && (col == 0 || col == 1))
|| (row == 7 && (col == 1 || col == 0))) {
} else {
if (col == 0 || col == 1) {
g2.setColor(Color.blue);
g2.fillRect(50 + row * 50, 150 + col * 50, 50, 50);
} else {
g2.setColor(Color.gray);
g2.fillRect(50 + row * 50, 150 + col * 50, 50, 50);
}
g2.setColor(Color.red);
g2.drawRect(50 + row * 50, 150 + col * 50, 50, 50);
if (row % 2 == col % 2) {
g2.setColor(Color.red);
g2.drawLine(50 + row * 50, 150 + col * 50, 100 + row * 50, 200 + col * 50);
} else {
g2.setColor(Color.red);
g2.drawLine(100 + row * 50, 150 + col * 50, 50 + row * 50, 200 + col * 50);
}
g2.setColor(Color.blue);
g2.fillPolygon(xPoints, yPoints, nPoints);
g2.fillPolygon(xPoints2, yPoints2, nPoints);
g2.setColor(Color.red);
g2.drawPolygon(xPoints, yPoints, nPoints);
g2.drawPolygon(xPoints2, yPoints2, nPoints);
}
}
}
for (int row = 0; row <= 8; row++) {
for (int col = 0; col <= 8; col++) {
if (((row == 0 || row == 8) && col == 0) || ((row == 0 | row == 1) && col == 1) || ((row == 7 || row == 8) && col == 1) || ((row == 0 || row == 1 || row == 7 || row == 8) && col == 7) || ((row == 0 || row == 1 || row == 8 || row == 7) && col == 8)) {
} else if (col == 0 || col == 1
|| (col == 2 && row == 2)
|| (col == 2 && row == 3)
|| (col == 2 && row == 4)
|| (col == 2 && row == 5)
|| (col == 2 && row == 6)) {
g2.setColor(Color.green);
g2.drawRect(40 + row * 50, 140 + col * 50, 20, 20);
g2.fillRect(40 + row * 50, 140 + col * 50, 20, 20);
} else if (col == 2 || col == 3 || col == 4 || col == 5 || col == 6 || col == 7 || col == 8) {
g2.setColor(Color.white);
g2.drawRect(40 + row * 50, 140 + col * 50, 20, 20);
g2.fillRect(40 + row * 50, 140 + col * 50, 20, 20);
}
if (boardPiece.pieceAt(row, col) == Piece.American) {
g.setColor(Color.black);
g.drawOval(42 + row * 50, 142 + col * 50, 15, 15);
g.setColor(Color.blue);
g.fillOval(42 + row * 50, 142 + col * 50, 15, 15);
} else if (boardPiece.pieceAt(row, col) == Piece.Japanese) {
g.setColor(Color.black);
g.drawOval(42 + row * 50, 142 + col * 50, 15, 15);
g.setColor(Color.yellow);
g.fillOval(42 + row * 50, 142 + col * 50, 15, 15);
}
}
}
//g2.setStroke(new BasicStroke(3));
if (inGameState){
g.setColor(Color.blue);
for (int i = 0; i < validMoves.length; i++) {
g2.drawRect(38 + validMoves[i].currentRow * 50, 138 + validMoves[i].currentCol * 50, 24, 24);
}
if (rowSelected >= 0) {
g.setColor(Color.yellow);
g2.drawRect(38 + rowSelected * 50, 138 + colSelected * 50, 24, 24);
g.setColor(Color.black);
for (int i = 0; i < validMoves.length; i++) {
if (validMoves[i].currentCol == colSelected && validMoves[i].currentRow == rowSelected) {
g2.drawRect(38 + validMoves[i].nxtRow * 50, 138 + validMoves[i].nxtCol * 50, 24, 24);
}
}
}
}
}
private static class BataanMoves {
int currentRow, currentCol, nxtRow, nxtCol;
public BataanMoves(int row1, int col1, int row2, int col2) {
currentRow = row1;
currentCol = col1;
nxtRow = row2;
nxtCol = col2;
}
boolean aJump() {
return (currentRow - nxtRow == 2 || currentRow - nxtRow == -2 || currentCol - nxtCol == 2 || currentCol - nxtCol == -2);
}
}
/**
An object of this class holds data about the game of Bataan: Battle of the Philippines.
It knows what kind of piece is on each square of the board.
Methods are provided to return lists of available legal moves.
*/
private static class Piece {
static final int American = 1, Japanese = 2, Empty = 0, NotPartofBoard = -1; //constants that hold the players and the empty slot in the board.
int[][] myBoard; //array to store the contents of the board in specifis row and column.
public Piece() { //contructor to save the pieces in the board and set it up for a new game.
myBoard = new int[9][9];
setGame();
}
/* Set the contents of the board with American and Japanese pieces in position
}
//returns the content of the specific pair of row and column in the board.
int pieceAt(int Row, int Col) {
return myBoard[Row][Col];
}
/**
/**
Make the move from (currentRow,currentCol) to (nxtRow,nxtCol). It is
assumed that this move is legal. If the move is a jump, the
jumped piece is removed from the board.
*/
void piecedoMove(int currentRow, int currentCol, int nxtRow, int nxtCol, int player) {
if (player == American) { //check if the current player is the American, it can jump.
int jumpedRow, jumpedCol;
if (((nxtRow - currentRow == 2) && (currentCol == nxtCol))) {
jumpedCol = currentCol;
jumpedRow = nxtRow - 1;
} else if (((nxtRow - currentRow == -2) && (currentCol == nxtCol))) {
jumpedCol = currentCol;
jumpedRow = nxtRow + 1;
} else if ((nxtCol - currentCol == 2) && (currentRow == nxtRow)) {
jumpedCol = nxtCol - 1;
jumpedRow = currentRow;
} else if ((nxtCol - currentCol == -2) && (currentRow == nxtRow)) {
jumpedCol = nxtCol + 1;
jumpedRow = currentRow;
} else {
jumpedCol = (nxtCol + currentCol) / 2;
jumpedRow = (nxtRow + currentRow) / 2;
}
myBoard[jumpedRow][jumpedCol] = Empty;
}else{
myBoard[nxtRow][nxtCol] = myBoard[currentRow][currentCol];
myBoard[currentRow][currentCol] = Empty;
}
}
/**
This is called by the two getValidMoves() and getValidJumps() methods to check whether the
player can legally jump from (r1,c1) to (r3,c3). It is assumed
that the player has a piece at (r1,c1), that (r3,c3) is a position
that is 2 rows and 2 columns distant from (r1,c1) and that
(r2,c2) is the square between (r1,c1) and (r3,c3).
*/
private boolean pieceCanJump(int player, int r1, int c1, int r2, int c2, int r3, int c3) {
//only the American piece can do a jump.
if (player == American && myBoard[r1][c1] == American) {
//(r3,c3) is out of the board.
if (r3 < 0 || r3 >8 || c3 < 0 || c3 >8 || myBoard[r3][c3] == NotPartofBoard) {
return false;
}
//(r3,c3) contains a piece.
if (myBoard[r3][c3] != Empty) {
return false;
}
//there is no Japanese piece to jump on.
if (myBoard[r2][c2] != Japanese) {
return false;
}
return true; //jump is valid.
} else {
return false;
}
}
/**
}
/**
Return an array containing all the legal BataanMoves
for the specified player on the current board. If the player
has no legal moves, null is returned. The value of player
should be one of the constants American and Japanese; if not, null
is returned. If the returned value is non-null, it consists
entirely of jump moves if the player is an American or entirely of regular moves if Japanese, since
if the player can jump, only jumps are legal moves.
*/
BataanMoves[] getValidMoves(int player) {
//player is not an American or a Japanese.
if (player != American && player != Japanese) {
return null;
}
//array list to store the valid moves.
ArrayList moves = new ArrayList();
/* Check all squares on the board for any possible jumps for the current
player if the player is Japanese nothing will be stored. If the player is an American
it checks the eight possible directions from that square if a jump is available it is
stored in the array list.
*/
for (int row = 0; row <= 8; row++) {
for (int col = 0; col <= 8; col++) {
if (myBoard[row][col] == player) {
if(row%2 == col%2){
if (pieceCanJump(player, row, col, row + 1, col + 1, row + 2, col + 2)) {
moves.add(new BataanMoves(row, col, row + 2, col + 2));
}
if (pieceCanJump(player, row, col, row - 1, col + 1, row - 2, col + 2)) {
moves.add(new BataanMoves(row, col, row - 2, col + 2));
}
if (pieceCanJump(player, row, col, row + 1, col - 1, row + 2, col - 2)) {
moves.add(new BataanMoves(row, col, row + 2, col - 2));
}
if (pieceCanJump(player, row, col, row - 1, col - 1, row - 2, col - 2)) {
moves.add(new BataanMoves(row, col, row - 2, col - 2));
}
if (pieceCanJump(player, row, col, row, col - 1, row, col - 2)) {
moves.add(new BataanMoves(row, col, row, col - 2));
}
if (pieceCanJump(player, row, col, row, col + 1, row, col + 2)) {
moves.add(new BataanMoves(row, col, row, col + 2));
}
if (pieceCanJump(player, row, col, row - 1, col, row - 2, col)) {
moves.add(new BataanMoves(row, col, row - 2, col));
}
if (pieceCanJump(player, row, col, row + 1, col, row + 2, col)) {
moves.add(new BataanMoves(row, col, row + 2, col));
}
}else{
if (pieceCanJump(player, row, col, row-1, col, row-2, col)) {
moves.add(new BataanMoves(row, col, row, col - 2));
}
if (pieceCanJump(player, row, col, row, col - 1, row, col - 2)) {
moves.add(new BataanMoves(row, col, row, col - 2));
}
if (pieceCanJump(player, row, col, row, col + 1, row, col + 2)) {
moves.add(new BataanMoves(row, col, row, col + 2));
}
if (pieceCanJump(player, row, col, row + 1, col, row + 2, col)) {
moves.add(new BataanMoves(row, col, row + 2, col));
}
}
}
}
}
/*After checking if there are available jumps and the array list is still empty,
the second check is if there are valid normal move for the player,still every
square of the board is checked for all the valid moves in the players piece.
*/
if (moves.isEmpty()) {
for (int row = 0; row <= 8; row++) {
for (int col = 0; col <= 8; col++) {
if (myBoard[row][col] == player) {
if(row%2 == col%2){
if (pieceCanMove(player, row, col, row + 1, col)) {
moves.add(new BataanMoves(row, col, row + 1, col));
}
if (pieceCanMove(player, row, col, row - 1, col)) {
moves.add(new BataanMoves(row, col, row - 1, col));
}
if (pieceCanMove(player, row, col, row + 1, col + 1)) {
moves.add(new BataanMoves(row, col, row + 1, col + 1));
}
if (pieceCanMove(player, row, col, row + 1, col - 1)) {
moves.add(new BataanMoves(row, col, row + 1, col - 1));
}
if (pieceCanMove(player, row, col, row, col + 1)) {
moves.add(new BataanMoves(row, col, row, col + 1));
}
if (pieceCanMove(player, row, col, row, col - 1)) {
moves.add(new BataanMoves(row, col, row, col - 1));
}
if (pieceCanMove(player, row, col, row - 1, col + 1)) {
moves.add(new BataanMoves(row, col, row - 1, col + 1));
}
if (pieceCanMove(player, row, col, row - 1, col - 1)) {
moves.add(new BataanMoves(row, col, row - 1, col - 1));
}
}else{
if (pieceCanMove(player, row, col, row - 1, col)) {
moves.add(new BataanMoves(row, col, row, col - 2));
}
if (pieceCanMove(player, row, col, row, col - 1)) {
moves.add(new BataanMoves(row, col, row, col - 2));
}
if (pieceCanMove(player, row, col, row, col + 1)) {
moves.add(new BataanMoves(row, col, row, col + 2));
}
if (pieceCanMove(player, row, col, row + 1, col)) {
moves.add(new BataanMoves(row, col, row + 2, col));
}
}
}
}
}
}
/*if still no legal moves are found return null else
/**
Return a list of the legal jumps that the specified player can
make starting from the specified row and column. If no such
jumps are possible, null is returned. The logic is similar
to the logic of the getLegalMoves() method.
*/
BataanMoves[] getValidJumps(int player, int row, int col) {
if (player != American) {
return null;
}
ArrayList moves = new ArrayList();
if (myBoard[row][col] == player) {
if(row%2 == col%2){
if (pieceCanJump(player, row, col, row + 1, col + 1, row + 2, col + 2)) {
moves.add(new BataanMoves(row, col, row + 2, col + 2));
}
if (pieceCanJump(player, row, col, row - 1, col + 1, row - 2, col + 2)) {
moves.add(new BataanMoves(row, col, row - 2, col + 2));
}
if (pieceCanJump(player, row, col, row + 1, col - 1, row + 2, col - 2)) {
moves.add(new BataanMoves(row, col, row + 2, col - 2));
}
if (pieceCanJump(player, row, col, row - 1, col - 1, row - 2, col - 2)) {
moves.add(new BataanMoves(row, col, row - 2, col - 2));
}
if (pieceCanJump(player, row, col, row, col - 1, row, col - 2)) {
moves.add(new BataanMoves(row, col, row, col - 2));
}
if (pieceCanJump(player, row, col, row, col + 1, row, col + 2)) {
moves.add(new BataanMoves(row, col, row, col + 2));
}
if (pieceCanJump(player, row, col, row - 1, col, row - 2, col)) {
moves.add(new BataanMoves(row, col, row - 2, col));
}
if (pieceCanJump(player, row, col, row + 1, col, row + 2, col)) {
moves.add(new BataanMoves(row, col, row + 2, col));
}
}else{
if (pieceCanJump(player, row, col, row-1, col, row-2, col)) {
moves.add(new BataanMoves(row, col, row, col - 2));
}
if (pieceCanJump(player, row, col, row, col - 1, row, col - 2)) {
moves.add(new BataanMoves(row, col, row, col - 2));
}
if (pieceCanJump(player, row, col, row, col + 1, row, col + 2)) {
moves.add(new BataanMoves(row, col, row, col + 2));
}
if (pieceCanJump(player, row, col, row + 1, col, row + 2, col)) {
moves.add(new BataanMoves(row, col, row + 2, col));
}
}
}
if (moves.isEmpty()) {
return null;
} else {
BataanMoves[] movesArray = new BataanMoves[moves.size()];
for (int i = 0; i < moves.size(); i++) {
movesArray[i] = moves.get(i);
}
return movesArray;
}
}
}
}
Sorry, didnt think about what intranet meant!
Please dont dump your code here without code tags. And for extra long code dumps like yours, host them on a code hosting site.
Again, we aren’t going to spoon feed you code. Go look at the link and read everything you can find on google. Then come back with specific problems. People will be more willing to help!
okay this what i’be done done so far, drawing the board and setting up the the pieces. Im having a dificulty on making a move when the user clicks a piece.
import java.awt.;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.image.BufferedImage;
import java.io.;
import java.util.ArrayList;
import javax.imageio.ImageIO;
import javax.swing.*;
/*
To change this template, choose Tools | Templates
and open the template in the editor.
/
/*
@author Compendio
*/
public class Bataan extends JPanel implements MouseListener, ActionListener {
private BufferedImage img; // image for the background of the game interface.
boolean inGameState; // gives true or false if a game is in progress.
int currentPlayer; // the current player to move.
int rowSelected, colSelected; // the row and column of the selected piece of the current player.
private JButton newGameButton; // Button for starting a new game.
private JButton quitButton; // Button to quit a game.
private JLabel message; // Label for displaying messages to the user.
int numberofJapanese; // the number of Japanese pieces.
/* instance of the class Piece, the pieces and the moves
BataanMoves[] validMoves; //array containing all the valid moves for the current player.
/* The main method creates a new JFrame as the window
/* The class contructor sets all the properties of the class
and initializes the background image.
*/
public Bataan() {
Font F = new Font(“kristen ITC”, Font.BOLD, 15);
setLayout(null);
addMouseListener(this);
setVisible(true);
setSize(700, 700);
quitButton = new JButton(“Quit”);
quitButton.addActionListener(this);
newGameButton = new JButton(“New Game”);
newGameButton.addActionListener(this);
message = new JLabel("", JLabel.CENTER);
message.setFont(F);
message.setForeground(Color.white);
boardPiece = new Piece();
add(newGameButton);
add(quitButton);
add(message);
newGameButton.setFont(F);
quitButton.setFont(F);
newGameButton.setBounds(100, 60, 120, 30);
quitButton.setBounds(300, 60, 100, 30);
message.setBounds(80, 600, 400, 30);
try {
img = ImageIO.read(new File(
“D:/Documents/NetBeansProjects/MyProjects/build/classes/Images/war2.jpg”));
} catch (IOException e) {
e.printStackTrace();
}
quitButton.setEnabled(false);
}
//Method called when the user clicks one of the buttons.
public void actionPerformed(ActionEvent evt) {
Object src = evt.getSource();
if (src == newGameButton) {
NewGame();
} else if (src == quitButton) {
QuitGame();
}
}
/*Sets a new game, the starting properties and paints the
// Called when the user clicks the Quit button.
void QuitGame() {
if (currentPlayer == Piece.Japanese) {
GameisOver(“Japanese quits, American wins!”);
} else {
GameisOver(“American quits, Japanese wins!”);
}
}
// Sets the properties when the game is over.
void GameisOver(String str) {
message.setText(str);
newGameButton.setEnabled(true);
quitButton.setEnabled(false);
inGameState = false;
}
/**
public void mouseReleased(MouseEvent e) {
}
public void mouseEntered(MouseEvent e) {
}
public void mouseExited(MouseEvent e) {
}
public void mouseClicked(MouseEvent e) {
}
/*When a user clicks on the board, checks if it is a piece or
a square on the board then, it makes the move.
*/
void squareClicked(int r, int c) {
for (int i = 0; i < validMoves.length; i++)
if (validMoves[i].currentRow == r && validMoves[i].currentCol == c) {
rowSelected = r;
colSelected = c;
if (currentPlayer == Piece.American) {
message.setText("American: Make your move.");
} else {
message.setText("Japanese: Make your move.");
}
repaint();
return;
}
if (rowSelected < 0) {
message.setText(“Click the piece you want to move.”);
return;
}
for (int i = 0; i < validMoves.length; i++)
if (validMoves[i].currentRow == rowSelected && validMoves[i].currentCol == colSelected
&& validMoves[i].nxtRow == r && validMoves[i].nxtCol == c) {
MakeMove(validMoves[i]);
return;
}
message.setText(“Click the square you want to move to.”);
}
void MakeMove(BataanMoves move) {
boardPiece.piecedoMove(move);
if (move.aJump()) {
validMoves = boardPiece.getValidJumps(currentPlayer, move.nxtRow, move.nxtCol);
if (validMoves != null) {
message.setText("American: You must continue jumping.");
}
rowSelected = move.nxtRow;
colSelected = move.nxtCol;
repaint();
return;
}
if (currentPlayer == Piece.Japanese) {
currentPlayer = Piece.American;
validMoves = boardPiece.getValidMoves(currentPlayer);
if (validMoves[0].aJump()) {
message.setText("American: Make your move, you must jump.");
} else {
message.setText("American: Make your move.");
}
} else {
currentPlayer = Piece.Japanese;
validMoves = boardPiece.getValidMoves(currentPlayer);
message.setText("Japanese: Make your move.");
}
rowSelected = -1;
if(validMoves != null){
boolean sameSquare = true;
for(int i=1; i<validMoves.length; i++){
if(validMoves[i].currentRow != validMoves[0].currentRow || validMoves[i].currentCol != validMoves[0].currentCol){
sameSquare = false;
break;
}
}
if(sameSquare){
rowSelected = validMoves[0].currentRow;
colSelected = validMoves[0].currentCol;
}
}
repaint();
}
/* Draws the playing board for the game
ands add the right pieces to it.
*/
public void paintComponent(Graphics g) {
int[] xPoints = {100, 150, 150};
int[] yPoints = {150, 200, 150};
int[] xPoints2 = {350, 400, 350};
int[] yPoints2 = {200, 150, 150};
int nPoints = 3;
Graphics2D g2 = (Graphics2D) g;
g2.setStroke(new BasicStroke(5));
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
g2.drawImage(img, 0, 0, getWidth(), getHeight(), this);
for (int row = 0; row < 8; row++) {
for (int col = 0; col < 8; col++) {
if ((row == 0 && (col == 6 || col == 7))
|| (row == 1 && (col == 6 || col == 7))
|| (row == 6 && (col == 7 || col == 6))
|| (row == 7 && (col == 6 || col == 7))
|| (row == 0 && (col == 1 || col == 0))
|| (row == 1 && (col == 1 || col == 0))
|| (row == 6 && (col == 0 || col == 1))
|| (row == 7 && (col == 1 || col == 0))) {
} else {
if (col == 0 || col == 1) {
g2.setColor(Color.blue);
g2.fillRect(50 + row * 50, 150 + col * 50, 50, 50);
} else {
g2.setColor(Color.gray);
g2.fillRect(50 + row * 50, 150 + col * 50, 50, 50);
}
g2.setColor(Color.red);
g2.drawRect(50 + row * 50, 150 + col * 50, 50, 50);
if (row % 2 == col % 2) {
g2.setColor(Color.red);
g2.drawLine(50 + row * 50, 150 + col * 50, 100 + row * 50, 200 + col * 50);
} else {
g2.setColor(Color.red);
g2.drawLine(100 + row * 50, 150 + col * 50, 50 + row * 50, 200 + col * 50);
}
g2.setColor(Color.blue);
g2.fillPolygon(xPoints, yPoints, nPoints);
g2.fillPolygon(xPoints2, yPoints2, nPoints);
g2.setColor(Color.red);
g2.drawPolygon(xPoints, yPoints, nPoints);
g2.drawPolygon(xPoints2, yPoints2, nPoints);
}
}
}
for (int row = 0; row <= 8; row++) {
for (int col = 0; col <= 8; col++) {
if (((row == 0 || row == 8) && col == 0) || ((row == 0 | row == 1) && col == 1) || ((row == 7 || row == 8) && col == 1) || ((row == 0 || row == 1 || row == 7 || row == 8) && col == 7) || ((row == 0 || row == 1 || row == 8 || row == 7) && col == 8)) {
} else if (col == 0 || col == 1
|| (col == 2 && row == 2)
|| (col == 2 && row == 3)
|| (col == 2 && row == 4)
|| (col == 2 && row == 5)
|| (col == 2 && row == 6)) {
g2.setColor(Color.green);
g2.drawRect(40 + row * 50, 140 + col * 50, 20, 20);
g2.fillRect(40 + row * 50, 140 + col * 50, 20, 20);
} else if (col == 2 || col == 3 || col == 4 || col == 5 || col == 6 || col == 7 || col == 8) {
g2.setColor(Color.white);
g2.drawRect(40 + row * 50, 140 + col * 50, 20, 20);
g2.fillRect(40 + row * 50, 140 + col * 50, 20, 20);
}
if (boardPiece.pieceAt(row, col) == Piece.American) {
g.setColor(Color.black);
g.drawOval(42 + row * 50, 142 + col * 50, 15, 15);
g.setColor(Color.blue);
g.fillOval(42 + row * 50, 142 + col * 50, 15, 15);
} else if (boardPiece.pieceAt(row, col) == Piece.Japanese) {
g.setColor(Color.black);
g.drawOval(42 + row * 50, 142 + col * 50, 15, 15);
g.setColor(Color.yellow);
g.fillOval(42 + row * 50, 142 + col * 50, 15, 15);
}
}
}
//g2.setStroke(new BasicStroke(3));
if (inGameState){
g.setColor(Color.blue);
for (int i = 0; i < validMoves.length; i++) {
g2.drawRect(38 + validMoves[i].currentRow * 50, 138 + validMoves[i].currentCol * 50, 24, 24);
}
if (rowSelected >= 0) {
g.setColor(Color.yellow);
g2.drawRect(38 + rowSelected * 50, 138 + colSelected * 50, 24, 24);
g.setColor(Color.black);
for (int i = 0; i < validMoves.length; i++) {
if (validMoves[i].currentCol == colSelected && validMoves[i].currentRow == rowSelected) {
g2.drawRect(38 + validMoves[i].nxtRow * 50, 138 + validMoves[i].nxtCol * 50, 24, 24);
}
}
}
}
}
private static class BataanMoves {
int currentRow, currentCol, nxtRow, nxtCol;
public BataanMoves(int row1, int col1, int row2, int col2) {
currentRow = row1;
currentCol = col1;
nxtRow = row2;
nxtCol = col2;
}
boolean aJump() {
return (currentRow - nxtRow == 2 || currentRow - nxtRow == -2 || currentCol - nxtCol == 2 || currentCol - nxtCol == -2);
}
}
/**
An object of this class holds data about the game of Bataan: Battle of the Philippines.
It knows what kind of piece is on each square of the board.
Methods are provided to return lists of available legal moves.
*/
private static class Piece {
static final int American = 1, Japanese = 2, Empty = 0, NotPartofBoard = -1; //constants that hold the players and the empty slot in the board.
int[][] myBoard; //array to store the contents of the board in specifis row and column.
public Piece() { //contructor to save the pieces in the board and set it up for a new game.
myBoard = new int[9][9];
setGame();
}
/* Set the contents of the board with American and Japanese pieces in position
}
//returns the content of the specific pair of row and column in the board.
int pieceAt(int Row, int Col) {
return myBoard[Row][Col];
}
/**
/**
Make the move from (currentRow,currentCol) to (nxtRow,nxtCol). It is
assumed that this move is legal. If the move is a jump, the
jumped piece is removed from the board.
*/
void piecedoMove(int currentRow, int currentCol, int nxtRow, int nxtCol, int player) {
if (player == American) { //check if the current player is the American, it can jump.
int jumpedRow, jumpedCol;
if (((nxtRow - currentRow == 2) && (currentCol == nxtCol))) {
jumpedCol = currentCol;
jumpedRow = nxtRow - 1;
} else if (((nxtRow - currentRow == -2) && (currentCol == nxtCol))) {
jumpedCol = currentCol;
jumpedRow = nxtRow + 1;
} else if ((nxtCol - currentCol == 2) && (currentRow == nxtRow)) {
jumpedCol = nxtCol - 1;
jumpedRow = currentRow;
} else if ((nxtCol - currentCol == -2) && (currentRow == nxtRow)) {
jumpedCol = nxtCol + 1;
jumpedRow = currentRow;
} else {
jumpedCol = (nxtCol + currentCol) / 2;
jumpedRow = (nxtRow + currentRow) / 2;
}
myBoard[jumpedRow][jumpedCol] = Empty;
}else{
myBoard[nxtRow][nxtCol] = myBoard[currentRow][currentCol];
myBoard[currentRow][currentCol] = Empty;
}
}
/**
This is called by the two getValidMoves() and getValidJumps() methods to check whether the
player can legally jump from (r1,c1) to (r3,c3). It is assumed
that the player has a piece at (r1,c1), that (r3,c3) is a position
that is 2 rows and 2 columns distant from (r1,c1) and that
(r2,c2) is the square between (r1,c1) and (r3,c3).
*/
private boolean pieceCanJump(int player, int r1, int c1, int r2, int c2, int r3, int c3) {
//only the American piece can do a jump.
if (player == American && myBoard[r1][c1] == American) {
//(r3,c3) is out of the board.
if (r3 < 0 || r3 >8 || c3 < 0 || c3 >8 || myBoard[r3][c3] == NotPartofBoard) {
return false;
}
//(r3,c3) contains a piece.
if (myBoard[r3][c3] != Empty) {
return false;
}
//there is no Japanese piece to jump on.
if (myBoard[r2][c2] != Japanese) {
return false;
}
return true; //jump is valid.
} else {
return false;
}
}
/**
}
/**
Return an array containing all the legal BataanMoves
for the specified player on the current board. If the player
has no legal moves, null is returned. The value of player
should be one of the constants American and Japanese; if not, null
is returned. If the returned value is non-null, it consists
entirely of jump moves if the player is an American or entirely of regular moves if Japanese, since
if the player can jump, only jumps are legal moves.
*/
BataanMoves[] getValidMoves(int player) {
//player is not an American or a Japanese.
if (player != American && player != Japanese) {
return null;
}
//array list to store the valid moves.
ArrayList moves = new ArrayList();
/* Check all squares on the board for any possible jumps for the current
player if the player is Japanese nothing will be stored. If the player is an American
it checks the eight possible directions from that square if a jump is available it is
stored in the array list.
*/
for (int row = 0; row <= 8; row++) {
for (int col = 0; col <= 8; col++) {
if (myBoard[row][col] == player) {
if(row%2 == col%2){
if (pieceCanJump(player, row, col, row + 1, col + 1, row + 2, col + 2)) {
moves.add(new BataanMoves(row, col, row + 2, col + 2));
}
if (pieceCanJump(player, row, col, row - 1, col + 1, row - 2, col + 2)) {
moves.add(new BataanMoves(row, col, row - 2, col + 2));
}
if (pieceCanJump(player, row, col, row + 1, col - 1, row + 2, col - 2)) {
moves.add(new BataanMoves(row, col, row + 2, col - 2));
}
if (pieceCanJump(player, row, col, row - 1, col - 1, row - 2, col - 2)) {
moves.add(new BataanMoves(row, col, row - 2, col - 2));
}
if (pieceCanJump(player, row, col, row, col - 1, row, col - 2)) {
moves.add(new BataanMoves(row, col, row, col - 2));
}
if (pieceCanJump(player, row, col, row, col + 1, row, col + 2)) {
moves.add(new BataanMoves(row, col, row, col + 2));
}
if (pieceCanJump(player, row, col, row - 1, col, row - 2, col)) {
moves.add(new BataanMoves(row, col, row - 2, col));
}
if (pieceCanJump(player, row, col, row + 1, col, row + 2, col)) {
moves.add(new BataanMoves(row, col, row + 2, col));
}
}else{
if (pieceCanJump(player, row, col, row-1, col, row-2, col)) {
moves.add(new BataanMoves(row, col, row, col - 2));
}
if (pieceCanJump(player, row, col, row, col - 1, row, col - 2)) {
moves.add(new BataanMoves(row, col, row, col - 2));
}
if (pieceCanJump(player, row, col, row, col + 1, row, col + 2)) {
moves.add(new BataanMoves(row, col, row, col + 2));
}
if (pieceCanJump(player, row, col, row + 1, col, row + 2, col)) {
moves.add(new BataanMoves(row, col, row + 2, col));
}
}
}
}
}
/*After checking if there are available jumps and the array list is still empty,
the second check is if there are valid normal move for the player,still every
square of the board is checked for all the valid moves in the players piece.
*/
if (moves.isEmpty()) {
for (int row = 0; row <= 8; row++) {
for (int col = 0; col <= 8; col++) {
if (myBoard[row][col] == player) {
if(row%2 == col%2){
if (pieceCanMove(player, row, col, row + 1, col)) {
moves.add(new BataanMoves(row, col, row + 1, col));
}
if (pieceCanMove(player, row, col, row - 1, col)) {
moves.add(new BataanMoves(row, col, row - 1, col));
}
if (pieceCanMove(player, row, col, row + 1, col + 1)) {
moves.add(new BataanMoves(row, col, row + 1, col + 1));
}
if (pieceCanMove(player, row, col, row + 1, col - 1)) {
moves.add(new BataanMoves(row, col, row + 1, col - 1));
}
if (pieceCanMove(player, row, col, row, col + 1)) {
moves.add(new BataanMoves(row, col, row, col + 1));
}
if (pieceCanMove(player, row, col, row, col - 1)) {
moves.add(new BataanMoves(row, col, row, col - 1));
}
if (pieceCanMove(player, row, col, row - 1, col + 1)) {
moves.add(new BataanMoves(row, col, row - 1, col + 1));
}
if (pieceCanMove(player, row, col, row - 1, col - 1)) {
moves.add(new BataanMoves(row, col, row - 1, col - 1));
}
}else{
if (pieceCanMove(player, row, col, row - 1, col)) {
moves.add(new BataanMoves(row, col, row, col - 2));
}
if (pieceCanMove(player, row, col, row, col - 1)) {
moves.add(new BataanMoves(row, col, row, col - 2));
}
if (pieceCanMove(player, row, col, row, col + 1)) {
moves.add(new BataanMoves(row, col, row, col + 2));
}
if (pieceCanMove(player, row, col, row + 1, col)) {
moves.add(new BataanMoves(row, col, row + 2, col));
}
}
}
}
}
}
/*if still no legal moves are found return null else
/**
Return a list of the legal jumps that the specified player can
make starting from the specified row and column. If no such
jumps are possible, null is returned. The logic is similar
to the logic of the getLegalMoves() method.
*/
BataanMoves[] getValidJumps(int player, int row, int col) {
if (player != American) {
return null;
}
ArrayList moves = new ArrayList();
if (myBoard[row][col] == player) {
if(row%2 == col%2){
if (pieceCanJump(player, row, col, row + 1, col + 1, row + 2, col + 2)) {
moves.add(new BataanMoves(row, col, row + 2, col + 2));
}
if (pieceCanJump(player, row, col, row - 1, col + 1, row - 2, col + 2)) {
moves.add(new BataanMoves(row, col, row - 2, col + 2));
}
if (pieceCanJump(player, row, col, row + 1, col - 1, row + 2, col - 2)) {
moves.add(new BataanMoves(row, col, row + 2, col - 2));
}
if (pieceCanJump(player, row, col, row - 1, col - 1, row - 2, col - 2)) {
moves.add(new BataanMoves(row, col, row - 2, col - 2));
}
if (pieceCanJump(player, row, col, row, col - 1, row, col - 2)) {
moves.add(new BataanMoves(row, col, row, col - 2));
}
if (pieceCanJump(player, row, col, row, col + 1, row, col + 2)) {
moves.add(new BataanMoves(row, col, row, col + 2));
}
if (pieceCanJump(player, row, col, row - 1, col, row - 2, col)) {
moves.add(new BataanMoves(row, col, row - 2, col));
}
if (pieceCanJump(player, row, col, row + 1, col, row + 2, col)) {
moves.add(new BataanMoves(row, col, row + 2, col));
}
}else{
if (pieceCanJump(player, row, col, row-1, col, row-2, col)) {
moves.add(new BataanMoves(row, col, row, col - 2));
}
if (pieceCanJump(player, row, col, row, col - 1, row, col - 2)) {
moves.add(new BataanMoves(row, col, row, col - 2));
}
if (pieceCanJump(player, row, col, row, col + 1, row, col + 2)) {
moves.add(new BataanMoves(row, col, row, col + 2));
}
if (pieceCanJump(player, row, col, row + 1, col, row + 2, col)) {
moves.add(new BataanMoves(row, col, row + 2, col));
}
}
}
if (moves.isEmpty()) {
return null;
} else {
BataanMoves[] movesArray = new BataanMoves[moves.size()];
for (int i = 0; i < moves.size(); i++) {
movesArray[i] = moves.get(i);
}
return movesArray;
}
}
}
}
Please format before you post. If you had code, use the [nobbc]
[/nobbc] tags. For example
[nobbc]
[/nobbc]
public void bar()
{
System.out.println("bar");
}
[nobbc]
[/nobbc]
Renders as
public void bar()
{
System.out.println(“bar”);
}
If you are having large code dumps, use the [url=http://pastebin.java-gaming.org/]pastebin[/url]. Also try to post an [url=http://sscce.org]SSCCE (Short, Self Contained, Correct (Compilable), Example)[/url]