def main(window):
sys.excepthook = onexception
logging.basicConfig(filename='app.log',
format='%(name)s - %(levelname)s - %(message)s',
level=logging.INFO)
renderer = Renderer()
gameloop = GameLoop(renderer)
gameloop.start()
def build_essentials(self):
"""A method which resets important objects for loading a different level
"""
self.load_level_list()
self.load_level()
self.gui = Gui((640, 360))
self.add_healthbars()
self.renderer = Renderer(self.display, self.level, self.gui)
self.game_loop = GameLoop(self.level, self.renderer, self.event_queue,
self.clock, CELL_SIZE, self.gui, self.mixer)
def play(self):
pygame.init()
display = pygame.display.set_mode((800, 700))
display.fill((230, 210, 170))
pygame.display.set_caption("TETRIS")
gameloop = GameLoop(display)
font = pygame.font.SysFont("comicsans", 60, bold=True)
title = font.render("TETRIS", 1, (210, 150, 75))
font = pygame.font.SysFont("comicsans", 30)
next_piece = font.render("NEXT PIECE:", 1, (210, 150, 75))
high_score = font.render("HIGH SCORE:", 1, (210, 150, 75))
font = pygame.font.SysFont("comicsans", 40)
score = font.render(gameloop.hscore, 1, (210, 150, 75))
display.blit(title, (250, 50))
display.blit(next_piece, (600, 100))
display.blit(high_score, (10, 100))
display.blit(score, (10, 150))
gameloop.handle_events()
def loop_switch(self, next_loop: str):
"""
this function chooses the next current_loop based on it's input
Args:
next_loop: string that tells the mainloop the next subloop
"""
if next_loop == "gameloop":
self.current_loop = GameLoop()
elif next_loop == "startloop":
self.current_loop = StartLoop()
elif next_loop == "scoreloop":
self.current_loop = ScoreLoop()
elif next_loop == "exit":
self.running = False
def setUp(self):
self.gameloop = GameLoop()
def create_gameloop():
player = Player(-2019)
levels = (create_level_0(), create_level_1(), create_level_2(), create_level_3())
return GameLoop(player, levels, 1, create_tut_lev(), create_won_lev(), create_lost_lev())
'''Reaction/Memory Light Game main module
There are two main parts to the program: The game loop, found in the gameloop module, and the
webapp code, using the Flask framework, found in this module.
'''
from queue import Empty, Queue
from flask import Flask, render_template
from flask_json import FlaskJSON, as_json
from gameloop import GameLoop
from player import Player
events_queue = Queue()
game = GameLoop((
Player('One', buttons=(24, 18), led=(17, 27, 22)),
Player('Two', buttons=(21, 20), led=(2, 3, 4)),
Player('Three', buttons=(16, 12), led=(26, 19, 13)),
), events_queue)
app = Flask(__name__)
json = FlaskJSON(app)
def names_and_scores():
sorted_players = list(game.players)
sorted_players.sort(key=lambda player: player.wins, reverse=True)
return [[
p.name, p.wins,
p.fastest_ms() or '',
p.mean_ms() or '',
p.slowest_ms() or ''
] for p in sorted_players]
def Menu(score_list):
pygame.init()
pygame.mixer.init()
menu = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Carrot Time")
pygame.event.set_blocked(pygame.MOUSEMOTION)
menu_image = pygame.image.load(os.path.join(IMG_FOLDER,
"menu.png")).convert()
menu_image = pygame.transform.scale(menu_image, (WIDTH, HEIGHT))
click_sound = pygame.mixer.Sound(os.path.join(SOUND_FOLDER, "click.wav"))
click_sound.set_volume(1)
big_font = pygame.font.SysFont("Arial", 30, False, False)
mini_font = pygame.font.SysFont("Arial", 15, False, False)
menu.fill(WHITE)
menu.blit(menu_image, (0, 0))
# create three buttons
Button(menu, "Start", YELLOW, 50, 310, 100, 50)
Button(menu, "High Scores", YELLOW, 50, 370, 100, 50)
Button(menu, "Quit", RED, 50, 430, 100, 50)
intro = True
while intro:
for event in pygame.event.get():
if event.type == pygame.QUIT:
intro = False
pygame.quit()
if event.type == pygame.MOUSEBUTTONDOWN:
cur = pygame.mouse.get_pos()
# button 1
if 50 < cur[0] < 150 and 310 < cur[1] < 360:
click_sound.play()
Button(menu, "Start", ORANGE, 50, 310, 100, 50)
pygame.display.update()
GameLoop(score_list)
# button 2
if 50 < cur[0] < 150 and 370 < cur[1] < 420:
click_sound.play()
Button(menu, "High Scores", ORANGE, 50, 370, 100, 50)
pygame.display.update()
# get the first 10 high scores
leng = len(score_list)
if leng < 10:
while len(score_list) < 10:
score_list.append(0)
for s in score_list:
print(s)
if leng >= 10:
for i in range(10):
print(score_list[i])
# display 10 high scores
e = True
while e:
pygame.draw.rect(menu, ORANGE, (0, 200, WIDTH, 200))
title = big_font.render("High Scores", False, BLACK)
rect = title.get_rect()
rect.center = (WIDTH / 2 - 10, 220)
menu.blit(title, rect)
text = mini_font.render("Back? Y/N", False, BLACK)
rect = text.get_rect()
rect.center = (WIDTH / 2 - 10, 380)
menu.blit(text, rect)
t1 = mini_font.render(str(score_list[0]), False, BLACK)
rect = t1.get_rect()
rect.center = (200, 250)
menu.blit(t1, rect)
t2 = mini_font.render(str(score_list[1]), False, BLACK)
rect = t2.get_rect()
rect.center = (200, 270)
menu.blit(t2, rect)
t3 = mini_font.render(str(score_list[2]), False, BLACK)
rect = t3.get_rect()
rect.center = (200, 290)
menu.blit(t3, rect)
t4 = mini_font.render(str(score_list[3]), False, BLACK)
rect = t4.get_rect()
rect.center = (200, 310)
menu.blit(t4, rect)
t5 = mini_font.render(str(score_list[4]), False, BLACK)
rect = t5.get_rect()
rect.center = (200, 330)
menu.blit(t5, rect)
t6 = mini_font.render(str(score_list[5]), False, BLACK)
rect = t6.get_rect()
rect.center = (270, 250)
menu.blit(t6, rect)
t7 = mini_font.render(str(score_list[6]), False, BLACK)
rect = t7.get_rect()
rect.center = (270, 270)
menu.blit(t7, rect)
t8 = mini_font.render(str(score_list[7]), False, BLACK)
rect = t8.get_rect()
rect.center = (270, 290)
menu.blit(t8, rect)
t9 = mini_font.render(str(score_list[8]), False, BLACK)
rect = t9.get_rect()
rect.center = (270, 310)
menu.blit(t9, rect)
t10 = mini_font.render(str(score_list[9]), False,
BLACK)
rect = t10.get_rect()
rect.center = (270, 330)
menu.blit(t10, rect)
pygame.display.update()
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_y:
Menu(score_list)
if event.key == pygame.K_n:
e = False
# button 3
if 50 < cur[0] < 150 and 430 < cur[1] < 480:
click_sound.play()
Button(menu, "Quit", ORANGE, 50, 430, 100, 50)
pygame.display.update()
pygame.quit()
pygame.display.update()
pygame.quit()
def setUp(self):
self.tetris = Tetris()
self.display = pygame.display.set_mode((800, 700))
self.gameloop = GameLoop(self.display)
self.blocks = Blocks()
class TestTetris(unittest.TestCase):
def setUp(self):
self.tetris = Tetris()
self.display = pygame.display.set_mode((800, 700))
self.gameloop = GameLoop(self.display)
self.blocks = Blocks()
def test_board_setup_is_right(self):
correct_ans = []
for i in range(35):
row = []
for j in range(15):
row.append((255, 255, 255))
correct_ans.append(row)
self.gameloop.setup_board()
self.assertEqual(self.gameloop.board, correct_ans)
def test_board_setup_is_right_with_blocks(self):
self.gameloop.blocks_on_board[(0, 1)] = (0, 255, 0)
self.gameloop.blocks[(0, 2)] = (0, 255, 0)
correct_ans = []
for i in range(35):
row = []
for j in range(15):
row.append((255, 255, 255))
correct_ans.append(row)
correct_ans[1][0] = (0, 255, 0)
correct_ans[2][0] = (0, 255, 0)
self.gameloop.setup_board()
self.assertEqual(self.gameloop.board, correct_ans)
def test_block_is_the_right_shape(self):
block = self.gameloop.block
if block in self.blocks.blocks:
return True
def test_block_is_the_right_color(self):
block = self.gameloop.block
if block[0]["color"] in self.blocks.blocks[0]["color"]:
return True
def test_block_position_is_right(self):
block = self.gameloop.block
self.gameloop.setup_board()
if (block[0], block[1]) in self.gameloop.board:
return True
def test_is_block_at_the_tetris_board(self):
board = [(j, i) for i in range(len(self.gameloop.board))
for j in range(len(self.gameloop.board[i]))]
if (self.gameloop.block[1], self.gameloop.block[2]) in board:
return True
def test_block_is_moving_down(self):
block = self.gameloop.block
self.gameloop.block_moves("down")
self.assertEqual((block[1], block[2]), (0, 1))
self.assertEqual(self.gameloop._can_move(), True)
def test_block_is_moving_right(self):
block = self.gameloop.block
self.gameloop.block_moves("right")
self.assertEqual((block[1], block[2]), (1, 0))
def test_block_is_moving_left(self):
block = self.gameloop.block
self.gameloop.block_moves("left")
self.assertEqual((block[1], block[2]), (-1, 0))
def test_block_doesnt_move_past_left_border(self):
self.gameloop.block = [self.blocks.square, 0, 0]
for i in range(20):
self.gameloop.block_moves("left")
self.gameloop._can_move()
self.assertEqual(self.gameloop.filled_in[0][0], 0)
def test_block_doesnt_move_past_right_border(self):
self.gameloop.block = [self.blocks.square, 0, 0]
for i in range(20):
self.gameloop.block_moves("right")
self.gameloop._can_move()
self.assertEqual(self.gameloop.filled_in[0][0], 13)
def test_block_doesnt_move_too_far(self):
self.gameloop.block = [self.blocks.square, 0, 0]
for i in range(25):
self.gameloop.block_moves("down")
self.gameloop._can_move()
self.assertEqual(self.gameloop._can_move(), False)
def test_block_doesnt_overlap_with_other_block(self):
self.gameloop.blocks_on_board[(0, 2)] = (0, 0, 0)
self.gameloop.filled_in.append((0, 1))
self.assertEqual(self.gameloop._can_move(), False)
def test_block_stop_works(self):
self.gameloop.blocks[(0, 2)] = (0, 0, 0)
self.gameloop.block_stop()
self.assertEqual(self.gameloop.blocks_on_board[(0, 2)],
self.gameloop.blocks[(0, 2)])
def test_block_rotate_rotates(self):
block = self.gameloop.block
self.gameloop.block_rotate()
self.assertEqual(block[0]["shape"][1],
block[0]["shape"][self.gameloop.rotation])
def test_block_rotate_work_with_multiple_rotations(self):
self.gameloop.block = [self.blocks.stick, 0, 0]
self.gameloop.block_rotate()
self.gameloop.block_rotate()
self.assertEqual(self.gameloop.rotation, 0)
def test_clear_row_works(self):
for i in range(len(self.gameloop.board[34])):
self.gameloop.board[34][i] = (0, 255, 0)
self.gameloop.clear_row()
correct_ans = []
for i in range(len(self.gameloop.board[34])):
correct_ans.append((255, 255, 255))
self.assertEqual(correct_ans, self.gameloop.board[0])
def test_score_changes(self):
for i in range(len(self.gameloop.board[34])):
self.gameloop.board[34][i] = (0, 255, 0)
self.gameloop.clear_row()
self.assertEqual(10, self.gameloop.score)
def test_changes_pieces(self):
self.gameloop.block_stop()
self.assertEqual(True, self.gameloop.get_new_block)
def test_change_block_works(self):
self.gameloop.get_new_block = True
old_next_block = self.gameloop._next_block
self.gameloop.change_block()
self.assertEqual(self.gameloop.block, old_next_block)
self.assertEqual(self.gameloop.get_new_block, False)
class Main:
"""The main game class, in charge of loading levels and handling
features which are outside the game loop
Attributes:
display: a pygame display object
level_list: list of levels
level_id: id of the current level
level: Level object
event_queue: EventQueue object
clock: a pygame clock object
mixer: a mixer object
"""
def __init__(self):
"""Class constructor. Loads everything into memory
"""
self.display = pg.display.set_mode((640, 360))
pg.display.set_caption("Crawler")
pg.init()
self.level_list = None
self.gui = Gui((640, 360))
self.level_id = 0
self.level = None
self.event_queue = EventQueue()
self.clock = Clock()
self.renderer = Renderer(self.display, self.level, self.gui)
self.mixer = Mixer()
self.mixer.load_track(0)
self.mixer.set_volume(0.3)
self.game_loop = None
self.menu_loop = MenuLoop(self.renderer, self.event_queue, self.clock)
self.start_menu()
def load_level_list(self):
"""Resets the level list from database
"""
self.level_list = DB_CONNECTION.get_map_data()
def build_essentials(self):
"""A method which resets important objects for loading a different level
"""
self.load_level_list()
self.load_level()
self.gui = Gui((640, 360))
self.add_healthbars()
self.renderer = Renderer(self.display, self.level, self.gui)
self.game_loop = GameLoop(self.level, self.renderer, self.event_queue,
self.clock, CELL_SIZE, self.gui, self.mixer)
def load_level(self):
"""Loads a different level into memory
"""
self.level = Level(self.level_list[self.level_id], CELL_SIZE)
def add_healthbars(self):
"""A method which adds health bars for all entities in a level
"""
for enemy in self.level.enemies:
self.gui.set_health_bar(enemy)
self.gui.set_player_health_bar(self.level.player)
def load_level_id(self):
"""A method which fetches the level id of a saved game from a database
"""
data = DB_CONNECTION.get_player_data()
if data:
self.level_id = data[2]
def load_player_data(self):
"""Loads a save game from a database
"""
data = DB_CONNECTION.get_player_data()
if data:
self.level.player.current_health = data[0]
self.level.player.inventory = data[1]
self.gui.set_player_health_bar(self.level.player)
def store_player_data(self):
"""A method which stores player data into a database
"""
DB_CONNECTION.store_player_data(self.level.player, self.level_id)
def start_menu(self):
"""Method which starts a menu loop and is the backbone of the game
"""
state = self.menu_loop.start()
if state != -1:
if state == 0:
DB_CONNECTION.reset_player_data()
self.level_id = 0
self.build_essentials()
if state == 1 and not self.level:
self.load_level_id()
self.build_essentials()
self.load_player_data()
self.run()
def run(self):
"""Method which starts the main game loop
"""
self.mixer.play_music(loops=-1)
state = self.game_loop.start()
if state == 1:
self.start_menu()
if state == 3:
self.level_id += 1
if self.level_id == len(self.level_list):
self.level_id = 0
self.store_player_data()
self.build_essentials()
self.load_player_data()
self.run()
if state == 4:
DB_CONNECTION.reset_player_data()
self.__init__()