Python clock.schedule_once函数代码示例

    def __init__(self,
                 img, x=0, y=0, z=0,
                 blend_src=GL_SRC_ALPHA,
                 blend_dest=GL_ONE_MINUS_SRC_ALPHA,
                 batch=None,
                 group=None,
                 usage='dynamic',
                 subpixel=False,
                 alpha_test_val=0.5):
        '''Create a sprite with z-coordinate support.

        :Parameters:
            `img` : `AbstractImage` or `Animation`
                Image or animation to display.
            `x` : int
                X coordinate of the sprite.
            `y` : int
                Y coordinate of the sprite.
            `z` : int
                Z coordinate of the sprite.
            `blend_src` : int
                OpenGL blend source mode.  The default is suitable for
                compositing sprites drawn from back-to-front.
            `blend_dest` : int
                OpenGL blend destination mode.  The default is suitable for
                compositing sprites drawn from back-to-front.
            `batch` : `Batch`
                Optional batch to add the sprite to.
            `group` : `Group`
                Optional parent group of the sprite.
            `usage` : str
                Vertex buffer object usage hint, one of ``"none"`` (default),
                ``"stream"``, ``"dynamic"`` or ``"static"``.  Applies
                only to vertex data.

        '''
        if batch is not None:
            self._batch = batch

        self._x = x
        self._y = y
        self._z = z
        
        self._alpha_test_val = alpha_test_val

        if isinstance(img, image.Animation):
            self._animation = img
            self._frame_index = 0
            self._texture = img.frames[0].image.get_texture()
            self._next_dt = img.frames[0].duration
            if self._next_dt:
                clock.schedule_once(self._animate, self._next_dt)
        else:
            self._texture = img.get_texture()

        # Must use the ZSpriteGroup to be able to enable depth testing
        self._group = ZSpriteGroup(self._alpha_test_val, self._texture, blend_src, blend_dest, group)
        self._usage = usage
        self._subpixel = subpixel
        self._create_vertex_list()

 def next_text(self, _):
     self.textidx += 1
     self.textidx %= len(texts)
     delay = 1.5
     if self.text == '':
         delay = 0.5
     clock.schedule_once(self.next_text, delay)

    def __init__(self, x, y):
        dst = 50
        num = 10
        dt = .6
        fscale = 1
        by = 360.0/num
        self.images = []
        for i in range(num):
            ang = i*by
            rad = ang / 180.0 * math.pi
            s = simage.SImage('wedge.png', x, y)
            s.sp.x = rabbyt.lerp(end=math.cos(rad)*dst*fscale+x, dt=dt)
            s.sp.y = rabbyt.lerp(end=math.sin(rad)*dst*fscale+y, dt=dt)
            '''cool things:
            #1
            s.sp.rot = ang - 90

            #2
            s.sp.rot = ang

            #3
            s.sp.rot = ang + 90
            '''
            s.sp.rot = rabbyt.lerp(ang, ang - 90.0, dt=dt/2)
            s.sp.rot = rabbyt.lerp(ang + 90, ang - 90.0, dt=dt)
            #s.sp.rot = ang - 90.0
            s.sp.scale = rabbyt.lerp(0,fscale,dt=dt)
            self.images.append(s)
        self.on = True
        def tmp(dt):
            l = rabbyt.lerp(1.0,0.0,dt=dt)
            for i in self.images:
                i.sp.alpha = l#rabbyt.lerp(1.0,0.0,dt=1)
            clock.schedule_once(self.off, dt)
        clock.schedule_once(tmp, dt/2)

    def __init__(self,
                 img, x=0, y=0,
                 blend_src=GL_SRC_ALPHA,
                 blend_dest=GL_ONE_MINUS_SRC_ALPHA,
                 batch=None,
                 group=None,
                 usage='dynamic',
                 subpixel=False):
        '''Create a sprite.

        :Parameters:
            `img` : `AbstractImage` or `Animation`
                Image or animation to display.
            `x` : int
                X coordinate of the sprite.
            `y` : int
                Y coordinate of the sprite.
            `blend_src` : int
                OpenGL blend source mode.  The default is suitable for
                compositing sprites drawn from back-to-front.
            `blend_dest` : int
                OpenGL blend destination mode.  The default is suitable for
                compositing sprites drawn from back-to-front.
            `batch` : `Batch`
                Optional batch to add the sprite to.
            `group` : `Group`
                Optional parent group of the sprite.
            `usage` : str
                Vertex buffer object usage hint, one of ``"none"`` (default),
                ``"stream"``, ``"dynamic"`` or ``"static"``.  Applies
                only to vertex data.
            `subpixel` : bool
                Allow floating-point coordinates for the sprite. By default,
                coordinates are restricted to integer values.

        '''
        if batch is not None:
            self._batch = batch

        self._x = x
        self._y = y

        if isinstance(img, image.Animation):
            self._animation = img
            self._frame_index = 0
            self._texture = img.frames[0].image.get_texture()
            self._next_dt = img.frames[0].duration
            if self._next_dt:
                clock.schedule_once(self._animate, self._next_dt)
        else:
            self._texture = img.get_texture()

        ## MY ADDITION - set anchor in center
        self._texture.anchor_x = self._texture.width/2
        self._texture.anchor_y = self._texture.height/2

        self._group = SpriteGroup(self._texture, blend_src, blend_dest, group)
        self._usage = usage
        self._subpixel = subpixel
        self._create_vertex_list()

 def __init__(self, x, y, dx, _, owner):
     WorldItem.__init__(self, x, y, 0, 0)
     self.rotation = 0
     self.speed = copysign(uniform(5, 52), -dx)
     self.curve = uniform(0.002, 0.02)
     self.owner = owner
     clock.schedule_once(lambda _: self.reset_owner(), 1)

    def start(self):
        self._remove_last_games_items()

        self.wave = 0
        Player.start_game()
        self.add(HudInstructions())
        clock.schedule_once(lambda _: self.spawn_wave(), 2)

