Programe seu próprio jogo 2048 com Java !: 8 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:34

Por PranP1My (Incomplete) SiteFollow Mais do autor:

Adoro o jogo 2048. Por isso decidi programar a minha própria versão.

É muito semelhante ao jogo real, mas programá-lo sozinho me dá a liberdade de mudar o que eu quiser quando quiser. Se eu quiser um jogo 5x5 em vez do 4x4 típico, uma simples mudança usando o construtor 'Tabuleiro' me permitirá fazer isso. Digamos que eu queira tornar o jogo mais difícil, adicionando peças em posições que o tornarão mais complexo para o jogador, em vez de aleatoriamente. Usando um algoritmo simples, posso fazer exatamente isso. Embora eu não aborde todas essas modificações neste Instructable, planejo adicionar mais conforme eu avance.

Por enquanto, entretanto, programaremos seu jogo típico de 2048.

Vamos começar!

(Uma nota lateral: este Instructable requer conhecimento moderado de programação - especificamente com Java)

Etapa 1: Materiais

Você não precisará de muito para este projeto, pois é apenas um passo a passo de programação.

Materiais:

• Computador portátil
• Eclipse (ou qualquer IDE de sua escolha)

Sim. É isso.

Etapa 2: Conheça o Programa - Quadro

Eu carreguei todo o meu código no GitHub - confira aqui:

Eu dividi o jogo em 3 classes: Tabuleiro, Bloco e Jogo.

Borda:

Descrição: A classe Board lida com o tabuleiro do jogo, configurando um array de elementos 'Tile', obtendo a pontuação atual e o ladrilho mais alto e colocando o array em uma string (para ser usado mais tarde em 'Game'). A maior parte da lógica também está aqui, a classe fornecendo métodos para gerar 2 e 4 em locais aleatórios, movendo-se para cima, para baixo, para a esquerda e para a direita, e informando aos jogadores quando o jogo acabou.

Construtores:

/ * Construtor padrão para a placa - configura uma matriz 4x4 * /

Conselho público () {…}

/ * Construtor para a placa - configura uma matriz com o tamanho de grade especificado * /

Public Board (int grids) {…}

Métodos:

/ * Método getter que retorna o tabuleiro * /

public Tile getBoard () {…}

/ * Método getter que retorna a pontuação * /

public int getScore () {…}

/ * Encontra a peça mais alta do tabuleiro e a retorna * /

public int getHighTile () {…}

/ * Imprime a placa no console - para fins de teste * /

public void print () {…}

/ * Retorna a placa como uma String - usada na GUI * /

public String toString () {…}

/ * Gera um 2 (ou 4) em um espaço vazio no momento em que um movimento é feito * /

public void spawn () {…}

/ * Verifica se o tabuleiro está completamente apagado e, se estiver, fará com que os jogadores reiniciem * /

public boolean blackOut () {…}

/ * Verifica se o jogo acabou - quando o tabuleiro está escuro e nenhuma das peças pode combinar * /

public boolean gameOver () {…}

/ * Chamado quando 'w' ou a seta para cima é pressionada - chama 'verticalMove' para cada peça no tabuleiro com o parâmetro 'para cima' * /

public void up () {…}

/ * Chamado quando 's' ou a seta para baixo são pressionadas - chama 'verticalMove' para cada bloco no tabuleiro com o parâmetro 'down' * / public void down () {…}

/ * Chamado quando 'd' ou seta para a direita são pressionados - chama 'horizontalMove' para cada bloco no tabuleiro com o parâmetro 'right' * / public void right () {…}

/ * Chamado quando 'a' ou seta para a esquerda é pressionada - chama 'horizontalMove' para cada ladrilho no tabuleiro com o parâmetro 'left' * /

public void left () {…}

/ * Compara os valores de dois blocos juntos e se eles são iguais ou se um for igual a 0 (bloco simples) - seus valores são adicionados (desde que os blocos que estamos comparando sejam dois blocos diferentes e estejam se movendo na direção apropriada) - move-se recursivamente pela linha * /

public void horizontalMove (int row, int col, String direction) {…}

/ * Compara os valores de dois blocos juntos e se eles são iguais ou se um for igual a 0 (bloco simples) - seus valores são adicionados (desde que os blocos que estamos comparando sejam dois blocos diferentes e estejam se movendo na direção apropriada) - move-se recursivamente pela coluna * /

