Esboço de Jogo-Da-Velha (tic-tac-toe) para uma amiga...

exercice1_DisplayConstants.java

package exercice1;

/**
 * Created by lucas on 27/08/16.
 * 
 * Essa interface provem as representacoes visuais para
 * serem exibidas no jogo. Ambas as representacoes podem
 * ser retornadas como inteiros, para fins de elaboracao
 * de logica por meio do metodo getSimboloByInt(int arg).
 */
public interface DisplayConstants {
    
    String O = "O";
    String X = "X";
    String EMPTY = "-";

    static String getSimboloByInt(int arg){
        return arg == 0 ? O : arg == -1 ? EMPTY: X;
    }
}

exercice1_Jogador.java

package exercice1;

/**
 * Created by lucas on 27/08/16.
 * Classe destinada a representar quaisquer jogadores
 * que estiverem a jogar o jogo.
 */
public class Jogador {

    /**
     * id unico do jogador
     */
    private int id;

    /**
     * Tabuleiro no qual o presente jogador estara
     * jogando
     */
    private Tabuleiro tab;


    /**
     * Construtor utilizado para inicializar os parametros
     * 
     * @param id inteiro que o jogador recebera
     * @param tab tabuleiro que o jogador jogara
     */
    public Jogador(int id, Tabuleiro tab){
        this.id = id;
        this.tab = tab;
    }

    /**
     * Este metodo invoca o metodo doJogada() da classe Tabuleiro.
     * Neste caso, este metodo passa os parametros para ser feita uma
     * jogada no tabuleiro com os parametros especificos do presente
     * jogador.
     * 
     * @param jogada tipo da jogada que o jogador vai fazer
     * @param x coordenada x onde a jogada vai ser realizada
     * @param y coordenada y onde a jogada vai ser realizada
     *          
     * @return se a jogada foi feita corretamente, via
     * Tabuleiro().doJogada().
     */
    public boolean doJogada(int jogada, int x, int y){
        //return (tab.doJogada(jogada, x, y)) ? true : false;
        return (tab.doJogada(jogada, x, y));
    }

    /**
     * Este metodo indica se o presente jogador conseguiu ganhar.
     * Para que um jogador seja dito "vencedor" ele precisa ter
     * inserido 3 simbolos seguidos, horinztalmente, verticalmente
     * ou em uma diagonal da matriz principal do jogo (tabuleiro).
     * 
     * @return true se o jogador conseguiu 3 simbolos seguidos na
     * matriz principal do jogo.
     */
    public boolean ganhou(){
        return tab.temTresSeguidos(id - 1);
    }

    /**
     * O metodo toString() e aqui invocado para representar visualmente
     * (no console) o jogador designado aa instancia especificada.
     * @return frase "eu sou o jogador " com seu id especifico.
     */
    @Override
    public String toString() {
        return "Eu sou o jogador " + id;
    }
}

exercice1_Jogo.java

package exercice1;

import java.util.Scanner;

/**
 * Created by lucas on 28/08/16.
 * Esta classe e responsavel por regular todas as acoes do jogo.
 */
public class Jogo {

    /**
     * Tabuleiro no qual o jogo ocorrera
     */
    private Tabuleiro tabuleiro;

    /**
     * jogadores que estarao presentes no jogo
     */
    private Jogador jogador1, jogador2;


    /**
     * Instancia da classe Scanner para obter dados dos
     * jogadores
     */
    private Scanner s;


    /**
     * booleans para verificar a vitoria e derrota de cada jogador
     */
    private boolean jogador1win = false, jogador2win = false;


    /**
     * Construtor usado para inicializar as variaveis
     * 
     * @param tabuleiro tabuleiro no qual os jogadores jogarao
     * @param jogador1 jogador 1
     * @param jogador2 jogador 2
     */
    public Jogo(Tabuleiro tabuleiro, Jogador jogador1, Jogador jogador2){
        this.tabuleiro = tabuleiro;
        this.jogador1 = jogador1;
        this.jogador2 = jogador2;

        s = new Scanner(System.in);
    }

