Python Clock.get_time方法代码示例

# 需要导入模块: from pygame.time import Clock [as 别名]
# 或者: from pygame.time.Clock import get_time [as 别名]
def main():
    """ Starting function for the application. Initialize pygame and quidditas and start
        the game.
    """
    pygame.init()
    pygame.display.set_caption("Tower defense example using Quidditas")
    
    screen = pygame.display.set_mode((640, 480))
    clock = Clock()
    running = 1
    
    images = {}
    images["soldier"] = load("res/soldier.png")

    q = init_quidditas(screen, images)

    while running:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = 0
        q.update(clock.get_time())
        update(clock.get_time())
        render(clock.get_time())

        pygame.display.flip()
        clock.tick(60)

# 需要导入模块: from pygame.time import Clock [as 别名]
# 或者: from pygame.time.Clock import get_time [as 别名]
class Asteroids(object):
    """ Class definition for the asteroids game. """

    def __init__(self):
        """ Create a new instance of the asteroids game. """
        pygame.init()
        pygame.display.set_caption("Asteroids example using Quidditas")

        screen = pygame.display.set_mode((640, 480))
        self.clock = Clock()

        self.to_update = []
        self.to_render= []

        self.event_bus = cyrusbus.Bus()
        self.event_bus.subscribe("event.exit", self.on_exit)

        images = {}
        images["asteroid"] = load("res/asteroid.png")
        images["spaceship"] = load("res/player.png")
        self.q = self.init_quidditas(screen, images)

    def on_exit(self, event):
        """ Handle an exit event that comes via the event bus. """
        self.running = 0

    def start(self):
        """ Start the game loop. """

        self.running = 1
        while self.running:
            for event in pygame.event.get(pygame.QUIT):
                self.running = 0
            time = self.clock.get_time()
            self.q.update(time)
            self.update(time)
            self.render(time)

            self.clock.tick(60)
        pygame.quit()

    def update(self, time):
        """ Iterate over all processors that update game logic and call their update. """
        [processor.update(time) for processor in self.to_update]

    def render(self, time):
        """ Iterate over all processors that render the game and call their update. """
        [processor.update(time) for processor in self.to_render]
        pygame.display.flip()

    def init_quidditas(self, screen, images):
        """ Initialize the quidditas instance and create the processors. """
        q = quidditas.Quidditas()
        q.add_type_definitions(type_definitions.definitions)

        self.to_update.append(q.add_processor(processors.RenderProcessor(screen, images)))
        self.to_update.append(q.add_processor(processors.AsteroidSpawner()))
        self.to_update.append(q.add_processor(processors.ControlsProcessor(self.event_bus)))
        self.to_render.append(q.add_processor(processors.MovementProcessor((640, 480))))
        return q

# 需要导入模块: from pygame.time import Clock [as 别名]
# 或者: from pygame.time.Clock import get_time [as 别名]
def start():
    pygame.init()
    pygame.display.set_caption("Monkey fever")
    pygame.mouse.set_visible(0)

    screen = pygame.display.set_mode((468, 60))
    clock = Clock()

    sounds = {"punch": load_sound("res/punch.wav"),
              "whiff": load_sound("res/whiff.wav")
              }

    q = quidditas.Quidditas()
    q.add_type_definitions(type_definitions.get_definitions())
    fist_proc = q.add_processor(processors.FistControlProcessor())
    punch_proc = q.add_processor(processors.PunchProcessor(sounds))
    chimp_proc = q.add_processor(processors.ChimpMovementProcessor())
    text_proc = q.add_processor(processors.DrawTextProcessor(screen))
    render_proc = q.add_processor(processors.RenderProcessor(screen))

    q.create_entity("chimp")
    q.create_entity("fist")

    running = 1
    while running:
        for event in pygame.event.get(pygame.QUIT):
            running = 0
        time = clock.get_time()
        q.update(time)
        fist_proc.update(time)
        punch_proc.update(time)
        chimp_proc.update(time)
        text_proc.update(time)
        render_proc.update(time)
        
        pygame.display.flip()

        clock.tick(60)
    pygame.quit()
    sys.exit()

