2048 Spiel in Python
In diesem Artikel werden wir uns mit Python-Code und Logik befassen, um ein 2048-Spiel zu entwerfen, das Sie sehr oft auf Ihrem Smartphone gespielt haben. Wenn Sie mit dem Spiel nicht vertraut sind, wird dringend empfohlen, das Spiel zuerst zu spielen, damit Sie die Grundfunktionen verstehen können.
Wie man 2048 spielt:
1. Es gibt ein 4 * 4-Raster, das mit einer beliebigen Zahl gefüllt werden kann. Zunächst werden zwei zufällige Zellen mit 2 gefüllt. Restzellen sind leer.
2. Wir müssen eine der vier Tasten drücken, um nach oben, unten, links oder rechts zu gelangen. Wenn wir eine beliebige Taste drücken, bewegen sich die Elemente der Zelle in diese Richtung, sodass sie erhalten, wenn zwei identische Zahlen in dieser bestimmten Zeile (bei Bewegung nach links oder rechts) oder Spalte (bei Bewegung nach oben und unten) enthalten sind addieren und extreme Zellen in dieser Richtung füllen sich mit dieser Zahl und Restzellen werden wieder leer.
3. Nach dieser Gitterkomprimierung wird jede zufällige leere Zelle mit 2 gefüllt.
4. Nach dem obigen Verfahren müssen wir die Elemente verdoppeln, indem wir 2048 in einer der Zellen addieren und ergeben. Wenn wir das können, gewinnen wir.
5. Wenn während des Spiels keine leere Zelle mehr vorhanden ist, die mit einer neuen 2 gefüllt werden kann, wird das Spiel beendet.
Im obigen Prozess können Sie die Schnappschüsse von der grafischen Benutzeroberfläche des 2048-Spiels sehen. Die ganze Logik liegt jedoch im Hauptcode. Um nur die Logik dahinter zu verstehen, können wir annehmen, dass das obige Gitter eine 4 * 4-Matrix ist (eine Liste mit vier Zeilen und vier Spalten). Unten sehen Sie, wie Sie für das obige Spiel Eingaben und Ausgaben ohne GUI vornehmen können.
Beispiel:
Die Befehle lauten wie folgt: 'W' oder 'w': Nach oben 'S' oder 's': Nach unten bewegen 'A' oder 'a': Nach links bewegen 'D' oder 'd': Nach rechts bewegen [0, 0, 0, 0] [0, 0, 0, 0] [0, 0, 0, 0] [0, 0, 2, 0] Drücken Sie den Befehl: a SPIEL NICHT ÜBER [0, 0, 0, 2] [0, 0, 0, 0] [0, 0, 0, 0] [2, 0, 0, 0] Drücken Sie den Befehl: s SPIEL NICHT ÜBER [0, 0, 0, 0] [0, 0, 0, 0] [0, 0, 2, 0] [2, 0, 0, 2] Drücken Sie den Befehl: d SPIEL NICHT ÜBER [0, 0, 0, 0] [0, 0, 0, 0] [2, 0, 0, 2] [0, 0, 0, 4] Drücken Sie den Befehl: a SPIEL NICHT ÜBER [0, 2, 0, 0] [0, 0, 0, 0] [4, 0, 0, 0] [4, 0, 0, 0] Drücken Sie den Befehl: s SPIEL NICHT ÜBER [0, 0, 0, 0] [0, 0, 0, 0] [0, 0, 0, 0] [8, 2, 0, 2] . . . Und die Reihe der Eingabe-Ausgabe wird fortgesetzt, bis wir verlieren oder gewinnen!
Programmieransatz:
- Wir werden jede Logikfunktion so entwerfen, dass wir einen linken Wisch ausführen, und sie dann für den rechten Wisch verwenden, indem wir die Matrix umkehren und den linken Wisch ausführen.
- Das Aufwärtsbewegen kann durch Transponieren und dann nach links erfolgen.
- Das Abwärtsbewegen kann durch Transponieren der Rechtsbewegung erfolgen.
- Die gesamte Logik im Programm wird in den Kommentaren ausführlich erläutert. Es wird dringend empfohlen, alle Kommentare durchzugehen.
Wir haben zwei Python-Dateien unten, eine ist 2048.py, die den Haupttreibercode enthält, und die andere ist logisch.py, die alle verwendeten Funktionen enthält. Logik.py sollte in 2048.py importiert werden, um diese Funktionen zu verwenden. Legen Sie einfach beide Dateien in denselben Ordner und führen Sie dann 2048.py aus.
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