def explode (self, villian): centerX, centerY = villian.getCenter() self.villianList.remove(villian) villian.kill() if (self.sound_on): Sounds().Explode() self.explosionList.append(Explosion.Explosion(self._containers, self._screen, numpy.array([centerX, centerY])))
def grooveModeTimerFired(dt, data):
moveBackground(data)
data.explosions.update()
if time.time() - data.playStartTime > data.songGameOffset:
# since there is some overlap between frames of video and chunks of
# audio, only add a new obstacle if the chunk of audio has moved \
# forward and there is a beat
data.lastIndex = data.curIndex
data.curIndex = data.song.getCurrentIndex(
pygame.mixer.music.get_pos() + data.songGameOffset * 1000)
if data.curIndex > data.lastIndex:
beats = data.song.isBeat(data.curIndex)
# add an obstacle to course
# use mid range frequencies
if beats[3] or beats[4] or beats[5]:
if data.lastLane == 0:
lane = np.random.randint(0, data.lanes - 1)
elif data.lastLane == 1:
lane = np.random.randint(0, data.lanes)
elif data.lastLane == 2:
lane = np.random.randint(1, data.lanes)
data.obstacles.add(Obstacle.Obstacle(lane, data))
data.lastLane = lane
# check collisions
for player in pygame.sprite.groupcollide(data.players, data.obstacles,
False, True):
player.turnOn()
data.explosions.add(Explosion(player.x, player.y))
# data.score += 1
data.score.update()
#update sprites
for player in data.players:
player.updateTimer()
data.obstacles.update(data)
def on_tile_collide(self, tile,entities, **kwargs):
self.x_velocity = 0
self.y_velocity = 0
self.exploding = True
explosion = Explosion(pygame.Rect(self.rect.topleft,(128,128)))
explosion.rect.center = self.rect.center
entities.append(explosion)
for g in self.groups():
g.remove(self)
def make_enemies(self):
laser = sprite.groupcollide(self.bullets, self.mysteryGroup, True,
True)
if laser:
for value in mysterydict.values():
for currentSprite in value:
currentSprite.mysteryEntered.stop()
self.sounds['mysterykilled'].play()
score = self.calculate_score(currentSprite.row)
explosion = Explosion(currentSprite.rect.x,
currentSprite.rect.y,
currentSprite.row, False, True,
score, self)
self.explosionsGroup.add(explosion)
self.allSprites.remove(currentSprite)
self.laserGroup.remove(currentSprite)
newShip = Highlaser(game, self.player.rect.x,
self.player.rect.x)
self.allSprites.add(newShip)
self.laserGroup.add(newShip)
break
print self.boss
if self.boss % 2 == 1:
self.mobs_shape = 'BOSS'
enemies = EnemiesGroup(10, 5, 'BOSS')
for row in range(5):
for column in range(10):
enemy = Enemy(row, column, self)
enemy.rect.x = 157 + (column * 1)
enemy.rect.y = self.enemyPosition + (row * 1)
enemies.add(enemy)
else:
mobs_grp_choice = randint(0, 1)
if mobs_grp_choice == 0:
self.mobs_shape = 'EXPLODED'
enemies = EnemiesGroup(10, 5, 'EXPLODED')
for row in range(5):
for column in range(10):
enemy = Enemy(row, column, self)
enemy.rect.x = randint(0, 750)
enemy.rect.y = randint(100, 400)
enemies.add(enemy)
else:
self.mobs_shape = 'GROUP'
enemies = EnemiesGroup(10, 5, 'GROUP')
for row in range(5):
for column in range(10):
enemy = Enemy(row, column, self)
enemy.rect.x = 157 + (column * 50)
enemy.rect.y = self.enemyPosition + (row * 45)
enemies.add(enemy)
self.enemies = enemies
self.allSprites = sprite.Group(self.player, self.enemies,
self.livesGroup, self.mysteryShip,
self.highlaser)
def rhythmModeDrumHit(data, players, obstacles):
collision = pygame.sprite.groupcollide(players, obstacles, False, True)
for player in players:
player.turnOn()
if player not in collision:
data.score.breakStreak()
for player in collision:
data.explosions.add(Explosion(player.x, player.y))
data.score.update()
def explode(self, friend):
centerX, centerY = friend.getCenter()
self.friendList.remove(friend)
friend.kill()
self.explosionList.append(
Explosion.Explosion(self._containers,
self._screen,
numpy.array([centerX, centerY]),
imageFile='star.png'))
Sounds().SmallExplode()
def explode(self, boss):
centerX, centerY = boss.getCenter()
self.bossList.remove(boss)
boss.kill()
if (self.sound_on):
Sounds().Explode()
self.explosionList.append(
Explosion.Explosion(self._containers,
self._screen,
numpy.array([centerX, centerY]),
explosionType='boss'))
def explosivifySprite(
self,
sprite_rect,
explosionCount=4
): #Explode around a sprite, optional explosions count
for i in range(0, explosionCount):
x_pos = sprite_rect.x - int(.4 * sprite_rect.width)
y_pos = sprite_rect.y - int(.4 * sprite_rect.height)
offset_x = random.randint(
0, sprite_rect.width + int(.4 * sprite_rect.width))
offset_y = random.randint(0, sprite_rect.height + int(
.4 * sprite_rect.height)) #40% increased explosion radius >:)
self.explosion_sprites.add(
Explosion(x_pos + offset_x, y_pos + offset_y))
def explode(self, objects):
# Explode bomb, draw the stain on the background
self.exploded = True
self.anim = Explosion(0, (self.x, self.y), self.sounds[0],
self.textures[1])
self.parent.backdrop.blit(
self.textures[2].subsurface(192 * randint(0, 1),
128 * randint(0, 1), 192, 128),
((GRIDX + GRATIO * self.x) - 128, (GRIDY + GRATIO * self.y) - 32))
for ob in objects:
if sqrt((ob.x - self.x)**2 + (ob.y - self.y)**2) < 2:
# Try to hur the enemy, if its not an entity, destroy it
try:
ob.destroy()
except:
ob.hurt(8)
def update(self):
super(NormalBall, self).update()
# Testing if it's time to explode/Exploding
if (self.state == 1 and self.timeOfImpact and time.time() >
self.timeOfImpact + 0.8 + self.randomExplosionDelay):
self.state = 2
# Creating explosion
self.gameObjects.addEntity(
Explosion.Explosion(self.fileManager, self.scale,
self.rect.center))
# Playing sound
self.fileManager.playBallExplode('NormalBall')
# Updating explosion
if self.state == 2:
self.__exploding()
def run_logic(self):
if not self.game_over and not self.end:
# Move all the sprites
self.all_sprites_list.update()
# For each bonus alien if alien.x > screen.width + 10 remove alien
for bonus_alien in self.alien_list:
if bonus_alien.rect.x > SCREEN_WIDTH + 10:
self.alien_list.remove(bonus_alien)
self.all_sprites_list.remove(bonus_alien)
# Have the aliens drop bombs
for alien in self.alien_list:
rand = random.randrange(200)
if (rand < 2):
if (alien.bombing == False and alien.bombs > 0):
bomb = Bomb()
alien.bombing = True
alien.bombs -= 1
bomb.rect.x = alien.rect.x + 18
bomb.rect.y = alien.rect.y
# Add the bomb to the lists
self.all_sprites_list.add(bomb)
self.bomb_list.add(bomb)
# Calculate mechanics for each bullet
for bullet in self.bullet_list:
# See if it hit an alien or wall
alien_hit_list = pygame.sprite.spritecollide(
bullet, self.alien_list, False) # Changed to False
wall_hit_list = pygame.sprite.spritecollide(
bullet, self.wall_list, True)
# For each alien hit, remove the bullet and add to the score
for alien in alien_hit_list:
alien.hitpoints -= 1
if alien.hitpoints <= alien.start_hitpoints / 2:
alien.not_damaged = False
if alien.hitpoints < 1:
if alien.bonus_points > 0:
Game.score += alien.bonus_points
else:
Game.score += alien.start_hitpoints * 10
# Every 1000 points player gets a new life
if Game.score > 0 and Game.score % 100 == 0:
Game.lives += 1
self.life.play()
alien_hit_list.remove(alien)
self.alien_list.remove(alien)
self.all_sprites_list.remove(alien)
self.ping.play()
print(Game.score)
self.explosion.play()
explode = Explosion()
explode.rect.x = alien.rect.x
explode.rect.y = alien.rect.y
self.all_sprites_list.add(explode)
self.explosion_list.add(explode)
self.bullet_list.remove(bullet)
self.all_sprites_list.remove(bullet)
# Kill bullet object if it flies up off the screen
if bullet.rect.y < -10:
self.bullet_list.remove(bullet)
self.all_sprites_list.remove(bullet)
# Remove wall pieces if they have been hit
for wall in wall_hit_list:
self.explosion.play()
self.bullet_list.remove(bullet)
self.all_sprites_list.remove(bullet)
# Remove explosion objects after they have exploded
for exp in self.explosion_list:
if exp.finished:
self.explosion_list.remove(exp)
self.all_sprites_list.remove(exp)
# Update game for each bomb dropped
for bomb in self.bomb_list:
wall_hit_list = pygame.sprite.spritecollide(
bomb, self.wall_list, True)
bomb_hit_list = pygame.sprite.spritecollide(
self.player, self.bomb_list, False)
# Play explosion sound and remove bombs that hit the wall
for wall in wall_hit_list:
self.explosion.play()
self.bomb_list.remove(bomb)
self.all_sprites_list.remove(bomb)
# Play hit sound and rove bomb that have hit player
# Reduce player lives and end game if they have no lives
for b in bomb_hit_list:
self.bomb_list.remove(b)
self.all_sprites_list.remove(b)
self.hit.play()
Game.lives -= 1
print("Lives = " + str(Game.lives))
if Game.lives == 0:
self.end = True
# Remove alien bombs from game that have droped below screen
if bomb.rect.y > SCREEN_HEIGHT:
self.bomb_list.remove(bomb)
self.all_sprites_list.remove(bomb)
# See if the self.player alien has collided with anything.
aliens_hit_list = pygame.sprite.spritecollide(
self.player, self.alien_list, False)
# Check the list of collisions.
for alien in aliens_hit_list:
alien.change_y *= -1
alien.change_x *= -1
print("Collided with Alien")
# If alien hits wall play explsion, remove wall piece
for wall in self.wall_list:
alien_hit_list = pygame.sprite.spritecollide(
wall, self.alien_list, True)
for alien in alien_hit_list:
self.explosion.play()
self.wall_list.remove(wall)
self.all_sprites_list.remove(wall)
print("Alien Hit Wall")
# Check to see if the game is over
if len(self.alien_list) == 0:
self.game_over = True
Game.level_number += 1
def cleanWindow(self):
self.screen.blit(self.background, (0, 0))
if __name__ == '__main__':
game = PulseGame()
# Game loop
while True:
# 60Hz framerate
game.clock.tick(60)
game.render()
for event in pygame.event.get():
if event.type == QUIT:
sys.exit()
elif event.type == MOUSEBUTTONDOWN and event.button == 1:
if game.gameRunning:
# Only creating a pulse when the number of pulses left i sufficient
if game.levelManager.pulses > 0:
# Creating explosion
game.gameObjects.addEntity(
Explosion.Explosion(
game.fileManager,
game.levelManager.currentLevel().scale,
pygame.mouse.get_pos()))
game.gameObjects.updateNotifierPulses(-1)
game.fileManager.playPulse()
else:
# Checking menu mouse over (gameRunning False means menu!)
game.menues.mouseClicked(pygame.mouse.get_pos())
# required because their are two types of spirals implemented
if pattern == 'spiral':
if np.random.choice([0, 1]):
pattern = 'archimedean'
else:
pattern = 'golden'
random_parameters = parameters.choose_random(pattern)
if pattern == 'golden': # golden spiral
shape = Spiral.Golden(WIDTH, HEIGHT, *random_parameters)
elif pattern == 'archimedean': # archimedean spiral
shape = Spiral.Archimedean(WIDTH, HEIGHT, *random_parameters)
elif pattern == 'explosion': # explosion
shape = Explosion.Explosion(WIDTH, HEIGHT, *random_parameters)
elif pattern == 'tile': # tile
shape = Tile.Tile(WIDTH, HEIGHT, *random_parameters)
elif pattern == 'branch': # branch
shape = Branch.Branch(WIDTH, HEIGHT, *random_parameters)
shape.filepath = f'{PATH_TO_IMAGE_FOLDER}/{shape.label}{idx}.png'
shape.maskpath = f'{PATH_TO_MASKS_FOLDER}/{shape.label}_mask{idx}.png'
# an image must be created before a corresponding mask can be created
shape.create_image()
shape.create_mask(pattern_labels)
if display_images:
img = Image.open(shape.filepath)
def lanzarExplosion(self, pos, tamano):
explosion = Explosion(pos, tamano, 'centro')
self.explosiones.append(explosion)
explosion.crearExplosiones(self.bomberman.tamExplosion,
self.explosiones, self)
def check_collisions(self):
collidedict = sprite.groupcollide(self.bullets, self.enemyBullets,
True, False)
if collidedict:
for value in collidedict.values():
for currentSprite in value:
self.enemyBullets.remove(currentSprite)
self.allSprites.remove(currentSprite)
enemiesdict = sprite.groupcollide(self.bullets, self.enemies, True,
False)
if enemiesdict:
for value in enemiesdict.values():
for currentSprite in value:
self.enemies.kill(currentSprite)
self.sounds['invaderkilled'].play()
score = self.calculate_score(currentSprite.row)
explosion = Explosion(currentSprite.rect.x,
currentSprite.rect.y,
currentSprite.row, False, False,
score, self)
self.explosionsGroup.add(explosion)
self.allSprites.remove(currentSprite)
self.enemies.remove(currentSprite)
self.gameTimer = time.get_ticks()
break
mysterydict = sprite.groupcollide(self.bullets, self.mysteryGroup,
True, True)
if mysterydict:
for value in mysterydict.values():
for currentSprite in value:
currentSprite.mysteryEntered.stop()
self.sounds['mysterykilled'].play()
score = self.calculate_score(currentSprite.row)
explosion = Explosion(currentSprite.rect.x,
currentSprite.rect.y,
currentSprite.row, False, True,
score, self)
self.explosionsGroup.add(explosion)
self.allSprites.remove(currentSprite)
self.mysteryGroup.remove(currentSprite)
newShip = Mystery(self)
self.allSprites.add(newShip)
self.mysteryGroup.add(newShip)
break
bulletsdict = sprite.groupcollide(self.enemyBullets, self.playerGroup,
True, False)
if bulletsdict:
for value in bulletsdict.values():
for playerShip in value:
if self.lives == 3:
self.lives -= 1
self.livesGroup.remove(self.life3)
self.allSprites.remove(self.life3)
elif self.lives == 2:
self.lives -= 1
self.livesGroup.remove(self.life2)
self.allSprites.remove(self.life2)
elif self.lives == 1:
self.lives -= 1
self.livesGroup.remove(self.life1)
self.allSprites.remove(self.life1)
elif self.lives == 0:
self.gameOver = True
self.boss = 0
self.startGame = False
self.sounds['shipexplosion'].play()
explosion = Explosion(playerShip.rect.x, playerShip.rect.y,
0, True, False, 0, self)
self.explosionsGroup.add(explosion)
self.allSprites.remove(playerShip)
self.playerGroup.remove(playerShip)
self.makeNewShip = True
self.shipTimer = time.get_ticks()
self.shipAlive = False
if sprite.groupcollide(self.enemies, self.playerGroup, True, True):
self.gameOver = True
self.startGame = False
sprite.groupcollide(self.bullets, self.allBlockers, True, True)
sprite.groupcollide(self.enemyBullets, self.allBlockers, True, True)
sprite.groupcollide(self.enemies, self.allBlockers, False, True)
def addOther(self, xy):
self.other.append(
Explosion(0, xy, self.sounds["explosion"],
self.textures["explosions"]))
def explose(self):
# On enlève 1 bombe au nombre de bombe posée par le personnage
self.perso.nb_bombePosee -=1
# On enlève la bombe de la liste des bombes
self.carte.liste_bombe.remove(self)
# Coordonnées de la bombe
x = self.rect.x
y = self.rect.y
# On affiche l'explosion à la place de la bombe
self.carte.liste_explosion.add(Explosion(self.carte, 'centre', x, y))
explosion_interrompueH = False
explosion_interrompueB = False
explosion_interrompueG = False
explosion_interrompueD = False
# Pour toutes les cases entre la bombe et sa portee maximum dans les 4 directions
for portee in range(1, (self.perso.bombe_portee + 1)):
# Direction : Haut
if not(explosion_interrompueH): # On vérifie si l'explosion de la bombe n'est pas intérompue
# On vérifie si l'explosion est possible
verifExplosion = self.verifierExplosion(self.carte.getCase((x, y-(portee*taille_sprite))))
# Si elle n'est pas possible, l'explosion est intérompue dans cette direction
if not(verifExplosion):
explosion_interrompueH = True
else:
# Si c'est un bloc, l'explosion sera différente que dans le vide
if(verifExplosion == 'bloc'):
self.carte.liste_explosion.add(Explosion(self.carte, 'bloc', x, y-(portee*taille_sprite)))
# l'explosion est intérompue dans cette direction
explosion_interrompueH = True
# Sinon on affiche la bombe
else:
# On vérifie si l'explosion est bout de sa portée
if(portee == self.perso.bombe_portee):
self.carte.liste_explosion.add(Explosion(self.carte, 'verticaleH', x, y-(portee*taille_sprite)))
else:
self.carte.liste_explosion.add(Explosion(self.carte, 'verticale', x, y-(portee*taille_sprite)))
# Direction : Bas
if not(explosion_interrompueB):
verifExplosion = self.verifierExplosion(self.carte.getCase((x, y+(portee*taille_sprite))))
if not(verifExplosion):
explosion_interrompueB = True
else:
if(verifExplosion == 'bloc'):
self.carte.liste_explosion.add(Explosion(self.carte, 'bloc', x, y+(portee*taille_sprite)))
explosion_interrompueB = True
else:
if(portee == self.perso.bombe_portee):
self.carte.liste_explosion.add(Explosion(self.carte, 'verticaleB', x, y+(portee*taille_sprite)))
else:
self.carte.liste_explosion.add(Explosion(self.carte, 'verticale', x, y+(portee*taille_sprite)))
# Direction : Gauche
if not(explosion_interrompueG):
verifExplosion = self.verifierExplosion(self.carte.getCase((x-(portee*taille_sprite), y)))
if not(verifExplosion):
explosion_interrompueG = True
else:
if(verifExplosion == 'bloc'):
self.carte.liste_explosion.add(Explosion(self.carte, 'bloc', x-(portee*taille_sprite), y))
explosion_interrompueG = True
else:
if(portee == self.perso.bombe_portee):
self.carte.liste_explosion.add(Explosion(self.carte, 'horizontaleG', x-(portee*taille_sprite), y))
else:
self.carte.liste_explosion.add(Explosion(self.carte, 'horizontale', x-(portee*taille_sprite), y))
# Direction : Droite
if not(explosion_interrompueD):
verifExplosion = self.verifierExplosion(self.carte.getCase((x+(portee*taille_sprite), y)))
if not(verifExplosion):
explosion_interrompueD = True
else:
if(verifExplosion == 'bloc'):
self.carte.liste_explosion.add(Explosion(self.carte, 'bloc', x+(portee*taille_sprite), y))
explosion_interrompueD = True
else:
if(portee == self.perso.bombe_portee):
self.carte.liste_explosion.add(Explosion(self.carte, 'horizontaleD', x+(portee*taille_sprite), y))
else:
self.carte.liste_explosion.add(Explosion(self.carte, 'horizontale', x+(portee*taille_sprite), y))
# Les bonus touchés par l'explosion disparaissent
bonus_touche = pygame.sprite.groupcollide(self.carte.liste_bonus, self.carte.liste_explosion, False, False)
for bonus in bonus_touche:
bonus.disparaitre()
# Les blocs touchés par l'explosion sont détruient
bloc_touche = pygame.sprite.groupcollide(self.carte.liste_bloc, self.carte.liste_explosion, False, False)
for bloc in bloc_touche:
bloc.detruire()
# Les bombe touchées par l'explosion explosent
bombe_touche = pygame.sprite.groupcollide(self.carte.liste_bombe, self.carte.liste_explosion, False, False)
for bombe in bombe_touche:
bombe.explose()
# Les personnages touchés par l'explosion meurent
perso_touche = pygame.sprite.groupcollide(self.carte.liste_perso, self.carte.liste_explosion, False, False)
for perso in perso_touche:
perso.mourir()
# Les bots touchés par l'explosion meurtent
bot_touche = pygame.sprite.groupcollide(self.carte.liste_bot, self.carte.liste_explosion, False, False)
for bot in bot_touche:
bot.mourir()
