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
)
def test_debug_provisions(self):
config_debug = GameConfig(debug_mode=True)
screen_debug = GameScreen(config_debug, GameModel())
window_size_debug = config_debug.get_config_val("window_size")
self.assertEqual(
(window_size_debug[0], window_size_debug[1] + GameScreen.DEBUG_SPACE_PROVISIONS),
screen_debug.screen_size
)
def test_draw(self, draw_rect):
config = GameConfig(window_size=(400, 400))
game_screen = GameScreen(config, GameModel())
window = pygame.display.set_mode(config.get_config_val("window_size"))
btn = Button("Test", Colors.NIGHT_BLUE, (100, 88))
btn.draw(window, game_screen)
draw_rect.assert_any_call(
window, btn.color, (
btn.position[1], btn.position[0], btn.max_size[0],
btn.max_size[1]
)
)
def main():
config = GameConfig()
config.set_config_val("clock_rate", 12)
config.set_config_val("window_size", [500, 500 + ColorBlocksScreen.GRID_OFFSET[0]])
config.set_config_val("window_title", "Color Blocks Game")
screen = ColorBlocksScreen(config, [10, 10])
loop_events = ColorBlocksEvents(screen)
return loop_events
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
)
pastel_flowers = Image(os.path.join("sample_sprites", "tiles", "png", "pastel_flowers.png"))
grass = Image(os.path.join("sample_sprites", "tiles", "png", "grass.png"))
images = (pastel_flowers, grass)
# XXX Just a demo, do not try this at home: this (rightly!) assumes that
# pastel_flowers and grass have the same dimensions
visible_width = int(self.screen_dimensions[GameConfig.WIDTH_INDEX] / pastel_flowers.width)
visible_height = int(self.screen_dimensions[GameConfig.HEIGHT_INDEX] / pastel_flowers.height)
area_tile_size = (visible_width + 2) * (visible_height + 2)
self.tiles = Group()
for i in range(area_tile_size):
img = random.choice(images)
img_xpos = img.width * (i % visible_width)
img_ypos = img.height * (i % visible_height)
self.tiles.add(PyRoSprite(img.clone((img_xpos, img_ypos))))
def draw_screen(self, window):
self.tiles.draw(window)
self.tiles.update()
if __name__ == "__main__":
config = GameConfig()
config.set_config_val("window_size", (400, 400))
model = GameModel()
screen = ExplorableScreen(config, model)
loop_events = GameLoopEvents(config, screen)
loop = GameLoop(loop_events)
loop.go()
def loop_invariant(self):
parent_invariant = super(AmoebaLoopEvents, self).loop_invariant()
return self.__i < self.__limit and parent_invariant
def loop_event(self):
self.window.fill(Colors.WHITE)
upper_bound = len(super(AmoebaLoopEvents, self).game_screen.mutating_shape.point_list) - 1
insertion_point = random.randint(0, upper_bound)
rand_x = random.randint(0, self.config.window_size[GameConfig.WIDTH_INDEX])
rand_y = random.randint(0, self.config.window_size[GameConfig.HEIGHT_INDEX])
super(AmoebaLoopEvents, self).game_screen.mutating_shape.add_point(Point(rand_x, rand_y), insertion_point)
super(AmoebaLoopEvents, self).loop_event()
self.__i += 1
gameconfig = GameConfig()
gameconfig.window_size = [500, 500]
gameconfig.clock_rate = 12
gameconfig.window_title = "Mutating Amoeba"
game_screen = AmoebaScreen(gameconfig.window_size)
loop_events = AmoebaLoopEvents(gameconfig, game_screen)
gameloop = GameLoop(loop_events)
gameloop.go()
A simple demo of using the framework that randomly draws
gray circles on a white canvas.
@author Chad Estioco
"""
class GrayCircle(GameLoopEvents):
def __init__(self, config):
super(GrayCircle, self).__init__(config, GameScreen([500,500]))
self.__limit = 100
self.__count = 0
def loop_invariant(self):
parent_invariant = super(GrayCircle, self).loop_invariant()
return self.__count < self.__limit and parent_invariant
def loop_event(self):
x = random.randint(0, 500)
y = random.randint(0, 500)
pygame.draw.circle(self.window, [218, 218, 218], [x, y], 50, 2)
self.__count += 1
gconfig = GameConfig()
gconfig.clock_rate = 10
gconfig.window_size = [500, 500]
gconfig.window_title = "Framework test"
gc_object = GrayCircle(gconfig)
game_loop = GameLoop(gc_object)
game_loop.go()
from components.core import GameConfig, GameLoop
from grid_model import Grid
from screen import GridLoopEvents, GridScreen
if __name__ == "__main__":
config = GameConfig(window_size=(400, 600), debug_mode=False)
model = Grid((10, 10), max_size=(400, 400))
screen = GridScreen(config, model)
loop_events = GridLoopEvents(screen)
loop = GameLoop(loop_events)
loop.go()
keydown_event = pygame.event.Event(pygame.KEYDOWN)
up_event_handler = GameLoopEvents.KeyboardHandlerMapping(pygame.K_UP, self.move_shooter)
down_event_handler = GameLoopEvents.KeyboardHandlerMapping(pygame.K_DOWN, self.move_shooter)
shoot_event_handler = GameLoopEvents.KeyboardHandlerMapping(pygame.K_RETURN, self.game_screen.shoot)
self.add_event_handler(keydown_event, up_event_handler)
self.add_event_handler(keydown_event, down_event_handler)
self.add_event_handler(keydown_event, shoot_event_handler)
class PVZLoop(GameLoop):
def __init__(self, events):
"""
@param events
Must be an instance of PVZEvents.
"""
super(PVZLoop, self).__init__(events)
config = GameConfig()
config.set_config_val("window_size", [500, 500])
config.set_config_val("clock_rate", 60)
config.set_config_val("window_title", "PvZ Clone Demo")
screen = PVZMainScreen(config)
image_gle = PVZEvents(config, screen)
gl = PVZLoop(image_gle)
gl.go()
def loop_setup(self):
super(ImageLoader, self).loop_setup()
init_x = super(ImageLoader, self).config.window_size[GameConfig.WIDTH_INDEX] - \
self.game_screen.meteormon.width
self.game_screen.meteormon.position = Point(init_x, 0)
class ImageScreen(GameScreen):
@property
def meteormon(self):
return self.__meteormon
def setup(self):
super(ImageScreen, self).setup()
self.__meteormon = Image(os.path.join("sample_sprites","meteormon_clueless.png"))
def draw_screen(self, window):
super(ImageScreen, self).draw_screen(window)
window.fill(Colors.WHITE)
self.meteormon.draw(window)
config = GameConfig()
config.window_size = [500, 500]
config.clock_rate = 12
config.window_title = "Image Class Test"
screen = ImageScreen(config.window_size)
image_gle = ImageLoader(config, screen)
gl = GameLoop(image_gle)
gl.go()
def setUp(self):
self.game_config = GameConfig()
self.watcher = ConfigSubscriberMock()
self.game_config.subscribe(self.watcher)
self.titled_config = GameConfig(window_title="Your Majesty")
class GameConfigTest(unittest.TestCase):
def setUp(self):
self.game_config = GameConfig()
self.watcher = ConfigSubscriberMock()
self.game_config.subscribe(self.watcher)
self.titled_config = GameConfig(window_title="Your Majesty")
def test_window_size_setter(self):
self.assertFalse(self.watcher.notified)
self.game_config.set_config_val("window_size", (100, 100))
self.assertTrue(self.watcher.notified)
def test_clock_rate_setter(self):
self.assertFalse(self.watcher.notified)
self.game_config.set_config_val("clock_rate", 100)
self.assertTrue(self.watcher.notified)
def test_custom_key_setter(self):
self.assertFalse(self.watcher.notified)
self.game_config.set_config_val("quick brown foxkcd", 1)
self.assertTrue(self.watcher.notified)
def test_load_from_file_expected(self):
expected_json_newbies = """{
"song": "Lost Stars",
"artist": "Adam Levine",
"player": "Spotify"
}"""
preload_title = self.titled_config.get_config_val("window_title")
self.assertTrue(preload_title is not None)
self.titled_config.load_from_file(StringIO(expected_json_newbies))
postload_title = self.titled_config.get_config_val("window_title")
self.assertEqual(preload_title, postload_title)
json_confs = json.loads(expected_json_newbies)
for key in json_confs.keys():
self.assertEqual(self.titled_config.get_config_val(key), json_confs[key])
def test_load_from_file_unwanted(self):
unwanted_json = """[
{"song": "Lost Stars"},
{"artist": "Adam Levine"},
{"player": "Spotify"}
]"""
preload_title = self.titled_config.get_config_val("window_title")
self.assertTrue(preload_title is not None)
with self.assertRaises(AttributeError):
self.titled_config.load_from_file(StringIO(unwanted_json))
postload_title = self.titled_config.get_config_val("window_title")
self.assertEquals(preload_title, postload_title)
def test_load_from_file_replacing(self):
replacing_json = '{"window_title": "Your Royal Highness"}'
preload_title = self.titled_config.get_config_val("window_title")
self.assertTrue(preload_title is not None)
self.titled_config.load_from_file(StringIO(replacing_json))
postload_title = self.titled_config.get_config_val("window_title")
self.assertEqual(postload_title, "Your Royal Highness")
self.assertNotEqual(preload_title, postload_title)
self.game_screen.ps.translate(10, 10)
class RandomDrawingScreen(GameScreen):
def __init__(self, config):
super(RandomDrawingScreen, self).__init__(config, GameModel())
self.__ps = PointShape()
self.__ps.add_point(Point(3, 5))
self.__ps.add_point(Point(15, 25))
self.__ps.add_point(Point(10, 40))
self.__ps.add_point(Point(30, 28))
@property
def ps(self):
return self.__ps
def draw_screen(self, window):
window.fill(Colors.MAX_WHITE)
self.ps.draw(window)
if __name__ == "__main__":
config = GameConfig()
config.set_config_val("window_size", (600, 600))
config.set_config_val("clock_rate", 12)
gamescreen = RandomDrawingScreen(config)
loopevents = RandomDrawing(config, gamescreen)
gl = GameLoop(loopevents)
gl.go()
def test_dry_run(self, pygame_init, clock_tick, flip, quit):
config = GameConfig()
config.set_config_val("clock_rate", 60)
config.set_config_val("window_size", (600, 600))
config.set_config_val("window_title", "SNAKE!")
config.set_config_val("debug_mode", True)
config.set_config_val("log_to_terminal", True)
config.set_config_val("difficulty", 1)
screen = SnakeScreen(config, (10, 10))
loop_events = SnakeGameEvents(screen)
loop = GameLoop(loop_events, is_test=True)
loop.go()
self.assertTrue(pygame_init.called)
self.assertTrue(clock_tick.called)
self.assertTrue(flip.called)
self.assertTrue(quit.called)
for i in range(self.grid_width):
for j in range(self.grid_height):
upper_left_x = j * self.block_width
upper_left_y = i * self.block_height
rect = (upper_left_x, upper_left_y, self.block_width, self.block_height)
rect_list.append(rect)
return rect_list
def draw_screen(self, window):
rects = self.get_rects()
for r in rects:
pygame.draw.rect(window, Colors.BLACK, r, 1)
self.dragon_group.draw(window)
self.gun_group.draw(window)
self.hat_group.draw(window)
if __name__ == "__main__":
config = GameConfig()
config.clock_rate = 12
config.window_size = (1357, 708)
config.window_title = "Hat vs Dragons"
screen = MainScreen(config.window_size, (10, 10))
loop_events = GameLoopEvents(config, screen)
loop = GameLoop(loop_events)
loop.go()
self.add_event_handler(keydown_event, GameLoopEvents.KeyboardHandlerMapping(
keycode=pygame.K_UP,
handler=self.__create_move_event_handler(pygame.K_UP)
))
self.add_event_handler(keydown_event, GameLoopEvents.KeyboardHandlerMapping(
keycode=pygame.K_DOWN,
handler=self.__create_move_event_handler(pygame.K_DOWN)
))
self.add_event_handler(keydown_event, GameLoopEvents.KeyboardHandlerMapping(
keycode=pygame.K_LEFT,
handler=self.__create_move_event_handler(pygame.K_LEFT)
))
self.add_event_handler(keydown_event, GameLoopEvents.KeyboardHandlerMapping(
keycode=pygame.K_RIGHT,
handler=self.__create_move_event_handler(pygame.K_RIGHT)
))
if __name__ == "__main__":
config = GameConfig()
config.set_config_val("clock_rate", 60)
config.set_config_val("window_size", (600, 600))
config.set_config_val("window_title", "SNAKE!")
config.set_config_val("debug_mode", True)
config.set_config_val("log_to_terminal", True)
config.set_config_val("difficulty", 1)
screen = SnakeScreen(config, (10, 10))
loop_events = SnakeGameEvents(config, screen)
loop = GameLoop(loop_events)
loop.go()
from components.core import GameConfig
from components.core import GameLoop
from components.core import GameLoopEvents
from components.core import GameScreen
from components.shapes import Point
class DisplayRectangle(GameScreen):
def __init__(self, screen_size):
super(DisplayRectangle, self).__init__(screen_size)
self.__rectangle = Rectangle(Point(10, 10), Point(40, 40), Colors.BLACK)
@property
def rectangle(self):
return self.__rectangle
def draw_screen(self, window):
super(DisplayRectangle, self).draw_screen(window)
self.rectangle.draw(window)
if __name__ == "__main__":
config = GameConfig()
config.clock_rate = 12
config.window_size = [500, 500]
config.window_title = "Rectangle Test"
rscreen = DisplayRectangle(config.window_size)
rloop_events = GameLoopEvents(config, rscreen)
loop = GameLoop(rloop_events)
loop.go()
I want a 500x500 window!
"""
def __init__(self, config, game_screen):
super(LineMesh, self).__init__(config, game_screen)
self.__limit = 200
self.__count = 0
def loop_invariant(self):
parent_invariant = super(LineMesh, self).loop_invariant()
return self.__count < self.__limit and parent_invariant
def loop_event(self):
self.window.fill(Colors.WHITE)
self.game_screen.triangle.draw(self.window)
self.game_screen.triangle.add_point(Point(random.randint(0, 500), random.randint(0, 500)))
self.__count += 1
config = GameConfig()
config.window_size = [500, 500]
config.clock_rate = 10
config.window_title = "Line Mesh"
game_screen = LineMeshScreen(config.window_size)
ms = LineMesh(config, game_screen)
game_loop = GameLoop(ms)
game_loop.go()
