def test_draw(self, draw_rect, draw_line):
game_screen = GameScreen(GameConfig(), GameModel())
window = pygame.display.set_mode((1, 1))
quadratic_grid = QuadraticGrid(4, 4)
quadratic_grid.draw(window, game_screen)
self.assertTrue(draw_rect.called)
self.assertFalse(draw_line.called)
def test_draw_borders(self, draw_rect, draw_line):
game_screen = GameScreen(GameConfig(), GameModel())
window = pygame.display.set_mode((1, 1))
qg = QuadraticGrid(4, 4, border_properties=BorderProperties())
qg.draw(window, game_screen)
self.assertTrue(draw_rect.called)
self.assertTrue(draw_line.called)
def test_get_clicked_algorithmspkg(self):
algrid_config = GameConfig(window_size=(600, 600), debug_mode=True)
algrid_screen = GameScreen(algrid_config, GameModel())
algrid_qg = QuadraticGrid(
10, 10, diag_neighbors=False, border_properties=BorderProperties()
)
self.assertEqual((4, 7), algrid_qg.get_clicked_cell(algrid_screen, (424, 294)))
def test_draw_borders_woffset(self, draw_rect, draw_line):
config = GameConfig(window_size=(500, 600))
game_screen = GameScreen(config, GameModel())
window = pygame.display.set_mode(config.get_config_val("window_size"))
border_prop = BorderProperties()
draw_offset = (100, 0)
qg = QuadraticGrid(10, 10, draw_offset=draw_offset, border_properties=border_prop)
qg.draw(window, game_screen)
self.assertTrue(draw_rect.called)
block_dim = 50
# Python sorcery
self.assertEqual(block_dim, qg._QuadraticGrid__compute_block_dimension(config, "width"))
self.assertEqual(block_dim, qg._QuadraticGrid__compute_block_dimension(config, "height"))
window_dimensions = config.get_config_val("window_size")
# The horizontal borders
for i in range(10):
y = i * block_dim + draw_offset[0]
draw_line.assert_any_call(
window, border_prop.color, (0, y), (window_dimensions[0], y),
border_prop.thickness
)
# The vertical borders
for i in range(10):
x = i * block_dim
draw_line.assert_any_call(
window, border_prop.color, (x, draw_offset[0]), (x, window_dimensions[1]),
border_prop.thickness
)
class ColorBlocksScreen(GameScreen):
COLOR_MAPPING = (Colors.LUCID_DARK, Colors.HUMAN_RED, Colors.HUMAN_GREEN,
Colors.HUMAN_BLUE, Colors.LIGHT_GRAY)
GRID_OFFSET = (100, 0)
def __init__(self, config, grid_size):
"""
Instantiates a ColorBlocksScreen instance.
@param screen_size
The dimensions of the screen. An iterable whose first element
is taken for the width while the second one is taken for the
height.
@param grid_size
The size of the grid, in squares per dimension. First element
is taken for the width while the second one is taken for the
height.
"""
super(ColorBlocksScreen, self).__init__(config, ColorBlocksModel(grid_size[0], grid_size[1], 2))
screen_size = config.get_config_val("window_size")
self.game_model = self.model
# Instantiate an underlying grid model
self.block_width = int(math.floor((screen_size[0] - ColorBlocksScreen.GRID_OFFSET[1]) / grid_size[0]))
self.block_height = int(math.floor((screen_size[1] - ColorBlocksScreen.GRID_OFFSET[0]) / grid_size[1]))
self.grid_model = QuadraticGrid(
grid_size[0], grid_size[1],
draw_offset=ColorBlocksScreen.GRID_OFFSET,
border_properties=BorderProperties()
)
self.rect_list = []
self.color_list = []
def setup(self):
self.represent_tiles()
def represent_tiles(self):
"""
Scans the game model and then lists their assigned colors.
"""
# rect_list and color_list are associative arrays.
# for the rect described in rect_list, its color is
# in color_list.
self.rect_list, self.color_list = QuadraticGrid.cons_rect_list(
self.grid_model, self.model, self.block_width, self.block_height,
offset=ColorBlocksScreen.GRID_OFFSET
)
def draw_screen(self, window):
self.grid_model.draw(window, self)
score_font = pygame.font.Font(None, 25)
score = score_font.render("Score: " + str(self.game_model.score), True, Colors.HUMAN_RED)
window.blit(score, [10, 10])
def __init__(self, config, grid_size):
"""
Instantiates a ColorBlocksScreen instance.
@param screen_size
The dimensions of the screen. An iterable whose first element
is taken for the width while the second one is taken for the
height.
@param grid_size
The size of the grid, in squares per dimension. First element
is taken for the width while the second one is taken for the
height.
"""
super(ColorBlocksScreen, self).__init__(config, ColorBlocksModel(grid_size[0], grid_size[1], 2))
screen_size = config.get_config_val("window_size")
self.game_model = self.model
# Instantiate an underlying grid model
self.block_width = int(math.floor((screen_size[0] - ColorBlocksScreen.GRID_OFFSET[1]) / grid_size[0]))
self.block_height = int(math.floor((screen_size[1] - ColorBlocksScreen.GRID_OFFSET[0]) / grid_size[1]))
self.grid_model = QuadraticGrid(
grid_size[0], grid_size[1],
draw_offset=ColorBlocksScreen.GRID_OFFSET,
border_properties=BorderProperties()
)
self.rect_list = []
self.color_list = []
def draw_screen(self, window):
snake_squares = self.game_model.snake.enumerate_snake_squares()
for snake_pos in snake_squares:
color = Colors.DIM_GRAY if snake_pos == self.game_model.snake.head else Colors.EBONY
snake_pos = QuadraticGrid.make_rect(snake_pos, self.block_width, self.block_height)
pygame.draw.rect(window, color, snake_pos, 0)
if self.game_model.food_point:
fp_rect = QuadraticGrid.make_rect(self.game_model.food_point, self.block_width, self.block_height)
pygame.draw.rect(window, Colors.NIGHT_GRAY, fp_rect, 0)
if self.game_model.is_endgame():
# Render a "Game Over" sign
game_over_render = SnakeScreen.GAME_OVER_FONT.render("GAME OVER", True, Colors.HUMAN_RED)
window.blit(game_over_render, (50, 50))
self.automove_schedule.event()
def represent_tiles(self):
"""
Scans the game model and then lists their assigned colors.
"""
# rect_list and color_list are associative arrays.
# for the rect described in rect_list, its color is
# in color_list.
self.rect_list, self.color_list = QuadraticGrid.cons_rect_list(
self.grid_model, self.model, self.block_width, self.block_height,
offset=ColorBlocksScreen.GRID_OFFSET
)
def __init__(self, grid_size, max_size):
super(Grid, self).__init__()
self.qg = QuadraticGrid(grid_size[0],
grid_size[1],
max_size[0],
max_size[1],
diag_neighbors=False,
border_properties=BorderProperties())
for i in range(grid_size[0]):
for j in range(grid_size[1]):
self.qg.grid[i][j] = GridScreen.UNTAKEN
def test_draw_borders_wparams(self, draw_rect, draw_line):
config = GameConfig(window_size=(400, 400))
game_screen = GameScreen(config, GameModel())
window = pygame.display.set_mode(config.get_config_val("window_size"))
border_prop = BorderProperties()
qg = QuadraticGrid(2, 2, border_properties=border_prop)
qg.draw(window, game_screen)
self.assertTrue(draw_rect.called)
# The vertical borders
draw_line.assert_any_call(
window, border_prop.color, (0, 0), (0, 400),
border_prop.thickness
)
draw_line.assert_any_call(
window, border_prop.color, (200, 0), (200, 400),
border_prop.thickness
)
draw_line.assert_any_call(
window, border_prop.color, (400, 0), (400, 400),
border_prop.thickness
)
# The horizontal borders
draw_line.assert_any_call(
window, border_prop.color, (0, 0), (400, 0),
border_prop.thickness
)
draw_line.assert_any_call(
window, border_prop.color, (0, 200), (400, 200),
border_prop.thickness
)
draw_line.assert_any_call(
window, border_prop.color, (0, 400), (400, 400),
border_prop.thickness
)
def test_adjacent_list(self):
one_row = QuadraticGrid(5, 1)
adj = one_row.get_adjacent(0, 0)
self.assertEqual(set(adj), set([(0, 1)]))
adj = one_row.get_adjacent(0, 3)
self.assertEqual(set(adj), set([(0, 2), (0, 4)]))
adj = one_row.get_adjacent(0, 4)
self.assertEqual(set(adj), set([(0, 3)]))
one_col = QuadraticGrid(1, 5)
adj = one_col.get_adjacent(0, 0)
self.assertEqual(set(adj), set([(1, 0)]));
adj = one_col.get_adjacent(3, 0)
self.assertEqual(set(adj), set([(2, 0), (4, 0)]))
adj = one_col.get_adjacent(4, 0)
self.assertEqual(set(adj), set([(3, 0)]))
matrix = QuadraticGrid(3, 4)
adj = matrix.get_adjacent(0, 0)
self.assertEqual(set(adj), set([(0, 1), (1, 0), (1, 1)]))
adj = matrix.get_adjacent(0, 2)
self.assertEqual(set(adj), set([(0, 1), (1, 1), (1, 2)]))
adj = matrix.get_adjacent(3, 0)
self.assertEqual(set(adj), set([(2, 0), (2, 1), (3, 1)]))
adj = matrix.get_adjacent(3, 2)
self.assertEqual(set(adj), set([(3, 1), (2, 1), (2, 2)]))
adj = matrix.get_adjacent(2, 1)
self.assertEqual(set(adj), set([(2, 0), (2, 2), (1, 0), (1, 1), (1, 2), (3, 0), (3, 1), (3, 2)]))
self.assertRaises(IndexError, matrix.get_adjacent, 10, 10)
self.assertRaises(TypeError, matrix.get_adjacent, 0.0, "zero")
def test_get_clicked(self):
grid_config = GameConfig(window_size=(600, 400))
screen = GameScreen(grid_config, GameModel())
qg = QuadraticGrid(10, 10, 400, 400)
self.assertIsNone(qg.get_clicked_cell(screen, (404, 404)))
def test_get_clicked_width_limited(self):
grid_config = GameConfig(window_size=(600, 400))
screen = GameScreen(grid_config, GameModel())
qg = QuadraticGrid(10, 10, 400, 400)
self.assertEqual((8, 3), qg.get_clicked_cell(screen, (121, 323)))
def test_get_clicked_cell_squarefull(self):
square_config = GameConfig(window_size=(80, 80))
square_screen = GameScreen(square_config, GameModel())
square_grid = QuadraticGrid(8, 8)
self.assertEqual((7, 3), square_grid.get_clicked_cell(square_screen, (36, 74)))
