Créer une nouvelle classe appelée TicTacToeGame. Si vous utilisez un IDE Java comme Netbeans ou Eclipse, ce sera traitée automatiquement pour vous. Si vous utilisez un éditeur de texte et le compilateur de ligne de commande, alors vous aurez besoin pour créer un fichier nommé TicTacToeGame.java et insérez le squelette de classe suivante en elle:
/ **
- Cette classe représente un jeu de 2 joueurs de TicTacToe.
* /
classe TicTacToeGame {
&# 9 - // Tout autre code dans le tutoriel ira dans cet espace!
} Définissez vos variables. Il ya quelques manières que vous pourriez le faire, mais la façon dont ce tutoriel choisit est un tableau 2D simple des caractères uniques pour représenter le conseil, avec le joueur actif, soit X ou O, stockée en tant que personnage. Aussi, pour assurer la cohérence et améliorer la lisibilité de votre code plus tard, définir quelques constantes pour les caractères utilisés pour X, O, et vide. Insérer le texte suivant:
/ **
* Le tableau. L'omble chevalier est soit 'X', 'O' ou ''. Ceux-ci sont définis dans les constantes.
* /
omble privé [] [] pension = new char [3] [3]
GO
omble currentPlayer
GO
omble finale public static X = 'X'
GO
omble finale O public static = 'O'
GO
public static final omble NONE = ''
GO
Chaque fois qu'une valeur est stockée sur la carte, par rapport à une autre valeur sur la carte, ou stocké dans currentPlayer, vous devez utiliser l'vos constantes déclarées X, Y et NONE. Comme mentionné plus haut, ceci améliore la lisibilité et la robustesse de code.
Initialiser le jeu. Un seul constructeur est nécessaire pour notre conseil TicTacToe.
/ **
Initialise la carte.
* /
TicTacToeBoard publique () {
&# 9 - // Vous pouvez également utiliser un double imbriquée boucle for pour remplir le plateau.
&# 9 de bord [0] [0] = NONE
GO
carte [0] [1] = NONE
GO
carte [0] [2] = NONE
GO
carte [1] [0] = NONE
GO
carte [1] [1] = NONE
GO
carte [1] [2] = NONE
GO
Conseil [2] [0] = NONE
GO
Conseil [2] [1] = NONE
GO
Conseil [2] [2] = NONE
GO
// Définir le joueur courant égal à la constante de X vous avez défini précédemment.
currentPlayer = X
GO
}
Ajouter la "makeMove" Procédé. Cette méthode devrait prendre trois arguments: le xCoord, coordY et lecteurEnCours.
/ **
* Faites un déménagement.
*param CoordX x coord pour marquer
*param CoordY l'y coord pour marquer
* Lecteurparam le joueur à utiliser. Cela devrait être l'une des constantes: X, O
*return True si déménagement a eu lieu. Si faux mouvement est interdit parce que la place est pleine.
* /
booléen makeMove (int xCoord, int coordY, joueur de char) {
si (conseil [xCoord] [coordY] == NONE) {
conseil [xCoord] [coordY] = joueur
GO
return true
GO
} Else {
return false
GO
}
}
Rappelez-vous de toujours définir vos commentaires JavaDoc.
Créez une méthode pour dessiner la carte. Il ya un certain nombre de façons de le faire, mais la manière la plus élégante est une boucle simple, double imbriqué.
/ **
* Dessine le conseil d'administration actuel de la console en utilisant System.out
* /
vide drawBoard () {
for (int x = 0- x lt; board.length- x ++) {
for (int y = y 0- lt; conseil [x] .length- y ++) {
&# 9 - // Dessinez le X et S sur la carte jusqu'à présent (ainsi que les espaces vides).
&# 9-System.out.print ("- "- + carte [x] [y] + "- "-)
GO
&# 9 - // Dessinez les lignes verticales entre les colonnes.
si (y lt; 2)
System.out.print ("-
}
System.out.println ()
GO
// Dessine des lignes horizontales entre les rangées.
System.out.println (" ---- + --- + --- "-)
GO
}}
Écrivez votre boucle de jeu. Tous les jeux contiennent une sorte de boucle de jeu qui définit le début du jeu, exécute les règles du jeu, et des tests pour un gagnant de jeu ou condition de fin. Voici la boucle de jeu pour le jeu TicTacToe:
jeu void () {
jeu booléen = true
GO
BufferedReader dans = new BufferedReader (nouvelle InputStreamReader (System.in))
GO
while (jouer) {try {
booléen validMove = false
GO
// Continuez à poser le joueur pour les coordonnées jusqu'à ce qu'elle donne une réponse valide!
while (! validMove) {
drawBoard ()
GO
System.out.println ("-actuel joueur est: "- + currentPlayer)
GO
System.out.println ("-Que coordonnée X? "-)
GO
// LIRE COORDONNEES
int xCoord = new Integer (in.readLine ())
GO
System.out.println ("-Que coordonnée y? "-)
GO
int coordY = new Integer (in.readLine ())
GO
validMove = makeMove (xCoord, coordY, currentPlayer)
GO
if (! validMove) System.out.println ("-erreur: Invalid mouvement "-)
GO
}// Change le joueur actif.
if (currentPlayer == X) {
currentPlayer = O
GO
} Else {
currentPlayer = X
GO
}// Si nous avons un gagnant, puis de les féliciter et de terminer le jeu!
if (this.testWinner ()! = NONE) {
drawBoard ()
GO
System.out.println ("-gagnant est: "- + this.testWinner ())
GO
retour
GO
}
// Test erreurs de saisie à partir du clavier, et les informations de débogage impression si l'on se rencontre. Ceci est non seulement une bonne idée, il est requis par la fonction in.ReadLine ().
} Catch (IOException e) {
e.printStackTrace ()
GO
}
}(Voir les références 1)
Il existe une fonction mentionnée dans la boucle play () qui n'a pas encore été écrit: testWinner (). Il est la fonction la plus difficile de tous, et il ya plusieurs façons d'aller sur le test pour le gagnant TicTacToe. Ce qui suit est la plus évidente, mais pas la plus efficace, la solution au problème:
/ **
* Cette fonction permettra de tester la carte pour voir si il ya un gagnant.
*return X si X a gagné la partie. O si O a gagné la partie. NONE si aucun n'a gagné la partie. Celui-ci utilise les constantes fournies par la classe.
* /
omble testWinner () {
// TOP ROW
si (conseil [1] [0] == conseil [0] [0] &Amp&Amp
carte [1] [0] == bord [2] [0]) {
conseil retourner [1] [0]
GO
}
// Rangée horizontale MOYEN
si (conseil [1] [1] == conseil [0] [1] &Amp&Amp
carte [1] [1] == bord [2] [1]) {
conseil retourner [1] [1]
GO
}
// Rangée du bas
si (conseil [1] [2] == conseil [0] [2] &Amp&Amp
carte [1] [2] == bord [2] [2]) {
conseil retourner [1] [2]
GO
}
// GAUCHE ROW
si (conseil [0] [1] == conseil [0] [0] &Amp&Amp
carte [0] [0] == conseil [0] [2]) {
conseil retourner [0] [0]
GO
}
// Médian vertical ROW
si (conseil [1] [1] == bord [1] [0] &Amp&Amp
carte [1] [0] == bord [1] [2]) {
conseil retourner [1] [1]
GO
}
// Rangée à droite
si (conseil [2] [1] == bord [2] [0] &Amp&Amp
Conseil [2] [0] == bord [2] [2]) {
conseil retourner [2] [0]
GO
}
// TOP diagonale gauche
si (conseil [0] [0] == bord [1] [1] &Amp&Amp
carte [0] [0] == bord [2] [2]) {
conseil retourner [0] [0]
GO
}
// TOP diagonale droite
si (conseil [0] [2] == bord [1] [1] &Amp&Amp
carte [0] [2] == bord [2] [0]) {
conseil retourner [0] [2]
GO
}
// Si elle devient ici, personne n'a gagné cette manche.
retourner NONE
GO
}Il passe simplement à travers le conseil d'administration, tester chaque combinaison gagnante possible de carrés et de voir si l'un des joueurs dont il dispose.
Créer la fonction principale. Enfin, vous aurez besoin pour créer une fonction principale de donner à votre programme un endroit pour commencer. Cette fonction principale sera très simple: Il va juste initialiser votre classe TicTacToeGame et commencer la méthode play (). Insérez la fonction suivante dans votre classe:
main (String [] args) {public static void
TicTacToeGame jeu = new TicTacToeGame ()
GO
jeu.Jouer ()
GO
}
Maintenant vous avez un jeu de morpion fonctionnement!