示例#1
0
文件: main.py 项目: millejoh/Islands
class GameLoop(DirectorLoop):
    def __init__(self):
        super().__init__()
        self.clock = GameClock()
        try:
            import IPython.core
            shell = IPython.core.getipython.get_ipython()
            self._kernel = shell.kernel
        except ImportError:
            self._kernel = None

    def terminal_init(self):
        super().terminal_init()
        terminal.set("""
        window.resizeable=true;
        """)

    def get_initial_scene(self):
        return MainMenuScene()

    def terminal_update(self):
        self.clock.tick()
        if self._kernel:
            self._kernel.do_one_iteration()
        return super().terminal_update()
示例#2
0
class GalaxyView:
    def __init__(self):
        self.galaxy = Galaxy()
        self.screen = pygame.display.set_mode((500, 500))
        self.clock = GameClock(FPS, update_callback=self.update)

    def draw_planets(self):
        for _planet in self.galaxy.planets:
            if isinstance(_planet, planet.Planet):
                self.screen.set_at(_planet.position, (255, 255, 255))

    def draw(self):
        self.screen.fill((0, 0, 0))
        self.draw_planets()
        pygame.display.flip()

    def main_loop(self):
        while True:
            self.clock.tick()

    def update(self, dt):
        self.galaxy.apply_dt(dt)
        self.draw()
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit()
示例#3
0
	def run(self):
		def callback(time):
			self.evManager.post(TickEvent())
			return
		clock = GameClock()
		clock.schedule_interval(callback, 0.042)
		#clock.schedule_interval(callback, 0.25)
		
		while self.keepGoing:
			clock.tick()
示例#4
0
    def run(self):
        def callback(time):
            self.evManager.post(TickEvent())
            return

        clock = GameClock()
        clock.schedule_interval(callback, 0.042)
        #clock.schedule_interval(callback, 0.25)

        while self.keepGoing:
            clock.tick()
示例#5
0
def main():
    global clock, pygame_clock, screen, screen_rect, sprite_group, eraser_image
    global USE_PYGAME_CLOCK, DO_KILL, USE_PREDICTION, PYGAME_FPS
    screen = pygame.display.set_mode((800, 600))
    screen.fill(BGCOLOR)
    screen_rect = screen.get_rect()
    eraser_image = screen.copy()
    which_settings = 0
    pygame_clock = pygame.time.Clock()
    clock = GameClock(*SETTINGS[which_settings],
                      update_callback=update_gameclock,
                      frame_callback=display_gameclock)
    clock.schedule_interval(set_caption_gameclock, 1.0)
    clock.use_wait = False
    sprite_group = pygame.sprite.Group([Ball() for i in range(INIT_BALLS)])
    #
    game_is_running = True
    while game_is_running:
        if USE_PYGAME_CLOCK:
            pygame_clock.tick(PYGAME_FPS)
            update_pygame()
            display_pygame()
        else:
            clock.tick()
        #
        for e in pygame.event.get():
            if e.type == QUIT:
                quit()
            elif e.type == KEYDOWN:
                if e.key == K_ESCAPE:
                    quit()
                elif e.key == K_TAB:
                    which_settings += 1
                    if which_settings >= len(SETTINGS):
                        which_settings = 0
                    (clock.max_ups, clock.max_fps) = SETTINGS[which_settings]
                elif e.key == K_1:
                    sprite_group.add(Ball())
                elif e.key == K_b:
                    sprite_group.add([Ball() for i in range(25)])
                elif e.key == K_k:
                    DO_KILL = not DO_KILL
                elif e.key == K_l:
                    USE_PYGAME_CLOCK = not USE_PYGAME_CLOCK
                elif e.key == K_m:
                    if PYGAME_FPS == 0:
                        PYGAME_FPS = 30
                    else:
                        PYGAME_FPS = 0
                elif e.key == K_p:
                    USE_PREDICTION = not USE_PREDICTION
                elif e.key == K_w:
                    clock.use_wait = not clock.use_wait
示例#6
0
def main():
    global clock, pygame_clock, screen, screen_rect, sprite_group, eraser_image
    global USE_PYGAME_CLOCK, DO_KILL, USE_PREDICTION, PYGAME_FPS
    screen = pygame.display.set_mode((800, 600))
    screen.fill(BGCOLOR)
    screen_rect = screen.get_rect()
    eraser_image = screen.copy()
    which_settings = 0
    pygame_clock = pygame.time.Clock()
    clock = GameClock(*SETTINGS[which_settings], update_callback=update_gameclock, frame_callback=display_gameclock)
    clock.schedule_interval(set_caption_gameclock, 1.0)
    clock.use_wait = False
    sprite_group = pygame.sprite.Group([Ball() for i in range(INIT_BALLS)])
    #
    game_is_running = True
    while game_is_running:
        if USE_PYGAME_CLOCK:
            pygame_clock.tick(PYGAME_FPS)
            update_pygame()
            display_pygame()
        else:
            clock.tick()
        #
        for e in pygame.event.get():
            if e.type == QUIT: quit()
            elif e.type == KEYDOWN:
                if e.key == K_ESCAPE: quit()
                elif e.key == K_TAB:
                    which_settings += 1
                    if which_settings >= len(SETTINGS):
                        which_settings = 0
                    (clock.max_ups, clock.max_fps) = SETTINGS[which_settings]
                elif e.key == K_1:
                    sprite_group.add(Ball())
                elif e.key == K_b:
                    sprite_group.add([Ball() for i in range(25)])
                elif e.key == K_k:
                    DO_KILL = not DO_KILL
                elif e.key == K_l:
                    USE_PYGAME_CLOCK = not USE_PYGAME_CLOCK
                elif e.key == K_m:
                    if PYGAME_FPS == 0:
                        PYGAME_FPS = 30
                    else:
                        PYGAME_FPS = 0
                elif e.key == K_p:
                    USE_PREDICTION = not USE_PREDICTION
                elif e.key == K_w:
                    clock.use_wait = not clock.use_wait
