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 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()