def on_key_press(symbol, modifiers):
  global lastKeyPressed
  #for now escape quits
  if symbol == key.ESCAPE: InitGL.win.has_exit = True
  lastKeyPressed = (symbol, modifiers)
  Nodes.canvas.focused.keydown = (symbol, modifiers)
  #set up keyrate timer - on_key_release removes it
  clock.schedule_once(repeatKey, 0.4)

 def _level_anime(dt, self):
     if self.level_anime <= 3:
         self.level_anime += 1
         clock.schedule_once(self._level_anime, 2, self)
     else:
         self.level_anime = -1
     if DEBUG:
         print 'LEVEL END ANIMATION (%s)' %(self.level_anime)

 def __init__(self, difficulties, camera):
     self.difficulties = difficulties
     self.counter = 0
     self.labels = deque()
     self.credit_it = self.credit_text()
     self.camera = camera
     schedule_interval(self.update_position, 0.017)
     schedule_once(self.update_text, 0)

def scene1():
    print "scene1"
    s.Narration('Sending me into the snow-storm')
    s.Narration('Without any help')
    s.Narration('Again')
    s.Narration('Alone')
    clock.schedule_interval(spawn_troll, 5)
    clock.schedule_once(scene2, 20)

def on_key_press(symbol,modifiers):
    if symbol == key.Q:
        pyglet.app.exit()
    if symbol in valid_keys:
        if move_robber(symbol):
            clock.schedule_once(move_cop0, cop_delay)
            clock.schedule_once(move_cop1, cop_delay * 2)
            game_state.print_locations()

 def next_frame(self, dt):
     self.index = (self.index + 1) % len(self.animation.frames)
     frame = self.animation.frames[self.index]
     if frame.duration is not None:
         delay = frame.duration - (self.expected_delay - dt)
         delay = min(max(0, delay), frame.duration)
         clock.schedule_once(self.next_frame, delay)
         self.expected_delay = delay

 def make_shape_animations(self):
     x, y = get_xy_positions(self.win.width, self.win.height)
     s = SImage(get_random_image(), x, y)
     s.sp.x = rabbyt.lerp(end=random.uniform(0, self.win.width), dt=1)
     s.sp.y = rabbyt.lerp(end=random.uniform(0, self.win.height), dt=1)
     s.sp.rot = rabbyt.lerp(start=0, end=360, dt=1)
     s.sp.scale = rabbyt.lerp(.25, 1, dt=1)
     self.world.objects.append(s)
     clock.schedule_once(lambda dt:self.world.objects.remove(s), 1)

 def spawn(self, dt=None, set_health=True):
     point = self._determine_spawn(self.team)
     if point is not None: #will return None if all the gates have been destroyed
         self.position, self.forward, self.up = point.position + point.forward * 5, point.forward, point.up
         self.velocity = Vector3(0,0,0)
         if set_health:
             self.health, self.dead = 100, False
     else:
         clock.schedule_once(self.spawn, 5)

 def controller_changed(self, sender, original):
     start_zone = self.play_zones[original]
     end_zone = self.play_zones[sender.controller]
     guicard = start_zone.get_card(sender)
     start_pos = self.project_to_window(*tuple(start_zone.pos+guicard.pos))
     start_zone.remove_card(sender, clock)
     guicard = end_zone.add_card(sender,startt=1.6)
     end_pos = self.project_to_window(*tuple(end_zone.pos+guicard.pos))
     clock.schedule_once(lambda t: self.sparks.add_spark(start_pos, end_pos, dt=1., color=str(sender.color)), 0.7)