示例#7
0
class InteractiveApp(App):
    def __init__(self, kernel):
        self.kernel = kernel
        self.clock = GameClock()
        self.clock.frame_callback = self.my_update

    def init_root(self, width=80, height=26, show_credits=False):
        self.root = tdl.init(width, height)
        self.scratch = tdl.Console(width, height)
        self.temp_console = tdl.Console(width, height)
        self.width, self.height = width, height
        tdl.set_fps(30)
        if show_credits:
            tcod.console_credits()
            # tcod.sys_set_fps(self.max_fps)

    def draw(self):
        self.root.drawStr(1, 2, "No draw method defined, using default method.")
        self.root.drawStr(1, 3, "Time elapsed = {0}".format(tcod.sys_elapsed_milli()))
        self.root.drawStr(1, 4, "FPS = {0}".format(tcod.sys_get_fps()))

    def my_update(self, dt):
        self.root.clear()
        self.draw()
        tdl.flush()

    def runOnce(self):
        """Pump events to this App instance and then return.

        This works in the way described in L{App.run} except it immediately
        returns after the first L{update} call.

        Having multiple L{App} instances and selectively calling runOnce on
        them is a decent way to create a state machine.
        """
        self.kernel.do_one_iteration()
        self.clock.tick()
        for event in get():
            if event.type:  # exclude custom events with a blank type variable
                # call the ev_* methods
                method = 'ev_%s' % event.type  # ev_TYPE
                getattr(self, method)(event)
            if event.type == 'KEYDOWN':
                # call the key_* methods
                method = 'key_%s' % event.key  # key_KEYNAME
                if hasattr(self, method):  # silently exclude undefined methods
                    getattr(self, method)(event)
示例#8
0
class InteractiveApp(App):
    def __init__(self, kernel):
        self.kernel = kernel
        self.clock = GameClock()
        self.clock.frame_callback = self.frame_update

    def init_root(self, width=80, height=26, show_credits=False):
        self.root = tdl.init(width, height)
        self.canvas = tdl.Console(width, height)
        self.temp_console = tdl.Console(width, height)
        self.width, self.height = width, height
        tdl.set_fps(30)
        if show_credits:
            tcod.console_credits()
            # tcod.sys_set_fps(self.max_fps)

    def draw(self):
        self.root.blit(self.canvas)

    def frame_update(self, dt):
        self.root.clear()
        self.draw()
        tdl.flush()

    def runOnce(self):
        """Pump events to this App instance and then return.

        This works in the way described in L{App.run} except it immediately
        returns after the first L{update} call.

        Having multiple L{App} instances and selectively calling runOnce on
        them is a decent way to create a state machine.
        """
        if self.kernel:
            self.kernel.do_one_iteration()
        self.clock.tick()
        for event in get():
            if event.type:  # exclude custom events with a blank type variable
                # call the ev_* methods
                method = 'ev_%s' % event.type  # ev_TYPE
                getattr(self, method)(event)
            if event.type == 'KEYDOWN':
                # call the key_* methods
                method = 'key_%s' % event.key  # key_KEYNAME
                if hasattr(self, method):  # silently exclude undefined methods
                    getattr(self, method)(event)
示例#9
0
class GalaxyView:
    def __init__(self):
        self.galaxy = Galaxy()
        self.screen = pygame.display.set_mode((500, 500))
        self.clock = GameClock(update_callback=self.update, max_ups=30)

    def update(self, dt):
        self.handle_events()
        self.screen.fill((30, 0, 0))
        for i in range(10):
            self.galaxy.apply_dt(dt/(2000*(i+1)))
        self.galaxy.load_from_gpu()
        for _planet in self.galaxy.planets_np:
            temp = _planet.astype(np.int)
            _planet_temp = planet.Planet(r=[temp[0], temp[1]])
            self.screen.set_at(_planet_temp.r, (255, 255, 255))
        pygame.display.flip()

    def handle_events(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                sys.exit()
            elif event.type == pygame.MOUSEBUTTONDOWN:
                self.galaxy.clicked = True
                return
            elif event.type == pygame.MOUSEBUTTONUP:
                self.galaxy.clicked = False
                return
            elif event.type == pygame.MOUSEMOTION:
                if self.galaxy.clicked:
                    x, y = event.pos
                    y = 500-y
                    print(x, y)
                    self.galaxy.click = np.array([x, y], dtype=np.float32)

    def main_loop(self):
        while True:
            self.clock.tick()
示例#10
0
    # noinspection PyUnusedLocal
    def _update(_):
        """
        Pump events to the current GameState and tell its objects to update
        :param _: unused dt provided by GameClock
        :return:
        """
        events = get()
        CONTEXT["gamestate"].handle_input(events)
        CONTEXT["gamestate"].update()
        # gamestate.handle_input(events)
        # gamestate.update()


    # noinspection PyUnusedLocal
    def _draw(_):
        """
        Ask the current GameState to redraw itself
        :param _: unused interp provided by GameClock
        :return:
        """
        # gamestate.draw()
        CONTEXT["gamestate"].draw()
        flip()

    CLOCK = GameClock(max_ups=60, max_fps=60, update_callback=_update, frame_callback=_draw)

    while True:
        CLOCK.tick()