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.

  ///////////////////////////////////
 //          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.

Desenvolvido por mim como forma de avaliação na faculdade.

flw