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)
