Exercici: TicTacToe

Joan Puigcerver Ibáñez

j.puigcerveribanez@edu.gva.es

Llicència: CC BY-NC-SA 4.0

(Reconeixement - NoComercial - CompartirIgual) 🅭

Objectius¶

Implementar un programa amb estructura client-servidor amb un protocol complex utilitzant l'enviament d'objectes.

Introducció¶

ud3.exercises.tictactoe

Acaba la implementació del joc del 3 en ratlla a partir del codi font proporcionat.

`TicTacToe`¶

Models¶

Board.java

package ud3.exercises.tictactoe.models;

public class Board {
    private final int[][] board;
    private int moveCount;
    private int winner;
    private boolean finished;

    public Board() {
        this.board = new int[3][3];
        this.moveCount = 0;
        this.winner = 0;
        this.finished = false;
    }

    public boolean isValid(BoardChoice boardChoice){
        return this.board[boardChoice.getX()][boardChoice.getY()] == 0;
    }

    public void updateBoard(BoardChoice boardChoice){
        int x = boardChoice.getX();
        int y = boardChoice.getY();
        int player = boardChoice.getPlayer();
        this.board[x][y] = player;
    }

    public void render(){
        for (int y = 2; y >= 0; y--) {
            System.out.println("-------------");
            for (int x = 0; x <= 2; x++) {
                int v = board[x][y];
                System.out.printf("| %s ", v > 0 ? v : " ");
            }
            System.out.println("|");
        }
        System.out.println("-------------");
    }

    public void addChoice(BoardChoice boardChoice){
        int x = boardChoice.getX();
        int y = boardChoice.getY();
        int player = boardChoice.getPlayer();
        this.board[x][y] = player;
        moveCount++;

        checkRow(y, player);
        if (!finished) checkColumn(x, player);
        if (!finished) checkDiagonal(x, y, player);
        if (!finished) checkAntiDiagonal(x, y, player);
        if (!finished) finished = moveCount == 9;
    }

    public void checkRow(int y, int player){
        for (int x = 0; x < 3; x++){
            if (board[x][y] != player) return;
        }

        this.winner = player;
        this.finished = true;
    }

    public void checkColumn(int x, int player){
        for (int y = 0; y < 3; y++){
            if (board[x][y] != player) return;
        }

        this.winner = player;
        this.finished = true;
    }

    public void checkDiagonal(int x, int y, int player){
        if (x != y)
            return;

        for (int i = 0; i < 3; i++){
            if (board[i][i] != player) return;
        }

        this.winner = player;
        this.finished = true;
    }

    public void checkAntiDiagonal(int x, int y, int player){
        if (x + y != 2)
            return;

        for (int i = 0; i < 3; i++){
            if (board[i][2 - i] != player) return;
        }

        this.winner = player;
        this.finished = true;
    }

    public boolean isFinished() {
        return finished;
    }
    public int getWinner() {
        return winner;
    }
}

Board és el model que representa el tauler de joc del 3 en ratlla.

BoardChoice.java

package ud3.exercises.tictactoe.models;

import java.io.Serializable;

public class BoardChoice implements Serializable {
    private final int x;
    private final int y;
    private int player;

    public BoardChoice(int x, int y, int player) {
        this.x = x;
        this.y = y;
        this.player = player;
    }
    public BoardChoice(int x, int y) {
        this(x, y, 0);
    }

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }

    public int getPlayer() {
        return player;
    }

    public void setPlayer(int player) {
        this.player = player;
    }
}

BoardChoice és el model que representa l'elecció d'una jugada.

TicTacToeMessage.java

package ud3.exercises.tictactoe.models;

import java.io.Serializable;

public class TicTacToeMessage implements Serializable {
    private TicTacToeMessageType type;
    private String message;
    private Object object;

    public TicTacToeMessage(TicTacToeMessageType type, String message) {
        this.type = type;
        this.message = message;
        this.object = null;
    }

    public TicTacToeMessage(TicTacToeMessageType type) {
        this(type, "");
    }

