README.md

@@ -6,8 +6,7 @@ Tetris clone made with Python and Arcade graphic library
 
 ## Requirements
 
-* [Python 3.6 or later](https://www.python.org/)
-* [FFmpeg 4](http://ubuntuhandbook.org/index.php/2019/08/install-ffmpeg-4-2-ubuntu-18-04/)
+* [Python](https://www.python.org/) 3.6 or upper
 
 ## Install
 

TetrArcade.py

@@ -1,9 +1,10 @@
 # -*- coding: utf-8 -*-
-"""Tetris clone with arcade GUI library"""
-
-
 import sys
-import random
+import locale
+import time
+import os
+
+import configparser
 
 try:
     import arcade
@@ -15,43 +16,11 @@ This game require arcade library.
 You can install it with:
 python -m pip install --user arcade"""
     )
-import pyglet
 
-import locale
-import time
-import os
-import itertools
-import configparser
-
-from tetrislogic import (
-    TetrisLogic,
-    Color,
-    Coord,
-    I_Tetrimino,
-    Movement,
-    AbstractScheduler,
-)
+from tetrislogic import TetrisLogic, Color, State
 
 
 # Constants
-# Matrix
-LINES = 20
-COLLUMNS = 10
-NEXT_PIECES = 6
-
-# Delays (seconds)
-LOCK_DELAY = 0.5
-FALL_DELAY = 1
-AUTOREPEAT_DELAY = 0.300
-AUTOREPEAT_PERIOD = 0.010
-PARTICULE_ACCELERATION = 1.1
-EXPLOSION_ANIMATION = 1
-
-# Piece init coord
-MATRIX_PIECE_COORD = Coord(4, LINES)
-NEXT_PIECES_COORDS = [Coord(COLLUMNS + 4, LINES - 4 * n) for n in range(NEXT_PIECES)]
-HELD_PIECE_COORD = Coord(-5, LINES)
-
 # Window
 WINDOW_WIDTH = 800
 WINDOW_HEIGHT = 600
@@ -64,7 +33,7 @@ BG_COLOR = (7, 11, 21)
 HIGHLIGHT_TEXT_DISPLAY_DELAY = 0.7
 
 # Transparency (0=invisible, 255=opaque)
-NORMAL_ALPHA = 255
+NORMAL_ALPHA = 200
 PRELOCKED_ALPHA = 100
 GHOST_ALPHA = 30
 MATRIX_BG_ALPHA = 100
@@ -74,20 +43,22 @@ BAR_ALPHA = 75
 MINO_SIZE = 20
 MINO_SPRITE_SIZE = 21
 
-if getattr(sys, "frozen", False):
+if getattr(sys, 'frozen', False):
     # The application is frozen
-    PROGRAM_DIR = os.path.dirname(sys.executable)
+    DATA_DIR = os.path.dirname(sys.executable)
 else:
     # The application is not frozen
-    PROGRAM_DIR = os.path.dirname(__file__)
-RESOURCES_DIR = os.path.join(PROGRAM_DIR, "resources")
+    # Change this bit to match where you store your data files:
+    DATA_DIR = os.path.dirname(__file__)
+DATA_DIR = os.path.join(DATA_DIR, "res")
 
 # Sprites
-IMAGES_DIR = os.path.join(RESOURCES_DIR, "images")
-WINDOW_BG_PATH = os.path.join(IMAGES_DIR, "bg.jpg")
-MATRIX_BG_PATH = os.path.join(IMAGES_DIR, "matrix.png")
-MINOES_SPRITES_PATH = os.path.join(IMAGES_DIR, "minoes.png")
-Color.LOCKED = 7
+WINDOW_BG_PATH = os.path.join(DATA_DIR, "bg.jpg")
+MATRIX_BG_PATH = os.path.join(DATA_DIR, "matrix.png")
+HELD_BG_PATH = os.path.join(DATA_DIR, "held.png")
+NEXT_BG_PATH = os.path.join(DATA_DIR, "next.png")
+MINOES_SPRITES_PATH = os.path.join(DATA_DIR, "minoes.png")
+Color.PRELOCKED = 7
 MINOES_COLOR_ID = {
     Color.BLUE: 0,
     Color.CYAN: 1,
@@ -96,82 +67,33 @@ MINOES_COLOR_ID = {
     Color.ORANGE: 4,
     Color.RED: 5,
     Color.YELLOW: 6,
-    Color.LOCKED: 7,
+    Color.PRELOCKED: 7,
 }
 TEXTURES = arcade.load_textures(
-    MINOES_SPRITES_PATH,
-    ((i * MINO_SPRITE_SIZE, 0, MINO_SPRITE_SIZE, MINO_SPRITE_SIZE) for i in range(8)),
+    MINOES_SPRITES_PATH, ((i * MINO_SPRITE_SIZE, 0, MINO_SPRITE_SIZE, MINO_SPRITE_SIZE) for i in range(8))
 )
 TEXTURES = {color: TEXTURES[i] for color, i in MINOES_COLOR_ID.items()}
 
-# Music
-MUSIC_DIR = os.path.join(RESOURCES_DIR, "musics")
-MUSICS_PATHS = (entry.path for entry in os.scandir(MUSIC_DIR))
+# User profile path
+if sys.platform == "win32":
+    USER_PROFILE_DIR = os.environ.get("appdata", os.path.expanduser("~\Appdata\Roaming"))
+else:
+    USER_PROFILE_DIR = os.environ.get("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 = os.path.join(RESOURCES_DIR, "fonts/joystix monospace.ttf")
+FONT_NAME = os.path.join(DATA_DIR, "joystix monospace.ttf")
 STATS_TEXT_MARGIN = 40
 STATS_TEXT_SIZE = 14
 STATS_TEXT_WIDTH = 150
 HIGHLIGHT_TEXT_COLOR = arcade.color.BUBBLES
 HIGHLIGHT_TEXT_SIZE = 20
 
-# User profile path
-if sys.platform == "win32":
-    USER_PROFILE_DIR = os.environ.get(
-        "appdata", os.path.expanduser("~\Appdata\Roaming")
-    )
-else:
-    USER_PROFILE_DIR = os.environ.get(
-        "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, "config.ini")
-
-
-class Texture:
-
-    NORMAL = 0
-    LOCKED = 1
-
-
-class State:
-
-    STARTING = 0
-    PLAYING = 1
-    PAUSED = 2
-    OVER = 3
-
-
-class Scheduler(AbstractScheduler):
-    def __init__(self):
-        self.tasks = {}
-
-    def postpone(self, task, delay):
-        _task = lambda _: task()
-        self.tasks[task] = _task
-        pyglet.clock.schedule_once(_task, delay)
-
-    def cancel(self, task):
-        try:
-            _task = self.tasks[task]
-        except KeyError:
-            pass
-        else:
-            arcade.unschedule(_task)
-            del self.tasks[task]
-
-    def reset(self, task, delay):
-        try:
-            _task = self.tasks[task]
-        except KeyError:
-            _task = lambda _: task()
-            self.tasks[task] = _task
-        else:
-            arcade.unschedule(_task)
-        pyglet.clock.schedule_once(_task, delay)
+# Music
+MUSIC_PATH = os.path.join(DATA_DIR, "Tetris - Song A.mp3")
 
 
 class MinoSprite(arcade.Sprite):
@@ -180,27 +102,22 @@ class MinoSprite(arcade.Sprite):
         self.alpha = alpha
         self.window = window
         self.append_texture(TEXTURES[mino.color])
-        self.append_texture(TEXTURES[Color.LOCKED])
+        self.append_texture(TEXTURES[Color.PRELOCKED])
         self.set_texture(0)
-        self.resize()
 
-    def resize(self):
+    def refresh(self, x, y, prelocked=False):
         self.scale = self.window.scale
-        self.size = MINO_SIZE * self.window.scale
-
-    def update(self, x, y):
-        self.left = self.window.matrix.bg.left + x * self.size
-        self.bottom = self.window.matrix.bg.bottom + y * self.size
-
-    def fall(self, lines_cleared):
-        self.bottom -= MINO_SIZE * self.window.scale * lines_cleared
+        size = MINO_SIZE * self.scale
+        self.left = self.window.matrix.bg.left + x * size
+        self.bottom = self.window.matrix.bg.bottom + y * size
+        self.set_texture(prelocked)
 
 
 class MinoesSprites(arcade.SpriteList):
-    def resize(self):
+    def resize(self, scale):
         for sprite in self:
-            sprite.resize()
-        self.update()
+            sprite.scale = scale
+        self.refresh()
 
 
 class TetrominoSprites(MinoesSprites):
@@ -208,48 +125,35 @@ class TetrominoSprites(MinoesSprites):
         super().__init__()
         self.tetromino = tetromino
         self.alpha = alpha
-        self.window = window
         for mino in tetromino:
             mino.sprite = MinoSprite(mino, window, alpha)
             self.append(mino.sprite)
 
-    def update(self):
+    def refresh(self):
         for mino in self.tetromino:
             coord = mino.coord + self.tetromino.coord
-            mino.sprite.update(coord.x, coord.y)
-
-    def set_texture(self, texture):
-        for mino in self.tetromino:
-            mino.sprite.set_texture(texture)
-            mino.sprite.scale = self.window.scale
+            mino.sprite.refresh(coord.x, coord.y, self.tetromino.prelocked)
 
 
 class MatrixSprites(MinoesSprites):
     def __init__(self, matrix):
         super().__init__()
         self.matrix = matrix
+        self.refresh()
 
-    def update(self):
+    def refresh(self):
         for y, line in enumerate(self.matrix):
             for x, mino in enumerate(line):
                 if mino:
-                    mino.sprite.update(x, y)
-
-    def remove_lines(self, lines_to_remove):
-        for y in lines_to_remove:
-            for mino in self.matrix[y]:
-                if mino:
-                    self.remove(mino.sprite)
+                    mino.sprite.refresh(x, y)
+                    self.append(mino.sprite)
 
 
 class TetrArcade(TetrisLogic, arcade.Window):
-    """Tetris clone with arcade GUI library"""
-
-    timer = Scheduler()
-
     def __init__(self):
         locale.setlocale(locale.LC_ALL, "")
         self.highlight_texts = []
+        self.tasks = {}
 
         self.conf = configparser.ConfigParser()
         if self.conf.read(CONF_PATH):
@@ -262,7 +166,7 @@ class TetrArcade(TetrisLogic, arcade.Window):
             self.new_conf()
             self.load_conf()
 
-        super().__init__(LINES, COLLUMNS, NEXT_PIECES)
+        super().__init__()
         arcade.Window.__init__(
             self,
             width=self.init_width,
@@ -278,31 +182,18 @@ class TetrArcade(TetrisLogic, arcade.Window):
         self.bg = arcade.Sprite(WINDOW_BG_PATH)
         self.matrix.bg = arcade.Sprite(MATRIX_BG_PATH)
         self.matrix.bg.alpha = MATRIX_BG_ALPHA
+        self.held.bg = arcade.Sprite(HELD_BG_PATH)
+        self.held.bg.alpha = BAR_ALPHA
+        self.next.bg = arcade.Sprite(NEXT_BG_PATH)
+        self.next.bg.alpha = BAR_ALPHA
         self.matrix.sprites = MatrixSprites(self.matrix)
         self.on_resize(self.init_width, self.init_height)
-        self.exploding_minoes = [None for y in range(LINES)]
-
         if self.play_music:
-            try:
-                self.music = pyglet.media.Player()
-                playlist = itertools.cycle(
-                    pyglet.media.load(path) for path in MUSICS_PATHS
-                )
-                self.music.queue(playlist)
-            except:
-                Warning("Can't play music.")
-                self.music = None
-        else:
-            self.music = None
-
-        self.state = State.STARTING
+            self.music = arcade.Sound(MUSIC_PATH)
+            self.music_player = None
 
     def new_conf(self):
-        self.conf["WINDOW"] = {
-            "width": WINDOW_WIDTH,
-            "height": WINDOW_HEIGHT,
-            "fullscreen": False,
-        }
+        self.conf["WINDOW"] = {"width": WINDOW_WIDTH, "height": WINDOW_HEIGHT, "fullscreen": False}
         self.conf["KEYBOARD"] = {
             "start": "ENTER",
             "move left": "LEFT",
@@ -315,7 +206,9 @@ class TetrArcade(TetrisLogic, arcade.Window):
             "pause": "ESCAPE",
             "fullscreen": "F11",
         }
-        self.conf["MUSIC"] = {"play": True}
+        self.conf["MUSIC"] = {
+            "play": True
+        }
         self.conf["AUTO-REPEAT"] = {"delay": 0.3, "period": 0.01}
         self.load_conf()
         if not os.path.exists(USER_PROFILE_DIR):
@@ -333,40 +226,26 @@ class TetrArcade(TetrisLogic, arcade.Window):
         self.key_map = {
             State.STARTING: {
                 getattr(arcade.key, self.conf["KEYBOARD"]["start"]): self.new_game,
-                getattr(
-                    arcade.key, self.conf["KEYBOARD"]["fullscreen"]
-                ): self.toggle_fullscreen,
+                getattr(arcade.key, self.conf["KEYBOARD"]["fullscreen"]): self.toggle_fullscreen,
             },
             State.PLAYING: {
                 getattr(arcade.key, self.conf["KEYBOARD"]["move left"]): self.move_left,
-                getattr(
-                    arcade.key, self.conf["KEYBOARD"]["move right"]
-                ): self.move_right,
+                getattr(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(
-                    arcade.key, self.conf["KEYBOARD"]["rotate clockwise"]
-                ): self.rotate_clockwise,
-                getattr(
-                    arcade.key, self.conf["KEYBOARD"]["rotate counter"]
-                ): self.rotate_counter,
-                getattr(arcade.key, self.conf["KEYBOARD"]["hold"]): self.hold,
+                getattr(arcade.key, self.conf["KEYBOARD"]["rotate clockwise"]): 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(
-                    arcade.key, self.conf["KEYBOARD"]["fullscreen"]
-                ): self.toggle_fullscreen,
+                getattr(arcade.key, self.conf["KEYBOARD"]["fullscreen"]): self.toggle_fullscreen,
             },
             State.PAUSED: {
                 getattr(arcade.key, self.conf["KEYBOARD"]["pause"]): self.resume,
-                getattr(
-                    arcade.key, self.conf["KEYBOARD"]["fullscreen"]
-                ): self.toggle_fullscreen,
+                getattr(arcade.key, self.conf["KEYBOARD"]["fullscreen"]): self.toggle_fullscreen,
             },
             State.OVER: {
                 getattr(arcade.key, self.conf["KEYBOARD"]["start"]): self.new_game,
-                getattr(
-                    arcade.key, self.conf["KEYBOARD"]["fullscreen"]
-                ): self.toggle_fullscreen,
+                getattr(arcade.key, self.conf["KEYBOARD"]["fullscreen"]): self.toggle_fullscreen,
             },
         }
 
@@ -377,21 +256,12 @@ class TetrArcade(TetrisLogic, arcade.Window):
             "\n\n\nCONTROLS\n\n"
             + "\n".join(
                 "{:<16s}{:>6s}".format(key, action)
-                for key, action in tuple(self.conf["KEYBOARD"].items())
-                + (("QUIT", "ALT+F4"),)
+                for key, action in tuple(self.conf["KEYBOARD"].items()) + (("QUIT", "ALT+F4"),)
             )
             + "\n\n\n"
         )
-        self.start_text = (
-            "TETRARCADE"
-            + 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.start_text = "TETRARCADE" + 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
 
@@ -404,158 +274,118 @@ AGAIN""".format(
 
         self.play_music = self.conf["MUSIC"].getboolean("play")
 
-    def on_new_game(self, matrix, next_pieces):
+    def new_game(self):
         self.highlight_texts = []
+        super().new_game()
+        if self.play_music:
+            if self.music_player:
+                self.music_player.seek(0)
+                self.music_player.play()
+            else:
+                self.music_player = self.music.player.play()
+                self.music_player.loop = True
 
-        self.matrix.sprites = MatrixSprites(matrix)
-        for piece in next_pieces:
-            piece.sprites = TetrominoSprites(piece, self)
+    def new_tetromino(self):
+        tetromino = super().new_tetromino()
+        tetromino.sprites = TetrominoSprites(tetromino, self)
+        return tetromino
 
-        if self.music:
-            self.music.seek(0)
-            self.music.play()
+    def new_matrix_piece(self):
+        self.matrix.sprites = MatrixSprites(self.matrix)
+        super().new_matrix_piece()
+        self.matrix.ghost.sprites = TetrominoSprites(self.matrix.ghost, self, GHOST_ALPHA)
+        for tetromino in [self.matrix.piece, self.matrix.ghost] + self.next.pieces:
+            tetromino.sprites.refresh()
 
-        self.state = State.PLAYING
+    def move(self, movement, prelock=True):
+        moved = super().move(movement, prelock)
+        self.matrix.piece.sprites.refresh()
+        if moved:
+            self.matrix.ghost.sprites.refresh()
+        return moved
 
-    def on_new_level(self, level):
-        self.show_text("LEVEL\n{:n}".format(level))
+    def rotate(self, rotation):
+        rotated = super().rotate(rotation)
+        if rotated:
+            for tetromino in (self.matrix.piece, self.matrix.ghost):
+                tetromino.sprites.refresh()
+        return rotated
 
-    def on_generation_phase(self, matrix, falling_piece, ghost_piece, next_pieces):
-        matrix.sprites.update()
-        falling_piece.sprites = TetrominoSprites(falling_piece, self)
-        ghost_piece.sprites = TetrominoSprites(ghost_piece, self, GHOST_ALPHA)
-        next_pieces[-1].sprites = TetrominoSprites(next_pieces[-1], self)
-        for piece, coord in zip(next_pieces, NEXT_PIECES_COORDS):
-            piece.coord = coord
-        for piece in [falling_piece, ghost_piece] + next_pieces:
-            piece.sprites.update()
+    def swap(self):
+        super().swap()
+        self.matrix.ghost.sprites = TetrominoSprites(self.matrix.ghost, self, GHOST_ALPHA)
+        for tetromino in (self.held.piece, self.matrix.piece, self.matrix.ghost):
+            if tetromino:
+                tetromino.sprites.refresh()
 
-    def on_falling_phase(self, falling_piece, ghost_piece):
-        falling_piece.sprites.set_texture(Texture.NORMAL)
-        falling_piece.sprites.update()
-        ghost_piece.sprites.update()
+    def lock(self):
+        self.matrix.piece.prelocked = False
+        self.matrix.piece.sprites.refresh()
+        super().lock()
 
-    def on_locked(self, falling_piece, ghost_piece):
-        falling_piece.sprites.set_texture(Texture.LOCKED)
-        falling_piece.sprites.update()
-        ghost_piece.sprites.update()
-
-    def on_locks_down(self, matrix, falling_piece):
-        falling_piece.sprites.set_texture(Texture.NORMAL)
-        for mino in falling_piece:
-            matrix.sprites.append(mino.sprite)
-
-    def on_animate_phase(self, matrix, lines_to_remove):
-        if not lines_to_remove:
-            return
-
-        self.timer.cancel(self.clean_particules)
-        for y in lines_to_remove:
-            line_textures = tuple(TEXTURES[mino.color] for mino in matrix[y])
-            self.exploding_minoes[y] = arcade.Emitter(
-                center_xy=(matrix.bg.left, matrix.bg.bottom + (y + 0.5) * MINO_SIZE),
-                emit_controller=arcade.EmitBurst(COLLUMNS),
-                particle_factory=lambda emitter: arcade.LifetimeParticle(
-                    filename_or_texture=random.choice(line_textures),
-                    change_xy=arcade.rand_in_rect(
-                        (-COLLUMNS * MINO_SIZE, -4 * MINO_SIZE),
-                        2 * COLLUMNS * MINO_SIZE,
-                        5 * MINO_SIZE,
-                    ),
-                    lifetime=EXPLOSION_ANIMATION,
-                    center_xy=arcade.rand_on_line((0, 0), (matrix.bg.width, 0)),
-                    scale=self.scale,
-                    alpha=NORMAL_ALPHA,
-                    change_angle=2,
-                ),
-            )
-        self.timer.postpone(self.clean_particules, EXPLOSION_ANIMATION)
-
-    def clean_particules(self):
-        self.exploding_minoes = [None for y in range(LINES)]
-
-    def on_eliminate_phase(self, matrix, lines_to_remove):
-        matrix.sprites.remove_lines(lines_to_remove)
-
-    def on_completion_phase(self, pattern_name, pattern_score, nb_combo, combo_score):
-        if pattern_score:
-            self.show_text("{:s}\n{:n}".format(pattern_name, pattern_score))
-        if combo_score:
-            self.show_text("COMBO x{:n}\n{:n}".format(nb_combo, combo_score))
-
-    def on_hold(self, held_piece):
-        held_piece.coord = HELD_PIECE_COORD
-        if type(held_piece) == I_Tetrimino:
-            held_piece.coord += Movement.LEFT
-        held_piece.sprites.set_texture(Texture.NORMAL)
-        held_piece.sprites.update()
-
-    def on_pause(self):
-        self.state = State.PAUSED
-        if self.music:
-            self.music.pause()
+    def pause(self):
+        super().pause()
+        if self.play_music:
+            self.music_player.pause()
 
     def resume(self):
-        if self.music:
-            self.music.play()
-        self.state = State.PLAYING
+        super().resume()
+        if self.play_music:
+            self.music_player.play()
 
-    def on_game_over(self):
-        self.state = State.OVER
-        if self.music:
-            self.music.pause()
+    def game_over(self):
+        super().game_over()
+        if self.play_music:
+            self.music_player.pause()
 
     def on_key_press(self, key, modifiers):
+        for key_or_modifier in (key, modifiers):
             try:
-            action = self.key_map[self.state][key]
+                action = self.key_map[self.state][key_or_modifier]
             except KeyError:
-            return
+                pass
             else:
                 self.do_action(action)
 
     def on_key_release(self, key, modifiers):
+        for key_or_modifier in (key, modifiers):
             try:
-            action = self.key_map[self.state][key]
+                action = self.key_map[self.state][key_or_modifier]
             except KeyError:
-            return
+                pass
             else:
                 self.remove_action(action)
 
     def show_text(self, text):
         self.highlight_texts.append(text)
-        self.timer.postpone(self.del_highlight_text, HIGHLIGHT_TEXT_DISPLAY_DELAY)
+        self.restart(self.del_highlight_text, HIGHLIGHT_TEXT_DISPLAY_DELAY)
 
     def del_highlight_text(self):
         if self.highlight_texts:
             self.highlight_texts.pop(0)
         else:
-            self.timer.cancel(self.del_highlight_text)
+            self.stop(self.del_highlight_text)
 
     def on_draw(self):
         arcade.start_render()
         self.bg.draw()
 
-        if self.state not in (State.STARTING, State.PAUSED):
+        if self.state in (State.PLAYING, State.OVER):
             self.matrix.bg.draw()
+            self.held.bg.draw()
+            self.next.bg.draw()
             self.matrix.sprites.draw()
 
-            for tetromino in [
-                self.held.piece,
-                self.matrix.piece,
-                self.matrix.ghost,
-            ] + self.next.pieces:
+            for tetromino in [self.held.piece, self.matrix.piece, self.matrix.ghost] + self.next.pieces:
                 if tetromino:
                     tetromino.sprites.draw()
 
-            t = time.localtime(self.stats.time)
+            t = time.localtime(self.time)
             font_size = STATS_TEXT_SIZE * self.scale
-            for y, text in enumerate(
-                ("TIME", "LINES", "GOAL", "LEVEL", "HIGH SCORE", "SCORE")
-            ):
+            for y, text in enumerate(("TIME", "LINES", "GOAL", "LEVEL", "HIGH SCORE", "SCORE")):
                 arcade.draw_text(
                     text=text,
-                    start_x=self.matrix.bg.left
-                    - self.scale * (STATS_TEXT_MARGIN + STATS_TEXT_WIDTH),
+                    start_x=self.matrix.bg.left - self.scale * (STATS_TEXT_MARGIN + STATS_TEXT_WIDTH),
                     start_y=self.matrix.bg.bottom + 1.5 * (2 * y + 1) * font_size,
                     color=TEXT_COLOR,
                     font_size=font_size,
@@ -566,11 +396,11 @@ AGAIN""".format(
             for y, text in enumerate(
                 (
                     "{:02d}:{:02d}:{:02d}".format(t.tm_hour - 1, t.tm_min, t.tm_sec),
-                    "{:n}".format(self.stats.lines_cleared),
-                    "{:n}".format(self.stats.goal),
-                    "{:n}".format(self.stats.level),
-                    "{:n}".format(self.stats.high_score),
-                    "{:n}".format(self.stats.score),
+                    "{:n}".format(self.nb_lines_cleared),
+                    "{:n}".format(self.goal),
+                    "{:n}".format(self.level),
+                    "{:n}".format(self.high_score),
+                    "{:n}".format(self.score),
                 )
             ):
                 arcade.draw_text(
@@ -584,10 +414,6 @@ AGAIN""".format(
                     anchor_x="right",
                 )
 
-        for exploding_minoes in self.exploding_minoes:
-            if exploding_minoes:
-                exploding_minoes.draw()
-
         highlight_text = {
             State.STARTING: self.start_text,
             State.PLAYING: self.highlight_texts[0] if self.highlight_texts else "",
@@ -629,15 +455,19 @@ AGAIN""".format(
         self.matrix.bg.left = int(self.matrix.bg.left)
         self.matrix.bg.top = int(self.matrix.bg.top)
 
-        self.matrix.sprites.resize()
+        self.held.bg.scale = self.scale
+        self.held.bg.right = self.matrix.bg.left
+        self.held.bg.top = self.matrix.bg.top
 
-        for tetromino in [
-            self.held.piece,
-            self.matrix.piece,
-            self.matrix.ghost,
-        ] + self.next.pieces:
+        self.next.bg.scale = self.scale
+        self.next.bg.left = self.matrix.bg.right
+        self.next.bg.top = self.matrix.bg.top
+
+        self.matrix.sprites.resize(self.scale)
+
+        for tetromino in [self.held.piece, self.matrix.piece, self.matrix.ghost] + self.next.pieces:
             if tetromino:
-                tetromino.sprites.resize()
+                tetromino.sprites.resize(self.scale)
 
     def load_high_score(self):
         try:
@@ -645,7 +475,7 @@ AGAIN""".format(
                 crypted_high_score = f.read()
                 super().load_high_score(crypted_high_score)
         except:
-            self.stats.high_score = 0
+            self.high_score = 0
 
     def save_high_score(self):
         try:
@@ -664,15 +494,34 @@ High score could not be saved:
                 + str(e)
             )
 
-    def update(self, delta_time):
-        for exploding_minoes in self.exploding_minoes:
-            if exploding_minoes:
-                exploding_minoes.update()
+    def start(self, task, period):
+        _task = lambda _: task()
+        self.tasks[task] = _task
+        arcade.schedule(_task, period)
+
+    def stop(self, task):
+        try:
+            _task = self.tasks[task]
+        except KeyError:
+            pass
+        else:
+            arcade.unschedule(_task)
+            del self.tasks[task]
+
+    def restart(self, task, period):
+        try:
+            _task = self.tasks[task]
+        except KeyError:
+            _task = lambda _: task()
+            self.tasks[task] = _task
+        else:
+            arcade.unschedule(_task)
+        arcade.schedule(_task, period)
 
     def on_close(self):
         self.save_high_score()
-        if self.music:
-            self.music.pause()
+        if self.play_music:
+            self.music_player.pause()
         super().on_close()
 
 

build-requirements.txt

@@ -1,2 +1 @@
-arcade
-cx-freeze
+arcade cx-freeze

setup.py

@@ -9,29 +9,35 @@ else:
     base = None
     icon = None
 
-excludes = ["tkinter", "PyQt4", "PyQt5", "PySide", "PySide2"]
+excludes = [
+    "tkinter",
+    "PyQt4",
+    "PyQt5",
+    "PySide",
+    "PySide2"
+]
 
 executable = Executable(
-    script="TetrArcade.py",
-    icon=icon,
-    base=base,
+    script = "TetrArcade.py",
+    icon = icon,
+    base = base,
     shortcutName="TetrArcade",
-    shortcutDir="DesktopFolder",
+    shortcutDir="DesktopFolder"
 )
 
 options = {
     "build_exe": {
         "packages": ["arcade", "pyglet"],
         "excludes": excludes,
-        "include_files": "resources",
-        "silent": True,
+        "include_files": "res",
+        "silent": True
     }
 }
 setup(
-    name="TetrArcade",
-    version="0.6",
-    description="Tetris clone",
-    author="AdrienMalin",
-    executables=[executable],
-    options=options,
+    name = "TetrArcade",
+    version = "0.2",
+    description = "Tetris clone",
+    author = "AdrienMalin",
+    executables = [executable],
+    options = options,
 )

test.py

@@ -1,34 +1,16 @@
 # -*- coding: utf-8 -*-
 
-from TetrArcade import TetrArcade, MinoSprite, State
-from tetrislogic import Mino, Color, Coord
+from TetrArcade import TetrArcade, State
 
 game = TetrArcade()
 game.new_game()
-for x in range(game.matrix.collumns):
-    mino = Mino(Color.ORANGE, Coord(x, 0))
-    mino.sprite = MinoSprite(mino, game, 200)
-    game.matrix[0][x] = mino
-    game.matrix.sprites.append(mino.sprite)
 game.move_left()
-game.pause()
-game.resume()
 game.move_right()
-game.hold()
-game.update(0)
-game.on_draw()
+game.swap()
 game.rotate_clockwise()
-game.hold()
-game.update(0)
-game.on_draw()
 game.rotate_counter()
-for i in range(22):
+for i in range(12):
     game.soft_drop()
-    game.on_draw()
-game.lock_phase()
-game.hold()
-game.update(0)
 game.on_draw()
 while game.state != State.OVER:
     game.hard_drop()
-game.on_draw()

tetrislogic/__init__.py

@@ -1,15 +1,5 @@
 # -*- coding: utf-8 -*-
-from .consts import LINES, COLLUMNS, NEXT_PIECES
-from .utils import Movement, Spin, Color, Coord
-from .tetromino import (
-    Mino,
-    Tetromino,
-    I_Tetrimino,
-    J_Tetrimino,
-    L_Tetrimino,
-    O_Tetrimino,
-    S_Tetrimino,
-    T_Tetrimino,
-    Z_Tetrimino,
-)
-from .tetrislogic import TetrisLogic, Matrix, AbstractScheduler
+from .consts import NB_LINES, NB_COLS, NB_NEXT
+from .utils import Movement, Rotation, Color
+from .tetromino import Mino, Tetromino
+from .tetrislogic import TetrisLogic, State, Matrix

tetrislogic/consts.py

@@ -1,27 +1,20 @@
 # -*- coding: utf-8 -*-
-from .utils import Coord, T_Spin
+from .utils import Coord
 
 
 # Matrix
-LINES = 20
-COLLUMNS = 10
-NEXT_PIECES = 5
+NB_LINES = 20
+NB_COLS = 10
+NB_NEXT = 5
 
 # Delays (seconds)
 LOCK_DELAY = 0.5
 FALL_DELAY = 1
-AUTOREPEAT_DELAY = 0.300  # Official : 0.300 s
-AUTOREPEAT_PERIOD = 0.010  # Official : 0.010 s
+AUTOREPEAT_DELAY = 0.200  # Official : 0.300
+AUTOREPEAT_PERIOD = 0.010  # Official : 0.010
+
 
 # Piece init coord
-FALLING_PIECE_COORD = Coord(4, LINES)
-
-# Scores
-LINES_CLEAR_NAME = "LINES_CLEAR_NAME"
-SCORES = (
-    {LINES_CLEAR_NAME: "", T_Spin.NONE: 0, T_Spin.MINI: 1, T_Spin.T_SPIN: 4},
-    {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},
-)
+CURRENT_COORD = Coord(4, NB_LINES)
+NEXT_COORDS = [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

@@ -1,138 +1,129 @@
 # -*- coding: utf-8 -*-
-"""Tetris game logic meant to be implemented with GUI
-Follows Tetris Guidelines 2009 (see https://tetris.fandom.com/wiki/Tetris_Guideline)
-"""
-
-
+import random
 import pickle
 
-from .utils import Coord, Movement, Spin, T_Spin, T_Slot
-from .tetromino import Tetromino, T_Tetrimino
+from .utils import Coord, Movement, Rotation, T_Spin
+from .tetromino import Tetromino, T_Tetrimino, I_Tetrimino
 from .consts import (
-    LINES,
-    COLLUMNS,
-    NEXT_PIECES,
+    NB_LINES,
+    NB_COLS,
+    NB_NEXT,
     LOCK_DELAY,
     FALL_DELAY,
     AUTOREPEAT_DELAY,
     AUTOREPEAT_PERIOD,
-    FALLING_PIECE_COORD,
-    SCORES,
-    LINES_CLEAR_NAME,
+    CURRENT_COORD,
+    NEXT_COORDS,
+    HELD_COORD,
 )
 
 
+LINES_CLEAR_NAME = "LINES_CLEAR_NAME"
 CRYPT_KEY = 987943759387540938469837689379857347598347598379584857934579343
 
 
-class AbstractScheduler:
-    """Scheduler class to be implemented"""
+class State:
 
-    def postpone(task, delay):
-        """schedule callable task once after delay in second"""
-        raise Warning("AbstractScheduler.postpone is not implemented.")
-
-    def cancel(self, task):
-        """cancel task if schedule of pass"""
-        raise Warning("AbstractScheduler.stop is not implemented.")
-
-    def reset(self, task, delay):
-        """cancel and reschedule task"""
-        self.timer.cancel(task)
-        self.timer.postpone(task, delay)
+    STARTING = "STARTING"
+    PLAYING = "PLAYING"
+    PAUSED = "PAUSED"
+    OVER = "OVER"
 
 
-class AbstractPieceContainer:
+class PieceContainer:
+
     def __init__(self):
         self.piece = None
 
 
-class HoldQueue(AbstractPieceContainer):
-    """the storage place where players can Hold any falling Tetrimino for use later"""
-
+class HoldQueue(PieceContainer):
     pass
 
 
-class Matrix(list, AbstractPieceContainer):
-    """the rectangular arrangement of cells creating the active game area, usually 10 columns wide by 20 rows high."""
+class Matrix(list, PieceContainer):
 
-    def __init__(self, lines, collumns):
-        list.__init__(self)
-        AbstractPieceContainer.__init__(self)
-        self.lines = lines
-        self.collumns = collumns
-        self.ghost = None
-
-    def new_game(self):
-        """Removes all minoes in matrix"""
-        self.clear()
-        for y in range(self.lines + 3):
-            self.append_new_line()
-
-    def append_new_line(self):
-        self.append([None for x in range(self.collumns)])
+    def __init__(self, *args, **kargs):
+        list.__init__(self, *args, **kargs)
+        PieceContainer.__init__(self)
 
     def cell_is_free(self, coord):
-        return (
-            0 <= coord.x < self.collumns and 0 <= coord.y and not self[coord.y][coord.x]
-        )
-
-    def space_to_move(self, potential_coord, minoes_coord):
-        return all(
-            self.cell_is_free(potential_coord + mino_coord)
-            for mino_coord in minoes_coord
-        )
-
-    def space_to_fall(self):
-        return self.space_to_move(
-            self.piece.coord + Movement.DOWN, (mino.coord for mino in self.piece)
-        )
+        return 0 <= coord.x < NB_COLS and 0 <= coord.y and not self[coord.y][coord.x]
 
 
-class NextQueue(AbstractPieceContainer):
-    """Displays the Next Tetrimino(s) to be placed (generated) just above the Matrix"""
+class NextQueue(PieceContainer):
 
-    def __init__(self, nb_pieces):
+    def __init__(self):
         super().__init__()
-        self.nb_pieces = nb_pieces
         self.pieces = []
 
-    def new_game(self):
-        self.pieces = [Tetromino() for n in range(self.nb_pieces)]
 
-    def generation_phase(self):
-        self.pieces.append(Tetromino())
-        return self.pieces.pop(0)
+class TetrisLogic:
 
+    NB_LINES = NB_LINES
+    NB_COLS = NB_COLS
+    NB_NEXT = NB_NEXT
+    LOCK_DELAY = LOCK_DELAY
+    FALL_DELAY = FALL_DELAY
+    AUTOREPEAT_DELAY = AUTOREPEAT_DELAY
+    AUTOREPEAT_PERIOD = AUTOREPEAT_PERIOD
+    CURRENT_COORD = CURRENT_COORD
+    NEXT_COORDS = NEXT_COORDS
+    HELD_COORD = HELD_COORD
+    random_bag = []
 
-class Stats:
-    """Game statistics"""
+    def __init__(self):
+        self.load_high_score()
+        self.state = State.STARTING
+        self.held = HoldQueue()
+        self.matrix = Matrix()
+        self.matrix.ghost = None
+        self.next = NextQueue()
+        self.time = 0
+        self.autorepeatable_actions = (self.move_left, self.move_right, self.soft_drop)
+        self.pressed_actions = []
+        self._score = 0
 
-    def _get_score(self):
+    def get_score(self):
         return self._score
 
-    def _set_score(self, new_score):
+    def set_score(self, new_score):
         self._score = new_score
         if self._score > self.high_score:
             self.high_score = self._score
 
-    score = property(_get_score, _set_score)
+    score = property(get_score, set_score)
 
-    def __init__(self):
-        self._score = 0
-        self.high_score = 0
-        self.time = 0
-
-    def new_game(self, level):
-        self.level = level - 1
+    def new_game(self):
+        self.level = 0
         self.score = 0
-        self.lines_cleared = 0
+        self.nb_lines_cleared = 0
         self.goal = 0
         self.time = 0
-        self.combo = -1
 
-        self.lock_delay = LOCK_DELAY
-        self.fall_delay = FALL_DELAY
+        self.pressed_actions = []
+        self.auto_repeat = False
+
+        self.lock_delay = self.LOCK_DELAY
+        self.fall_delay = self.FALL_DELAY
+
+        self.matrix.clear()
+        for y in range(self.NB_LINES + 3):
+            self.append_new_line_to_matrix()
+        self.next.pieces = [self.new_tetromino() for n in range(self.NB_NEXT)]
+        self.held.piece = None
+        self.state = State.PLAYING
+        self.start(self.update_time, 1)
+
+        self.new_level()
+
+    def new_tetromino(self):
+        if not self.random_bag:
+            self.random_bag = list(Tetromino.shapes)
+            random.shuffle(self.random_bag)
+        return self.random_bag.pop()()
+
+    def append_new_line_to_matrix(self):
+        self.matrix.append([None for x in range(self.NB_COLS)])
 
     def new_level(self):
         self.level += 1
@@ -141,254 +132,23 @@ class Stats:
             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.show_text("LEVEL\n{:n}".format(self.level))
+        self.restart(self.fall, self.fall_delay)
+        self.new_matrix_piece()
 
-    def update_time(self):
-        self.time += 1
-
-    def locks_down(self, t_spin, lines_cleared):
-        pattern_name = []
-        pattern_score = 0
-        combo_score = 0
-
-        if t_spin:
-            pattern_name.append(t_spin)
-        if lines_cleared:
-            pattern_name.append(SCORES[lines_cleared][LINES_CLEAR_NAME])
-            self.combo += 1
-        else:
-            self.combo = -1
-
-        if lines_cleared or t_spin:
-            pattern_score = SCORES[lines_cleared][t_spin]
-            self.goal -= pattern_score
-            pattern_score *= 100 * self.level
-            pattern_name = "\n".join(pattern_name)
-
-        if self.combo >= 1:
-            combo_score = (20 if lines_cleared == 1 else 50) * self.combo * self.level
-
-        self.score += pattern_score + combo_score
-
-        return pattern_name, pattern_score, self.combo, combo_score
-
-
-class TetrisLogic:
-    """Tetris game logic"""
-
-    # These class attributes can be redefined on inheritance
-    AUTOREPEAT_DELAY = AUTOREPEAT_DELAY
-    AUTOREPEAT_PERIOD = AUTOREPEAT_PERIOD
-    FALLING_PIECE_COORD = FALLING_PIECE_COORD
-
-    timer = AbstractScheduler()
-
-    def __init__(self, lines=LINES, collumns=COLLUMNS, nb_next_pieces=NEXT_PIECES):
-        """init game with a `lines`x`collumns` size matrix
-        and `nb_next_pieces`"""
-        self.stats = Stats()
-        self.load_high_score()
-        self.held = HoldQueue()
-        self.matrix = Matrix(lines, collumns)
-        self.next = NextQueue(nb_next_pieces)
-        self.autorepeatable_actions = (self.move_left, self.move_right, self.soft_drop)
-        self.pressed_actions = []
-
-    def new_game(self, level=1):
-        """start a new game at `level`"""
-        self.stats.new_game(level)
-
-        self.pressed_actions = []
-
-        self.matrix.new_game()
-        self.next.new_game()
-        self.held.piece = None
-        self.timer.postpone(self.stats.update_time, 1)
-
-        self.on_new_game(self.matrix, self.next.pieces)
-        self.new_level()
-
-    def on_new_game(self, matrix, next_pieces):
-        pass
-
-    def new_level(self):
-        self.stats.new_level()
-        self.on_new_level(self.stats.level)
-        self.generation_phase()
-
-    def on_new_level(self, level):
-        pass
-
-    # Tetris Engine
-
-    def generation_phase(self, held_piece=None):
-        if not held_piece:
-            self.matrix.piece = self.next.generation_phase()
-        self.matrix.piece.coord = self.FALLING_PIECE_COORD
+    def new_matrix_piece(self):
+        self.matrix.piece = self.next.pieces.pop(0)
+        self.matrix.piece.coord = self.CURRENT_COORD
         self.matrix.ghost = self.matrix.piece.ghost()
-        self.refresh_ghost()
+        self.move_ghost()
+        self.next.pieces.append(self.new_tetromino())
+        self.next.pieces[-1].coord = self.NEXT_COORDS[-1]
+        for tetromino, coord in zip(self.next.pieces, self.NEXT_COORDS):
+            tetromino.coord = coord
 
-        self.on_generation_phase(
-            self.matrix, self.matrix.piece, self.matrix.ghost, self.next.pieces
-        )
-        if self.matrix.space_to_move(
-            self.matrix.piece.coord, (mino.coord for mino in self.matrix.piece)
-        ):
-            self.falling_phase()
-        else:
+        if not self.can_move(self.matrix.piece.coord, (mino.coord for mino in self.matrix.piece)):
             self.game_over()
 
-    def refresh_ghost(self):
-        self.matrix.ghost.coord = self.matrix.piece.coord
-        for ghost_mino, current_mino in zip(self.matrix.ghost, self.matrix.piece):
-            ghost_mino.coord = current_mino.coord
-        while self.matrix.space_to_move(
-            self.matrix.ghost.coord + Movement.DOWN,
-            (mino.coord for mino in self.matrix.ghost),
-        ):
-            self.matrix.ghost.coord += Movement.DOWN
-
-    def on_generation_phase(self, matrix, falling_piece, ghost_piece, next_pieces):
-        pass
-
-    def falling_phase(self):
-        self.timer.cancel(self.lock_phase)
-        self.timer.cancel(self.locks_down)
-        self.matrix.piece.locked = False
-        self.timer.postpone(self.lock_phase, self.stats.fall_delay)
-        self.on_falling_phase(self.matrix.piece, self.matrix.ghost)
-
-    def on_falling_phase(self, falling_piece, ghost_piece):
-        pass
-
-    def lock_phase(self):
-        self.move(Movement.DOWN)
-
-    def move(self, movement, rotated_coords=None, lock=True):
-        potential_coord = self.matrix.piece.coord + movement
-        potential_minoes_coords = rotated_coords or (
-            mino.coord for mino in self.matrix.piece
-        )
-        if self.matrix.space_to_move(potential_coord, potential_minoes_coords):
-            self.matrix.piece.coord = potential_coord
-            if rotated_coords:
-                for mino, coord in zip(self.matrix.piece, rotated_coords):
-                    mino.coord = coord
-            self.refresh_ghost()
-            if movement != Movement.DOWN:
-                self.matrix.piece.rotated_last = False
-            if self.matrix.space_to_fall():
-                self.falling_phase()
-            else:
-                self.matrix.piece.locked = True
-                self.on_locked(self.matrix.piece, self.matrix.ghost)
-                self.timer.reset(self.locks_down, self.stats.lock_delay)
-            return True
-        else:
-            return False
-
-    def on_locked(self, falling_piece, ghost_piece):
-        pass
-
-    def rotate(self, spin):
-        rotated_coords = tuple(mino.coord @ spin for mino in self.matrix.piece)
-        for rotation_point, liberty_degree in enumerate(
-            self.matrix.piece.SRS[spin][self.matrix.piece.orientation], start=1
-        ):
-            if self.move(liberty_degree, rotated_coords, lock=False):
-                self.matrix.piece.orientation = (
-                    self.matrix.piece.orientation + spin
-                ) % 4
-                self.matrix.piece.rotated_last = True
-                if rotation_point == 5:
-                    self.matrix.piece.rotation_point_5_used = True
-                return True
-        else:
-            return False
-
-    def locks_down(self):
-        self.timer.cancel(self.lock_phase)
-
-        # Game over
-        if all(
-            (mino.coord + self.matrix.piece.coord).y >= self.matrix.lines
-            for mino in self.matrix.piece
-        ):
-            self.game_over()
-            return
-
-        for mino in self.matrix.piece:
-            coord = mino.coord + self.matrix.piece.coord
-            if coord.y <= self.matrix.lines + 3:
-                self.matrix[coord.y][coord.x] = mino
-
-        self.on_locks_down(self.matrix, self.matrix.piece)
-
-        # Pattern phase
-
-        # T-Spin
-        if type(self.matrix.piece) == T_Tetrimino and self.matrix.piece.rotated_last:
-            a = self.is_t_slot(T_Slot.A)
-            b = self.is_t_slot(T_Slot.B)
-            c = self.is_t_slot(T_Slot.C)
-            d = self.is_t_slot(T_Slot.D)
-            if a and b and (c or d):
-                t_spin = T_Spin.T_SPIN
-            elif c and d and (a or b):
-                if self.matrix.piece.rotation_point_5_used:
-                    t_spin = T_Spin.T_SPIN
-                else:
-                    t_spin = T_Spin.MINI
-            else:
-                t_spin = T_Spin.NONE
-        else:
-            t_spin = T_Spin.NONE
-
-        # Complete lines
-        lines_to_remove = []
-        for y, line in reversed(list(enumerate(self.matrix))):
-            if all(mino for mino in line):
-                lines_to_remove.append(y)
-
-        lines_cleared = len(lines_to_remove)
-        if lines_cleared:
-            self.stats.lines_cleared += lines_cleared
-
-            # Animate phase
-
-            self.on_animate_phase(self.matrix, lines_to_remove)
-
-            # Eliminate phase
-            self.on_eliminate_phase(self.matrix, lines_to_remove)
-            for y in lines_to_remove:
-                self.matrix.pop(y)
-                self.matrix.append_new_line()
-
-        # Completion phase
-
-        pattern_name, pattern_score, nb_combo, combo_score = self.stats.locks_down(
-            t_spin, lines_cleared
-        )
-        self.on_completion_phase(pattern_name, pattern_score, nb_combo, combo_score)
-
-        if self.stats.goal <= 0:
-            self.new_level()
-        else:
-            self.generation_phase()
-
-    def on_locks_down(self, matrix, falling_piece):
-        pass
-
-    def on_animate_phase(self, matrix, lines_to_remove):
-        pass
-
-    def on_eliminate_phase(self, matrix, lines_to_remove):
-        pass
-
-    def on_completion_phase(self, pattern_name, pattern_score, nb_combo, combo_score):
-        pass
-
-    # Actions
-
     def move_left(self):
         self.move(Movement.LEFT)
 
@@ -396,98 +156,228 @@ class TetrisLogic:
         self.move(Movement.RIGHT)
 
     def rotate_clockwise(self):
-        self.rotate(Spin.CLOCKWISE)
+        self.rotate(Rotation.CLOCKWISE)
 
     def rotate_counter(self):
-        self.rotate(Spin.COUNTER)
+        self.rotate(Rotation.COUNTER)
+
+    def move_ghost(self):
+        self.matrix.ghost.coord = self.matrix.piece.coord
+        for ghost_mino, current_mino in zip(self.matrix.ghost, self.matrix.piece):
+            ghost_mino.coord = current_mino.coord
+        while self.can_move(self.matrix.ghost.coord + Movement.DOWN, (mino.coord for mino in self.matrix.ghost)):
+            self.matrix.ghost.coord += Movement.DOWN
 
     def soft_drop(self):
         moved = self.move(Movement.DOWN)
         if moved:
-            self.stats.score += 1
+            self.score += 1
         return moved
 
     def hard_drop(self):
-        self.timer.cancel(self.lock_phase)
-        self.timer.cancel(self.locks_down)
-        while self.move(Movement.DOWN, lock=False):
-            self.stats.score += 2
-        self.locks_down()
+        while self.move(Movement.DOWN, prelock=False):
+            self.score += 2
+        self.lock()
 
-    def hold(self):
-        if not self.matrix.piece.hold_enabled:
+    def fall(self):
+        self.move(Movement.DOWN)
+
+    def move(self, movement, prelock=True):
+        potential_coord = self.matrix.piece.coord + movement
+        if self.can_move(potential_coord, (mino.coord for mino in self.matrix.piece)):
+            if self.matrix.piece.prelocked:
+                self.restart(self.lock, self.lock_delay)
+            self.matrix.piece.coord = potential_coord
+            if not movement == Movement.DOWN:
+                self.matrix.piece.last_rotation_point = None
+            self.move_ghost()
+            return True
+        else:
+            if prelock and not self.matrix.piece.prelocked and movement == Movement.DOWN:
+                self.matrix.piece.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) for mino in self.matrix.piece)
+        for rotation_point, liberty_degree in enumerate(self.matrix.piece.SRS[rotation][self.matrix.piece.orientation], start=1):
+            potential_coord = self.matrix.piece.coord + liberty_degree
+            if self.can_move(potential_coord, rotated_coords):
+                if self.matrix.piece.prelocked:
+                    self.restart(self.lock, self.lock_delay)
+                self.matrix.piece.coord = potential_coord
+                for mino, coord in zip(self.matrix.piece, rotated_coords):
+                    mino.coord = coord
+                self.matrix.piece.orientation = (self.matrix.piece.orientation + rotation) % 4
+                self.matrix.piece.last_rotation_point = rotation_point
+                self.move_ghost()
+                return True
+        else:
+            return False
+
+    SCORES = (
+        {LINES_CLEAR_NAME: "", T_Spin.NONE: 0, T_Spin.MINI: 1, T_Spin.T_SPIN: 4},
+        {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},
+    )
+
+    def lock(self):
+        self.matrix.piece.prelocked = False
+        self.stop(self.lock)
+
+        # Piece unlocked
+        if self.can_move(self.matrix.piece.coord + Movement.DOWN, (mino.coord for mino in self.matrix.piece)):
             return
 
-        self.matrix.piece.hold_enabled = False
-        self.timer.cancel(self.lock_phase)
-        self.matrix.piece, self.held.piece = self.held.piece, self.matrix.piece
+        # Game over
+        if all((mino.coord + self.matrix.piece.coord).y >= self.NB_LINES for mino in self.matrix.piece):
+            self.game_over()
+            return
 
-        for mino, coord in zip(self.held.piece, self.held.piece.MINOES_COORDS):
-            mino.coord = coord
+        if self.pressed_actions:
+            self.auto_repeat = False
+            self.restart(self.repeat_action, self.AUTOREPEAT_DELAY)
 
-        self.on_hold(self.held.piece)
-        self.generation_phase(self.matrix.piece)
+        # T-Spin
+        if type(self.matrix.piece) == T_Tetrimino and self.matrix.piece.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.matrix.piece.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
+            else:
+                t_spin = T_Spin.NONE
+        else:
+            t_spin = T_Spin.NONE
 
-    def on_hold(self, held_piece):
-        pass
+        for mino in self.matrix.piece:
+            coord = mino.coord + self.matrix.piece.coord
+            del mino.coord
+            if coord.y <= self.NB_LINES + 3:
+                self.matrix[coord.y][coord.x] = mino
+
+        # Clear complete lines
+        nb_lines_cleared = 0
+        for y, line in reversed(list(enumerate(self.matrix))):
+            if all(mino for mino in line):
+                nb_lines_cleared += 1
+                self.matrix.pop(y)
+                self.append_new_line_to_matrix()
+        if nb_lines_cleared:
+            self.nb_lines_cleared += nb_lines_cleared
+
+        # Scoring
+        lock_strings = []
+        lock_score = 0
+
+        if t_spin:
+            lock_strings.append(t_spin)
+        if nb_lines_cleared:
+            lock_strings.append(self.SCORES[nb_lines_cleared][LINES_CLEAR_NAME])
+            self.combo += 1
+        else:
+            self.combo = -1
+
+        if nb_lines_cleared or t_spin:
+            ds = self.SCORES[nb_lines_cleared][t_spin]
+            self.goal -= ds
+            ds *= 100 * self.level
+            lock_score += ds
+            lock_strings.append(str(ds))
+            self.show_text("\n".join(lock_strings))
+
+        if self.combo >= 1:
+            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))
+
+        self.score += lock_score
+
+        if self.goal <= 0:
+            self.new_level()
+        else:
+            self.new_matrix_piece()
+
+    def can_move(self, potential_coord, minoes_coords):
+        return all(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))
 
     def is_t_slot(self, n):
-        t_slot_coord = (
-            self.matrix.piece.coord
-            + self.T_SLOT_COORDS[(self.matrix.piece.orientation + n) % 4]
-        )
+        t_slot_coord = self.matrix.piece.coord + self.T_SLOT_COORDS[(self.matrix.piece.orientation + n) % 4]
         return not self.matrix.cell_is_free(t_slot_coord)
 
+    def swap(self):
+        if self.matrix.piece.hold_enabled:
+            self.matrix.piece.hold_enabled = False
+            self.matrix.piece.prelocked = False
+            self.stop(self.lock)
+            self.matrix.piece, self.held.piece = self.held.piece, self.matrix.piece
+            self.held.piece.coord = self.HELD_COORD
+            if type(self.held.piece) == I_Tetrimino:
+                self.held.piece.coord += Movement.LEFT
+            for mino, coord in zip(self.held.piece, self.held.piece.MINOES_COORDS):
+                mino.coord = coord
+
+            if self.matrix.piece:
+                self.matrix.piece.coord = self.CURRENT_COORD
+                self.matrix.ghost = self.matrix.piece.ghost()
+                self.move_ghost()
+            else:
+                self.new_matrix_piece()
+
     def pause(self):
+        self.state = State.PAUSED
         self.stop_all()
         self.pressed_actions = []
-        self.timer.cancel(self.repeat_action)
-        self.on_pause()
-
-    def on_pause(self):
-        pass
+        self.auto_repeat = False
+        self.stop(self.repeat_action)
 
     def resume(self):
-        self.timer.postpone(self.lock_phase, self.stats.fall_delay)
-        if self.matrix.piece.locked:
-            self.timer.postpone(self.locks_down, self.stats.lock_delay)
-        self.timer.postpone(self.stats.update_time, 1)
-        self.on_resume()
-
-    def on_resume(self):
-        pass
+        self.state = State.PLAYING
+        self.start(self.fall, self.fall_delay)
+        if self.matrix.piece.prelocked:
+            self.start(self.lock, self.lock_delay)
+        self.start(self.update_time, 1)
 
     def game_over(self):
+        self.state = State.OVER
         self.stop_all()
         self.save_high_score()
-        self.on_game_over()
-
-    def on_game_over(self):
-        pass
 
     def stop_all(self):
-        self.timer.cancel(self.lock_phase)
-        self.timer.cancel(self.locks_down)
-        self.timer.cancel(self.stats.update_time)
+        self.stop(self.fall)
+        self.stop(self.lock)
+        self.stop(self.update_time)
+
+    def update_time(self):
+        self.time += 1
 
     def do_action(self, action):
         action()
         if action in self.autorepeatable_actions:
+            self.auto_repeat = False
             self.pressed_actions.append(action)
             if action == self.soft_drop:
-                delay = self.stats.fall_delay / 20
+                delay = self.fall_delay / 20
             else:
                 delay = self.AUTOREPEAT_DELAY
-            self.timer.reset(self.repeat_action, delay)
+            self.restart(self.repeat_action, delay)
 
     def repeat_action(self):
-        if not self.pressed_actions:
-            return
-
+        if self.pressed_actions:
             self.pressed_actions[-1]()
-        self.timer.postpone(self.repeat_action, self.AUTOREPEAT_PERIOD)
+            if not self.auto_repeat:
+                self.auto_repeat = True
+                self.restart(self.repeat_action, self.AUTOREPEAT_PERIOD)
+        else:
+            self.auto_repeat = False
+            self.stop(self.repeat_action)
 
     def remove_action(self, action):
         if action in self.autorepeatable_actions:
@@ -503,15 +393,25 @@ class TetrisLogic:
     def load_high_score(self, crypted_high_score=None):
         if crypted_high_score:
             crypted_high_score = int(pickle.loads(crypted_high_score))
-            self.stats.high_score = crypted_high_score ^ CRYPT_KEY
+            self.high_score = crypted_high_score ^ CRYPT_KEY
         else:
             raise Warning(
                 """TetrisLogic.load_high_score not implemented.
 High score is set to 0"""
             )
-            self.stats.high_score = 0
+            self.high_score = 0
 
     def save_high_score(self):
-        crypted_high_score = self.stats.high_score ^ CRYPT_KEY
+        crypted_high_score = self.high_score ^ CRYPT_KEY
         crypted_high_score = pickle.dumps(crypted_high_score)
         return crypted_high_score
+
+    def start(task, period):
+        raise Warning("TetrisLogic.start is not implemented.")
+
+    def stop(self, task):
+        raise Warning("TetrisLogic.stop is not implemented.")
+
+    def restart(self, task, period):
+        self.stop(task)
+        self.start(task, period)

tetrislogic/tetromino.py

@@ -1,7 +1,5 @@
 # -*- coding: utf-8 -*-
-import random
-
-from .utils import Coord, Spin, Color
+from .utils import Coord, Rotation, Color
 
 
 class Mino:
@@ -16,29 +14,18 @@ class MetaTetromino(type):
         Tetromino.shapes.append(cls)
 
 
-class Tetromino:
+class Tetromino(list):
 
     shapes = []
-    random_bag = []
-
-    def __new__(cls):
-        if not cls.random_bag:
-            cls.random_bag = list(cls.shapes)
-            random.shuffle(cls.random_bag)
-        return cls.random_bag.pop()()
-
-
-class TetrominoBase(list):
-
     # Super rotation system
     SRS = {
-        Spin.CLOCKWISE: (
+        Rotation.CLOCKWISE: (
             (Coord(0, 0), Coord(-1, 0), Coord(-1, 1), Coord(0, -2), Coord(-1, -2)),
             (Coord(0, 0), Coord(1, 0), Coord(1, -1), Coord(0, 2), Coord(1, 2)),
             (Coord(0, 0), Coord(1, 0), Coord(1, 1), Coord(0, -2), Coord(1, -2)),
             (Coord(0, 0), Coord(-1, 0), Coord(-1, -1), Coord(0, -2), Coord(-1, 2)),
         ),
-        Spin.COUNTER: (
+        Rotation.COUNTER: (
             (Coord(0, 0), Coord(1, 0), Coord(1, 1), Coord(0, -2), Coord(1, -2)),
             (Coord(0, 0), Coord(1, 0), Coord(1, -1), Coord(0, 2), Coord(1, 2)),
             (Coord(0, 0), Coord(-1, 0), Coord(-1, 1), Coord(0, -2), Coord(-1, -2)),
@@ -49,19 +36,19 @@ class TetrominoBase(list):
     def __init__(self):
         super().__init__(Mino(self.MINOES_COLOR, coord) for coord in self.MINOES_COORDS)
         self.orientation = 0
-        self.rotated_last = False
-        self.rotation_point_5_used = False
+        self.last_rotation_point = None
         self.hold_enabled = True
+        self.prelocked = False
 
     def ghost(self):
         return type(self)()
 
 
-class O_Tetrimino(TetrominoBase, metaclass=MetaTetromino):
+class O_Tetrimino(Tetromino, metaclass=MetaTetromino):
 
     SRS = {
-        Spin.CLOCKWISE: (tuple(), tuple(), tuple(), tuple()),
-        Spin.COUNTER: (tuple(), tuple(), tuple(), tuple()),
+        Rotation.CLOCKWISE: (tuple(), tuple(), tuple(), tuple()),
+        Rotation.COUNTER: (tuple(), tuple(), tuple(), tuple()),
     }
     MINOES_COORDS = (Coord(0, 0), Coord(1, 0), Coord(0, 1), Coord(1, 1))
     MINOES_COLOR = Color.YELLOW
@@ -70,16 +57,16 @@ class O_Tetrimino(TetrominoBase, metaclass=MetaTetromino):
         return False
 
 
-class I_Tetrimino(TetrominoBase, metaclass=MetaTetromino):
+class I_Tetrimino(Tetromino, metaclass=MetaTetromino):
 
     SRS = {
-        Spin.CLOCKWISE: (
+        Rotation.CLOCKWISE: (
             (Coord(1, 0), Coord(-1, 0), Coord(2, 0), Coord(-1, -1), Coord(2, 2)),
             (Coord(0, -1), Coord(-1, -1), Coord(2, -1), Coord(-1, 1), Coord(2, -2)),
             (Coord(-1, 0), Coord(1, 0), Coord(-2, 0), Coord(1, 1), Coord(-2, -2)),
             (Coord(0, -1), Coord(1, 1), Coord(-2, 1), Coord(1, -1), Coord(-2, 2)),
         ),
-        Spin.COUNTER: (
+        Rotation.COUNTER: (
             (Coord(0, -1), Coord(-1, -1), Coord(2, -1), Coord(-1, 1), Coord(2, -2)),
             (Coord(-1, 0), Coord(1, 0), Coord(-2, 0), Coord(1, 1), Coord(-2, -2)),
             (Coord(0, 1), Coord(1, 1), Coord(-2, 1), Coord(1, -1), Coord(-2, 2)),
@@ -90,31 +77,31 @@ class I_Tetrimino(TetrominoBase, metaclass=MetaTetromino):
     MINOES_COLOR = Color.CYAN
 
 
-class T_Tetrimino(TetrominoBase, metaclass=MetaTetromino):
+class T_Tetrimino(Tetromino, metaclass=MetaTetromino):
 
     MINOES_COORDS = (Coord(-1, 0), Coord(0, 0), Coord(0, 1), Coord(1, 0))
     MINOES_COLOR = Color.MAGENTA
 
 
-class L_Tetrimino(TetrominoBase, metaclass=MetaTetromino):
+class L_Tetrimino(Tetromino, metaclass=MetaTetromino):
 
     MINOES_COORDS = (Coord(-1, 0), Coord(0, 0), Coord(1, 0), Coord(1, 1))
     MINOES_COLOR = Color.ORANGE
 
 
-class J_Tetrimino(TetrominoBase, metaclass=MetaTetromino):
+class J_Tetrimino(Tetromino, metaclass=MetaTetromino):
 
     MINOES_COORDS = (Coord(-1, 1), Coord(-1, 0), Coord(0, 0), Coord(1, 0))
     MINOES_COLOR = Color.BLUE
 
 
-class S_Tetrimino(TetrominoBase, metaclass=MetaTetromino):
+class S_Tetrimino(Tetromino, metaclass=MetaTetromino):
 
     MINOES_COORDS = (Coord(-1, 0), Coord(0, 0), Coord(0, 1), Coord(1, 1))
     MINOES_COLOR = Color.GREEN
 
 
-class Z_Tetrimino(TetrominoBase, metaclass=MetaTetromino):
+class Z_Tetrimino(Tetromino, metaclass=MetaTetromino):
 
     MINOES_COORDS = (Coord(-1, 1), Coord(0, 1), Coord(0, 0), Coord(1, 0))
     MINOES_COLOR = Color.RED

tetrislogic/utils.py

@@ -7,9 +7,6 @@ class Coord:
     def __add__(self, other):
         return Coord(self.x + other.x, self.y + other.y)
 
-    def __matmul__(self, spin):
-        return Coord(spin * self.y, -spin * self.x)
-
 
 class Movement:
 
@@ -18,7 +15,7 @@ class Movement:
     DOWN = Coord(0, -1)
 
 
-class Spin:
+class Rotation:
 
     CLOCKWISE = 1
     COUNTER = -1
@@ -31,14 +28,6 @@ class T_Spin:
     T_SPIN = "T-SPIN"
 
 
-class T_Slot:
-
-    A = 0
-    B = 1
-    C = 3
-    D = 2
-
-
 class Color:
 
     BLUE = 0