Python Clock.get_fps方法代码示例

# 需要导入模块: from pygame.time import Clock [as 别名]
# 或者: from pygame.time.Clock import get_fps [as 别名]
def main():
    """Main program loop"""
    
    pygame.init()
    screen = pygame.display.set_mode(opt.window_size)
    
    sys_font = Font(get_default_font(), opt.font_size)
    clock = Clock()
    
    manager = YarsManager()

    running = True
    
    while running:
        #limit framerate and prepare FPS display text
        clock.tick(opt.max_framerate)
        fps = clock.get_fps()
        fps_text = sys_font.render("FPS: {0:.1f}".format(fps), False, opt.white)
        
        if event.get(pygame.QUIT):
            sys.exit()

        running = manager.handle_events(event.get(), key.get_pressed())
        manager.update()

        screen.fill(opt.black)
        manager.draw(screen)
        screen.blit(fps_text, fps_text.get_rect(top = 0, right = opt.width))
        pygame.display.update()
		
    sys.exit()

# 需要导入模块: from pygame.time import Clock [as 别名]
# 或者: from pygame.time.Clock import get_fps [as 别名]
def main():
    """The main function of the game.
    Initializes PyGame objects and then enters the game loop
    """
    
    pygame.init()
    screen = pygame.display.set_mode(window_size)
    
    sys_font = Font(get_default_font(), font_size)
    clock = Clock()
    
    #now that pygame is initialized, initialize inherited classes properly
    global enemy_wave, player
    enemy_wave = EnemyGroup(evil_bullets)
    
    player = Player(window_size, ship_filename, ship_speed)
    
    while 1:
        #limit framerate and prepare FPS display text
        clock.tick(max_framerate)
        fps = clock.get_fps()
        fps_text = sys_font.render("FPS: {0:.1f}".format(fps), False, white)
        
        score_text = sys_font.render("SCORE: {}".format(score), False, white)
        lives_text = sys_font.render("MANS: {}".format(lives), False, white)
    
        #check for QUIT event to prevent endless loopage
        for event in pygame.event.get():
            if event.type == pygame.QUIT: sys.exit()
            
        #call the game's thinking functions
        check_gameover()
        keyboard()
        evil_bullets.update()
        good_bullets.update()
        enemy_wave.update()
        collisions()
            
        #draw the stuff
        screen.fill(black)
        good_bullets.draw(screen)
        evil_bullets.draw(screen)
        enemy_wave.draw(screen)
        screen.blit(player.image, player.rect)
        screen.blit(score_text, score_text.get_rect(top = 0, left = 0))
        screen.blit(lives_text, lives_text.get_rect(top = 0, centerx = width / 2))
        screen.blit(fps_text, fps_text.get_rect(top = 0, right = width))
        pygame.display.update()

# 需要导入模块: from pygame.time import Clock [as 别名]
# 或者: from pygame.time.Clock import get_fps [as 别名]
class Time(object):
    """
    A helper class for dealing with time.
    """
    _instance = None

    def __init__(self):
        if Time._instance is None:
            Time._instance = self
        else:
            pass
        self._delta_time = 0
        self._time_scale = 1
        self._clock = Clock()

    def update(self):
        self._delta_time = self._clock.tick(Configuration.instance().frame_cap )

    @property
    def delta_time(self):
        return self._delta_time / self.time_scale

    @property
    def time_scale(self):
        return self._time_scale

    @time_scale.setter
    def time_scale(self, time_scale):
        self._time_scale = time_scale

    @property
    def clock(self):
        return self._clock

    @property
    def frame_rate(self):
        """
        :return: The frame rate which the game is current running.
        """
        return self._clock.get_fps()

    @staticmethod
    def instance():
        if Time._instance is None:
            Time._instance = Time()
        return Time._instance

# 需要导入模块: from pygame.time import Clock [as 别名]
# 或者: from pygame.time.Clock import get_fps [as 别名]
class Game:
    #Constants

    #Properties
    world = None
    player = None
    display = None
    controls = None
    clock = None
    is_running = False
    fps = -1



    def __init__(self):
        self.world = World()
        self.display = Display()
        self.controls = Controls()
        self.clock = Clock()
        self.fps = -1
        #self.is_running = False ?

    def init(self):
        self.display.initWindow()
        self.world.loadTextWorld('sample')
        self.display.initMinimap(self.world)
        self.player = Player(Vector(self.world.starting_point)+0.5)


    def startLoop(self):
        time_to_exit = False
        while not time_to_exit:
            self.clock.tick(30)
            self.fps = self.clock.get_fps()
            keys = self.controls.getInput()
            self.player.move(self.world, keys)
            self.display.draw(self)
            time_to_exit = keys[self.controls.ESCAPE]

    def close(self):
        self.display.close()

