tetris/piece.py at main · iamlambda/tetris · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
import random


class Piece:
    """
    classe qui represente une piece de tetris
    """

    formes = ["J", "L", "S", "T", "Z", "I", "O"]
    pieces = {
        "J": [
            [1, 0, 0],
            [1, 1, 1],
            [0, 0, 0],
        ],
        "L": [
            [0, 0, 2],
            [2, 2, 2],
            [0, 0, 0],
        ],
        "S": [
            [0, 3, 3],
            [3, 3, 0],
            [0, 0, 0],
        ],
        "T": [
            [0, 4, 0],
            [4, 4, 4],
            [0, 0, 0],
        ],
        "Z": [
            [5, 5, 0],
            [0, 5, 5],
            [0, 0, 0],
        ],
        "I": [
            [0, 0, 0, 0, 0],
            [0, 0, 0, 0, 0],
            [0, 6, 6, 6, 6],
            [0, 0, 0, 0, 0],
            [0, 0, 0, 0, 0],
        ],
        "O": [
            [0, 7, 7],
            [0, 7, 7],
            [0, 0, 0],
        ],
    }
    table_decalages = {
        "JLSTZ": {
            0: [(0, 0), (0, 0), (0, 0), (0, 0), (0, 0)],
            1: [(0, 0), (1, 0), (1, -1), (0, 2), (1, 2)],
            2: [(0, 0), (0, 0), (0, 0), (0, 0), (0, 0)],
            3: [(0, 0), (-1, 0), (-1, -1), (0, 2), (-1, 2)],
        },
        "I": {
            0: [(0, 0), (-1, 0), (2, 0), (-1, 0), (2, 0)],
            1: [(-1, 0), (0, 0), (0, 0), (0, 1), (0, -2)],
            2: [(-1, 1), (1, 1), (-2, 1), (1, 0), (-2, 0)],
            3: [(0, 1), (0, 1), (0, 1), (0, -1), (0, 2)],
        },
        "O": {
            0: [(0, 0)],
            1: [(0, -1)],
            2: [(-1, -1)],
            3: [(-1, 0)],
        },
    }

    def __init__(self, forme, grille) -> None:
        """
        initialise la piece
        """
        # choix aleatoire de la forme
        self.forme = forme if forme else random.choice(self.formes)
        self.piece = self.pieces[self.forme]
        self.table = self.table_decalages[
            "JLSTZ" if self.forme in "JLSTZ" else self.forme
        ]

        self.x, self.y = (2, 18) if self.forme == "I" else (3, 19)
        self.taille = len(self.piece)
        self.etat = 0  # 0 a 3, incremente de 1 dans le sens horaire

        self.grille = grille

    def deplacer(self, dx: int, dy: int) -> None:
        """
        deplace la piece dans la direction indiquee si possible
        """
        self.x += dx
        self.y += dy
        if not self.grille.peut_placer(self):
            self.x -= dx
            self.y -= dy

    def descendre_max(self) -> None:
        """
        descend la piece au max
        """
        while self.grille.peut_placer(self):
            self.y += 1
        self.y -= 1

    def tourner(self, horaire: bool, decalage=True) -> None:
        """
        effectue une rotation de 90 degres dans le sens indique
        """
        etat_initial = self.etat

        # on effectue la rotation
        if horaire:
            self.piece = [
                [self.piece[i][j] for i in range(self.taille - 1, -1, -1)]
                for j in range(self.taille)
            ]
            self.etat = (self.etat + 1) % 4
        else:
            self.piece = [
                [self.piece[i][j] for i in range(self.taille)]
                for j in range(self.taille - 1, -1, -1)
            ]
            self.etat = (self.etat - 1) % 4

        # si on ne doit pas decaler, ou que le decalage fonctionne, on return
        if not decalage or self.decaler(etat_initial, self.etat):
            return

        # sinon on inverse la rotation
        self.tourner(not horaire, False)

    def decaler(self, etat_initial: int, etat_final: int) -> bool:
        """
        teste les kick possibles pour la piece, renvoie True si un kick a ete effectue
        """
        # technique basée sur le guide https://harddrop.com/wiki/SRS
        for i in range(len(self.table[etat_final])):
            # on calcule le kick
            dx = self.table[etat_initial][i][0] - self.table[etat_final][i][0]
            dy = self.table[etat_initial][i][1] - self.table[etat_final][i][1]

            # on teste si le kick est possible
            self.deplacer(dx, -dy)
            if self.grille.peut_placer(self):
                return True
            self.deplacer(-dx, dy)

        return False