Search results for 'oracle'

Penn foster Graded Project 3 Cell-based Board Games Java

In this project, you'll create data types in a class structure for cell-based board games similar to Tic-Tac-Toe. Games like Connect Four and Mastermind also use boards divided by rows and columns. The Board and Cell classes represent the board, while the Player, Mark, and Outcome enumerations track the game.
You’ll use the classes and enumerations created in this project in future graded projects. You use the NetBeans project in the next lesson

INSTRUCTIONS
1. In NetBeans, create a new Java Application project named BoardGameTester.
2. Create a new package named games and a sub-package of games named board. The easiest way is simply to create a package named games.board.
3. Add an enumeration named Player to the games.board package. You could add Empty Java File or choose Java Enum as the file type. This enumeration represents the current player in a turn-based game. Use the following code:
public enum Player {FIRST,SECOND}
Note: Although Tic-Tac-Toe and Mastermind allow only two players, Connect Four can be played with up to four players. For simplicity, our code will handle only two players.
4. Add an enumeration named Outcome to the games.board package. This enumeration represents the result when the turn is completed. Use the following code:
public enum Outcome {PLAYER1_WIN, PLAYER2_WIN, CONTINUE, TIE}
5. Add an enumeration named Mark to the games.board package. This enumeration represents the result when the game is completed. Use the following code:
public enum Mark {EMPTY, NOUGHT, CROSS, YELLOW, RED, BLUE, GREEN, MAGENTA, ORANGE}
Keep in mind that only yellow and red are used in Connect Four, while Mastermind uses all six colors.
6. Add the Cell class to the games.board package. It should have the private variables content, row, and column, and the public methods getContent, setContent, getRow, and getColumn. Use the following code as a guide:
public class Cell {
private Mark content;
private int row, column;
public Cell(int row, int column) {
this.row = row;
this.column = column;
content = Mark.EMPTY;
}
public Mark getContent() { return content; }
public void setContent(Mark content) { this.content = content;
}
public int getRow() { return row; }
public int getColumn() { return column; }
}
Take note that all classes that support direct instantiation should have a constructor. In this case, the constructor will be used by the Board class to create each of its cells.
7. Add the Board class to the games.board package. It should have a two-dimensional array of Cell objects. The Board class should initialize a board with a specified number of columns and rows, provide access to Cell objects, and display all of its cells correctly. Use the following code as a guide:
public class Board {
private Cell[][] cells;
public Board(int rows, int columns) {
cells = new Cell[rows][columns];
for( int r = 0; r < cells[0].length; r++) {
for (int c = 0; c < cells[1].length;c++) {
cells[r][c] = new Cell(r,c);
}
}
}
public void setCell(Mark mark, int row, int
column) throws IllegalArgumentException {
if (cells[row][column].getContent() == Mark.EMPTY)
cells[row][column].setContent(mark);
else throw new IllegalArgumentException("Player already there!");
}
public Cell getCell(int row, int column) {
return cells[row][column];
}
public String toString() {
StringBuilder str = new StringBuilder();
for( int r = 0; r < cells.length; r++ ) {
str.append("|");
for (int c = 0; c < cells[r].length; c++) {
switch(cells[r][c].getContent())
{
case NOUGHT:
str.append("O");
break;
case CROSS:
str.append("X");
break;
case YELLOW:
str.append("Y");
break;
case RED:
str.append("R");
break;
case BLUE:
str.append("B");
break;
case GREEN:
str.append("G");
break;
case MAGENTA:
str.append("M");
break;
case ORANGE:
str.append("M");
break;
default: //Empty
str.append(" ");
}
str.append("|");
}
str.append("\n");
}
return str.toString();
}
}

This code should seem familiar to you. The methods in the TicTacToeGame class are similar to those in the Board class. The StringBuilder class was used instead of the String class for better performance. You can learn more about the StringBuilder class by visiting the Oracle Website at http://docs.oracle.com/javase/tutorial/java/data/buffers.html.

8. Add the following import statement to the BoardGameTester class:
import games.boards.*;

9. In the main() method of BoardGameTester, perform the following actions:
a. Create a 3 × 3 board for a Tic-Tac-Toe game.
b. Create a 6 × 7 board for a Connect Four game.
c. Create a 5 × 8 board for a game of Mastermind.
d. Set a cell to a nought or cross on the Tic-Tac-Toe board.
e. Set a cell to yellow or red on the Connect Four board.
f. Set a cell to yellow, red, green, blue, magenta, or orange on the Mastermind board.
g. Display the boards for Tic-Tac-Toe, Connect Four, and Mastermind.

