README.md

@@ -26,10 +26,3 @@ python tetrarcade.py
 * Linux: Edit `~/.local/share/Tetrarcade/TetrArcade.ini`
 
 Use key name from [arcade.key package](http://arcade.academy/arcade.key.html).
-
-## Build
-
-```shell
-python -m pip install cx-freeze
-python setup.py build
-```

TetrArcade.py

@@ -3,7 +3,6 @@ import sys
 import locale
 import time
 import os
-
 try:
     import configparser
 except ImportError:
@@ -39,39 +38,32 @@ NORMAL_ALPHA = 200
 PRELOCKED_ALPHA = 100
 GHOST_ALPHA = 30
 MATRIX_BG_ALPHA = 100
-BAR_ALPHA = 75
 
 # Sprites
-WINDOW_BG_PATH = "res/bg.jpg"
+WINDOW_BG_PATH = "images/bg.jpg"
-MATRIX_BG_PATH = "res/matrix.png"
+MATRIX_SPRITE_PATH = "images/matrix.png"
-HELD_BG_PATH = "res/held.png"
-NEXT_BG_PATH = "res/next.png"
 MINOES_SPRITES_PATHS = {
-    "orange": "res/orange_mino.png",
+    "orange":  "images/orange_mino.png",
-    "blue": "res/blue_mino.png",
+    "blue":    "images/blue_mino.png",
-    "yellow": "res/yellow_mino.png",
+    "yellow":  "images/yellow_mino.png",
-    "cyan": "res/cyan_mino.png",
+    "cyan":    "images/cyan_mino.png",
-    "green": "res/green_mino.png",
+    "green":   "images/green_mino.png",
-    "red": "res/red_mino.png",
+    "red":     "images/red_mino.png",
-    "magenta": "res/magenta_mino.png",
+    "magenta": "images/magenta_mino.png"
 }
 
 # User profile path
 if sys.platform == "win32":
-    USER_PROFILE_DIR = os.environ.get(
+    USER_PROFILE_DIR = os.environ.get("appdata", os.path.expanduser("~\Appdata\Roaming"))
-        "appdata", os.path.expanduser("~\Appdata\Roaming")
-    )
 else:
-    USER_PROFILE_DIR = os.environ.get(
+    USER_PROFILE_DIR = os.environ.get("XDG_DATA_HOME", os.path.expanduser("~/.local/share"))
-        "XDG_DATA_HOME", os.path.expanduser("~/.local/share")
-    )
 USER_PROFILE_DIR = os.path.join(USER_PROFILE_DIR, "TetrArcade")
 HIGH_SCORE_PATH = os.path.join(USER_PROFILE_DIR, ".high_score")
 CONF_PATH = os.path.join(USER_PROFILE_DIR, "TetrArcade.ini")
 
 # Text
 TEXT_COLOR = arcade.color.BUBBLES
-FONT_NAME = "res/joystix monospace.ttf"
+FONT_NAME = "joystix monospace.ttf"
 STATS_TEXT_MARGIN = 40
 STATS_TEXT_SIZE = 14
 STATS_TEXT_WIDTH = 150
@@ -80,6 +72,7 @@ HIGHLIGHT_TEXT_SIZE = 20
 
 
 class MinoSprite(arcade.Sprite):
+
     def __init__(self, mino, window, alpha):
         super().__init__(MINOES_SPRITES_PATHS[mino.color], window.scale)
         self.alpha = alpha
@@ -87,11 +80,12 @@ class MinoSprite(arcade.Sprite):
 
     def set_position(self, x, y):
         size = MINO_SIZE * self.scale
-        self.left = self.window.matrix_bg.left + x * size
+        self.left   = self.window.matrix_bg.left   + x*size
-        self.bottom = self.window.matrix_bg.bottom + y * size
+        self.bottom = self.window.matrix_bg.bottom + y*size
 
 
 class MinoesSprites(arcade.SpriteList):
+
     def resize(self, scale):
         for sprite in self:
             sprite.scale = scale
@@ -99,6 +93,7 @@ class MinoesSprites(arcade.SpriteList):
 
 
 class TetrominoSprites(MinoesSprites):
+
     def __init__(self, tetromino, window, alpha=NORMAL_ALPHA):
         super().__init__()
         self.tetromino = tetromino
@@ -119,6 +114,7 @@ class TetrominoSprites(MinoesSprites):
 
 
 class MatrixSprites(MinoesSprites):
+
     def __init__(self, matrix):
         super().__init__()
         self.matrix = matrix
@@ -133,8 +129,9 @@ class MatrixSprites(MinoesSprites):
 
 
 class TetrArcade(tetrislogic.TetrisLogic, arcade.Window):
+
     def __init__(self):
-        locale.setlocale(locale.LC_ALL, "")
+        locale.setlocale(locale.LC_ALL, '')
         self.highlight_texts = []
         self.tasks = {}
 
@@ -152,23 +149,22 @@ class TetrArcade(tetrislogic.TetrisLogic, arcade.Window):
         super().__init__()
         arcade.Window.__init__(
             self,
-            width=self.init_width,
+            width = self.init_width,
-            height=self.init_height,
+            height = self.init_height,
-            title=WINDOW_TITLE,
+            title = WINDOW_TITLE,
-            resizable=True,
+            resizable = True,
-            antialiasing=False,
+            antialiasing = False,
-            fullscreen=self.init_fullscreen,
+            fullscreen = self.init_fullscreen
         )
-
         arcade.set_background_color(BG_COLOR)
         self.set_minimum_size(WINDOW_MIN_WIDTH, WINDOW_MIN_HEIGHT)
         self.bg = arcade.Sprite(WINDOW_BG_PATH)
-        self.matrix_bg = arcade.Sprite(MATRIX_BG_PATH)
+        self.matrix_bg = arcade.Sprite(MATRIX_SPRITE_PATH)
         self.matrix_bg.alpha = MATRIX_BG_ALPHA
-        self.held_bg = arcade.Sprite(HELD_BG_PATH)
+        self.held_bg = arcade.Sprite("images/held.png")
-        self.held_bg.alpha = BAR_ALPHA
+        self.held_bg.alpha = MATRIX_BG_ALPHA
-        self.next_bg = arcade.Sprite(NEXT_BG_PATH)
+        self.next_bg = arcade.Sprite("images/next.png")
-        self.next_bg.alpha = BAR_ALPHA
+        self.next_bg.alpha = MATRIX_BG_ALPHA
         self.matrix.sprites = MatrixSprites(self.matrix)
         self.on_resize(self.init_width, self.init_height)
 
@@ -176,7 +172,7 @@ class TetrArcade(tetrislogic.TetrisLogic, arcade.Window):
         self.conf["WINDOW"] = {
             "width": WINDOW_WIDTH,
             "height": WINDOW_HEIGHT,
-            "fullscreen": False,
+            "fullscreen": False
         }
         self.conf["KEYBOARD"] = {
             "start": "ENTER",
@@ -188,12 +184,12 @@ class TetrArcade(tetrislogic.TetrisLogic, arcade.Window):
             "rotate counter": "Z",
             "hold": "C",
             "pause": "ESCAPE",
-            "fullscreen": "F11",
+            "fullscreen": "F11"
         }
         self.load_conf()
         if not os.path.exists(USER_PROFILE_DIR):
             os.makedirs(USER_PROFILE_DIR)
-        with open(CONF_PATH, "w") as f:
+        with open(CONF_PATH, 'w') as f:
             self.conf.write(f)
 
     def load_conf(self):
@@ -204,61 +200,38 @@ class TetrArcade(tetrislogic.TetrisLogic, arcade.Window):
         self.key_map = {
             tetrislogic.State.STARTING: {
                 getattr(arcade.key, self.conf["KEYBOARD"]["start"]): self.new_game,
-                getattr(
+                getattr(arcade.key, self.conf["KEYBOARD"]["fullscreen"]): self.toggle_fullscreen
-                    arcade.key, self.conf["KEYBOARD"]["fullscreen"]
-                ): self.toggle_fullscreen,
             },
             tetrislogic.State.PLAYING: {
                 getattr(arcade.key, self.conf["KEYBOARD"]["move left"]): self.move_left,
-                getattr(
+                getattr(arcade.key, self.conf["KEYBOARD"]["move right"]): self.move_right,
-                    arcade.key, self.conf["KEYBOARD"]["move right"]
-                ): self.move_right,
                 getattr(arcade.key, self.conf["KEYBOARD"]["soft drop"]): self.soft_drop,
                 getattr(arcade.key, self.conf["KEYBOARD"]["hard drop"]): self.hard_drop,
-                getattr(
+                getattr(arcade.key, self.conf["KEYBOARD"]["rotate clockwise"]): self.rotate_clockwise,
-                    arcade.key, self.conf["KEYBOARD"]["rotate clockwise"]
+                getattr(arcade.key, self.conf["KEYBOARD"]["rotate counter"]): self.rotate_counter,
-                ): self.rotate_clockwise,
-                getattr(
-                    arcade.key, self.conf["KEYBOARD"]["rotate counter"]
-                ): self.rotate_counter,
                 getattr(arcade.key, self.conf["KEYBOARD"]["hold"]): self.swap,
                 getattr(arcade.key, self.conf["KEYBOARD"]["pause"]): self.pause,
-                getattr(
+                getattr(arcade.key, self.conf["KEYBOARD"]["fullscreen"]): self.toggle_fullscreen
-                    arcade.key, self.conf["KEYBOARD"]["fullscreen"]
-                ): self.toggle_fullscreen,
             },
             tetrislogic.State.PAUSED: {
                 getattr(arcade.key, self.conf["KEYBOARD"]["pause"]): self.resume,
-                getattr(
+                getattr(arcade.key, self.conf["KEYBOARD"]["fullscreen"]): self.toggle_fullscreen
-                    arcade.key, self.conf["KEYBOARD"]["fullscreen"]
-                ): self.toggle_fullscreen,
             },
             tetrislogic.State.OVER: {
                 getattr(arcade.key, self.conf["KEYBOARD"]["start"]): self.new_game,
-                getattr(
+                getattr(arcade.key, self.conf["KEYBOARD"]["fullscreen"]): self.toggle_fullscreen
-                    arcade.key, self.conf["KEYBOARD"]["fullscreen"]
+            }
-                ): self.toggle_fullscreen,
-            },
         }
 
