def level_generator(fruits, tiers, suckers, birbs, birb_level=False, change_music=False, background=arcade.csscolor.CORNFLOWER_BLUE): """As a sort of after thought, condensed a significant portion of level making operations, the first argument is the fruits for that level, in the order of how they will be stacked. The second argument is the tier list that corresponds to each fruit, third argument is for music, fourth argument is used to change background.""" if change_music: if self.background_playing: arcade.stop_sound(self.background_music_player) self.background_playing = False arcade.set_background_color(background) #Setup Fruits, putting them into their fruit lists and applying fruit movement for fruit in range(len(fruits)): Basic_Fruit_Movement(fruits[fruit]) self.revamped_fruit_list.append(fruits[fruit]) tiers[fruit].append(fruits[fruit]) self.complete_sprite_list.append(fruits[fruit]) #Setup Suckers, putting them into their list and applying sucker movement for sucker in suckers: Sucker_Movement(sucker) self.Sucker_list.append(sucker) self.complete_sprite_list.append(sucker) if birb_level: for birb in birbs: Birb_Movement(birb) self.birds_list.append(birb) self.complete_sprite_list.append(birb)
def _stop_music_track(self): try: stop_sound(self.current_music) except AttributeError: pass finally: self.current_music = None
def update(self, delta, fireflies, shaked_fireflies: set): firefly_shaked = lambda mouse: arcade.NamedPoint( random.uniform(mouse.center_x - mouse.radius, mouse.center_x + mouse.radius), random.uniform(mouse.center_y - mouse.radius, mouse.center_y + mouse.radius), ) if self.display: # si l'utilisateur clique, les lucioles sont attirées for f in fireflies: if f.collides_with_sprite(self): ## collision avec la souris f.is_shaked = True f.target = firefly_shaked(self) f.speed = 100 shaked_fireflies.add(f) elif (f in shaked_fireflies ): ## elles ne sont plus dans la range de la souris f.is_shaked = False f.speed = f.original_speed shaked_fireflies.remove(f) else: # les lucioles retournent à leur business for f in shaked_fireflies: f.is_shaked = False f.target = Firefly.find_new_target() f.speed = ( f.original_speed ) ## on rétablit la vitesse par défaut de la luciole f.timer = random.uniform(0.0, f.countdown) shaked_fireflies.clear() # gestion du son volume = lambda: self.fade / Firefly.FADE_SOUND if len(shaked_fireflies): ## création du son / fade in self.fade = min(1, self.fade + delta) if not self.player_sound: self.player_sound = arcade.play_sound(self.firefly_sound, volume=volume(), looping=True) else: self.firefly_sound.set_volume(volume(), self.player_sound) elif not len(shaked_fireflies) and self.player_sound: ## supression du son / fade out self.fade = max(0, self.fade - delta) if volume() > 0: self.firefly_sound.set_volume(volume(), self.player_sound) else: arcade.stop_sound(self.player_sound) self.player_sound = None
def move(delta_time): global times global first global track times += 1 for each in movers: thick = 3 x = each[0] y = each[1] radius = each[2] if radius <= 20: thick = 2 if times > 25 and times < 150: if first: time.sleep(15) first = False arcade.draw_circle_filled(x, y, radius, arcade.color.WHEAT) # big circle body arcade.draw_circle_outline(x, y, radius, arcade.color.WHEAT, thick) # outline arcade.draw_circle_filled(x, y, radius * (2 / 3), arcade.color.WHEAT) # smaller circle in body arcade.draw_circle_outline(x, y, radius * (2 / 3), arcade.color.WHEAT, thick) # outline arcade.draw_circle_filled(x, y, (radius * (2 / 3)) / 2, arcade.color.WHEAT) # smallest circle in body arcade.draw_circle_outline(x, y, (radius * (2 / 3)) / 2, arcade.color.WHEAT, thick) # outline arcade.draw_arc_filled(x, y + radius - (radius * .16666667), radius * 1.5, radius * 1.5, arcade.color.WHEAT, 0, 180) arcade.draw_arc_outline(x, y + radius - (radius * .16666667), radius * 1.5, radius * 1.5, arcade.color.WHEAT, 0, 180, thick + 2) arcade.draw_line(x - radius * 1.5 / 2, y + radius * (5 / 6), x - radius * 1.5 * -1 / 2, y + radius * (5 / 6), arcade.color.WHEAT, thick) arcade.draw_circle_filled(x, y + radius + (radius * .1966667), radius / 4.5, arcade.color.WHEAT) arcade.draw_circle_outline(x, y + radius + (radius * .1966667), radius / 4.5, arcade.color.WHEAT, thick) each[0] = random.randint(50, 550) each[1] = random.randint(50, 550) each[2] = radius draw_BB8(each[0], each[1], radius) print("times:", times) if times >= 150 and times <= 200: # arcade.play_sound(arcade.load_sound("alarm.mp3")) draw_BB8(random.randint(50, 550), random.randint(50, 550), random.randint(10, 60), True) elif times > 200 and times <= 320: track += 1 if track == 20: print("track") arcade.stop_sound(arcade.load_sound("alarm.mp3")) arcade.play_sound(arcade.load_sound("alarm.mp3")) track = 0 for i in range(25): draw_BB8(random.randint(50, 550), random.randint(50, 550), random.randint(10, 60), True) elif times > 320: arcade.stop_sound(arcade.load_sound("alarm.mp3")) for i in range(60): draw_BB8(random.randint(50, 550), random.randint(50, 550), random.randint(times-200, times-100), True) print("big")
def on_key_release(self, key, modifiers): if key == arcade.key.LEFT: self.ball.dx = 0 arcade.stop_sound(self.snd) elif key == arcade.key.RIGHT: self.ball.dx = 0 arcade.stop_sound(self.snd) elif key == arcade.key.UP: self.ball.dy = 0 arcade.stop_sound(self.snd) elif key == arcade.key.DOWN: self.ball.dy = 0 arcade.stop_sound(self.snd)
def setup(self, nb: int = 100): # préchargement du son (sinon freeze) arcade.stop_sound(arcade.play_sound(self.firefly_sound)) # lancement de la musique arcade.play_sound(self.music, volume=0.5, looping=True) # objet conteneur de la souris self.mouse = Mouse() self.mouse.firefly_sound = self.firefly_sound # message FadingMessage.COLOR_START = self.BACKGROUND self.message = FadingMessage(self.width / 2, self.height, "clique avec la souris") # initialisation des lucioles aléatoirement (position, taille, cible, état de l'éclairage, vitesse d'éclairage) self.shaked_fireflies = set() self.fireflies = arcade.SpriteList() for _ in range(nb): x, y, r = ( random.randint(0, self.width), random.randint(0, self.height), random.randint(4, 7), ) countdown = random.uniform(1, 5) timer = random.uniform(0, countdown) f = Firefly( x, y, r, speed=random.uniform(*Firefly.SPEED), timer=timer, target=Firefly.find_new_target(), countdown=countdown, ) self.fireflies.append(f)
def on_update(self, delta_time: float): if self.mode == "game": self.players.update() self.ball.update() if self.ball.right >= self.window.width: self.player_1.score += 1 if self.player_1.score == 3: self.mode = "end" self.winner = "Player 1" self.end_timer = time() self.start() elif self.ball.left <= 0: self.player_2.score += 1 if self.player_2.score == 3: self.mode = "end" self.winner = "Player 2" self.end_timer = time() self.start() elif self.mode == "end": if time() - self.end_timer >= 5: ac.stop_sound(self.music_player) self.window.show_menu()
def on_update(self, delta_time): # We're calling physics engine # Enemy if not self.health == 0: self.enemy_list.update() self.physics_engine.update() self.total_time -= delta_time # Update animations if self.physics_engine.can_jump(): self.player_sprite.can_jump = False else: self.player_sprite.can_jump = True if self.physics_engine.is_on_ladder( ) and not self.physics_engine.can_jump(): self.player_sprite.is_on_ladder = True self.process_keychange() else: self.player_sprite.is_on_ladder = False self.process_keychange() self.coin_list.update_animation(delta_time) self.background_list.update_animation(delta_time) self.player_list.update_animation(delta_time) self.wall_list.update() # See if the moving wall hit a boundary and needs to reverse direction. for wall in self.wall_list: if wall.boundary_right and wall.right > wall.boundary_right and wall.change_x > 0: wall.change_x *= -1 if wall.boundary_left and wall.left < wall.boundary_left and wall.change_x < 0: wall.change_x *= -1 if wall.boundary_top and wall.top > wall.boundary_top and wall.change_y > 0: wall.change_y *= -1 if wall.boundary_bottom and wall.bottom < wall.boundary_bottom and wall.change_y < 0: wall.change_y *= -1 # if you hit any coins coin_hit_list = arcade.check_for_collision_with_list( self.player_sprite, self.coin_list) for coin in coin_hit_list: self.game_score += 1 # Remove the coin coin.remove_from_sprite_lists() # Play sound arcade.play_sound(self.collect_coin_sound) # enemy for enemy in self.enemy_list: if len(arcade.check_for_collision_with_list(enemy, self.wall_list)) > 0: enemy.change_x *= -1 elif enemy.boundary_left is not None and enemy.left < enemy.boundary_left: enemy.change_x *= -1 elif enemy.boundary_right is not None and enemy.right > enemy.boundary_right: enemy.change_x *= -1 changed_viewport = False if self.player_sprite.center_x >= self.end_of_map: self.level += 1 self.setup(self.level) self.view_left = 0 self.view_bottom = 0 arcade.stop_sound(self.game_sound) arcade.play_sound(self.level_update_sound) # arcade.play_sound(self.game_sound) changed_viewport = True # Manage Scrolling if len( arcade.check_for_collision_with_list(self.player_sprite, self.enemy_list)) > 0: self.player_sprite.center_x = PLAYER_START_X self.player_sprite.center_y = PLAYER_START_Y self.view_left = 0 self.view_bottom = 0 changed_viewport = True arcade.play_sound(self.game_over) self.health -= 1 # if player falls if self.player_sprite.center_y < -100: self.player_sprite.center_x = PLAYER_START_X self.player_sprite.center_y = PLAYER_START_Y # Set the camera self.view_left = 0 self.view_bottom = 0 changed_viewport = True arcade.play_sound(self.game_over) self.health -= 1 if self.health == 0: arcade.stop_sound(self.game_sound) arcade.pause(3) arcade.play_sound(self.game_sound) self.total_time = 303.0 self.view_left = 0 self.view_bottom = 0 changed_viewport = True self.health = 3 self.game_score = self.game_score - 20 # end of the game if self.level > 3: game_over_view = GameOverView() self.window.show_view(game_over_view) # if character hits don't touch if arcade.check_for_collision_with_list(self.player_sprite, self.dont_touch_list): self.player_sprite.change_x = 0 self.player_sprite.change_y = 0 self.player_sprite.center_x = PLAYER_START_X self.player_sprite.center_y = PLAYER_START_Y # Set the camera to the start self.view_left = 0 self.view_bottom = 0 changed_viewport = True arcade.play_sound(self.game_over) self.health -= 1 # Scroll left left_boundary = self.view_left + LEFT_VIEWPORT_MARGIN if self.player_sprite.left < left_boundary: self.view_left -= left_boundary - self.player_sprite.left changed_viewport = True # Scroll right right_boundary = self.view_left + SCREEN_WIDTH - RIGHT_VIEWPORT_MARGIN if self.player_sprite.right > right_boundary: self.view_left += self.player_sprite.right - right_boundary changed_viewport = True # Scroll up top_boundary = self.view_bottom + SCREEN_HEIGHT - TOP_VIEWPORT_MARGIN if self.player_sprite.top > top_boundary: self.view_bottom += self.player_sprite.top - top_boundary changed_viewport = True # Scroll down bottom_boundary = self.view_bottom + BOTTOM_VIEWPORT_MARGIN if self.player_sprite.bottom < bottom_boundary: self.view_bottom -= bottom_boundary - self.player_sprite.bottom changed_viewport = True if changed_viewport: self.view_bottom = int(self.view_bottom) self.view_left = int(self.view_left) # Done the Scrolling arcade.set_viewport(self.view_left, SCREEN_WIDTH + self.view_left, self.view_bottom, SCREEN_HEIGHT + self.view_bottom)
def update(self, delta_time): """ Movement and game logic """ # Move the player with the physics engine self.physics_engine.update() # Run main BGM loop if intro is finished position = self.intro.get_stream_position(self.introduction) if position == 0 and self.bgm == None: self.bgm = arcade.play_sound(self.music, .5, 0, True) # Make goblin patrol self.enemy_sprite.enemy_walk() # See if we hit any hazards or enemies danger_hit_list = arcade.check_for_collision_with_list( self.player_sprite, self.danger_list) danger_hit_list += arcade.check_for_collision_with_list( self.player_sprite, self.foe_list) if danger_hit_list: # "Kill" player, play death sound, and move to the game over screen self.player_sprite.kill() arcade.play_sound(self.death) # End music if self.intro.is_playing(self.introduction): arcade.stop_sound(self.introduction) else: arcade.stop_sound(self.bgm) game_view = EndingView(1) self.window.show_view(game_view) # See if we have collected any gems gem_hit_list = arcade.check_for_collision_with_list( self.player_sprite, self.gem_list) for gem in gem_hit_list: gem.remove_from_sprite_lists() self.player_sprite.change_score(1) arcade.play_sound(self.gem_collect) # --- Manage Scrolling --- # Track if we need to change the viewport changed = False # Scroll left left_boundary = self.view_left + LEFT_VIEWPOINT_MARGIN if self.player_sprite.left < left_boundary: self.view_left -= left_boundary - self.player_sprite.left changed = True # Scroll right right_boundary = self.view_left + SCREEN_WIDTH - RIGHT_VIEWPORT_MARGIN if self.player_sprite.right > right_boundary: self.view_left += self.player_sprite.right - right_boundary changed = True # Scroll up top_boundary = self.view_bottom + SCREEN_HEIGHT - TOP_VIEWPORT_MARGIN if self.player_sprite.top > top_boundary: self.view_bottom += self.player_sprite.top - top_boundary changed = True # Scroll down bottom_boundary = self.view_bottom + BOTTOM_VIEWPORT_MARGIN if self.player_sprite.bottom < bottom_boundary: self.view_bottom -= bottom_boundary - self.player_sprite.bottom changed = True if changed: # Only scroll full integers to avoid mismanagement of pixels self.view_bottom = int(self.view_bottom) self.view_left = int(self.view_left) # Do the scrolling arcade.set_viewport(self.view_left, SCREEN_WIDTH + self.view_left, self.view_bottom, SCREEN_HEIGHT + self.view_bottom) # Game finish condition self.exit_access = arcade.check_for_collision(self.player_sprite, self.escape) if self.player_sprite.score == 5 and self.exit_access: # End music if self.intro.is_playing(self.introduction): arcade.stop_sound(self.introduction) else: arcade.stop_sound(self.bgm) # Move to victory screen game_view = EndingView(2) self.window.show_view(game_view)
def reset_level(self): arcade.stop_sound(self.music) # Exhaust generator since we don't need load view for resetting for _ in self.setup(self.current_level): pass
def on_show(self): for sound in self.sound_list: arcade.stop_sound(sound)
def on_update(self, delta_time): """ Movement and game logic """ if not self.game_over: # Move the player with the physics engine self.physics_engine.update() # Updating suckers self.Sucker_list.update() #Update birbs self.birds_list.update() # Condensing our fruit update operations self.revamped_fruit_list.update() # New hitting ground function to optimize some things def fruit_hitting_ground(fruits): """When fruit hits ground, this function will reset it""" #fruits.bottom = FRUIT_SIZE * 9.75 #fruits.left = FRUIT_SIZE * rdm.randint(1, 14) fruits.change_y = rdm.randint(-4, -2) fruits.center_x = rdm.randrange(100, SCREEN_WIDTH - 100) fruits.center_y = SCREEN_HEIGHT + 100 def sucker_hitting_ground(sucker): """When sucker hits ground, this function will reset it""" sucker.bottom = FRUIT_SIZE * 9.75 sucker.left = FRUIT_SIZE * rdm.randint(2, 13) sucker.boundary_right = FRUIT_SIZE sucker.boundary_left = FRUIT_SIZE sucker.change_y = rdm.choice([-5, -4, -3, -2]) sucker.change_x = rdm.choice([-1, 0, 1]) # Update suckers when they hit the ground for sucker in self.Sucker_list: if arcade.check_for_collision_with_list( sucker, self.wall_list): sucker_hitting_ground(sucker) sucker.update() # Update each tier of fruit separately to manage shake and stacked conditions, which is still condensed # compared to updating every fruit on their own. All tiers can now be setup this way, with no need to # reference particular levels. for fruit in self.tier_1_fruit_list: if arcade.check_for_collision_with_list(fruit, self.wall_list): fruit_hitting_ground(fruit) if self.Shake_1: arcade.play_sound(self.fruit_hit_ground, volume=sound_effect_volume) self.Shake_1 = False self.Stacked_1 = False self.Catch_1 = False fruit.update() for fruit in self.tier_2_fruit_list: if arcade.check_for_collision_with_list(fruit, self.wall_list): fruit_hitting_ground(fruit) if self.Shake_2: arcade.play_sound(self.fruit_hit_ground, volume=sound_effect_volume) self.Shake_2 = False self.Stacked_2 = False self.Catch_2 = False fruit.update() for fruit in self.tier_3_fruit_list: if arcade.check_for_collision_with_list(fruit, self.wall_list): fruit_hitting_ground(fruit) if self.Shake_3: arcade.play_sound(self.fruit_hit_ground, volume=sound_effect_volume) self.Shake_3 = False self.Stacked_3 = False self.Catch_3 = False fruit.update() for fruit in self.tier_4_fruit_list: if arcade.check_for_collision_with_list(fruit, self.wall_list): fruit_hitting_ground(fruit) if self.Shake_4: arcade.play_sound(self.fruit_hit_ground, volume=sound_effect_volume) self.Shake_4 = False self.Stacked_4 = False self.Catch_4 = False fruit.update() for fruit in self.tier_5_fruit_list: if arcade.check_for_collision_with_list(fruit, self.wall_list): fruit_hitting_ground(fruit) if self.Shake_5: arcade.play_sound(self.fruit_hit_ground, volume=sound_effect_volume) self.Shake_5 = False self.Stacked_5 = False self.Catch_5 = False fruit.update() # Stacking operations, each successive fruit will follow the previous fruit. # Occurs only when the previous fruit is stacked. for tier_1_fruit in self.tier_1_fruit_list: if arcade.check_for_collision(tier_1_fruit, self.player_sprite) and not self.Shake_1 \ and not self.Catch_1: # Play good sound here when this occurs tier_1_fruit.follow_sprite(self.player_sprite) if not self.Stacked_1: arcade.play_sound(self.picking_up_sound, volume=sound_effect_volume) self.Stacked_1 = True if self.Catch_1: tier_1_fruit.follow_below(self.crow) for tier_2_fruit in self.tier_2_fruit_list: if arcade.check_for_collision_with_list(tier_2_fruit, self.tier_1_fruit_list) and not self.Shake_2 \ and self.Stacked_1\ and not self.Catch_2: # Play good sound here when this occurs tier_2_fruit.follow_sprite(tier_1_fruit) if not self.Stacked_2: arcade.play_sound(self.picking_up_sound, volume=sound_effect_volume) self.Stacked_2 = True if self.Catch_2: tier_2_fruit.follow_below(self.crow) for tier_3_fruit in self.tier_3_fruit_list: if arcade.check_for_collision_with_list(tier_3_fruit, self.tier_2_fruit_list) \ and not self.Shake_3 \ and self.Stacked_2\ and not self.Catch_3: # Play good sound here when this occurs tier_3_fruit.follow_sprite(tier_2_fruit) if not self.Stacked_3: arcade.play_sound(self.picking_up_sound, volume=sound_effect_volume) self.Stacked_3 = True if self.Catch_3: tier_3_fruit.follow_below(self.crow) for tier_4_fruit in self.tier_4_fruit_list: if arcade.check_for_collision_with_list(tier_4_fruit, self.tier_3_fruit_list) \ and not self.Shake_4 \ and self.Stacked_3\ and not self.Catch_4: # Play good sound here when this occurs tier_4_fruit.follow_sprite(tier_3_fruit) if not self.Stacked_4: arcade.play_sound( self.picking_up_sound, volume=sound_effect_volume) self.Stacked_4 = True if self.Catch_4: tier_1_fruit.follow_below(self.crow) for tier_5_fruit in self.tier_5_fruit_list: if arcade.check_for_collision_with_list(tier_5_fruit, self.tier_4_fruit_list) \ and not self.Shake_5 \ and self.Stacked_4\ and not self.Catch_5: # Play good sound here when this occurs tier_5_fruit.follow_sprite(tier_4_fruit) if not self.Stacked_5: arcade.play_sound( self.picking_up_sound, volume=sound_effect_volume) self.Stacked_5 = True if self.Catch_5: tier_5_fruit.follow_below(self.crow) # Revamped collision system, if a sucker collides with fruit that is stacked, it will knock ONLY the top one off. for sucker in self.Sucker_list: if (((arcade.check_for_collision_with_list(sucker, self.tier_1_fruit_list) and self.Stacked_1)) or (arcade.check_for_collision_with_list(sucker, self.tier_2_fruit_list) and self.Stacked_2) or (arcade.check_for_collision_with_list(sucker, self.tier_3_fruit_list) and self.Stacked_3) or (arcade.check_for_collision_with_list(sucker, self.tier_4_fruit_list) and self.Stacked_4)) \ and (not self.Shake_1 or not self.Shake_2 or not self.Shake_3 or not self.Shake_4 or not self.Shake_5): if self.Stacked_4: # Play bad sound here when this occurs. if not self.Shake_4: arcade.play_sound(self.losing_fruit_sound, volume=sound_effect_volume) self.Shake_4 = True elif self.Stacked_3: # Play bad sound here when this occurs. if not self.Shake_3: arcade.play_sound(self.losing_fruit_sound, volume=sound_effect_volume) self.Shake_3 = True elif self.Stacked_2: if not self.Shake_2: # Play bad sound here when this occurs. arcade.play_sound(self.losing_fruit_sound, volume=sound_effect_volume) self.Shake_2 = True elif self.Stacked_1: if not self.Shake_1: # Play bad sound here when this occurs. arcade.play_sound(self.losing_fruit_sound, volume=sound_effect_volume) self.Shake_1 = True for birb in self.birds_list: if self.Stacked_1 and (not self.Catch_1 or not self.Catch_2 or not self.Catch_3 or not self.Catch_4 or not self.Catch_5): birb.follow_sprite(self.player_sprite) if (((arcade.check_for_collision_with_list(birb, self.tier_1_fruit_list) and self.Stacked_1)) or (arcade.check_for_collision_with_list(birb, self.tier_2_fruit_list) and self.Stacked_2) or (arcade.check_for_collision_with_list(birb, self.tier_3_fruit_list) and self.Stacked_3) or (arcade.check_for_collision_with_list(birb, self.tier_4_fruit_list) and self.Stacked_4)) \ and (not self.Catch_1 or not self.Catch_2 or not self.Catch_3 or not self.Catch_4 or not self.Catch_5): if self.Stacked_4: # Play bad sound here when this occurs. if not self.Catch_4: arcade.play_sound(self.losing_fruit_sound, volume=sound_effect_volume) self.Catch_4 = True self.Stacked_3 = False birb.follow_sprite(self.birb_spawn_right) elif self.Stacked_3: # Play bad sound here when this occurs. if not self.Catch_3: arcade.play_sound(self.losing_fruit_sound, volume=sound_effect_volume) self.Catch_3 = True self.Stacked_2 = False birb.follow_sprite(self.birb_spawn_right) elif self.Stacked_2: if not self.Catch_2: # Play bad sound here when this occurs. arcade.play_sound(self.losing_fruit_sound, volume=sound_effect_volume) self.Catch_2 = True self.Stacked_1 = False birb.follow_sprite(self.birb_spawn_right) elif self.Stacked_1: if not self.Catch_1: # Play bad sound here when this occurs. arcade.play_sound(self.losing_fruit_sound, volume=sound_effect_volume) self.Catch_1 = True self.Stacked_1 = False birb.follow_sprite(self.birb_spawn_right) if not self.Stacked_1: birb.follow_sprite(self.birb_spawn_left) if len( arcade.check_for_collision_with_list( self.player_sprite, self.cherry_list)) > 0: self.instr_objective = True if len( arcade.check_for_collision_with_list( self.player_sprite, self.cherry_list_2)) > 0: self.restart_objective = True for item in self.outro_list: if arcade.check_for_collision_with_list(item, self.wall_list): arcade.play_sound(self.burst_sound, volume=sound_effect_volume) item.kill() self.outro_list.update() # See if the user got to the end of the level if self.level == 0: if self.instr_objective or self.skip_level: # once we hit the cherry, go to next level self.skip_level = False self.instr_objective = False self.level = 1 # Load the next level self.setup(self.level) if self.level == 1: if self.reverse_level: self.reverse_level = False self.level = 0 if self.background_playing: arcade.stop_sound(self.background_music_player) self.background_playing = False self.setup(self.level) if self.Stacked_3 or self.skip_level: self.skip_level = False # once we hit 3 fruits, go to next level self.level = 2 # Load the next level self.setup(self.level) self.Stacked_1 = False self.Stacked_2 = False self.Stacked_3 = False self.Stacked_4 = False self.Stacked_5 = False if self.level == 2: if self.reverse_level: self.level = 1 self.reverse_level = False self.setup(self.level) if self.Stacked_4 or self.skip_level: self.skip_level = False # once we hit 4 fruits, go to next level self.level = 3 # Load the next level self.setup(self.level) self.Stacked_1 = False self.Stacked_2 = False self.Stacked_3 = False self.Stacked_4 = False self.Stacked_5 = False if self.level == 3: if self.reverse_level: self.reverse_level = False self.level = 2 self.setup(self.level) if self.Stacked_5 or self.skip_level: self.skip_level = False # once we hit 5 fruits, go to next level self.level = 4 # Load the next level self.setup(self.level) self.Stacked_1 = False self.Stacked_2 = False self.Stacked_3 = False self.Stacked_4 = False self.Stacked_5 = False if self.level == 4: if self.restart_objective: self.restart_objective = False #once we hit the cherry, restart at level 1 self.level = 0 self.Stacked_1 = False self.Stacked_2 = False self.Stacked_3 = False self.Stacked_4 = False self.Stacked_5 = False # Load the next level arcade.stop_sound(self.intro_player) self.setup(self.level) # See if the player walks to the door. If so, game over. if len( arcade.check_for_collision_with_list( self.player_sprite, self.door_list)) > 0: self.game_over = True else: MyGame.close(self)
def setup(self, level): """ Set up the game here. Call this function to restart the game. """ # Create the Sprite lists self.player_list = arcade.SpriteList() self.wall_list = arcade.SpriteList(use_spatial_hash=True) self.orders_list = arcade.SpriteList(use_spatial_hash=True) self.instructions_list = arcade.SpriteList(use_spatial_hash=True) self.intro_list = arcade.SpriteList(use_spatial_hash=True) self.cherry_list = arcade.SpriteList() self.cherry_list_2 = arcade.SpriteList() self.door_list = arcade.SpriteList() self.outro_list = arcade.SpriteList() #We use this list for each level of fruits self.revamped_fruit_list = arcade.SpriteList() #Complete list for easier drawing self.complete_sprite_list = arcade.SpriteList() # Consider a list for each tier of fruit in the tower, but don't actually draw # from this list # Think of these as categories for operations self.tier_1_fruit_list = arcade.SpriteList() self.tier_2_fruit_list = arcade.SpriteList() self.tier_3_fruit_list = arcade.SpriteList() self.tier_4_fruit_list = arcade.SpriteList() self.tier_5_fruit_list = arcade.SpriteList() # This sucker list works for every level self.Sucker_list = arcade.SpriteList() self.birds_list = arcade.SpriteList() self.crow = Birb("Our Images/Enemies/birb.png", FRUIT_SCALING * 0.4) self.birb_spawn_right = arcade.Sprite( ":resources:images/tiles/boxCrate_double.png", TILE_SCALING) self.birb_spawn_left = arcade.Sprite( ":resources:images/tiles/boxCrate_double.png", TILE_SCALING) self.Sucker1 = arcade.Sprite("Our Images/Suckers/sucker1.png", FRUIT_SCALING * 1.8) self.Sucker2 = arcade.Sprite("Our Images/Suckers/sucker2.png", FRUIT_SCALING * 1.8) self.Sucker3 = arcade.Sprite("Our Images/Suckers/sucker3.png", FRUIT_SCALING * 1.8) self.Sucker4 = TurningSprite("Our Images/Suckers/sucker3.png", FRUIT_SCALING * 1.8) self.Sucker5 = arcade.Sprite("Our Images/Suckers/sucker1.png", FRUIT_SCALING * 1.8) self.Sucker6 = arcade.Sprite("Our Images/Suckers/sucker2.png", FRUIT_SCALING * 1.8) #We only need individual fruit coins instead! self.Grape_coin = Coin("Our Images/Fruits/grapes.png", FRUIT_SCALING * 1.8) self.Cherry_coin = Coin("Our Images/Fruits/Cherry.png", FRUIT_SCALING * 1.8) self.Watermelon_coin = Coin("Our Images/Fruits/Watermelon.png", FRUIT_SCALING * 1.8) self.Orange_coin = Coin("Our Images/Fruits/orange.png", FRUIT_SCALING * 1.8) self.Pear_coin = Coin("Our Images/Fruits/pear.png", FRUIT_SCALING * 1.8) self.Pineapple_coin = Coin("Our Images/Fruits/Pineapple.png", FRUIT_SCALING * 1.8) self.Plum_coin = Coin("Our Images/Fruits/plum.png", FRUIT_SCALING * 1.8) self.Strawberry_coin = Coin("Our Images/Fruits/Strawberry.png", FRUIT_SCALING * 1.8) self.Kiwi_coin = Coin("Our Images/Fruits/kiwi.png", FRUIT_SCALING * 1.8) self.Lemon_coin = Coin("Our Images/Fruits/lemon.png", FRUIT_SCALING * 1.8) self.Apple_coin = Coin("Our Images/Fruits/Apple.png", FRUIT_SCALING * 1.8) self.Bannana_coin = Coin("Our Images/Fruits/Bannana.png", FRUIT_SCALING * 1.8) # Set up the player, specifically placing it at these coordinates. image_source = "Our Images/Gal_with_basket.PNG" self.player_sprite = arcade.Sprite(image_source, CHARACTER_SCALING) self.player_sprite.center_x = PLAYER_START_X self.player_sprite.center_y = PLAYER_START_Y self.player_list.append(self.player_sprite) self.complete_sprite_list.append(self.player_sprite) # Create the ground # This shows using a loop to place multiple sprites horizontally for x in range(0, 1750, 64): wall = arcade.Sprite(":resources:images/tiles/grassMid.png", TILE_SCALING) wall.center_x = x wall.center_y = 32 self.wall_list.append(wall) self.complete_sprite_list.append(wall) # We use crates to define boundaries of our game, and put them in the wall_list. # This shows using a coordinate list to place sprites coordinate_list = [[-230, 96], [1245, 96]] for coordinate in coordinate_list: # Add a crate on the ground wall = arcade.Sprite(":resources:images/tiles/boxCrate_double.png", TILE_SCALING * 0.7) wall.position = coordinate self.wall_list.append(wall) self.complete_sprite_list.append(wall) def Basic_Fruit_Movement(fruit): """Defining a function that condenses the fruit movement operations, input what fruit you want to move down the screen""" fruit.change_y = rdm.choice([-4, -3, -2]) fruit.center_y = SCREEN_HEIGHT + 100 fruit.center_x = rdm.randrange(SCREEN_WIDTH) # Still use this sucker movement. def Sucker_Movement(sucker): """Defining a function that has the suckers moving different than the fruits""" #sucker.bottom = FRUIT_SIZE * 9.75 # fruit.left will have to by FRUIT_SIZE * an random integer --> use random here #sucker.left = FRUIT_SIZE * rdm.randint(0, 14) #sucker.boundary_right = FRUIT_SIZE #sucker.boundary_left = FRUIT_SIZE sucker.center_y = SCREEN_HEIGHT + 100 sucker.center_x = rdm.randrange(SCREEN_WIDTH) sucker.change_y = rdm.choice([-5, -4, -3, -2]) sucker.change_x = rdm.choice([-1, 0, 1]) def Birb_Movement(birb): """Defining a function that has the suckers moving different than the fruits""" birb.center_x = -100 birb.center_y = 400 #birb.boundary_right = FRUIT_SIZE #birb.boundary_left = FRUIT_SIZE #birb.change_y = rdm.choice([-5, -4, -3, -2]) #birb.change_x = rdm.choice([-1, 0, 1]) # Instruction screen if self.level == 0: arcade.set_background_color(arcade.csscolor.CORNFLOWER_BLUE) self.intro_player = arcade.play_sound(self.intro_theme, volume=music_effect_volume, looping=True) self.intro_playing = True lvl_0 = "Our Images/Intro/Title.PNG" intro_coordinate_list = [[700, 550]] for coordinate in intro_coordinate_list: intro = arcade.Sprite(lvl_0, TILE_SCALING) intro.position = coordinate self.intro_list.append(intro) self.complete_sprite_list.append(intro) lvl_0_instr = "Our Images/Intro/Instructions.png" instruction_coordinate_list = [[700, 360]] for coordinate in instruction_coordinate_list: instructions = arcade.Sprite(lvl_0_instr, TILE_SCALING * .3) instructions.position = coordinate self.instructions_list.append(instructions) self.complete_sprite_list.append(instructions) # Placing fruit to take us into the game when collected fruit = "Our Images/Fruits/Cherry.png" cherry_coordinate_list = [[1125, 175]] for coordinate in cherry_coordinate_list: cherry_instr = arcade.Sprite(fruit, FRUIT_SCALING * 1.8) cherry_instr.position = coordinate self.cherry_list.append(cherry_instr) self.complete_sprite_list.append(cherry_instr) def level_generator(fruits, tiers, suckers, birbs, birb_level=False, change_music=False, background=arcade.csscolor.CORNFLOWER_BLUE): """As a sort of after thought, condensed a significant portion of level making operations, the first argument is the fruits for that level, in the order of how they will be stacked. The second argument is the tier list that corresponds to each fruit, third argument is for music, fourth argument is used to change background.""" if change_music: if self.background_playing: arcade.stop_sound(self.background_music_player) self.background_playing = False arcade.set_background_color(background) #Setup Fruits, putting them into their fruit lists and applying fruit movement for fruit in range(len(fruits)): Basic_Fruit_Movement(fruits[fruit]) self.revamped_fruit_list.append(fruits[fruit]) tiers[fruit].append(fruits[fruit]) self.complete_sprite_list.append(fruits[fruit]) #Setup Suckers, putting them into their list and applying sucker movement for sucker in suckers: Sucker_Movement(sucker) self.Sucker_list.append(sucker) self.complete_sprite_list.append(sucker) if birb_level: for birb in birbs: Birb_Movement(birb) self.birds_list.append(birb) self.complete_sprite_list.append(birb) # Better yet, lets only have one option per level, and save us # a lot of extra hassle! if self.level == 1: # Originially we picked random orders for each level, but this made # the code needlessly longer and more of a hassle. # lvl_1_orders= ["Our Images/Orders/Lvl1/Order1.1.PNG", "Our Images/Orders/Lvl1/Order1.2.PNG", # "Our Images/Orders/Lvl1/Order1.3.PNG"] # rdm_lvl_1_order = rdm.choice(lvl_1_orders) if self.intro_playing: arcade.stop_sound(self.intro_player) self.intro_playing = False if not self.background_playing: self.background_music_player = arcade.play_sound( self.background_music, volume=music_effect_volume, looping=True) self.background_playing = True # Now, we use only one order per level. lvl_1_order = "Our Images/Orders/Lvl1/Order1.2.PNG" # Place Order: order_coordinate_list = [[950, 550]] for coordinate in order_coordinate_list: orders = arcade.Sprite(lvl_1_order, TILE_SCALING) orders.position = coordinate self.orders_list.append(orders) self.complete_sprite_list.append(orders) """This is the model level setup """ level_generator( [self.Kiwi_coin, self.Pineapple_coin, self.Strawberry_coin], [ self.tier_1_fruit_list, self.tier_2_fruit_list, self.tier_3_fruit_list, self.tier_4_fruit_list, self.tier_5_fruit_list ], [self.Sucker1, self.Sucker2, self.Sucker3, self.Sucker4], [self.crow]) if self.level == 2: lvl_2_order = "Our Images/Orders/Lvl2/Order1.2.PNG" # Place Order: order_coordinate_list = [[950, 530]] for coordinate in order_coordinate_list: orders = arcade.Sprite(lvl_2_order, TILE_SCALING) orders.position = coordinate self.orders_list.append(orders) self.complete_sprite_list.append(orders) """This is most of the level setup """ level_generator([ self.Watermelon_coin, self.Bannana_coin, self.Grape_coin, self.Cherry_coin ], [ self.tier_1_fruit_list, self.tier_2_fruit_list, self.tier_3_fruit_list, self.tier_4_fruit_list, self.tier_5_fruit_list ], [ self.Sucker1, self.Sucker2, self.Sucker3, self.Sucker4, self.Sucker5 ], [self.crow], background=arcade.csscolor.LIGHT_YELLOW) if self.level == 3: lvl_3_order = "Our Images/Orders/Lvl3/Lvl3Order1.1.PNG" # Place Order: order_coordinate_list = [[950, 510]] for coordinate in order_coordinate_list: orders = arcade.Sprite(lvl_3_order, TILE_SCALING) orders.position = coordinate self.orders_list.append(orders) self.complete_sprite_list.append(orders) self.birb_spawn_right.position = (1500, 500) self.complete_sprite_list.append(self.birb_spawn_right) self.wall_list.append(self.birb_spawn_right) self.birb_spawn_left.position = (10, 500) self.complete_sprite_list.append(self.birb_spawn_left) self.wall_list.append(self.birb_spawn_left) """This is most of the level setup """ level_generator([ self.Pineapple_coin, self.Apple_coin, self.Plum_coin, self.Pear_coin, self.Orange_coin ], [ self.tier_1_fruit_list, self.tier_2_fruit_list, self.tier_3_fruit_list, self.tier_4_fruit_list, self.tier_5_fruit_list ], [ self.Sucker1, self.Sucker2, self.Sucker3, self.Sucker4, self.Sucker5, self.Sucker6 ], [self.crow], birb_level=True, background=arcade.csscolor.ORANGE) #End Screen if self.level == 4: if self.background_playing: arcade.stop_sound(self.background_music_player) self.background_playing = False self.intro_player = arcade.play_sound(self.intro_theme, volume=music_effect_volume) arcade.set_background_color(arcade.csscolor.PALE_VIOLET_RED) # Placing everything related to the ending lvl_4 = "Our Images/Outro/Outro.PNG" ending_coordinate_list = [[500, 450]] for coordinate in ending_coordinate_list: ending = arcade.Sprite(lvl_4, TILE_SCALING * .37) ending.position = coordinate self.instructions_list.append(ending) self.complete_sprite_list.append(ending) fruit = "Our Images/Fruits/Cherry.png" cherry_coordinate_list = [[150, 175]] for coordinate in cherry_coordinate_list: cherry_instr = arcade.Sprite(fruit, FRUIT_SCALING * 1.8) cherry_instr.position = coordinate self.cherry_list_2.append(cherry_instr) self.complete_sprite_list.append(cherry_instr) door = "Our Images/Outro/pixel door.png" door_coordinate_list = [[890, 143]] for coordinate in door_coordinate_list: door_1 = arcade.Sprite(door, FRUIT_SCALING * .75) door_1.position = coordinate self.door_list.append(door_1) self.complete_sprite_list.append(door_1) self.player_sprite.set_position(500, PLAYER_START_Y) self.outro_list.append(self.Orange_boi) self.outro_list.append(self.Yellow_boi) self.outro_list.append(self.Blue_boi) self.outro_list.append(self.Purple_boi) self.outro_list.append(self.Red_boi) for item in self.outro_list: Basic_Fruit_Movement(item) self.complete_sprite_list.append(item) # Create the 'physics engine' self.physics_engine = arcade.PhysicsEnginePlatformer( self.player_sprite, self.wall_list)
def update(self, delta_time): """All the logic to move, and the game logic goes here. """ global explode, explode_x, explode_y, fps, position_y_1, position_y_2, level, prompt, prompt_time, boss_hp, boss_hp_current global up_pressed, down_pressed, left_pressed, right_pressed, laser_bomb, laser_effect, laser_fps, laser_counter, laser_counter_update global boss_create_fps, boss_sound_on, game_sound_on, game_sound_1, game_sound_2, game_sound_3, boss_sound_1, boss_sound_2, boss_sound_3, game_sound, boss_sound_4 if self.current_state != GAME_RUNNING and self.frame_count % 3480 == 0: try: arcade.play_sound(background_sound) except Exception as e: print("Error playing sound.", e) pass if self.current_state == GAME_RUNNING: try: arcade.stop_sound(background_sound) except Exception as e: print("Error pausing sound.", e) pass if level == 4: self.current_state = WIN return if self.current_state == GAME_RUNNING: if self.boss and boss_sound_on == 0: boss_sound_on = 1 try: if level == 0: arcade.stop_sound(game_sound) arcade.play_sound(boss_sound_1) if level == 1: game_sound_1.pause() arcade.play_sound(boss_sound_2) if level == 2: game_sound_2.pause() arcade.play_sound(boss_sound_3) if level == 3: game_sound_3.pause() arcade.play_sound(boss_sound_4) except Exception as e: print("Error pausing sound.", e) pass if not self.boss: try: if level == 0: boss_sound_1.pause() if level == 1: boss_sound_2.pause() if level == 2: boss_sound_3.pause() if level == 3: boss_sound_4.pause() except Exception as e: print("Error pausing sound.", e) pass boss_sound_on = 0 # if (self.frame_count - fps) == 180 and fps != 0: # game_sound_on = 0 if game_sound_on == 0: try: if level == 0: arcade.play_sound(game_sound) if level == 1: arcade.play_sound(game_sound_1) if level == 2: arcade.play_sound(game_sound_2) if level == 3: arcade.play_sound(game_sound_3) except Exception as e: print("Error playing sound.", e) pass game_sound_on = 1 # update remaining laser based on current score laser_counter = Score // 1000 + 1 if laser_counter + laser_counter_update == 1: arcade.play_sound(missile_sound_1) self.laser_player += 1 laser_counter_update -= 1 if self.hp <= 0: game_sound_on = 10 try: arcade.stop_sound(game_sound) # game_sound_1.pause() # game_sound_2.pause() # game_sound_3.pause() # boss_sound_1.pause() # boss_sound_2.pause() # boss_sound_3.pause() # boss_sound_4.pause() except Exception as e: print("Error pausing sound.", e) self.dead() else: # drop hp bonus every 60s if self.frame_count % 3600 == 3599: bonus_hp = arcade.Sprite("images/hp_bonus.png", 0.45) bonus_hp.center_x = random.randrange(0, SCREEN_WIDTH) bonus_hp.center_y = random.randrange( SCREEN_HEIGHT, SCREEN_HEIGHT * 1.25) self.bonus.append(bonus_hp) if self.frame_count % 240 == 0 and not self.boss and not 1 <= explode <= 4: for _ in range(2 + level): # generate randomly enemy planes of different levels ranNum = random.randint(0, 1000) if ranNum < 500: enemy = Enemy("images/plane_small.png", 0.8, 2, 10, 4, False) elif ranNum < 850: enemy = Enemy("images/bigplane0.png", 0.7, 3, 50, 3, False) else: enemy = Enemy("images/boss0.png", 0.35, 5, 100, 2, False) enemy.center_x = random.randrange(0, SCREEN_WIDTH) enemy.center_y = random.randrange( SCREEN_HEIGHT, SCREEN_HEIGHT * 1.25) enemy.angle = 180 self.enemy_list.append(enemy) # create a boss and ensure no small enemies appear during the boss battle elif self.frame_count - fps == ( 1799 * (level + 1)) and not self.boss and not 1 <= explode <= 4: # 提示 boss_create_fps = self.frame_count prompt = True prompt_time = self.frame_count # update boss image based on game level if level == 0: enemy = Enemy("images/boss_2.png", 0.8, 25, 500, 2, True) elif level == 1: enemy = Enemy("images/boss_4.png", 0.8, 35, 1000, 3, True) elif level == 2: enemy = Enemy("images/boss_1.png", 0.8, 50, 2000, 3, True) elif level == 3: enemy = Enemy("images/boss_5.png", 0.8, 70, 4000, 3, True) enemy.center_x = random.randrange(0, SCREEN_WIDTH) enemy.center_y = SCREEN_HEIGHT * 2 enemy.angle = 180 self.enemy_list.append(enemy) self.boss = True boss_hp = enemy.ehp # set time for boss prompt to be 3s if self.frame_count - prompt_time == 180 and prompt: prompt = False # update player's hp based on different damage levels from boss for boss in self.enemy_list: if 1 <= laser_effect <= 6: # realize the disappearance of self bullet when it hits boss for e in self.bullet_self_list: if boss.center_x - 20 <= e.center_x <= boss.center_x + 20: e.kill() # calculate different damage levels of laser from boss if level == 0: if self.player.center_x - 36 < boss.center_x < self.player.center_x + 36: self.hp = max(0, self.hp - 0.8) if level == 1: if self.player.center_x - 36 < boss.center_x < self.player.center_x + 36: self.hp = max(0, self.hp - 0.9) if level == 2: if self.player.center_x - 36 < boss.center_x - 45 < self.player.center_x + 36 or self.player.center_x - 36 < boss.center_x + 15 < self.player.center_x + 36: self.hp = max(0, self.hp - 1) if level == 3: if self.player.center_x - 36 < boss.center_x - 45 < self.player.center_x + 36 or self.player.center_x - 36 < boss.center_x < self.player.center_x + 36 or self.player.center_x - 36 < boss.center_x + 15 < self.player.center_x + 36: self.hp = max(0, self.hp - 1.1) # update the background position position_y_1 -= 1 position_y_2 -= 1 if position_y_1 == -300: position_y_1 = 900 if position_y_2 == -300: position_y_2 = 900 # collision with bullet bullet_collide_list = arcade.check_for_collision_with_list( self.player, self.bullet_list) for collide_bullet in bullet_collide_list: collide_bullet.kill() self.hp = max(0, self.hp - 5) # collision with enemy enemy_collide_list = arcade.check_for_collision_with_list( self.player, self.enemy_list) for collide_enemy in enemy_collide_list: collide_enemy.kill() if self.boss: self.hp = 0 self.hp = max(0, self.hp - 30) # calculate different damage of player's bullet or bomb makes on enemy or boss for e in self.enemy_list: if e.boss: boss_hp_current = e.ehp bullet_hit_list = arcade.check_for_collision_with_list( e, self.bullet_self_list) for bullet_hit in bullet_hit_list: bullet_hit.kill() boss_hit = e.hitted(1) if boss_hit[0] == 1: self.boss = False explode = 1 explode_x = boss_hit[1] explode_y = boss_hit[2] fps = self.frame_count for bomb in self.assist: bullet_hit_list = arcade.check_for_collision_with_list( bomb, self.bullet_list) for b in bullet_hit_list: b.kill() for e in self.enemy_list: if e.boss: boss_hp_current = e.ehp bullet_hit_list = arcade.check_for_collision_with_list( e, self.assist) for bullet_hit in bullet_hit_list: boss_hit = e.hitted(0.3) if boss_hit[0] == 1: self.boss = False explode = 1 explode_x = boss_hit[1] explode_y = boss_hit[2] fps = self.frame_count # boss explode animation if explode == 1 and self.frame_count - fps == 20: arcade.play_sound(bomb_sound) explode += 1 elif explode == 2 and self.frame_count - fps == 40: explode += 1 elif explode == 3 and self.frame_count - fps == 60: explode += 1 elif explode == 4 and self.frame_count - fps == 180: explode += 1 level += 1 # bomb_sound.pause() game_sound_on = 0 # use loop to make all enemies facing to the player for enemy in self.enemy_list: # First, calculate the angle to the player. We could do this # only when the bullet fires, but in this case we will rotate # the enemy to face the player each frame, so we'll do this # each frame. # Position the start at the enemy's current location start_x = enemy.center_x start_y = enemy.center_y # list_1[i][2]Get the destination location for the bullet dest_x = self.player.center_x dest_y = self.player.center_y # Do math to calculate how to get the bullet to the destination. # Calculation the angle in radians between the start points # and end points. This is the angle the bullet will travel. x_diff = dest_x - start_x y_diff = dest_y - start_y angle = math.atan2(y_diff, x_diff) # use if statement to exclude the boss angle if enemy.boss: enemy.angle = 0 else: enemy.angle = math.degrees(angle) - 270 # determine the shooting characteristics of enemy / boss planes if enemy.boss and self.frame_count % ( (120 - 20 * level) // 2) == 0: bullet = arcade.Sprite("images/boss_bullet.png", 0.5) bullet.center_x = start_x bullet.center_y = start_y bullet.angle = 0 bullet.change_x = 0 bullet.change_y = -BULLET_SPEED * (level // 3 + 1) self.bullet_list.append(bullet) elif self.frame_count % (120 - 20 * level) == 0: bullet = arcade.Sprite("images/enemy_bullet.png", 0.5) bullet.center_x = start_x bullet.center_y = start_y bullet.angle = math.degrees(angle) bullet.change_x = math.cos(angle) * BULLET_SPEED * ( level // 3 + 1) bullet.change_y = math.sin(angle) * BULLET_SPEED * ( level // 3 + 1) self.bullet_list.append(bullet) # determine the shooting frequency of the player airplane if self.frame_count % (15 - 2 * level) == 0: bullet = arcade.Sprite("images/Bomb2.png", 0.7) bullet.center_x = self.player.center_x bullet.center_y = self.player.center_y # Angle the bullet sprite bullet.angle = 0 # Taking into account the angle, calculate our change_x # and change_y. Velocity is how fast the bullet travels. bullet.change_x = 0 bullet.change_y = BULLET_SPEED * 3 self.bullet_self_list.append(bullet) # arcade.play_sound(bullet_sound) # use loops to remove the bullet when it flies off-screen for bullet in self.bullet_self_list: if bullet.bottom > 600: bullet.kill() for bullet in self.assist: if bullet.bottom > 600: bullet.kill() for bullet in self.bullet_list: if bullet.top < 0: bullet.kill() # use loops to control the dropping of hp_bonus for hp_bonus in self.bonus: hp_bonus.center_y -= 5 # update player's hp when it catches hp_bonus if arcade.check_for_collision(self.player, hp_bonus): self.hp = min(100, self.hp + 30) arcade.play_sound(hp_bonus_sound) hp_bonus.kill() # remove hp_bonus when it gets out of windows if hp_bonus.top < 0: hp_bonus.kill() # keyboard control the movement of the player if up_pressed: self.player.center_y = min(552, self.player.center_y + 5) if down_pressed: self.player.center_y = max(48, self.player.center_y - 5) if left_pressed: self.player.center_x = max(36, self.player.center_x - 5) if right_pressed: self.player.center_x = min(764, self.player.center_x + 5) # trigger the missile if laser_bomb and self.laser_player > 0 and len( self.assist) <= 1: assist_bomb = arcade.Sprite("images/assisent1_1.png", 1) assist_bomb.center_x = self.player.center_x - 25 assist_bomb.center_y = self.player.center_y assist_bomb.angle = 0 assist_bomb.change_x = 0 assist_bomb.change_y = 10 self.assist.append(assist_bomb) assist_bomb = arcade.Sprite("images/assisent1_1.png", 1) assist_bomb.center_x = self.player.center_x + 25 assist_bomb.center_y = self.player.center_y assist_bomb.angle = 0 assist_bomb.change_x = 0 assist_bomb.change_y = 10 self.assist.append(assist_bomb) self.laser_player -= 1 # use if statement to set the laser shooting period to be 8s if self.boss and (self.frame_count - boss_create_fps) % 480 == 0 and ( self.frame_count - boss_create_fps) != 0: laser_effect = 1 laser_fps = self.frame_count # use if statement to animate laser if laser_effect == 1 and self.frame_count - laser_fps == 20: laser_effect += 1 elif laser_effect == 2 and self.frame_count - laser_fps == 40: laser_effect += 1 elif laser_effect == 3 and self.frame_count - laser_fps == 60: laser_effect += 1 elif laser_effect == 4 and self.frame_count - laser_fps == 80: laser_effect += 1 elif laser_effect == 5 and self.frame_count - laser_fps == 100: laser_effect += 1 elif laser_effect == 6 and self.frame_count - laser_fps == 120: laser_effect += 1 # realize the dropping of boss and enemy planes for e in self.enemy_list: e.drop() if level == 4: self.current_state = WIN self.set_mouse_visible(True) self.bullet_list.update() self.bullet_self_list.update() self.assist.update() # update the frame_count self.frame_count += 1
def on_hide_view(self) -> None: """Called when this view is not shown anymore.""" self.ui_manager.unregister_handlers() if self.background_player and self.background_player.playing: arcade.stop_sound(self.background_player)