def test_default_event_handling(self):
     screen = SampleGameScreenUI(GameConfig(), GameModel())
     loop_events = GameLoopEvents(screen)
     loop_events.loop_setup()
     loop = GameLoop(loop_events)
     # Python sorcery!
     loop._GameLoop__handle_event(pygame.event.Event(pygame.MOUSEBUTTONDOWN))
     self.assertTrue(screen.evh.is_called)
    def test_dry_run(self, pygame_init, clock_tick, flip, quit):
        config = GameConfig()
        model = GameModel()
        screen = GameScreen(config, model)
        loop_events = LoopEventsMock(config, screen)
        loop = GameLoop(loop_events)
        loop.go()

        self.assertTrue(pygame_init.called)
        self.assertTrue(clock_tick.called)
        self.assertTrue(flip.called)
        self.assertTrue(quit.called)
 def test_event_handling_basic(self):
     """
     Test basic event handling of non-keyboard-based events.
     """
     screen = GameScreen(GameConfig(), GameModel())
     loop_events = GameLoopEvents(screen)
     evh1 = EventHandlerMock()
     loop_events.add_event_handler(self.btn_down_event, evh1.handle_event)
     loop = GameLoop(loop_events)
     # More Python sorcery!
     loop._GameLoop__handle_event(self.btn_down_event)
     self.assertTrue(evh1.is_called)
 def test_event_handling_kbd_basic(self):
     """
     Test basic event handling of keyboard-based events.
     """
     screen = GameScreen(GameConfig(), GameModel())
     loop_events = KeyboardHandlingLoopEventsMock(screen)
     evh1 = EventHandlerMock()
     loop_events.key_controls.register_key(pygame.K_UP, evh1.handle_event)
     loop_events.attach_event_handlers()
     loop = GameLoop(loop_events)
     # More Python sorcery!
     loop._GameLoop__handle_event(self.press_up_key_event)
     self.assertTrue(evh1.is_called)
 def test_event_handling_multiple(self):
    """
    Test that multiple event handlers can listen on the same non-keyboard-based
    event.
    """
    screen = GameScreen(GameConfig(), GameModel())
    loop_events = GameLoopEvents(screen)
    evh1 = EventHandlerMock()
    evh2 = EventHandlerMock()
    loop_events.add_event_handler(self.btn_down_event, evh1.handle_event)
    loop_events.add_event_handler(self.btn_down_event, evh2.handle_event)
    loop = GameLoop(loop_events)
    # More Python sorcery!
    loop._GameLoop__handle_event(self.btn_down_event)
    self.assertTrue(evh1.is_called)
    self.assertTrue(evh2.is_called)
    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)
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()
    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 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()
Exemple #11
0
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()