-        controls_text = (
+        controls_text = "\n\n\nCONTROLS\n\n" + "\n".join(
-            "\n\n\nCONTROLS\n\n"
+            "{:<16s}{:>6s}".format(key, action)
-            + "\n".join(
+            for key, action in tuple(self.conf["KEYBOARD"].items()) + (("QUIT", "ALT+F4"),)
-                "{:<16s}{:>6s}".format(key, action)
+        ) + "\n\n\n"
-                for key, action in tuple(self.conf["KEYBOARD"].items())
+        self.start_text = "TETRARCADE" + controls_text + "PRESS [{}] TO START".format(
-                + (("QUIT", "ALT+F4"),)
+            self.conf["KEYBOARD"]["start"]
-            )
-            + "\n\n\n"
         )
-        self.start_text = (
+        self.pause_text = "PAUSE" + controls_text + "PRESS [{}] TO RESUME".format(
-            "TETRARCADE"
+            self.conf["KEYBOARD"]["pause"]
-            + controls_text
-            + "PRESS [{}] TO START".format(self.conf["KEYBOARD"]["start"])
-        )
-        self.pause_text = (
-            "PAUSE"
-            + controls_text
-            + "PRESS [{}] TO RESUME".format(self.conf["KEYBOARD"]["pause"])
         )
         self.game_over_text = """GAME
 OVER
@@ -357,59 +330,65 @@ AGAIN""".format(
             t = time.localtime(self.time)
             font_size = STATS_TEXT_SIZE * self.scale
             for y, text in enumerate(
-                ("TIME", "LINES", "GOAL", "LEVEL", "HIGH SCORE", "SCORE")
+                (
+                    "TIME",
+                    "LINES",
+                    "GOAL",
+                    "LEVEL",
+                    "HIGH SCORE",
+                    "SCORE"
+                )
             ):
                 arcade.draw_text(
-                    text=text,
+                    text = text,
-                    start_x=self.matrix_bg.left
+                    start_x = self.matrix_bg.left - self.scale*(STATS_TEXT_MARGIN + STATS_TEXT_WIDTH),
-                    - self.scale * (STATS_TEXT_MARGIN + STATS_TEXT_WIDTH),
+                    start_y = self.matrix_bg.bottom + 1.5*(2*y+1)*font_size,
-                    start_y=self.matrix_bg.bottom + 1.5 * (2 * y + 1) * font_size,
+                    color = TEXT_COLOR,
-                    color=TEXT_COLOR,
+                    font_size = font_size,
-                    font_size=font_size,
+                    align = 'right',
-                    align="right",
+                    font_name = FONT_NAME,
-                    font_name=FONT_NAME,
+                    anchor_x = 'left'
-                    anchor_x="left",
                 )
             for y, text in enumerate(
                 (
-                    "{:02d}:{:02d}:{:02d}".format(t.tm_hour - 1, t.tm_min, t.tm_sec),
+                    "{:02d}:{:02d}:{:02d}".format(
+                        t.tm_hour-1, t.tm_min, t.tm_sec
+                    ),
                     "{:n}".format(self.nb_lines_cleared),
                     "{:n}".format(self.goal),
                     "{:n}".format(self.level),
                     "{:n}".format(self.high_score),
-                    "{:n}".format(self.score),
+                    "{:n}".format(self.score)
                 )
             ):
                 arcade.draw_text(
-                    text=text,
+                    text = text,
-                    start_x=self.matrix_bg.left - STATS_TEXT_MARGIN * self.scale,
+                    start_x = self.matrix_bg.left - STATS_TEXT_MARGIN*self.scale,
-                    start_y=self.matrix_bg.bottom + 3 * y * font_size,
+                    start_y = self.matrix_bg.bottom + 3*y*font_size,
-                    color=TEXT_COLOR,
+                    color = TEXT_COLOR,
-                    font_size=font_size,
+                    font_size = font_size,
-                    align="right",
+                    align = 'right',
-                    font_name=FONT_NAME,
+                    font_name = FONT_NAME,
-                    anchor_x="right",
+                    anchor_x = 'right'
                 )
 
         highlight_text = {
             tetrislogic.State.STARTING: self.start_text,
-            tetrislogic.State.PLAYING: self.highlight_texts[0]
+            tetrislogic.State.PLAYING: self.highlight_texts[0] if self.highlight_texts else "",
-            if self.highlight_texts
-            else "",
             tetrislogic.State.PAUSED: self.pause_text,
-            tetrislogic.State.OVER: self.game_over_text,
+            tetrislogic.State.OVER: self.game_over_text
         }.get(self.state, "")
         if highlight_text:
             arcade.draw_text(
-                text=highlight_text,
+                text = highlight_text,
-                start_x=self.matrix_bg.center_x,
+                start_x = self.matrix_bg.center_x,
-                start_y=self.matrix_bg.center_y,
+                start_y = self.matrix_bg.center_y,
-                color=HIGHLIGHT_TEXT_COLOR,
+                color = HIGHLIGHT_TEXT_COLOR,
-                font_size=HIGHLIGHT_TEXT_SIZE * self.scale,
+                font_size = HIGHLIGHT_TEXT_SIZE * self.scale,
-                align="center",
+                align = 'center',
-                font_name=FONT_NAME,
+                font_name = FONT_NAME,
-                anchor_x="center",
+                anchor_x = 'center',
-                anchor_y="center",
+                anchor_y = 'center'
             )
 
     def on_hide(self):
@@ -422,9 +401,9 @@ AGAIN""".format(
         super().on_resize(width, height)
         center_x = width / 2
         center_y = height / 2
-        self.scale = min(width / WINDOW_WIDTH, height / WINDOW_HEIGHT)
+        self.scale = min(width/WINDOW_WIDTH, height/WINDOW_HEIGHT)
 
-        self.bg.scale = max(width / WINDOW_WIDTH, height / WINDOW_HEIGHT)
+        self.bg.scale = max(width/WINDOW_WIDTH, height/WINDOW_HEIGHT)
         self.bg.center_x = center_x
         self.bg.center_y = center_y
 
@@ -432,7 +411,7 @@ AGAIN""".format(
         self.matrix_bg.center_x = center_x
         self.matrix_bg.center_y = center_y
         self.matrix_bg.left = int(self.matrix_bg.left)
-        self.matrix_bg.top = int(self.matrix_bg.top)
+        self.matrix_bg.top  = int(self.matrix_bg.top)
 
         self.held_bg.scale = self.scale
         self.held_bg.right = self.matrix_bg.left
@@ -460,17 +439,14 @@ AGAIN""".format(
         try:
             if not os.path.exists(USER_PROFILE_DIR):
                 os.makedirs(USER_PROFILE_DIR)
-            with open(HIGH_SCORE_PATH, mode="wb") as f:
+            with open(HIGH_SCORE_PATH, mode='wb') as f:
                 crypted_high_score = super().save_high_score()
                 f.write(crypted_high_score)
         except Exception as e:
             sys.exit(
                 """High score: {:n}
 High score could not be saved:
-""".format(
+""".format(self.high_score) + str(e)
-                    self.high_score
-                )
-                + str(e)
             )
 
     def start(self, task, period):
@@ -501,11 +477,9 @@ High score could not be saved:
         self.save_high_score()
         super().on_close()
 
-
 def main():
     TetrArcade()
     arcade.run()
 
-
 if __name__ == "__main__":
     main()

setup.py

@@ -1,30 +0,0 @@
-# -*- coding: utf-8 -*-
-import sys
-from cx_Freeze import setup, Executable
-
-if sys.platform == "win32":
-    base = "Win32GUI"
-    icon = "icon.ico"
-else:
-    base = None
-    icon = None
-
-setup(
-    name="TetrArcade",
-    version="0.1",
-    description="Tetris clone",
-    author="adrienmalin",
-    executables=[Executable(
-        script="TetrArcade.py",
-        icon=icon,
-        base=base
-    )],
-    options={
-        "build_exe": {
-            "packages": ["arcade"],
-            "excludes": ["tkinter"],
-            "include_files": "res",
-            "silent": True
-        }
-    },
-)

tetrislogic/consts.py

@@ -10,11 +10,14 @@ NB_NEXT = 5
 # Delays (seconds)
 LOCK_DELAY = 0.5
 FALL_DELAY = 1
-AUTOREPEAT_DELAY = 0.200  # Official : 0.300
+AUTOREPEAT_DELAY = 0.200    # Official : 0.300
-AUTOREPEAT_PERIOD = 0.010  # Official : 0.010
+AUTOREPEAT_PERIOD = 0.010   # Official : 0.010
 
 
 # Piece init coord
 CURRENT_COORD = Coord(4, NB_LINES)
-NEXT_COORDS = [Coord(NB_COLS + 4, NB_LINES - 4 * n - 3) for n in range(NB_NEXT)]
+NEXT_COORDS = [
-HELD_COORD = Coord(-5, NB_LINES - 3)
+    Coord(NB_COLS+4, NB_LINES-4*n-3)
+    for n in range(NB_NEXT)
+]
+HELD_COORD = Coord(-5, NB_LINES-3)

tetrislogic/tetrislogic.py

@@ -5,16 +5,10 @@ import pickle
 from .utils import Coord, Movement, Rotation, T_Spin, Line
 from .tetromino import Tetromino, T, I
 from .consts import (
-    NB_LINES,
+    NB_LINES, NB_COLS, NB_NEXT,
-    NB_COLS,
+    LOCK_DELAY, FALL_DELAY,
-    NB_NEXT,
+    AUTOREPEAT_DELAY, AUTOREPEAT_PERIOD,
-    LOCK_DELAY,
+    CURRENT_COORD, NEXT_COORDS, HELD_COORD
-    FALL_DELAY,
-    AUTOREPEAT_DELAY,
-    AUTOREPEAT_PERIOD,
-    CURRENT_COORD,
-    NEXT_COORDS,
-    HELD_COORD,
 )
 
 
@@ -25,17 +19,22 @@ CRYPT_KEY = 987943759387540938469837689379857347598347598379584857934579343
 class State:
 
     STARTING = "STARTING"
-    PLAYING = "PLAYING"
+    PLAYING  = "PLAYING"
-    PAUSED = "PAUSED"
+    PAUSED   = "PAUSED"
-    OVER = "OVER"
+    OVER     = "OVER"
 
 
 class Matrix(list):
+
     def cell_is_free(self, coord):
-        return 0 <= coord.x < NB_COLS and 0 <= coord.y and not self[coord.y][coord.x]
+        return (
+            0 <= coord.x < NB_COLS
+            and 0 <= coord.y
+            and not self[coord.y][coord.x]
+        )
 
 
-class TetrisLogic:
+class TetrisLogic():
 
     NB_LINES = NB_LINES
     NB_COLS = NB_COLS
@@ -86,7 +85,7 @@ class TetrisLogic:
         self.fall_delay = self.FALL_DELAY
 
         self.matrix.clear()
-        for y in range(self.NB_LINES + 3):
+        for y in range(self.NB_LINES+3):
             self.append_new_line_to_matrix()
         self.next = [self.new_tetromino() for n in range(self.NB_NEXT)]
         self.held = None
@@ -108,9 +107,9 @@ class TetrisLogic:
         self.level += 1
         self.goal += 5 * self.level
         if self.level <= 20:
-            self.fall_delay = pow(0.8 - ((self.level - 1) * 0.007), self.level - 1)
+            self.fall_delay = pow(0.8 - ((self.level-1)*0.007), self.level-1)
         if self.level > 15:
-            self.lock_delay = 0.5 * pow(0.9, self.level - 15)
+            self.lock_delay = 0.5 * pow(0.9, self.level-15)
         self.show_text("LEVEL\n{:n}".format(self.level))
         self.restart(self.fall, self.fall_delay)
 
@@ -123,10 +122,13 @@ class TetrisLogic:
         self.move_ghost()
         self.next.append(self.new_tetromino())
         self.next[-1].coord = self.NEXT_COORDS[-1]
-        for tetromino, coord in zip(self.next, self.NEXT_COORDS):
+        for tetromino, coord in zip (self.next, self.NEXT_COORDS):
             tetromino.coord = coord
 
-        if not self.can_move(self.current.coord, (mino.coord for mino in self.current)):
+        if not self.can_move(
+            self.current.coord,
+            (mino.coord for mino in self.current)
+        ):
             self.game_over()
 
     def move_left(self):
@@ -146,7 +148,8 @@ class TetrisLogic:
         for ghost_mino, current_mino in zip(self.ghost, self.current):
             ghost_mino.coord = current_mino.coord
         while self.can_move(
-            self.ghost.coord + Movement.DOWN, (mino.coord for mino in self.ghost)
+            self.ghost.coord + Movement.DOWN,
+            (mino.coord for mino in self.ghost)
         ):
             self.ghost.coord += Movement.DOWN
 
@@ -166,7 +169,10 @@ class TetrisLogic:
 
     def move(self, movement, prelock=True):
         potential_coord = self.current.coord + movement
-        if self.can_move(potential_coord, (mino.coord for mino in self.current)):
+        if self.can_move(
+            potential_coord,
+            (mino.coord for mino in self.current)
+        ):
             if self.current.prelocked:
                 self.restart(self.lock, self.lock_delay)
             self.current.coord = potential_coord
@@ -175,18 +181,22 @@ class TetrisLogic:
             self.move_ghost()
             return True
         else:
-            if prelock and not self.current.prelocked and movement == Movement.DOWN:
+            if (
+                prelock and not self.current.prelocked
+                and movement == Movement.DOWN
+            ):
                 self.current.prelocked = True
                 self.start(self.lock, self.lock_delay)
             return False
 
     def rotate(self, rotation):
         rotated_coords = tuple(
-            Coord(rotation * mino.coord.y, -rotation * mino.coord.x)
+            Coord(rotation*mino.coord.y, -rotation*mino.coord.x)
             for mino in self.current
         )
         for rotation_point, liberty_degree in enumerate(
-            self.current.SRS[rotation][self.current.orientation], start=1
+            self.current.SRS[rotation][self.current.orientation],
+            start = 1
         ):
             potential_coord = self.current.coord + liberty_degree
             if self.can_move(potential_coord, rotated_coords):
@@ -195,7 +205,9 @@ class TetrisLogic:
                 self.current.coord = potential_coord
                 for mino, coord in zip(self.current, rotated_coords):
                     mino.coord = coord
-                self.current.orientation = (self.current.orientation + rotation) % 4
+                self.current.orientation = (
+                    (self.current.orientation + rotation) % 4
+                )
                 self.current.last_rotation_point = rotation_point
                 self.move_ghost()
                 return True
@@ -207,7 +219,7 @@ class TetrisLogic:
         {LINES_CLEAR_NAME: "SINGLE", T_Spin.NONE: 1, T_Spin.MINI: 2, T_Spin.T_SPIN: 8},
         {LINES_CLEAR_NAME: "DOUBLE", T_Spin.NONE: 3, T_Spin.T_SPIN: 12},
         {LINES_CLEAR_NAME: "TRIPLE", T_Spin.NONE: 5, T_Spin.T_SPIN: 16},
-        {LINES_CLEAR_NAME: "TETRIS", T_Spin.NONE: 8},
+        {LINES_CLEAR_NAME: "TETRIS", T_Spin.NONE: 8}
     )
 
     def lock(self):
@@ -216,7 +228,8 @@ class TetrisLogic:
 
         # Piece unlocked
         if self.can_move(
-            self.current.coord + Movement.DOWN, (mino.coord for mino in self.current)
+            self.current.coord + Movement.DOWN,
+            (mino.coord for mino in self.current)
         ):
             return
 
@@ -233,12 +246,17 @@ class TetrisLogic:
             self.restart(self.repeat_action, self.AUTOREPEAT_DELAY)
 
         # T-Spin
-        if type(self.current) == T and self.current.last_rotation_point is not None:
+        if (
+            type(self.current) == T
+            and self.current.last_rotation_point is not None
+        ):
             a = self.is_t_slot(0)
             b = self.is_t_slot(1)
             c = self.is_t_slot(3)
             d = self.is_t_slot(2)
-            if self.current.last_rotation_point == 5 or (a and b and (c or d)):
+            if self.current.last_rotation_point == 5 or (
+                a and b and (c or d)
+            ):
                 t_spin = T_Spin.T_SPIN
             elif c and d and (a or b):
                 t_spin = T_Spin.MINI
@@ -249,8 +267,8 @@ class TetrisLogic:
 
         for mino in self.current:
             coord = mino.coord + self.current.coord
-            del mino.coord
+            del(mino.coord)
-            if coord.y <= self.NB_LINES + 3:
+            if coord.y <= self.NB_LINES+3:
                 self.matrix[coord.y][coord.x] = mino
 
         # Clear complete lines
@@ -284,7 +302,7 @@ class TetrisLogic:
             self.show_text("\n".join(lock_strings))
 
         if self.combo >= 1:
-            ds = (20 if nb_lines_cleared == 1 else 50) * self.combo * self.level
+            ds = (20 if nb_lines_cleared==1 else 50) * self.combo * self.level
             lock_score += ds
             self.show_text("COMBO x{:n}\n{:n}".format(self.combo, ds))
 
@@ -297,16 +315,21 @@ class TetrisLogic:
 
     def can_move(self, potential_coord, minoes_coords):
         return all(
-            self.matrix.cell_is_free(potential_coord + mino_coord)
+            self.matrix.cell_is_free(potential_coord+mino_coord)
             for mino_coord in minoes_coords
         )
 
-    T_SLOT_COORDS = (Coord(-1, 1), Coord(1, 1), Coord(-1, 1), Coord(-1, -1))
+    T_SLOT_COORDS = (
+        Coord(-1,  1),
+        Coord( 1,  1),
+        Coord(-1,  1),
+        Coord(-1, -1)
+    )
 
     def is_t_slot(self, n):
-        t_slot_coord = (
+        t_slot_coord = self.current.coord + self.T_SLOT_COORDS[
-            self.current.coord + self.T_SLOT_COORDS[(self.current.orientation + n) % 4]
+            (self.current.orientation + n) % 4
-        )
+        ]
         return not self.matrix.cell_is_free(t_slot_coord)
 
     def swap(self):

tetrislogic/tetromino.py

@@ -1,14 +1,15 @@
 # -*- coding: utf-8 -*-
 from .utils import Coord, Rotation
 
-
 class Mino:
+
     def __init__(self, color, coord):
         self.color = color
         self.coord = coord
 
 
 class MetaTetromino(type):
+
     def __init__(cls, name, bases, dct):
         super().__init__(name, bases, dct)
         Tetromino.shapes.append(cls)
@@ -34,7 +35,10 @@ class Tetromino(list):
     }
 
     def __init__(self):
