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:

  1. 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.
  2. Das Aufwärtsbewegen kann durch Transponieren und dann nach links erfolgen.
  3. Das Abwärtsbewegen kann durch Transponieren der Rechtsbewegung erfolgen.
  4. 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) 
  
    
    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