2048 Jogo em Python
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:
- 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.
- O movimento para cima pode ser feito transpondo e movendo para a esquerda.
- O movimento para baixo pode ser feito transpondo a direita móvel.
- 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
)
(
"Commands are as follows : "
)
(
"'W' or 'w' : Move Up"
)
(
"'S' or 's' : Move Down"
)
(
"'A' or 'a' : Move Left"
)
(
"'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
As postagens do blog Acervo Lima te ajudaram? Nos ajude a manter o blog no ar!
Faça uma doação para manter o blog funcionando.
70% das doações são no valor de R$ 5,00...
Diógenes Lima da Silva