fix setup.py

New musics
Piece lock optimize

.gitignore

@@ -25,6 +25,8 @@ wheels/
 .installed.cfg
 *.egg
 MANIFEST
+Tetrarcade.build/
+Tetrarcade.dist/
 
 # PyInstaller
 #  Usually these files are written by a python script from a template

README.md

@@ -2,9 +2,11 @@
 
 Tetris clone made with Python and Arcade graphic library
 
+![Screenshot](https://malingrey.fr/images/fMd4EseZ/VtwJIMyQ.png)
+
 ## Requirements
 
-[Python](https://www.python.org/)
+* [Python](https://www.python.org/) 3.6 or upper
 
 ## Install
 
@@ -18,4 +20,18 @@ python -m pip install -r requirements.txt
 
 ```shell
 python tetrarcade.py
-```
+```
+
+## Settings
+
+* Windows: Edit `%appdata%\Tetrarcade\TetrArcade.ini`
+* 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 -r build-requirements.txt
+python setup.py bdist
+```

TetrArcade.py

@@ -0,0 +1,585 @@
+# -*- coding: utf-8 -*-
+import sys
+try:
+    import arcade
+except ImportError as e:
+    sys.exit(
+        str(e) + """
+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, State, Coord
+
+
+# Constants
+# Matrix
+NB_LINES = 20
+NB_COLS = 10
+NB_NEXT = 5
+
+# Delays (seconds)
+LOCK_DELAY = 0.5
+FALL_DELAY = 1
+AUTOREPEAT_DELAY = 0.300
+AUTOREPEAT_PERIOD = 0.010
+
+# Piece init coord
+MATRIX_PIECE_COORD = Coord(4, NB_LINES)
+NEXT_PIECE_COORDS = [Coord(NB_COLS + 4, NB_LINES - 4 * n - 3) for n in range(NB_NEXT)]
+HELD_PIECE_COORD = Coord(-5, NB_LINES - 3)
+
+# Window
+WINDOW_WIDTH = 800
+WINDOW_HEIGHT = 600
+WINDOW_MIN_WIDTH = 517
+WINDOW_MIN_HEIGHT = 388
+WINDOW_TITLE = "TETRARCADE"
+BG_COLOR = (7, 11, 21)
+
+# Delays (seconds)
+HIGHLIGHT_TEXT_DISPLAY_DELAY = 0.7
+
+# Transparency (0=invisible, 255=opaque)
+NORMAL_ALPHA = 200
+PRELOCKED_ALPHA = 100
+GHOST_ALPHA = 30
+MATRIX_BG_ALPHA = 100
+BAR_ALPHA = 75
+
+# Mino size
+MINO_SIZE = 20
+MINO_SPRITE_SIZE = 21
+
+if getattr(sys, 'frozen', False):
+    # The application is frozen
+    PROGRAM_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")
+
+# 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")
+HELD_BG_PATH = os.path.join(IMAGES_DIR, "held.png")
+NEXT_BG_PATH = os.path.join(IMAGES_DIR, "next.png")
+MINOES_SPRITES_PATH = os.path.join(IMAGES_DIR, "minoes.png")
+Color.PRELOCKED = 7
+MINOES_COLOR_ID = {
+    Color.BLUE: 0,
+    Color.CYAN: 1,
+    Color.GREEN: 2,
+    Color.MAGENTA: 3,
+    Color.ORANGE: 4,
+    Color.RED: 5,
+    Color.YELLOW: 6,
+    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))
+)
+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))
+
+# Text
+TEXT_COLOR = arcade.color.BUBBLES
+FONT_NAME = os.path.join(RESOURCES_DIR, "fonts/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, "TetrArcade.ini")
+
+
+class MinoSprite(arcade.Sprite):
+
+    def __init__(self, mino, window, alpha):
+        super().__init__()
+        self.alpha = alpha
+        self.window = window
+        self.append_texture(TEXTURES[mino.color])
+        self.append_texture(TEXTURES[Color.PRELOCKED])
+        self.set_texture(0)
+
+    def refresh(self, x, y, prelocked=False):
+        self.scale = self.window.scale
+        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, scale):
+        for sprite in self:
+            sprite.scale = scale
+        self.refresh()
+
+
+class TetrominoSprites(MinoesSprites):
+
+    def __init__(self, tetromino, window, alpha=NORMAL_ALPHA):
+        super().__init__()
+        self.tetromino = tetromino
+        self.alpha = alpha
+        for mino in tetromino:
+            mino.sprite = MinoSprite(mino, window, alpha)
+            self.append(mino.sprite)
+
+    def refresh(self):
+        for mino in self.tetromino:
+            coord = mino.coord + self.tetromino.coord
+            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 refresh(self):
+        for y, line in enumerate(self.matrix):
+            for x, mino in enumerate(line):
+                if mino:
+                    mino.sprite.refresh(x, y)
+
+    def remove_line(self, y):
+        for mino in self.matrix[y]:
+            if mino:
+                self.remove(mino.sprite)
+
+
+class TetrArcade(TetrisLogic, arcade.Window):
+
+    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
+    MATRIX_PIECE_COORD = MATRIX_PIECE_COORD
+    NEXT_PIECE_COORDS = NEXT_PIECE_COORDS
+    HELD_PIECE_COORD = HELD_PIECE_COORD
+
+    def __init__(self):
+        locale.setlocale(locale.LC_ALL, "")
+        self.highlight_texts = []
+        self.tasks = {}
+
+        self.conf = configparser.ConfigParser()
+        if self.conf.read(CONF_PATH):
+            try:
+                self.load_conf()
+            except:
+                self.new_conf()
+                self.load_conf()
+        else:
+            self.new_conf()
+            self.load_conf()
+
+        super().__init__()
+        arcade.Window.__init__(
+            self,
+            width=self.init_width,
+            height=self.init_height,
+            title=WINDOW_TITLE,
+            resizable=True,
+            antialiasing=False,
+            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.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)
+
+        if self.play_music:
+            self.music = pyglet.media.Player()
+            playlist = itertools.cycle(
+                pyglet.media.load(path)
+                for path in MUSICS_PATHS
+            )
+            self.music.queue(playlist)
+
+    def new_conf(self):
+        self.conf["WINDOW"] = {"width": WINDOW_WIDTH, "height": WINDOW_HEIGHT, "fullscreen": False}
+        self.conf["KEYBOARD"] = {
+            "start": "ENTER",
+            "move left": "LEFT",
+            "move right": "RIGHT",
+            "soft drop": "DOWN",
+            "hard drop": "SPACE",
+            "rotate clockwise": "UP",
+            "rotate counter": "Z",
+            "hold": "C",
+            "pause": "ESCAPE",
+            "fullscreen": "F11",
+        }
+        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):
+            os.makedirs(USER_PROFILE_DIR)
+        with open(CONF_PATH, "w") as f:
+            self.conf.write(f)
+
+    def load_conf(self):
+        self.init_width = int(self.conf["WINDOW"]["width"])
+        self.init_height = int(self.conf["WINDOW"]["height"])
+        self.init_fullscreen = self.conf["WINDOW"].getboolean("fullscreen")
+
+        for action, key in self.conf["KEYBOARD"].items():
+            self.conf["KEYBOARD"][action] = key.upper()
+        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,
+            },
+            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"]["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.swap,
+                getattr(arcade.key, self.conf["KEYBOARD"]["pause"]): self.pause,
+                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,
+            },
+            State.OVER: {
+                getattr(arcade.key, self.conf["KEYBOARD"]["start"]): self.new_game,
+                getattr(arcade.key, self.conf["KEYBOARD"]["fullscreen"]): self.toggle_fullscreen,
+            },
+        }
+
+        self.AUTOREPEAT_DELAY = float(self.conf["AUTO-REPEAT"]["delay"])
+        self.AUTOREPEAT_PERIOD = float(self.conf["AUTO-REPEAT"]["period"])
+
+        controls_text = (
+            "\n\n\nCONTROLS\n\n"
+            + "\n".join(
+                "{:<16s}{:>6s}".format(key, action)
+                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.game_over_text = """GAME
+OVER
+
+PRESS
+[{}]
+TO PLAY
+AGAIN""".format(
+            self.conf["KEYBOARD"]["start"]
+        )
+
+        self.play_music = self.conf["MUSIC"].getboolean("play")
+
+    def new_game(self):
+        self.highlight_texts = []
+        super().new_game()
+        self.matrix.sprites = MatrixSprites(self.matrix)
+        if self.play_music:
+            self.music.seek(0)
+            self.music.play()
+
+    def new_tetromino(self):
+        tetromino = super().new_tetromino()
+        tetromino.sprites = TetrominoSprites(tetromino, self)
+        return tetromino
+
+    def new_matrix_piece(self):
+        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()
+
+    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 rotate(self, rotation):
+        rotated = super().rotate(rotation)
+        if rotated:
+            for tetromino in (self.matrix.piece, self.matrix.ghost):
+                tetromino.sprites.refresh()
+        return rotated
+
+    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 lock(self):
+        self.matrix.piece.prelocked = False
+        self.matrix.piece.sprites.refresh()
+        super().lock()
+        self.matrix.sprites.refresh()
+
+    def enter_the_matrix(self):
+        super().enter_the_matrix()
+        for mino in self.matrix.piece:
+            self.matrix.sprites.append(mino.sprite)
+
+    def remove_line(self, y):
+        self.matrix.sprites.remove_line(y)
+        super().remove_line(y)
+
+    def pause(self):
+        super().pause()
+        if self.play_music:
+            self.music.pause()
+
+    def resume(self):
+        super().resume()
+        if self.play_music:
+            self.music.play()
+
+    def game_over(self):
+        super().game_over()
+        if self.play_music:
+            self.music.pause()
+
+    def on_key_press(self, key, modifiers):
+        for key_or_modifier in (key, modifiers):
+            try:
+                action = self.key_map[self.state][key_or_modifier]
+            except KeyError:
+                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_or_modifier]
+            except KeyError:
+                pass
+            else:
+                self.remove_action(action)
+
+    def show_text(self, text):
+        self.highlight_texts.append(text)
+        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.stop(self.del_highlight_text)
+
+    def on_draw(self):
+        arcade.start_render()
+        self.bg.draw()
+
+        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:
+                if tetromino:
+                    tetromino.sprites.draw()
+
+            t = time.localtime(self.time)
+            font_size = STATS_TEXT_SIZE * self.scale
+            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_y=self.matrix.bg.bottom + 1.5 * (2 * y + 1) * font_size,
+                    color=TEXT_COLOR,
+                    font_size=font_size,
+                    align="right",
+                    font_name=FONT_NAME,
+                    anchor_x="left",
+                )
+            for y, text in enumerate(
+                (
+                    "{: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),
+                )
+            ):
+                arcade.draw_text(
+                    text=text,
+                    start_x=self.matrix.bg.left - STATS_TEXT_MARGIN * self.scale,
+                    start_y=self.matrix.bg.bottom + 3 * y * font_size,
+                    color=TEXT_COLOR,
+                    font_size=font_size,
+                    align="right",
+                    font_name=FONT_NAME,
+                    anchor_x="right",
+                )
+
+        highlight_text = {
+            State.STARTING: self.start_text,
+            State.PLAYING: self.highlight_texts[0] if self.highlight_texts else "",
+            State.PAUSED: self.pause_text,
+            State.OVER: self.game_over_text,
+        }.get(self.state, "")
+        if highlight_text:
+            arcade.draw_text(
+                text=highlight_text,
+                start_x=self.matrix.bg.center_x,
+                start_y=self.matrix.bg.center_y,
+                color=HIGHLIGHT_TEXT_COLOR,
+                font_size=HIGHLIGHT_TEXT_SIZE * self.scale,
+                align="center",
+                font_name=FONT_NAME,
+                anchor_x="center",
+                anchor_y="center",
+            )
+
+    def on_hide(self):
+        self.pause()
+
+    def toggle_fullscreen(self):
+        self.set_fullscreen(not self.fullscreen)
+
+    def on_resize(self, width, height):
+        super().on_resize(width, height)
+        center_x = width / 2
+        center_y = height / 2
+        self.scale = min(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
+
+        self.matrix.bg.scale = self.scale
+        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.held.bg.scale = self.scale
+        self.held.bg.right = self.matrix.bg.left
+        self.held.bg.top = self.matrix.bg.top
+
+        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(self.scale)
+
+    def load_high_score(self):
+        try:
+            with open(HIGH_SCORE_PATH, "rb") as f:
+                crypted_high_score = f.read()
+                super().load_high_score(crypted_high_score)
+        except:
+            self.high_score = 0
+
+    def save_high_score(self):
+        try:
+            if not os.path.exists(USER_PROFILE_DIR):
+                os.makedirs(USER_PROFILE_DIR)
+            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(
+                    self.high_score
+                )
+                + str(e)
+            )
+
+    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.play_music:
+            self.music.pause()
+        super().on_close()
+
+
+def main():
+    try:
+        TetrArcade()
+        arcade.run()
+    except Exception as e:
+        sys.exit(e)
+
+
+if __name__ == "__main__":
+    main()

build-requirements.txt

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

setup.py

@@ -0,0 +1,43 @@
+# -*- 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
+
+excludes = [
+    "tkinter",
+    "PyQt4",
+    "PyQt5",
+    "PySide",
+    "PySide2"
+]
+
+executable = Executable(
+    script = "TetrArcade.py",
+    icon = icon,
+    base = base,
+    shortcutName="TetrArcade",
+    shortcutDir="DesktopFolder"
+)
+
+options = {
+    "build_exe": {
+        "packages": ["arcade", "pyglet"],
+        "excludes": excludes,
+        "include_files": "resources",
+        "silent": True
+    }
+}
+setup(
+    name = "TetrArcade",
+    version = "0.3",
+    description = "Tetris clone",
+    author = "AdrienMalin",
+    executables = [executable],
+    options = options,
+)

test.py

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+
+from TetrArcade import TetrArcade, State
+
+game = TetrArcade()
+game.new_game()
+game.move_left()
+game.move_right()
+game.swap()
+game.rotate_clockwise()
+game.rotate_counter()
+for i in range(12):
+    game.soft_drop()
+game.matrix.sprites.refresh()
+game.on_draw()
+while game.state != State.OVER:
+    game.hard_drop()

tetrarcade.py

@@ -1,421 +0,0 @@
-# -*- coding: utf-8 -*-
-import sys
-import locale
-import time
-import os
-
-try:
-    import arcade
-except ImportError:
-    sys.exit(
-"""This game require arcade library.
-You can install it with:
-python -m pip install --user arcade
-"""
-)
-
-from tetrislogic import TetrisLogic, State, AbstractScheduler
-
-
-# Constants
-# Window
-WINDOW_WIDTH = 800
-WINDOW_HEIGHT = 600
-WINDOW_TITLE = "TETRARCADE"
-
-# Delays (seconds)
-HIGHLIGHT_TEXT_DISPLAY_DELAY = 1
-
-# Text
-TEXT_COLOR = arcade.color.BUBBLES
-HIGHLIGHT_TEXT_COLOR = arcade.color.BUBBLES
-FONT_NAME = "joystix monospace.ttf"
-TEXT_MARGIN = 40
-FONT_SIZE = 16
-TEXT_HEIGHT = 20.8
-HIGHLIGHT_TEXT_FONT_SIZE = 20
-START_TEXT = """TETRARCADE
-
-CONTROLS
-MOVE LEFT                 ←
-MOVE RIGHT                →
-SOFT DROP                 ↓
-HARD DROP             SPACE
-ROTATE CLOCKWISE          ↑
-ROTATE COUNTERCLOCKWISE   Z
-HOLD                      C
-PAUSE                   ESC
-
-PRESS [ENTER] TO START"""
-STATS_TEXT = """SCORE
-
-HIGH SCORE
-
-LEVEL
-
-GOAL
-
-LINES
-
-TIME
-"""
-PAUSE_TEXT = """TETRARCADE
-
-CONTROLS
-MOVE LEFT                 ←
-MOVE RIGHT                →
-SOFT DROP                 ↓
-HARD DROP             SPACE
-ROTATE CLOCKWISE          ↑
-ROTATE COUNTERCLOCKWISE   Z
-HOLD                      C
-RESUME                  ESC
-
-PRESS [ESC] TO RESUME"""
-GAME_OVER_TEXT = """GAME
-OVER
-
-PRESS
-[ENTER]
-TO PLAY
-AGAIN"""
-
-# Paths
-WINDOW_BG = "images/bg.jpg"
-MATRIX_SPRITE_PATH = "images/matrix.png"
-MINOES_SPRITES_PATHS = {
-    "orange":  "images/orange_mino.png",
-    "blue":    "images/blue_mino.png",
-    "yellow":  "images/yellow_mino.png",
-    "cyan":    "images/cyan_mino.png",
-    "green":   "images/green_mino.png",
-    "red":     "images/red_mino.png",
-    "magenta": "images/magenta_mino.png"
-}
-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")
-
-# Transparency (0=invisible, 255=opaque)
-NORMAL_ALPHA = 200
-PRELOCKED_ALPHA = 127
-GHOST_ALPHA = 50
-MATRIX_SRITE_ALPHA = 100
-
-
-class ArcadeScheduler(AbstractScheduler):
-
-    def __init__(self):
-        self._tasks = {}
-
-    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]
-
-
-class TetrArcade(TetrisLogic, arcade.Window):
-
-    scheduler = ArcadeScheduler()
-
-    def __init__(self):
-        super().__init__()
-
-        locale.setlocale(locale.LC_ALL, '')
-
-        self.KEY_MAP = {
-            State.STARTING: {
-                arcade.key.ENTER:     self.new_game
-            },
-            State.PLAYING: {
-                arcade.key.LEFT:      self.move_left,
-                arcade.key.NUM_4:     self.move_left,
-                arcade.key.RIGHT:     self.move_right,
-                arcade.key.NUM_6:     self.move_right,
-                arcade.key.SPACE:     self.hard_drop,
-                arcade.key.NUM_8:     self.hard_drop,
-                arcade.key.DOWN:      self.soft_drop,
-                arcade.key.NUM_2:     self.soft_drop,
-                arcade.key.UP:        self.rotate_clockwise,
-                arcade.key.X:         self.rotate_clockwise,
-                arcade.key.NUM_1:     self.rotate_clockwise,
-                arcade.key.NUM_5:     self.rotate_clockwise,
-                arcade.key.NUM_9:     self.rotate_clockwise,
-                arcade.key.Z:         self.rotate_counterclockwise,
-                arcade.key.NUM_3:     self.rotate_counterclockwise,
-                arcade.key.NUM_7:     self.rotate_counterclockwise,
-                arcade.key.C:         self.swap,
-                arcade.key.MOD_SHIFT: self.swap,
-                arcade.key.NUM_0:     self.swap,
-                arcade.key.ESCAPE:    self.pause,
-                arcade.key.F1:        self.pause,
-            },
-            State.PAUSED: {
-                arcade.key.ESCAPE:    self.resume,
-                arcade.key.F1:        self.resume
-            },
-            State.OVER: {
-                arcade.key.ENTER:     self.new_game
-            }
-        }
-
-        self.highlight_texts = []
-
-        arcade.Window.__init__(
-            self,
-            width = WINDOW_WIDTH,
-            height = WINDOW_HEIGHT,
-            title = WINDOW_TITLE,
-            resizable = False,
-            antialiasing = False
-        )
-
-        self.bg_sprite = arcade.Sprite(WINDOW_BG)
-        self.matrix_minoes_sprites = arcade.SpriteList()
-        self.held_piece_sprites = arcade.SpriteList()
-        self.current_piece_sprites = arcade.SpriteList()
-        self.ghost_piece_sprites = arcade.SpriteList()
-        self.next_pieces_sprites = arcade.SpriteList()
-        self.matrix_sprite = arcade.Sprite(MATRIX_SPRITE_PATH)
-        self.matrix_sprite.alpha = MATRIX_SRITE_ALPHA
-        self.on_resize(self.width, self.height)
-        self.general_text = arcade.create_text(
-            text = STATS_TEXT,
-            color = TEXT_COLOR,
-            font_size = FONT_SIZE,
-            font_name = FONT_NAME,
-            anchor_x = 'right'
-        )
-
-    def new_game(self):
-        self.highlight_texts = []
-        super().new_game()
-
-    def new_current_piece(self):
-        super().new_current_piece()
-        self.reload_next_pieces()
-        self.reload_current_piece()
-        self.reload_matrix()
-
-    def lock(self):
-        super().lock()
-
-    def swap(self):
-        super().swap()
-        self.reload_held_piece()
-        self.reload_current_piece()
-
-    def game_over(self):
-        super().game_over()
-
-    def on_key_press(self, key, modifiers):
-        for key_or_modifier in (key, modifiers):
-            try:
-                action = self.KEY_MAP[self.state][key_or_modifier]
-            except KeyError:
-                pass
-            else:
-                self.do_action(action)
-
-    def on_key_release(self, key, modifiers):
-        try:
-            action = self.KEY_MAP[self.state][key]
-        except KeyError:
-            pass
-        else:
-            self.remove_action(action)
-
-    def show_text(self, text):
-        self.highlight_texts.append(text)
-        self.scheduler.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.scheduler.stop(self.del_highlight_text)
-
-    def reload_piece(self, piece):
-        piece_sprites = arcade.SpriteList()
-        for mino_coord in piece.minoes_coords:
-            mino_sprite_path = MINOES_SPRITES_PATHS[piece.MINOES_COLOR]
-            mino_sprite = arcade.Sprite(mino_sprite_path)
-            mino_sprite.alpha = NORMAL_ALPHA
-            piece_sprites.append(mino_sprite)
-        return piece_sprites
-
-    def reload_held_piece(self):
-        self.held_piece_sprites = self.reload_piece(self.held_piece)
-
-    def reload_next_pieces(self):
-        self.next_pieces_sprites = arcade.SpriteList()
-        for piece in self.next_pieces:
-            for mino_coord in piece.minoes_coords:
-                mino_sprite_path = MINOES_SPRITES_PATHS[piece.MINOES_COLOR]
-                mino_sprite = arcade.Sprite(mino_sprite_path)
-                mino_sprite.alpha = NORMAL_ALPHA
-                self.next_pieces_sprites.append(mino_sprite)
-
-    def reload_current_piece(self):
-        self.current_piece_sprites = self.reload_piece(self.current_piece)
-        self.ghost_piece_sprites = self.reload_piece(self.ghost_piece)
-
-    def reload_matrix(self):
-        if self.matrix:
-            self.matrix_minoes_sprites = arcade.SpriteList()
-            for y, line in enumerate(self.matrix):
-                for x, mino_color in enumerate(line):
-                    if mino_color:
-                        mino_sprite_path = MINOES_SPRITES_PATHS[mino_color]
-                        mino_sprite = arcade.Sprite(mino_sprite_path)
-                        mino_sprite.left = self.matrix_sprite.left + x*(mino_sprite.width-1)
-                        mino_sprite.bottom = self.matrix_sprite.bottom + y*(mino_sprite.height-1)
-                        mino_sprite.alpha = 200
-                        self.matrix_minoes_sprites.append(mino_sprite)
-
-    def update_piece(self, piece, piece_sprites):
-        if piece:
-            for mino_sprite, mino_coord in zip(
-                piece_sprites, piece.minoes_coords
-            ):
-                mino_coord += piece.coord
-                mino_sprite.left = self.matrix_sprite.left + mino_coord.x*(mino_sprite.width-1)
-                mino_sprite.bottom = self.matrix_sprite.bottom + mino_coord.y*(mino_sprite.height-1)
-
-    def on_draw(self):
-        arcade.start_render()
-        self.bg_sprite.draw()
-
-        if self.state in (State.PLAYING, State.OVER):
-            self.matrix_sprite.draw()
-            self.matrix_minoes_sprites.draw()
-
-            self.update_piece(self.held_piece, self.held_piece_sprites)
-            self.held_piece_sprites.draw()
-
-            self.update_piece(self.current_piece, self.current_piece_sprites)
-            if self.current_piece.prelocked:
-                alpha = (
-                    PRELOCKED_ALPHA
-                    if self.current_piece.prelocked
-                    else NORMAL_ALPHA
-                )
-                for mino_sprite in self.current_piece_sprites:
-                    mino_sprite.alpha = alpha
-            self.current_piece_sprites.draw()
-
-            self.update_piece(self.ghost_piece, self.ghost_piece_sprites)
-            for mino_sprite in self.ghost_piece_sprites:
-                mino_sprite.alpha = GHOST_ALPHA
-            self.ghost_piece_sprites.draw()
-
-            for n, piece in enumerate(self.next_pieces):
-                for mino_sprite, mino_coord in zip(
-                    self.next_pieces_sprites[4*n:4*(n+1)], piece.minoes_coords
-                ):
-                    mino_coord += piece.coord
-                    mino_sprite.left = self.matrix_sprite.left + mino_coord.x*(mino_sprite.width-1)
-                    mino_sprite.bottom = self.matrix_sprite.bottom + mino_coord.y*(mino_sprite.height-1)
-            self.next_pieces_sprites.draw()
-
-            arcade.render_text(
-                self.general_text,
-                self.matrix_sprite.left - TEXT_MARGIN,
-                self.matrix_sprite.bottom
-            )
-            t = time.localtime(self.time)
-            for y, text in enumerate(
-                (
-
-                    "{:02d}:{:02d}:{:02d}".format(
-                        t.tm_hour-1, t.tm_min, t.tm_sec
-                    ),
-                    "{:n}".format(self.nb_lines),
-                    "{:n}".format(self.goal),
-                    "{:n}".format(self.level),
-                    "{:n}".format(self.high_score),
-                    "{:n}".format(self.score)
-                )
-            ):
-                arcade.draw_text(
-                    text = text,
-                    start_x = self.matrix_sprite.left - TEXT_MARGIN,
-                    start_y = self.matrix_sprite.bottom + 2*y*TEXT_HEIGHT,
-                    color = TEXT_COLOR,
-                    font_size = FONT_SIZE,
-                    align = 'right',
-                    font_name = FONT_NAME,
-                    anchor_x = 'right'
-                )
-
-        highlight_text = {
-            State.STARTING: START_TEXT,
-            State.PLAYING: self.highlight_texts[0] if self.highlight_texts else "",
-            State.PAUSED: PAUSE_TEXT,
-            State.OVER: GAME_OVER_TEXT
-        }.get(self.state, "")
-        if highlight_text:
-            arcade.draw_text(
-                text = highlight_text,
-                start_x = self.matrix_sprite.center_x,
-                start_y = self.matrix_sprite.center_y,
-                color = HIGHLIGHT_TEXT_COLOR,
-                font_size = HIGHLIGHT_TEXT_FONT_SIZE,
-                align = 'center',
-                font_name = FONT_NAME,
-                anchor_x = 'center',
-                anchor_y = 'center'
-            )
-
-    def on_resize(self, width, height):
-        center_x = self.width / 2
-        center_y = self.height / 2
-        self.bg_sprite.center_x = center_x
-        self.bg_sprite.center_y = center_y
-        self.matrix_sprite.center_x = center_x
-        self.matrix_sprite.center_y = center_y
-        self.matrix_sprite.left = int(self.matrix_sprite.left)
-        self.matrix_sprite.top = int(self.matrix_sprite.top)
-        self.reload_matrix()
-
-    def load_high_score(self):
-        try:
-            with open(HIGH_SCORE_PATH, "r") as f:
-               self.high_score = int(f.read())
-        except:
-            self.high_score = 0
-
-    def save_high_score(self):
-        try:
-            if not os.path.exists(USER_PROFILE_DIR):
-                os.makedirs(USER_PROFILE_DIR)
-            with open(HIGH_SCORE_PATH, mode='w') as f:
-                f.write(str(self.high_score))
-        except Exception as e:
-            sys.exit(
-                """High score: {:n}
-High score could not be saved:
-""".format(self.high_score)
-                + str(e)
-            )
-
-
-def main():
-    tetrarcade = TetrArcade()
-    arcade.run()
-    tetrarcade.save_high_score()
-
-if __name__ == "__main__":
-    main()

tetrislogic.py

@@ -1,543 +0,0 @@
-# -*- coding: utf-8 -*-
-import random
-
-# Matrix
-NB_LINES = 20
-NB_COLS = 10
-NB_NEXT_PIECES = 5
-
-# Delays (seconds)
-LOCK_DELAY = 0.5
-FALL_DELAY = 1
-AUTOREPEAT_DELAY = 0.220    # Official : 0.300
-AUTOREPEAT_PERIOD = 0.010   # Official : 0.010
-
-
-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)
-
-
-# Piece init coord
-MATRIX_PIECE_INIT_COORD = Coord(4, NB_LINES)
-NEXT_PIECES_COORDS = [
-    Coord(NB_COLS+6, NB_LINES-4*n-3)
-    for n in range(NB_NEXT_PIECES)
-]
-HELD_PIECE_COORD = Coord(-7, NB_LINES-3)
-HELD_I_COORD = Coord(-7, NB_LINES-3)
-
-
-class State:
-
-    STARTING = "starting"
-    PLAYING  = "playing"
-    PAUSED   = "paused"
-    OVER     = "over"
-
-
-class Movement:
-
-    LEFT  = Coord(-1,  0)
-    RIGHT = Coord( 1,  0)
-    DOWN  = Coord( 0, -1)
-
-
-class Rotation:
-
-    CLOCKWISE        =  1
-    COUNTERCLOCKWISE = -1
-
-
-class T_Spin:
-
-    NO_T_SPIN =   ""
-    MINI_T_SPIN = "MINI\nT-SPIN"
-    T_SPIN =      "T-SPIN"
-
-
-class AbstractScheduler:
-
-    def start(task, period):
-        raise Warning("AbstractScheduler.start is not implemented.")
-
-    def stop(self, task):
-        raise Warning("AbstractScheduler.stop is not implemented.")
-
-    def restart(self, task, period):
-        self.stop(task)
-        self.start(task, period)
-
-
-class Tetromino:
-
-
-    class AbstractTetromino:
-        # Super rotation system
-        SRS = {
-            Rotation.COUNTERCLOCKWISE: (
-                (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))
-            ),
-            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))
-            )
-        }
-        CAN_SPIN = False
-
-        def __init__(self):
-            self.coord = NEXT_PIECES_COORDS[-1]
-            self.minoes_coords = self.MINOES_COORDS
-            self.orientation = 0
-            self.last_rotation_point_used = None
-            self.hold_enabled = True
-            self.prelocked = False
-
-        def ghost(self):
-            return self.__class__()
-
-
-    class O(AbstractTetromino):
-
-        SRS = {
-            Rotation.COUNTERCLOCKWISE: (tuple(), tuple(), tuple(), tuple()),
-            Rotation.CLOCKWISE: (tuple(), tuple(), tuple(), tuple())
-        }
-        MINOES_COORDS = (Coord(0, 0), Coord(1, 0), Coord(0, 1), Coord(1, 1))
-        MINOES_COLOR = "yellow"
-
-        def rotate(self, direction):
-            return False
-
-
-    class I(AbstractTetromino):
-
-        SRS = {
-            Rotation.COUNTERCLOCKWISE: (
-                (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)),
-                (Coord(1, 0), Coord(-1, 0), Coord(2, 0), Coord(-1, -1), Coord(2, 2))
-            ),
-            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))
-            )
-        }
-        MINOES_COORDS = (Coord(-1, 0), Coord(0, 0), Coord(1, 0), Coord(2, 0))
-        MINOES_COLOR = "cyan"
-
-
-    class T(AbstractTetromino):
-
-        MINOES_COORDS = (Coord(-1, 0), Coord(0, 0), Coord(0, 1), Coord(1, 0))
-        MINOES_COLOR = "magenta"
-        CAN_SPIN = True
-
-
-    class L(AbstractTetromino):
-
-        MINOES_COORDS = (Coord(-1, 0), Coord(0, 0), Coord(1, 0), Coord(1, 1))
-        MINOES_COLOR = "orange"
-
-
-    class J(AbstractTetromino):
-
-        MINOES_COORDS = (Coord(-1, 1), Coord(-1, 0), Coord(0, 0), Coord(1, 0))
-        MINOES_COLOR = "blue"
-
-
-    class S(AbstractTetromino):
-
-        MINOES_COORDS = (Coord(-1, 0), Coord(0, 0), Coord(0, 1), Coord(1, 1))
-        MINOES_COLOR = "green"
-
-
-    class Z(AbstractTetromino):
-
-        MINOES_COORDS = (Coord(-1, 1), Coord(0, 1), Coord(0, 0), Coord(1, 0))
-        MINOES_COLOR = "red"
-
-
-    TETROMINOES = (O, I, T, L, J, S, Z)
-    random_bag = []
-
-    def __new__(cls):
-        if not cls.random_bag:
-            cls.random_bag = list(cls.TETROMINOES)
-            random.shuffle(cls.random_bag)
-        return cls.random_bag.pop()()
-
-
-class TetrisLogic():
-
-    scheduler = AbstractScheduler()
-
-    def __init__(self):
-        self.load_high_score()
-        self.state = State.STARTING
-        self.matrix = []
-        self.next_pieces = []
-        self.current_piece = None
-        self.held_piece = None
-        self.time = 0
-        self.autorepeatable_actions = (self.move_left, self.move_right, self.soft_drop)
-        self.pressed_actions = []
-
-    def new_game(self):
-        self.level = 0
-        self.score = 0
-        self.nb_lines = 0
-        self.goal = 0
-        self.time = 0
-
-        self.pressed_actions = []
-        self.auto_repeat = False
-
-        self.lock_delay = LOCK_DELAY
-        self.fall_delay = FALL_DELAY
-
-        self.matrix = [
-            [None for x in range(NB_COLS)]
-            for y in range(NB_LINES+3)
-        ]
-        self.next_pieces = [Tetromino() for i in range(NB_NEXT_PIECES)]
-        self.current_piece = None
-        self.held_piece = None
-        self.state = State.PLAYING
-        self.scheduler.start(self.update_time, 1)
-        self.new_level()
-
-    def new_level(self):
-        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)
-        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.scheduler.restart(self.fall, self.fall_delay)
-        self.new_current_piece()
-
-    def new_current_piece(self):
-        self.current_piece = self.next_pieces.pop(0)
-        self.current_piece.coord = MATRIX_PIECE_INIT_COORD
-        self.ghost_piece = self.current_piece.ghost()
-        self.move_ghost()
-        self.next_pieces.append(Tetromino())
-        for piece, coord in zip (self.next_pieces, NEXT_PIECES_COORDS):
-            piece.coord = coord
-        if not self.can_move(
-            self.current_piece.coord,
-            self.current_piece.minoes_coords
-        ):
-            self.game_over()
-
-    def move_left(self):
-        self.move(Movement.LEFT)
-
-    def move_right(self):
-        self.move(Movement.RIGHT)
-
-    def rotate_counterclockwise(self):
-        self.rotate(Rotation.COUNTERCLOCKWISE)
-
-    def rotate_clockwise(self):
-        self.rotate(Rotation.CLOCKWISE)
-
-    def move_ghost(self):
-        self.ghost_piece.coord = self.current_piece.coord
-        self.ghost_piece.minoes_coords = self.current_piece.minoes_coords
-        while self.can_move(
-            self.ghost_piece.coord + Movement.DOWN,
-            self.ghost_piece.minoes_coords
-        ):
-            self.ghost_piece.coord += Movement.DOWN
-
-    def soft_drop(self):
-        if self.move(Movement.DOWN):
-            self.add_to_score(1)
-            return True
-        else:
-            return False
-
-    def hard_drop(self):
-        while self.move(Movement.DOWN, prelock=False):
-            self.add_to_score(2)
-        self.lock()
-
-    def fall(self):
-        self.move(Movement.DOWN)
-
-    def move(self, movement, prelock=True):
-        potential_coord = self.current_piece.coord + movement
-        if self.can_move(potential_coord, self.current_piece.minoes_coords):
-            if self.current_piece.prelocked:
-                self.scheduler.restart(self.lock, self.lock_delay)
-            self.current_piece.coord = potential_coord
-            if not movement == Movement.DOWN:
-                self.current_piece.last_rotation_point_used = None
-            self.move_ghost()
-            return True
-        else:
-            if (
-                prelock and not self.current_piece.prelocked
-                and movement == Movement.DOWN
-            ):
-                self.current_piece.prelocked = True
-                self.scheduler.start(self.lock, self.lock_delay)
-            return False
-
-    def rotate(self, direction):
-        rotated_minoes_coords = tuple(
-            Coord(direction*mino_coord.y, -direction*mino_coord.x)
-            for mino_coord in self.current_piece.minoes_coords
-        )
-        for rotation_point, liberty_degree in enumerate(
-            self.current_piece.SRS[direction][self.current_piece.orientation],
-            start = 1
-        ):
-            potential_coord = self.current_piece.coord + liberty_degree
-            if self.can_move(potential_coord, rotated_minoes_coords):
-                if self.current_piece.prelocked:
-                    self.scheduler.restart(self.lock, self.lock_delay)
-                self.current_piece.coord = potential_coord
-                self.current_piece.minoes_coords = rotated_minoes_coords
-                self.current_piece.orientation = (
-                    (self.current_piece.orientation + direction) % 4
-                )
-                self.current_piece.last_rotation_point_used = rotation_point
-                self.move_ghost()
-                return True
-        else:
-            return False
-
-    SCORES = (
-        {"name": "", T_Spin.NO_T_SPIN: 0, T_Spin.MINI_T_SPIN: 1, T_Spin.T_SPIN: 4},
-        {"name": "SINGLE", T_Spin.NO_T_SPIN: 1, T_Spin.MINI_T_SPIN: 2, T_Spin.T_SPIN: 8},
-        {"name": "DOUBLE", T_Spin.NO_T_SPIN: 3, T_Spin.MINI_T_SPIN: 12},
-        {"name": "TRIPLE", T_Spin.NO_T_SPIN: 5, T_Spin.T_SPIN: 16},
-        {"name": "TETRIS", T_Spin.NO_T_SPIN: 8}
-    )
-
-    def lock(self):
-        # Piece unlocked
-        if self.move(Movement.DOWN):
-            return
-
-        # Start lock
-        self.current_piece.prelocked = False
-        self.scheduler.stop(self.lock)
-        if self.pressed_actions:
-            self.stop_autorepeat()
-            self.scheduler.start(self.repeat_action, AUTOREPEAT_DELAY)
-
-        # Game over
-        if all(
-            (mino_coord + self.current_piece.coord).y >= NB_LINES
-            for mino_coord in self.current_piece.minoes_coords
-        ):
-            self.game_over()
-            return
-
-        # Insert tetromino in the matrix
-        for mino_coord in self.current_piece.minoes_coords:
-            coord = mino_coord + self.current_piece.coord
-            if coord.y <= NB_LINES+3:
-                self.matrix[coord.y][coord.x] = self.current_piece.MINOES_COLOR
-
-        # 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.matrix.append([None for x in range(NB_COLS)])
-        if nb_lines_cleared:
-            self.nb_lines += nb_lines_cleared
-
-        # T-Spin
-        if (
-            self.current_piece.CAN_SPIN
-            and self.current_piece.last_rotation_point_used 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_piece.last_rotation_point_used == 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_T_SPIN
-            else:
-                t_spin = T_Spin.NO_T_SPIN
-        else:
-            t_spin = T_Spin.NO_T_SPIN
-
-        # 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]["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))
-
-        if self.combo >= 1:
-            lock_strings.append("COMBO x%d" % self.combo)
-            ds = (20 if nb_lines_cleared==1 else 50) * self.combo * self.level
-            lock_score += ds
-            lock_strings.append(str(ds))
-
-        if lock_strings:
-            self.show_text("\n".join(lock_strings))
-
-        self.add_to_score(lock_score)
-
-        if self.goal <= 0:
-            self.new_level()
-        else:
-            self.new_current_piece()
-
-    def can_move(self, potential_coord, minoes_coords):
-        return all(
-            self.cell_is_free(potential_coord+mino_coord)
-            for mino_coord in minoes_coords
-        )
-
-    def cell_is_free(self, coord):
-        return (
-            0 <= coord.x < NB_COLS
-            and 0 <= coord.y
-            and not self.matrix[coord.y][coord.x]
-        )
-
-    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.current_piece.coord + self.T_SLOT_COORDS[
-            (self.current_piece.orientation + n) % 4
-        ]
-        return not self.cell_is_free(t_slot_coord)
-
-    def add_to_score(self, delta_score):
-        self.score += delta_score
-        if self.score > self.high_score:
-            self.high_score = self.score
-
-    def swap(self):
-        if self.current_piece.hold_enabled:
-            self.current_piece.hold_enabled = False
-            self.current_piece.prelocked = False
-            self.scheduler.stop(self.lock)
-            self.current_piece, self.held_piece = self.held_piece, self.current_piece
-            if self.held_piece.__class__ == Tetromino.I:
-                self.held_piece.coord = HELD_I_COORD
-            else:
-                self.held_piece.coord = HELD_PIECE_COORD
-            self.held_piece.minoes_coords = self.held_piece.MINOES_COORDS
-            if self.current_piece:
-                self.current_piece.coord = MATRIX_PIECE_INIT_COORD
-                self.ghost_piece = self.current_piece.ghost()
-                self.move_ghost()
-            else:
-                self.new_current_piece()
-
-    def pause(self):
-        self.state = State.PAUSED
-        self.scheduler.stop(self.fall)
-        self.scheduler.stop(self.lock)
-        self.scheduler.stop(self.update_time)
-        self.pressed_actions = []
-        self.stop_autorepeat()
-
-    def resume(self):
-        self.state = State.PLAYING
-        self.scheduler.start(self.fall, self.fall_delay)
-        if self.current_piece.prelocked:
-            self.scheduler.start(self.lock, self.lock_delay)
-        self.scheduler.start(self.update_time, 1)
-
-    def game_over(self):
-        self.state = State.OVER
-        self.scheduler.stop(self.fall)
-        self.scheduler.stop(self.update_time)
-        self.scheduler.stop(self.repeat_action)
-        self.save_high_score()
-
-    def update_time(self, delta_time=1):
-        self.time += delta_time
-
-    def do_action(self, action):
-        action()
-        if action in self.autorepeatable_actions:
-            self.stop_autorepeat()
-            self.pressed_actions.append(action)
-            self.scheduler.start(self.repeat_action, AUTOREPEAT_DELAY)
-
-    def repeat_action(self):
-        if self.pressed_actions:
-            self.pressed_actions[-1]()
-            if not self.auto_repeat:
-                self.auto_repeat = True
-                self.scheduler.restart(self.repeat_action, AUTOREPEAT_PERIOD)
-        else:
-            self.stop_autorepeat()
-
-    def remove_action(self, action):
-        if action in self.autorepeatable_actions:
-            try:
-                self.pressed_actions.remove(action)
-            except ValueError:
-                pass
-
-    def stop_autorepeat(self):
-        self.auto_repeat = False
-        self.scheduler.stop(self.repeat_action)
-
-    def show_text(self, text):
-        print(text)
-        raise Warning("TetrisLogic.show_text not implemented.")
-
-    def load_high_score(self):
-        self.high_score = 0
-        raise Warning(
-            """TetrisLogic.load_high_score not implemented.
-High score is set to 0"""
-        )
-
-    def save_high_score(self):
-        raise Warning(
-            """TetrisLogic.save_high_score not implemented.
-High score is not saved"""
-        )
-

tetrislogic/__init__.py

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+from .consts import NB_LINES, NB_COLS, NB_NEXT
+from .utils import Movement, Rotation, Color, Coord
+from .tetromino import Mino, Tetromino
+from .tetrislogic import TetrisLogic, State, Matrix

tetrislogic/consts.py

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+from .utils import Coord
+
+
+# Matrix
+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
+
+# Piece init coord
+MATRIX_PIECE_COORD = Coord(4, NB_LINES)
+NEXT_PIECE_COORDS = [Coord(NB_COLS + 4, NB_LINES - 4 * n - 3) for n in range(NB_NEXT)]
+HELD_PIECE_COORD = Coord(-5, NB_LINES - 3)

tetrislogic/tetrislogic.py

@@ -0,0 +1,422 @@
+# -*- coding: utf-8 -*-
+import random
+import pickle
+
+from .utils import Coord, Movement, Rotation, T_Spin
+from .tetromino import Tetromino, T_Tetrimino, I_Tetrimino
+from .consts import (
+    NB_LINES,
+    NB_COLS,
+    NB_NEXT,
+    LOCK_DELAY,
+    FALL_DELAY,
+    AUTOREPEAT_DELAY,
+    AUTOREPEAT_PERIOD,
+    MATRIX_PIECE_COORD,
+    NEXT_PIECE_COORDS,
+    HELD_PIECE_COORD,
+)
+
+
+LINES_CLEAR_NAME = "LINES_CLEAR_NAME"
+CRYPT_KEY = 987943759387540938469837689379857347598347598379584857934579343
+
+
+class State:
+
+    STARTING = "STARTING"
+    PLAYING = "PLAYING"
+    PAUSED = "PAUSED"
+    OVER = "OVER"
+
+
+class PieceContainer:
+
+    def __init__(self):
+        self.piece = None
+
+
+class HoldQueue(PieceContainer):
+    pass
+
+
+class Matrix(list, PieceContainer):
+
+    def __init__(self, *args, **kargs):
+        list.__init__(self, *args, **kargs)
+        PieceContainer.__init__(self)
+
+    def cell_is_free(self, coord):
+        return 0 <= coord.x < NB_COLS and 0 <= coord.y and not self[coord.y][coord.x]
+
+
+class NextQueue(PieceContainer):
+
+    def __init__(self):
+        super().__init__()
+        self.pieces = []
+
+
+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
+    MATRIX_PIECE_COORD = MATRIX_PIECE_COORD
+    NEXT_PIECE_COORDS = NEXT_PIECE_COORDS
+    HELD_PIECE_COORD = HELD_PIECE_COORD
+    random_bag = []
+
+    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):
+        return self._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)
+
+    def new_game(self):
+        self.level = 0
+        self.score = 0
+        self.nb_lines_cleared = 0
+        self.goal = 0
+        self.time = 0
+
+        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
+        self.goal += 5 * self.level
+        if self.level <= 20:
+            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 new_matrix_piece(self):
+        self.matrix.piece = self.next.pieces.pop(0)
+        self.matrix.piece.coord = self.MATRIX_PIECE_COORD
+        self.matrix.ghost = self.matrix.piece.ghost()
+        self.move_ghost()
+        self.next.pieces.append(self.new_tetromino())
+        self.next.pieces[-1].coord = self.NEXT_PIECE_COORDS[-1]
+        for tetromino, coord in zip(self.next.pieces, self.NEXT_PIECE_COORDS):
+            tetromino.coord = coord
+
+        if not self.can_move(self.matrix.piece.coord, (mino.coord for mino in self.matrix.piece)):
+            self.game_over()
+
+    def move_left(self):
+        self.move(Movement.LEFT)
+
+    def move_right(self):
+        self.move(Movement.RIGHT)
+
+    def rotate_clockwise(self):
+        self.rotate(Rotation.CLOCKWISE)
+
+    def rotate_counter(self):
+        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.score += 1
+        return moved
+
+    def hard_drop(self):
+        while self.move(Movement.DOWN, prelock=False):
+            self.score += 2
+        self.lock()
+
+    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
+
+        # Game over
+        if all((mino.coord + self.matrix.piece.coord).y >= self.NB_LINES for mino in self.matrix.piece):
+            self.game_over()
+            return
+
+        if self.pressed_actions:
+            self.auto_repeat = False
+            self.restart(self.repeat_action, self.AUTOREPEAT_DELAY)
+
+        # 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
+
+        self.enter_the_matrix()
+
+        # 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.remove_line(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 enter_the_matrix(self):
+        for mino in self.matrix.piece:
+            coord = mino.coord + self.matrix.piece.coord
+            if coord.y <= self.NB_LINES + 3:
+                self.matrix[coord.y][coord.x] = mino
+
+    def remove_line(self, y):
+        self.matrix.pop(y)
+
+    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]
+        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_PIECE_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.MATRIX_PIECE_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.auto_repeat = False
+        self.stop(self.repeat_action)
+
+    def resume(self):
+        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()
+
+    def stop_all(self):
+        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.fall_delay / 20
+            else:
+                delay = self.AUTOREPEAT_DELAY
+            self.restart(self.repeat_action, delay)
+
+    def repeat_action(self):
+        if self.pressed_actions:
+            self.pressed_actions[-1]()
+            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:
+            try:
+                self.pressed_actions.remove(action)
+            except ValueError:
+                pass
+
+    def show_text(self, text):
+        print(text)
+        raise Warning("TetrisLogic.show_text not implemented.")
+
+    def load_high_score(self, crypted_high_score=None):
+        if crypted_high_score:
+            crypted_high_score = int(pickle.loads(crypted_high_score))
+            self.high_score = crypted_high_score ^ CRYPT_KEY
+        else:
+            raise Warning(
+                """TetrisLogic.load_high_score not implemented.
+High score is set to 0"""
+            )
+            self.high_score = 0
+
+    def save_high_score(self):
+        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

@@ -0,0 +1,107 @@
+# -*- coding: utf-8 -*-
+from .utils import Coord, Rotation, Color
+
+
+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)
+
+
+class Tetromino(list):
+
+    shapes = []
+    # Super rotation system
+    SRS = {
+        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)),
+        ),
+        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)),
+            (Coord(0, 0), Coord(-1, 0), Coord(-1, -1), Coord(0, 2), Coord(-1, 2)),
+        ),
+    }
+
+    def __init__(self):
+        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
+        self.prelocked = False
+
+    def ghost(self):
+        return type(self)()
+
+
+class O_Tetrimino(Tetromino, metaclass=MetaTetromino):
+
+    SRS = {
+        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
+
+    def rotate(self, direction):
+        return False
+
+
+class I_Tetrimino(Tetromino, metaclass=MetaTetromino):
+
+    SRS = {
+        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)),
+        ),
+        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)),
+            (Coord(1, 0), Coord(-1, 0), Coord(2, 0), Coord(-1, -1), Coord(2, 2)),
+        ),
+    }
+    MINOES_COORDS = (Coord(-1, 0), Coord(0, 0), Coord(1, 0), Coord(2, 0))
+    MINOES_COLOR = Color.CYAN
+
+
+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(Tetromino, metaclass=MetaTetromino):
+
+    MINOES_COORDS = (Coord(-1, 0), Coord(0, 0), Coord(1, 0), Coord(1, 1))
+    MINOES_COLOR = Color.ORANGE
+
+
+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(Tetromino, metaclass=MetaTetromino):
+
+    MINOES_COORDS = (Coord(-1, 0), Coord(0, 0), Coord(0, 1), Coord(1, 1))
+    MINOES_COLOR = Color.GREEN
+
+
+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

@@ -0,0 +1,39 @@
+# -*- 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)
+
+
+class Movement:
+
+    LEFT = Coord(-1, 0)
+    RIGHT = Coord(1, 0)
+    DOWN = Coord(0, -1)
+
+
+class Rotation:
+
+    CLOCKWISE = 1
+    COUNTER = -1
+
+
+class T_Spin:
+
+    NONE = ""
+    MINI = "MINI\nT-SPIN"
+    T_SPIN = "T-SPIN"
+
+
+class Color:
+
+    BLUE = 0
+    CYAN = 1
+    GREEN = 2
+    MAGENTA = 3
+    ORANGE = 4
+    RED = 5
+    YELLOW = 6