# -*- coding: utf-8 -*- import pickle from .utils import Coord, Movement, Spin, T_Spin, T_Slot from .tetromino import Tetromino, T_Tetrimino from .consts import ( ROWS, COLLUMNS, NEXT_PIECES, LOCK_DELAY, FALL_DELAY, AUTOREPEAT_DELAY, AUTOREPEAT_PERIOD, MATRIX_PIECE_COORD, SCORES, LINES_CLEAR_NAME, ) CRYPT_KEY = 987943759387540938469837689379857347598347598379584857934579343 class AbstractScheduler: """Scheduler to implement""" def postpone(task, delay): """Schedule callable once after delay in seconds""" raise Warning("AbstractTimer.postpone is not implemented.") def cancel(self, task): """Unschedule task or pass if task is not scheduled""" raise Warning("AbstractTimer.stop is not implemented.") def reset(self, task, delay): """Cancel schedule and reschedule task after delay in seconds""" self.timer.cancel(task) self.timer.postpone(task, delay) class PieceContainer: """Object with piece attribute: None or Tetromino""" def __init__(self): self.piece = None class HoldQueue(PieceContainer): """The storage place where players can Hold any falling tetrimino for use later. When called for, the held tetrimino swaps places with the currently falling tetrimino, and begins falling again at the generation point.""" pass class Matrix(list, PieceContainer): """The rectangular arrangement of cells creating the active game area, usually 10 columns wide by 20 rows high. Tetriminos fall from the top-middle just above the Skyline (off-screen) to the bottom.""" def __init__(self, rows, collumns): list.__init__(self) PieceContainer.__init__(self) self.rows = rows self.collumns = collumns self.ghost = None def reset(self): self.clear() for y in range(self.rows + 3): self.append_new_row() def append_new_row(self): self.append([None for x in range(self.collumns)]) def cell_is_free(self, coord): return ( 0 <= coord.x < self.collumns and 0 <= coord.y and not self[coord.y][coord.x] ) def space_to_move(self, potential_coord, minoes_coord): return all( self.cell_is_free(potential_coord + mino_coord) for mino_coord in minoes_coord ) def space_to_fall(self): return self.space_to_move( self.piece.coord + Movement.DOWN, (mino.coord for mino in self.piece) ) class NextQueue(PieceContainer): """Displays the next tetrimino(s) to be placed (generated) just above the Matrix. If hardware permits, the next six tetriminos should be shown.""" def __init__(self, number): super().__init__() self.number = number self.pieces = [] class Stats: """Game statistics""" 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 __init__(self): self._score = 0 self.high_score = 0 self.time = 0 def new_game(self, level): self.level = level - 1 self.score = 0 self.rows_cleared = 0 self.goal = 0 self.time = 0 self.combo = -1 self.lock_delay = LOCK_DELAY self.fall_delay = FALL_DELAY 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) def update_time(self): self.time += 1 def locks_down(self, t_spin, rows_cleared): pattern_name = [] pattern_score = 0 combo_score = 0 if t_spin: pattern_name.append(t_spin) if rows_cleared: pattern_name.append(SCORES[rows_cleared][LINES_CLEAR_NAME]) self.combo += 1 else: self.combo = -1 if rows_cleared or t_spin: pattern_score = SCORES[rows_cleared][t_spin] self.goal -= pattern_score pattern_score *= 100 * self.level pattern_name = "\n".join(pattern_name) if self.combo >= 1: combo_score = (20 if rows_cleared == 1 else 50) * self.combo * self.level self.score += pattern_score + combo_score return pattern_name, pattern_score, self.combo, combo_score class TetrisLogic: """Tetris game logic intended to implement with GUI""" # These class attributes can be redefined on inheritance AUTOREPEAT_DELAY = AUTOREPEAT_DELAY AUTOREPEAT_PERIOD = AUTOREPEAT_PERIOD MATRIX_PIECE_COORD = MATRIX_PIECE_COORD timer = AbstractScheduler() def __init__(self, rows=ROWS, collumns=COLLUMNS, next_pieces=NEXT_PIECES): self.stats = Stats() self.load_high_score() self.held = HoldQueue() self.matrix = Matrix(rows, collumns) self.next = NextQueue(next_pieces) self.autorepeatable_actions = (self.move_left, self.move_right, self.soft_drop) self.pressed_actions = [] def new_game(self, level=1): self.stats.new_game(level) self.pressed_actions = [] self.matrix.reset() self.next.pieces = [Tetromino() for n in range(self.next.nb_pieces)] self.held.piece = None self.timer.postpone(self.stats.update_time, 1) self.on_new_game(self.next.pieces) self.new_level() def on_new_game(self, next_pieces): pass def new_level(self): self.stats.new_level() self.on_new_level(self.stats.level) self.generation_phase() def on_new_level(self, level): pass # Tetris Engine def generation_phase(self, held_piece=None): if not held_piece: self.matrix.piece = self.next.pieces.pop(0) self.next.pieces.append(Tetromino()) self.matrix.piece.coord = self.MATRIX_PIECE_COORD self.matrix.ghost = self.matrix.piece.ghost() self.refresh_ghost() # if self.pressed_actions: # self.timer.postpone(self.repeat_action, self.AUTOREPEAT_DELAY) self.on_generation_phase( self.matrix, self.matrix.piece, self.matrix.ghost, self.next.pieces ) if self.move(Movement.DOWN): self.falling_phase() else: self.game_over() def refresh_ghost(self): self.matrix.ghost.coord = self.matrix.piece.coord for ghost_mino, current_mino in zip(self.matrix.ghost, self.matrix.piece): ghost_mino.coord = current_mino.coord while self.matrix.space_to_move( self.matrix.ghost.coord + Movement.DOWN, (mino.coord for mino in self.matrix.ghost), ): self.matrix.ghost.coord += Movement.DOWN def on_generation_phase(self, matrix, falling_piece, ghost_piece, next_pieces): pass def falling_phase(self): self.timer.cancel(self.lock_phase) self.timer.cancel(self.locks_down) self.matrix.piece.locked = False self.timer.postpone(self.lock_phase, self.stats.fall_delay) self.on_falling_phase(self.matrix.piece) def on_falling_phase(self, falling_piece): pass def lock_phase(self): self.move(Movement.DOWN) def on_locked(self, falling_piece): pass def move(self, movement, rotated_coords=None, lock=True): """The tetrimino in play falls from just above the Skyline one cell at a time, and moves left and right one cell at a time. Each Mino of a tetrimino “snaps” to the appropriate cell position at the completion of a move, although intermediate tetrimino movement appears smooth. Only right, left, and downward movement are allowed. Movement into occupied cells and Matrix walls and floors is not allowed.""" potential_coord = self.matrix.piece.coord + movement potential_minoes_coords = rotated_coords or ( mino.coord for mino in self.matrix.piece ) if self.matrix.space_to_move(potential_coord, potential_minoes_coords): self.matrix.piece.coord = potential_coord if rotated_coords: for mino, coord in zip(self.matrix.piece, rotated_coords): mino.coord = coord self.refresh_ghost() if movement != Movement.DOWN: self.matrix.piece.rotated_last = False if self.matrix.space_to_fall(): self.falling_phase() else: """Classic Lock down rules apply. Like Infinite Placement, the Lock down timer starts counting down from 0.5 seconds once the tetrimino in play lands on a Surface. the y-coordinate of the tetrimino must decrease (i.e., the tetrimino falls further down in the Matrix) in order for the timer to be reset.""" self.matrix.piece.locked = True self.on_locked(self.matrix.piece) self.timer.reset(self.locks_down, self.stats.lock_delay) return True else: return False def rotate(self, spin): """Tetriminos can rotate clockwise and counterclockwise using the Super Rotation System. this system allows tetrimino rotation in situations that the original Classic Rotation System did not allow, such as rotating against walls. each time a rotation button is pressed, the tetrimino in play rotates 90 degrees in the clockwise or counterclockwise direction. Rotation can be performed while the tetrimino is Auto- Repeating left or right. there is no Auto-Repeat for rotation itself.""" rotated_coords = tuple(mino.coord @ spin for mino in self.matrix.piece) for rotation_point, liberty_degree in enumerate( self.matrix.piece.SRS[spin][self.matrix.piece.orientation], start=1 ): if self.move(liberty_degree, rotated_coords, lock=False): self.matrix.piece.orientation = ( self.matrix.piece.orientation + spin ) % 4 self.matrix.piece.rotated_last = True if rotation_point == 5: self.matrix.piece.rotation_point_5_used = True return True else: return False def locks_down(self): """A tetrimino that is Hard dropped Locks down immediately. However, if a tetrimino naturally falls or Soft drops onto a Surface, it is given 0.5 seconds (less after level 20) on a Lock down timer before it actually Locks down.""" self.timer.cancel(self.lock_phase) # Game over if all( (mino.coord + self.matrix.piece.coord).y >= self.matrix.rows for mino in self.matrix.piece ): self.game_over() return for mino in self.matrix.piece: coord = mino.coord + self.matrix.piece.coord if coord.y <= self.matrix.rows + 3: self.matrix[coord.y][coord.x] = mino self.on_locks_down(self.matrix, self.matrix.piece) # Pattern phase # T-Spin """A t-Spin or Mini t-Spin is a special rotation of the t-tetrimino into a t-Slot, and when accomplished, awards a scoring or line bonus in most variants. A t-Slot is defined as any Block formation such that when the t-tetrimino is spun in it, any three of the four cells diagonally adjacent to the center of the t-tetrimino are occupied by existing Blocks. In order to be considered a t-Spin or Mini t-Spin, the t-tetrimino must spin clockwise or counterclockwise first (it cannot merely be moved or dropped into a t-Slot). In addition to a scoring or other bonus, t-Spins and Mini t-Spins can also continue a Back-to-Back sequence.""" if type(self.matrix.piece) == T_Tetrimino and self.matrix.piece.rotated_last: a = self.is_t_slot(T_Slot.A) b = self.is_t_slot(T_Slot.B) c = self.is_t_slot(T_Slot.C) d = self.is_t_slot(T_Slot.D) if a and b and (c or d): """A rotation is considered a t-Spin if any of the following conditions are met: • Sides A and B + (C or d) are touching a Surface when the tetrimino Locks down. • the t-tetrimino fills a t-Slot completely with no holes. • Rotation Point 5 is used to rotate the tetrimino into the t-Slot. Any further rotation will be considered a t-Spin, not a Mini t-Spin.""" t_spin = T_Spin.T_SPIN elif c and d and (a or b): """A rotation is considered a Mini t-Spin if either of the following conditions are met: • Sides C and d + (A or B) are touching a Surface when the tetrimino Locks down. • the t-tetrimino creates holes in a t-Slot. However, if Rotation Point 5 was used to rotate the tetrimino into the t-Slot, the rotation is considered a t-Spin. """ if self.matrix.piece.rotation_point_5_used: t_spin = T_Spin.T_SPIN else: t_spin = T_Spin.MINI else: t_spin = T_Spin.NONE else: t_spin = T_Spin.NONE # Clear complete rows self.rows_to_remove = [] for y, row in reversed(list(enumerate(self.matrix))): if all(mino for mino in row): self.rows_to_remove.append(y) rows_cleared = len(self.rows_to_remove) if rows_cleared: self.stats.rows_cleared += rows_cleared # Animate phase self.on_animate_phase(self.matrix, self.rows_to_remove) # Eliminate phase self.on_eliminate_phase(self.matrix, self.rows_to_remove) for y in self.rows_to_remove: self.matrix.pop(y) self.matrix.append_new_row() # Completion phase pattern_name, pattern_score, nb_combo, combo_score = self.stats.locks_down( t_spin, rows_cleared ) self.on_completion_phase(pattern_name, pattern_score, nb_combo, combo_score) if self.stats.goal <= 0: self.new_level() else: self.generation_phase() def on_locks_down(self, matrix, falling_piece): pass def on_animate_phase(self, matrix, rows_to_remove): pass def on_eliminate_phase(self, matrix, rows_to_remove): pass def on_completion_phase(self, pattern_name, pattern_score, nb_combo, combo_score): pass # Actions def move_left(self): self.move(Movement.LEFT) def move_right(self): self.move(Movement.RIGHT) def rotate_clockwise(self): self.rotate(Spin.CLOCKWISE) def rotate_counter(self): self.rotate(Spin.COUNTER) def soft_drop(self): """when the Soft drop command is pressed, the tetrimino in play drops at a rate 20 times faster than the normal fall Speed, measured in seconds per line. the tetrimino resumes its normal fall Speed once the Soft drop button is released. for example, if the normal fall Speed is 0.5 seconds per line, then the Soft drop speed is (0.5 / 20) = 0.025 seconds per line. note that if the player Soft drops a tetrimino until it lands on a Surface, Lock down does not occur until the Lock down timer hits zero. Press and hold the Soft drop button to continue the downward movement. Soft drop continues to the next tetrimino (after Lock down) as long as the button remains pressed.""" moved = self.move(Movement.DOWN) if moved: self.stats.score += 1 return moved def hard_drop(self): """The Hard drop command instantly drops the tetrimino and locks it down on the Surface directly below it. There is no Auto-Repeat for a Hard drop.""" self.timer.cancel(self.lock_phase) self.timer.cancel(self.locks_down) while self.move(Movement.DOWN, lock=False): self.stats.score += 2 self.locks_down() def hold(self): """Using the Hold command places the tetrimino in play into the Hold Queue. The previously held tetrimino (if one exists) will then start falling from the top of the Matrix, beginning from its generation position and north facing orientation. Only one tetrimino may be held at a time. A Lock down must take place between Holds. Ror example, at the beginning, the first tetrimino is generated and begins to fall. The player decides to hold this tetrimino. Immediately the next tetrimino is generated from the next Queue and begins to fall. The player must first Lock down this tetrimino before holding another tetrimino. In other words, you may not Hold the same tetrimino more than once.""" if not self.matrix.piece.hold_enabled: return self.matrix.piece.hold_enabled = False self.timer.cancel(self.lock_phase) self.matrix.piece, self.held.piece = self.held.piece, self.matrix.piece for mino, coord in zip(self.held.piece, self.held.piece.MINOES_COORDS): mino.coord = coord self.on_hold(self.held.piece) self.generation_phase(self.matrix.piece) def on_hold(self, held_piece): pass 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 pause(self): self.stop_all() self.pressed_actions = [] self.timer.cancel(self.repeat_action) self.on_pause() def on_pause(self): pass def resume(self): self.timer.postpone(self.lock_phase, self.stats.fall_delay) if self.matrix.piece.locked: self.timer.postpone(self.locks_down, self.stats.lock_delay) self.timer.postpone(self.stats.update_time, 1) self.on_resume() def on_resume(self): pass def game_over(self): self.stop_all() self.save_high_score() self.on_game_over() def on_game_over(self): pass def stop_all(self): self.timer.cancel(self.lock_phase) self.timer.cancel(self.locks_down) self.timer.cancel(self.stats.update_time) def do_action(self, action): action() if action in self.autorepeatable_actions: self.pressed_actions.append(action) if action == self.soft_drop: delay = self.stats.fall_delay / 20 else: delay = self.AUTOREPEAT_DELAY self.timer.reset(self.repeat_action, delay) def repeat_action(self): """tapping the move button allows a single cell movement of the tetrimino in the direction pressed. Holding down the move button triggers an Auto-Repeat movement that allows the player to move a tetrimino from one side of the Matrix to the other in about 0.5 seconds. this is essential on higher levels when the fall Speed of a tetrimino is very fast. there must be a slight delay between the time the move button is pressed and the time when Auto-Repeat kicks in, roughly 0.3 seconds. this delay prevents unwanted extra movement of a tetrimino. Auto-Repeat only affects Left/Right movement. Auto-Repeat continues to the next tetrimino (after Lock down) as long as the move button remains pressed. In addition, when Auto-Repeat begins, and the player then holds the opposite direction button, the tetrimino must then begin moving the opposite direction with the initial delay. this mainly applies to devices with movement buttons—such as a keyboard or mobile phone—where more than one direction button is able to be pressed simultaneously. when any single button is then released, the tetrimino should again move in the direction still held, with the Auto-Repeat delay of roughly 0.3 seconds applied once more.""" if not self.pressed_actions: return self.pressed_actions[-1]() self.timer.postpone(self.repeat_action, self.AUTOREPEAT_PERIOD) 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.stats.high_score = crypted_high_score ^ CRYPT_KEY else: raise Warning( """TetrisLogic.load_high_score not implemented. High score is set to 0""" ) self.stats.high_score = 0 def save_high_score(self): crypted_high_score = self.stats.high_score ^ CRYPT_KEY crypted_high_score = pickle.dumps(crypted_high_score) return crypted_high_score