Lo sviluppo del gioco può essere divertente ed emozionante. Tuttavia, è anche una sfida enorme, con una curva di apprendimento ripida. Mentre il vecchio due giocatori Tic Tac Toe potrebbe non essere eccitante come Quake o Advance Wars, introduce alcuni fondamenti di lavoro a turni game design. Input deve essere presa dal lettore, trattati secondo le regole del gioco, e l'uscita di nuovo in una forma il giocatore può capire.

istruzione

1 Creare una nuova classe chiamata TicTacToeGame. Se si utilizza un IDE Java, come Netbeans o Eclipse, questo verrà gestita automaticamente per voi. Se si utilizza un editor di testo e il compilatore a riga di comando, quindi è necessario creare un file denominato TicTacToeGame.java e inserire la seguente scheletro di classe in esso:

/ **

Questa classe rappresenta un gioco a 2 giocatori di TicTacToe.
* /
class TicTacToeGame {
// Tutti gli altri codice nel tutorial andrà in questo spazio!
}

2 Definire le variabili. Ci sono alcuni modi si potrebbe fare questo, ma il modo in cui questo tutorial sceglie è una matrice 2D semplice dei singoli caratteri per rappresentare la scheda, con il giocatore di turno, X o O, memorizzato come un personaggio. Inoltre, per garantire la coerenza e migliorare la leggibilità del codice in seguito, definire alcune costanti per i caratteri utilizzati per X, O, e vuota. Inserire il seguente:

/**
* The board. The char is either 'X', 'O', or ' ' . These are defined in the constants.
*/
private char[][] board = new char[3][3]

ANDARE

char currentPlayer

ANDARE

public static final char X = 'X'

ANDARE

public static final char O = 'O'

ANDARE

public static final char NONE = ' '

ANDARE

Ogni volta che un valore viene memorizzato sulla scheda, rispetto ad un altro valore sul bordo, o memorizzato in currentPlayer, si dovrebbe usare la vostra costanti dichiarate X, Y, e NESSUNO. Come accennato in precedenza, questo aumenta la leggibilità e robustezza del codice.

3 Inizializzare il gioco. Solo un costruttore è necessario per il nostro bordo TicTacToe.

/ **

Inizializza la scheda.
* /
TicTacToeBoard pubblico () {
// Si potrebbe anche usare un doppio-nidificato ciclo for per riempire la scheda.
bordo [0] [0] = NONE
ANDARE

board[0][1] = NONE

ANDARE

board[0][2] = NONE

ANDARE

board[1][0] = NONE

ANDARE

board[1][1] = NONE

ANDARE

board[1][2] = NONE

ANDARE

board[2][0] = NONE

ANDARE

board[2][1] = NONE

ANDARE

board[2][2] = NONE

ANDARE

// Set the current player equal to the X constant you defined earlier.
currentPlayer = X

ANDARE
}

4 Aggiungere il metodo \ "makeMove \". Questo metodo dovrebbe prendere tre argomenti: il xcoord, yCoord, e currentPlayer.

/**
* Make a move.
* @param xCoord the x coord to mark
* @param yCoord the y coord to mark
* @param player the player to use. This should be one of the constants : X, O
* @return true if move occurred. False if move is forbidden because square is full.
*/
boolean makeMove(int xCoord, int yCoord, char player) {
if (board[xCoord][yCoord] == NONE) {
board[xCoord][yCoord] = player

ANDARE

return true

ANDARE

} else {
return false

ANDARE

}
}

Ricordarsi di definire sempre i tuoi commenti JavaDoc.

5 Creare un metodo per disegnare il bordo. Ci sono un certo numero di modi per farlo, ma il modo più elegante è un semplice, anello doppio nidificato.