    /**
     * Esse metodo se encarrega de estabelecer o loop que funcionara
     * ate que algum dos jogadores ganhem. Apos o loop, o metodo
     * declara as vitorias de cada jogador, caso hajam.
     */
    public void iniciar(){
        while (true){
            for (int i = 0; i < 2; i++){
                mainGameLoop(i == 0 ? 0 : 1);
                if (jogador1.ganhou() || jogador2.ganhou()){
                    break;
                }
            }
            if (jogador1.ganhou() || jogador2.ganhou()){
                jogador1win = jogador1.ganhou();
                jogador2win = jogador2.ganhou();
                break;
            }
        }

        p(tabuleiro);

        if (jogador1win){
            p("jogador 1 ganhou!");
        }

        if (jogador2win){
            p("jogador 2 ganhou!");
        }

        if (!jogador1win && !jogador2win){
            p("ninguem ganhou!!!");
        }
    }

    /**
     * Esse metodo estabelece as instrucoes que deverao ser repetidas
     * a cada jogada
     * 
     * @param jogador id do jogador que esta na jogada
     */
    private void mainGameLoop(int jogador){
        String j;
        int[] params;

        p("Jogador " + (jogador + 1) + ", faca sua jogada...");
        p(tabuleiro);

        j = s.nextLine();
        params = decompileJogada(j);
        if (jogador == 0){
            if (!jogador1.doJogada(params[0],params[1],params[2])){
                p("Jogue novamente, vc jogou errado ou jogou num lugar que ja foi jogado!");
            }
        } else {
            if (!jogador2.doJogada(params[0],params[1],params[2])){
                p("Jogue novamente, vc jogou errado ou jogou num lugar que ja foi jogado!");
            }
        }
    }

    /**
     * Este metodo privado recebe a jogada de um jogador no formato
     * "j,x,y" (sem aspas), onde j e o tipo da jogada na qual o
     * jogador fez, x e a coordenada x na qual o jogador indicou
     * e y e a coordenada y na qual o jogador indicou para o tabuleiro.
     * 
     * @param jogada String contendo os parametros para a jogada.
     *               
     * @return int[] contendo em cada posicao, respectivamente,
     * o tipo da jogada na qual o
     * jogador fez, x e a coordenada x na qual o jogador indicou
     * e y e a coordenada y na qual o jogador indicou para o tabuleiro.
     */
    private int[] decompileJogada(String jogada){
        String[] toOut = jogada.split(",");
        int[] r = new int[3];
        for (int i = 0; i < 3; i++){
            r[i] = Integer.parseInt(toOut[i]);
        }
        return r;
    }

    /**
     * Metodo personalizado para exibir mensagens no console.
     * 
     * @param object objeto a ter seu toString() evidenciado.
     */
    private static void p(Object object){
        System.out.println(object);
    }
}

exercice1_Main.java

package exercice1;

/**
 * Created by lucas on 27/08/16.
 * Classe principal para dar funcionamento ao Jogo.
 */
public class Main {
    
    public static void main(String[] args) {
        Tabuleiro tabuleiro = new Tabuleiro();
        Jogador p1 = new Jogador(1, tabuleiro);
        Jogador p2 = new Jogador(2, tabuleiro);

        Jogo jogo = new Jogo(tabuleiro, p1, p2);
        jogo.iniciar();
    }
}

exercice1_Tabuleiro.java

package exercice1;

/**
 * Created by lucas on 27/08/16.
 * Classe utilizada para representar o tabuleiro no qual
 * o jogo ocorrera.
 */
public class Tabuleiro implements DisplayConstants{

    /**
     * Matriz principal 
     */
    private int[][] tab = new int[3][3];

