def on_ship_alien_collision(ship, alien_fleet, lasers):
"""Handles player ship colliding with aliens."""
if not ship.is_dead:
if (sprite.spritecollideany(ship, lasers) or sprite.spritecollideany(ship, alien_fleet.aliens) or
alien_fleet.reached_bottom()):
ship.destroy()
return True
def test_spritecollideany__without_collided_callback(self):
# pygame.sprite.spritecollideany(sprite, group) -> sprite
# finds any sprites that collide
# if collided is not passed, all
# sprites must have a "rect" value, which is a
# rectangle of the sprite area, which will be used
# to calculate the collision.
# s2 in, s3 out
self.assert_(
sprite.spritecollideany(self.s1, self.ag2)
)
# s2 and s3 out
self.s2.rect.move_ip(0, 10)
self.assertFalse(sprite.spritecollideany(self.s1, self.ag2))
# s2 out, s3 in
self.s3.rect.move_ip(-105, -105)
self.assert_(sprite.spritecollideany(self.s1, self.ag2))
# s2 and s3 in
self.s2.rect.move_ip(0, -10)
self.assert_(sprite.spritecollideany(self.s1, self.ag2))
def test_spritecollideany__without_collided_callback(self):
# pygame.sprite.spritecollideany(sprite, group) -> sprite
# finds any sprites that collide
# if collided is not passed, all
# sprites must have a "rect" value, which is a
# rectangle of the sprite area, which will be used
# to calculate the collision.
# s2 in, s3 out
self.assert_(
sprite.spritecollideany(self.s1, self.ag2)
)
# s2 and s3 out
self.s2.rect.move_ip(0, 10)
self.assertFalse(sprite.spritecollideany(self.s1, self.ag2))
# s2 out, s3 in
self.s3.rect.move_ip(-105, -105)
self.assert_(sprite.spritecollideany(self.s1, self.ag2))
# s2 and s3 in
self.s2.rect.move_ip(0, -10)
self.assert_(sprite.spritecollideany(self.s1, self.ag2))
def get_direction_options(self):
tests = {
'u': self.rect.move((0, -self.speed)),
'l': self.rect.move((-self.speed, 0)),
'd': self.rect.move((0, self.speed)),
'r': self.rect.move((self.speed, 0))
}
remove = []
original_pos = self.rect
for d, t in tests.items():
self.rect = t
if spritecollideany(self,
self.maze.maze_blocks) and d not in remove:
remove.append(d)
if spritecollideany(
self, self.pacman_position.portal_controller.blue_portal
) and d not in remove:
remove.append(d)
if spritecollideany(
self, self.pacman_position.portal_controller.orange_portal
) and d not in remove:
remove.append(d)
for rem in remove:
del tests[rem]
self.rect = original_pos
return list(tests.keys())
def test_spritecollideany__without_collided_callback(self):
# pygame.sprite.spritecollideany(sprite, group) -> sprite
# finds any sprites that collide
# if collided is not passed, all
# sprites must have a "rect" value, which is a
# rectangle of the sprite area, which will be used
# to calculate the collision.
# s2 in, s3 out
expected_sprite = self.s2
collided_sprite = sprite.spritecollideany(self.s1, self.ag2)
self.assertEqual(collided_sprite, expected_sprite)
# s2 and s3 out
self.s2.rect.move_ip(0, 10)
collided_sprite = sprite.spritecollideany(self.s1, self.ag2)
self.assertIsNone(collided_sprite)
# s2 out, s3 in
self.s3.rect.move_ip(-105, -105)
expected_sprite = self.s3
collided_sprite = sprite.spritecollideany(self.s1, self.ag2)
self.assertEqual(collided_sprite, expected_sprite)
# s2 and s3 in
self.s2.rect.move_ip(0, -10)
expected_sprite_choices = self.ag2.sprites()
collided_sprite = sprite.spritecollideany(self.s1, self.ag2)
self.assertIn(collided_sprite, expected_sprite_choices)
def get_direction_options(self):
"""Check if the ghost is blocked by any maze barriers and return all directions possible to move in"""
tests = {
'u': self.rect.move((0, -self.speed)),
'l': self.rect.move((-self.speed, 0)),
'd': self.rect.move((0, self.speed)),
'r': self.rect.move((self.speed, 0))
}
remove = []
original_pos = self.rect
for d, t in tests.items():
self.rect = t # temporarily move self
if spritecollideany(self,
self.maze.maze_blocks) and d not in remove:
remove.append(
d) # if collision, mark this direction for removal
if spritecollideany(self, self.target.portal_controller.blue_portal
) and d not in remove:
remove.append(d)
if spritecollideany(self, self.target.portal_controller.
orange_portal) and d not in remove:
remove.append(d)
for rem in remove:
del tests[rem]
self.rect = original_pos # reset position
return list(tests.keys())
def check_collisions(player, lions, cars):
"""Returns true if there is a collision """
if (spritecollideany(player.sheep, lions) or
spritecollideany(player.sheep, cars)):
player.sheep.reset()
return True
return False
def collision(self):
bullets = Group()
bullets.add(self.player.bullets)
bullets.add(self.room.enemies_bullets)
groupcollide(bullets, self.room.walls, True, False)
spritecollideany(self.player,
self.room.enemies_bullets,
collided=self.__collide_with('bullet'))
groupcollide(self.room.enemies,
self.player.bullets,
False,
False,
collided=self.__collide_with('bullet'))
spritecollideany(self.player,
self.room.hearts,
collided=self.__collide_with('heart'))
spritecollideany(self.player,
self.room.coins,
collided=self.__collide_with('coin'))
spritecollideany(self.player,
self.room.energy_orbs,
collided=self.__collide_with('energy_orb'))
if self.room.portal is not None:
entered = self.player.rect.colliderect(self.room.portal.rect)
if entered:
self.new_room()
self.player.rooms_survived += 1
def _create_image(self):
grp = Group()
for word in self.words:
if len(grp.sprites()) == 0:
word.scale(self.ratio+0.2)
pm_w = word.rect.width
pm_h = word.rect.height
pm_x, pm_y = place_primary(pm_w, pm_h)
word.rect.x, word.rect.y = pm_x, pm_y
arch_x = pm_x + pm_w/2
arch_y = pm_y + pm_h/2
else:
word.scale(self.ratio)
for x, y in archimedean_spiral(False):
if self.debug:
rs = Surface((5, 5))
rs.fill((0, 0, 255))
rs.set_alpha(100)
self.sf.blit(rs, (x + arch_x, y + arch_y))
word.set_position(x + arch_x, y + arch_y)
x_out = CANVAS_WIDTH - CANVAS_PADDING < word.rect.x + word.rect.width or word.rect.x < CANVAS_PADDING
y_out = CANVAS_HEIGHT - CANVAS_PADDING < word.rect.y + word.rect.height or word.rect.y < CANVAS_PADDING
out_of_bound = x_out or y_out
if spritecollideany(word, grp, collide_mask) is None and not out_of_bound:
if self.debug:
rs = Surface((5, 5))
rs.fill((0, 255, 0))
rs.set_alpha(100)
self.sf.blit(rs, (x + arch_x, y + arch_y))
break
self.sf.blit(word.image, word.rect)
grp.add(word)
def quadtree_check_future_collision(self, speed, platforms, col_rect = None):
""" Checks wether the speed vector is going to give a collision
in the next tick. Return a list of platform collided.
Takes the speed vector and a group of sprites to check collisions
with """
if not col_rect:
col_rect = self.col_rect
# Remember, self.rect variables shouldn't be changed
# of reference.
# Hold a copy to the reference of the original col_rect
old_reference_col_rect = self.col_rect
self.col_rect = self.col_rect.move(speed[0], speed[1])
# NOTE TO FUTURE SELF: .hit() and collision between rects don't
# use the same algorithm, this make odd stuff some times. For
# example, in here .hit() returns some platforms but
# .spritecollideany() don't.
# TODO: Maybe would be good idea to make quadtree work with
# pygame.Rect() ?
map_coll = platforms.hit(self.col_rect)
map_coll = spritecollideany(self, map_coll, collision_detection)
# Restore the old reference
self.col_rect = old_reference_col_rect
return map_coll
def detect_collision(self):
if self.elements['ship'].sprite:
self.ship_collides = spritecollideany(self.elements['ship'].sprite,
self.elements['asteroids'])
if groupcollide(self.elements['lasers'], self.elements['asteroids'],
True, True):
self.score_add(50)
def _update_health(self):
hit = spritecollideany(self, self.game.adventure.bullets, False)
if hit:
self.health -= ATTACK_DAMAGE
hit.kill()
if self.health <= 0:
self.game.score.add_kill()
self.kill()
def update_aliens(ai_settings, stats, screen, sb, ship, aliens, bullets):
"""""Check if the fleet is at an edge, and then update alien's postion"""
check_fleet_edges(ai_settings, aliens)
aliens.update()
if spritecollideany(ship, aliens):
ship_hit(ai_settings, stats, screen, sb, ship, aliens, bullets)
check_aliens_bottom(ai_settings, stats, screen, sb, ship, aliens, bullets)
def detect_collision(self):
if self.elements['ship'].sprite:
self.ship_collides = spritecollideany(self.elements['ship'].sprite, self.elements['asteroids'])
self.ship_catches = spritecollide(self.elements['ship'].sprite, self.elements['power-ups'], True)
if groupcollide(self.elements['lasers'], self.elements['asteroids'], True, True):
if randint(1, 20) == 1:
self.newPU = True
self.score_add(50)
def spawn_new_orb_randomly(self):
while True:
# do not spawn orbs on top of robot or obstacles or outside the floor
orb_width, orb_height = self.settings['orb_size']
x, y = random.randint(0, self.floor.width -
orb_width), random.randint(
0, self.floor.height - orb_height)
new_orb = Orb(x, y, self)
if self.state == OrbCatchingGame.STATE_BONUS:
new_orb = BonusOrb(x, y, self)
if not spritecollideany(new_orb, self.obstacles, collide_rect_ratio(self.spawn_dist_obs_orb)) and \
not collide_rect_ratio(self.spawn_dist_robot_orb)(new_orb, self.robot) and \
not spritecollideany(new_orb, self.orbs, collide_rect_ratio(self.spawn_dist_orb_orb)):
break
self.orbs.add(new_orb)
def _spawn_robot_at_pos(self, robot_pos):
x, y = robot_pos
robot = Robot(x, y, self.floor, self)
if len(self.obstacles) > 0 and spritecollideany(robot, self.obstacles):
raise ValueError(
'Could not spawn robot at position {} because it collides with an obstacle'
.format(robot_pos))
return robot
def _spawn_robot_randomly(self):
while True:
robot_w, robot_h = self.settings['robot_size']
x, y = random.randint(0,
self.floor.width - robot_w), random.randint(
0, self.floor.height - robot_h)
robot = Robot(x, y, self.floor, self)
if not spritecollideany(robot, self.obstacles):
break
return robot
def is_bird_dead(self):
# Game ends when bird collides with pipe
collided_sprite = sprite.spritecollideany(self.flappy_bird,
self._pipe_group)
if collided_sprite is not None:
return True
# Bird stops moving when hitting near bottom of screen
bird_death_pos_y = self._settings.window_height - 20
if self.flappy_bird.rect.bottom >= bird_death_pos_y:
return True
return False
def update_aliens(game_set, stats, screen, ship, aliens, bullets, sb,
play_button, sound):
"""Checks if the fleet reached some edge and then updates the position of all aliens"""
check_fleet_edges(game_set, aliens)
aliens.update()
#Checks if had any collide among the aliens and the ship
if spritecollideany(ship, aliens):
ship_hit(game_set, stats, screen, ship, aliens, bullets, sb,
play_button, sound)
check_aliens_bottom(game_set, stats, screen, ship, aliens, bullets, sb,
play_button, sound)
def update(self):
self.player.update()
self.npcgroup.update()
if sprite.spritecollideany(self.player, self.walls):
self.player._goback()
for npc in sprite.groupcollide(self.npcgroup, self.walls, False, False):
npc._goback()
npcCollisions = sprite.spritecollide(self.player, self.npcgroup, False)
if len(npcCollisions) > 0:
self.prepareForBattle()
npcCollisions[0].kill()
return BattleEvent(self.player, npcCollisions[0])
return None
def on_loop(self):
caught_orb = spritecollideany(self.robot, self.orbs)
if caught_orb is not None:
self.n_orbs_collected += 1
if type(caught_orb) == BonusOrb:
self.n_bonus_orbs_collected += 1
caught_orb.kill()
if PLAY_SELF and self.normal_orb_is_caught():
self.reset()
colliding_obstacle = spritecollideany(self.robot, self.obstacles)
if colliding_obstacle is not None:
if colliding_obstacle not in self.collided_obstacles:
self.collided_obstacles.append(colliding_obstacle)
self.robot.reset_to_prev_position()
if self.n_obstacles > 1:
if self.state is not OrbCatchingGame.STATE_BONUS and len(
self.collided_obstacles) == self.n_obstacles:
self.go_in_bonus_mode()
def sendShips(self, game, destPlanet):
# finds available locations around a planet to spawn the
# ships in a circle around a planet
BUFFERSPACE = 1
numShips = self.units // 2
# create a new group of ships
cluster = Cluster(destPlanet, self.team)
game.clusterNames[cluster.name] = cluster
#initial values
startAngle = getAngle(*self.loc, *destPlanet.loc)
spawnDist = self.r + Ship.RADIUS + BUFFERSPACE
shipsMade = 0
while shipsMade < numShips:
angleStep = math.asin((Ship.RADIUS + BUFFERSPACE) / (spawnDist))
currAngle = startAngle
while currAngle < pi * 2:
spawnPt = cartePlusPolar(*self.loc, spawnDist, currAngle)
tryShip = Ship(spawnPt, self, destPlanet)
collision = (sp.spritecollideany(tryShip, game.ships,
Ship.collidedShip)
or sp.spritecollideany(tryShip, game.map,
Ship.collidedShip))
if collision:
# failPoints.append(spawnPt)
del tryShip # get rid of failed object
else:
game.ships.add(tryShip)
cluster.add(tryShip)
shipsMade += 1
self.units -= 1
if shipsMade == numShips: break
currAngle += 2 * angleStep
spawnDist += 2 * Ship.RADIUS + BUFFERSPACE
def update(self):
if self.direction == DIRECTION_BACK:
self.y -= ATTACK_SPEED
elif self.direction == DIRECTION_FRONT:
self.y += ATTACK_SPEED
elif self.direction == DIRECTION_LEFT:
self.x -= ATTACK_SPEED
elif self.direction == DIRECTION_RIGHT:
self.x += ATTACK_SPEED
self.rect.x = self.x
self.rect.y = self.y
if spritecollideany(self, self.game.adventure.walls, False):
self.kill()
def update(self):
self.player.move()
self.shots.update()
self.alien_shots.update()
self.aliens.update()
for a in self.aliens:
shot = a.get_shot()
if shot:
self.alien_shots.add(shot)
self.draw()
groupcollide(self.shots, self.aliens, True, True, collided=collide_mask)
if spritecollideany(self.player, self.alien_shots, collided=collide_mask):
self.game.exit()
if not self.aliens:
self.game.exit()
def move(self):
if self.timer - self.last_timer >= 5:
self.vy += self.ay
self.last_timer = self.timer
self.rect.y += int(self.vy)
if sprite.spritecollideany(self, self.wall_sprites):
self.rect.y -= int(self.vy)
self.stay = True
self.last_timer = self.timer
cords = self.rect.center
self.image = self.boom
self.rect = self.image.get_rect()
self.rect.center = cords
if self.rect.bottom <= 0:
self.kill()
def merge_plant_sets(origin_dict, merging_dict):
"""
:param origin_dict:
:param merging_dict:
:return: Merges the two dictionaries merged together, correcting for overlapping plants
"""
for plant in merging_dict.values():
collision = spritecollideany(plant, origin_dict.values())
if collision:
move_dir = Vector2(plant.rect.left, plant.rect.top) - Vector2(
collision.rect.left, collision.rect.top)
plant.rect.left = plant.rect.left + move_dir.x
plant.rect.top = plant.rect.top + move_dir.y
return {**origin_dict, **merging_dict}
def update(self, time_delta: float):
if self._speed.length() == 0:
return
before = self.rect
mov = self._speed * time_delta
self.rect = pygame.Rect(self.position.x + mov.x, self.position.y + mov.y, before.width, before.height)
if spritecollideany(self, self.level.colliders, False) is None and self.level.bounds.contains(self.rect):
self._position += mov
s = set()
for obj in pygame.sprite.spritecollide(self, self.level.interactions, False):
s.add(obj.map_object)
for obj in s:
if obj not in self._triggered:
self.level.activate_object(obj)
self._triggered = s
else:
self.rect = before
def _init_obstacle_randomly(self, obstacles):
obstacle_width, obstacle_height = self.settings['obstacle_size']
while True:
x, y = random.randint(0, self.floor.width -
obstacle_width), random.randint(
0, self.floor.height - obstacle_height)
obstacle = Obstacle(x, y, self.settings['obstacle_size'])
if not spritecollideany(
obstacle, obstacles,
collide_rect_ratio(self.spawn_dist_obs_obs)):
if hasattr(self, 'robot') and self.robot is not None:
if not collide_rect_ratio(self.spawn_dist_obs_robot)(
obstacle, self.robot):
break
else:
break
return obstacle
def update(self, event):
self.check_death()
self.now_time += 1
try:
self.image = self.all_animations_file[self.now_animation][
self.tick_of_animation %
len(self.all_animations_file[self.now_animation])]
if self.time_space == self.now_time:
self.now_time = 0
if self.now_animation == 0:
# for walk
collide_sprite = spritecollideany(
self, self.battle_state.get_not_my_group(self.team_id))
# can to attack?
# print(collide_sprite.__class__.__name__)
if collide_sprite and self.damage:
collide_sprite.give_damage(self.damage)
if len(self.all_animations_file) > 1:
self.now_animation = 1
# change to attack
self.tick_of_animation = 0
if self.now_animation == 0:
self.rect.x += self.speed \
if self.fm.get_function("SimpleVars").PLAYER_TEAM_ID == self.team_id \
else -self.speed
if self.now_animation == 1:
# print("attack")
if self.tick_of_animation == len(
self.all_animations_file[self.now_animation]) - 1:
self.now_animation = 0
if self.now_animation == 2:
# change to kill
if self.tick_of_animation == len(
self.all_animations_file[self.now_animation]) - 1:
self.now_animation = 0
self.kill()
# changing sprite
self.tick_of_animation += 1
except Exception as e:
self.fm.get_main_log().write_log(
f" {e} || {self.now_animation} ", self,
self.fm.get_main_log().ERROR_STATE)
def update(self):
# Event handling
for e in self.events:
if e.type == events.ADD_ENEMY:
self.add_enemy()
if self.player.alive():
# Phase handling
self.update_phase()
# Collision handling
enemy: Enemy = spritecollideany(self.player, self.enemies, box_collide)
if enemy:
self.player_collide(enemy)
else:
if self.cursor.selected is not None:
if self.cursor.selected == 0:
self.restart()
elif self.cursor.selected == 1:
self.exit(1)
def moveUnit(unit, tryTurns):
for dist in range(Ship.VELOCITY, 0, -1):
for turn in tryTurns:
unit.tryMove(dist, turn)
collidePlanet = sp.spritecollideany(
unit, planets, sp.collide_circle)
if collidePlanet is unit.destPlanet:
unit.destPlanet.arrival(self.team)
unit.kill()
return
else:
pass
# moveUnit(unit, filtertryTurns)
# return
if (len(
sp.spritecollide(unit, ships, False,
Ship.collidedShip)) == 1
and not collidePlanet):
unit.doMove()
return
else:
unit.unTryMove()
def death(self):
self.scores -= 20
self.lives -= 1
if self.lives == 0:
self.the_end()
return
self.begin[0] = 0
self.begin[1] = 0
self.max_bombs = 1
self.strength = 1
self.hero = Player(self.start_pos[0], self.start_pos[1], 1, 1,
self.begin,
len(self.board[0]) * 40,
len(self.board) * 40)
timer = Clock()
for i in range(20):
timer.tick(50)
while spritecollideany(self.hero, self.mobs):
for m in self.mobs:
m.strategy()
m.update(self.screen, self.sprites)
update()
def move(self):
if self.timer - self.last_timer >= 5:
self.vy += self.ay
self.last_timer = self.timer
if not self.rl:
self.rect.x += int(self.vx)
else:
self.rect.x -= int(self.vx)
self.rect.y += int(self.vy)
if sprite.spritecollideany(self, self.wall_sprites):
self.vy = -self.vy // 2
self.rect.y += int(self.vy)
self.vx -= self.ax
if self.vx <= 0.5:
self.stay = True
self.last_timer = self.timer
cords = self.rect.center
self.image = self.boom
self.rect = self.image.get_rect()
self.rect.center = cords
if self.rect.bottom <= 0:
self.kill()
def check_events(settings, play_button, dino, cacti):
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_q:
reset(settings, dino)
cacti.empty()
elif event.key == pygame.K_SPACE:
if not settings.play:
settings.play = True
else:
dino.jump()
# Shoots fireball if 1 is available
elif event.key == pygame.K_f and settings.fireball_count > 0:
dino.set_fireball()
settings.fireball = True
settings.fireball_count = settings.fireball_count - 1
elif event.type == pygame.MOUSEBUTTONDOWN:
mouse_x, mouse_y = pygame.mouse.get_pos()
if play_button.rect.collidepoint(mouse_x, mouse_y):
dino.frame = 1 # Makes dino not stand
settings.play = True
# Resets game if collide
if spritecollideany(dino, cacti):
reset(settings, dino)
cacti.empty()
# Every 10 scored gives 1 fireball
if settings.score % 10 == 0 and settings.score > 9:
settings.fireball_count = settings.fireball_count + 1
def update(self, newTime):
self.surf2.fill((0, 0, 0))
self.surf2.set_alpha(self.alpha)
if self.alpha > 0:
self.alpha -= 5
self.time = self.time + newTime
self.currTime = time.time() # Current time
self.elapsedTime = int(self.currTime - self.startTime) # elapsed time
self.score = LOSE_TIME - self.elapsedTime
Globals.HUD.updateTime(self.score)
if not self.elapsedTime == self.lastTime:
self.surf = Globals.FONT.render(str(self.score), True, (0, 0, 0))
self.lastTime = self.elapsedTime
if self.elapsedTime > LOSE_TIME:
Globals.SCREEN.fill(Setup.BLACK)
Globals.STATE = LoseScreen.LoseScreen(self.score)
if self.time > self.CYCLE:
self.time = 0.0
if self.time < 0.33:
image_counter = 0
elif self.time < 0.66:
image_counter = 1
else:
image_counter = 2
Globals.WORLD.background(Globals.SCREEN)
Globals.WORLD.dr(Globals.SCREEN)
Globals.WORLD.update(self.hero)
# self.group.draw(Globals.SCREEN)
#Globals.SCREEN.blit(self.surf, (500, 100)) # Drawing clock
#Globals.SCREEN.blit(self.surf2, (0, 0))
playerX = self.hero.rect.centerx
playerY = self.hero.rect.centery
key = PG.key.get_pressed()
for event in PE.get():
if event.type == PG.QUIT:
Globals.RUNNING = False
if key[PG.K_ESCAPE]:
Globals.RUNNING = False
if key[PG.K_w]:
self.hero.speed = 8.0
elif not key[PG.K_w]:
self.hero.speed = 3.0
# Sword Logic
if key[PG.K_e] and not Player.events[4]:
if self.currTime - self.sword_timer >= 1:
self.hero.attacking = True
self.sword_timer = self.currTime
# else:
# self.sword_timer += 0.1
elif not key[PG.K_e]:
self.hero.attacking = False
# self.sword_timer = 0
# Projectile Logic
if key[PG.K_r]:
if (self.currTime - self.projectile_timer) >= 2:
temp = self.hero.shoot_projectile(Globals.STATE.heroProjectileGroup)
Globals.WORLD.addEntity(temp)
self.projectile_timer = self.currTime
Globals.HUD.updateCooldown()
if key[PG.K_DOWN] and not key[PG.K_LEFT] \
and not key[PG.K_RIGHT] and not key[PG.K_UP]:
self.hero.movedown(image_counter)
elif key[PG.K_LEFT] and not key[PG.K_RIGHT] \
and not key[PG.K_UP] and not key[PG.K_DOWN]:
self.hero.moveleft(image_counter)
elif key[PG.K_RIGHT] and not key[PG.K_UP] \
and not key[PG.K_LEFT] and not key[PG.K_DOWN]:
self.hero.moveright(image_counter)
elif key[PG.K_UP] and not key[PG.K_RIGHT] \
and not key[PG.K_LEFT] and not key[PG.K_DOWN]:
self.hero.moveup(image_counter)
else:
self.hero.moveidle(image_counter)
# joystick controls
'''
if PJ.get_count() > 0:
if joystick.get_axis(2) > 0.1:
self.hero.speed = 8.0
# Sword Logic
if joystick.get_button(2) and not Player.events[4]:
if self.currTime - self.sword_timer >= 1:
self.hero.attacking = True
self.sword_timer = self.currTime
#else:
#self.sword_timer += 0.1
elif not key[PG.K_e]:
self.hero.attacking = False
#self.sword_timer = 0
# Projectile Logic
if joystick.get_button(1):
if (self.currTime - self.projectile_timer) >= 2:
temp = self.hero.shoot_projectile(Globals.STATE.heroProjectileGroup)
Globals.WORLD.addEntity(temp)
self.projectile_timer = self.currTime
Globals.HUD.updateCooldown()
if joystick.get_axis(1) > 0.1:
self.hero.movedown(image_counter)
elif joystick.get_axis(0) < -0.1:
self.hero.moveleft(image_counter)
elif joystick.get_axis(0) > 0.1:
self.hero.moveright(image_counter)
elif joystick.get_axis(1) < -0.1:
self.hero.moveup(image_counter)
else:
self.hero.moveidle(image_counter)
'''
playerX = self.hero.rect.centerx
playerY = self.hero.rect.centery
self.allEnemies.add(self.enemyGroup)
self.allEnemies.add(self.optionalGroup)
self.heroGroup.update(self.allEnemies, self.wagonGroup, smooth.wallMap[playerX/(Setup.GRID_SIZE * Setup.PIXEL_SIZE), playerY/(Setup.GRID_SIZE*Setup.PIXEL_SIZE)], self)
self.allEnemies.update(smooth.wallMap[playerX/(Setup.GRID_SIZE * Setup.PIXEL_SIZE), playerY/(Setup.GRID_SIZE * Setup.PIXEL_SIZE)], self.hero)
self.enemyProjectileGroup.update(self.heroGroup)
if not self.allEnemies:
self.heroProjectileGroup.update()
else:
self.heroProjectileGroup.update(self.allEnemies)
self.heroSword.update(self.hero, self.allEnemies)
# Direction changes
for wagon in self.wagonGroup:
if wagon.rect.centerx == 26 * Setup.PIXEL_SIZE and wagon.rect.centery == 11 * Setup.PIXEL_SIZE:
wagon.direction = 0
elif wagon.rect.centerx == 26 * Setup.PIXEL_SIZE and wagon.rect.centery == 30 * Setup.PIXEL_SIZE:
wagon.direction = 2
elif wagon.rect.centerx == 106 * Setup.PIXEL_SIZE and wagon.rect.centery == 30 * Setup.PIXEL_SIZE:
wagon.direction = 3
elif wagon.rect.centerx == 106 * Setup.PIXEL_SIZE and wagon.rect.centery == 21 * Setup.PIXEL_SIZE:
wagon.direction = 2
# First stall position for caravan
if self.w1.rect.centerx == 50 * Setup.PIXEL_SIZE and not LevelThree.phase[0]:
LevelThree.phase[0] = True
for wagon in self.wagonGroup:
wagon.isBroken = True
# Second stall position for caravan
if self.w1.rect.centerx == 90 * Setup.PIXEL_SIZE and not LevelThree.phase[1]:
LevelThree.phase[1] = True
for wagon in self.wagonGroup:
wagon.isBroken = True
# Third stall position for caravan
if self.w1.rect.centerx == 120 * Setup.PIXEL_SIZE and not LevelThree.phase[2]:
LevelThree.phase[2] = True
for wagon in self.wagonGroup:
wagon.isBroken = True
# Create First wave of enemies
if self.w1.rect.centerx == 40 * Setup.PIXEL_SIZE and not LevelThree.phase[0]:
# Add enemies
enemy = Enemy.Enemy(57 * Setup.PIXEL_SIZE, 30 * Setup.PIXEL_SIZE, True, 0, 2)
self.enemyGroup.add(enemy)
Globals.WORLD.addEntity(enemy)
enemy = Enemy.Enemy(59 * Setup.PIXEL_SIZE, 30 * Setup.PIXEL_SIZE, True, 1, 1)
self.enemyGroup.add(enemy)
Globals.WORLD.addEntity(enemy)
enemy = Enemy.Enemy(58 * Setup.PIXEL_SIZE, 32 * Setup.PIXEL_SIZE, True, 0, 2)
self.enemyGroup.add(enemy)
Globals.WORLD.addEntity(enemy)
enemy = Enemy.Enemy(59 * Setup.PIXEL_SIZE, 33 * Setup.PIXEL_SIZE, True, 1, 2)
self.enemyGroup.add(enemy)
Globals.WORLD.addEntity(enemy)
enemy = Enemy.Enemy(59 * Setup.PIXEL_SIZE, 34 * Setup.PIXEL_SIZE, True, 0, 1)
self.enemyGroup.add(enemy)
Globals.WORLD.addEntity(enemy)
# Create Second wave of enemies
if self.w1.rect.centerx == 80 * Setup.PIXEL_SIZE and not LevelThree.phase[1]:
# Add enemies
enemy = Enemy.Enemy(98 * Setup.PIXEL_SIZE, 30 * Setup.PIXEL_SIZE, True, 1, 2)
self.enemyGroup.add(enemy)
Globals.WORLD.addEntity(enemy)
enemy = Enemy.Enemy(95 * Setup.PIXEL_SIZE, 30 * Setup.PIXEL_SIZE, True, 1, 1)
self.enemyGroup.add(enemy)
Globals.WORLD.addEntity(enemy)
enemy = Enemy.Enemy(100 * Setup.PIXEL_SIZE, 32 * Setup.PIXEL_SIZE, True, 0, 1)
self.enemyGroup.add(enemy)
Globals.WORLD.addEntity(enemy)
enemy = Enemy.Enemy(99 * Setup.PIXEL_SIZE, 33 * Setup.PIXEL_SIZE, True, 1, 1)
self.enemyGroup.add(enemy)
Globals.WORLD.addEntity(enemy)
enemy = Enemy.Enemy(98 * Setup.PIXEL_SIZE, 34 * Setup.PIXEL_SIZE, True, 0, 1)
self.enemyGroup.add(enemy)
Globals.WORLD.addEntity(enemy)
# Create Third wave of enemies
if self.w1.rect.centerx == 110 * Setup.PIXEL_SIZE and not LevelThree.phase[2]:
# Add enemies
enemy = Enemy.Enemy(127 * Setup.PIXEL_SIZE, 22 * Setup.PIXEL_SIZE, True, 1, 2)
self.enemyGroup.add(enemy)
Globals.WORLD.addEntity(enemy)
enemy = Enemy.Enemy(129 * Setup.PIXEL_SIZE, 22 * Setup.PIXEL_SIZE, True, 1, 1)
self.enemyGroup.add(enemy)
Globals.WORLD.addEntity(enemy)
enemy = Enemy.Enemy(128 * Setup.PIXEL_SIZE, 20 * Setup.PIXEL_SIZE, True, 1, 1)
self.enemyGroup.add(enemy)
Globals.WORLD.addEntity(enemy)
enemy = Enemy.Enemy(129 * Setup.PIXEL_SIZE, 22 * Setup.PIXEL_SIZE, True, 0, 2)
self.enemyGroup.add(enemy)
Globals.WORLD.addEntity(enemy)
enemy = Enemy.Enemy(128 * Setup.PIXEL_SIZE, 20 * Setup.PIXEL_SIZE, True, 0, 1)
self.enemyGroup.add(enemy)
Globals.WORLD.addEntity(enemy)
if LevelThree.phase[0] == True and LevelThree.phase[1] == False:
# First stop
if self.enemyGroup:
# While enemies are still alive
pass
else:
for wagon in self.wagonGroup:
wagon.isBroken = False
if LevelThree.phase[1] == True and LevelThree.phase[2] == False:
# Second stop
if self.enemyGroup:
# While enemies are still alive
pass
else:
for wagon in self.wagonGroup:
wagon.isBroken = False
if LevelThree.phase[2] == True and LevelThree.phase[3] == False:
# Third stop
if self.enemyGroup:
# While enemies are still alive
pass
else:
for wagon in self.wagonGroup:
wagon.isBroken = False
LevelThree.phase[3] = True # Allowed to proceed to final level
if LevelThree.phase[3] == True:
if playerX >= 133 * Setup.PIXEL_SIZE:
if playerY > 19 * Setup.PIXEL_SIZE and playerY < 25 * Setup.PIXEL_SIZE:
# TODO: Implement cutscene then go to level 4
Player.events[8] = False
Globals.STATE = LevelThreeCut()
if PS.spritecollideany(self.hero, self.wagonGroup) == None:
self.wagonGroup.update()
if self.hero.health <= 0:
Globals.STATE = LoseScreen.LoseScreen(0)
def test_spritecollideany__with_collided_callback(self):
# pygame.sprite.spritecollideany(sprite, group) -> sprite
# finds any sprites that collide
# collided is a callback function used to calculate if
# two sprites are colliding. it should take two sprites
# as values, and return a bool value indicating if
# they are colliding.
# This collision test can be faster than pygame.sprite.spritecollide()
# since it has less work to do.
arg_dict_a = {}
arg_dict_b = {}
return_container = [True]
# This function is configurable using the mutable default arguments!
def collided_callback(
spr_a,
spr_b,
arg_dict_a=arg_dict_a,
arg_dict_b=arg_dict_b,
return_container=return_container,
):
count = arg_dict_a.get(spr_a, 0)
arg_dict_a[spr_a] = 1 + count
count = arg_dict_b.get(spr_b, 0)
arg_dict_b[spr_b] = 1 + count
return return_container[0]
# This should return a sprite from self.ag2 because the callback
# function (collided_callback()) currently returns True.
expected_sprite_choices = self.ag2.sprites()
collided_sprite = sprite.spritecollideany(self.s1, self.ag2,
collided_callback)
self.assertIn(collided_sprite, expected_sprite_choices)
# The callback function should have been called only once, so self.s1
# should have only been passed as an argument once
self.assertEqual(len(arg_dict_a), 1)
self.assertEqual(arg_dict_a[self.s1], 1)
# The callback function should have been called only once, so self.s2
# exclusive-or self.s3 should have only been passed as an argument
# once
self.assertEqual(len(arg_dict_b), 1)
self.assertEqual(list(arg_dict_b.values())[0], 1)
self.assertTrue(self.s2 in arg_dict_b or self.s3 in arg_dict_b)
arg_dict_a.clear()
arg_dict_b.clear()
return_container[0] = False
# This should return None because the callback function
# (collided_callback()) currently returns False.
collided_sprite = sprite.spritecollideany(self.s1, self.ag2,
collided_callback)
self.assertIsNone(collided_sprite)
# The callback function should have been called as many times as
# there are sprites in self.ag2
self.assertEqual(len(arg_dict_a), 1)
self.assertEqual(arg_dict_a[self.s1], len(self.ag2))
self.assertEqual(len(arg_dict_b), len(self.ag2))
# Each sprite in self.ag2 should be called once.
for s in self.ag2:
self.assertEqual(arg_dict_b[s], 1)
def update(self, time):
self.l_interval = self.l_interval + .01
if self.l_interval >= 4 * math.pi:
self.l_interval = 0.0
self.time += time
while self.time > G.Globals.INTERVAL:
self.time -= G.Globals.INTERVAL
curr_enemies = PS.Group()
for i, e in enumerate(self.enemies.sprites()):
dead, bull = e.update(G.Globals.INTERVAL, self.player,
self.map, self.enemies.sprites(), i)
if dead:
self.enemies.remove(e)
if self.map.boss_coord is not None:
Game.SCORE += 500
G.new_level(self.player)
return
elif not (e.rect.x < - e.rect.width or e.rect.x > G.Globals.WIDTH + e.rect.width \
or e.rect.y < -e.rect.height or e.rect.y > G.Globals.HEIGHT + e.rect.height):
curr_enemies.add(e)
if bull is not None:
self.e_bullets.add(bull)
for b in self.bullets.sprites():
if b.update(G.Globals.INTERVAL):
self.bullets.remove(b)
for b in self.e_bullets.sprites():
if b.update(G.Globals.INTERVAL):
self.e_bullets.remove(b)
for blood in self.blood:
blood.update(G.Globals.INTERVAL)
if blood.gone:
self.blood.remove(blood)
for stain in self.blood_stains:
stain.update()
for heart in self.hearts_group.sprites():
heart.update()
self.player.update(G.Globals.INTERVAL)
self.set_screen_cords_player()
#self.collision(curr_enemies, self.bullets, self.e_bullets, self.player_group, self.wall_sprites_list)
# Are there collisions
# Player Collision with walls
result = PS.groupcollide(self.player_group, self.wall_sprites_list,
False, False)
for key in result:
for wall in result[key]:
if self.player.rect.colliderect(wall.rect):
val = self.player.wall_collision(wall, self.map)
self.set_screen_cords_player()
if val == 1:
self.wall_sprites_list.remove(wall)
if val == 2:
Game.SCORE += 100
G.new_level(self.player)
# Player collision with enemies
result = PS.groupcollide(self.player_group, curr_enemies,
False, False)
for key in result:
for enemy in result[key]:
if enemy.dying is False and self.player.take_damage(1):
G.Globals.STATE = GameOver.GameOver(False, Game.SCORE)
# Player collision with enemy bullets
result = PS.groupcollide(self.player_group, self.e_bullets, False,
False)
for player in result:
if self.player.take_damage(1):
G.Globals.STATE = GameOver.GameOver(False, Game.SCORE)
blood_x = player.world_coord_x + Player.Player.WIDTH / 2
blood_y = player.world_coord_y + Player.Player.HEIGHT / 2
self.blood.append(Blood.Blood(blood_x,
blood_y, .8))
p_width = Player.Player.WIDTH
p_height = Player.Player.HEIGHT
self.blood_stains.append(BloodStain.BloodStain(blood_x,
blood_y,
p_width,
p_height))
for bullet in result[player]:
self.e_bullets.remove(bullet)
# Enemy Collision with Bullets
result = PS.groupcollide(curr_enemies, self.bullets, False, False)
for enemy in result:
if enemy.dying is True:
continue
if self.double_kill is False:
self.double_kill = True
self.double_kill_timer = 0
self.last_killed = enemy
if self.double_kill_timer < Game.DOUBLE_KILL_TIME and self.double_kill \
and self.last_killed is not enemy:
#Game.DOUBLE_KILL_SOUND.play()
self.double_kill = False
enemy.start_death()
blood_x = int(enemy.world_x + enemy.width / 2)
blood_y = int(enemy.world_y + enemy.height / 2)
self.blood.append(Blood.Blood(blood_x,
blood_y, .8))
self.blood_stains.append(BloodStain.BloodStain(blood_x,
blood_y,
enemy.width,
enemy.height))
Game.SCORE = Game.SCORE + 10
for bullet in result[enemy]:
if self.player.piercing is False and bullet.__class__.__name__ is not "Laser":
self.bullets.remove(bullet)
if random.random() < Game.HEALTH_DROP_RATE:
self.hearts_group.add(Heart.Heart(enemy.world_x,
enemy.world_y))
# Bullets Collide with Wall
result = PS.groupcollide(
self.bullets, self.wall_sprites_list, False, False)
for bullet in result:
if bullet.__class__.__name__ is not "Laser":
self.bullets.remove(bullet)
# Enemy Bullets Collide with Wall
result = PS.groupcollide(
self.e_bullets, self.wall_sprites_list, False, False)
for bullet in result:
self.e_bullets.remove(bullet)
# Player picking up hearts
if self.player.health < self.player.max_health:
heart = PS.spritecollideany(self.player, self.hearts_group)
if heart is not None:
self.hearts_group.remove(heart)
self.player.health += 1
if self.player.health > self.player.max_health:
self.player.health = self.player.max_health
if self.double_kill:
self.double_kill_timer += time
if self.double_kill_timer > Game.DOUBLE_KILL_TIME:
self.double_kill = False
def test_spritecollideany__with_collided_callback(self):
# pygame.sprite.spritecollideany(sprite, group) -> sprite
# finds any sprites that collide
# collided is a callback function used to calculate if
# two sprites are colliding. it should take two sprites
# as values, and return a bool value indicating if
# they are colliding.
# This collision test can be faster than pygame.sprite.spritecollide()
# since it has less work to do.
arg_dict_a = {}
arg_dict_b = {}
return_container = [True]
# This function is configurable using the mutable default arguments!
def collided_callback(spr_a, spr_b,
arg_dict_a=arg_dict_a, arg_dict_b=arg_dict_b,
return_container=return_container):
count = arg_dict_a.get(spr_a, 0)
arg_dict_a[spr_a] = 1 + count
count = arg_dict_b.get(spr_b, 0)
arg_dict_b[spr_b] = 1 + count
return return_container[0]
# This should return True because return_container[0] is True
self.assert_(
sprite.spritecollideany(self.s1, self.ag2, collided_callback)
)
# The callback function should have been called only once, so self.s1
# should have only been passed as an argument once
self.assert_(len(arg_dict_a) == 1 and arg_dict_a[self.s1] == 1)
# The callback function should have been called only once, so self.s2
# exclusive-or self.s3 should have only been passed as an argument
# once
self.assert_(
len(arg_dict_b) == 1 and list(arg_dict_b.values())[0] == 1 and
(self.s2 in arg_dict_b or self.s3 in arg_dict_b)
)
arg_dict_a.clear()
arg_dict_b.clear()
return_container[0] = False
# This should return False because return_container[0] is False
self.assertFalse(
sprite.spritecollideany(self.s1, self.ag2, collided_callback)
)
# The callback function should have been called as many times as
# there are sprites in self.ag2
self.assert_(len(arg_dict_a) == 1 and arg_dict_a[self.s1] == 2)
# The callback function should have been twice because self.s2 and
# self.s3 should have been passed once each
self.assert_(
len(arg_dict_b) == 2 and
arg_dict_b[self.s2] == 1 and arg_dict_b[self.s3] == 1
)
)
if sprite.collide_mask(new_wall, irobot) is None:
new_wall.render(background)
walls.add(new_wall)
else:
print("Error while adding new wall")
# Move irobot
if event.button == 3 and not started:
mouse_pos = pygame.mouse.get_pos()
posx = mouse_pos[0] - irobot.rect[0] - irobot.rect[2] / 2
posy = mouse_pos[1] - irobot.rect[1] - irobot.rect[3] / 2
old_rect = irobot.rect
irobot.rect = irobot.rect.move(posx, posy)
if sprite.spritecollideany(irobot, walls,
sprite.collide_mask):
irobot.rect = old_rect
print("Error while move irobot")
if started:
if state == STATE_ROTATE:
if irobot.deg <= irobot.to_deg:
irobot.rotate(2)
else:
irobot.compute_speed()
state = STATE_MOVE
if state == STATE_MOVE:
if irobot.can_move_forward():
start_pos = irobot.rect.center
irobot.move_forward()
