Neste artigo, veremos o código Python e a lógica para projetar um jogo 2048 que você jogou com frequência em seu smartphone. Se você não estiver familiarizado com o jogo, é altamente recomendável jogar primeiro o jogo para que você possa entender seu funcionamento básico.

Como jogar 2048:

1. Há uma grade 4 * 4 que pode ser preenchida com qualquer número. Inicialmente, duas células aleatórias são preenchidas com 2. As células de repouso estão vazias.

2. temos que pressionar qualquer uma das quatro teclas para mover para cima, para baixo, para a esquerda ou para a direita. Quando pressionamos qualquer tecla, os elementos da célula se movem nessa direção de modo que se dois números idênticos estiverem contidos nessa linha específica (no caso de mover para a esquerda ou direita) ou coluna (no caso de mover para cima e para baixo) eles obterão some e as células extremas nessa direção se preencham com aquele número e as células restantes ficam vazias novamente.



3. Após essa compressão de grade, qualquer célula vazia aleatória é preenchida com 2.

4. Seguindo o processo acima, temos que dobrar os elementos somando e perfazendo 2048 em qualquer uma das células. Se formos capazes de fazer isso, ganhamos.

5. Mas se durante o jogo não houver nenhuma célula vazia para ser preenchida com um novo 2, o jogo termina.

No processo acima, você pode ver os instantâneos da interface gráfica do usuário do 2048 jogo. Mas toda a lógica está no código principal. Portanto, para entender apenas a lógica por trás disso, podemos assumir que a grade acima é uma matriz 4 * 4 (uma lista com quatro linhas e quatro colunas). Você pode ver abaixo a forma de obter entrada e saída sem GUI para o jogo acima.



Exemplo:

Os comandos são os seguintes:
'W' ou 'w': Mover para cima
'S' ou 's': Mover para baixo
'A' ou 'a': mover para a esquerda
'D' ou 'd': Mover para a direita
[0, 0, 0, 0]
[0, 0, 0, 0]
[0, 0, 0, 0]
[0, 0, 2, 0]
Pressione o comando: a
O JOGO NÃO ACABOU
[0, 0, 0, 2]
[0, 0, 0, 0]
[0, 0, 0, 0]
[2, 0, 0, 0]
Pressione o comando: s
O JOGO NÃO ACABOU
[0, 0, 0, 0]
[0, 0, 0, 0]
[0, 0, 2, 0]
[2, 0, 0, 2]
Pressione o comando: d
O JOGO NÃO ACABOU
[0, 0, 0, 0]
[0, 0, 0, 0]
[2, 0, 0, 2]
[0, 0, 0, 4]
Pressione o comando: a
O JOGO NÃO ACABOU
[0, 2, 0, 0]
[0, 0, 0, 0]
[4, 0, 0, 0]
[4, 0, 0, 0]
Pressione o comando: s
O JOGO NÃO ACABOU
[0, 0, 0, 0]
[0, 0, 0, 0]
[0, 0, 0, 0]
[8, 2, 0, 2]
.
.
.
E a série de entradas e saídas continuará até perdermos ou ganharmos!

Abordagem de programação:

  1. Iremos projetar cada função lógica como se estivéssemos realizando um deslize para a esquerda e, em seguida, usaremos para deslizar para a direita invertendo a matriz e realizando um deslize para a esquerda.
  2. O movimento para cima pode ser feito transpondo e movendo para a esquerda.
  3. O movimento para baixo pode ser feito transpondo a direita móvel.
  4. Toda a lógica do programa é explicada em detalhes nos comentários. Altamente recomendado para passar por todos os comentários.

Temos dois arquivos python abaixo, um é 2048.py que contém o código do driver principal e o outro é logic.py que contém todas as funções usadas. Logic.py deve ser importado em 2048.py para usar essas funções. basta colocar os dois arquivos na mesma pasta e executar o 2048.py para funcionar perfeitamente.

import random 
def start_game(): 
  
    
    
    
    mat =[] 
    for i in range(4): 
        mat.append([0] * 4) 
  
    
    print("Commands are as follows : ") 
    print("'W' or 'w' : Move Up") 
    print("'S' or 's' : Move Down") 
    print("'A' or 'a' : Move Left") 
    print("'D' or 'd' : Move Right") 
  
    
    
    add_new_2(mat) 
    return mat 
def add_new_2(mat): 
  
   
   
    r = random.randint(0, 3) 
    c = random.randint(0, 3) 
  
    
    
    
    while(mat[r] != 0): 
        r = random.randint(0, 3) 
        c = random.randint(0, 3) 
  
    
    
    mat[r] = 2
def get_current_state(mat): 
  
    
    
    for i in range(4): 
        for j in range(4): 
            if(mat[i][j]== 2048): 
                return 'WON'
  
    
    
    
    for i in range(4): 
        for j in range(4): 
            if(mat[i][j]== 0): 
                return 'GAME NOT OVER'
  
    
    
    
    
    
    for i in range(3): 
        for j in range(3): 
            if(mat[i][j]== mat[i + 1][j] or mat[i][j]== mat[i][j + 1]): 
                return 'GAME NOT OVER'
  
    for j in range(3): 
        if(mat[3][j]== mat[3][j + 1]): 
            return 'GAME NOT OVER'
  
    for i in range(3): 
        if(mat[i][3]== mat[i + 1][3]): 
            return 'GAME NOT OVER'
  
    
    return 'LOST'
  
  
def compress(mat): 
  
    
    
    changed = False
  
    
    new_mat = [] 
  
    
    for i in range(4): 
        new_mat.append([0] * 4) 
          
    
    
    
    
    for i in range(4): 
        pos = 0
      for j in range(4): 
            if(mat[i][j] != 0): 
                                                new_mat[i][pos] = mat[i][j] 
                        if(j != pos): 
                    changed = True
                pos += 1
  
    
    
    return new_mat, changed 
def merge(mat): 
      
    changed = False
      
    for i in range(4): 
        for j in range(3): 
          if(mat[i][j] == mat[i][j + 1] and mat[i][j] != 0): 
                    mat[i][j] = mat[i][j] * 2
                mat[i][j + 1] = 0
                          changed = True
  
    return mat, changed 
  
def reverse(mat): 
    new_mat =[] 
    for i in range(4): 
        new_mat.append([]) 
        for j in range(4): 
            new_mat[i].append(mat[i][3 - j]) 
    return new_mat 
  
def transpose(mat): 
    new_mat = [] 
    for i in range(4): 
        new_mat.append([]) 
        for j in range(4): 
            new_mat[i].append(mat[j][i]) 
    return new_mat 
def move_left(grid): 
  
    
    new_grid, changed1 = compress(grid) 
  
    
    new_grid, changed2 = merge(new_grid) 
      
    changed = changed1 or changed2 
  
    
    new_grid, temp = compress(new_grid) 
  
    
    
    
    return new_grid, changed 
def move_right(grid): 
  
    
    
    new_grid = reverse(grid) 
  
    
    new_grid, changed = move_left(new_grid) 
  
    
    
    new_grid = reverse(new_grid) 
    return new_grid, changed 
def move_up(grid): 
  
    
    
    new_grid = transpose(grid) 
  
    
    
    new_grid, changed = move_left(new_grid) 
  
    
    
    new_grid = transpose(new_grid) 
    return new_grid, changed 
def move_down(grid): 
  
    
    new_grid = transpose(grid) 
  
    
    new_grid, changed = move_right(new_grid) 
  
    
    
    new_grid = transpose(new_grid) 
    return new_grid, changed