/**
* Draws the current board to the console using System.out
*/
void drawBoard() {
for (int x = 0; x < board.length; x++) {
for (int y = 0; y < board[x].length; y++) {
// Draw the X and Os on the board so far (as well as the blank spaces).
System.out.print(\" \" + board[x][y] + \" \")

ANDARE

// Draw the vertical lines between columns.
if (y < 2) {
System.out.print(\"|\")

ANDARE

}
}
System.out.println()

ANDARE

// Draw horizontal lines between rows.
System.out.println(\"---+---+---\")

ANDARE

}

}

6 Scrivi il tuo ciclo di gioco. Tutti i giochi contengono una sorta di ciclo di gioco che definisce l'inizio del gioco, esegue le regole del gioco, e le prove per un vincitore gioco o condizione di fine. Ecco il ciclo di gioco per il gioco TicTacToe:

void play() {
boolean playing = true

ANDARE

BufferedReader in = new BufferedReader(new InputStreamReader(System.in))

ANDARE

while (playing) {

provare {
booleano validMove = false

ANDARE

// Keep asking the player for coordinates until she gives a valid response!
while (!validMove) {
drawBoard()

ANDARE

System.out.println(\"Current Player is: \" + currentPlayer)

ANDARE

System.out.println(\"What x coordinate? \")

ANDARE

// READ COORDINATES
int xCoord = new Integer(in.readLine())

ANDARE

System.out.println(\"What y coordinate? \")

ANDARE

int yCoord = new Integer(in.readLine())

ANDARE

validMove = makeMove(xCoord, yCoord, currentPlayer)

ANDARE

if (!validMove) System.out.println(\"ERROR: Invalid move!\")

ANDARE

}

// Cambiare il giocatore di turno.
if (currentPlayer == X) {
currentPlayer = O

ANDARE

} else {
currentPlayer = X

ANDARE

}

// Se abbiamo un vincitore, quindi congratularmi con loro e terminare il gioco!
if (this.testWinner ()! = NONE) {
drawBoard ()

ANDARE

System.out.println(\"Winner is : \" + this.testWinner())

ANDARE

return

ANDARE

}
// Test for input errors from the keyboard, and print debug information if one is encountered. This is not just a good idea, it is required by the in.ReadLine() function.
} catch (IOException e) {
e.printStackTrace()

ANDARE

}
}

(Vedi riferimenti 1)

7 C'è una funzione menzionato nel loop play () che non è ancora stato scritto: testWinner (). E 'la funzione più difficile di tutti, e ci sono molti modi per andare su test per il vincitore TicTacToe. Quanto segue è la più ovvia, ma non il più efficiente, soluzione al problema:

/ **

* This function will test the board to see if there is a winner.
* @return X if X has won the game. O if O has won the game. NONE if none have won the game. This uses the constants provided by the class.
*/
char testWinner() {

// RIGA SUPERIORE

if (board[1][0] == board[0][0] &&
board[1][0] == board[2][0]) {
return board[1][0]

ANDARE

}

// MEDIO fila orizzontale

if (board[1][1] == board[0][1] &&
board[1][1] == board[2][1]) {
return board[1][1]

ANDARE

}

// Basse di fila

if (board[1][2] == board[0][2] &&
board[1][2] == board[2][2]) {
return board[1][2]

ANDARE

}

// SINISTRA ROW

if (board[0][1] == board[0][0] &&
board[0][0] == board[0][2]) {
return board[0][0]

ANDARE

}

// MIDDLE ROW VERTICAL

if (board[1][1] == board[1][0] &&
board[1][0] == board[1][2]) {
return board[1][1]

ANDARE

}

// ROW RIGHT

if (board[2][1] == board[2][0] &&
board[2][0] == board[2][2]) {
return board[2][0]

ANDARE

}

// IN ALTO A SINISTRA DIAGONALE

if (board[0][0] == board[1][1] &&
board[0][0] == board[2][2]) {
return board[0][0]

ANDARE

}

// ALTO A DESTRA DIAGONALE

if (board[0][2] == board[1][1] &&
board[0][2] == board[2][0]) {
return board[0][2]

ANDARE

}

// Se si arriva qui, nessuno ha vinto questo round.

return NONE

ANDARE

}

Si procede semplicemente attraverso la scheda, testare ogni possibile combinazione vincente di quadrati e vedere se uno dei giocatori ha.

8 Creare la funzione principale. Infine, è necessario creare una funzione principale per dare al vostro programma di un punto di partenza. Questa funzione principale sarà molto semplice: Sarà solo inizializzare la classe TicTacToeGame e avviare il metodo play (). Inserire la seguente funzione nella tua classe:

Main (string [] args) {public static void
TicTacToeGame gioco = new TicTacToeGame ()
ANDARE
game.play ()
ANDARE
}

Ora avete un gioco TicTacToe funzionante!