Python Clock.tick方法代码示例

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

    size = width, height = 1280, 720
    speed = [2,2]
    black = 0, 0, 0
    pos = posx, posy = width/2, height/2
    radius = 20
    color = THECOLORS["red"]
    clock = Clock()
    screen = pygame.display.set_mode(size)
    surface = pygame.display.get_surface()
    rmanager = RingManager( width, height, center = pos)
    r = 0
    while True:
        for event in pygame.event.get():
            if event.type == pygame.QUIT: pygame.quit(); sys.exit()
            elif event.type == KEYDOWN:
                if pygame.key.get_pressed()[K_1]:
                    r = 0
                if pygame.key.get_pressed()[K_2]:
                    r = 1
                if pygame.key.get_pressed()[K_3]:
                    r = 2
                if pygame.key.get_pressed()[K_4]:
                    r = 3
                if pygame.key.get_pressed()[K_LEFT]:
                    rmanager.rings[r] << 1
                elif pygame.key.get_pressed()[K_RIGHT]:
                    rmanager.rings[r] >> 1
        rmanager.checkCollide()
        rmanager.paintAll(surface)
        pygame.display.flip()
        clock.tick(60)

# 需要导入模块: from pygame.time import Clock [as 别名]
# 或者: from pygame.time.Clock import tick [as 别名]
 def update(self, deps, callback, max_fps):
   c = Clock()
   while self.running:
     env = self.compose(deps)
     callback(*env)
     c.tick(max_fps)
   self.logger.debug("Thread with deps %s ending" % (str(deps)))

# 需要导入模块: from pygame.time import Clock [as 别名]
# 或者: from pygame.time.Clock import tick [as 别名]
class CpuSpinner:
    def __init__(self, directory, ttl=False, gameticks=Parameters.GAMETICKS, gamespeed=Parameters.GAMESPEED):
        self.clock = GameClock(gameticks)
        self.clock.set_speed(gamespeed)
        self.clock.start()

        self.limitclock = Clock()

        self._running = True

        self.__ttl = ttl * Parameters.GAMETICKS

        self._directory = directory

        self.__aupdatecounter = 0

    def __gettick(self):
        return self.clock.game_tick

    def __getbetweenframe(self):
        return self.clock.get_between_frame()

    def start(self):
        self.__loop()

    def __loop(self):
        while self._running:
            for i in self.clock.update():
                self.__update()
            self._draw()

    def __update(self):
        if self.__ttl:
            self.__ttl -= 1
            if self.__ttl == 0:
                self._running = False

        # regular update done x times by seconds
        for updatable in self._directory.get(Tags.UPDATABLE):
            updatable.update(self.__gettick())

        self.__aupdatecounter += 1

        if self.__aupdatecounter == Parameters.AGAMETICKS:
            self.__aupdatecounter = 0
            self._aupdate()

    def _aupdate(self):
        # alternative (heavy update) every x updates
        self._directory.update()
        # print self.clock.average_fps

    def _draw(self):
        self._directory.get_single(Tags.RENDERER).draw(self.__getbetweenframe())
        if Parameters.FPSLIMIT:
            self.limitclock.tick(Parameters.FPSLIMIT)

# 需要导入模块: from pygame.time import Clock [as 别名]
# 或者: from pygame.time.Clock import tick [as 别名]
 def run(self):
     clock = Clock()
     while True:
         clock.tick(50)
         for event in pygame.event.get():
             if event.type == QUIT:
                 return
             if event.type == KEYDOWN:
                 return
         self.draw(self.screen)

# 需要导入模块: from pygame.time import Clock [as 别名]
# 或者: from pygame.time.Clock import tick [as 别名]
class TaltosGame():

    def __init__(self):
        pygame.init()
        self.clock = Clock()
        MusicPlayer.MusicPlayer().playContinously()

        self.gameMode = GameMode.GameMode(GameModes.RPG)
        self.gameScreen = MainScreen.MainScreen()
        self.gameScreen.setScreenMode(self.gameMode.getGameMode())
        self.language = Menu.Menu(self.gameScreen.getScreen()).languageChooser()

        """
        self.gameModules = {
                GameModes.RPG : None,
                GameModes.CYBERSPACE : None }
        """
        self.changeGameMode(GameModes.RPG)

    def changeGameMode(self, newGameMode):
        self.gameMode.setGameMode(newGameMode)
        self.gameScreen.setScreenMode(self.gameMode.getGameMode())
        if self.gameMode.getGameMode() == GameModes.RPG:
            self.currentGameModule = Rpg.Rpg(self.gameScreen, self.language)
        if self.gameMode.getGameMode() == GameModes.CYBERSPACE:
            self.currentGameModule = Cyberspace.Cyberspace(self.gameScreen, self.language)
        """
        if self.gameMode.getGameMode() == GameModes.RPG:
            if self.gameModules[GameModes.RPG] is None:
                self.gameModules[GameModes.RPG] = Rpg.Rpg(self.gameScreen, self.language)
        if self.gameMode.getGameMode() == GameModes.CYBERSPACE:
            if self.gameModules[GameModes.CYBERSPACE] is None:
                self.gameModules[GameModes.CYBERSPACE] = Cyberspace.Cyberspace(self.gameScreen, self.language)
        self.currentGameModule = self.gameModules[self.gameMode.getGameMode()]
        """

    def gameLoop(self):
        while True:
            try:
                self.clock.tick(30)
                self.currentGameModule.handleKeyEvents()
                self.currentGameModule.gameLoop()
            except MainExceptions.Exit:
                exit()
            except MainExceptions.ChangeGameMode as gameModeChange:
                self.changeGameMode(gameModeChange.newGameMode)

            if self.gameMode.getGameMode() == GameModes.RPG:
                pygame.display.update()
            if self.gameMode.getGameMode() == GameModes.CYBERSPACE:
                pygame.display.flip()

