adrien/TetrArcade
1
0
Fork 0
Code Issues 1 Pull Requests Releases 6 Wiki Activity

refactorize using inheritance

Browse Source
This commit is contained in:
adrienmalin 2019-09-28 04:24:04 +02:00
parent dcac72251f
commit 30e5bf30c3
2 changed files with 145 additions and 151 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

207
tetrarcade.py
View File

@ -13,7 +13,7 @@ python -m pip install --user arcade
""" """
) )
from gamelogic import GameLogic, Status, Movement, Rotation from tetris import Tetris, Status
# Constants # Constants
@ -89,11 +89,12 @@ GHOST_ALPHA = 50
MATRIX_SRITE_ALPHA = 100 MATRIX_SRITE_ALPHA = 100
class TetrArcade(arcade.Window): class TetrArcade(Tetris, arcade.Window):
def __init__(self): def __init__(self):
super().__init__()
locale.setlocale(locale.LC_ALL, '') locale.setlocale(locale.LC_ALL, '')
self.game = GameLogic(self)
self.actions = { self.actions = {
Status.PLAYING: { Status.PLAYING: {
@ -129,7 +130,11 @@ class TetrArcade(arcade.Window):
} }
self.autorepeatable_actions = (self.move_left, self.move_right, self.soft_drop) self.autorepeatable_actions = (self.move_left, self.move_right, self.soft_drop)
super().__init__( self.highlight_texts = []
self.pressed_actions = []
arcade.Window.__init__(
self,
width = WINDOW_WIDTH, width = WINDOW_WIDTH,
height = WINDOW_HEIGHT, height = WINDOW_HEIGHT,
title = WINDOW_TITLE, title = WINDOW_TITLE,
@ -153,112 +158,45 @@ class TetrArcade(arcade.Window):
anchor_x = 'right' anchor_x = 'right'
) )
self.new_game()
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.load_matrix()
def new_game(self): def new_game(self):
self.pressed_actions = []
self.highlight_texts = [] self.highlight_texts = []
self.pressed_actions = []
self.auto_repeat = False self.auto_repeat = False
arcade.schedule(self.clock, 1) super().new_game()
self.game.new_game()
self.new_current_piece()
def new_current_piece(self): def new_current_piece(self):
self.load_next_pieces() super().new_current_piece()
self.load_current_piece() self.reload_next_pieces()
self.load_matrix() self.reload_current_piece()
self.reload_matrix()
if self.pressed_actions: if self.pressed_actions:
self.stop_autorepeat() self.stop_autorepeat()
arcade.schedule(self.repeat_action, AUTOREPEAT_DELAY) arcade.schedule(self.repeat_action, AUTOREPEAT_DELAY)
def move_left(self, delta_time=0): def lock(self, _=0):
self.game.move(Movement.LEFT) super().lock()
self.reload_matrix()
self.reload_next_pieces()
self.reload_current_piece()
def move_right(self, delta_time=0): def swap(self, _=0):
self.game.move(Movement.RIGHT) super().swap()
self.reload_held_piece()
self.reload_current_piece()
def soft_drop(self, delta_time=0): def pause(self, _=0):
self.game.soft_drop() super().pause()
def hard_drop(self, delta_time=0):
self.game.hard_drop()
self.lock()
def rotate_counterclockwise(self, delta_time=0):
self.game.rotate(Rotation.COUNTERCLOCKWISE)
def rotate_clockwise(self, delta_time=0):
self.game.rotate(Rotation.CLOCKWISE)
def fall(self, delta_time=0):
self.game.move(Movement.DOWN)
def start_fall(self):
arcade.schedule(self.fall, self.game.fall_delay)
def stop_fall(self):
arcade.unschedule(self.fall)
def prelock(self, restart=False):
if restart:
self.cancel_prelock()
arcade.schedule(self.lock, self.game.lock_delay)
def cancel_prelock(self):
arcade.unschedule(self.lock)
def lock(self, delta_time=0):
self.game.lock()
self.load_matrix()
self.load_next_pieces()
self.load_current_piece()
if self.game.status == Status.PLAYING:
self.new_current_piece()
elif self.game.status == Status.OVER:
self.game_over()
def swap(self, delta_time=0):
self.game.swap()
self.load_held_piece()
self.load_current_piece()
def pause(self, delta_time=0):
self.game.status = Status.PAUSED
self.stop_fall()
self.cancel_prelock()
arcade.unschedule(self.clock)
self.pressed_actions = [] self.pressed_actions = []
self.stop_autorepeat() self.stop_autorepeat()
def resume(self, delta_time=0):
self.highlight_texts = []
self.game.status = Status.PLAYING
self.start_fall()
if self.game.current_piece.prelocked:
arcade.schedule(self.lock, self.game.lock_delay)
arcade.schedule(self.clock, 1)
def game_over(self): def game_over(self):
arcade.unschedule(self.repeat_action) super().game_over()
self.cancel_prelock() self.unschedule(self.repeat_action)
self.stop_fall()
arcade.unschedule(self.clock)
def on_key_press(self, key, modifiers): def on_key_press(self, key, modifiers):
for key_or_modifier in (key, modifiers): for key_or_modifier in (key, modifiers):
try: try:
action = self.actions[self.game.status][key_or_modifier] action = self.actions[self.status][key_or_modifier]
except KeyError: except KeyError:
pass pass
else: else:
@ -270,7 +208,7 @@ class TetrArcade(arcade.Window):
def on_key_release(self, key, modifiers): def on_key_release(self, key, modifiers):
try: try:
action = self.actions[self.game.status][key] action = self.actions[self.status][key]
except KeyError: except KeyError:
pass pass
else: else:
@ -297,21 +235,18 @@ class TetrArcade(arcade.Window):
def stop_autorepeat(self): def stop_autorepeat(self):
self.auto_repeat = False self.auto_repeat = False
arcade.unschedule(self.repeat_action) self.unschedule(self.repeat_action)
def add_highlight_text(self, string): def show_text(self, text):
self.highlight_texts.append(string) self.highlight_texts.append(text)
arcade.schedule(self.del_highlight_text, HIGHLIGHT_TEXT_DISPLAY_DELAY) self.schedule(self.del_highlight_text, HIGHLIGHT_TEXT_DISPLAY_DELAY)
def del_highlight_text(self, delta_time=0): def del_highlight_text(self, _=0):
self.highlight_texts.pop(0) self.highlight_texts.pop(0)
if not self.highlight_texts: if not self.highlight_texts:
arcade.unschedule(self.del_highlight_text) self.unschedule(self.del_highlight_text)
def clock(self, delta_time=0): def reload_piece(self, piece):
self.game.time += delta_time
def load_piece(self, piece):
piece_sprites = arcade.SpriteList() piece_sprites = arcade.SpriteList()
for mino_position in piece.minoes_positions: for mino_position in piece.minoes_positions:
mino_sprite_path = MINOES_SPRITES_PATHS[piece.MINOES_COLOR] mino_sprite_path = MINOES_SPRITES_PATHS[piece.MINOES_COLOR]
@ -320,26 +255,26 @@ class TetrArcade(arcade.Window):
piece_sprites.append(mino_sprite) piece_sprites.append(mino_sprite)
return piece_sprites return piece_sprites
def load_held_piece(self): def reload_held_piece(self):
self.held_piece_sprites = self.load_piece(self.game.held_piece) self.held_piece_sprites = self.reload_piece(self.held_piece)
def load_next_pieces(self): def reload_next_pieces(self):
self.next_pieces_sprites = arcade.SpriteList() self.next_pieces_sprites = arcade.SpriteList()
for piece in self.game.next_pieces: for piece in self.next_pieces:
for mino_position in piece.minoes_positions: for mino_position in piece.minoes_positions:
mino_sprite_path = MINOES_SPRITES_PATHS[piece.MINOES_COLOR] mino_sprite_path = MINOES_SPRITES_PATHS[piece.MINOES_COLOR]
mino_sprite = arcade.Sprite(mino_sprite_path) mino_sprite = arcade.Sprite(mino_sprite_path)
mino_sprite.alpha = NORMAL_ALPHA mino_sprite.alpha = NORMAL_ALPHA
self.next_pieces_sprites.append(mino_sprite) self.next_pieces_sprites.append(mino_sprite)
def load_current_piece(self): def reload_current_piece(self):
self.current_piece_sprites = self.load_piece(self.game.current_piece) self.current_piece_sprites = self.reload_piece(self.current_piece)
self.ghost_piece_sprites = self.load_piece(self.game.ghost_piece) self.ghost_piece_sprites = self.reload_piece(self.ghost_piece)
def load_matrix(self): def reload_matrix(self):
if self.game.matrix: if self.matrix:
self.matrix_minoes_sprites = arcade.SpriteList() self.matrix_minoes_sprites = arcade.SpriteList()
for y, line in enumerate(self.game.matrix): for y, line in enumerate(self.matrix):
for x, mino_color in enumerate(line): for x, mino_color in enumerate(line):
if mino_color: if mino_color:
mino_sprite_path = MINOES_SPRITES_PATHS[mino_color] mino_sprite_path = MINOES_SPRITES_PATHS[mino_color]
@ -362,25 +297,25 @@ class TetrArcade(arcade.Window):
arcade.start_render() arcade.start_render()
self.bg_sprite.draw() self.bg_sprite.draw()
self.matrix_sprite.draw() self.matrix_sprite.draw()
if not self.game.status == Status.PAUSED: if not self.status == Status.PAUSED:
self.matrix_minoes_sprites.draw() self.matrix_minoes_sprites.draw()
self.update_piece(self.game.held_piece, self.held_piece_sprites) self.update_piece(self.held_piece, self.held_piece_sprites)
self.held_piece_sprites.draw() self.held_piece_sprites.draw()
self.update_piece(self.game.current_piece, self.current_piece_sprites) self.update_piece(self.current_piece, self.current_piece_sprites)
if self.game.current_piece.prelocked: if self.current_piece.prelocked:
alpha = PRELOCKED_ALPHA if self.game.current_piece.prelocked else NORMAL_ALPHA alpha = PRELOCKED_ALPHA if self.current_piece.prelocked else NORMAL_ALPHA
for mino_sprite in self.current_piece_sprites: for mino_sprite in self.current_piece_sprites:
mino_sprite.alpha = alpha mino_sprite.alpha = alpha
self.current_piece_sprites.draw() self.current_piece_sprites.draw()
self.update_piece(self.game.ghost_piece, self.ghost_piece_sprites) self.update_piece(self.ghost_piece, self.ghost_piece_sprites)
for mino_sprite in self.ghost_piece_sprites: for mino_sprite in self.ghost_piece_sprites:
mino_sprite.alpha = GHOST_ALPHA mino_sprite.alpha = GHOST_ALPHA
self.ghost_piece_sprites.draw() self.ghost_piece_sprites.draw()
for n, piece in enumerate(self.game.next_pieces): for n, piece in enumerate(self.next_pieces):
for mino_sprite, mino_position in zip( for mino_sprite, mino_position in zip(
self.next_pieces_sprites[4*n:4*(n+1)], piece.minoes_positions self.next_pieces_sprites[4*n:4*(n+1)], piece.minoes_positions
): ):
@ -394,15 +329,15 @@ class TetrArcade(arcade.Window):
self.matrix_sprite.left - TEXT_MARGIN, self.matrix_sprite.left - TEXT_MARGIN,
self.matrix_sprite.bottom self.matrix_sprite.bottom
) )
t = time.localtime(self.game.time) t = time.localtime(self.time)
for y, text in enumerate( for y, text in enumerate(
( (
"{:n}".format(self.game.nb_lines), "{:n}".format(self.nb_lines),
"{:n}".format(self.game.goal), "{:n}".format(self.goal),
"{:n}".format(self.game.level), "{:n}".format(self.level),
"{:02d}:{:02d}:{:02d}".format(t.tm_hour-1, t.tm_min, t.tm_sec), "{:02d}:{:02d}:{:02d}".format(t.tm_hour-1, t.tm_min, t.tm_sec),
"{:n}".format(self.game.high_score), "{:n}".format(self.high_score),
"{:n}".format(self.game.score) "{:n}".format(self.score)
), ),
start=14 start=14
): ):
@ -420,7 +355,7 @@ class TetrArcade(arcade.Window):
Status.PLAYING: self.highlight_texts[0] if self.highlight_texts else "", Status.PLAYING: self.highlight_texts[0] if self.highlight_texts else "",
Status.PAUSED: PAUSE_TEXT, Status.PAUSED: PAUSE_TEXT,
Status.OVER: GAME_OVER_TEXT Status.OVER: GAME_OVER_TEXT
}.get(self.game.status, "") }.get(self.status, "")
if highlight_text: if highlight_text:
arcade.draw_text( arcade.draw_text(
text = highlight_text, text = highlight_text,
@ -434,9 +369,27 @@ class TetrArcade(arcade.Window):
anchor_y = '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 schedule(self, task, period):
arcade.schedule(task, period)
def unschedule(self, task):
arcade.unschedule(task)
def main(): def main():
TetrArcade() tetrarcade = TetrArcade()
tetrarcade.new_game()
arcade.run() arcade.run()
if __name__ == "__main__": if __name__ == "__main__":

87
gamelogic.py → tetris.py
View File

@ -167,7 +167,7 @@ class Tetromino:
return cls.random_bag.pop()() return cls.random_bag.pop()()
class GameLogic(): class Tetris():
T_SLOT = (Coord(-1, 1), Coord(1, 1), Coord(1, -1), Coord(-1, -1)) T_SLOT = (Coord(-1, 1), Coord(1, 1), Coord(1, -1), Coord(-1, -1))
SCORES = ( SCORES = (
@ -178,8 +178,7 @@ class GameLogic():
{"name": "TETRIS", T_Spin.NO_T_SPIN: 8} {"name": "TETRIS", T_Spin.NO_T_SPIN: 8}
) )
def __init__(self, ui): def __init__(self):
self.ui = ui
self.high_score = 0 self.high_score = 0
self.status = Status.STARTING self.status = Status.STARTING
self.matrix = [] self.matrix = []
@ -206,8 +205,8 @@ class GameLogic():
self.current_piece = None self.current_piece = None
self.held_piece = None self.held_piece = None
self.status = Status.PLAYING self.status = Status.PLAYING
self.schedule(self.clock, 1)
self.new_level() self.new_level()
self.new_current_piece()
def new_level(self): def new_level(self):
self.level += 1 self.level += 1
@ -216,7 +215,9 @@ class GameLogic():
self.fall_delay = pow(0.8 - ((self.level-1)*0.007), self.level-1) self.fall_delay = pow(0.8 - ((self.level-1)*0.007), self.level-1)
if self.level > 15: if self.level > 15:
self.lock_delay = 0.5 * pow(0.9, self.level-15) self.lock_delay = 0.5 * pow(0.9, self.level-15)
self.ui.add_highlight_text("Level\n{:n}".format(self.level)) self.show_text("Level\n{:n}".format(self.level))
self.schedule(self.drop, self.fall_delay)
self.new_current_piece()
def new_current_piece(self): def new_current_piece(self):
self.current_piece = self.next_pieces.pop(0) self.current_piece = self.next_pieces.pop(0)
@ -226,12 +227,10 @@ class GameLogic():
self.next_pieces.append(Tetromino()) self.next_pieces.append(Tetromino())
for piece, position in zip (self.next_pieces, NEXT_PIECES_POSITIONS): for piece, position in zip (self.next_pieces, NEXT_PIECES_POSITIONS):
piece.position = position piece.position = position
if self.can_move( if not self.can_move(
self.current_piece.position, self.current_piece.position,
self.current_piece.minoes_positions self.current_piece.minoes_positions
): ):
self.ui.start_fall()
else:
self.game_over() self.game_over()
def cell_is_free(self, position): def cell_is_free(self, position):
@ -251,7 +250,8 @@ class GameLogic():
potential_position = self.current_piece.position + movement potential_position = self.current_piece.position + movement
if self.can_move(potential_position, self.current_piece.minoes_positions): if self.can_move(potential_position, self.current_piece.minoes_positions):
if self.current_piece.prelocked: if self.current_piece.prelocked:
self.ui.prelock(restart=True) self.unschedule(self.lock)
self.schedule(self.lock, self.lock_delay)
self.current_piece.position = potential_position self.current_piece.position = potential_position
self.current_piece.last_rotation_point_used = None self.current_piece.last_rotation_point_used = None
self.move_ghost() self.move_ghost()
@ -262,9 +262,15 @@ class GameLogic():
and movement == Movement.DOWN and movement == Movement.DOWN
): ):
self.current_piece.prelocked = True self.current_piece.prelocked = True
self.ui.prelock() self.schedule(self.lock, self.lock_delay)
return False return False
def move_left(self, delta_time=0):
self.move(Movement.LEFT)
def move_right(self, delta_time=0):
self.move(Movement.RIGHT)
def rotate(self, direction): def rotate(self, direction):
rotated_minoes_positions = tuple( rotated_minoes_positions = tuple(
Coord(-direction*mino_position.y, direction*mino_position.x) Coord(-direction*mino_position.y, direction*mino_position.x)
@ -277,7 +283,8 @@ class GameLogic():
potential_position = self.current_piece.position + liberty_degree potential_position = self.current_piece.position + liberty_degree
if self.can_move(potential_position, rotated_minoes_positions): if self.can_move(potential_position, rotated_minoes_positions):
if self.current_piece.prelocked: if self.current_piece.prelocked:
self.ui.prelock(restart=True) self.unschedule(self.lock)
self.schedule(self.lock, self.lock_delay)
self.current_piece.position = potential_position self.current_piece.position = potential_position
self.current_piece.minoes_positions = rotated_minoes_positions self.current_piece.minoes_positions = rotated_minoes_positions
self.current_piece.orientation = ( self.current_piece.orientation = (
@ -289,6 +296,12 @@ class GameLogic():
else: else:
return False return False
def rotate_counterclockwise(self, delta_time=0):
self.rotate(Rotation.COUNTERCLOCKWISE)
def rotate_clockwise(self, delta_time=0):
self.rotate(Rotation.CLOCKWISE)
def move_ghost(self): def move_ghost(self):
self.ghost_piece.position = self.current_piece.position self.ghost_piece.position = self.current_piece.position
self.ghost_piece.minoes_positions = self.current_piece.minoes_positions self.ghost_piece.minoes_positions = self.current_piece.minoes_positions
@ -298,6 +311,9 @@ class GameLogic():
): ):
self.ghost_piece.position += Movement.DOWN self.ghost_piece.position += Movement.DOWN
def drop(self, _=0):
self.move(Movement.DOWN)
def add_to_score(self, ds): def add_to_score(self, ds):
self.score += ds self.score += ds
if self.score > self.high_score: if self.score > self.high_score:
@ -311,26 +327,22 @@ class GameLogic():
return False return False
def hard_drop(self): def hard_drop(self):
drop_score = 0
while self.move(Movement.DOWN, prelock_on_stuck=False): while self.move(Movement.DOWN, prelock_on_stuck=False):
drop_score += 2 self.add_to_score(2)
self.add_to_score(drop_score) self.lock()
return drop_score
def lock(self): def lock(self):
if self.move(Movement.DOWN): if self.move(Movement.DOWN):
self.ui.cancel_prelock()
return return
if all( if all(
(mino_position + self.current_piece.position).y >= NB_LINES (mino_position + self.current_piece.position).y >= NB_LINES
for mino_position in self.current_piece.minoes_positions for mino_position in self.current_piece.minoes_positions
): ):
self.current_piece.prelocked = False
self.game_over() self.game_over()
return return
self.ui.stop_fall() self.unschedule(self.lock)
for mino_position in self.current_piece.minoes_positions: for mino_position in self.current_piece.minoes_positions:
position = mino_position + self.current_piece.position position = mino_position + self.current_piece.position
@ -392,21 +404,21 @@ class GameLogic():
lock_strings.append(str(ds)) lock_strings.append(str(ds))
if lock_strings: if lock_strings:
self.ui.add_highlight_text("\n".join(lock_strings)) self.show_text("\n".join(lock_strings))
self.add_to_score(lock_score) self.add_to_score(lock_score)
if self.goal <= 0: if self.goal <= 0:
self.unschedule(self.drop)
self.new_level() self.new_level()
else:
self.new_current_piece() self.new_current_piece()
def swap(self): def swap(self):
if self.current_piece.hold_enabled: if self.current_piece.hold_enabled:
self.current_piece.hold_enabled = False self.current_piece.hold_enabled = False
self.current_piece.prelocked = False self.current_piece.prelocked = False
self.ui.cancel_prelock() self.unschedule(self.lock)
self.ui.stop_fall()
self.current_piece, self.held_piece = self.held_piece, self.current_piece self.current_piece, self.held_piece = self.held_piece, self.current_piece
if self.held_piece.__class__ == Tetromino.I: if self.held_piece.__class__ == Tetromino.I:
self.held_piece.position = HELD_I_POSITION self.held_piece.position = HELD_I_POSITION
@ -417,10 +429,39 @@ class GameLogic():
self.current_piece.position = MATRIX_PIECE_INIT_POSITION self.current_piece.position = MATRIX_PIECE_INIT_POSITION
self.ghost_piece = self.current_piece.ghost() self.ghost_piece = self.current_piece.ghost()
self.move_ghost() self.move_ghost()
self.ui.start_fall()
else: else:
self.new_current_piece() self.new_current_piece()
def pause(self, _=0):
self.status = Status.PAUSED
self.unschedule(self.drop)
self.unschedule(self.lock)
self.unschedule(self.clock)
self.pressed_actions = []
self.stop_autorepeat()
def resume(self, delta_time=0):
self.status = Status.PLAYING
self.schedule(self.drop, self.fall_delay)
if self.current_piece.prelocked:
self.schedule(self.lock, self.lock_delay)
self.schedule(self.clock, 1)
def clock(self, delta_time=1):
self.time += delta_time
def game_over(self): def game_over(self):
self.status = Status.OVER self.status = Status.OVER
self.unschedule(self.lock)
self.unschedule(self.drop)
self.unschedule(self.clock)
def schedule(task, period):
raise NotImplementedError
def unschedule(self, task):
raise NotImplementedError
def show_text(self, text):
print(text)