[Java] Puzzle N

Este jogo consiste em um tabuleiro de N x N casas, numeradas de 0 a N*N. Sua tarefa é organizar os números de 1 a N*N, sendo a última casa, o número 0. O código é bom para estudos de iniciantes em vetores e matrizes.



Source:

   ///////////////////////////////////
  //          Jogo PuzzleN         //
 // Desenvolvido por João Marcos  //
///////////////////////////////////

package PuzzleN;

import java.util.Random;
import java.util.Scanner;

class PuzzleN {
    Integer[][] Tabuleiro = null;
    Integer Jogadas = 0;

        //Função para criar o tabuleiro de acordo com o tamanho definido por x
        public void CriaTabuleiro(Integer x) {
            Tabuleiro = new Integer[x][x];
            Integer q = 0;

            for(int i = 0; i < x; i++) {
                for(int v = 0; v < x; v++) {
                    Tabuleiro[i][v] = q;
                    q++;
                }
            }
        }

        //Função para embaralhar o conteúdo do tabuleiro, repetindo turns vezes
        public void EmbaralhaTabuleiro(Integer turns) {
            Integer Troca;

            for(int i = 0; i < turns; i++) {
                Random r = new Random();
                Integer s = r.nextInt(Tabuleiro.length);
                Integer q = r.nextInt(Tabuleiro.length);

                Integer w = r.nextInt(Tabuleiro.length);
                Integer e = r.nextInt(Tabuleiro.length);

                Troca = Tabuleiro[s][q];
                Tabuleiro[s][q] = Tabuleiro[w][e];
                Tabuleiro[w][e] = Troca;
            }
        }

        //Função para exibir o estado atual do tabuleiro
        public void MostraTabuleiro() {
            System.out.println();
            for(int l = 0; l < Tabuleiro.length; l++) {
                for(int c = 0; c < Tabuleiro.length; c++) {
                    System.out.print(Tabuleiro[l][c]+ "\t");
                }
                System.out.println("\n");
            }
            System.out.println();
        }

        //Função para verificar se a peça zero está em volta de Peca
        public boolean VerificaEmVolta(Integer Peca) {
            Integer Linha = null, Coluna = null;

            for(int i = 0; i < Tabuleiro.length; i++) {
                for(int c = 0; c < Tabuleiro.length; c++) {
                    if(Tabuleiro[i][c] == Peca) {
                        Linha = i;
                        Coluna = c;
                        break;
                    }
                }
            }

            //Cima
            if((Linha-1) >= 0) {
                if(Tabuleiro[(Linha-1)][Coluna] == 0) {
                    return true;
                }
            }

            //Laterais
            if((Coluna-1) >= 0) {
                if(Tabuleiro[Linha][(Coluna-1)] == 0) {
                   return true;
                }
            }
            if((Coluna+1) <= (Tabuleiro.length-1)) {
                if(Tabuleiro[Linha][(Coluna+1)] == 0) {
                    return true;
                }
            }

            //Baixo
            if((Linha+1) <= (Tabuleiro.length-1)) {
                if(Tabuleiro[(Linha+1)][Coluna] == 0) {
                    return true;
                }
            }

            return false;
        }

        //Função para executar a jogada - substituir os valores da peça zero e Peca
        public void ExecutaJogada(Integer Peca) {
            Integer LinhaPeca = null, ColunaPeca = null;
            Integer LinhaZero = null, ColunaZero = null;

            if(VerificaEmVolta(Peca) == true) {
                for(int i = 0; i < Tabuleiro.length; i++) {
                    for(int x = 0; x < Tabuleiro.length; x++) {
                        if(Tabuleiro[i][x] == Peca) {
                            LinhaPeca = i;
                            ColunaPeca = x;
                        }
                        if(Tabuleiro[i][x] == 0) {
                            LinhaZero = i;
                            ColunaZero = x;
                        }
                    }
                }

                Tabuleiro[LinhaZero][ColunaZero] = Tabuleiro[LinhaPeca][ColunaPeca];
                Tabuleiro[LinhaPeca][ColunaPeca] = 0;
                Jogadas++;
            }
        }

        //Função para verificar se o tabuleiro está organizado, jogador ganhou
        public boolean VerificaTabuleiro() {
            Integer[] T = new Integer[Tabuleiro.length*Tabuleiro.length];
            Integer[] Model = new Integer[Tabuleiro.length*Tabuleiro.length];
            Integer q = 0;
            Integer Acertos = 0;
            boolean s = false;

            for(int i = 0; i < Tabuleiro.length; i++) {
                for(int x = 0; x < Tabuleiro.length; x++) {
                   T[q] = Tabuleiro[i][x];
                   q++;
                }
            }

            for(int i = 1; i < Tabuleiro.length*Tabuleiro.length-1; i++) {
                    Model[i-1] = i;
            }

            Model[Tabuleiro.length*Tabuleiro.length-1] = 0;

            for(int i = 0; i < Tabuleiro.length*Tabuleiro.length; i++) {
                if(T[i] == Model[i]) {
                    Acertos++;
                }
            }

            if(Acertos == Tabuleiro.length*Tabuleiro.length-1) {
                s = true;
            }
            return s;
        }
}

public class Main {

    public static void main(String[] args) {
        Integer Tamanho = 0;
        Integer T = 0;
        Scanner in = new Scanner(System.in);

        //Menu
        do {
            System.out.println("Bem vindo ao jogo Puzzle N.");
            System.out.println("Escolha o nível de dificuldade:");
            System.out.println("1 - Para fácil");
            System.out.println("2 - Para médio");
            System.out.println("3 - Para difícil");
            System.out.print("Digite sua opção: ");
            Tamanho = in.nextInt();
            System.out.println();
        } while(Tamanho < 1 || Tamanho > 3);

        switch(Tamanho) {
            case 1:
                T = 3;
                break;
            case 2:
                T = 4;
                break;
            case 3:
                T = 5;
                break;
        }

        //Cria ambiente do jogo
        PuzzleN Puzzle = new PuzzleN();
        Puzzle.CriaTabuleiro(T);
        Puzzle.EmbaralhaTabuleiro(10);
        Puzzle.MostraTabuleiro();

        Integer Jogada= 0;

        while(true) { //Executa infinitamente ou até ser parado
            System.out.print("Digite o número da peça que será movida: ");
            Jogada = in.nextInt();

            while(Jogada <= 0 || Jogada > (Puzzle.Tabuleiro.length*Puzzle.Tabuleiro.length)-1 || !Puzzle.VerificaEmVolta(Jogada)) {
                System.out.println("Peça inválida. Digite o número da peça que será movida: ");
                Jogada = in.nextInt();
            }

            Puzzle.ExecutaJogada(Jogada);
            Puzzle.MostraTabuleiro();
            //Se jogador ganhou, termine laço e exiba o resultado
            if(Puzzle.VerificaTabuleiro() == true) {
                break;
            }
        }
        Puzzle.MostraTabuleiro();
        System.out.println("Você venceu! Foram precisos " + Puzzle.Jogadas + " movimentos.");
    }
}

O jogo não possui interface gráfica. Logo, deve ser executado com o auxílio de um debugger.