    public TicTacToeMessageType getType() {
        return type;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public Object getObject() {
        return object;
    }

    public void setObject(Object object) {
        this.object = object;
    }
}

TicTacToeMessage és el model que representa un missatge utilitzat en la comunicació entre el servidor i el client.

TicTacToeMessageType.java

package ud3.exercises.tictactoe.models;

import java.io.Serializable;

public enum TicTacToeMessageType implements Serializable {
    INFO,
    ERROR,
    START_GAME,
    INVALID_CHOICE,
    START_TURN,
    WAIT_TURN,
    POST,
    UPDATE_BOARD,
    END_GAME
}

TicTacToeMessageType és l'enumeració que representa els tipus de missatges que es poden enviar:

INFO: el servidor envia un missatge d'informació als clients.
ERROR: el servidor envia un missatge d'error als clients.
START_GAME: el servidor indica als jugadors que la partida acaba de començar.
START_TURN: el servidor indica a un jugador que és el seu torn i que espera rebre la seua jugada.
WAIT_TURN: el servidor indica a un jugador que és el torn del contrincant i que cal esperar la seua jugada.
POST: el client indica al servidor quina és la jugada realitzada.
INVALID_CHOICE: el servidor indica a un jugador que la jugada que ha intentat fer no és correcta i que ha de triar una altra jugada.
UPDATE_BOARD: el servidor indica que el tauler ha sigut actualitzat amb una nova jugada, indicada en el missatge.
END_GAME: el servidor indica que la partida ha finalitzat.

`TicTacToeServer`¶

El servidor s'encarrega de gestionar les connexions dels jugadors i d'emparellar-los perquè juguen entre ells:

El servidor espera que es connecten dos jugadors perquè comencen una partida entre ells.
Quan dos jugadors es connecten, llança un nou fil que gestiona la partida entre els dos jugadors.

Com que és una aplicació amb múltiples clients, la gestió de cada client és independent, en el seu propi fil d'execució. El codi font és el següent:

TicTacToeServer.java

package ud3.exercises.tictactoe.server;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class TicTacToeServer extends Thread {
    ServerSocket server;

    List<TicTacToeGame> games;
    TicTacToeGame nextGame;
    boolean running;

    public TicTacToeServer(int port) throws IOException {
        server = new ServerSocket(port);
        games = new ArrayList<>();
        nextGame = new TicTacToeGame(0);
        running = true;
    }

    public void close(){
        running = false;
        this.interrupt();
    }

    /**
     * TODO: Execució del servidor.
     * <p>
     * El servidor accepta les connexions dels clients.
     * Quan dos jugadors es connecten, els emparella per començar una partida.
     */
    @Override
    public void run() {
        while (running){
            try {
                // TODO
            } catch (Exception e) { // TODO: Adaptar la excepció
                System.err.println("Error while accepting new connection");
                System.err.println(e.getMessage());
            }
        }
    }

    public static void main(String[] args) {
        try {
            Scanner scanner = new Scanner(System.in);
            TicTacToeServer server = new TicTacToeServer(1234);
            server.start();

            scanner.nextLine();

            server.close();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

    }
}

TicTacToeServerPlayerHandler.java

package ud3.exercises.tictactoe.server;

import ud3.exercises.tictactoe.models.BoardChoice;
import ud3.exercises.tictactoe.models.TicTacToeMessage;
import ud3.exercises.tictactoe.models.TicTacToeMessageType;

import java.io.*;
import java.net.Socket;

import static ud3.exercises.tictactoe.models.TicTacToeMessageType.*;
public class TicTacToeServerPlayerHandler {
    private final Socket socket;
    private final ObjectOutputStream out;
    private final ObjectInputStream in;

    public TicTacToeServerPlayerHandler(Socket socket) throws IOException {
        this.socket = socket;

        this.in = new ObjectInputStream(socket.getInputStream());
        this.out = new ObjectOutputStream(socket.getOutputStream());
    }

    public void sendMessage(TicTacToeMessageType type, String message) throws IOException {
        out.writeObject(new TicTacToeMessage(type, message));
    }
    public void sendMessage(TicTacToeMessageType type, String message, Object obj) throws IOException {
        TicTacToeMessage ticTacToeMessage = new TicTacToeMessage(type, message);
        ticTacToeMessage.setObject(obj);
        out.writeObject(ticTacToeMessage);
    }
    public void sendMessage(TicTacToeMessageType type) throws IOException {
        out.writeObject(new TicTacToeMessage(type));
    }

    public BoardChoice getChoice() throws IOException, ClassNotFoundException {
        TicTacToeMessage receivedMessage = (TicTacToeMessage) in.readObject();
        while (receivedMessage.getType() != POST){
            sendMessage(ERROR, "Expected a POST message.");
            receivedMessage = (TicTacToeMessage) in.readObject();
        }

        return (BoardChoice) receivedMessage.getObject();
    }

    public void close() throws IOException {
        this.socket.close();
    }
}

`TicTacToeGame`¶

Aquest fil s'encarrega de portar a terme la partida entre els dos jugadors connectats. Internament, emmagatzema el tauler Board amb l'estat de la partida actual. Pregunta per torns als jugadors per un moviment, que va actualitzant en el seu tauler. A més, comunica a cada jugador els moviments perquè el client puga actualitzar el seu tauler.

La comunicació es gestiona mitjançant objectes TicTacToeMessage, que tenen un TicTacToeMessageType, un missatge i un objecte.

TicTacToeGame.java

package ud3.exercises.tictactoe.server;

import ud3.exercises.tictactoe.models.Board;
import ud3.exercises.tictactoe.models.BoardChoice;
import ud3.exercises.tictactoe.models.TicTacToeMessageType;

import java.io.IOException;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ThreadLocalRandom;

import static ud3.exercises.tictactoe.models.TicTacToeMessageType.*;

public class TicTacToeGame extends Thread {
    private final int id;
    private final List<TicTacToeServerPlayerHandler> players;

    private final Board board;
    private boolean finished;
    private int currentPlayer;

    public TicTacToeGame(int id) {
        this.id = id;
        this.players = new ArrayList<>();
        board = new Board();
        finished = false;
    }

    public void addPlayer(Socket client) throws IOException {
        if (players.size() < 2)
            players.add(new TicTacToeServerPlayerHandler(client));
    }

    public boolean enoughPlayers(){
        return players.size() >= 2;
    }

    public TicTacToeServerPlayerHandler getCurrentPlayer(){
        return players.get(currentPlayer);
    }

    public void sendGlobalMessage(TicTacToeMessageType type) throws IOException{
        for(TicTacToeServerPlayerHandler player : players){
            player.sendMessage(type);
        }
    }
    public void sendGlobalMessage(TicTacToeMessageType type, String message) throws IOException{
        for(TicTacToeServerPlayerHandler player : players){
            player.sendMessage(type, message);
        }
    }
    public void sendGlobalMessage(TicTacToeMessageType type, String message, Object obj) throws IOException{
        for(TicTacToeServerPlayerHandler player : players){
            player.sendMessage(type, message, obj);
        }
    }

    /**
     * TODO: Send the choice to all players, so they update the board.
     */
    public void updateClientBoards(BoardChoice choice) throws IOException {
    }

    public void changeTurn(){
        currentPlayer = (currentPlayer + 1) % players.size();
    }

    private void close() throws IOException {
        for(TicTacToeServerPlayerHandler player : players){
            player.close();
        }
    }

    /**
     * Server side of TicTacToe game.
     * <p>
     * TODO: The server should keep track of:
     * - Comunication with both connected players.
     * - The TicTacToe Board. It should be updated given
     *      the players choices.
     * - It's a turn based game.
     * - Winner/Loser or draw.
     */
    @Override
    public void run(){
        try {
            // TODO
        } catch (Exception e) {
            System.err.println(e.getMessage());
        }
    }
}

`TicTacToeClient`¶

El client es compon d'un únic fil d'execució que ha de reaccionar als missatges enviats pel servidor i actuar en conseqüència, seguint el protocol.

TicTacToeClient.java

package ud3.exercises.tictactoe.client;

import ud3.exercises.tictactoe.models.Board;
import ud3.exercises.tictactoe.models.BoardChoice;
import ud3.exercises.tictactoe.models.TicTacToeMessage;
import ud3.exercises.tictactoe.models.TicTacToeMessageType;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.util.Scanner;

import static ud3.exercises.tictactoe.models.TicTacToeMessageType.*;

public class TicTacToeClient {
    private final Socket socket;
    private final Scanner scanner;
    private final ObjectOutputStream out;
    private final ObjectInputStream in;

    private Board board;
    private boolean finished;

    public TicTacToeClient(String host, int port) throws IOException {
        this.scanner = new Scanner(System.in);
        this.socket = new Socket(host, port);
        this.out = new ObjectOutputStream(socket.getOutputStream());
        this.in = new ObjectInputStream(socket.getInputStream());
        this.board = new Board();
        this.finished = false;
    }

    private TicTacToeMessage readMessage() throws IOException, ClassNotFoundException {
        return (TicTacToeMessage) in.readObject();
    }
    private void sendMessage(TicTacToeMessageType type, String message, Object obj) throws IOException {
        TicTacToeMessage ticTacToeMessage = new TicTacToeMessage(type, message);
        ticTacToeMessage.setObject(obj);
        out.writeObject(ticTacToeMessage);
    }

    /**
     * TODO: Ask for the position where the user wants to play.
     * Send the user's choice to the server.
     */
    private void playMove() throws IOException {
    }

    /**
     * Client-side TicTacToe game.
     * <p>
     * TODO: This method should recevie a TicTacToeMessage from the server and implement
     * the accions based on the message type.
     *
     */
    public void game() throws IOException, ClassNotFoundException {
    }

    public static void main(String[] args) {
        System.out.println("Connectant-se amb el servidor...");
        try {
            TicTacToeClient ticTacToeClient = new TicTacToeClient("localhost", 1234);
            ticTacToeClient.game();
        } catch (IOException | ClassNotFoundException e) {
            System.err.println(e.getMessage());
        }
    }
}

📌 Aquest document pot quedar desactualitzat després d’imprimir-lo. Pots consultar la versió més recent a la pàgina web.

🌿 Abans d’imprimir aquest document, considera si és realment necessari. Redueix el consum de paper i ajuda a protegir el nostre entorn.

Exercici: TicTacToe

Objectius¶

Introducció¶

TicTacToe¶

Models¶

TicTacToeServer¶

TicTacToeGame¶

TicTacToeClient¶

`TicTacToe`¶

`TicTacToeServer`¶

`TicTacToeGame`¶

`TicTacToeClient`¶