def __init__(self) -> None:
"""Initialise the Tetris application."""
self._field = PlayField(10, 24)
self._generator = RandomGenerator()
self._keymap = {
"Left": MoveCommand("left", self._field),
"Right": MoveCommand("right", self._field),
"Down": MoveCommand("down", self._field),
"space": DropCommand(self),
"Up": RotateCommand("right", self._field),
"x": RotateCommand("right", self._field),
"Control_L": RotateCommand("left", self._field),
"Control_R": RotateCommand("left", self._field),
"z": RotateCommand("left", self._field),
"Shift_L": HoldCommand(self),
"Shift_R": HoldCommand(self),
"c": HoldCommand(self),
"Escape": PlayPauseCommand(self)
}
self._valid_keys = self._keymap.keys()
self._window = AppFrame(self._field, self)
self._field.add_observer(self._window)
self._fall_delay = 1000
self._lock_delay = 500
self._playing = False
self._new_game = True
self._counting_down = False
self._level = 1
self._progress_to_next_level = 0
self._score = 0
self._next_tetrimino = None
self._held = None
self._already_held = False
def create_agents(num_agents, album_sheets=700):
agents = [Agent(album_sheets=album_sheets, idx=i) for i in range(num_agents)]
rd = RandomGenerator('uniform', 0, num_agents - 1)
if num_agents > 1:
for agent in agents:
max_recursions = 10
friends = rd.get_int()
for i in range(friends):
m = rd.get_int()
friend = agents[m]
while friend != agent and friend.idx != agent.idx and max_recursions > 0:
friend = agents[rd.get_int()]
max_recursions -= 1
agent.add_friend(friend)
friend.add_friend(agent)
return agents
def _generate_keys(self):
p = RandomGenerator.prime_integer()
print p
q = RandomGenerator.prime_integer()
print q
n = p * q
totient = (p - 1) * (q - 1)
coprime = totient
while coprime > 0:
try:
e = self._find_coprime(coprime)
d = self._modinv(e, totient)
break
except Exception:
coprime = e - 1
self._public_key = RSAPublicKey(n=n, e=e)
self._private_key = RSAPrivateKey(n=n, d=d)
class RandomGeneratorMethods(unittest.TestCase):
def setUp(self):
self.generator = RandomGenerator()
def test_next(self):
# Ensure that a sequence of seven tetriminoes produced by the
# generator has one of each kind of tetrimino
tetrimino_lst = ["J", "L", "O", "I", "S", "Z", "T"]
lst = []
for i in range(7):
lst.append(self.generator.next())
self.assertEqual(lst.sort(), tetrimino_lst.sort())
class Store():
"""Abstraction of the store in which the agents will buy the album sheets
"""
def __init__(self, distribution, sheets, seed=1):
self.distribution = distribution
self.__rg = RandomGenerator(distribution,
0,
int(sheets - 1),
seed=seed)
def get_sheet(self):
return self.__rg.get_int()
def setUp(self):
self.generator = RandomGenerator()
class Tetris:
"""This is the main application class.
This class acts as the controller and contains the main gameplay
loop.
Public Methods:
- get_level() -> int
- get_score() -> int
- get_playing() -> bool
- get_next() -> Optional[str]
- get_held() -> Optional[str]
- play_or_pause() -> None
- drop() -> None
- hold() -> None
- activate() -> None
"""
def __init__(self) -> None:
"""Initialise the Tetris application."""
self._field = PlayField(10, 24)
self._generator = RandomGenerator()
self._keymap = {
"Left": MoveCommand("left", self._field),
"Right": MoveCommand("right", self._field),
"Down": MoveCommand("down", self._field),
"space": DropCommand(self),
"Up": RotateCommand("right", self._field),
"x": RotateCommand("right", self._field),
"Control_L": RotateCommand("left", self._field),
"Control_R": RotateCommand("left", self._field),
"z": RotateCommand("left", self._field),
"Shift_L": HoldCommand(self),
"Shift_R": HoldCommand(self),
"c": HoldCommand(self),
"Escape": PlayPauseCommand(self)
}
self._valid_keys = self._keymap.keys()
self._window = AppFrame(self._field, self)
self._field.add_observer(self._window)
self._fall_delay = 1000
self._lock_delay = 500
self._playing = False
self._new_game = True
self._counting_down = False
self._level = 1
self._progress_to_next_level = 0
self._score = 0
self._next_tetrimino = None
self._held = None
self._already_held = False
def get_level(self) -> int:
"""Return the current level."""
return self._level
def get_score(self) -> int:
"""Return the current score."""
return self._score
def get_playing(self) -> bool:
"""Return whether or not a game of Tetris is being played."""
return self._playing
def get_next(self) -> Optional[str]:
"""Return the kind of tetrimino that will be played next."""
return self._next_tetrimino
def get_held(self) -> Optional[str]:
"""Return the kind of tetrimino currently being held."""
return self._held
def play_or_pause(self) -> None:
"""If a game of Tetris is playing, pause the game; otherwise,
play the game."""
if self._counting_down: # Can't activate while counting down
return
if self._playing:
self._pause()
else:
self._play()
def _play(self) -> None:
"""Start/Resume a game of Tetris."""
self._window.clear_key()
# Starting a new game
if self._new_game:
self._new_game = False
self._field.clear()
self._held = None
self._field.spawn(self._generator.next())
self._next_tetrimino = self._generator.next()
self._window.remove_game_over_text()
# Resuming a game
else:
self._window.remove_pause_text()
self._counting_down = True
self._window.countdown() # Takes 4 seconds
self._window.after(4000, self._counting_down_false)
self._window.after(4000, self._playing_true)
self._window.after(4000, self._window.update_ui, self)
self._window.after(4000, self._game_loop)
self._window.after(4000, self._listen_to_keys)
def _playing_true(self) -> None:
"""Set self._playing to be true."""
self._playing = True
def _counting_down_false(self) -> None:
"""Set self._counting_down to be false."""
self._counting_down = False
def _pause(self) -> None:
"""Pause a game of Tetris."""
self._playing = False
self._window.show_pause_text()
self._window.update_ui(self)
def drop(self) -> None:
"""Drop the current tetrimino."""
self._field.drop_current()
# Instantly lock
rows_cleared = 0
for y in range(self._field.get_height()):
if self._field.row_is_full(y):
self._field.clear_row(y)
rows_cleared += 1
self._update_scores_and_levels(rows_cleared)
self._update_fall_delay()
if self._game_over():
self._playing = False
self._new_game = True
self._next_tetrimino = None
self._window.update_ui(self)
self._window.show_game_over_text()
self._window.game_over_dialog(self._level, self._score)
self._already_held = False # Can hold again
def hold(self) -> None:
"""Hold the current tetrimino and spawn in the previously held
tetrimino; if such a tetrimino does not exist, spawn a new
tetrimino."""
if self._already_held: # Prevent infinitely spamming hold
return # without placing a tetrimino
self._already_held = True
prev_held = self._held
self._held = self._field.delete_current().kind
if prev_held == None:
self._field.spawn(self._next_tetrimino)
self._next_tetrimino = self._generator.next()
else:
self._field.spawn(prev_held)
self._window.update_ui(self)
def _game_loop(self) -> None:
"""The main gameplay loop for Tetris."""
if self._playing:
# Current tetrimino is set
if not self._field.move_current("down"):
self._already_held = False
self._window.after(self._lock_delay,
self._set_current_tetrimino)
# Current block has fallen one space
else:
self._window.after(self._fall_delay, self._game_loop)
def _set_current_tetrimino(self) -> None:
"""Set the current tetrimino into place, clearing any filled
rows, updating scores, levels and movement delay and check if
the game is over."""
if not self._field.move_current("down"):
rows_cleared = 0
for y in range(self._field.get_height()):
if self._field.row_is_full(y):
self._field.clear_row(y)
rows_cleared += 1
self._update_scores_and_levels(rows_cleared)
self._update_fall_delay()
if self._game_over():
self._playing = False
self._new_game = True
self._next_tetrimino = None
self._window.update_ui(self)
self._window.game_over_dialog(self._level, self._score)
self._window.after(0, self._game_loop)
# User has moved block to where it can fall again
else:
self._window.after(self._fall_delay, self._game_loop)
def _update_scores_and_levels(self, rows_cleared: int) -> None:
"""Update the score and level based on how many rows were
cleared."""
if rows_cleared == 1:
self._progress_to_next_level += 1
self._score += 100 * self._level
elif rows_cleared == 2:
self._progress_to_next_level += 3
self._score += 300 * self._level
elif rows_cleared == 3:
self._progress_to_next_level += 5
self._score += 500 * self._level
elif rows_cleared == 4:
self._progress_to_next_level += 8
self._score += 800 * self._level
if self._progress_to_next_level >= self._level * 5:
self._progress_to_next_level -= self._level * 5
self._level += 1
self._window.update_ui(self)
def _update_fall_delay(self) -> None:
"""Update the speed at which tetriminoes fall based on the
current level."""
self._fall_delay = (0.8 - (self._level - 1) * 0.007)**(self._level - 1)
self._fall_delay *= 1000
self._fall_delay = int(self._fall_delay)
def _game_over(self) -> bool:
"""Return whether the game is over.
If the game is not over, this method has the side effect of
spawning the next tetrimino."""
over = (self._field.lock_out()
or not self._field.spawn(self._next_tetrimino))
self._next_tetrimino = self._generator.next()
self._window.update_ui(self)
return over
def _listen_to_keys(self) -> None:
"""Respond to user keyboard input."""
if self._playing:
key = self._window.get_key()
if key in self._valid_keys:
cmd = self._keymap[key]
cmd.execute()
self._window.after(10, self._listen_to_keys)
else:
key = self._window.get_key()
if key == "Escape": # If not playing only listen to the
cmd = self._keymap[key] # escape key which pauses/plays the
cmd.execute() # game
self._window.after(10, self._listen_to_keys)
def activate(self) -> None:
"""Activate the application."""
self._field.notify_observers()
self._window.update_ui(self)
self._window.mainloop()
def __init__(self, distribution, sheets, seed=1):
self.distribution = distribution
self.__rg = RandomGenerator(distribution,
0,
int(sheets - 1),
seed=seed)