def sort_key(self, key_list) -> List: """ Use bubble sort to sort all the keys in the list by distances. Sort the distance from the closest to the furthest Args: key_list: A list of key sprites Returns: a sorted sprite list """ for i in range(len(key_list)): for j in range(len(key_list) - 1): new_sprite = arcade.SpriteList() key_1 = arcade.get_distance_between_sprites( self.player_sprite, key_list[j]) key_2 = arcade.get_distance_between_sprites( self.player_sprite, key_list[j + 1]) if key_1 > key_2: # Because of a spritelist cannot be modify, so I use another temperate list to append. temp = None for k in range(len(key_list)): if k == j: temp = key_list[j] elif k == j + 1: new_sprite.append(key_list[k]) new_sprite.append(temp) # append values that does not need to be swap else: new_sprite.append(key_list[k]) key_list = new_sprite self.key.all_keys = key_list return key_list
def turretAttack(turret: arcade.sprite, entity_list: arcade.sprite_list, delta_time: float, dmg_anim_list: arcade.sprite_list): if not entity_list: return True turret.cooldown += delta_time if not turret.target: turret.target = getTarget(turret, entity_list) elif turret.cooldown >= T_COOLDOWN: turret.cooldown = 0 if arcade.get_distance_between_sprites(turret, turret.target) >= 32 * T_RANGE: turret.target = None return True if turret.target.health <= 0: turret.target.kill() turret.target = None return True if turret.e_type - 9 == turret.target.e_type: turret.target.health -= turret.dmg * DMG_MULTIPLIER if turret.e_type == T_SPRAY: dmg_anim_list.append(AnimatedDamage("y_dmg", [turret.target.center_x, turret.target.center_y], 1.5)) elif turret.e_type == T_LAMP: dmg_anim_list.append(AnimatedDamage("b_dmg", [turret.target.center_x, turret.target.center_y], 1.5)) elif turret.e_type == T_VACUUM: dmg_anim_list.append(AnimatedDamage("r_dmg", [turret.target.center_x, turret.target.center_y], 1.5)) else: turret.target.health -= turret.dmg if turret.e_type == T_SPRAY: dmg_anim_list.append(AnimatedDamage("y_dmg", [turret.target.center_x, turret.target.center_y])) elif turret.e_type == T_LAMP: dmg_anim_list.append(AnimatedDamage("b_dmg", [turret.target.center_x, turret.target.center_y])) elif turret.e_type == T_VACUUM: dmg_anim_list.append(AnimatedDamage("r_dmg", [turret.target.center_x, turret.target.center_y])) if turret.target.health <= 0: turret.target.kill() turret.target = None if not entity_list: return True elif arcade.get_distance_between_sprites(turret, turret.target) >= 32 * T_RANGE: turret.target = None
def create_car_sprites(self): for i in range(0, 4): depart = i goal = random.randint(0, 3) while (depart == goal): depart = i goal = random.randint(0, 3) depart_coords = self.departCoords[depart] goal_coords = self.goalCoords[goal] path = self.create_paths(depart_coords, goal_coords) self.car_sprite = Car("car.png", SPRITE_SCALING_CAR, path, goal_coords) self.car_sprite.center_x = self.departCoords[depart][0] self.car_sprite.center_y = self.departCoords[depart][1] distance_to_all_cars = [ arcade.get_distance_between_sprites(self.car_sprite, x) for x in self.cars_list ] if not (len(list(filter(lambda x: x < 70, distance_to_all_cars))) > 0): self.cars_list.append(self.car_sprite)
def on_mouse_press(self, x: float, y: float, button: int, modifiers: int) -> None: """ Detects when button on mouse is pressed. Parameters ---------- x : float x-coordinate. y : float y-coordinate. button : int Button pressed. modifiers : int Modifier value. """ for shop in self.current_level.sprites.shop_list: if shop.collides_with_point((self.view.left_offset + x, self.view.bottom_offset + y)) and \ (arcade.get_distance_between_sprites(shop, self.drill) < 70): self.drill.stop_moving() # Release all buttons and mouse clicks. self.keys_pressed = {key: False for key in self.keys_pressed} for entity in (*self.current_level.sprites.entity_list, self.drill): if issubclass(entity.__class__, ControllableMixin): entity.handle_mouse_release(button) self.window.show_view(self.window.shop_view) for entity in (*self.current_level.sprites.entity_list, self.drill): if issubclass(entity.__class__, ControllableMixin): entity.handle_mouse_click(button)
def remove_obstacles_around_player(self, max_distance=200): for obstacle in self.obstacles: distance = arcade.get_distance_between_sprites( self.player, obstacle) if distance < max_distance: obstacle.remove_from_sprite_lists() self.number_of_obstacles_removed += 1 self._increase_speed_of_obstacles()
def closest_distance_between_planets(planet1, planet2): # Only works cuz the planets are circles center_distance = arcade.get_distance_between_sprites(planet1, planet2) # Unclear why this is 4 instead of 2 but it works better planet1_radius = planet1.height / 4 planet2_radius = planet2.height / 4 closest_distance = center_distance - planet1_radius - planet2_radius logger.debug(f"{center_distance=}, {closest_distance=}") return closest_distance
def handleDragonReachesCastle(self, stage): dragonSprites = stage.getDragonSprites() castleTile = stage.getCastleTile() for dragon in dragonSprites: distance = arcade.get_distance_between_sprites(dragon, castleTile) if (distance < constants.REACH_THRESHOLD): stage.damageCastle(dragon.getAtk()) stage.removeDragon(dragon) stage.incrementDragonDead()
def on_update(self, delta_time): if self.paused: return self.level_sprites.append(self.player_sprite.weapon) self.scroll() self.update_player_movement(delta_time) self.update_player_weapon() self.physics_engine.update() self.detect_enemy_collision() for pirate in range(len(self.player_sprites)): self.player_sprites[pirate].on_update(delta_time) self.enemy_list.on_update(delta_time) if self.player_sprite.health <= 0: self.player_sprite.weapon.kill() x, y = self.mouse_position self.cursor._set_left(x*self.viewport_scale+self.view_left) self.cursor._set_top(y*self.viewport_scale+self.view_bottom) self.cursor.scale = self.viewport_scale for enemy in self.enemy_list: if arcade.get_distance_between_sprites( self.player_sprite, enemy) < 50: enemy.move_to(self.player_sprite) enemy.enemy_pathfinding( self.matrix, self.player_sprite, delta_time ) distance = arcade.get_distance_between_sprites( enemy, self.player_sprite) if distance < 10: enemy.is_attacking = True if arcade.check_for_collision(self.player_sprite, enemy): self.player_sprite.health -= 10 self.player_sprite.is_hit = True
def on_update(self, delta_time): # Update cannonball position self.cannonballs.update() # TODO: Need to figure out these values max_height = 10000 max_width = 10000 for cannonball in self.cannonballs: if (cannonball._get_right() < 0 or cannonball._get_top() < 0 or cannonball._get_bottom() > max_height or cannonball._get_left() > max_width): cannonball.kill() # Scroll viewport with ship movement self.scroll() # Detect user input and change speed self.ship_controls(delta_time) # Animate ocean and sea foam layers self.animate_layers() # Engine update and collision detection self.ship_collision() self.play_audio() self.enemy_pathfinding(delta_time) self.enemy_list.on_update(delta_time) width, height = arcade.get_viewport()[1], arcade.get_viewport()[3] if self.player_ship.left < 0: self.player_ship.left = 0 elif self.player_ship.right > width - 1: self.player_ship.right = width - 1 if self.player_ship.bottom < 0: self.player_ship.bottom = 0 elif self.player_ship.top > height - 1: self.player_ship.top = height - 1 for enemy in self.enemy_list: enemy.cannonballs.on_update(delta_time) if arcade.get_distance_between_sprites(self.player_ship, enemy) < 100: enemy.fire_port = True enemy.fire_starboard = True cannonball_collision = len(arcade.check_for_collision_with_list( enemy, self.cannonballs)) > 0 if cannonball_collision and enemy.collision_time_diff > 1: enemy.health -= 20 enemy.collision_time = time.time()
def handleDragonsMovement(self, stage): #dragonSprites, tileSprites): dragonSprites = stage.getDragonSprites() tileSprites = stage.getTileSprites() for dragon in dragonSprites: currentDestTile = tileSprites[dragon.getCurrentDestTileIndex()] if (arcade.get_distance_between_sprites(dragon, currentDestTile) < constants.REACH_THRESHOLD): dragon.popCurrentDestTileIndex() currentDestTile = tileSprites[dragon.getCurrentDestTileIndex()] dragon.setVelocityByDestTile(currentDestTile)
def update_animation(self, delta_time): super().update_animation(delta_time) try: if self.master.left_face: item_margin_x = self.item_margin_x else: item_margin_x = -self.item_margin_x item_margin_y = self.item_margin_y self.a_time += 1 if self.a_time < 70: self.light.radius += delta_time * uniform(1.4, 4.8) elif self.a_time < 140: self.light.radius -= delta_time * uniform(1.4, 4.8) elif self.a_time < 210: self.a_time = 0 self.light.radius = self.texture.width / 3 self.light.position = self.position if abs(arcade.get_distance_between_sprites(self, self.owner)) >= 150: self.my_speed += 1 else: self.my_speed = self.base_my_speed if self.flower_move == 0: self.angle += uniform(0.1, 3) x_diff = (self.master.center_x + item_margin_x + random()) - (self.center_x) y_diff = (self.master.center_y + item_margin_y + random()) - (self.center_y) angle = math.atan2(y_diff, x_diff) if abs(x_diff) > 15 or abs(y_diff) > 15: self.change_x = math.cos(angle) * (self.my_speed + uniform(0.6, 4.2)) self.change_y = math.sin(angle) * (self.my_speed + uniform(0.6, 4.2)) else: self.change_x = math.cos(angle) * uniform(0.02, 0.3) self.change_y = math.sin(angle) * uniform(0.02, 0.3) elif self.flower_move == 1: pass except: pass
def get_closest_sprite(sprite: Sprite, sprite_list: SpriteList) -> Optional[Tuple[Sprite, float]]: """ Given a Sprite and SpriteList, returns the closest sprite, and its distance. :param Sprite sprite: Target sprite :param SpriteList sprite_list: List to search for closest sprite. :return: Closest sprite. :rtype: Sprite """ if len(sprite_list) == 0: return None min_pos = 0 min_distance = get_distance_between_sprites(sprite, sprite_list[min_pos]) for i in range(1, len(sprite_list)): distance = get_distance_between_sprites(sprite, sprite_list[i]) if distance < min_distance: min_pos = i min_distance = distance return sprite_list[min_pos], min_distance
def update(self, delta_time): """ 所有的角色移动等游戏逻辑都在这里编写代码 """ self.frame_counter += 1 if self.frame_counter % 60 == 0: # 约1秒产生一个泡泡,可对数量进行限制 self.spawn_pop() if self.pops: for pop in self.pops: if pop.index < len(self.path): # 把每个泡泡放在路径坐标 pop.center_x = self.path[pop.index][0] # 起始点x坐标 pop.center_y = self.path[pop.index][1] # 起始点y坐标 pop.index += 1 else: pop.kill() # 超出路径则删除它,防守失败! self.game_over = True # print("Game Over") if self.clicked_show > 0: self.clicked_show += 1 # 随机选择一只猴子,让它发射 if self.monkey_list and random.randint(1, 10) == 1: # 这里修改发射击的几率 monkey = random.choice(self.monkey_list) # 查找离它最近的泡泡,如果小于发射半径,则计算角度,让子弹从那个方向发射 min_distance = 10000 for pop in self.pops: # 每个泡泡 distance = arcade.get_distance_between_sprites(pop, monkey) if distance < min_distance: min_distance = distance # 记录更小距离 min_pop = pop # 记录更小距离的泡泡 if min_distance < self.shoot_radius: # 找到小于发射半径的,则发射一颗子弹 dy = (min_pop.center_y - monkey.center_y) // 8 dx = (min_pop.center_x - monkey.center_x) // 8 bullet = arcade.Sprite("images/bullet.png") bullet.center_x = monkey.center_x bullet.center_y = monkey.center_y bullet.change_x = dx bullet.change_y = dy self.bullet_list.append(bullet) # 子弹组和泡泡组的碰撞检测 for bullet in self.bullet_list: bs = arcade.check_for_collision_with_list(bullet, self.pops) # 返回碰到的泡泡列表 if bs: bullet.kill() self.hitedpop_amounts += len([pop.kill() for pop in bs]) if self.hitedpop_amounts == self.pop_amounts: # 击中的泡泡和总数相等,胜利结束。 self.game_over = True self.success = True break self.bullet_list.update()
def getTarget(turret: arcade.sprite, entity_list: arcade.sprite_list): distance = None target = False max_x = 0 max_x_pref = 0 max_pos = 0 max_pos_pref = 0 for i in range(len(entity_list)): distance = arcade.get_distance_between_sprites(turret, entity_list[i]) if not distance >= 32*T_RANGE: if entity_list[i].e_type == turret.e_type - 9: if entity_list[i].center_x > max_x_pref: max_x_pref = entity_list[i].center_x max_pos_pref = i target = True elif entity_list[i].center_x > max_x: max_x = entity_list[i].center_x max_pos = i target = True if target: if max_x_pref != 0: x_sign = turret.center_x - entity_list[max_pos_pref].center_x y_sign = turret.center_y - entity_list[max_pos_pref].center_y if abs(x_sign) > abs(y_sign): if x_sign > 0: turret.character_face_direction = TR else: turret.character_face_direction = TL return entity_list[max_pos_pref] elif max_x != 0: x_sign = turret.center_x - entity_list[max_pos].center_x y_sign = turret.center_y - entity_list[max_pos].center_y if abs(x_sign) > abs(y_sign): if x_sign > 0: turret.character_face_direction = TR else: turret.character_face_direction = TL return entity_list[max_pos] else: return None
def update(self, time: float, delta_time: float, sprites, block_grid) -> None: """ Handles update logic specific to this Enemy. Attempts to shoot at and pathfind to the drill every x seconds. Note ---- As this function is implemented in an Entity subclass, we need to call super().update() at the end of this function so that collision engines are updated accordingly. Parameters ---------- time : float The time that the game has been running for. We can store this to do something every x amount of time. delta_time : float The time in seconds since the last game loop iteration. sprites : SpriteContainer The SpriteContainer class which contains all sprites so we can interact and do calculations with them. block_grid : BlockGrid Reference to all blocks in the game. """ if (time - self._last_line_of_sight_check_time) > 1: self._last_line_of_sight_check_time = time if self.has_line_of_sight_with(sprites.drill, sprites.all_blocks_list): self._has_line_of_sight_with_drill = True else: self._has_line_of_sight_with_drill = False if self._has_line_of_sight_with_drill: if ((time - self._last_shot_time) > 1.5) and \ (arcade.get_distance_between_sprites(self, sprites.drill) < 40): self._last_shot_time = time self.attack = True sprites.drill.hurt(self.damage) if (time - self._last_pathfind_time) > 1: self._last_pathfind_time = time self.path_to_position(sprites.drill.center_x, sprites.drill.center_y, sprites.all_blocks_list) super().update(time, delta_time, sprites, block_grid)
def move(self, character: PlayerCharacter, graph): """Manages move_state, calculates paths to the player, and moves the enemy according to said paths.""" # enemy attacks if arcade.get_distance_between_sprites( self, character) <= self.range and not character.temp_invincibility: self.move_state = "ATTACKING" # elif arcade.get_distance_between_sprites(self, character) > self.range: else: self.move_state = "ROAMING" cur_node_x = int(self.center_x / 64) cur_node_y = int((960 - self.center_y) / 64) if len(self.path) > 0: next_node = self.path[-1] else: next_node = None # if attacking, move according to path if self.move_state is "ATTACKING": char_node_x = int(character.center_x / 64) char_node_y = int((960 - character.center_y) / 64) cur_player_loc = (char_node_x, char_node_y) # if player has moved, re-calculate path if cur_player_loc != self.player_loc: self.build_player_path(graph, char_node_x, char_node_y, cur_node_x, cur_node_y, next_node) # if player is in different location, update it if cur_player_loc != self.player_loc: self.player_loc = cur_player_loc if next_node is not None: self.move_next_node(next_node) # if roaming, move in random directions elif self.move_state is "ROAMING": if self.build_again is True: self.build_random_path(graph[cur_node_y][cur_node_x]) self.build_again = False if next_node is not None: self.move_next_node(next_node)
def on_draw(self): """ Render the screen. """ # This command has to happen before we start drawing arcade.start_render() # Draw all the sprites. hero.player_list.draw() countdown(5) NPC.interact( arcade.get_distance_between_sprites(hero.player_sprite, boy1.npc_sprite), hero.space_key, boy1.text) #boy1.npc_sprite.draw() # Draw the rooms Room.rooms[Room.current_room].wall_list.draw()
def update(self): self.frame_count += 1 self.change_x += np.sign(self.player.center_x - self.center_x) * 0.5 * (1 + self.frame_count / 60) self.change_y += np.sign(self.player.center_y - self.center_y) * 0.5 * (1 + self.frame_count / 60) if np.abs(self.change_x) > 40: self.change_x = np.sign(self.change_x) * 40 if np.abs(self.change_y) > 40: self.change_y = np.sign(self.change_y) * 40 self.center_x += self.change_x self.center_y += self.change_y if arcade.get_distance_between_sprites( self, self.player) < self.player.width and self.frame_count > 20: self.remove_from_sprite_lists()
def on_mouse_press(self, x: float, y: float, button: int, modifiers: int): if button == 4: for ent, (rend, monster, name) in world.get_components(Renderable, Monster, Name): if point_collision(self.mouse_pos, rend): rend.target = not rend.target break elif button == 1: player = world.component_for_entity(self.player, Renderable) monsters = arcade.SpriteList() names = [] [ monsters.append(x[1][0]) for x in world.get_components(Renderable, Monster, Name) ] [ names.append(x[1][2]) for x in world.get_components(Renderable, Monster, Name) ] for m in monsters: print(arcade.get_distance_between_sprites(player, m), names[monsters.index(m)])
def update(self): distance_to_all_cars = [ arcade.get_distance_between_sprites(self, x) for x in self.other_cars_list ] #Quando passaste o ponto de colisão if (self.entrei == True and (self.center_x, self.center_y) not in AREA): for pos in self.collision_point: for carrinho in self.collision_point[pos]: carrinho.message = None self.entrei = False #kill if (int(self.center_x) == int(self.goal[0]) and int(self.center_y) == int(self.goal[1])): #print("iff 2") end = time.time() TIMES.append(end - self.start) self.kill() #Slow down elif ((self.array_pos + MOVEMENT_SPEED) > len(self.path) - 1): self.center_x = self.path[self.array_pos][0] self.center_y = self.path[self.array_pos][1] self.array_pos += 1 #move after stop elif (len( list( filter(lambda y: y == True, [(x.center_x, x.center_y) in self.path[self.array_pos:self.array_pos + 100] for x in self.other_cars_list]))) == 0): self.center_x = self.path[self.array_pos][0] self.center_y = self.path[self.array_pos][1] self.array_pos += MOVEMENT_SPEED #braking distance elif (len( list(filter(lambda x: x < 20 and x > 0, distance_to_all_cars))) > 0): #print("ifff 5") self.center_x = self.path[self.array_pos][0] self.center_y = self.path[self.array_pos][1] self.array_pos += 0 #if someone has locked you elif (self.message != None): self.center_x = self.path[self.array_pos][0] self.center_y = self.path[self.array_pos][1] self.array_pos += 0 self.number_of_blocks += 1 # desbloqueia-se a ele proprio quando o carro que o bloqueou ja nao esta dentro da area de intersecao if ((self.car_who_blocked_me.center_x, self.car_who_blocked_me.center_y) not in AREA and self.number_of_blocks > 5): self.message = None # o carro que o bloqueou tambem esta bloqueado elif (self.car_who_blocked_me.message != None): self.message = None # o carro que o bloqueou nao esta bloqueado, mas por alguma razao tambem nao anda, por isso obrigar o outro a andar elif (self.car_who_blocked_me.message == None ): # obrigar o que o bloqueou a andar self.car_who_blocked_me.center_x = self.car_who_blocked_me.path[ self.car_who_blocked_me.array_pos][0] self.car_who_blocked_me.center_y = self.car_who_blocked_me.path[ self.car_who_blocked_me.array_pos][1] self.car_who_blocked_me.array_pos += MOVEMENT_SPEED #inside intersection elif ((self.center_x, self.center_y) in AREA and self.entrei == False): cars_inside = [ x for x in self.other_cars_list if (x.center_x, x.center_y) in AREA ] counter = 0 for car in cars_inside: common = [ value for value in self.path[self.array_pos:self.array_pos + 300] if value in car.path[car.array_pos:car.array_pos + 300] ] if (len(common) > 0): mine_n_iterations = abs(common[0][0] - self.center_x) + abs(common[0][1] - self.center_y) other_n_iterations = abs(common[0][0] - car.center_x) + abs(common[0][1] - car.center_y) if (mine_n_iterations < other_n_iterations ): # a minha distancia é menor que a do outro counter += 1 if (common[0] in self.collision_point.keys()): cars_list = self.collision_point[common[0]] cars_list.append(car) self.collision_point[common[0]] = cars_list else: self.collision_point[common[0]] = [car] car.message = 0 car.car_who_blocked_me = self self.entrei = True self.center_x = self.path[self.array_pos][0] self.center_y = self.path[self.array_pos][1] self.array_pos += MOVEMENT_SPEED #normal circulation else: self.center_x = self.path[self.array_pos][0] self.center_y = self.path[self.array_pos][1] self.array_pos += MOVEMENT_SPEED
def update(self, delta_time): """ Contains logic to update sprites and view. """ # Updates physics engine self.physics_engine.update() # Update Rogue Ducks self.rogue_duck_list.update() # Find the closest trees self.trees_in_range = [ t for t in self.tree_list if arcade.get_distance_between_sprites(self.player_sprite, t) < 100 ] # --- Manage Scrolling --- # Track if we need to change the viewport changed = False # Scroll left left_bndry = self.view_left + VIEWPORT_MARGIN if self.player_sprite.left < left_bndry: self.view_left -= left_bndry - self.player_sprite.left changed = True # Scroll right right_bndry = self.view_left + SCREEN_WIDTH - VIEWPORT_MARGIN if self.player_sprite.right > right_bndry: self.view_left += self.player_sprite.right - right_bndry changed = True # Scroll up top_bndry = self.view_bottom + SCREEN_HEIGHT - VIEWPORT_MARGIN if self.player_sprite.top > top_bndry: self.view_bottom += self.player_sprite.top - top_bndry changed = True # Scroll down bottom_bndry = self.view_bottom + VIEWPORT_MARGIN if self.player_sprite.bottom < bottom_bndry: self.view_bottom -= bottom_bndry - self.player_sprite.bottom changed = True self.view_left = int(self.view_left) self.view_bottom = int(self.view_bottom) if changed: arcade.set_viewport( self.view_left, SCREEN_WIDTH + self.view_left - 1, self.view_bottom, SCREEN_HEIGHT + self.view_bottom - 1 ) # Checks for collision between player and baby duck duck_and_baby_duck_hit_list = arcade.check_for_collision_with_list( self.player_sprite, self.baby_duck_list, ) # Kill baby duck sprite if collision with player if len(duck_and_baby_duck_hit_list) > 0: for baby_duck in duck_and_baby_duck_hit_list: baby_duck.kill() self.score += 1 arcade.play_sound(self.captured_duck_sound) if self.score == BABY_DUCKS_COUNT: self.player_speed = 0 self.game_state = False self.game_over.center_x = self.view_left + 400 self.game_over.center_y = self.view_bottom + 300 self.win = True # Check if player has collided with rogue duck player_rogue_duck_hit_list = arcade.check_for_collision_with_list( self.player_sprite, self.rogue_duck_list ) # Kill game if player collided with rogue duck if len(player_rogue_duck_hit_list) > 0: self.player_speed = 0 self.game_state = False self.game_over.center_x = self.view_left + 400 self.game_over.center_y = self.view_bottom + 300
def update(self, delta_time): #Updates the characters self.player_1.update() self.player_2.update() #Sets the center of the viewport to be inbetween the players and scale to the distance between them creating a zoom effect midpoint = ((self.player_1.center_x + self.player_2.center_x) / 2, (self.player_1.center_y + self.player_2.center_y) / 2) distance = arcade.get_distance_between_sprites(self.player_1, self.player_2) arcade.set_viewport(midpoint[0] - distance - self.view, midpoint[0] + distance + self.view, midpoint[1] - distance - self.view, midpoint[1] + distance + self.view) #--COLLISIONS-- #Checks if both players are colliding with any exits, if so, setup the next level if (arcade.check_for_collision_with_list(self.player_1, self.exits) and arcade.check_for_collision_with_list( self.player_2, self.exits)): print("Player 1 Cash:" + str(self.player_1_cash) + "\n" + "Player 2 Cash:" + str(self.player_2_cash) + "\n") self.levels[self.level_index + 1]() #Checks if both players are colliding with any entrances, if so setup the previous level if (arcade.check_for_collision_with_list(self.player_1, self.entrances) and arcade.check_for_collision_with_list( self.player_2, self.entrances)): print("Player 1 Cash:" + str(self.player_1_cash - 1) + "\n", "Player 2 Cash:" + str(self.player_2_cash) + "\n") self.levels[self.level_index - 1]() #Destroys any coins colliding with player_1 as well as adding to player_1's cash player_1_coin_collisions = arcade.check_for_collision_with_list( self.player_1, self.coins) for i in player_1_coin_collisions: self.level_coin_positions[self.level_index].remove( [i.center_x, i.center_y]) self.coins.remove(i) self.player_1_cash += 1 #Destroys any coins colliding with player_2 as well as adding to player_2's cash player_2_coin_collisions = arcade.check_for_collision_with_list( self.player_2, self.coins) for i in player_2_coin_collisions: self.level_coin_positions[self.level_index].remove( [i.center_x, i.center_y]) self.coins.remove(i) self.player_2_cash += 1 #Update Guards and detect collisions collision = False for i in self.guards: i.guard_update() if (i.alerted == True): if (arcade.get_distance_between_sprites(self.player_1, i) < arcade.get_distance_between_sprites(self.player_2, i)): i.target = [self.player_1.center_x, self.player_1.center_y] else: i.target = [self.player_2.center_x, self.player_2.center_y] if (arcade.check_for_collision(self.player_1, i)): i.alert() collision = True if (arcade.check_for_collision(self.player_2, i)): i.alert() collision = True if (collision == True): self.guard_collisions += 1 if (self.guard_collisions == 1): self.game_over_time = time.time() + 2 else: self.guard_collisions = 0 self.game_over_time = 0 if (self.game_over_time != 0): if (time.time() >= self.game_over_time): self.game_over()
def update(self): distance_to_all_cars = [ arcade.get_distance_between_sprites(self, x) for x in self.other_cars_list ] #reset flags if ((self.center_x, self.center_y) in AREA and self.in_intersection == True and (250 > self.center_x or self.center_x > 550 or 250 > self.center_y or self.center_y > 550)): self.in_intersection = False self.after_intersection = True #kill on arrival to goal if (int(self.center_x) == int(self.goal[0]) and int(self.center_y) == int(self.goal[1])): end = time.time() TIMES.append(end - self.start) self.kill() #slow down elif ((self.array_pos + MOVEMENT_SPEED) > len(self.path)): self.center_x = self.path[self.array_pos][0] self.center_y = self.path[self.array_pos][1] self.array_pos += 1 #someone already is inside the intersection elif (len( list( filter(lambda y: y == True, [x.in_intersection for x in self.other_cars_list]))) > 0 and (self.center_x, self.center_y) in AREA and self.after_intersection == False): self.center_x = self.path[self.array_pos][0] self.center_y = self.path[self.array_pos][1] self.array_pos += 0 #someone enters the intersection elif (250 < self.center_x and self.center_x < 550 and 250 < self.center_y and self.center_y < 550 and self.in_intersection == False): self.in_intersection = True self.center_x = self.path[self.array_pos][0] self.center_y = self.path[self.array_pos][1] self.array_pos += MOVEMENT_SPEED #move after stop elif (len( list( filter(lambda y: y == True, [(x.center_x, x.center_y) in self.path[self.array_pos:self.array_pos + 100] for x in self.other_cars_list]))) == 0): self.center_x = self.path[self.array_pos][0] self.center_y = self.path[self.array_pos][1] self.array_pos += MOVEMENT_SPEED #braking distance elif (len( list(filter(lambda x: x < 65 and x > 0, distance_to_all_cars))) > 0): self.center_x = self.path[self.array_pos][0] self.center_y = self.path[self.array_pos][1] self.array_pos += 0 QUEUE.append(self) #normal circulation else: self.center_x = self.path[self.array_pos][0] self.center_y = self.path[self.array_pos][1] self.array_pos += MOVEMENT_SPEED
def setVelocityByDestTile(self, tile): distanceToLocation = arcade.get_distance_between_sprites(self, tile) scaler = self._absoluteVelocity / distanceToLocation change_x = scaler * (tile.center_x - self.center_x) change_y = scaler * (tile.center_y - self.center_y) super().setVelocity(change_x, change_y)
def on_update(self, delta_time): """ Movement and game logic """ self.frame_count += 1 # Move the player with the physics engine self.physics_engine.update() #check if the player is in water, water is always at a certain level, so #can just check if player is below this level if self.player_sprite.center_y < 9 * GRID_SIZE: self.in_fluid = True else: self.in_fluid = False # 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.player_list.update_animation(delta_time) self.bullet_list.update() #remove lasers if they go offscreen to save memory for laser in self.bullet_list: if laser.center_x + 18 > self.view_left + SCREEN_WIDTH: laser.remove_from_sprite_lists() print('laser removed') elif laser.center_x - 18 < self.view_left: laser.remove_from_sprite_lists() print('laser removed') #check to see if enemies were hit by player laser, in which case they are #destroyed for laser in self.bullet_list: enemy_hit_list = arcade.check_for_collision_with_list(laser, self.enemy_list) projectile_enemy_hit_list = arcade.check_for_collision_with_list(laser, self.projectile_enemy_list) if len(enemy_hit_list) > 0: laser.remove_from_sprite_lists() for enemy in enemy_hit_list: enemy.remove_from_sprite_lists() continue elif len(projectile_enemy_hit_list) > 0: laser.remove_from_sprite_lists() for enemy in projectile_enemy_hit_list: enemy.remove_from_sprite_lists() continue #check to see if gems were contacted by player sprite, in which case the #player gains an ability point gem_hit_list = arcade.check_for_collision_with_list(self.player_sprite, self.gem_list) for gem in gem_hit_list: self.ability_reset_count += 1 gem.remove_from_sprite_lists() #add the gems collected to a list so they can be recalled upon reset self.ability_count += 1 #make enemies patrol on platforms #create invisible platforms in foreground, i.e. platforms we do not call in #draw, and then if enemy collides with these, they turn around for enemy in self.enemy_list: if enemy.change_x >0.5 and arcade.check_for_collision_with_list(enemy, self.invisible_platform_list): enemy.change_x = -ENEMY_PATROL_SPEED elif enemy.change_x <-0.5 and arcade.check_for_collision_with_list(enemy, self.invisible_platform_list): enemy.change_x = ENEMY_PATROL_SPEED elif enemy.change_x == 0: enemy.change_x = ENEMY_PATROL_SPEED self.frame_count +=1 for enemy in self.projectile_enemy_list: if self.frame_count % 240 == 0: enemy_laser = arcade.Sprite("art/PNG/lasers/laserRedVertical.png", scale=LASER_SCALING) enemy_laser.center_x = enemy.center_x enemy_laser.center_y = enemy.center_y - 54 enemy_laser.change_y = -ENEMY_LASER_SPEED self.enemy_laser_list.append(enemy_laser) for laser in self.enemy_laser_list: projectile_enemy_hit_list = arcade.check_for_collision_with_list(laser, self.projectile_enemy_list) #removes laser if it hits a platform if arcade.check_for_collision_with_list(laser, self.wall_list): laser.remove_from_sprite_lists() if len(projectile_enemy_hit_list) >0: laser.remove_from_sprite_lists() for enemy in projectile_enemy_hit_list: enemy.remove_from_sprite_lists() continue #gets distance between player and laser, then creates parry mechanic self.distance = arcade.get_distance_between_sprites(laser, self.player_sprite) if self.parry_pressed and self.distance < 80: laser.change_y = ENEMY_LASER_SPEED self.enemy_laser_list.update() self.projectile_enemy_list.update() self.enemy_list.update() #----TRACK DEATH EVENTS----# #check if player fell off map, this also works for the player falls in #water, as the water level is always nine grid blocks above 0 if self.player_sprite.center_y < 1 * GRID_SIZE: self.reset_position() # print(self.player_sprite.center_y) #check if player came into contact with general/type enemy, and then 'dies' if arcade.check_for_collision_with_list(self.player_sprite, self.enemy_list): self.reset_position() if arcade.check_for_collision_with_list(self.player_sprite, self.projectile_enemy_list): self.reset_position() if arcade.check_for_collision_with_list(self.player_sprite, self.enemy_laser_list): self.reset_position() #checks to see if the player hit the checkpoint, in which case their #starting coordinates are reset to the checkpoint if arcade.check_for_collision_with_list(self.player_sprite, self.checkpoint_list): print('checkpoint collision detectedd') #coordinates should roughly be 2400, 992 self.START_X = self.checkpoint_list[0].center_x self.START_Y = self.checkpoint_list[0].center_y print(self.START_X) #checks to see if player has found the objective and has won the game! if arcade.check_for_collision_with_list(self.player_sprite, self.objective_list): win_view = WinView() self.window.show_view(win_view) # Track if we need to change the viewport changed = False # 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 = 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 to integers. Otherwise we end up with pixels that # don't line up on the screen 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)
def update(self, delta_time): """ All the logic to move, and the game logic goes here. """ global end_window, end_window_time, key_k, key_k_used_time, open_door # kill every key has been collect hit_list = arcade.check_for_collision_with_list( self.player_sprite, self.key.all_keys) for key in hit_list: # count the number of time player use K to get the closest key if key == self.key.all_keys[0]: key_k_used_time += 1 key_k = False key.remove_from_sprite_lists() self.score += 1 # check if the player hit the door if len( arcade.check_for_collision_with_list(self.player_sprite, self.door)) == 1: end_window = True end_window_time = self.frime_count # Show the text: 3 seconds if self.flag_k: if self.frime_count - end_window_time == 180 and end_window: end_window = False open_door = False # update the physics engine self.physics_engine.update() # get the closest key if key_k and key_k_used_time < 1: steps = int( arcade.get_distance_between_sprites(self.player_sprite, self.key.all_keys[0])) x_delta = 6 * ( (self.key.all_keys[0].center_x - self.player_sprite.center_x) / steps) y_delta = 6 * ( (self.key.all_keys[0].center_y - self.player_sprite.center_y) / steps) self.key.all_keys[ 0].center_x = self.key.all_keys[0].center_x - x_delta self.key.all_keys[ 0].center_y = self.key.all_keys[0].center_y - y_delta # ------------- merge the screen view ---------------- changed = False # Scroll left left_boundary = self.view_left + view_merge if self.player_sprite.left < left_boundary and left_boundary > 100: self.view_left -= left_boundary - self.player_sprite.left changed = True # Scroll right right_boundary = self.view_left + WIDTH - view_merge if self.player_sprite.right > right_boundary and right_boundary < 1400: self.view_left += self.player_sprite.right - right_boundary changed = True # Scroll up top_boundary = self.view_bottom + HEIGHT - view_merge if self.player_sprite.top > top_boundary and top_boundary < 1395: self.view_bottom += self.player_sprite.top - top_boundary changed = True # Scroll down bottom_boundary = self.view_bottom + view_merge if self.player_sprite.bottom < bottom_boundary and bottom_boundary > 105: self.view_bottom -= bottom_boundary - self.player_sprite.bottom changed = True # make sure no rounding errors. self.view_left = int(self.view_left) self.view_bottom = int(self.view_bottom) # If we changed the boundary values, update the view port to match if changed: arcade.set_viewport(self.view_left, WIDTH + self.view_left - 1, self.view_bottom, HEIGHT + self.view_bottom - 1) self.frime_count += 1
def update(self): if not self.dead: # Pre-load animations if self.setup_bool: for i in range( len(SpriteCache.ENEMY_SLIME_IDLE_RIGHT_ANIMATION)): self.texture = SpriteCache.ENEMY_SLIME_IDLE_RIGHT_ANIMATION[ i] for i in range(len( SpriteCache.ENEMY_SLIME_IDLE_LEFT_ANIMATION)): self.texture = SpriteCache.ENEMY_SLIME_IDLE_LEFT_ANIMATION[ i] for i in range( len(SpriteCache.ENEMY_SLIME_ATTACK_LEFT_ANIMATION)): self.texture = SpriteCache.ENEMY_SLIME_ATTACK_LEFT_ANIMATION[ i] for i in range( len(SpriteCache.ENEMY_SLIME_ATTACK_RIGHT_ANIMATION)): self.texture = SpriteCache.ENEMY_SLIME_ATTACK_RIGHT_ANIMATION[ i] self.setup_bool = False # Handle HP self.hp_container.center_x = self.center_x self.hp_container.center_y = self.center_y + self.height if self.current_hp / self.max_hp < 0.25: self.hp_color = [182, 1, 1] else: self.hp_color = [228, 52, 52] # Handle attacking and moving sign = np.sign(self.game_view.player.center_x - self.center_x) self.change_x = sign * self.movement_speed if self.change_x > 0: self.facing_left = False elif self.change_x < 0: self.facing_left = True # Handle auto-attack enemy_to_attack = None distance_to_player = arcade.get_distance_between_sprites( self, self.game_view.player) distance_to_player_x = np.abs(self.center_x - self.game_view.player.center_x) collided = arcade.check_for_collision(self, self.game_view.player) if collided: self.can_attack = True else: self.can_attack = False if distance_to_player_x < self.width / 2 - 1: self.change_x = 0 if (self.can_attack) and (self.frames_since_attack > self.frames_between_attack): self.attack() self.frames_since_attack = 0 # Damage label for damaged_label_object in self.damaged_label_list: damaged_label_object.update() if damaged_label_object.animation_complete: self.damaged_label_list.remove(damaged_label_object) if self.current_hp <= 0: self.death() # End of frame updates self.center_x += self.change_x self.frames_since_attack += 1 self.time_since_damaged += 1.0 / FRAME_RATE else: # Damage label for damaged_label_object in self.damaged_label_list: damaged_label_object.update() if damaged_label_object.animation_complete: self.damaged_label_list.remove(damaged_label_object) # Check animation status if self.death_animation_finished: if self.alpha > 7: self.alpha -= 6 else: self.ready_to_remove = True self.remove_from_sprite_lists()
def get_dist(self, p1: Player, p2: Player): return arcade.get_distance_between_sprites(p1.sprite, p2.sprite)
def get_ball_distance(self, player: Player): return arcade.get_distance_between_sprites(self.ball.sprite, player.sprite)