def checkCollision(self):
#if pygame.sprite.spritecollide(self.p1, self.asteroids, False, pygame.sprite.collide_mask):
#print('collide', randint(1, 100))
for shoot in self.shoots:
collide = pygame.sprite.spritecollide(shoot, self.asteroids, False,
pygame.sprite.collide_mask)
for c in collide:
self.shoots.remove(shoot)
c.life -= shoot.damage
if c.life > 0:
expl = explosion.Explosion((shoot.rect.x, shoot.rect.y),
(25, 25))
#expl.rect.y -= expl.rect.height / 2
#expl.rect.x -= expl.rect.width / 2
self.explosions.append(expl)
break
expl = explosion.Explosion((c.rect.x, c.rect.y),
(c.rect.height, c.rect.width))
self.explosions.append(expl)
self.points += c.points
self.asteroids.remove(c)
for e in self.explosions:
done = e.explode()
if done:
self.explosions.remove(e)
e = None
if pygame.sprite.spritecollide(self.p1, self.asteroids, True,
pygame.sprite.collide_mask):
self.running = False
def processCollision(self):
self.__turtle.forward(10)
hitobjects = self.__turtle.collision(["tank"], 22)
for hitobject in hitobjects:
if (hitobject != None and hitobject != self.__localtank):
power = self.extrainfo().power()
#print (self.extrainfo().name() + " power:" + str(power) + " " + hitobject.extrainfo().playerClass().name())
self.extrainfo().hitobject(hitobject)
self.__hitpoints = power #single time scoring
if (hitobject.extrainfo().playerClass().hit(power)) > 0:
self.extrainfo().animation(
explosion.Explosion("small", self))
else:
self.extrainfo().animation(explosion.Explosion(
"big", self))
def update(self, dt):
if self.hover:
self.hover_time += dt
self.pos = self.initial_pos + (
V2(4, 0) * math.sin(self.hover_time * 1.25) +
V2(0, 4) * math.cos(self.hover_time * 1.25))
if random.random() < 0.25:
colors = [PICO_WHITE, PICO_BLUE, PICO_BLUE]
if random.random() < 0.5:
colors = [PICO_WHITE, PICO_YELLOW, PICO_YELLOW]
p = Particle(colors, 1,
self.pos + V2(41, 11) + helper.random_angle() * 1,
0.25,
helper.random_angle() * 20)
self.scene.game_group.add(p)
if random.random() < 0.25:
ep = self.pos + V2(19, 45)
def scale_fn(t):
return 1 - t
e = explosion.Explosion(
ep,
[PICO_WHITE, PICO_LIGHTGRAY, PICO_WHITE, PICO_LIGHTGRAY],
1,
random.randint(3, 6),
scale_fn,
velocity=V2(0, 9) + helper.random_angle() * 4)
e.layer = -1
self.scene.game_group.add(e)
else:
self.pos = self.initial_pos
return super().update(dt)
def update(self, dt):
if self.hover:
self.hover_time += dt
self.pos = self.initial_pos + V2(1, -3) * math.sin(
self.hover_time * 6)
# Make an explosion for the thruster, with a random chance.
if random.random() < 0.25:
def scale_fn(t):
return 1 - t
#return math.sin(t * 3.14159)
offset = V2(2, 29)
if random.random() > 0.5:
offset = V2(12, 32)
ep = self.pos + offset + helper.random_angle() * 0
vel = V2(-7, 20)
e = explosion.Explosion(
ep, [PICO_WHITE, PICO_YELLOW, PICO_ORANGE, PICO_RED],
1,
random.randint(2, 3),
scale_fn,
velocity=vel)
self.scene.game_group.add(e)
else:
self.pos = self.initial_pos
return super().update(dt)
def die(self):
print("Test")
self.entities.append(
explosion.Explosion(self.screen, self.space, self.entities,
self.body.position))
print("Test 2")
self.alive = False
self.remove()
def __del__(
self): # destructor: Automatically called when instance is deleted
if not self.reset:
self.explode.play()
self.stats.score += 10
new_explosion = explosion.Explosion(self.screen, self.rect.x,
self.rect.y)
self.explosions.add(new_explosion)
self.sb.prep_score()
def emit_thrust_particles(self):
def sfn(t):
if t < 0.125:
return t * 8
return 1 - (t - 0.125) / (1 - 0.125)
e = explosion.Explosion(
self.pos + -self.velocity,
[PICO_WHITE, PICO_YELLOW, PICO_YELLOW, PICO_ORANGE, PICO_RED], 1.5,
4, sfn, 4)
self.scene.game_group.add(e)
def update_all(self):
self.hero_and_enemy.update(self.weapon_sprites)
self.weapon_sprites.update()
self.wall_sprites.update()
self.enemy_sprites.update(self.enemy_weapon_sprites)
if pygame.sprite.spritecollide(self.tank,
self.wall_sprites,
dokill=False):
self.tank.check_for_collision(True)
is_explo = pygame.sprite.groupcollide(self.weapon_sprites,
self.wall_sprites, True, True)
#返回以self.weapon_sprites为key的字典，
#每个key的值为self.wall_sprites中与self.weapon_sprites碰撞的元素
for key in is_explo:
if is_explo[key]:
self.explo = explosion.Explosion(is_explo[key][0].rect.center)
self.explo_sprites.add(self.explo)
self.explo_sprites.update()
hero_wall_collide = pygame.sprite.groupcollide(self.hero_and_enemy,
self.wall_sprites,
False, False)
for key in hero_wall_collide:
key.is_collide = True
enemy_wall_collide = pygame.sprite.groupcollide(
self.enemy_sprites, self.wall_sprites, False, False)
for key in enemy_wall_collide:
key.is_collide = True
hit_collide = pygame.sprite.groupcollide(self.weapon_sprites,
self.enemy_sprites, True,
True)
for key in hit_collide:
if hit_collide[key]:
self.enemy_explo = explosion.Explosion(
hit_collide[key][0].rect.center)
self.explo_sprites.add(self.enemy_explo)
self.explo_sprites.update()
def collisionShip3 (self):
if pygame.sprite.collide_rect(self.torpedo, self.ship3):
print("explosion 3 found")
self.explosionLocX = self.ship3.rect.x
self.explosionLocY = self.ship3.rect.y
self.explodeSound.play()
self.explosion = explosion.Explosion(self.screen, self.explosionLocX, self.explosionLocY)
del(self.ship3)
self.ship3 = ships.Ship(self.screen, -600, 340)
for i in range(3):
self.explosion.animate(i)
self.score += self.ship3Speed * 100
def update(self):
if self.hitDetect():
explosion.Explosion(self.pos)
my.ENGINE.game.entities.remove(self)
lib.delayedfunc.DelayedFunc(
lambda: my.ENGINE.game.turncontroller.next(), 2)
else:
acceleration = my.GRAVITY + my.ENGINE.game.wind.wind
self.velocity += acceleration
self.pos[0] += self.velocity.x
self.pos[1] += self.velocity.y
self.rect.center = self.pos
def __del__(
self
): # This modified destructor will unleash a wave of three bullets upon activation
if not self.reset:
self.explode.play()
self.stats.score += 20
new_explosion = explosion.Explosion(self.screen, self.rect.x,
self.rect.y)
self.explosions.add(new_explosion)
self.sb.prep_score()
new_alien_bullet1 = alien_bullet.AlienBullet(
self.ai_settings, self.screen, self)
new_alien_bullet2 = alien_bullet.AlienBullet(
self.ai_settings, self.screen, self)
new_alien_bullet2.rect.centerx -= self.rect.width
new_alien_bullet3 = alien_bullet.AlienBullet(
self.ai_settings, self.screen, self)
new_alien_bullet3.rect.centerx += self.rect.width
self.alien_bullets.add(new_alien_bullet1)
self.alien_bullets.add(new_alien_bullet2)
self.alien_bullets.add(new_alien_bullet3)
all_sprites.add(user)
for i in range(8):
newmob()
score = 0
clock.tick(FPS)
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
all_sprites.update()
hits = pygame.sprite.spritecollide(user, mobs, True, pygame.sprite.collide_circle)
for hit in hits:
user.shield -= hit.radius * 2
expl = explosion.Explosion(hit.rect.center, 'sm')
all_sprites.add(expl)
newmob()
if user.shield <= 0:
death_explosion = explosion.Explosion(user.rect.center, 'player')
all_sprites.add(death_explosion)
user.hide()
user.lives -= 1
user.shield = 100
if user.lives == 0 and not death_explosion.alive():
game_over = True
hits = pygame.sprite.groupcollide(mobs, user.get_bullet(), True, True)
for hit in hits:
score += 50 - hit.radius
def __init__(self):
self.win = py.display.set_mode(
(config.screen_width, config.screen_height))
py.font.init()
py.display.set_caption("EscapeVector")
#----------Menusystem---------
self.menu_system = menu.Menu()
############
self.mouse_clicked = False
self.quit = False
self.mouse_pos = (0, 0)
self.pressed_escape = False
self.turn_right = False
self.turn_left = False
self.turbo = False
self.throttle_down = True
self.throttle_up = False
self.slowtime = False
self.slowduration = 10
self.clock = py.time.Clock()
self.hud_base = py.transform.scale(py.image.load("../images/hud.png"),
(200, 200))
self.explode = explosion.Explosion()
self.minimap = minimap.Minimap()
self.missiles_exploded = []
self.close_time = 0
self.fighters = py.sprite.Group()
self.missiles = py.sprite.Group()
self.emps = py.sprite.Group()
self.turn_screen_red = False
self.slowvalue = 1
self.bullets = bullet.BulletsSystem()
self.enemiesbullets = bullet.BulletsSystem()
self.shoot = False
self.ai = brain.Brain()
self.ai.fighters = self.fighters.sprites()
self.sparkSystem = particle.SparkSystem()
self.explosions_size = 10
self.initial_explosion = []
self.clouds = clouds.Clouds()
self.explosions = []
self.camoffs = []
for i in range(20):
self.camoffs.append(
[random.randint(-10, 10),
random.randint(-10, 10)])
self.camoffx = 0
self.camoffy = 0
self.shake = False
self.shakecount = 0
self.screen_r = 0x8c
self.screen_g = 0xbe
self.screen_b = 0xd6
self.turn_screen_normal = True
self.dirty_rects = []
self.game_exists = False
#######sounds#####
self.sounds = sound.Sound()
self.playerhit = False
self.fighterhit = False
self.ticklowspeed = 0.5
self.tickhighspeed = 0.1
self.tickspeedrate = 0.05
self.tickspeed = 0.1
def _create_explosion(self, center, color):
n_explosion = explosion.Explosion(self, center, color)
self.explosion_group.append(n_explosion)
def update(self, dt):
if hasattr(self.get_max_speed, 'cache_clear'):
self.get_max_speed.cache_clear()
if not self.updated_color:
self.update_color()
self.updated_color = True
self.time += dt
if self.health <= 0:
e = explosion.Explosion(
self.pos, [PICO_WHITE, PICO_LIGHTGRAY, PICO_DARKGRAY],
0.25,
13,
scale_fn="log",
line_width=1)
self.scene.game_group.add(e)
self.kill()
return
self.states[self.state]['update'](dt)
# Factor in fleet forces
self.fleet_forces = self.get_fleet_forces(dt) * FLEET_POWER
if self.fleet_forces.length_squared() > self.fleet_minimum_forces**2:
self.target_velocity += self.fleet_forces
# Try to get to the target velocity
velocity_adjust_total = self.target_velocity - self.velocity
# We want to reduce thrust if we're trying to thrust away from our heading
angle_thrust_adjust = 1
if velocity_adjust_total.x or velocity_adjust_total.y:
velocity_adjust_final = helper.try_normalize(velocity_adjust_total)
else:
velocity_adjust_final = velocity_adjust_total
current_heading_vec = helper.from_angle(self.angle)
dp = velocity_adjust_final.dot(current_heading_vec)
if dp < 0: # dot product < 0 means that the two vectors are facing away from eachother.
angle_thrust_adjust = 0.5
velocity_adjust_frame = velocity_adjust_final * dt * self.get_thrust_accel(
) * angle_thrust_adjust
if velocity_adjust_frame.length_squared(
) > velocity_adjust_total.length_squared() * angle_thrust_adjust:
self.velocity = self.target_velocity * angle_thrust_adjust
else:
self.velocity += velocity_adjust_frame
if self.velocity.length_squared() > (self.get_max_speed() *
angle_thrust_adjust)**2:
self.velocity = helper.try_normalize(
self.velocity) * self.get_max_speed() * angle_thrust_adjust
# Set angle based on velocity
if self.target_heading is None:
if self.velocity.length_squared() > 0:
_, self.angle = self.velocity.as_polar()
self.angle *= 3.14159 / 180
else:
angle_delta = helper.get_angle_delta(self.angle,
self.target_heading)
if abs(angle_delta) < ROTATE_SPEED * dt:
self.angle = self.target_heading
elif angle_delta < 0:
self.angle -= ROTATE_SPEED * dt
else:
self.angle += ROTATE_SPEED * dt
if self.velocity.length_squared() > 0:
if self._timers['thrust_particle_time'] > THRUST_PARTICLE_RATE:
self.emit_thrust_particles()
self._timers['thrust_particle_time'] = 0
# Nearest hazard
nearest, dsq = helper.get_nearest(self.pos, [
o for o in self.scene.get_objects_in_range(self.pos, 20)
if o.collidable and o.stationary
])
if nearest and nearest != self.effective_target:
dsf = dsq - nearest.radius**2
delta = helper.try_normalize(nearest.pos - self.pos)
near = 20
if dsf > 0 and dsf < near**2:
t = 1 - math.sqrt(dsf) / near
self.velocity += -delta * t * 5 * dt
side = V2(delta.y, -delta.x)
fwd = helper.try_normalize(self.velocity)
cross = fwd.cross(side)
if cross > 0:
side = -side
self.velocity += side * t * 5 * dt
# Stay away from the edges of the world
if self.pos.x < 5:
self.velocity.x += dt * self.get_thrust_accel() * 2
if self.pos.y < 5:
self.velocity.y += dt * self.get_thrust_accel() * 2
if self.pos.x > game.Game.inst.game_resolution.x - 5:
self.velocity.x -= dt * self.get_thrust_accel() * 2
if self.pos.y > game.Game.inst.game_resolution.y - 5:
self.velocity.y -= dt * self.get_thrust_accel() * 2
# Fuel empty
if self.state == STATE_CRUISING:
speed_adjust = self.get_max_speed() / self.MAX_SPEED
cruise_travel_dist_frame = self.velocity.length(
) * dt / speed_adjust
self.fuel_remaining -= cruise_travel_dist_frame
if self.fuel_remaining < 0:
sound.play("recall")
self.set_state(STATE_RETURNING)
self.turnaround_spr = FrameSprite(
self.pos, "assets/fighterturnaround.png", 6)
self.scene.ui_group.add(self.turnaround_spr)
self.turnaround_time = 0
# TODO: Error sound
self.pos += self.velocity * dt
self.health_bar.pos = self.pos + V2(0, -6)
self.shield_bar.pos = self.pos + V2(0, -9)
self.special_stat_update(dt)
if self.scene.game.run_info.o2 <= 0 and self.owning_civ and self.owning_civ.is_player:
self.health -= self.get_max_health() / 60 * dt
super().update(dt)
if self.stealth:
if self._sheet != self._stealth_sheet:
self.set_stealth_image()
self._timers['thrust_particle_time'] = -1
else:
if self._unstealth_sheet and self._sheet != self._unstealth_sheet:
self._sheet = self._unstealth_sheet
def append(self, coord):
self.add(explosion.Explosion(coord))
def display(self):
""" Called from manager, handles draws and updates of all assets """
if self.first_run:
self.ticks = pygame.time.get_ticks()
self.first_run = False
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.on_exit()
elif event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE:
self.on_exit()
prev_ticks = self.cur_ticks
self.cur_ticks = pygame.time.get_ticks()
ticks = self.cur_ticks - prev_ticks
self.elapsed += ticks
if self.elapsed > self.delay:
self.elapsed = self.elapsed % self.delay
self.keys = pygame.key.get_pressed()
if self.keys[self.player_key_up]:
self.player.move_up()
if self.keys[self.player_key_shoot]:
self.shoot()
self.background.scroll(2)
self.player.update()
self.enemy_group.update()
for bul in self.bullets:
if bul.is_on_screen:
bul.update()
self.background.draw(self.screen)
self.player.draw()
self.enemy_group.draw(self.screen)
if pygame.sprite.spritecollide(self.player, self.enemy_group, True):
print "YOU WERE HIT"
self.on_exit()
for bul in self.bullets:
if bul.is_on_screen:
bul.draw()
enemies = pygame.sprite.spritecollide(bul, self.enemy_group,
True)
if enemies:
bul.hit()
for enemy in enemies:
exploded = explosion.Explosion(enemy.image, enemy.rect,
enemy.x, enemy.y,
enemy.speed_x / 4.0)
self.explosions.append(exploded)
if len(self.explosions):
for exploding in self.explosions:
exploding.update()
exploding.draw()
if not len(self.enemy_group):
temp_explosions = []
for exploding in self.explosions:
if not exploding.done:
temp_explosions.append(exploding)
self.explosions = temp_explosions
if not len(self.explosions):
print "YOU WIN"
self.on_exit()
pygame.display.flip()
self.frames += 1
def explode(self):
self.remove()
explosions.add(explosion.Explosion(self.power, self.position))
self.player.recharge_bomb()
def main():
# Initialise constants
leadTime = 2.0
loadTime = 0.2
thrustTime = 1.8
torpedoTime = 2.0
torpedoSpeed = 600
# Initialise mixer
pygame.mixer.pre_init(44100, -16, 2, 4096)
# Initialise screen
pygame.init()
screen = pygame.display.set_mode((800,600))
pygame.display.set_caption('Holy Diver')
screenRect = screen.get_rect()
# Initialise joysticks
joysticks = [pygame.joystick.Joystick(x) for x in range(pygame.joystick.get_count())]
map(lambda x: x.init(), joysticks)
# Initialise game objects
layers = world.Layers([1, 2, 3, 4, 5], [150,250,400,500,600])
player1 = diver.Diver("right", "crescent", layers)
player2 = diver.Diver("left", "cross", layers)
# Initialise sounds
pygame.mixer.init()
bloopsound = resources.load_sound('bluop.wav')
pewsound = resources.load_sound('PEW.wav')
explodesound = resources.load_sound('PCHRR.wav')
startsound = resources.load_sound('BADAM.wav')
winsound = resources.load_sound('daDUN.wav')
losesound = resources.load_sound('wawow.wav')
pewChannel = pygame.mixer.find_channel()
# Initialise sprites
playersprite = pygame.sprite.Group((player1,player2))
scoresprite = pygame.sprite.Group((player1.scorepanel,player2.scorepanel))
torpedos1 = pygame.sprite.Group()
torpedos2 = pygame.sprite.Group()
torpedos = [None, None]
torpedoPool = []
explosions = pygame.sprite.Group()
def newTorpedo(velocity, player):
if len(torpedoPool) == 0:
return torpedo.Torpedo(velocity,player,layers)
else:
t = torpedoPool.pop()
t.reinit(velocity,player)
return t
# Fill background
background = pygame.Surface(screen.get_size())
background = background.convert()
background.fill((0,0,0))
layers.draw(background)
splash, _ = resources.load_png("OpeningSplash.png")
win_screen = {}
win_screen['cross'], _ = resources.load_png("WinCross.png")
win_screen['crescent'], _ = resources.load_png("WinCrescent.png")
win_screen['draw'], _ = resources.load_png("Draw.png")
# Blit everything to the screen
screen.blit(background, (0, 0))
pygame.display.flip()
# Initialise clock
clock = pygame.time.Clock()
# Initialise torpedo timer
timer = [-leadTime] # Length one array so it can be captured by closure
def reset():
player1.reinit()
player2.reinit()
torpedoPool.extend(torpedos1)
torpedos1.empty()
torpedoPool.extend(torpedos2)
torpedos2.empty()
explosions.empty()
torpedos[0] = None
torpedos[1] = None
timer[0] = -leadTime
state = "start"
cinematic = False
cin_timer = 0
startsound.play()
while 1:
dt = clock.tick(1000) / 1000.0
if state == "start":
for event in pygame.event.get():
if event.type == QUIT:
return
elif event.type == KEYDOWN or event.type == JOYBUTTONDOWN:
state = "run"
player1.setLife(3)
player2.setLife(3)
screen.blit(splash, (0,0))
elif state == "run":
if dt > 0.1:
dt = 0.1
if cinematic:
cin_timer -= dt
dt *= 0.05
if cin_timer <= 0:
cinematic = False
reset()
if player2.lives <= 0:
if player1.lives > 0:
winner = player1.faction
winsound.play()
state = "end"
else:
winner = "draw"
losesound.play()
state = "end"
elif player1.lives <= 0:
winner = player2.faction
winsound.play()
state = "end"
continue
else:
mindist = 1000**2
for t in torpedos1:
d = (t.rect.left - player2.rect.centerx - 23)**2 + (t.rect.centery - player2.rect.centery - 15)**2
if d < mindist:
mindist = d
d = (t.rect.left - player2.rect.centerx + 8)**2 + (t.rect.centery - player2.rect.centery - 15)**2
if d < mindist:
mindist = d
for t in torpedos2:
d = (t.rect.right - player1.rect.centerx + 23)**2 + (t.rect.centery - player1.rect.centery - 15)**2
if d < mindist:
mindist = d
d = (t.rect.right - player1.rect.centerx - 8)**2 + (t.rect.centery - player1.rect.centery - 15)**2
if d < mindist:
mindist = d
if mindist < 20**2:
dt *= 0.05
elif mindist < 100**2:
dt *= 0.05 + 0.95 * (mindist - 20.0**2) / (100.0**2 - 20.0**2)
for event in pygame.event.get():
if event.type == QUIT:
return
elif event.type == KEYDOWN:
if event.key == K_ESCAPE:
reset()
state = "start"
continue
elif not cinematic:
if event.key == K_o:
player1.up()
#bloopsound.play()
elif event.key == K_l:
player1.down()
#bloopsound.play()
elif event.key == K_i:
player1.torpedoUp()
elif event.key == K_k:
player1.torpedoDown()
elif event.key == K_w:
player2.up()
#bloopsound.play()
elif event.key == K_s:
player2.down()
#bloopsound.play()
elif event.key == K_q:
player2.torpedoUp()
elif event.key == K_a:
player2.torpedoDown()
elif event.type == JOYBUTTONDOWN:
if event.button == 6:
reset()
state = "start"
continue
elif not cinematic:
if event.joy == 0:
if event.button == 0:
player1.down()
elif event.button == 1:
player1.up()
elif event.button == 2:
player1.torpedoDown()
elif event.button == 3:
player1.torpedoUp()
elif event.joy == 1:
if event.button == 0:
player2.down()
elif event.button == 1:
player2.up()
elif event.button == 2:
player2.torpedoDown()
elif event.button == 3:
player2.torpedoUp()
if not cinematic:
timer[0] += dt
if timer[0] >= loadTime or timer[0] < 0:
if torpedos[0] == None:
torpedos[0] = newTorpedo([-torpedoSpeed,0],player1)
torpedos1.add(torpedos[0])
if torpedos[1] == None:
torpedos[1] = newTorpedo([torpedoSpeed,0],player2)
torpedos2.add(torpedos[1])
if timer[0] >= thrustTime:
torpedos[0].power = 2
torpedos[1].power = 2
if not pewChannel.get_busy():
pewChannel.play(pewsound)
if timer[0] > torpedoTime:
torpedos[0].locked = False
torpedos[0] = None
torpedos[1].locked = False
torpedos[1] = None
timer[0] -= torpedoTime
elif timer[0] < 0:
torpedos[0].power = 0
torpedos[1].power = 0
else:
power = int((timer[0] - loadTime) * 2.0 / (thrustTime - loadTime))
torpedos[0].power = power
torpedos[1].power = power
screen.blit(background, (0,0))
torpedos1.update(dt)
torpedos2.update(dt)
delete = [t for t in torpedos1 if not t.rect.colliderect(screenRect)]
for t in delete:
torpedoPool.append(t)
torpedos1.remove(t)
delete = [t for t in torpedos2 if not t.rect.colliderect(screenRect)]
for t in delete:
torpedoPool.append(t)
torpedos2.remove(t)
playersprite.update(dt)
collisions = pygame.sprite.spritecollide(player1,torpedos2,True,pygame.sprite.collide_mask)
if collisions:
for c in collisions:
explosions.add(explosion.Explosion(c.rect.midright))
torpedoPool.extend(collisions)
player1.markHit()
if not cinematic:
explodesound.play()
cinematic = True
cin_timer = 2.0
collisions = pygame.sprite.spritecollide(player2,torpedos1,True,pygame.sprite.collide_mask)
if collisions:
for c in collisions:
explosions.add(explosion.Explosion(c.rect.midleft))
torpedoPool.extend(collisions)
player2.markHit()
if not cinematic:
explodesound.play()
cinematic = True
cin_timer = 2.0
explosions.update(dt)
playersprite.draw(screen)
torpedos1.draw(screen)
torpedos2.draw(screen)
explosions.draw(screen)
scoresprite.draw(screen)
elif state == "end":
for event in pygame.event.get():
if event.type == QUIT:
return
elif event.type == KEYDOWN or event.type == JOYBUTTONDOWN:
state = "start"
continue
screen.blit(win_screen[winner], (0,0))
pygame.display.flip()
#print('added a rock')
########################
# Check for collisions #
########################
# Enemies
for enemy in enemies.enemies:
# Hit by bullets
for bullet in ship.bullets:
GameUtility.CheckCollide(enemy, bullet)
# Hit by laser
for laser in ship.lasers:
GameUtility.CheckCollide(enemy, laser)
# If they died, remove from array and drop powerup
if (enemy.dead == True):
enemies.enemies.remove(enemy)
boom = explosion.Explosion(enemy.x + enemy.width,
enemy.y + enemy.height)
explosions.append(boom)
if (random.randint(1, 10) == 10):
pup = PowerUps.PowerUp(enemy.x + enemy.width,
enemy.y + enemy.height)
powerups.append(pup)
# Powerup collection by ship
for p in powerups:
GameUtility.CheckCollide(p, ship)
###############
# Draw things #
###############
DISPLAYSURF.fill((0, 0, 0))
ship.draw()
