def hit(self, damage): self.hp -= damage if self.hp <= 0 and self.alive: self.body.velocity = 0, 0 self.body.angular_velocity = 0 self.destroy() else: hit_images = [] for i in range(1, 10): image = pyglet.image.load("res/PNG/Tanks/hit/%d.png" % (i)) hit_images.append(image) for i in range(len(hit_images)): hit_images[i].anchor_x = hit_images[i].width // 2 hit_images[i].anchor_y = hit_images[i].height // 2 + 5 hit_anim = pyglet.image.Animation.from_image_sequence( hit_images, 0.1, False) hit_sprite = pyglet.sprite.Sprite(hit_anim, x=self.sprite.position[0], y=self.sprite.position[1], batch=fg_batch, group=explosion_group) hit_sprite.scale = Tank.SCALE hit_sprite.rotation = self.sprite.rotation global effect_count effect_count += 1 hit_sprite.idn = effect_count effects[effect_count] = hit_sprite def hit_s(self): effects[hit_sprite.idn].delete() effects.pop(hit_sprite.idn) clock.schedule_once(hit_s, 1)
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 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, **kwargs): self.image = load_image(self.image_file) self.sprite = Sprite(self.image, self.x, self.y, batch=self.batch, group=self.group) self.chunk.objects.append(self) clock.schedule_once(self.delete, self.timer)
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 fire(self, projectile_id): if self.ammo_type == SharedProjectile.Ammo_Type.REGULAR and self.ammo1 <= 0 or self.ammo_type == SharedProjectile.Ammo_Type.AP and self.ammo2 <= 0: return if self.ammo_type == SharedProjectile.Ammo_Type.REGULAR: self.ammo1 -= 1 elif self.ammo_type == SharedProjectile.Ammo_Type.AP: self.ammo2 -= 1 posx = self.body.position[0] + ( sin(radians(self.barrelSprite.rotation)) * 50) posy = self.body.position[1] + ( cos(radians(self.barrelSprite.rotation)) * 50) global projectile_count p = SharedProjectile(pos=(posx, posy), color=self.color, idn=projectile_id, src_idn=self.idn, client_id=self.CLIENT_ID, type=self.ammo_type) p.body.velocity = (p.velocity * sin(radians(self.barrelSprite.rotation)), p.velocity * cos(radians(self.barrelSprite.rotation))) p.body.angle = radians(self.barrelSprite.rotation) projectiles[p.idn] = p projectile_count += 1 self.isReloading = True def reload(self, idn): tanks[idn].isReloading = False clock.schedule_once(reload, 2, self.idn)
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 __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 on_first_throw(self, first_result): self.board_ctrl.dice_ctrl.stop_waiting_for_throw(self.on_first_throw) self.first_result = first_result clock.schedule_once(lambda _: self.board_ctrl.dice_ctrl.reset_dice(), delay=0.3) self.board_ctrl.dice_ctrl.wait_for_throw(self.on_second_throw)
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 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 emphasize(self, duration=0.10): if self.emphasizable: self.emphasizable = False if duration < 0.10: duration = 0.10 half_duration = duration / 2.0 self.do(ScaleTo(1.2, half_duration) + ScaleTo(1, half_duration)) schedule_once(self.make_emphasizable, duration)
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 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 _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 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 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 take_damage(self, dmg) -> int: self.color = (128, 0, 0) clock.schedule_once(self.revert_color, 0.25) self.health = self.health - dmg if (self.health <= 0): self.is_dead = True return (5 * (1 + self.multiplier)) else: return 0
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)
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): x = uniform(self.left, self.right) y = uniform(self.bottom, self.top) spawned_enemy = choice(self.available_enemies, p=self.spawn_ratios) spawned_enemy(self.game_controller, center_x=x, center_y=y) clock.schedule_once( self._spawn, self.spawn_interval * np.sqrt(len(self.game_controller.enemy_list) + 1))
def __init__(self, entity, logic, **args): super(ExplosionBehavior, self).__init__(entity, logic) entity.name = next_anonymous_name(self) entity.state = ["explode"] self.play_sound("Burst") clock.schedule_once(self.remove, .24)
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 scene2(dt): print "scene2" s.Narration('Why me?') s.Narration('Alone') s.Narration('Why me?') s.Narration('Alone') s.Narration('This is not fair') clock.unschedule(spawn_troll) clock.schedule_interval(spawn_troll, 3) clock.schedule_once(scene3, 20)
def play(self): if self.mediaplayer: logging.debug( 'Music.play {') self.mediaplayer = MediaPlayer() self.mediaplayer.volume = 0.45 self.mediaplayer.eos_action = self.mediaplayer.EOS_LOOP self.mediaplayer.queue(self.current_source) # if we play music immediately, it stutters a little at the start # so schedule it to start a second from now clock.schedule_once(lambda _: self.mediaplayer.play(), 1) logging.debug( '} Music.play')
def play(self): if settings.get('all', 'force_audio') == 'silent': return self.player = Player() self.player.volume = 0.15 self.player.eos_action = self.player.EOS_LOOP self.player.queue(self.music) # if we play music immediately, it stutters a little at the start # so schedule it to start a second from now if settings.getboolean('all', 'music'): clock.schedule_once(lambda _: self.player.play(), 1)
def make_string(self, string): x, y = get_xy_positions(self.win.width, self.win.height) s = SpriteText(self.ft, string) s.rgba = rcolor() s.x = rabbyt.lerp(x, random.uniform(0, self.win.width), dt=1) s.y = rabbyt.lerp(y, random.uniform(0, self.win.height), dt=1) s.rot = rabbyt.lerp(start=0, end=360, dt=1) s.scale = rabbyt.lerp(.5, 1, dt=1) self.world.objects.append(s) def tmp(dt): s.alpha = rabbyt.lerp(1.0, 0, dt=2) clock.schedule_once(lambda dt:self.world.objects.remove(s),2) clock.schedule_once(tmp, 2)
def go_next_test_hand(dt): global h, test_hand_no hand_str, expected_desc = test_hands[test_hand_no] h = Hand.from_str(hand_str) actual_desc = h.get_desc() result = "PASS!" if actual_desc != expected_desc: result = "FAIL!!" text.text = "hand:%s\nactual:%s\nexpected:%s\n%s" % (hand_str, actual_desc, expected_desc, result) if test_hand_no + 1 == len(test_hands): text.text = "ALL YOUR TESTS ARE BELONG TO US!" else: test_hand_no = test_hand_no + 1 clock.schedule_once(go_next_test_hand, TEST_DELAY)
def update(self,dt): ''' Update game state ''' if self.pause or self.level_anime > 0: return elif self.level_anime == -1: if self.target_controller.level + 1 > len(self.LEVELS): self.game_complete = True self.target_controller = TargetController( self.target_controller.difficulty, self.target_controller.level + 1) self.level_anime = 0 elif not (self.game_complete or self.level_anime) and ( self.score > self.LEVELS[self.target_controller.level - 1]): self.level_anime = 1 clock.schedule_once(self._level_anime, 2.5, self) self.killall() for t in self.target_controller.targets: if (not t.is_dead): # Calculate the health kill if t.z < self.LAWN_ZMAX: self.health_loss += (self.LAWN_ZMAX - t.z) / self.HDDOWN # Move Target t.move(dt) else: # they killed Kenny! t.deadtime+=dt if (t.deadtime > self.target_controller.max_deadtime): self.target_controller.targets.remove(t) # Incrementing counters and timers self.timestamp+=dt run_len=time.time() - self.runtime # checking: should we create target(s) create_target = False if (self.timestamp > self.target_controller.release_int): self.timestamp=0 create_target = True if create_target: # K Were supposed to create target(s) count = 1 if (not len(filter( lambda t: not t.is_dead, self.target_controller.targets))): # If we clear all targets then create a bunch right away count = self.target_controller.relive_count for i in range(count): if (len(self.target_controller.targets) < MAX_TARGETS): self.target_controller.generate_target(run_len)
def invalid_target(self, sender, target): if isPlayer(target): pstatus = self.player_status[target] avatar = pstatus.avatar if avatar.shaking == 0: avatar.shaking = 1 avatar._pos.set_transition(dt=0.25, method=lambda t: anim.oscillate_n(t, 4)) avatar.pos += euclid.Vector3(10, 0, 0) clock.schedule_once(lambda t: setattr(avatar, "shaking", 0), 0.5) elif isPermanent(target): zone = self.play_zones[target.controller] guicard = zone.get_card(target) guicard.shake() clock.schedule_once(lambda t: guicard.unshake(), 0.25)
def enter_zone(self, sender, card): if sender in self.status_zones: pstatus, symbol = self.status_zones[sender] if card.key in self.tracker: start_pos, from_zone = self.tracker[card.key] end_pos = pstatus.pos + symbol.pos if from_zone in self.play_zones.values(): guicard = from_zone.get_card(card) from_zone.remove_card(card, clock) self.sparks.add_spark(start_pos, start_pos, dt=1.5, color=str(card.color), grow=True) clock.schedule_once(lambda t: self.sparks.add_spark(start_pos, end_pos, dt=1.25, color=str(card.color)), 1.55) clock.schedule_once(lambda t: pstatus.update_zone(sender), 2.80) clock.schedule_once(lambda t: self.sparks.add_star_spark(end_pos, end_pos, dt=.5, color=str(card.color)) , 2.70) else: dt = 1.0 self.sparks.add_spark(start_pos, end_pos, dt=dt, color="") clock.schedule_once(lambda t: pstatus.update_zone(sender), dt) del self.tracker[card.key] else: pstatus.update_zone(sender) elif str(sender) == "battlefield": dt = 0.5 zone = self.play_zones[card.controller] if card.key in self.tracker: guicard = zone.add_card(card,startt=dt) start_pos, from_zone = self.tracker[card.key] end_pos = self.project_to_window(*tuple(zone.pos+guicard.pos)) self.sparks.add_spark(start_pos, end_pos, grow=True, dt=dt, color=str(card.color)) del self.tracker[card.key] else: zone.add_card(card,startt=0) else: if card.key in self.tracker: start_pos, from_zone = self.tracker[card.key] if from_zone in self.play_zones.values(): from_zone.remove_card(card, clock) del self.tracker[card.key]
def _set_image(self, img): if self._animation is not None: clock.unschedule(self._animate) self._animation = None if isinstance(img, image.Animation): self._animation = img self._frame_index = 0 self._set_texture(img.frames[0].image.get_texture()) self._next_dt = img.frames[0].duration clock.schedule_once(self._animate, self._next_dt) else: self._set_texture(img.get_texture()) self._update_position()
def fire(self, dt): """ fire a bullet """ if not self.reload: angle_radians = radians(self.t.rot) bullet_x = self.t.x + sin(angle_radians) bullet_y = self.t.y + cos(angle_radians) bullet = self.active_weapon(bullet_x, bullet_y, self) bullet.rot = self.t.rot self.bullet_list.append(bullet) self.reload = True clock.schedule_once(self.reloadComplete, bullet.load_time)
def toggleAwake(self, dt = 0): if(self.world.awokenHunter): self.awake = not self.awake else: self.awake = False if(self.awake): # If we just woke up clock.schedule_once(self.toggleAwake, uniform(*self.awakeTime)) else: # We just fell asleep, sleep for 5 to 8 seconds clock.schedule_once(self.toggleAwake, uniform(*self.sleepTime))
def spawn_wave(self): self.wave += 1 self.add(HudMessage("Wave %d" % (self.wave,), remove_after=2)) text = WAVE_MESSAGES[min(self.wave - 1, len(WAVE_MESSAGES) - 1)] hudmessage = HudMessage(text, y=self.height / 2 - 40, color=(255, 255, 255, 128), font_size=16, remove_after=2) clock.schedule_once(lambda _: self.add(hudmessage), 0.5) number = self.wave ** 2 def _spawn(fast): clock.schedule_once(lambda _: Enemy.spawn(fast), 1.5 + n * 0.25) for n in xrange(number): fast = n >= number + 2 - self.wave _spawn(fast)
def __display_fix(self): """ Display the fixation point """ # Tell the Render instance not attempt to render stimuli self.render_stimuli = False # Set current_img to the fixation point image self.current_img = self.render.fix_image # Set the shaders to not be used, bind the VBO using bind_message # and assign current_img as the texture self.__ready_texture(False, self.render.bind_message) # Ready the change over in state schedule_once(self.__next_state, FIX_DUR)
def reset_game(): global bvx, bvy point_label.text = 'Player: {0} Computer: {1}'.format(ppoints, cpoints) computer.x = window.width - 8 computer.y = window.height / 2 ball.x = window.width / 2 ball.y = 0 bvx = 0 bvy = 0 global ready_visible ready_visible = True clock.schedule_once(push_ball, 2)