# 需要导入模块: from pygame.time import Clock [as 别名]
# 或者: from pygame.time.Clock import tick [as 别名]
class GameClock(Observable):
    """Keeps track of how fast the game clock runs"""

    # Fires when game time advances
    # :param dt: Amount of game time that elapsed
    @EventType
    def REAL_TIME_ADVANCE(dt):
        """Game time has advanced
        :param dt: Amount of game time that elapsed, in "seconds"
        """

    @EventType
    def GAME_TIME_ADVANCE(dt):
        """Real time has passed
        :param dt: Amount of real time that elapsed, in milliseconds
        """

    def __init__(self, framerate, multiplier=1.0):
        super(GameClock, self).__init__()

        self.clock = Clock()
        self._multiplier = multiplier
        self.framerate = framerate
        self.isPaused = False

    @property
    def multiplier(self):
        """Get the real/game time ratio"""
        if self.isPaused:
            return 0
        else:
            return self._multiplier

    @multiplier.setter
    def multiplier(self, multiplier):
        """Get the real/game time ratio"""
        self._multiplier = multiplier

    def toggle(self):
        self.isPaused ^= True

    def update(self):
        # pygame.time.Clock::tick() returns milliseconds
        real_dt = self.clock.tick(self.framerate)
        # self.notify(GameClock.REAL_TIME_ADVANCE, real_dt)
        game_dt = real_dt * self.multiplier / 1000.0
        self.notify(GameClock.GAME_TIME_ADVANCE, game_dt)

    def zero(self):
        """Drain any time off the internal clock without calling any updaters"""
        real_dt = self.clock.tick(self.framerate)

# 需要导入模块: from pygame.time import Clock [as 别名]
# 或者: from pygame.time.Clock import tick [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 tick [as 别名]
 def start_display_output(self):
     """ Start thread for graphical VU meter """
     
     pygame.event.clear()
     clock = Clock()
     self.meter.start()        
     while 1:
         for event in pygame.event.get():
             if event.type == pygame.QUIT:
                 self.exit()
             elif event.type == pygame.KEYDOWN or event.type == pygame.KEYUP:
                 keys = pygame.key.get_pressed() 
                 if (keys[pygame.K_LCTRL] or keys[pygame.K_RCTRL]) and event.key == pygame.K_c:
                     self.exit()                                                 
         self.refresh()
         clock.tick(1)

# 需要导入模块: from pygame.time import Clock [as 别名]
# 或者: from pygame.time.Clock import tick [as 别名]
def run():
    clock = Clock()
    initialize()
    while(True):
        dt = clock.tick(60)
        update()
        render()

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

	def __init__(self, height, width):
		self._height = height
		self._width = width
		self.IPtext = ""
		self.clock = Clock()
	
	def get_key(self):
		while True:
			event = pygame.event.poll()
			if event.type == KEYDOWN:
				return event.key
			elif event.type == pygame.QUIT:
				exit()
			else:
				pass

	def draw(self, view):
		tfont = pygame.font.Font(None, 20)
		pygame.draw.rect(view, (0,0,0), ((self._width/2)-100, (self._height/2)-10, 200,20), 0)
		pygame.draw.rect(view, (255,255,255), ((self._width/2)-102, (self._height/2)-12, 204,24), 1)
		view.blit(tfont.render("IP address: "+ self.IPtext, 1, (255,0,0)), ((self._width/ 2) - 100, (self._height/ 2) - 10))
		pygame.display.update()

	def get_ip(self,view):
		IP = []
		self.IPtext = ""
		self.draw(view)
		while True:
			inputkey = self.get_key()
			if inputkey == K_BACKSPACE:
				IP = IP[0:-1]
			elif inputkey == K_RETURN:
				break
			elif inputkey <=127:
				IP.append(chr(inputkey))

			self.IPtext = (string.join(IP,""))
			self.draw(view)
			
			self.clock.tick(40)
		return self.IPtext

# 需要导入模块: from pygame.time import Clock [as 别名]
# 或者: from pygame.time.Clock import tick [as 别名]
class PygameView():
    def __init__(self, model):
        init_pygame()
        self.screen = set_mode((400, 300))
        self.clock = Clock()
        self.model = model
         
    def display(self):
        self.screen.fill((0, 0, 64))  # dark blue
        [draw_rect(self.screen, (0, 191, 255), b) for b in model.borders]  # deep sky blue 
        [draw_rect(self.screen, (255, 192, 203), p) for p in model.pellets]  # shrimp
        for name, p in model.players.items():
            if name != model.myname:
                draw_rect(self.screen, (255, 0, 0), p)  # red
        if model.myname:
            draw_rect(self.screen, (0, 191, 255), model.players[model.myname])  # deep sky blue
           
        update_pygame_display()
           
        self.clock.tick(50)  # frames per second, independent of server frame rate

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