music pause

README.md

@@ -1,7 +1,14 @@
 # Terminis
+
 Tetris clone for terminal. Ideal for servers without GUI!
 
-## Install
+## Requirements
+
+[Python 2 or 3](https://www.python.org/)
+
+beep command to play music with internal speaker
+
+## Installation
 
 ```bash
 pip install --user terminis
@@ -12,7 +19,8 @@ pip install --user terminis
 ```bash
 terminis [options]
 ```
-* --help: show command usage (this message)
+
-* --edit: edit controls in text editor
+- --help -h: show command usage (this message)
-* --reset: reset to default controls settings
+- --edit -e: edit controls in text editor
-* --level=n: start at level n (integer between 1 and 15)
+- --reset -r: reset to default controls settings
+- --level=n: start at level n (integer between 1 and 15)

pyproject.toml

@@ -1,11 +1,11 @@
 [tool.poetry]
 name = "terminis"
-version = "0.2.2"
+version = "0.2.4.2"
 description = "Tetris clone for terminal. Ideal for servers without GUI!"
 authors = ["adrienmalin <41926238+adrienmalin@users.noreply.github.com>"]
 license = "MIT"
 repository = "https://github.com/adrienmalin/Terminis"
-keywords = ["Tetris", "terminal", "curses"]
+keywords = ["Tetris", "terminal", "curses","beep"]
 classifiers = [
     "Environment :: Console :: Curses",
     "Programming Language :: Python",
@@ -16,6 +16,7 @@ classifiers = [
     "Topic :: System :: Systems Administration"
 ]
 readme = "README.md"
+include = ["music.sh"]
 
 [tool.poetry.dependencies]
 python = ">=2.7"

terminis/terminis.py

@@ -1,6 +1,11 @@
+
+
 # -*- coding: utf-8 -*-
 
 import sys
+import os
+import subprocess
+import signal
 
 try:
     import curses
@@ -11,7 +16,7 @@ You can install it on Windows with:
 pip install --user windows-curses"""
     )
 else:
-    curses.COLOR_ORANGE = 8
+    curses.COLOR_ORANGE = curses.COLOR_WHITE
     
 import random
 import sched
@@ -21,27 +26,22 @@ import locale
 import subprocess
 
 try:
-    import configparser
+    from configparser import ConfigParser
 except ImportError:
-    import ConfigParser as configparser
+    try:
-
+        from configparser import SafeConfigParser as ConfigParser
+    except ImportError: # Python2
+        import ConfigParser
 
 DIR_NAME = "Terminis"
 HELP_MSG = """terminis [options]
 
 Tetris clone for terminal
 
-  --help\tshow command usage (this message)
+  --help\t-h\tshow command usage (this message)
-  --edit\tedit controls in text editor
+  --edit\t-e\tedit controls in text editor
-  --reset\treset to default controls settings
+  --reset\t-r\treset to default controls settings
-  --level=n\tstart at level n (integer between 1 and 15)"""
+  --level=n\t\tstart at level n (integer between 1 and 15)"""
-
-
-locale.setlocale(locale.LC_ALL, '')
-if locale.getpreferredencoding() == 'UTF-8':
-    os.environ["NCURSES_NO_UTF8_ACS"] = "1"
-
-scheduler = sched.scheduler(time.time, lambda delay: curses.napms(int(delay*1000)))
 
 
 class Rotation:
@@ -62,7 +62,33 @@ class Movement:
     LEFT  = Point(-1, 0)
     RIGHT = Point(1, 0)
     DOWN  = Point(0, 1)
-    STILL = Point(0, 0)
+
+
+class Scheduler(sched.scheduler, dict):
+    def __init__(self):
+        sched.scheduler.__init__(self, time.time, time.sleep)
+        dict.__init__(self)
+        
+    def repeat(self, name, delay, action, args=tuple()):
+        self[name] = sched.scheduler.enter(self, delay, 1, self._repeat, (name, delay, action, args))
+        
+    def _repeat(self, name, delay, action, args):
+        del(self[name])
+        self.repeat(name, delay, action, args)
+        action(*args)
+        
+    def single_shot(self, name, delay, action, args=tuple()):
+        self[name] = sched.scheduler.enter(self, delay, 1, self._single_shot, (name, action, args))
+        
+    def _single_shot(self, name, action, args):
+        del(self[name])
+        action(*args)
+        
+    def cancel(self, name):
+        if name in self:
+            sched.scheduler.cancel(self, self.pop(name))
+
+scheduler = Scheduler()
 
 
 class Tetromino:
@@ -91,63 +117,52 @@ class Tetromino:
     def __init__(self, matrix, position):
         self.matrix = matrix
         self.position = position
-        self.minoes_position = self.MINOES_POSITIONS
+        self.minoes_positions = self.MINOES_POSITIONS
         self.orientation = 0
         self.rotation_point_5_used = False
         self.rotated_last = False
-        self.lock_timer = None
-        self.fall_timer = None
         self.hold_enabled = True
         
-    def possible_position(self, minoes_position, movement):
+    def move_rotate(self, movement, minoes_positions):
         potential_position = self.position + movement
         if all(
-            self.matrix.is_free_cell(mino_position+potential_position)
+            self.matrix.is_free_cell(potential_position+mino_position)
-            for mino_position in minoes_position
+            for mino_position in minoes_positions
         ):
-            return potential_position
+            self.position = potential_position
+            if "lock" in scheduler:
+                scheduler.cancel("lock")
+                scheduler.single_shot("lock", self.lock_delay, self.matrix.lock)
+            return True
         else:
-            return None
+            return False
         
-    def move(self, movement, lock=True):
+    def move(self, movement, lock=True, refresh=True):
-        possible_position = self.possible_position(self.minoes_position, movement)
+        if self.move_rotate(movement, self.minoes_positions):
-        if possible_position:
-            self.position = possible_position
-            self.postpone_lock()
             self.rotated_last = False
+            if refresh:
                 self.matrix.refresh()
             return True
         else:
-            if lock and movement == Movement.DOWN:
+            if (
-                self.locking()
+                lock
+                and movement == Movement.DOWN
+                and "lock" not in scheduler
+            ):
+                scheduler.single_shot("lock", self.lock_delay, self.matrix.lock)
+                self.matrix.refresh()
             return False
 
-    def soft_drop(self):
-        if self.move(Movement.DOWN):
-            self.matrix.game.stats.piece_dropped(1)
-
-    def hard_drop(self):
-        if self.lock_timer:
-            self.lock_timer = scheduler.cancel(self.lock_timer)
-        lines = 0
-        while self.move(Movement.DOWN, lock=False):
-            lines += 2
-        self.matrix.game.stats.piece_dropped(lines)
-        self.lock()
-
     def rotate(self, direction):
-        potential_minoes_positions = tuple(
+        rotated_minoes_positions = tuple(
             Point(-direction*mino_position.y, direction*mino_position.x)
-            for mino_position in self.minoes_position
+            for mino_position in self.minoes_positions
         )
         for rotation_point, liberty_degree in enumerate(self.SUPER_ROTATION_SYSTEM[self.orientation][direction], start=1):
-            possible_position = self.possible_position(potential_minoes_positions, liberty_degree)
+            if self.move_rotate(liberty_degree, rotated_minoes_positions):
-            if possible_position:
+                self.minoes_positions = rotated_minoes_positions
                 self.orientation = (self.orientation+direction) % 4
-                self.position = possible_position
+                self.rotated_last = False
-                self.minoes_position = potential_minoes_positions
-                self.postpone_lock()
-                self.rotated_last = True
                 if rotation_point == 5:
                     self.rotation_point_5_used = True
                 self.matrix.refresh()
@@ -155,32 +170,27 @@ class Tetromino:
         else:
             return False
 
-    def fall(self):
+    def soft_drop(self):
-        self.fall_timer = scheduler.enter(self.fall_delay, 2, self.fall, tuple())
+        if self.move(Movement.DOWN):
-        self.move(Movement.DOWN)
+            self.matrix.game.stats.piece_dropped(1)
 
-    def locking(self):
+    def hard_drop(self):
-        if not self.lock_timer:
+        lines = 0
-            self.lock_timer = scheduler.enter(self.lock_delay, 1, self.lock, tuple())
+        while self.move(Movement.DOWN, lock=False, refresh=False):
+            lines += 2
         self.matrix.refresh()
+        self.matrix.game.stats.piece_dropped(lines)
+        self.matrix.lock()
         
-    def postpone_lock(self):
+    def fall(self):
-        if self.lock_timer:
+        self.move(Movement.DOWN)
-            scheduler.cancel(self.lock_timer)
-            self.lock_timer = scheduler.enter(self.lock_delay, 1, self.lock, tuple())
-
-    def lock(self):
-        self.lock_timer = None
-        if not self.possible_position(self.minoes_position, Movement.DOWN):
-            if self.fall_timer:
-                self.fall_timer = scheduler.cancel(self.fall_timer)
-            self.matrix.lock(self.t_spin())
 
     def t_spin(self):
         return ""
 
 
 class O(Tetromino):
+    SUPER_ROTATION_SYSTEM = tuple()
     MINOES_POSITIONS = (Point(0, 0), Point(1, 0), Point(0, -1), Point(1, -1))
     COLOR = curses.COLOR_YELLOW
 
@@ -248,7 +258,8 @@ class Window:
     def __init__(self, width, height, begin_x, begin_y):
         self.window = curses.newwin(height, width, begin_y, begin_x)
         if self.TITLE:
-            self.title_begin_x = (width-len(self.TITLE)) // 2 + 1
+            self.title = "[" + self.TITLE + "]"
+            self.title_begin_x = (width-len(self.title)) // 2 + 1
         self.piece = None
         self.refresh()
 
@@ -256,15 +267,15 @@ class Window:
         self.window.erase()
         self.window.border()
         if self.TITLE:
-            self.window.addstr(0, self.title_begin_x, self.TITLE, curses.A_BOLD)
+            self.window.addstr(0, self.title_begin_x, self.title, curses.A_BOLD)
 
     def draw_piece(self):
         if self.piece:
-            if self.piece.lock_timer:
+            if "lock" in scheduler:
                 attr = self.piece.color_pair | curses.A_BLINK | curses.A_REVERSE
             else:
                 attr = self.piece.color_pair
-            for mino_position in self.piece.minoes_position:
+            for mino_position in self.piece.minoes_positions:
                 position = mino_position + self.piece.position
                 self.draw_mino(position.x, position.y, attr)
 
@@ -276,9 +287,9 @@ class Window:
 class Matrix(Window):
     NB_COLS = 10
     NB_LINES = 21
-    WIDTH = NB_COLS*2+2
+    WIDTH = NB_COLS*2 + 2
-    HEIGHT = NB_LINES+1
+    HEIGHT = NB_LINES + 1
-    PIECE_POSITION = Point(4, 0)
+    PIECE_POSITION = Point(4, -1)
     TITLE = ""
 
     def __init__(self, game, begin_x, begin_y):
@@ -289,6 +300,7 @@ class Matrix(Window):
             [None for x in range(self.NB_COLS)]
             for y in range(self.NB_LINES)
         ]
+        self.piece = None
         Window.__init__(self, self.WIDTH, self.HEIGHT, begin_x, begin_y)
 
     def refresh(self, paused=False):
@@ -310,8 +322,13 @@ class Matrix(Window):
             and not (position.y >= 0 and self.cells[position.y][position.x] is not None)
         )
 
-    def lock(self, t_spin):
+    def lock(self):
-        for mino_position in self.piece.minoes_position:
+        if not self.piece.move(Movement.DOWN):
+            scheduler.cancel("fall")
+            
+            t_spin = self.piece.t_spin()
+            
+            for mino_position in self.piece.minoes_positions:
                 position = mino_position + self.piece.position
                 if position.y >= 0:
                     self.cells[position.y][position.x] = self.piece.color_pair
@@ -327,7 +344,8 @@ class Matrix(Window):
                     nb_lines_cleared += 1
                     
             self.game.stats.piece_locked(nb_lines_cleared, t_spin)
-        self.game.start_next_piece()
+            self.piece = None
+            self.game.new_piece()
 
 
 class HoldNext(Window):
@@ -354,17 +372,16 @@ class Next(HoldNext):
 
 class Stats(Window):
     SCORES = (
-        {"": 0, "MINI T-SPIN": 1, "T-SPIN": 4},
+        {"name": "", "": 0, "MINI T-SPIN": 1, "T-SPIN": 4},
-        {"": 1, "MINI T-SPIN": 2, "T-SPIN": 8},
+        {"name": "SINGLE", "": 1, "MINI T-SPIN": 2, "T-SPIN": 8},
-        {"": 3, "T-SPIN": 12},
+        {"name": "DOUBLE", "": 3, "T-SPIN": 12},
-        {"": 5, "T-SPIN": 16},
+        {"name": "TRIPLE", "": 5, "T-SPIN": 16},
-        {"": 8}
+        {"name": "TETRIS", "": 8}
     )
-    LINES_CLEARED_NAMES = ("", "SINGLE", "DOUBLE", "TRIPLE", "TETRIS")
     TITLE = "STATS"
     FILE_NAME = ".high_score"
     if sys.platform == "win32":
-        DIR_PATH = os.environ.get("appdata", os.path.expanduser("~\Appdata\Roaming"))
+        DIR_PATH = os.environ.get("appdata", os.path.expanduser(r"~\Appdata\Roaming"))
     else:
         DIR_PATH = os.environ.get("XDG_DATA_HOME", os.path.expanduser("~/.local/share"))
     DIR_PATH = os.path.join(DIR_PATH, DIR_NAME)
@@ -398,7 +415,6 @@ class Stats(Window):
         self.combo = -1
         self.time = time.time()
         self.lines_cleared = 0
-        self.clock_timer = None
         self.strings = []
         Window.__init__(self, width, height, begin_x, begin_y)
         self.new_level()
@@ -407,23 +423,22 @@ class Stats(Window):
         self.draw_border()
         self.window.addstr(2, 2, "SCORE\t{:n}".format(self.score))
         if self.score >= self.high_score:
-            self.window.addstr(3, 2, "HIGH\t{:n}".format(self.high_score), curses.A_BLINK|curses.A_BOLD)
+            self.window.addstr(3, 2, "HIGH\t{:n}".format(self.high_score), curses.A_BLINK | curses.A_BOLD)
         else:
             self.window.addstr(3, 2, "HIGH\t{:n}".format(self.high_score))
-        t = time.localtime(time.time() - self.time)
-        self.window.addstr(4, 2, "TIME\t%02d:%02d:%02d" % (t.tm_hour-1, t.tm_min, t.tm_sec))
         self.window.addstr(5, 2, "LEVEL\t%d" % self.level)
         self.window.addstr(6, 2, "GOAL\t%d" % self.goal)
         self.window.addstr(7, 2, "LINES\t%d" % self.lines_cleared)
         start_y = self.height - len(self.strings) - 2
         for y, string in enumerate(self.strings, start=start_y):
-            x = (self.width-len(string)) // 2 + 1
+            x = (self.width - len(string)) // 2 + 1
             self.window.addstr(y, x, string)
-        self.window.refresh()
+        self.refresh_time()
         
-    def clock(self):
+    def refresh_time(self):
-        self.clock_timer = scheduler.enter(1, 3, self.clock, tuple())
+        t = time.localtime(time.time() - self.time)
-        self.refresh()
+        self.window.addstr(4, 2, "TIME\t%02d:%02d:%02d" % (t.tm_hour-1, t.tm_min, t.tm_sec))
+        self.window.refresh()
 
     def new_level(self):
         self.level += 1
@@ -446,7 +461,7 @@ class Stats(Window):
         if t_spin:
             self.strings.append(t_spin)
         if nb_lines:
-            self.strings.append(self.LINES_CLEARED_NAMES[nb_lines])
+            self.strings.append(self.SCORES[nb_lines]["name"])
             self.combo += 1
         else:
             self.combo = -1
@@ -485,10 +500,10 @@ class Stats(Window):
             print(e)
 
 
-class ControlsParser(configparser.SafeConfigParser):
+class ControlsParser(ConfigParser):
     FILE_NAME = "config.cfg"
     if sys.platform == "win32":
-        DIR_PATH = os.environ.get("appdata", os.path.expanduser("~\Appdata\Roaming"))
+        DIR_PATH = os.environ.get("appdata", os.path.expanduser(r"~\Appdata\Roaming"))
     else:
         DIR_PATH = os.environ.get("XDG_CONFIG_HOME", os.path.expanduser("~/.config"))
     DIR_PATH = os.path.join(DIR_PATH, DIR_NAME)
@@ -496,9 +511,9 @@ class ControlsParser(configparser.SafeConfigParser):
     SECTION = "CONTROLS"
     COMMENT = """# You can change key below.
 # Acceptable values are:
-# `SPACE`, `TAB`, `ENTER`,
+# - `SPACE`, `TAB`, `ENTER`,
-# printable characters (`q`, `*`...) (case sensitive),
+# - printable characters (`q`, `*`...) (case sensitive),
-# curses's constants name starting with `KEY_`
+# - curses's constants name starting with `KEY_`
 # See https://docs.python.org/3/library/curses.html?highlight=curses#constants
 
 """
@@ -515,7 +530,7 @@ class ControlsParser(configparser.SafeConfigParser):
     }
 
     def __init__(self):
-        configparser.SafeConfigParser.__init__(self)
+        ConfigParser.__init__(self)
         self.optionxform = str
         self.add_section(self.SECTION)
         for action, key in self.DEFAULTS.items():
@@ -574,6 +589,43 @@ class ControlsWindow(Window, ControlsParser):
         self.window.refresh()
 
 
+class Music:
+    def __init__(self):
+        self.process = None
+
+    def play(self):
+        try:
+            self.process = subprocess.Popen(["beep", "-l400", "-f659", "-n", "-l200", "-f493", "-n", "-l200", "-f523", "-n", "-l200", "-f587", "-n", "-l100", "-f659", "-n", "-l100", "-f587", "-n", "-l200", "-f523", "-n", "-l200", "-f493", "-n", "-l400", "-f440", "-n", "-l200", "-f440", "-n", "-l200", "-f523", "-n", "-l400", "-f659", "-n", "-l200", "-f587", "-n", "-l200", "-f523", "-n", "-l200", "-f493", "-n", "-l200", "-f329", "-n", "-l200", "-f415", "-n", "-l200", "-f523", "-n", "-l400", "-f587", "-n", "-l400", "-f659", "-n", "-l400", "-f523", "-n", "-l400", "-f440", "-n", "-l400", "-f440", "-n", "-l200", "-f246", "-n", "-l200", "-f261", "-n", "-l600", "-f587", "-n", "-l200", "-f698", "-n", "-l200", "-f880", "-n", "-l100", "-f880", "-n", "-l100", "-f880", "-n", "-l200", "-f783", "-n", "-l200", "-f698", "-n", "-l400", "-f659", "-n", "-l200", "-f659", "-n", "-l200", "-f523", "-n", "-l200", "-f659", "-n", "-l100", "-f698", "-n", "-l100", "-f659", "-n", "-l200", "-f587", "-n", "-l200", "-f523", "-n", "-l200", "-f493", "-n", "-l200", "-f329", "-n", "-l200", "-f415", "-n", "-l200", "-f523", "-n", "-l400", "-f587", "-n", "-l400", "-f659", "-n", "-l400", "-f523", "-n", "-l400", "-f440", "-n", "-l800", "-f440", "-n", "-l400", "-f659", "-n", "-l200", "-f493", "-n", "-l200", "-f523", "-n", "-l200", "-f587", "-n", "-l100", "-f659", "-n", "-l100", "-f587", "-n", "-l200", "-f523", "-n", "-l200", "-f493", "-n", "-l400", "-f440", "-n", "-l200", "-f440", "-n", "-l200", "-f523", "-n", "-l400", "-f659", "-n", "-l200", "-f587", "-n", "-l200", "-f523", "-n", "-l200", "-f493", "-n", "-l200", "-f329", "-n", "-l200", "-f415", "-n", "-l200", "-f523", "-n", "-l400", "-f587", "-n", "-l400", "-f659", "-n", "-l400", "-f523", "-n", "-l400", "-f440", "-n", "-l400", "-f440", "-n", "-l200", "-f246", "-n", "-l200", "-f261", "-n", "-l600", "-f587", "-n", "-l200", "-f698", "-n", "-l200", "-f880", "-n", "-l100", "-f880", "-n", "-l100", "-f880", "-n", "-l200", "-f783", "-n", "-l200", "-f698", "-n", "-l400", "-f659", "-n", "-l200", "-f659", "-n", "-l200", "-f523", "-n", "-l200", "-f659", "-n", "-l100", "-f698", "-n", "-l100", "-f659", "-n", "-l200", "-f587", "-n", "-l200", "-f523", "-n", "-l200", "-f493", "-n", "-l200", "-f329", "-n", "-l200", "-f415", "-n", "-l200", "-f523", "-n", "-l400", "-f587", "-n", "-l400", "-f659", "-n", "-l400", "-f523", "-n", "-l400", "-f440", "-n", "-l800", "-f440", "-n", "-l800", "-f329", "-n", "-l800", "-f261", "-n", "-l800", "-f293", "-n", "-l800", "-f246", "-n", "-l800", "-f261", "-n", "-l800", "-f220", "-n", "-l800", "-f207", "-n", "-l200", "-f246", "-n", "-l200", "-f164", "-n", "-l200", "-f207", "-n", "-l200", "-f246", "-n", "-l800", "-f329", "-n", "-l800", "-f261", "-n", "-l800", "-f293", "-n", "-l800", "-f246", "-n", "-l400", "-f261", "-n", "-l400", "-f329", "-n", "-l400", "-f440", "-n", "-l400", "-f440", "-n", "-l1600", "-f415"])
+        except FileNotFoundError:
+            pass
+        else:
+            scheduler.repeat("music", 0.02, self.repeat)
+
+    def repeat(self):
+        if self.process:
+            if self.process.poll() is not None:
+                self.play()
+        else:
+            scheduler.cancel("music")
+
+    def pause(self):
+        if self.process:
+            scheduler.cancel("music")
+            self.process.send_signal(signal.SIGSTOP)
+            subprocess.Popen(["beep", "-l1", "-f1"])
+            scheduler.repeat("music", 0.02, self.repeat)
+
+    def resume(self):
+        if self.process:
+            self.process.send_signal(signal.SIGCONT)
+
+    def stop(self):
+        if self.process:
+            scheduler.cancel("music")
+            self.process.terminate()
+            self.process = None
+
+
 class Game:
     WIDTH = 80
     HEIGHT = Matrix.HEIGHT
@@ -585,12 +637,12 @@ class Game:
             curses.start_color()
             if curses.can_change_color():
                 curses.init_color(curses.COLOR_YELLOW, 1000, 500, 0)
-            for tetromino_class in self.TETROMINOES: 
+            for tetromino in self.TETROMINOES: 
-                curses.init_pair(tetromino_class.COLOR, tetromino_class.COLOR, curses.COLOR_WHITE)
+                curses.init_pair(tetromino.COLOR, tetromino.COLOR, curses.COLOR_WHITE)
-                if tetromino_class.COLOR == curses.COLOR_ORANGE:
+                if tetromino.COLOR == curses.COLOR_ORANGE:
-                    tetromino_class.color_pair = curses.color_pair(curses.COLOR_YELLOW)
+                    tetromino.color_pair = curses.color_pair(curses.COLOR_YELLOW)
                 else:
-                    tetromino_class.color_pair = curses.color_pair(tetromino_class.COLOR)|curses.A_BOLD
+                    tetromino.color_pair = curses.color_pair(tetromino.COLOR) | curses.A_BOLD
         try:
             curses.curs_set(0)
         except curses.error:
@@ -611,6 +663,7 @@ class Game:
         self.next = Next(side_width, right_x, top_y)
         self.stats = Stats(self, side_width, side_height, left_x, bottom_y)
         self.controls = ControlsWindow(side_width, side_height, right_x, bottom_y)
+        self.music = Music()
 
         self.actions = {
             self.controls["QUIT"]: self.quit,
@@ -624,14 +677,13 @@ class Game:
             self.controls["HARD DROP"]: lambda: self.matrix.piece.hard_drop()
         }
 
-        self.playing = True
         self.paused = False
-        self.stats.time = time.time()
-        self.stats.clock_timer = scheduler.enter(1, 3, self.stats.clock, tuple())
         self.random_bag = []
         self.next.piece = self.random_piece()
-        self.start_next_piece()
+        self.new_piece()
-        self.input_timer = scheduler.enter(self.AUTOREPEAT_DELAY, 2, self.process_input, tuple())
+        scheduler.repeat("time", 1, self.stats.refresh_time)
+        scheduler.repeat("input", self.AUTOREPEAT_DELAY, self.process_input)
+        self.music.play()
 
         try:
             scheduler.run()
@@ -644,22 +696,19 @@ class Game:
             random.shuffle(self.random_bag)
         return self.random_bag.pop()(self.matrix, Next.PIECE_POSITION)
 
-    def start_next_piece(self):
+    def new_piece(self):
-        self.matrix.piece = self.next.piece
+        scheduler.cancel("lock")
-        self.next.piece = self.random_piece()
+        if not self.matrix.piece:
+            self.matrix.piece, self.next.piece = self.next.piece, self.random_piece()
             self.next.refresh()
-        self.start_piece()
-            
-    def start_piece(self):
         self.matrix.piece.position = Matrix.PIECE_POSITION
-        if self.matrix.piece.possible_position(self.matrix.piece.minoes_position, Movement.STILL):
+        if self.matrix.piece.move(Movement.DOWN):
-            self.matrix.piece.fall_timer = scheduler.enter(Tetromino.fall_delay, 2, self.matrix.piece.fall, tuple())
+            scheduler.repeat("fall", Tetromino.fall_delay, self.matrix.piece.fall)
             self.matrix.refresh()
         else:
             self.over()
 
     def process_input(self):
-        self.input_timer = scheduler.enter(self.AUTOREPEAT_DELAY, 2, self.process_input, tuple())
         try:
             action = self.actions[self.scr.getkey()]
         except (curses.error, KeyError):
@@ -674,6 +723,7 @@ class Game:
         self.matrix.refresh(paused=True)
         self.next.refresh(paused=True)
         self.scr.timeout(-1)
+        self.music.pause()
         
         while True:
             key = self.scr.getkey()
@@ -681,76 +731,75 @@ class Game:
                 self.quit()
                 break
             elif key == self.controls["PAUSE"]:
+                break
+
         self.scr.timeout(0)
         self.hold.refresh()
         self.matrix.refresh()
         self.next.refresh()
         self.stats.time = time.time() - self.stats.time
-                break
+        self.music.resume()
 
     def swap(self):
         if self.matrix.piece.hold_enabled:
-            if self.matrix.piece.fall_timer:
+            scheduler.cancel("fall")
-                self.matrix.piece.fall_timer = scheduler.cancel(self.matrix.piece.fall_timer)
+            scheduler.cancel("lock")
-            if self.matrix.piece.lock_timer:
-                self.matrix.piece.lock_timer = scheduler.cancel(self.matrix.piece.lock_timer)
-                
             self.matrix.piece, self.hold.piece = self.hold.piece, self.matrix.piece
             self.hold.piece.position = self.hold.PIECE_POSITION
-            self.hold.piece.minoes_position = self.hold.piece.MINOES_POSITIONS
+            self.hold.piece.minoes_positions = self.hold.piece.MINOES_POSITIONS
             self.hold.piece.hold_enabled = False
             self.hold.refresh()
-            
+            self.new_piece()
-            if self.matrix.piece:
-                self.start_piece()
-            else:
-                self.start_next_piece()
 
     def over(self):
-        self.matrix.refresh()
+        self.stats.time = time.time() - self.stats.time
         if curses.has_colors():
-            for tetromino_class in self.TETROMINOES: 
+            for tetromino in self.TETROMINOES:
-                curses.init_pair(tetromino_class.COLOR, tetromino_class.COLOR, curses.COLOR_BLACK)
+                curses.init_pair(tetromino.COLOR, tetromino.COLOR, curses.COLOR_BLACK if tetromino.COLOR == curses.COLOR_YELLOW else curses.COLOR_WHITE)
-        for y, word in enumerate((("GA", "ME") ,("OV", "ER")), start=Matrix.NB_LINES//2):
+        for y, word in enumerate((("GA", "ME") ,("OV", "ER")), start=Matrix.NB_LINES // 2):
-            for x, syllable in enumerate(word, start=Matrix.NB_COLS//2-1):
+            for x, syllable in enumerate(word, start=Matrix.NB_COLS//2 - 1):
                 color = self.matrix.cells[y][x]
-                if color is None:
+                self.matrix.window.addstr(y, 2*x + 1, syllable, (color | curses.A_REVERSE) if color else curses.COLOR_BLACK)
-                    color = curses.COLOR_BLACK
-                else:
-                    color |= curses.A_REVERSE
-                self.matrix.window.addstr(y, x*2+1, syllable, color)
         self.matrix.window.refresh()
         curses.beep()
         self.scr.timeout(-1)
+        self.music.stop()
+
         while self.scr.getkey() != self.controls["QUIT"]:
             pass
+
         self.quit()
 
     def quit(self):
-        self.playing = False
-        if self.matrix.piece.fall_timer:
-            self.matrix.piece.fall_timer = scheduler.cancel(self.matrix.piece.fall_timer)
-        if self.matrix.piece.lock_timer:
-            self.matrix.piece.lock_timer = scheduler.cancel(self.matrix.piece.lock_timer)
-        if self.stats.clock_timer:
-            self.stats.clock_timer = scheduler.cancel(self.stats.clock_timer)
-        if self.input_timer:
-            self.input_timer = scheduler.cancel(self.input_timer)
         self.stats.save()
+        self.music.stop()
+        t = time.localtime(time.time() - self.stats.time)
+        sys.exit(
+            "SCORE\t{:n}\n".format(self.stats.score) +
+            "HIGH\t{:n}\n".format(self.stats.high_score) +
+            "TIME\t%02d:%02d:%02d\n" % (t.tm_hour-1, t.tm_min, t.tm_sec) +
+            "LEVEL\t%d\n" % self.stats.level +
+            "LINES\t%d" % self.stats.lines_cleared
+        )
 
 
 def main():
-    if "--help" in sys.argv[1:] or "/?" in sys.argv[1:]:
+    if "--help" in sys.argv[1:] or "-h" in sys.argv[1:] or "/?" in sys.argv[1:]:
         print(HELP_MSG)
     else:
-        if "--reset" in sys.argv[1:]:
+        if "-reset" in sys.argv[1:] or "-r" in sys.argv[1:]:
             controls = ControlsParser()
             controls.reset()
             controls.edit()
-        elif "--edit" in sys.argv[1:]:
+        elif "--edit" in sys.argv[1:] or "-e" in sys.argv[1:]:
             ControlsParser().edit()
+            
+        locale.setlocale(locale.LC_ALL, '')
+        if locale.getpreferredencoding() == 'UTF-8':
+            os.environ["NCURSES_NO_UTF8_ACS"] = "1"
         curses.wrapper(Game)
 
 
 if __name__ == "__main__":
     main()
+