    /**
     * Construtor sem parametros para inicializar a matriz
     * principal do jogo que representara o tabuleiro.
     * Inicialmente a matriz e completamente preenchida com
     * valores -1, representando, assim, nenhuma jogada
     * feita.
     */
    public Tabuleiro(){
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                tab[i][j] = -1;
            }
        }
    }

    /**
     * Esse metodo pega os parametros vindos do jogador e altera
     * a matriz desta classe de acordo com o parametro passado.
     * 
     * @param jogada tipo da jogada a se fazer
     * @param x coordenada x da matriz pra jogar
     * @param y coordenada y da matriz pra jogar
     * @return true se a jogada foi feita
     */
    public boolean doJogada(int jogada, int x, int y){
        if (tab[x][y] == -1){
            if (jogada == 0 || jogada == 1){
                if ((x >= 0 && x <= 2) && (y >= 0 && y <= 2)){
                    tab[x][y] = jogada;
                    return true;
                } else {
                    System.out.println("jogue numeros validos!");
                }
                return false;
            }
            return false;
        }
        return false;
    }

    /**
     * Este metodo retorna se tem 3 valores (simbolos) iguais
     * em linha seguidos. A analise verifica se tem 3 iguais
     * horizontalmente, verticalmente ou em uma diagonal.
     * 
     * @param tipoDaJogada
     * @return
     */
    public boolean temTresSeguidos(int tipoDaJogada){
        if (checarLinhaCompleta(tipoDaJogada) != -1){
            return true;
        }
        if (checarColunaCompleta(tipoDaJogada) != -1){
            return true;
        }
        if (checarDiagonalCompleta(tipoDaJogada) != -1){
            return true;
        }
        return false;
    }

    /**
     * Este metodo privado verifica se tem tres simblos iguais em
     * alguma linha (horizontal) da matriz. Pra isso leva em consideracao
     * duas condicoes: se os valores da linha analisada sao iguais
     * entre si E se tais valores sao iguais ao valor que esta
     * sendo verificado.
     * 
     * @param tipoDaJogada valor da jogada que esta se verificando.
     *                     pode ser 0 ou 1.
     * @return o indice da linha na qual tem 3 simbolos iguais
     *         seguidos, caso nao haja 3 seguidos, retorna -1.
     */
    private int checarLinhaCompleta(int tipoDaJogada){
        int l = -1;

        for (int linha = 0; linha < 3; linha++) {
            if (tab[linha][0] == tab[linha][1] && tab[linha][1] == tab[linha][2] && tab[linha][0] == tab[linha][2]){
                if (tab[linha][0] == tipoDaJogada && tab[linha][1] == tipoDaJogada && tab[linha][0] == tipoDaJogada){
                    l = linha;
                    break;
                }
            }
        }
        return l;
    }

    /**
     * Este metodo privado verifica se tem tres simblos iguais em
     * alguma coluna (vertical) da matriz. Pra isso leva em consideracao
     * duas condicoes: se os valores da coluna analisada sao iguais
     * entre si E se tais valores sao iguais ao valor que esta
     * sendo verificado.
     *
     * @param tipoDaJogada valor da jogada que esta se verificando.
     *                     pode ser 0 ou 1.
     * @return o indice da linha na qual tem 3 simbolos iguais
     *         seguidos, caso nao haja 3 seguidos, retorna -1.
     */
    private int checarColunaCompleta(int tipoDaJogada){
        int c = -1;

        for (int coluna = 0; coluna < 3; coluna++) {
            if (tab[0][coluna] == tab[1][coluna] && tab[1][coluna] == tab[2][coluna] && tab[0][coluna] == tab[2][coluna]){
                if (tab[0][coluna] == tipoDaJogada && tab[1][coluna] == tipoDaJogada && tab[0][coluna] == tipoDaJogada){
                    c = coluna;
                    break;
                }
            }
        }
        return c;
    }

    /**
     * Este metod privado analisa se tem alguma diagonal da matriz
     * com 3 simbolos iguais seguidos. Pra isso ele verifica as
     * posicoes da matriz que geram uma diagonal.
     * 
     * @param tipoDaJogada valor da jogada que esta se verificando.
     *                     pode ser 0 ou 1.
     *                     
     * @return Na matriz declarada
     * existem DUAS diagonais, na diagonal que inicia nas coordenadas
     * [0,0] o metodo retorna 0, para a diagonal que inicia nas
     * coordenadas [0,2] o metodo retorna 1. Caso nao hajam
     * diagonais com 3 simbolos iguais o metodo retorna -1.
     */
    private int checarDiagonalCompleta(int tipoDaJogada){
        int d = -1;

        if (tab[0][0] == tab[1][1] && tab[1][1] == tab[2][2] && tab[2][2] == tab[0][0]){
            if (tab[0][0] == tipoDaJogada && tab[1][1] == tipoDaJogada && tab[2][2] == tipoDaJogada){
                d = 0;
            }
        }

        if (tab[0][2] == tab[1][1] && tab[1][1] == tab[2][0] && tab[2][0] == tab[0][2]){
            if (tab[0][2] == tipoDaJogada && tab[1][1] == tipoDaJogada && tab[2][0] == tipoDaJogada){
                d = 1;
            }
        }

        return d;
    }

    /**
     * O metodo toString() e aqui invocado para fazer o trabalho de representar
     * visualmente, no console, o tabuleiro de jogo.
     * 
     * @return representacao visual do proprio tabuleiro de jogo.
     */
    @Override
    public String toString() {
        String r = "";

        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < 3; j++) {
                //r += tab[i][j] + "  ";
                r += DisplayConstants.getSimboloByInt(tab[i][j]) + "  ";
            }
            r += "\n";
        }
        return r;
    }
}