368 lines
12 KiB
Python
368 lines
12 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
import random
|
|
import time
|
|
|
|
|
|
class Rotation:
|
|
CLOCKWISE = 1
|
|
COUNTERCLOCKWISE = -1
|
|
|
|
|
|
class Point:
|
|
def __init__(self, x, y):
|
|
self.x = x
|
|
self.y = y
|
|
|
|
def __add__(self, other):
|
|
return Point(self.x+other.x, self.y+other.y)
|
|
|
|
|
|
class Movement:
|
|
LEFT = Point(-1, 0)
|
|
RIGHT = Point(1, 0)
|
|
DOWN = Point(0, 1)
|
|
|
|
|
|
class Mino:
|
|
NO_MINO = 0
|
|
I = 1
|
|
J = 2
|
|
L = 3
|
|
O = 4
|
|
S = 5
|
|
T = 6
|
|
Z = 7
|
|
|
|
|
|
class Tetromino:
|
|
INIT_POSITION = Point(4, 0)
|
|
CAN_ROTATE = True
|
|
SUPER_ROTATION_SYSTEM = (
|
|
{
|
|
Rotation.COUNTERCLOCKWISE: (Point(0, 0), Point(1, 0), Point(1, -1), Point(0, 2), Point(1, 2)),
|
|
Rotation.CLOCKWISE: (Point(0, 0), Point(-1, 0), Point(-1, -1), Point(0, 2), Point(-1, 2)),
|
|
},
|
|
{
|
|
Rotation.COUNTERCLOCKWISE: (Point(0, 0), Point(1, 0), Point(1, 1), Point(0, -2), Point(1, -2)),
|
|
Rotation.CLOCKWISE: (Point(0, 0), Point(1, 0), Point(1, 1), Point(0, -2), Point(1, -2)),
|
|
},
|
|
{
|
|
Rotation.COUNTERCLOCKWISE: (Point(0, 0), Point(-1, 0), Point(-1, -1), Point(0, 2), Point(-1, 2)),
|
|
Rotation.CLOCKWISE: (Point(0, 0), Point(1, 0), Point(1, -1), Point(0, 2), Point(1, 2)),
|
|
},
|
|
{
|
|
Rotation.COUNTERCLOCKWISE: (Point(0, 0), Point(-1, 0), Point(-1, 1), Point(0, -2), Point(-1, -2)),
|
|
Rotation.CLOCKWISE: (Point(0, 0), Point(-1, 0), Point(-1, 1), Point(0, 2), Point(-1, -2))
|
|
}
|
|
)
|
|
lock_delay = 0.5
|
|
|
|
def __init__(self, position):
|
|
self.position = self.INIT_POSITION
|
|
self.minoes_position = self.MINOES_POSITIONS
|
|
self.orientation = 0
|
|
self.rotation_point_5_used = False
|
|
self.rotated_last = False
|
|
self.hold_enabled = True
|
|
|
|
def t_spin(self):
|
|
return ""
|
|
|
|
|
|
class O(Tetromino):
|
|
MINOES_POSITIONS = (Point(0, 0), Point(1, 0), Point(0, -1), Point(1, -1))
|
|
MINOES_TYPE = Mino.O
|
|
CAN_ROTATE = False
|
|
|
|
def _rotate(self, direction):
|
|
return False
|
|
|
|
class I(Tetromino):
|
|
SUPER_ROTATION_SYSTEM = (
|
|
{
|
|
Rotation.COUNTERCLOCKWISE: (Point(0, 1), Point(-1, 1), Point(2, 1), Point(-1, -1), Point(2, 2)),
|
|
Rotation.CLOCKWISE: (Point(1, 0), Point(-1, 0), Point(2, 0), Point(-1, 1), Point(2, -2)),
|
|
},
|
|
{
|
|
Rotation.COUNTERCLOCKWISE: (Point(-1, 0), Point(1, 0), Point(-2, 0), Point(1, -1), Point(-2, 2)),
|
|
Rotation.CLOCKWISE: (Point(0, 1), Point(-1, 1), Point(2, 1), Point(-1, -1), Point(2, 2)),
|
|
},
|
|
{
|
|
Rotation.COUNTERCLOCKWISE: (Point(0, -1), Point(1, -1), Point(-2, -1), Point(1, 1), Point(-2, -2)),
|
|
Rotation.CLOCKWISE: (Point(-1, 0), Point(1, 0), Point(-2, 0), Point(1, -1), Point(-2, 2)),
|
|
},
|
|
{
|
|
Rotation.COUNTERCLOCKWISE: (Point(1, 0), Point(-1, 0), Point(2, 0), Point(-1, 1), Point(2, -2)),
|
|
Rotation.CLOCKWISE: (Point(0, 1), Point(1, -1), Point(-2, -1), Point(1, 1), Point(-2, -2)),
|
|
},
|
|
)
|
|
MINOES_POSITIONS = (Point(-1, 0), Point(0, 0), Point(1, 0), Point(2, 0))
|
|
MINOES_TYPE = Mino.I
|
|
|
|
class T(Tetromino):
|
|
MINOES_POSITIONS = (Point(-1, 0), Point(0, 0), Point(0, -1), Point(1, 0))
|
|
MINOES_TYPE = Mino.T
|
|
T_SLOT = (Point(-1, -1), Point(1, -1), Point(1, 1), Point(-1, 1))
|
|
|
|
def t_spin(self):
|
|
if self.rotated_last:
|
|
a = not self.matrix.is_free_cell(self.position+self.T_SLOT[self.orientation])
|
|
b = not self.matrix.is_free_cell(self.position+self.T_SLOT[(1+self.orientation)%4])
|
|
c = not self.matrix.is_free_cell(self.position+self.T_SLOT[(3+self.orientation)%4])
|
|
d = not self.matrix.is_free_cell(self.position+self.T_SLOT[(2+self.orientation)%4])
|
|
|
|
if self.rotation_point_5_used or (a and b and (c or d)):
|
|
return "T-SPIN"
|
|
elif c and d and (a or b):
|
|
return "MINI T-SPIN"
|
|
return ""
|
|
|
|
class L(Tetromino):
|
|
MINOES_POSITIONS = (Point(-1, 0), Point(0, 0), Point(1, 0), Point(1, -1))
|
|
MINOES_TYPE = Mino.L
|
|
|
|
class J(Tetromino):
|
|
MINOES_POSITIONS = (Point(-1, -1), Point(-1, 0), Point(0, 0), Point(1, 0))
|
|
MINOES_TYPE = Mino.J
|
|
|
|
class S(Tetromino):
|
|
MINOES_POSITIONS = (Point(-1, 0), Point(0, 0), Point(0, -1), Point(1, -1))
|
|
MINOES_TYPE = Mino.S
|
|
|
|
class Z(Tetromino):
|
|
MINOES_POSITIONS = (Point(-1, -1), Point(0, -1), Point(0, 0), Point(1, 0))
|
|
MINOES_TYPE = Mino.Z
|
|
|
|
|
|
class Tetris:
|
|
TETROMINOES = (O, I, T, L, J, S, Z)
|
|
LEN_NEXT_QUEUE = 1
|
|
MATRIX_ROWS = 20
|
|
MATRIX_COLS = 10
|
|
INIT_POSITION = Point(4, 0)
|
|
FALL_DELAY = 1
|
|
LOCK_DELAY = 0.5
|
|
AUTOSHIFT_DELAY = 0.2
|
|
SCORES = (
|
|
{"name": "", "": 0, "MINI T-SPIN": 1, "T-SPIN": 4},
|
|
{"name": "SINGLE", "": 1, "MINI T-SPIN": 2, "T-SPIN": 8},
|
|
{"name": "DOUBLE", "": 3, "T-SPIN": 12},
|
|
{"name": "TRIPLE", "": 5, "T-SPIN": 16},
|
|
{"name": "TETRIS", "": 8}
|
|
)
|
|
|
|
def __init__(self, high_score=0):
|
|
self.matrix = [
|
|
[Mino.NO_MINO for x in range(self.MATRIX_ROWS)]
|
|
for y in range(self.MATRIX_COLS)
|
|
]
|
|
self.high_score = high_score
|
|
|
|
def _random_piece(self):
|
|
if not self.random_bag:
|
|
self.random_bag = list(self.TETROMINOES)
|
|
random.shuffle(self.random_bag)
|
|
return self.random_bag.pop()()
|
|
|
|
def new_game(self, level=1):
|
|
self.matrix.cells = [
|
|
[Mino.NO_MINO for x in range(self.NB_COLS)]
|
|
for y in range(self.NB_ROWS)
|
|
]
|
|
self.level = level - 1
|
|
self.goal = 0
|
|
self.score = 0
|
|
self.random_bag = []
|
|
self.next_queue = [
|
|
self._random_piece()
|
|
for _ in range(self.LEN_NEXT_QUEUE)
|
|
]
|
|
self.held_piece = None
|
|
self.fall_delay = self.FALL_DELAY
|
|
self.lock_delay = self.LOCK_DELAY
|
|
self.time = time.time()
|
|
self.next_level()
|
|
self.new_piece()
|
|
|
|
def next_level(self):
|
|
self.level += 1
|
|
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.goal += 5 * self.level
|
|
self.show_text("LEVEL %d" % self.level)
|
|
|
|
def new_piece(self):
|
|
self.current_piece = self.next_queue.pop(1)
|
|
self.next_queue.append(self._random_piece)
|
|
self.start_piece()
|
|
|
|
def hold_piece(self):
|
|
if self.current_piece.hold_enabled:
|
|
self.current_piece, self.hold_piece = self.held_piece, self.current_piece
|
|
self.held_piece.minoes_position = self.held_piece.MINOES_POSITIONS
|
|
self.held_piece.hold_enabled = False
|
|
|
|
if self.matrix.piece:
|
|
self.start_piece()
|
|
else:
|
|
self.new_piece()
|
|
|
|
def start_piece(self):
|
|
self.current_piece.position = self.INIT_POSITION
|
|
if not self.shape_fits(self.current_piece.position, self.current_piece.minoes_positions):
|
|
self.over()
|
|
|
|
def _move(self, movement):
|
|
potential_position = self.current_piece.position + movement
|
|
if self.shape_fits(potential_position, self.current_piece.minoes_positions):
|
|
self.current_piece.position = potential_position
|
|
self.current_piece.rotated_last = False
|
|
self.postpone_lock()
|
|
return True
|
|
else:
|
|
self.prelock()
|
|
return False
|
|
|
|
def _rotate(self, direction):
|
|
if not self.current_piece.CAN_ROTATE:
|
|
return False
|
|
|
|
potential_minoes_positions = tuple(
|
|
Point(-direction*mino_position.y, direction*mino_position.x)
|
|
for mino_position in self.minoes_position
|
|
)
|
|
for rotation_point, liberty_degree in enumerate(self.SUPER_ROTATION_SYSTEM[self.orientation][direction], start=1):
|
|
potential_position = self.position + liberty_degree
|
|
if self.shape_fits(potential_position, potential_minoes_positions):
|
|
self.current_piece.orientation = (self.orientation+direction) % 4
|
|
self.current_piece.position = potential_position
|
|
self.current_piece.minoes_position = potential_minoes_positions
|
|
self.current_piece.rotated_last = True
|
|
if rotation_point == 5:
|
|
self.current_piece.rotation_point_5_used = True
|
|
self.postpone_lock()
|
|
return True
|
|
else:
|
|
self.prelock()
|
|
return False
|
|
|
|
def move_left(self):
|
|
self._move(Movement.LEFT)
|
|
|
|
def move_right(self):
|
|
self._move(Movement.RIGHT)
|
|
|
|
def soft_drop(self):
|
|
if self._move(Movement.DOWN):
|
|
self.rows_dropped(1)
|
|
|
|
def hard_drop(self):
|
|
points = 0
|
|
while self._move(Movement.DOWN):
|
|
points += 2
|
|
self.rows_dropped(points)
|
|
self.lock_piece()
|
|
|
|
def rows_dropped(self, points):
|
|
self.update_score(points, "")
|
|
|
|
def fall(self):
|
|
self._move(Movement.DOWN)
|
|
|
|
def rotate_clockwise(self):
|
|
return self.current_piece._rotate(Rotation.CLOCKWISE)
|
|
|
|
def rotate_counterclockwise(self):
|
|
return self.current_piece._rotate(Rotation.COUNTERCLOCKWISE)
|
|
|
|
def is_free_cell(self, position):
|
|
return (
|
|
0 <= position.x < self.NB_COLS
|
|
and position.y < self.NB_LINES
|
|
and not (position.y >= 0 and self.matrix[position.y][position.x] != Mino.NO_MINO)
|
|
)
|
|
|
|
def shape_fits(self, piece_position, minoes_positions):
|
|
return all(
|
|
self.is_free_cell(piece_position+mino_position)
|
|
for mino_position in minoes_positions
|
|
)
|
|
|
|
def prelock(self):
|
|
"""
|
|
Schedules self.lock in self.lock_delay
|
|
"""
|
|
raise NotImplementedError
|
|
|
|
def postpone_lock(self):
|
|
"""
|
|
Reset timer calling self.lock to self.lock_delay
|
|
"""
|
|
raise NotImplementedError
|
|
|
|
def lock_piece(self):
|
|
if self.shape_fits(self.current_piece.position+Movement.DOWN, self.current_piece.minoes_positions):
|
|
self.postpone_lock()
|
|
return
|
|
|
|
t_spin = self.current_piece.t_spin()
|
|
|
|
for mino_position in self.current_piece.minoes_position:
|
|
position = mino_position + self.current_piece.position
|
|
if position.y >= 0:
|
|
self.matrix[position.y][position.x] = self.current_piece.MINOES_TYPE
|
|
else:
|
|
self.over()
|
|
return
|
|
|
|
nb_rows = 0
|
|
for y, row in enumerate(self.cells):
|
|
if all(mino for mino in row):
|
|
self.cells.pop(y)
|
|
self.cells.insert(0, [Mino.NO_MINO for x in range(self.NB_COLS)])
|
|
nb_rows += 1
|
|
self.piece_locked(nb_rows, t_spin)
|
|
|
|
if t_spin or nb_rows:
|
|
points = self.SCORES[nb_rows][t_spin]
|
|
self.goal -= points
|
|
points *= 100 * self.level
|
|
text = t_spin
|
|
if t_spin and nb_rows:
|
|
text += " "
|
|
if nb_rows:
|
|
text += self.SCORES[nb_rows]["name"]
|
|
self.update_score(points, text)
|
|
|
|
self.combo = self.combo + 1 if nb_rows else -1
|
|
if self.combo >= 1:
|
|
points = (20 if nb_rows==1 else 50) * self.combo * self.level
|
|
text = "COMBO x%d" % self.combo
|
|
self.update_score(points, text)
|
|
|
|
if self.goal <= 0:
|
|
self.new_level()
|
|
|
|
self.new_piece()
|
|
|
|
def update_score(self, points, text):
|
|
self.score += points
|
|
if self.score > self.high_score:
|
|
self.high_score = self.score
|
|
self.show_text("%s\n%d" % (text, points))
|
|
|
|
def show_text(self, text):
|
|
print(text)
|
|
|
|
def pause(self):
|
|
self.time = time.time() - self.time
|
|
|
|
def resume(self):
|
|
self.time = time.time() - self.time
|
|
|
|
def over(self):
|
|
self.show_text("GAME OVER")
|