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()