def update(self):
self.running = True
self.player.update()
if self.player.health <= 0:
for entity in self.npcEntities:
self.npcEntities.remove(entity)
self.background.paraX = self.player.xVelocity * Settings.starParallaxX
self.background.paraY = self.player.yVelocity * Settings.starParallaxY
self.background.update()
for entity in self.npcEntities:
if entity.update():
explosion = Explosion(self, entity.xPosition, entity.yPosition)
explosion.sprite = pygame.image.load("../assets/explosion.png")
explosion.setSprite(explosion.sprite)
self.npcEntities.append(explosion)
self.npcEntities.remove(entity)
for entity in self.playerProjectileEntities:
if entity.update():
self.playerProjectileEntities.remove(entity)
for entity in self.npcProjectileEntities:
if entity.update():
self.npcProjectileEntities.remove(entity)
if self.exitTimer < 0 and len(self.npcEntities) == 0:
self.exitTimer = 10
if self.exitTimer > 0:
self.exitTimer -= 1
elif self.exitTimer == 0:
self.running = False
self.exitTimer = -1
return self.running
def hit(self, other):
if str(type(other)).__contains__("Invader"):
Sound.hit()
lives = RunningValues.lives_variable.get()
lives = lives - 1
RunningValues.lives_variable.set(lives)
Explosion.create_explosion(self.canvas, self.x + self.width / 2,
self.y - self.height / 2)
RunningValues.player_dead()
def hit(self, other):
if isinstance(other, PlayerMissile):
Sound.invader()
Invader.alive_invader_count = Invader.alive_invader_count - 1
RunningValues.delete_list.append(self)
if self in RunningValues.render_list:
RunningValues.render_list.remove(self)
self.canvas.delete(self.img1)
self.canvas.delete(self.img2)
score = RunningValues.score_variable.get()
score = score + 1
RunningValues.score_variable.set(score)
Explosion.create_explosion(self.canvas, self.x + self.width / 2,
self.y - self.height / 2)
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 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 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 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 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 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 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 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 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 __init__(self, parent, variant, xy, sounds, textures, explode=False): self.variant = variant self.x = xy[0] self.y = xy[1] self.sounds = sounds self.textures = textures self.parent = parent # So we can stain the room floor if not explode: self.bounds = Rect(GRIDX+GRATIO*self.x,GRIDY+GRATIO*self.y, 32, 64) else: # You cant collide with a bomb that will explode self.bounds = Rect(0,0,0,0) # Should the bomb explode self.shouldExplode = explode self.placed = cTime() self.anim = Animation([textures[0].subsurface(0,0,64,64)], .2)
def __init__(self, parent, variant, xy, sounds, textures, explode=False):
self.variant = variant
self.x = xy[0]
self.y = xy[1]
self.sounds = sounds
self.textures = textures
self.parent = parent # So we can stain the room floor
if not explode:
self.bounds = Rect(GRIDX + GRATIO * self.x,
GRIDY + GRATIO * self.y, 32, 64)
else:
# You cant collide with a bomb that will explode
self.bounds = Rect(0, 0, 0, 0)
# Should the bomb explode
self.shouldExplode = explode
self.placed = cTime()
self.anim = Animation([textures[0].subsurface(0, 0, 64, 64)], .2)
class Bomb(Item):
"""Droppable bomb class"""
collideable = False
pickedUp = False
exploded = False
fuse = 2
def __init__(self, parent, variant, xy, sounds, textures, explode=False):
self.variant = variant
self.x = xy[0]
self.y = xy[1]
self.sounds = sounds
self.textures = textures
self.parent = parent # So we can stain the room floor
if not explode:
self.bounds = Rect(GRIDX + GRATIO * self.x,
GRIDY + GRATIO * self.y, 32, 64)
else:
# You cant collide with a bomb that will explode
self.bounds = Rect(0, 0, 0, 0)
# Should the bomb explode
self.shouldExplode = explode
self.placed = cTime()
self.anim = Animation([textures[0].subsurface(0, 0, 64, 64)], .2)
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 pickup(self):
if not self.shouldExplode:
self.pickedUp = True
def render(self, surface, time, objects, ox=0, oy=0):
if self.pickedUp:
return False
if not self.shouldExplode:
surface.blit(
self.anim.render(time),
((GRIDX + GRATIO * self.x) - self.anim.width // 2 + ox,
(GRIDY + GRATIO * self.y) - self.anim.height // 2 + oy))
return True
if not self.exploded:
# render the normal bomb
frame = self.anim.render(time)
surface.blit(
frame,
((GRIDX + GRATIO * self.x) - self.anim.width // 2 + ox,
(GRIDY + GRATIO * self.y) - self.anim.height // 2 + oy))
if time - self.placed >= self.fuse:
self.explode(objects)
return True
else:
# Render the explosion
return self.anim.render(surface, time)
def lanzarExplosion(self, pos, tamano):
explosion = Explosion(pos, tamano, 'centro')
self.explosiones.append(explosion)
explosion.crearExplosiones(self.bomberman.tamExplosion,
self.explosiones, self)
class Bomb(Item): """Droppable bomb class""" collideable = False pickedUp = False exploded = False fuse = 2 def __init__(self, parent, variant, xy, sounds, textures, explode=False): self.variant = variant self.x = xy[0] self.y = xy[1] self.sounds = sounds self.textures = textures self.parent = parent # So we can stain the room floor if not explode: self.bounds = Rect(GRIDX+GRATIO*self.x,GRIDY+GRATIO*self.y, 32, 64) else: # You cant collide with a bomb that will explode self.bounds = Rect(0,0,0,0) # Should the bomb explode self.shouldExplode = explode self.placed = cTime() self.anim = Animation([textures[0].subsurface(0,0,64,64)], .2) 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 pickup(self): if not self.shouldExplode: self.pickedUp = True def render(self, surface, time, objects, ox=0, oy=0): if self.pickedUp: return False if not self.shouldExplode: surface.blit(self.anim.render(time), ((GRIDX + GRATIO*self.x) - self.anim.width//2+ox, (GRIDY + GRATIO*self.y) - self.anim.height//2+oy)) return True if not self.exploded: # render the normal bomb frame = self.anim.render(time) surface.blit(frame, ((GRIDX + GRATIO*self.x) - self.anim.width//2+ox, (GRIDY + GRATIO*self.y) - self.anim.height//2+oy)) if time-self.placed >= self.fuse: self.explode(objects) return True else: # Render the explosion return self.anim.render(surface, time)
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)
# 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 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()
def game_loop():
new()
# Create game loop conditions and score
running = True
score = 0
count = 0
shadow_score = 0
rocks_condition = True
bullets_exist = False
dialogue = True
music_play = True
stage_1_end = False
explosion_counter = 0
# Play background music
def music_1(condition):
if condition:
pygame.mixer.music.load(
os.path.join(sound_folder, 'Vegas_Loop.wav'))
pygame.mixer.music.set_volume(.5)
pygame.mixer.music.play(-1)
else:
pygame.mixer.music.load(os.path.join(sound_folder,
'Serotonin.wav'))
pygame.mixer.music.set_volume(1)
pygame.mixer.music.play(-1)
# Game Loop
while running:
# Set FPS
dt = clock.tick(FPS) / 1000
mainSurface.blit(background, background_rect)
if music_play and rocks_condition:
music_1(True)
music_play = False
if not music_play and not rocks_condition:
music_1(False)
music_play = True
if score > 1500:
rocks_condition = False
# Events loop
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
if dialogue:
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_RETURN:
dialogue = False
elif event.type == pygame.KEYDOWN and not dialogue:
if event.key == pygame.K_ESCAPE:
# pygame.mixer.music.pause()
menu_resume()
if event.key == pygame.K_SPACE:
shoot_sound.play()
shoot_sound.set_volume(.3)
shoot_player(player)
if event.key == pygame.K_RETURN and dialogue:
dialogue = False
# Control rules for all units movement
for player in units_player:
if not dialogue and not stage_1_end:
Player.player_1.manual_control(player)
for unit in units_rocks:
if not dialogue:
SpaceRock.space_rock1.AI_control(unit)
if not rocks_condition:
for unit in units_mobships:
if not dialogue:
Mobship.mob_ship.AI_control_outside(unit)
for planet in units_planets:
Planet.planet_1.AI_control(planet, shadow_score, count)
count = 0
shadow_score = 0
# Checking if mobs entered the screen and assign new controls and assign bullet
for unit in units_mobships:
if unit.rect.right <= SCREEN_WIDTH or unit.rect.top <= 0:
Mobship.mob_ship.AI_control_inside(unit)
if (unit.rect.left <
SCREEN_WIDTH / 2 + 200) and not bullets_exist:
super_bullet = Bullets.bullet_2(mainSurface,
unit.rect.left,
unit.rect.centery)
shoot_sound_2.play()
shoot_sound_2.set_volume(.2)
units_bullets_mob.add(super_bullet)
units_all.add(super_bullet)
bullets_exist = True
if bullets_exist:
expl_bullet = Explosion.explosion(
mainSurface, super_bullet.rect.left,
super_bullet.rect.centery, 'small')
units_all.add(expl_bullet)
if len(units_bullets_mob) == 0:
bullets_exist = False
# Checking if any rock passed the screen to apply self destruct
for unit in units_rocks:
if unit.rect.right <= 0:
unit.kill()
score += 10
if rocks_condition:
rock = new_rock()
count += 1
if unit.rect.bottom > SCREEN_HEIGHT:
print('check3!')
unit.kill()
if rocks_condition:
rock = new_rock()
# Checking collision between rocks and rocks and initiating speedy rocks
for unit in units_rocks:
units_rocks.remove(unit)
if (collision_check(unit, units_rocks, False,
False)) and unit.rect.x <= SCREEN_WIDTH:
unit.speedx -= 5
explosion_sound.set_volume(.2)
explosion_sound.play()
expl_rock = Explosion.explosion(mainSurface, unit.rect.centerx,
unit.rect.centery, 'large')
units_all.add(expl_rock)
units_rocks.add(unit)
# Checking collision between rocks and bullets
hits_2 = pygame.sprite.groupcollide(units_rocks, units_bullets, True,
True, pygame.sprite.collide_circle)
for hit in hits_2:
if rocks_condition:
new_rock()
score += 10
shadow_score += 10
explosion_sound.set_volume(.2)
explosion_sound.play()
expl_rock = Explosion.explosion(mainSurface, hit.rect.centerx,
hit.rect.centery, 'large')
units_all.add(expl_rock)
# Checking collision between player and rocks
hits_1 = pygame.sprite.groupcollide(units_player, units_rocks, False,
True, pygame.sprite.collide_circle)
for hit in hits_1:
rock = new_rock()
for unit in units_rocks:
damage = unit.hit_damage
player.hp -= damage
explosion_player_sound.play()
expl_player = Explosion.explosion(mainSurface, player.rect.centerx,
player.rect.centery, 'large')
units_all.add(expl_player)
if player.hp <= 0:
player.hide()
player.lives += -1
player.hp = player.full_hp
if player.lives == 0:
running = False
# Check collision between player ship and enemy bullets
if collision_check_groups(units_player, units_bullets_mob, False,
True):
player.hp -= 100
explosion_player_sound.play()
expl_player = Explosion.explosion(mainSurface, player.rect.centerx,
player.rect.centery, 'large')
units_all.add(expl_player)
if player.hp <= 0:
player.hide()
player.lives += -1
player.hp = player.full_hp
if player.lives == 0:
running = False
# Check collision between player bullets and enemy bullets
if collision_check_groups(units_bullets, units_bullets_mob, True,
False):
pass
# Check collision between player bullets and enemy ship
if collision_check_groups(units_mobships, units_bullets, False, True):
for unit in units_mobships:
unit.hp -= 100
expl_mob_ship = Explosion.explosion(mainSurface,
unit.rect.centerx,
unit.rect.centery, 'large')
explosion_sound_2.play()
units_all.add(expl_mob_ship)
print(unit.hp)
if unit.hp <= 0:
stage_1_end = True
# Explosion of boss when dead
if stage_1_end:
for unit in units_bullets_mob:
unit.kill()
for unit in units_bullets:
unit.kill()
if explosion_counter < 5 and stage_1_end:
clock.tick(3)
for unit in units_mobships:
if explosion_counter == 0:
expl_mob_ship = Explosion.explosion(
mainSurface, unit.rect.right, unit.rect.centery,
'small')
units_all.add(expl_mob_ship)
explosion_sound_3.play()
explosion_counter += 1
print('explosion of boss 0')
elif explosion_counter == 1:
expl_mob_ship = Explosion.explosion(
mainSurface, unit.rect.left, unit.rect.centery,
'large')
units_all.add(expl_mob_ship)
explosion_sound_3.play()
explosion_counter += 1
print('explosion of boss 1')
elif explosion_counter == 2:
expl_mob_ship = Explosion.explosion(
mainSurface, unit.rect.right, unit.rect.centery,
'small')
units_all.add(expl_mob_ship)
explosion_sound_3.play()
explosion_counter += 1
elif explosion_counter == 3:
expl_mob_ship = Explosion.explosion(
mainSurface, unit.rect.left, unit.rect.centery,
'large')
units_all.add(expl_mob_ship)
explosion_sound_3.play()
explosion_counter += 1
elif explosion_counter == 4:
expl_mob_ship = Explosion.explosion(
mainSurface, unit.rect.right, unit.rect.centery,
'small')
explosion_sound_3.play()
units_all.add(expl_mob_ship)
explosion_counter += 1
unit.kill()
# Background and game units on screen
units_all.update()
units_all.draw(mainSurface)
if dialogue:
dialogue_1 = draw.dialogue(
mainSurface,
"Welcome this is my first game. Press Enter to continue! ", 0,
400, SCREEN_WIDTH, 300, blue, white, True)
# Screen platform, e.g. (Score, Hp bar)
text_1 = draw.text(mainSurface, 'Score ' + str(score), 18,
SCREEN_WIDTH / 2, 20, white)
hp_bar = draw.draw_hp_bar(mainSurface, 0, 20, player.full_hp,
player.hp)
lives_icons = draw.draw_icons_lives(mainSurface, 0, player.lives)
if explosion_counter == 5:
text_2 = draw.text(mainSurface, 'You Win', 40, SCREEN_WIDTH / 2,
SCREEN_HEIGHT / 2, blue_bright)
pygame.display.update()
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
player.die()
net.theChosenNet = True
control = False
player.x = net.x + (net.actualWidth / 2)
player.y = net.y + (net.actualHeight / 2)
for net in nets:
net.drawBack()
player.draw()
# player.lookRay()
if (player.actualX() > boatX and player.actualX() < boatX + 300
and player.actualY() > (-player.depth - 140) and player.actualY() <
(-player.depth - 140 + 150)):
explosion = Explosion.explosion(screen, boatX, -player.depth - 140)
explosion.explodeP1(boatX, -player.depth - 140)
boatX = 100000
explosion.explodeP2(boatX, -player.depth - 140)
actualWon = True
for net in nets:
net.drawFront()
pygame.draw.rect(
screen, black,
pygame.Rect(width / 20, (height * 2 / 5) - 50, width / 10,
(height / 5) + 50))
pygame.draw.rect(
screen, (0, 0, 255),
pygame.Rect((width / 20) + (width / 100),
class Rabbit():
pygame.mixer.pre_init(44100, -16, 2, 1024)
pygame.mixer.init()
def __init__(self, id = -1, name = "", color = (255, 255, 255), objectList = [], spriteList = [], fake = False, x = 0, y = 0):
self.objectList = objectList
self.spriteList = spriteList
self.rabbitList = []
self.fake = fake
self.color = color
self.rect = pygame.Rect(x, y, 43, 32)
self.rabbitAnim = Animation("rabbit", 30)
self.rabbitAnim.updateColor(self.color)
self.rabbitAnim.setFrameRange(1, 8);
self.sprite = pygame.sprite.RenderPlain(self.rabbitAnim)
self.rabbitAnim.stopAnim()
self.screen = pygame.display.get_surface()
self.area = self.screen.get_rect()
self.area.h += 500
self.area.y -= 550
self.area.w -= 200
self.floorLevel = self.screen.get_height() - self.rect.h
self.explosion = Explosion()
self.movingLeft = False
self.movingRight = False
self.movingUp = False
self.movingDown = False
self.isJumping = False
self.isOnBlock = False
self.direction = "left"
self.collide = False
self.touched = False
self.touchDelay = 0
self.id = id
self.name = name
self.jumpSound = pygame.mixer.Sound("resources/sound/jump.wav")
self.splashSound = pygame.mixer.Sound("resources/sound/splash.wav")
self.carrotSound = pygame.mixer.Sound("resources/sound/carrot.wav")
self.jumpSound.set_volume(float(Resources.getOptionValue("sound"))/100)
self.splashSound.set_volume(float(Resources.getOptionValue("sound"))/100)
self.carrotSound.set_volume(float(Resources.getOptionValue("sound"))/100)
self.velocity = 5
self.gravity = 0.6
self.movePos = [0,0.01]
self.replaceRabbit()
self.points = 0
self.carrots = 0
self.currentFriction = self.getFloorFriction()
self.thrownCarrots = []
self.blood = Resources.getOptionValue("blood")
def __str__(self):
print "Rabbit ", self.id, ": ", self.name
def update(self):
if not self.fake:
if self.touched:
self.touchDelayCalculation()
else:
if self.movingLeft == True:
self.movePos[0] = -self.velocity
if self.movingRight == True:
self.movePos[0] = self.velocity
if self.movePos[1] is not 0:
self.movePos[1] += self.gravity
self.rect.y += self.movePos[1]
if self.rect.y > self.floorLevel:
self.rect.y = self.floorLevel
self.movePos[1] = 0
self.isJumping = False
if self.movePos[1] < 0:
self.movingUp = True
self.movingDown = False
elif self.movePos[1] > 0:
self.movingUp = False
self.movingDown = True
else:
self.movingUp = False
self.movingDown = False
self.checkForCollision()
newpos = self.rect.move(self.movePos)
if self.area.contains(newpos) and not self.collide:
self.rect = newpos
if self.isJumping:
self.rabbitAnim.setFrameRange(9, 15)
if self.movingUp:
self.rabbitAnim.stopAnim()
self.rabbitAnim.setCurrentFrame(9)
else:
self.rabbitAnim.playAnim(False)
else:
self.rabbitAnim.setFrameRange(1, 8)
if not self.movingLeft and not self.movingRight:
self.rabbitAnim.stopAnim()
self.rabbitAnim.rewind()
else:
self.rabbitAnim.playAnim()
self.rabbitAnim.getRect().x = self.rect.x
self.rabbitAnim.getRect().y = self.rect.y - 16
tmpThrownCarrots = []
for c in self.thrownCarrots:
end = c.update()
if not end:
tmpThrownCarrots.append(c)
self.thrownCarrots = tmpThrownCarrots
self.sprite.update()
self.sprite.draw(self.screen)
self.rabbitAnim.update()
self.explosion.update()
pygame.event.pump()
def collisionDetection(self, obj, rabbit = False):
if self.movingLeft:
if (self.rect.x < (obj.rect.x + obj.rect.w)) and (obj.rect.x < self.rect.x):
if (self.rect.y + self.rect.h) > (obj.rect.y + 1):
if self.rect.y < (obj.rect.y + obj.rect.h):
self.movePos[0] = 0
if self.movingRight:
if (obj.rect.x < (self.rect.x + self.rect.w)) and (obj.rect.x > self.rect.x):
if (self.rect.y + self.rect.h) > (obj.rect.y + 1):
if self.rect.y < (obj.rect.y + obj.rect.h):
self.movePos[0] = 0
if self.movingUp:
if (self.rect.y <= (obj.rect.y + obj.rect.h)) and (obj.rect.y <= self.rect.y):
if (self.rect.x + self.rect.w) > (obj.rect.x + 3):
if self.rect.x < (obj.rect.x + obj.rect.w - 5):
self.movePos[1] = 0.01
if ((self.rect.y + self.rect.h) >= obj.rect.y) and (self.rect.y <= obj.rect.y):
if (self.rect.x + self.rect.w) > (obj.rect.x + 3):
if self.rect.x < (obj.rect.x + obj.rect.w - 5):
if self.movePos[1] >= 0 and not self.isOnBlock:
self.isJumping = False
if rabbit:
self.jump(5)
if self.blood == 1:
obj.explosion = Explosion(obj.rect.x, obj.rect.y, obj.color)
obj.explosion.startExplosion()
self.splashSound.play()
obj.replaceRabbit()
self.points += 1
elif obj.getType() == "boing":
self.jump(12.7)
else:
self.rect.y = obj.rect.y - self.rect.h
self.movePos[1] = 0
self.isOnBlock = True
if self.isJumping:
self.isOnBlock = False
if self.isOnBlock:
if (self.rect.x > (obj.rect.x + obj.rect.w)) or ((self.rect.x + self.rect.w) < obj.rect.x):
self.isOnBlock = False
self.movePos[1] = 0.01
def checkForCollision(self):
if not self.movingLeft and not self.movingRight and self.movePos[1] == 0 and self.velocity == 0 and not self.isJumping:
return
for obj in self.objectList:
if obj.getType() == "carrot" and obj.isInBlock(self.rect.x + self.rect.w/2, self.rect.y + self.rect.h -5):
self.carrotSound.play()
self.carrots += 1
self.objectList.remove(obj)
self.spriteList.remove(obj)
if obj.getType() is not "carrot":
self.collisionDetection(obj, False)
for rabbit in self.rabbitList:
self.collisionDetection(rabbit, True)
def jump(self, velocity = 8.1):
if not self.isJumping:
self.jumpSound.play()
self.movePos[1] = -velocity
self.isJumping = True
def moveLeftStart(self):
if self.rabbitAnim.getFlip():
self.rabbitAnim.flipAnim()
self.rabbitAnim.playAnim()
self.movingLeft = True
self.movingRight = False
self.direction = "left"
def moveLeftStop(self):
if not self.movingRight:
self.rabbitAnim.stopAnim()
self.rabbitAnim.rewind()
self.movingLeft = False
self.movePos[0] = 0
def moveRightStart(self):
if not self.rabbitAnim.getFlip():
self.rabbitAnim.flipAnim()
self.rabbitAnim.playAnim()
self.movingRight = True
self.movingLeft = False
self.direction = "right"
def moveRightStop(self):
if not self.movingLeft:
self.rabbitAnim.stopAnim()
self.rabbitAnim.rewind()
self.movingRight = False
self.movePos[0] = 0
def appendRabbit(self, rabbit):
self.rabbitList.append(rabbit)
def replaceRabbit(self):
self.touched = False
while True:
randObj = self.objectList[random.randint(1, len(self.objectList)) - 1]
if self.isFloor(randObj):
break
self.rect.topleft = (randObj.rect.x, randObj.rect.y - randObj.rect.h)
def isInBlock(self, x, y):
for obj in self.objectList:
if obj.isInBlock(x, y):
return True
return False
def isFloor(self, object):
if self.isInBlock(object.getX() + 5, object.getY() - 5):
return False
return True
def getFloorFriction(self):
return 0.7
def touch(self):
self.touched = True
self.touchDelay = 180
TOUCH = USEREVENT + 1
touchevent = pygame.event.Event(TOUCH)
pygame.event.post(touchevent)
def touchDelayCalculation(self):
self.touchDelay -= 1
if(self.touchDelay == 0):
self.touched = False
UNTOUCH = USEREVENT + 2
untouchevent = pygame.event.Event(UNTOUCH)
pygame.event.post(untouchevent)
def isTouched(self):
return self.touched
def throwCarrot(self):
if(self.carrots > 0):
if(self.direction == "right"):
self.thrownCarrots.append(Carrot(self.direction, self.rect.x + 10, self.rect.y, self.objectList, self.rabbitList))
else:
self.thrownCarrots.append(Carrot(self.direction, self.rect.x, self.rect.y, self.objectList, self.rabbitList))
self.carrots -= 1
def updateColor(self, color):
self.rabbitAnim.updateColor(color)
def getId(self):
return self.id
def getName(self):
return self.name
def getPoints(self):
return self.points
def getCarrots(self):
return self.carrots
def getAnim(self):
return self.rabbitAnim
def setId(self, id):
self.id = id
def setName(self, name):
self.name = name
def setPoints(self, points):
self.points = points
def __init__(self, id = -1, name = "", color = (255, 255, 255), objectList = [], spriteList = [], fake = False, x = 0, y = 0):
self.objectList = objectList
self.spriteList = spriteList
self.rabbitList = []
self.fake = fake
self.color = color
self.rect = pygame.Rect(x, y, 43, 32)
self.rabbitAnim = Animation("rabbit", 30)
self.rabbitAnim.updateColor(self.color)
self.rabbitAnim.setFrameRange(1, 8);
self.sprite = pygame.sprite.RenderPlain(self.rabbitAnim)
self.rabbitAnim.stopAnim()
self.screen = pygame.display.get_surface()
self.area = self.screen.get_rect()
self.area.h += 500
self.area.y -= 550
self.area.w -= 200
self.floorLevel = self.screen.get_height() - self.rect.h
self.explosion = Explosion()
self.movingLeft = False
self.movingRight = False
self.movingUp = False
self.movingDown = False
self.isJumping = False
self.isOnBlock = False
self.direction = "left"
self.collide = False
self.touched = False
self.touchDelay = 0
self.id = id
self.name = name
self.jumpSound = pygame.mixer.Sound("resources/sound/jump.wav")
self.splashSound = pygame.mixer.Sound("resources/sound/splash.wav")
self.carrotSound = pygame.mixer.Sound("resources/sound/carrot.wav")
self.jumpSound.set_volume(float(Resources.getOptionValue("sound"))/100)
self.splashSound.set_volume(float(Resources.getOptionValue("sound"))/100)
self.carrotSound.set_volume(float(Resources.getOptionValue("sound"))/100)
self.velocity = 5
self.gravity = 0.6
self.movePos = [0,0.01]
self.replaceRabbit()
self.points = 0
self.carrots = 0
self.currentFriction = self.getFloorFriction()
self.thrownCarrots = []
self.blood = Resources.getOptionValue("blood")
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())
