def powerup_collision_check(self, rocket):
for powerup in self.powerups[:]:
if powerup.collided(rocket):
self.explosions.append(
Explosion(powerup.width,
rocket.rect.center[0] - rocket.width,
rocket.rect.y, self.screen, powerup))
rocket.powerup_pickup(powerup)
self.powerups.remove(powerup)
self.score_checker()
#Enemy projectile can destroy powerup
for enemy_projectile in self.enemy_projectiles[:]:
if powerup.collided(enemy_projectile):
self.explosions.append(
Explosion(powerup.width, powerup.rect.x,
powerup.rect.y, self.screen,
enemy_projectile))
self.enemy_projectiles.remove(enemy_projectile)
if powerup not in self.powerups:
pass
else:
self.powerups.remove(powerup)
def start(self):
pygame.init()
self.stage = Stage(self, 1)
self.screen = pygame.display.set_mode((800, 600))
self.background = Background(self)
self.background.load()
self.player = Player(self)
self.player.load()
self.bullet = Bullet(self)
self.bullet.load()
self.enemies = Enemies(self)
self.enemies.load()
self.game_text = GameText(self)
self.game_text.load()
self.explosion = Explosion(self)
self.explosion.load()
self.caption = Caption(self)
self.caption.load()
self.score = Score(self)
self.score.load()
while self.running:
self.screen.fill((0, 0, 0))
self.background.show()
self.handle_event()
def render(self):
#Render asteroids and stars
for object in self.objects:
object.render()
#Render powerups
if len(self.powerups) > 0:
for powerup in self.powerups:
powerup.fallmove()
if powerup.rect.y > self.screen.get_height():
self.powerups.remove(powerup)
powerups_plain = pygame.sprite.RenderPlain(self.powerups)
powerups_plain.draw(self.screen)
#Render enemies
if len(self.enemies) > 0:
for enemy in self.enemies:
enemy.render()
#Render enemy projectiles
enemy_shoot_chance = Dice()
dice_roll = enemy_shoot_chance.roll()
self.enemy_shoot(dice_roll)
if len(self.enemy_projectiles) > 0:
for enemy_projectile in self.enemy_projectiles:
enemy_projectile.render()
if enemy_projectile.rect.y > self.screen.get_height():
self.enemy_projectiles.remove(enemy_projectile)
#Render explosions
if len(self.explosions) > 0:
for explosion in self.explosions:
explosion.render_cycle()
#Destroy asteroids and ufos inside explosion
if type(explosion.object) is BombProjectile:
for object in self.objects:
if object.projectile_collided(explosion):
self.explosions.append(
Explosion(object.size, object.rect.x,
object.rect.y, self.screen,
explosion.object))
object.reset()
self.score_checker()
for enemy in self.enemies:
if enemy.projectile_collided(explosion):
self.explosions.append(
Explosion(object.size, object.rect.x,
object.rect.y, self.screen,
explosion.object))
self.enemies.remove(enemy)
self.score_checker()
if explosion.over:
self.explosions.remove(explosion)
def hit(self):
#set true to indicate the brick was hit
self.broke = True
#create explosion to draw instead of brick rectangle
self.explosion = Explosion(self.rect.centerx, self.rect.centery, 4, 25,
self.color, "sounds/shortbreak.ogg",
self.displaySurface)
def initialize(self):
pygame.init()
self.__total_time = pygame.time.get_ticks()
#flags = pygame.FULLSCREEN | pygame.DOUBLEBUF
flags = pygame.DOUBLEBUF | pygame.RESIZABLE
self.__window = pygame.display.set_mode(window_size, flags)
self.__game_continues = True
Explosion.load_image()
def update(self):
"Handle obj interactions, and update each obj."
if self.verbose: print "Game.update"
wH = self.screenHeight
wW = self.screenWidth
# screen issues
if self.ship.offScreen(wW, wH):
self.ship.wrapAround(wW, wH)
for a in self.asteroids:
if a.offScreen(wW, wH):
a.wrapAround(wW, wH)
for i, b in enumerate(self.bullets):
if b.offScreen(wW, wH):
self.bullets.pop(i)
# explosions done?
for ei, e in enumerate(self.explosions):
if e.isDone():
print "explosion done"
self.explosions.pop(ei)
# collision detection
for bi, b in enumerate(self.bullets):
for ai, a in enumerate(self.asteroids):
if b.collision(a):
print "collision: ", b, a
# replace both
self.asteroids.pop(ai)
self.bullets.pop(bi)
# with an explosion
self.explosions.append(Explosion(a.x, a.y))
# did we just kill all asteroids?
if len(self.asteroids) == 0:
self.state.inPlay = False
self.state.win = True
# or did asteroids kill us?
for a in self.asteroids:
if self.ship.collision(a):
print "collision with ship!"
self.state.inPlay = False
self.state.win = False
self.explosions.append(Explosion(self.ship.x, self.ship.y))
# pass on the call to update
self.ship.update()
for b in self.bullets:
b.update()
for a in self.asteroids:
a.update()
for e in self.explosions:
e.update()
def hit(self, actor):
if type(actor).__name__ != 'Hero':
self.x -= self.speed_x
self.y -= self.speed_y
self.speed_y = -self.speed_y
if type(actor).__name__ == 'Weapon':
self.world.remove_actor(actor)
self.world.remove_actor(self)
explosion = Explosion(self.world)
explosion.x = self.x
explosion.y = self.y
self.world.add_actor(explosion)
def create_explosion(self, x_cord, y_cord):
""" Creates an explosion at coordinates x_cord and y_cord on board. """
if x_cord < 0 or y_cord < 0 or \
x_cord >= self.row or y_cord >= self.col:
return
explosion = Explosion(x_cord, y_cord)
self.board[x_cord][y_cord].append(explosion)
def update(self, time, scene):
self.floatX += self.speedX * time * GRENADE_SPEED
self.floatY += self.speedY * time * GRENADE_SPEED
self.rect.x = roundToInt(self.floatX)
self.rect.y = roundToInt(self.floatY)
self.timeToBoom -= time
if self.timeToBoom <= 0:
scene.bulletGroup.remove(self)
scene.bulletGroup.add(Explosion(self.rect.x, self.rect.y))
# Kill people!
originalRect = self.rect.copy()
self.rect.inflate_ip(80, 80) # 80x80 area damage
enemies_hit = sprite.spritecollide(self, scene.enemyGroup, False)
for enemy in enemies_hit:
# Friendly fire
if self.creator.__class__.__name__ == enemy.__class__.__name__:
continue
enemy.receive_attack(self.atk)
if sprite.collide_rect(self, scene.player):
scene.player.receive_attack(self.atk)
self.rect = originalRect # Restore the real rect
self.timeToStop -= time
if self.timeToStop <= 0:
self.speedX = 0
self.speedY = 0
def destruct_rocket(self, r, object):
self.reset_view = True
r.explode()
self.reset_view = True
self.explosions.append(Explosion(r.get_pos(), 0.04, object.get_nationality()))
self.rockets.remove(r)
self.planet.load_rocket()
def explode(self):
self.sonidos.PlayExplosion()
self.sprite.visible = False
Entidades.eliminarBomba(self.sprite)
self.exp = Explosion(self.rango, self.x, self.y, self.atraviesa)
t = threading.Timer(1, self.destroyExplode)
t.start()
def timerFired(self, dt):
self.timer += dt
self.shipGroup.update(dt, self.isKeyPressed, self.width, self.height)
self.asteroids.update(self.width, self.height)
self.bullets.update(self.width, self.height)
self.explosions.update(dt)
self.starGroup.update()
ship = self.shipGroup.sprite
star = self.starGroup.sprite
if ((not ship.isInvincible()) and pygame.sprite.groupcollide(
self.shipGroup, self.asteroids, False, False,
pygame.sprite.collide_circle)):
self.explosions.add(Explosion(ship.x, ship.y))
self.shipGroup.add(Ship(self.width / 2, self.height / 2))
for asteroid in pygame.sprite.groupcollide(
self.asteroids, self.starGroup, True, False,
pygame.sprite.collide_circle):
self.asteroids.remove(asteroid)
for asteroid in pygame.sprite.groupcollide(
self.asteroids, self.bullets, True, True,
pygame.sprite.collide_circle):
self.asteroids.add(asteroid.breakApart())
def __explosion(self, explosiones):
if explosiones:
path = os.path.join(BASE_PATH, "Explosion")
self._audio.explosion()
for e in explosiones:
x, y = e
self._explosiones.add(Explosion(x, y, path))
def rocket_collision_check(self, rocket):
for object in self.objects:
if object.rocket_collided(rocket):
self.explosions.append(
Explosion(rocket.width * 2,
rocket.rect.center[0] - rocket.width,
rocket.rect.y, self.screen, object))
object.reset()
for enemy_projectile in self.enemy_projectiles:
if enemy_projectile.rocket_collided(rocket):
self.explosions.append(
Explosion(rocket.width * 2,
rocket.rect.center[0] - rocket.width,
rocket.rect.y, self.screen, enemy_projectile))
self.enemy_projectiles.remove(enemy_projectile)
def init(self):
self.bgColor = (0, 0, 0)
Ship.init()
ship = Ship(self.width / 2, self.height / 2)
self.shipGroup = pygame.sprite.GroupSingle(ship)
Asteroid.init()
self.asteroids = pygame.sprite.Group()
for i in range(5):
x = random.randint(0, self.width)
y = random.randint(0, self.height)
self.asteroids.add(Asteroid(x, y))
self.bullets = pygame.sprite.Group()
Explosion.init()
self.explosions = pygame.sprite.Group()
def afterExpl(self): # clears up the exploded blocks
n = self.pos[0]
m = self.pos[1]
expl = Explosion()
expl.afterExplosion(n, m)
expl.afterExplosion(n - 2, m)
expl.afterExplosion(n + 2, m)
expl.afterExplosion(n, m + 4)
expl.afterExplosion(n, m - 4)
self.set = 0
return
def bang_action(self, other):
global kol_bang1
other.kill()
x = (self.pos[0] + other.pos[0]) / 2
y = (self.pos[1] + other.pos[1]) / 2
exp = Explosion(pos=(x, y))
shoot_sound = pygame.mixer.Sound('vz.mp3')
shoot_sound.play()
kol_bang1 += 1
return [exp]
def alien_bullet_update(alien_bullets, ai_settings, ship, explosions,
sprite_sheet, screen, stats, sb, ship_explosions_sheet,
ship_explosions):
for bullet in alien_bullets.copy():
bullet.y += bullet.speed_factor
bullet.rect.y = bullet.y
bullet.draw_bullet()
if bullet.rect.bottom >= ai_settings.screen_height:
alien_bullets.remove(bullet)
elif bullet.rect.y >= ship.rect.y and ship.rect.right >= bullet.rect.x >= ship.rect.left:
alien_bullets.remove(bullet)
new_explosion = Explosion(ship_explosions_sheet, screen)
new_explosion.rect = pygame.Rect(ship.rect)
new_explosion.rect.centerx = ship.rect.centerx
ship_explosions.append(new_explosion)
ship.ship_destroyed = True
stats.ships_left -= 1
sb.prep_ships()
def update(self):
# drop the bomb!! pass in an x velocity and y velocity
self.rect.move_ip(0, self.y_velocity)
# blow up bomb, if it hits the ground
# where y is 470
if (self.rect.bottom >= 750):
Explosion(self)
self.kill()
def explode(self, bomb):
# out with the old
self.bombs.remove(bomb)
self.remove(bomb, bomb.getPos())
bomb.player.addBomb()
# in with the new
explosion = Explosion(bomb, self)
affected = explosion.getAffected()
for xy in filter(self.map.has_key, affected):
for el in filter(lambda x: x.fragile, self.map[xy]):
self.remove(el, xy)
if not self.map[xy]:
del self.map[xy]
for xy in filter(self.playersAt, affected):
for player in self.playersAt(xy):
if player.die():
print "{} dies".format(player)
bomb.player.resetKillCounter(suicide = bomb.player == player)
self.explosions.append(explosion)
def collision(self, mObjects, explosions):
for mOb1 in mObjects:
for mOb2 in mObjects:
#Ship
if (isinstance(mOb1, Ship)):
#Ship, Astroid
if (isinstance(mOb2, AstroidClass)):
pos = self.collide(mOb1, mOb2)
if (pos != None):
explosions.append(Explosion(pos[0], pos[1]))
return None
def explode(self, triggeredByAnotherBomb): now = pg.time.get_ticks() if now - self.timeOfBirth > settings.BOMB_CLOCK or triggeredByAnotherBomb: try: self.game.bombPos.remove([self.bombx, self.bomby]) except: pass self.game.bombs.remove(self) self.player.bomb += 1 self.kill() Explosion(self.game, self.bombx*settings.TILESIZE, self.bomby*settings.TILESIZE, self.power, "center")
def make_fights(self):
for player_ship in self.player_ships:
enemy_ships = check_for_collision_with_list(
player_ship, self.enemy_ships)
for enemy_ship in enemy_ships:
while player_ship.get_hp() > 0 and enemy_ship.get_hp() > 0:
player_ship.get_damage(player_ship.blow_damage +
enemy_ship.make_damage())
enemy_ship.get_damage(enemy_ship.blow_damage +
player_ship.make_damage())
explosion = Explosion(self.explosion_texture)
explosion.center_x = (player_ship.center_x +
enemy_ship.center_x) / 2
explosion.center_y = player_ship.center_y
explosion.update()
self.explosions_list.append(explosion)
if player_ship.get_hp() <= 0:
player_ship.remove_from_sprite_lists()
if enemy_ship.get_hp() <= 0:
enemy_ship.remove_from_sprite_lists()
if enemy_ship.get_hp() < player_ship.get_hp():
self.player_benefit += (1.5 * MONEY_COEFFICIENT - player_ship.cost) /\
MONEY_COEFFICIENT * enemy_ship.cost
else:
self.enemy_benefit += (1.5 * MONEY_COEFFICIENT - enemy_ship.cost) /\
MONEY_COEFFICIENT * player_ship.cost
def __save_colisiones_data(self, _dict):
path = os.path.join(BASE_PATH, "Explosion")
exp = []
for ip in _dict.keys():
exp.extend(_dict[ip].get("e", []))
if exp:
self._audio.explosion()
for e in exp:
self._explosiones.add(Explosion(e["x"], e["y"], path))
# Las explosiones no deben guardarse
for ip in self._data_game_players.keys():
if "e" in self._data_game_players[ip].keys():
del (self._data_game_players[ip]["e"])
def bang_action(self, other):
e = self.energy + other.energy
if e < 0.01:
return super().bang_action(other)
else:
self.kill()
other.kill()
x = (self.pos[0] + other.pos[0]) / 2
y = (self.pos[1] + other.pos[1]) / 2
exp = Explosion(pos=(x, y))
shoot_sound = pygame.mixer.Sound('vz.mp3')
shoot_sound.play()
return [exp]
def explodeBomb(self, life):
n = self.pos[0]
m = self.pos[1]
if life != Board.lives:
return
expl = Explosion()
expl.explode(n, m)
expl.explode(n - 2, m)
expl.explode(n + 2, m)
expl.explode(n, m + 4)
expl.explode(n, m - 4)
if Board.lives >= 0:
# The explosion is shown for 1 second
t = Timer(1, self.afterExpl)
t.start()
return
def detect_collisions(player, aliens, shots, bombs, boom_sound):
for alien in pygame.sprite.groupcollide(shots, aliens, 1, 1).keys():
boom_sound.play()
Explosion(alien)
Score.score_points = Score.score_points + 1
check_game_level(Score.score_points)
for bomb in pygame.sprite.spritecollide(player, bombs, 1):
boom_sound.play()
Explosion(player)
Explosion(bomb)
PlayerLives.lives = PlayerLives.lives - 1
check_player_life(player)
for bomb in pygame.sprite.groupcollide(shots, bombs, 1, 1).keys():
boom_sound.play()
bomb.kill()
Explosion(bomb)
def hit(self):
#indicates this invader is hit
self.damaged = True
#increase the speed of all the Invaders
Invader.speed = Invader.speed + 2
#increase the number of Invaders destroyed
Invader.numberDestroyed = Invader.numberDestroyed + 1
#change the amount moved based on how many destroyed
#increase 1 for every 5 Invaders destroyed
Invader.moveAmount = int(Invader.numberDestroyed / 5) + 4
#create an explosion to draw instead of the invader image
self.explosion = Explosion(self.rect.centerx, self.rect.centery, 4, 15,
self.color, self.destroySound,
self.displaySurface)
def check_ships(self, ships):
for ship in ships:
if ship.get_hp() <= 0:
explosion = Explosion(ship.dying_sprite)
explosion.center_x = ship.center_x
explosion.center_y = ship.center_y
explosion.update()
self.explosions_list.append(explosion)
ship.remove_from_sprite_lists()
def check_bullets_hit_meteor():
global score
# TODO 05.修正碰撞偵測的規則
hits = pygame.sprite.groupcollide(meteors, bullets, True, True)
if hits:
for hit in hits:
# TODO 02.修改加分的機制
score += round(60 / hit.size)
explosion = Explosion(hit.rect.centerx, hit.rect.centery)
all_sprites.add(explosion)
newSupport(hit.rect.centerx, hit.rect.centery)
hit.kill()
# print("check_bullets_hit_meteor")
newMeteor()
def check_collisions(self, ships, base: Sprite):
for ship in ships:
if check_for_collision(ship, base):
base.damage(ship.make_damage())
explosion = Explosion(self.explosion_texture)
explosion.center_x = base.center_x
explosion.center_y = base.center_y
explosion.update()
self.explosions_list.append(explosion)
ship.remove_from_sprite_lists()
def check_bullets_hit_enemy():
global score
hits = pygame.sprite.groupcollide(enemies,bullets,True,True,pygame.sprite.collide_circle_ratio(1))
if hits:
for hit in hits:
hit.kill()
score += (hit.size)*2
# print("check_bullets_hit_meteor")
newEnemy()
explosion=Explosion(hit.rect.centerx,hit.rect.centery)
all_sprites.add(explosion)
type=random.randint(0,1)
support=Support(hit.rect.centerx,hit.rect.centery,type)
supports.add(support)
all_sprites.add(supports)
class Bomba(object):
MAX_RANGO = 15
@staticmethod
def getMaxRango():
return Bomba.MAX_RANGO
def __init__(self, nombre, x, y, atrav):
self.rango = 3
self.sprite = None
self.spriteName = nombre
self.escalaX = 1
self.escalaY = 1
self.atraviesa = atrav
self.x = int(x / 52.3076923077) * 52.3076923077
self.y = int(y / 52.3076923077) * 52.3076923077
self.sonidos = Sonidos()
self.exp = None
self.explosionEnded = False
self.atraviesa = atrav
time = threading.Timer(2.5, self.explode)
time.start()
def setScales(self, scaleX, scaleY):
self.escalaX = scaleX
self.escalaY = scaleY
def setPosicion(self, x, y):
self.x = x
self.x = int(x / 52.3076923077) * 52.3076923077
self.y = y
self.y = int(y / 52.3076923077) * 52.3076923077
def setRango(self, rango):
self.rango = rango
def explode(self):
self.sonidos.PlayExplosion()
self.sprite.visible = False
Entidades.eliminarBomba(self.sprite)
self.exp = Explosion(self.rango, self.x, self.y, self.atraviesa)
t = threading.Timer(1, self.destroyExplode)
t.start()
def destroyExplode(self):
self.explosionEnded = True
self.exp.endExplosion()
def getSprite(self):
sprite = MySprite(self.spriteName, self.x, self.y, 10)
sprite.t = 20.0
sprite.listframes(1, 7, 50, 50)
sprite.setframe(1)
return sprite
def Update(self, gameTime):
if self.sprite == None:
self.sprite = self.getSprite()
Entidades.agregarBomba(self.sprite)
if self.sprite.visible:
self.sprite.animar(False, [1, 2, 3, 4, 5, 6, 7], gameTime)
self.sprite.post_update("Estatico")
else:
if self.exp != None:
if not self.explosionEnded:
self.exp.Update(gameTime)
def Draw(self, gameTime, window):
if self.sprite == None:
self.sprite = self.getSprite()
Entidades.agregarBomba(self.sprite)
if self.sprite.visible:
window.Draw(self.sprite)
else:
if self.exp != None:
if not self.explosionEnded:
self.exp.Draw(gameTime, window)
def toString(self):
s = "ClassName: Bomba\n"
s += "Sprite: " + self.spriteName + "\n"