10. Compile and run the project to ensure it works as you expected it to.

Penn foster Graded Project 5 TicTacToe Game GUI Java

In this project, you'll create the GUI front-end for the TicTacToe game. This application will leverage the classes you wrote in the graded project for Lesson 3. You'll copy code from Graded Project 3 for this project.
Figure 20 is a guide for the completed user interface.

INSTRUCTIONS
1. In NetBeans, create a new Java Application project named TicTacToeGUIGame.
2. Copy the games.board package from the Lesson 3 project named BoardGameTester.
- Right-click on the game.board package in the BoardGameTester project of the Projects pane panel.
- Choose the Copy option from the context menu or use the keyboard shortcut CTRL+C.
- Paste it in the TicTacToeGUIGame project using the Paste option in the context menu or the keyboard shortcut CTRL+V.
Make sure to copy and paste the package in the Source Packages folder.
3. In the Cell.java file, have the Cell class extend the JButton class. This action will ensure that each cell on the board has the look and feel of a standard Java button.
4. Override the paintComponent method in the Cell class as follows:
public void paintComponent(Graphics g) {
        //paint the basic button first
        super.paintComponent(g);
        int offset = 5;
        Graphics2D g2 = (Graphics2D) g;
        g2.setStroke(new BasicStroke(5));
        switch (content) {
            case NOUGHT:
                g2.setColor(Color.RED);
                //Draw O
                g2.drawOval(offset, offset, this.getWidth()
                        - offset * 2, this.getHeight() - offset * 2);
                break;
            case CROSS:
                g2.setColor(Color.BLACK);
                //Draw X
                g2.drawLine(offset, offset, this.getWidth() - offset,
                        this.getHeight() - offset);
                g2.drawLine(this.getWidth() - offset, offset, offset,
                        this.getHeight() - offset);
                break;
        }
    }
This code uses the enhanced Graphics2D class to set the stroke thickness to more than one pixel. The Oracle documentation provides more guidance on creating complex geometric shapes using the Graphics2D class at http://docs.oracle.com/javase/tutorial/2d/geometry/index.html. Remember to import the java.awt and javax.swing packages!
5. In the Board.java file, have the Board class extend the JPanel class. This action will ensure that the board can lay out each cell and process its UI events.
6. Make the following modifications to the Board constructor:
public Board(int rows, int columns, ActionListener ah) {
cells = new Cell[rows][columns];
this.setLayout(new GridLayout());
for( int r = 0; r < cells.length; r++ ) {
for (int c = 0; c < cells[r].length; c++) {
cells[r][c] = new Cell(r,c);
this.add(cells[r][c]);
cells[r][c].addActionListener(ah);
}
}
}
These changes will add each cell to the UI and assign an ActionListener object to each cell.
Note: Remember to import the java.awt, java.awt.event, and javax.swing packages.
7. In the TicTacToeGUIGame.java file, have the TicTacToeGUIGame class extend JFrame. This action will ensure that the game is hosted in a Java window.
8. Import the games.board, java.awt, and javax.swing packages.
9. Add the following code to the main method:
SwingUtilities.invokeLater( new Runnable () {
public void run() { new TicTacToeGUIGame(); }
});
10. Declare the following instance variables in TicTacToeGUIGame:
private Board gb;
private int turn;
11. Add the following method to handle each turn:
private void takeTurn(Cell c) {
Mark curMark = (turn++ % 2 == 0)?Mark.NOUGHT
: Mark.CROSS;
gb.setCell(curMark,c.getRow(),c.getColumn());
}
12. Define the following constructor to create the board, provide the event listener, and display the board in the window:
private TicTacToeGUIGame() {
gb = new Board(3, 3, new ActionListener() {
public void actionPerformed(ActionEvent ae) {
Cell c = (Cell) ae.getSource();
takeTurn(c);
}
});
this.add(gb);
this.setDefaultCloseOperation(EXIT_ON_CLOSE);
this.setTitle(“TIC-TAC-TOE”);
this.setSize(300, 300);
this.setVisible(true);
}
13. Compile and run the project. How did you do? Test to make sure that each button displays a nought or cross when clicked.