# 需要导入模块: from pygame.time import Clock [as 别名]
# 或者: from pygame.time.Clock import get_fps [as 别名]

#.........这里部分代码省略.........
        self.font = font
        
        self.sprites.empty()

        x = 0
        self.announcesprite = self._sprite(' ', x, 0)
        self.announcesprite.time = None
        self.sprites.add(self.announcesprite)

        y = self.announcesprite.rect.height
        self.pausesprite = self._sprite(self.pausestring, x, y)
        x += self.pausesprite.rect.width
        self.timesprites = [self._sprite(t, x, y) for t in self.timestrings]
        x += max([s.rect.width for s in self.timesprites])
        self.fpssprites = [self._sprite(self.fpsstring.format(num=9999, g=g),
                                        x, y)
                           for g in '','G']
        self.fpssprites[1].rect.move_ip(self.fpssprites[1].rect.width, 0)

        apply(self.sprites.add,
              [self.pausesprite] + self.timesprites + self.fpssprites)

        self._dirty()

    def _dirty(self):
        self.paused = None
        self.timeindex = -1

    def resize(self, size):
        self.background = Surface(size, flags=SRCALPHA)
        self.background.fill((0,0,0))

        self._dirty()

    def draw(self, surface):
        t = time()

        if (self.announcesprite.time and
            t - self.announcesprite.time > self._prefs.announcementtimeout):
            self.announcesprite.image.fill((0,0,0))
            self.announcesprite.dirty = True
            self.announcesprite.time = None
        
        paused = self.game.paused
        if self.paused != paused:
            self.paused = paused
            self.pausesprite.visible = self.paused
            self.pausesprite.dirty = True

        timeindex = self.game.timescales.index(0.1 / self.game.dt)
        if self.timeindex != timeindex:
            self.timeindex = timeindex
            for i in range(len(self.timesprites)):
                self.timesprites[i].visible = i == self.timeindex
                self.timesprites[i].dirty = True
            self.fps.clear()

        if not self.lasttime:
            self.lasttime = self.game.world.time, t
        else:
            if self.paused:
                fps = 0
                self.lasttime = self.game.world.time, t
            else:
                frames = self.game.world.time - self.lasttime[0]
                secs = t - self.lasttime[1]
                if secs > 0:
                    if len(self.fps) > 20:
                        self.fps.popleft()
                    self.fps.append(frames/secs)
                    fps = sum(self.fps)/len(self.fps)
                else:
                    fps = None

                self.lasttime = self.game.world.time, t

            if fps is not None:
                image = self.font.render(
                    self.fpsstring.format(num=int(fps+0.5), g=''),
                    True, (255,255,255))
                self.fpssprites[0].image.fill((0,0,0))
                self.fpssprites[0].image.blit(image,
                                              (self.fpssprites[0].rect.width-
                                               image.get_width(), 0))

            self.fpssprites[0].dirty = True

        image = self.font.render(
            self.fpsstring.format(num=int(self.clock.get_fps()+0.5), g='G'),
            True, (255,255,255))
        self.fpssprites[1].image.fill((0,0,0))
        self.fpssprites[1].image.blit(image,
                                      (self.fpssprites[1].rect.width-
                                       image.get_width(), 0))
        self.fpssprites[1].dirty = True

        self.sprites.clear(surface, self.background)
        self.sprites.draw(surface)

        self.clock.tick()

# 需要导入模块: from pygame.time import Clock [as 别名]
# 或者: from pygame.time.Clock import get_fps [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_fps [as 别名]
import Camera
from pygame.time import Clock

running = True
paused = False
Game = Camera.Camera()
gameClock = Clock()

while running:
    while not paused:
        gameClock.tick(60)
        fps = gameClock.get_fps()

        Game.updateScreen(fps)

# 需要导入模块: from pygame.time import Clock [as 别名]
# 或者: from pygame.time.Clock import get_fps [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()