public void verticalMove (int row, int col, String direction) {…}

Sim, são muitos métodos - mas não se preocupe, a maioria é extremamente fácil de entender. Além disso, a classe 'Board' é a mais complexa, então tudo depois disso será relativamente simples.

Etapa 3: Conheça o programa - Bloco

Telha:

Descrição: a classe Bloco lida com blocos individuais e é a menor de todas as classes. Cada bloco possui um valor inteiro e uma cor. Possui dois construtores que criam blocos de valor 0 (padrão) ou valor #. Os métodos são, em sua maioria, autoexplicativos, com os métodos 'getter' e 'setter' constituindo a maior parte do total.

Construtores:

/ * Constrói um bloco básico com um valor de 0 * /

bloco público () {…}

/ * Constrói um ladrilho com um valor de número * /

Bloco público (número interno) {…}

Métodos:

/ * Obtém o valor do bloco * /

public int getValue () {…}

/ * Define o valor do bloco - usado ao adicionar dois blocos juntos * /

public void setValue (valor int) {…}

/ * Representa o bloco como uma String - usado na GUI * /

public String toString () {…}

/ * Define a cor do bloco com base em seu valor * /

public void setColor () {…}

/ * Obtém a cor do bloco * /

public void getColor () {…}

Etapa 4: Conheça o Programa - Jogo

Jogo

Descrição: a classe Game contém o método principal, a maioria dos métodos GUI e as interações de chave. Ele usa as classes Tile e Board e permite que elas trabalhem juntas.

Construtores:

Nenhum

Métodos:

/ * configura a GUI com tamanhos apropriados e adiciona um Key Listener * /

public static void setUpGUI () {…}

/ * Verifica se as teclas wasd ou de seta estão pressionadas e executa as ações apropriadas - atualiza o JFrame a cada movimento * /

public void keyPressed (KeyEvent e) {…}

/ * Pinta a GUI com uma série de cordas, o tabuleiro, as peças e garante que sejam repintadas quando o jogo terminar * /

public void paint (Graphics g) {…}

/ * desenha um bloco individual - chamado a partir do método de pintura * /

public void drawTiles (Graphics g, Tile tile, int x, int y) {…}

/ * Método principal - configura a GUI e inicia o jogo * /

public static void main (String args) {…}

Etapa 5: Métodos Importantes - Movimento

Os métodos de movimento são os mais importantes de entender, mas a boa notícia é que, depois de entender os movimentos verticais, você pode aplicar esse entendimento aos movimentos horizontais. Na verdade, os três métodos de movimento vertical são exatamente iguais aos três métodos de movimento horizontal, exceto que um se move pelas linhas e o outro pelas colunas. Por esse motivo, vamos nos concentrar apenas nos métodos de movimento vertical.

private void verticalMove (int row, int col, String direction)

{Inicial do bloco = tabuleiro [borda] [col]; Comparação de blocos = tabuleiro [linha] [col]; if (initial.getValue () == 0 || initial.getValue () == compare.getValue ()) {if (row> border || (direction.equals ("down") && (row <border))) {int addScore = initial.getValue () + compare.getValue (); if (initial.getValue ()! = 0) {score + = addScore; } initial.setValue (addScore); compare.setValue (0); }} else {if (direction.equals ("down")) {border--; } else {border ++; } verticalMove (linha, coluna, direção); }}

O método acima, verticalMove, é chamado pelos métodos 'up' e 'down'. Vamos dar uma olhada no método 'up'.

public void up ()

{para (int i = 0; i <grades; i ++) {borda = 0; for (int j = 0; j <grades; j ++) {if (board [j] .getValue ()! = 0) {if (border <= j) {verticalMove (j, i, "para cima"); }}}}}

Este método percorre todo o tabuleiro e chama verticalMove para cada bloco com o parâmetro "para cima". verticalMove então compara o bloco na posição 'j' e 'i' com o bloco na posição 'borda' e 'i'. Se os dois forem iguais, eles serão combinados. Se não estiverem, o ladrilho da borda é aumentado em 1 (já que o parâmetro no local é 'para cima') e verticalMove é chamado novamente.