# 需要导入模块: from pygame.time import Clock [as 别名]
# 或者: from pygame.time.Clock import get_time [as 别名]
class Application(object):
    """
    @type _config: configparser.ConfigParser
    @type _display: pygame.Surface
    @type _manager: Manager
    @type _scene: AbstractScene
    @type _clock: Clock
    @type _camera: Camera
    @type _run: bool
    @type _state: int
    """

    _config = None
    _display = None
    _manager = None
    _scene = None
    _clock = None
    _camera = None

    _state = GAME_STATE_LOADING
    _run = False

    def __init__(self, config):
        """
        @type config: configparser.ConfigParser
        """
        self._config = config
        self._manager = Manager(self)
        pygame.mixer.init()
        pygame.init()

    def init(self):
        config_display = self._config["DISPLAY"]
        display_width = int(config_display.get("width", 800))
        display_height = int(config_display.get("height", 600))
        display_tup = (display_width, display_height)
        pygame.init()

        fullscreen = int(config_display.get("fullscreen", 0))
        display_flags = DOUBLEBUF | HWSURFACE
        if fullscreen == 1:
            display_flags |= FULLSCREEN
            videoinfo = pygame.display.Info()
            # we have to limit our display to FullHD, to use only one monitor untill pygame with SDL > 1.2.14 released
            display_tup = (min(videoinfo.current_w, 1920), min(videoinfo.current_h, 1080))

        self._display = pygame.display.set_mode(display_tup, display_flags)
        self._camera = Camera(self._display.get_size())
        self._clock = Clock()
        self.set_scene(self._manager.get_scene(MainMenuScene))

    def get_display(self):
        return self._display

    def get_camera(self):
        return self._camera

    def set_state(self, state):
        """
        @type state: int
        """
        self._state = state

    def get_state(self):
        return self._state

    def set_scene(self, scene: AbstractScene):
        self._scene = scene

    def running(self):
        return bool(self._run)

    def run(self, run=False):
        self._run = run
        while self.running():
            events = pygame.event.get()
            for e in events:
                if e.type == EVENT_LOAD_MAP:
                    camera = self._manager.get_camera()
                    map_loading_thread = slg.map.map.MapLoadingThread(
                        e.map_name, slg.map.map.Map(self._manager), camera
                    )
                    map_loading_thread.start()
                if e.type == QUIT:
                    self._run = False
                if e.type == KEYDOWN:
                    if e.key == K_F4 and pygame.key.get_mods() & pygame.KMOD_ALT:
                        self._run = False
                    if e.key == K_t and pygame.key.get_mods() & pygame.KMOD_ALT:
                        print(self.get_state())
            self._manager.handle(events)
            if self._scene:
                self._scene.handle_events(events)
                self._scene.draw()
                pygame.display.update()
                pygame.display.set_caption(
                    "FPS: %.2f" % (self._clock.get_fps()) + "ticks: %.2f" % (self._clock.tick(FPS))
                )

    def get_time(self):
#.........这里部分代码省略.........

# 需要导入模块: from pygame.time import Clock [as 别名]
# 或者: from pygame.time.Clock import get_time [as 别名]
            if collision_pnt:
                e1.collide(e2.id, collision_pnt)
                e2.collide(e1.id, collision_pnt)

    entity_control.kill_finalize()

    player = entity_control.entity_dict[player_id]
    camera.set_pos(player.pos-player.velocity*delta)
    
    #draw loop

    draw_list = Draw_Call_List()

    for e in entity_control.yield_entities():
        draw_list.append(e.draw(debug))

    draw_list.draw()
              
    draw.draw_text(str(clock/1000.0), (0,0), 255, 255, 255)
    draw.draw_text(str(fps_clock.get_fps()), (40,0), 255, 255, 255)
    draw.draw_text(str(map(int, player.pos.tuple())), (0,30), 255, 255, 255)

    draw.draw_text(str(input.player_move), (0,15), 255, 255, 255)

    delta = fps_clock.get_time()
    fps_clock.tick()
    
    draw.flip()

pygame.quit()