-        super().__init__(Mino(self.MINOES_COLOR, coord) for coord in self.MINOES_COORDS)
+        super().__init__(
+            Mino(self.MINOES_COLOR, coord)
+            for coord in self.MINOES_COORDS
+        )
         self.orientation = 0
         self.last_rotation_point = None
         self.hold_enabled = True
@@ -43,7 +47,6 @@ class Tetromino(list):
     def ghost(self):
         return type(self)()
 
-
 class O(Tetromino, metaclass=MetaTetromino):
 
     SRS = {

tetrislogic/utils.py

@@ -1,32 +1,34 @@
 # -*- coding: utf-8 -*-
 class Coord:
+
     def __init__(self, x, y):
         self.x = x
         self.y = y
 
     def __add__(self, other):
-        return Coord(self.x + other.x, self.y + other.y)
+        return Coord(self.x+other.x, self.y+other.y)
 
 
 class Movement:
 
-    LEFT = Coord(-1, 0)
+    LEFT  = Coord(-1,  0)
-    RIGHT = Coord(1, 0)
+    RIGHT = Coord( 1,  0)
-    DOWN = Coord(0, -1)
+    DOWN  = Coord( 0, -1)
 
 
 class Rotation:
 
-    CLOCKWISE = 1
+    CLOCKWISE =  1
-    COUNTER = -1
+    COUNTER   = -1
 
 
 class T_Spin:
 
-    NONE = ""
+    NONE =   ""
     MINI = "MINI\nT-SPIN"
-    T_SPIN = "T-SPIN"
+    T_SPIN =      "T-SPIN"
 
 
 class Line(list):
     pass
+