def create_ufo(ai_settings, screen, stats, ufos):
if random.randint(1, 8000) == 1 and len(ufos) == 0:
ufo = UFO(ai_settings, screen)
ufo.x = 0
ufo.rect.x = ufo.x
ufos.add(ufo)
ai_settings.oscillation.play()
def reset(self):
self.start_time = datetime.now()
self.level_start = datetime.now()
self.pass_through = 0
self.fast_ball = 0
self.grab_ball = 0
self.score = 0
self.win = False
self.pause_time = 0
self.lives = LIVES
self.balls = []
self.paddle = Paddle(65, 29, 8, 0)
self.bricks = []
self.powerups = []
self.bullets = []
self.ufo = UFO(65, 1, 8, 0)
self.bombs = []
self.level = 1
self.ufo_count = 0
self.balls.append(Ball(69, 28, -1, -1))
self.screen.reset_screen()
self.update_screen()
self.screen.print_game_screen()
self.check_powerup_times()
self.print_meta()
def create_ufo(ai_settings, screen, ufos):
ufo = UFO(ai_settings, screen)
ufo_width = ufo.rect.width
ufo.x = ufo_width + 2 * ufo_width
ufo.rect.x = ufo.x
ufo.rect.y = ufo.rect.height + 2 * ufo.rect.height
ufos.add(ufo)
def create_ufo(g_set, screen, ufos, no_ufo, row_no):
for ufo_no in range(no_ufo):
ufo = UFO(g_set, screen)
ufo.x = ufo.rect.width + 2 * ufo.rect.width * ufo_no
ufo.rect.x = ufo.x
ufo.rect.y = ufo.rect.height + 2 * ufo.rect.height * row_no
ufos.add(ufo)
def _create_ufo(self):
if not self.stats.game_active:
return
if self.ufo is None and random.randint(0, 5) == 2:
self.ufo = UFO(self, int(self.settings.score_values[2] * random.randint(3, 9) / 1.5))
self.ufo.rect.y = int(self.settings.screen_height * random.randint(15, 75) / 100)
if not self._soundmananger.getinstance().getufosoundactive():
self._soundmananger.getinstance().playufosound()
def small_reset(self):
self.pass_through = 0
self.grab_ball = 0
self.fast_ball = 0
self.balls = []
self.paddle = Paddle(65, 29, 8, 0)
self.powerups = []
self.bullets = []
self.ufo = UFO(65, 1, 8, 0)
self.bombs = []
self.balls.append(Ball(69, 28, -1, -1))
self.screen.reset_screen()
self.update_screen()
self.screen.print_game_screen()
self.check_powerup_times()
self.print_meta()
def __init__(self):
self.scores = HighScore()
self.ai_settings = Settings()
self.screen = pygame.display.set_mode((self.ai_settings.screen_width, self.ai_settings.screen_height))
pygame.display.set_caption("Alien Invasion")
self.sounds = Sound()
self.play_button = Button(self.screen, pygame.image.load('images/play_btn.png'), 850, 400)
self.high_score_button = Button(self.screen, pygame.image.load('images/high_score_btn.png'), 850, 600)
self.menu_bg = Button(self.screen,
pygame.image.load('images/menu.png'), self.ai_settings.screen_width / 2, self.ai_settings.screen_height / 2)
self.stats = GameStats(self.ai_settings, self.scores)
self.sb = Scoreboard(self.ai_settings, self.screen, self.sounds, self.stats)
self.ship = Ship(self.ai_settings, self.screen, self.sounds)
self.bullets = Group()
self.alien_bullets = Group()
self.aliens = Group()
self.ufo = UFO(self.ai_settings, self.screen, self.sounds)
self.barriers = Group()
self.smokes = Group()
self.inactive = 240
gf.create_fleet(self.ai_settings, self.screen, self.sounds, self.aliens)
gf.create_barriers(self.ai_settings, self.screen, self.barriers)
# timers used for animation and event checking
self.alien_timer = Timer(self.ai_settings.alien_frame_factor)
self.smoke_timer = Timer(self.ai_settings.smoke_timer)
self.ship_timer = Timer(self.ai_settings.ship_timer)
self.ufo_timer = Timer(self.ai_settings.alien_frame_factor * 5)
self.bullet_delay = 0
self.stats.game_active = True
def run_game():
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("Alien Invasion")
play_button = Button(ai_settings, screen, "PLAY")
stats = GameStats(ai_settings)
sb = Scoreboard(ai_settings, screen, stats)
ship = Ship(ai_settings, screen)
ufo = UFO(ai_settings, screen)
bullets = Group()
aliens = Group()
enemy_bullets = Group()
# Create the fleet of aliens
gf.create_fleet(ai_settings, screen, ship, aliens)
ai_settings.alien_number = 0
while True:
gf.check_events(ai_settings, screen, stats, sb, play_button, ship,
aliens, bullets)
if stats.game_active:
ship.update()
gf.update_bullets(ai_settings, screen, stats, sb, ship, aliens,
bullets, enemy_bullets, ufo)
gf.update_aliens(ai_settings, screen, stats, sb, ship, aliens,
bullets, enemy_bullets, ufo)
gf.update_ufo(ai_settings, ufo)
gf.update_screen(ai_settings, screen, stats, sb, ship, aliens, bullets,
play_button, enemy_bullets, ufo)
def create_random_ufo(ai_settings, screen):
"""randomly create ufo"""
ufo = None
if random.randrange(0, 100) <= 15:
ufo = UFO(ai_settings, screen)
time_stamp = pygame.time.get_ticks()
return time_stamp, ufo
def spawn_ufo(ai_settings, screen, ufo):
if random.randint(0, 1000) == 0 and ai_settings.show_game:
if len(ufo) == 0:
ai_settings.ufo_move = True
newUFO = UFO(ai_settings, screen)
ufo.add(newUFO)
else:
ai_settings.ufo_move = True
def create_random_ufo(ai_settings, screen):
"""Create a UFO 80% of the time and show up"""
ufo = None
# Set random timing to ufo 80% of the time
if random.randrange(0, 100) <= 80:
ufo = UFO(ai_settings, screen)
time_stamp = pygame.time.get_ticks()
return time_stamp, ufo
def check_bullet_alien_collisions(settings, screen, stats, sb, ship, aliens,
ufos, bullets, lasers):
"""Respond to bullet-alien collisions"""
# Remove any bullets and aliens that have colided
collisions = pygame.sprite.groupcollide(aliens, bullets, True, True)
ufo_collision = pygame.sprite.groupcollide(ufos, bullets, True, True)
if ufo_collision:
random_points = random.randint(100, 1000000) * settings.alien_points
stats.score += random_points
sb.prep_score()
check_high_score(stats, sb)
ufo = UFO(settings, screen)
ufos.add(ufo)
for ufo in ufo_collision:
ufo.print_point_values(random_points)
if collisions:
for alien in collisions:
alien.play_death_sound()
alien.play_death_animation()
stats.score += settings.alien_points * alien.multiplier
sb.prep_score()
check_high_score(stats, sb)
if len(aliens) == 0:
# If the entire fleet is destroyed, start a new level
bullets.empty()
lasers.empty()
ufos.empty()
settings.increase_speed()
# Increase level.
stats.level += 1
sb.prep_level()
pygame.mixer.music.stop()
pygame.mixer.music.load('music/Space Invaders - Do The Freak.mid')
pygame.mixer.music.play(-1, 0.0)
create_fleet(settings, screen, ship, aliens, ufos)
def check_ufo_spawn(self, screen, bullets, stats, sb):
for alien_explosion in self.alien_explosions:
alien_explosion.update()
if alien_explosion.frame_counter > 10:
self.alien_explosions.remove(alien_explosion)
if self.ufo:
self.ufo.update()
if self.ufo.rect.right < self.screen.get_rect().left:
self.ufo = None
else:
self.check_bullet_ufo_collision(bullets, stats, sb)
if pygame.time.get_ticks() > self.next_ufo_spawn:
self.last_ufo_spawn = self.next_ufo_spawn
self.next_ufo_spawn = pygame.time.get_ticks() + random.randrange(
10000, 20000)
self.ufo = UFO(screen)
def select_layout(stage: int, frame: Frame, paddle):
'''
returns the layout instance corresponding to the stage
'''
if stage == 1:
return LayoutStage1(frame)
elif stage == 2:
return LayoutStage2(frame)
elif stage == 3:
return LayoutStage3(frame)
elif stage == 4:
return LayoutStage4(frame)
else:
ly = LayoutStage5(frame)
UFO1 = UFO(paddle, frame)
return ly, UFO1
def create_fleet(settings, screen, ship, aliens, ufos):
"""Create a full fleet of aliens."""
# Create an alien and find the number of aliens in a row.
# Spacing between each alien is equal to one alien width.
alien = Alien(settings, screen)
number_aliens_x = get_number_aliens_x(settings, alien.rect.width)
number_rows = get_number_rows(settings, ship.rect.height,
alien.rect.height)
# Create the first row of aliens.
for row_number in range(number_rows):
for alien_number in range(number_aliens_x):
create_alien(settings, screen, aliens, alien_number, row_number)
if len(ufos) == 0:
ufo = UFO(settings, screen)
ufos.add(ufo)
def run_game():
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("Alien Invasion")
# play button
play_button = Button(ai_settings, screen, "PLAY")
hs = Highscorelist(ai_settings, screen, "HIGHSCORES")
# Create an instance to store game statistics
stats = GameStats(ai_settings)
sb = Scoreboard(ai_settings, screen, stats)
ship = Ship(ai_settings, screen)
bullets = Group()
#ebullets = Group()
aliens = Group()
alien = Alien(ai_settings, screen)
ufos = Group()
ufo = UFO(ai_settings, screen)
# Create the fleet of aliens
gf.create_fleet(ai_settings, screen, ship, aliens)
while True:
gf.check_events(ai_settings, screen, stats, sb, play_button, ship,
aliens, bullets, hs)
if stats.game_active:
ship.update()
gf.update_bullets(ai_settings, screen, stats, sb, ship, aliens,
bullets, ufos)
#gf.update_ebullets(ai_settings, screen, stats, sb, ship, aliens)
gf.update_aliens(ai_settings, stats, screen, sb, ship, aliens,
bullets)
gf.update_ufo(ai_settings, screen, stats, sb, ship, bullets, ufos)
gf.update_screen(ai_settings, screen, stats, sb, ship, aliens, bullets,
play_button, hs, ufos)
class Game:
def __init__(self, width, height):
self.paddle = Paddle(width, height)
self.screen = Screen(width, height)
self.bricks = get_bricks(width, height, 1)
self.final_boss = False
self.ufo = None
self.height = height
self.width = width
self.balls: [Ball] = [
Ball(max_width=width,
max_height=height,
x=width // 2,
y=height // 2)
]
self.ball_on_paddle = True
self.powerups = []
self.score = 0
self.lives = 3
self.time = time.time()
self.active_powerups: [PowerUp] = []
self.thru_ball = False
self.grab_ball = False
self.game_level = 1
self.time_attack = False
self.pending_defense = False
self.paddle_bullets: [Bullet] = []
os.system('clear')
def input(self, inp):
if inp == ' ':
self.ball_on_paddle = False
self.paddle.move(inp)
def spawn_powerup(self, x, y, ball, rigged=False):
if random.randint(0, 0) == 0 and not self.final_boss:
self.powerups.append(
createPowerUp(self.width, self.height, x, y,
ball.speed_x * 0.5, ball.speed_y * 0.5))
if self.final_boss and rigged:
self.powerups.append(
createPowerUp(self.width, self.height, x, y, 0, 1,
rigged=True))
def check_paddle_collision(self, obj: GameObject):
ball_x, ball_y, _, _, _ = obj.get_dim()
paddle_x, paddle_y, paddle_show, _, _ = self.paddle.get_dim()
paddle_center = paddle_x + len(paddle_show) / 2
for i in range(len(paddle_show)):
paddle_part_x = paddle_x + i
dist_x = ball_x - paddle_part_x
dist_y = ball_y - paddle_y
if dist_x == 0 and dist_y == -1:
if isinstance(obj, Ball):
if obj.get_speed()[1] < 0:
continue
paddle_dist_center = ball_x - paddle_center
ratio_dist = abs(2 * paddle_dist_center / len(paddle_show))
new_x_speed = speed_x.flat[np.abs(speed_x -
ratio_dist).argmin()]
if ball_x < paddle_center:
new_x_speed = -new_x_speed
obj.set_speed_x(new_x_speed)
obj.reverse_y_speed()
if self.grab_ball:
self.ball_on_paddle = True
if self.time_attack and not self.final_boss:
for idd, _ in enumerate(self.bricks):
self.bricks[idd].y += 1
if self.final_boss:
if (self.ufo.health == 5 or self.ufo.health
== 8) and self.pending_defense:
self.bricks += self.ufo.spawn_defense(
self.ufo.health // 3)
self.pending_defense = False
# log(str(new_x_speed))
return
if isinstance(obj, PowerUp):
return -1
def brick_ball_collision(self):
colz_ufo = False
for idx2 in range(len(self.bricks)):
for idx, ball in enumerate(self.balls):
collision = objects_collision_vh(ball, self.bricks[idx2])
if collision != Collision.NOPE:
colz_ufo = self.bricks[idx2].ufo
if not self.thru_ball:
new_strength = self.bricks[idx2].got_hit()
if new_strength <= 0:
self.score += 1
self.spawn_powerup(self.bricks[idx2].get_dim()[0],
self.bricks[idx2].get_dim()[1],
ball)
if collision == Collision.VERTICAL:
self.balls[idx].reverse_y_speed()
if collision == Collision.HORIZONTAL:
self.balls[idx].reverse_x_speed()
log("collision " + collision.name + "\n")
else:
self.bricks[idx2].strength = 0
self.score += 1
self.spawn_powerup(self.bricks[idx2].get_dim()[0],
self.bricks[idx2].get_dim()[1],
ball)
self.bricks = [brick for brick in self.bricks if brick.strength > 0]
for idx2 in range(len(self.bricks)):
for idx, ball in enumerate(self.balls):
collision = objects_collision_d(ball, self.bricks[idx2])
if collision != Collision.NOPE:
colz_ufo = self.bricks[idx2].ufo
if not self.thru_ball:
new_strength = self.bricks[idx2].got_hit()
if new_strength <= 0:
self.score += 1
self.spawn_powerup(self.bricks[idx2].get_dim()[0],
self.bricks[idx2].get_dim()[1],
ball)
if collision == Collision.DIAGONAL:
self.balls[idx].reverse_x_speed()
self.balls[idx].reverse_y_speed()
log("collision " + collision.name + "\n")
else:
self.bricks[idx2].strength = 0
self.score += 1
self.spawn_powerup(self.bricks[idx2].get_dim()[0],
self.bricks[idx2].get_dim()[1],
ball)
self.bricks = [brick for brick in self.bricks if brick.strength > 0]
if self.final_boss and colz_ufo:
self.ufo.health -= 1
if self.ufo.health == 5 or self.ufo.health == 8:
self.pending_defense = True
def brick_bullet_collision(self):
for idx2 in range(len(self.bricks)):
for idx, bullet in enumerate(self.paddle_bullets):
collision = objects_collision_vh(bullet, self.bricks[idx2])
if collision != Collision.NOPE:
new_strength = self.bricks[idx2].got_hit()
if new_strength <= 0:
self.score += 1
self.spawn_powerup(self.bricks[idx2].get_dim()[0],
self.bricks[idx2].get_dim()[1],
self.balls[0])
self.paddle_bullets[idx].dead = True
self.bricks = [brick for brick in self.bricks if brick.strength > 0]
def check_collision(self):
# check if ball collided with bricks
self.brick_ball_collision()
log("dickkk " + str(len(self.paddle_bullets)))
self.brick_bullet_collision()
self.paddle_bullets = [
bullet for bullet in self.paddle_bullets if not bullet.dead
]
# check if ball collided with paddle
[self.check_paddle_collision(ball) for ball in self.balls]
# check if a powerup collided with paddle
new_powerups = []
for powerup in self.powerups:
if self.check_paddle_collision(powerup) == -1:
self.active_powerups = [
pw for pw in self.active_powerups
if powerup.get_type() != pw.get_type()
]
if powerup.get_type(
) == PowerUpType.SHRINK or powerup.get_type(
) == PowerUpType.EXP:
self.active_powerups = [
pw for pw in self.active_powerups if pw.get_type()
not in [PowerUpType.EXP, PowerUpType.SHRINK]
]
powerup.set_time(time.time())
self.active_powerups.append(powerup)
powerup.power_up_activate(self)
log("activated powerup " + powerup.type.name + "\n")
# log(str(len(self.balls)))
else:
new_powerups.append(powerup)
self.powerups = new_powerups
def play(self):
if self.final_boss and self.ufo.health == 0:
return -2, self.score + 200, int(time.time() - self.time)
if self.lives <= 0:
return -1, self.score, int(time.time() - self.time)
# active powerups
new_active = []
for pw in self.active_powerups:
if time.time() - pw.time > 10:
pw.power_up_deactivate(self)
else:
new_active.append(pw)
self.active_powerups = new_active
# move bullets
for bullet in self.paddle_bullets:
bullet.move()
self.paddle_bullets = [
bullet for bullet in self.paddle_bullets if not bullet.dead
]
# bricks
for brick in self.bricks:
brick.change()
if brick.y == self.paddle.y:
return -1, self.score, int(time.time() - self.time)
# move balls
alive_ball = False
for ball in self.balls:
if ball.move() != -1:
alive_ball = True
else:
ball.dead = True
self.balls = [ball for ball in self.balls if not ball.dead]
if not alive_ball:
self.lives -= 1
self.balls.append(Ball(self.width, self.height, 0, 0))
self.ball_on_paddle = True
for powerup in self.active_powerups:
powerup.power_up_deactivate(self)
self.active_powerups = []
if self.lives == 0:
return -1, self.score, int(time.time() - self.time)
# move powerups
new_powerups = []
for powerup in self.powerups:
if powerup.move() != -1:
new_powerups.append(powerup)
self.powerups = new_powerups
# check for collisions
self.check_collision()
# ball on paddle
paddle_x, paddle_y, paddle_show, _, _ = self.paddle.get_dim()
paddle_center = paddle_x + len(paddle_show) / 2
if self.ball_on_paddle:
[
ball.set_x_y(int(paddle_center), paddle_y - 1)
for ball in self.balls
]
# set all the sprites and render
if self.final_boss:
self.ufo.move(paddle_center)
self.screen.set_sprites(paddle=self.paddle,
bricks=self.bricks,
balls=self.balls,
powerups=self.powerups,
bullets=self.paddle_bullets)
cursor_to_top()
pw_time = 0
for pw in self.active_powerups:
if pw.get_type() == PowerUpType.BULLET:
pw_time = time.time() - pw.time
ufo_health = -1
if self.final_boss:
ufo_health = self.ufo.health
self.screen.render(self.time, self.score, self.lives, self.game_level,
pw_time, ufo_health)
# get bullets
new_b = self.paddle.gen_bullets()
if new_b is not None:
self.paddle_bullets = new_b
if self.final_boss and self.ufo.bombTime():
self.spawn_powerup(random.randint(self.ufo.x_start,
self.ufo.x_end),
self.ufo.y + 5,
self.balls[0],
rigged=True)
# self.spawn_powerup(random.randint(self.ufo.x_start, self.ufo.x_end), self.ufo.y + 5, self.balls[0],
# rigged=True)
self.ufo.last_bomb = time.time()
# check for time attack
if not self.time_attack and time.time() - self.time > 5:
self.time_attack = True
# check for level end
level_end = True
for brick in self.bricks:
if brick.strength != 4:
level_end = False
if level_end:
self.game_level += 1
if self.game_level == 4:
return -2, self.score, int(time.time() - self.time)
else:
self.powerups = []
for powerup in self.active_powerups:
powerup.power_up_deactivate(self)
self.active_powerups = []
if self.game_level == 3:
self.final_boss = True
self.ufo = UFO(self.width, self.height, 0, 0)
self.bricks = self.ufo.art_to_bricks()
else:
self.bricks = get_bricks(self.width, self.height,
self.game_level)
self.ball_on_paddle = True
self.time = time.time()
self.time_attack = False
self.balls = [self.balls[0]]
log("level upped")
return 0, 0, 0
def genUFO(speed, x):
ufo = UFO(speed, GROUND_POS, all_sprites_list, bomb_list)
ufo.rect.x = x
ufo.rect.y = random.randrange(30, 59)
all_sprites_list.add(ufo)
ufo_sprites_list.add(ufo)
def run_game():
# Initialize pygame, settings, and screen object.
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode((ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("Alien Invasion")
# Make the play button.
play_button = Button(ai_settings, screen, "Play")
highscore_button = Button(ai_settings, screen, 'High Score')
hs_file = open("score.txt", "r")
ai_settings.hs = int(hs_file.read())
hs_file.close()
msgg = 'The high score is ' + str(ai_settings.hs)
score = Button(ai_settings, screen, msgg)
score.rect.centery += 150
score.msg_image_rect.center = score.rect.center
highscore_button.rect.centery += 80
highscore_button.msg_image_rect.center = highscore_button.rect.center
savescore = 0
space_invaders = Button(ai_settings, screen, "Space Invaders")
space_invaders.rect.centery -= 350
space_invaders.msg_image_rect.center = space_invaders.rect.center
s10 = Button(ai_settings, screen, " = 10")
s10.rect.centerx = 1200 / 2 + 100
s10.rect.top = 80
s10.msg_image_rect.center = s10.rect.center
s20 = Button(ai_settings, screen, " = 20")
s20.rect.centerx = 1200 / 2 + 100
s20.rect.top = 140
s20.msg_image_rect.center = s20.rect.center
s30 = Button(ai_settings, screen, " = 30")
s30.rect.centerx = 1200 / 2 + 100
s30.rect.top = 200
s30.msg_image_rect.center = s30.rect.center
# Create an instance to store game statistics and create a scoreboard.
stats = GameStats(ai_settings)
sb = Scoreboard(ai_settings, screen, stats)
stats.high_score = ai_settings.hs
# Make a ship, a group of bullets, and a group of aliens.
ship = Ship(ai_settings, screen)
ufo = UFO(ai_settings, screen)
bullets = Group()
alienbullets = Group()
aliens = Group()
alien = Alien(ai_settings, screen)
# Create the fleet of aliens.
gf.create_fleet(ai_settings, screen, ship, aliens)
# Music
music1 = pygame.mixer.Sound('audio/deep1.wav')
music2 = pygame.mixer.Sound('audio/deep2.wav')
music3 = pygame.mixer.Sound('audio/deep3.wav')
# Start the main loop for the game.
while True:
if ai_settings.hs < stats.high_score and stats.game_active:
ai_settings.hs = stats.high_score
msgg = 'The high score is ' + str(ai_settings.hs)
score = Button(ai_settings, screen, msgg)
score.rect.centery += 150
score.msg_image_rect.center = score.rect.center
gf.check_events(ai_settings, screen, stats, sb, play_button, ship,
aliens, bullets, savescore, highscore_button, msgg)
if stats.game_active:
ship.update()
ufo.update()
gf.update_bullets(ai_settings, screen, stats, sb, ship, aliens,
bullets, alienbullets, play_button, ufo)
gf.update_aliens(ai_settings, screen, stats, sb, ship, aliens, bullets, play_button, alienbullets)
gf.update_screen(ai_settings, screen, stats, sb, ship, aliens,
bullets, play_button, highscore_button, score, alien, space_invaders, s10, s20, s30, music1,
music2, music3, alienbullets, ufo)
def create_ufo(ai_settings, screen, ufo):
interval = random.randint(0, 500)
if interval == 10:
ufo_random = UFO(ai_settings=ai_settings, screen=screen)
if len(ufo) < 1:
ufo.add(ufo_random)
def update_UFO(ai_settings, screen, stats, sb, ship, bullets, UFO):
UFO.update()
check_bullet_UFO_collision(ai_settings, screen, stats, sb, ship, bullets,
UFO)
def create_ufo2(ai_settings, screen, ufo):
ship = UFO(ai_settings, screen)
ufo.add(ship)
def run_game():
pygame.init()
clock = pygame.time.Clock()
highscores = HighScore()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("Alien Invasion")
sounds = Sound()
play_button = Button(screen, pygame.image.load('images/play_btn.png'), 850,
400)
high_score_button = Button(screen,
pygame.image.load('images/high_score_btn.png'),
850, 600)
menu_bg = Button(screen, pygame.image.load('images/menu.png'),
ai_settings.screen_width / 2,
ai_settings.screen_height / 2)
stats = GameStats(ai_settings, highscores)
sb = Scoreboard(ai_settings, screen, sounds, stats)
ship = Ship(ai_settings, screen, sounds)
bullets = Group()
alien_bullets = Group()
aliens = Group()
ufo = UFO(ai_settings, screen, sounds)
barriers = Group()
smokes = Group()
gf.create_fleet(ai_settings, screen, sounds, aliens)
gf.create_barriers(ai_settings, screen, barriers)
# timers used for animation and event checking
alien_timer = Timer(ai_settings.alien_frame_factor)
smoke_timer = Timer(8)
ship_timer = Timer(4)
ufo_timer = Timer(ai_settings.alien_frame_factor * 5)
while True:
clock.tick(60)
gf.check_events(ai_settings, screen, sounds, stats, sb, highscores,
play_button, high_score_button, ship, aliens, bullets,
barriers, alien_bullets, smokes)
if stats.game_active:
gf.update_timers(alien_timer, ufo_timer, ship_timer, smoke_timer)
gf.update_ship(stats, sb, highscores, ship, aliens, ufo, bullets,
alien_bullets, ship_timer, alien_timer)
if not ship.hit:
gf.update_bullets(ai_settings, screen, sounds, stats, sb, ship,
aliens, ufo, bullets, barriers,
alien_bullets, smokes, alien_timer,
ufo_timer, smoke_timer)
gf.update_aliens(ai_settings, screen, sounds, ship, aliens,
barriers, alien_bullets, alien_timer)
gf.update_ufo(ufo, ufo_timer)
gf.update_smokes(smokes, smoke_timer)
gf.update_screen(ai_settings, screen, stats, sb, ship, aliens, ufo,
bullets, menu_bg, play_button, high_score_button,
barriers, alien_bullets, smokes)
class GameScene(Scene):
def __init__(self, director, background=(0, 0, 0)):
super().__init__(director)
self.background = background
self.ship = Ship(director.screen)
self.ship_bullets_allowed = 3
self.laser_sound = pygame.mixer.Sound('assets/sounds/laser.ogg')
self.alein_explosion = pygame.mixer.Sound(
'assets/sounds/alien_explosion.ogg')
self.ship_explosion = pygame.mixer.Sound(
'assets/sounds/ship_explosion.ogg')
self.ufo_sound = pygame.mixer.Sound('assets/sounds/ufo.ogg')
self.background_sound = pygame.mixer.Sound(
'assets/sounds/background.ogg')
self.gg_sound = pygame.mixer.Sound('assets/sounds/game_over.ogg')
self.bullets = Group()
self.fleet = Group()
self.explosions = Group()
self.bunkers = Group()
self.fleet_drop_speed = 10
self.rows = 8
self.cols = self.get_number_aliens_x()
self.game_stats = GameStats(director)
self.old_ticks = pygame.time.get_ticks()
self.ufo_time = random.randint(15, 30) * 1000
self.ufo_ticks = pygame.time.get_ticks()
self.ufo = None
def exit(self):
self.game_stats.save_scores()
def reset(self, alien_speed=0.2):
self.game_stats.reset()
self.ship_bullets = 0
self.alien_speed = alien_speed
self.number_of_bunkers = 5
self.bullets.empty()
self.fleet.empty()
self.bunkers.empty()
self.create_fleet()
self.create_bunkers()
self.ship.reset()
self.game_stats.save_scores()
self.ufo_time = random.randint(15, 30) * 1000
self.ufo_ticks = pygame.time.get_ticks()
self.ufo = None
self.background_sound.play(-1)
def get_number_aliens_x(self):
alien = Alien(self.director.screen)
available_space_x = self.director.screen.get_rect().width - 2 * \
alien.rect.width
number_aliens_x = int(available_space_x / (2 * alien.rect.width))
return number_aliens_x
def create_alien(self, alien_number, row_number, alien_type):
alien = Alien(self.director.screen,
alien_type=alien_type,
speed_factor=self.alien_speed)
alien_width = alien.rect.width
alien.x = alien_width + 2 * alien_width * alien_number
alien.rect.x = alien.x
alien.rect.y = alien.rect.height + 2 * alien.rect.height * \
row_number
self.fleet.add(alien)
def create_fleet(self):
alien_type = 0
change_type = self.rows / 4
for row_number in range(self.rows):
if int(row_number % change_type) == 0:
alien_type += 1
for alien_number in range(self.cols):
self.create_alien(alien_number, row_number, alien_type)
def create_bunkers(self):
space = int(
(self.director.screen.get_rect().right -
((self.number_of_bunkers - 1) * 56)) / self.number_of_bunkers)
x = space
for i in range(self.number_of_bunkers):
self.bunkers.add(Bunker(self.director.screen, x))
x += space
def fire_bullet(self, rect, bullet_type="ship"):
if bullet_type == "ship":
if self.ship_bullets < self.ship_bullets_allowed:
new_bullet = Bullet(self.director.screen, rect.centerx,
rect.top)
self.bullets.add(new_bullet)
self.laser_sound.play()
self.ship_bullets += 1
else:
new_bullet = Bullet(self.director.screen, rect.centerx, rect.top,
(200, 0, 0), 1)
self.bullets.add(new_bullet)
self.laser_sound.play()
def keydown(self, key):
if key == pygame.K_RIGHT or key == pygame.K_d:
self.ship.moving_right = True
elif key == pygame.K_LEFT or key == pygame.K_a:
self.ship.moving_left = True
elif key == pygame.K_SPACE:
self.fire_bullet(self.ship.rect)
def keyup(self, key):
if key == pygame.K_RIGHT or key == pygame.K_d:
self.ship.moving_right = False
elif key == pygame.K_LEFT or key == pygame.K_a:
self.ship.moving_left = False
def create_explosion(self, center, character_type="alien"):
new_explosion = Explosion(self.director.screen, center)
self.explosions.add(new_explosion)
if character_type == "alien":
self.alein_explosion.play()
else:
self.ship_explosion.play()
def change_fleet_direction(self):
for alien in self.fleet.sprites():
alien.direction *= -1
alien.rect.y += self.fleet_drop_speed
def check_explosions(self):
for explosion in self.explosions.sprites():
if explosion.explosion == 8:
self.explosions.remove(explosion)
def check_fleet_edges(self):
for alien in self.fleet.sprites():
if alien.check_edges():
self.change_fleet_direction()
break
def check_fleet_bottom(self):
screen_bottom = self.director.screen.get_rect().bottom
if self.fleet.sprites()[-1].rect.bottom > screen_bottom:
self.lose_ship()
def check_bullets(self):
screen_height = self.director.screen.get_rect().height
for bullet in self.bullets.sprites():
if bullet.speed_factor < 0:
if bullet.rect.bottom <= 0:
self.bullets.remove(bullet)
self.ship_bullets -= 1
else:
for alien in self.fleet.sprites():
if bullet.rect.colliderect(alien.rect):
self.game_stats.score += alien.alien_type * 10
self.create_explosion(alien.rect.center)
self.fleet.remove(alien)
self.bullets.remove(bullet)
self.ship_bullets -= 1
self.alein_explosion.play()
if self.ufo is not None:
if bullet.rect.colliderect(self.ufo.rect):
self.game_stats.score += random.randint(1, 5) * \
1000
self.create_explosion(self.ufo.rect.center)
self.ship_bullets -= 1
self.alein_explosion.play()
self.ufo = None
self.ufo_sound.stop()
for bunker in self.bunkers:
if bunker.collide(bullet.rect):
self.bullets.remove(bullet)
self.ship_explosion.play()
self.ship_bullets -= 1
if not bunker.standing():
self.bunkers.remove(bunker)
else:
if bullet.rect.top >= screen_height:
self.bullets.remove(bullet)
elif bullet.rect.colliderect(self.ship.rect):
self.create_explosion(self.ship.rect.center)
self.bullets.remove(bullet)
self.ship_explosion.play()
self.lose_ship()
for bunker in self.bunkers:
if bunker.collide(bullet.rect):
self.bullets.remove(bullet)
self.ship_explosion.play()
if not bunker.standing():
self.bunkers.remove(bunker)
def move_aliens_top(self):
alien = Alien(self.director.screen,
alien_type=self.fleet.sprites()[0].alien_type)
top_y = alien.rect.height
prev_alien_y = self.fleet.sprites()[0].rect.y
for alien in self.fleet.sprites():
if (alien.rect.y > prev_alien_y):
top_y += 2 * alien.rect.height
prev_alien_y = alien.rect.y
alien.rect.y = top_y
def lose_ship(self):
if self.game_stats.ships_left > 0:
self.game_stats.ships_left -= 1
self.move_aliens_top()
self.ship.reset()
else:
self.gg_sound.play()
self.background_sound.stop()
self.director.set_scene("menu")
def update(self):
if len(self.fleet.sprites()) == 0:
self.ufo_sound.stop()
self.background_sound.stop()
self.alien_speed += 0.2
self.reset(self.alien_speed)
print(len(self.fleet.sprites()))
if self.ufo is not None:
if self.ufo.check_edges():
self.ufo = None
self.ufo_sound.stop()
self.ufo_time = random.randint(15, 30) * 1000
self.ufo_ticks = pygame.time.get_ticks()
else:
self.ufo.update()
else:
if pygame.time.get_ticks() - self.ufo_ticks >= \
self.ufo_time:
self.ufo = UFO(self.director.screen, self.alien_speed * 2)
self.ufo_sound.play(-1)
self.check_explosions()
self.explosions.update()
self.ship.update()
self.check_fleet_edges()
self.check_fleet_bottom()
self.fleet.update()
if len(self.fleet.sprites()) > 0 and \
pygame.time.get_ticks() - self.old_ticks >= \
10000 / self.game_stats.level:
fleet = self.fleet.sprites()
self.fire_bullet(fleet[random.randint(0,
len(fleet) - 1)].rect,
"alien")
self.old_ticks = pygame.time.get_ticks()
self.check_bullets()
self.bullets.update()
if len(self.fleet.sprites()) > 0 and \
self.fleet.sprites()[-1].rect.bottom >= \
self.bunkers.sprites()[0].top_left_triangle_rect.top:
for alien in self.fleet.sprites():
for bunker in self.bunkers.sprites():
if bunker.collide(alien.rect):
self.create_explosion(alien.rect.center)
self.fleet.remove(alien)
self.alein_explosion.play()
if not bunker.standing():
self.bunkers.remove(bunker)
self.game_stats.update()
if self.game_stats.ships == 0:
self.ufo_sound.stop()
self.background_sound.stop()
def render(self):
self.director.screen.fill(self.background)
self.game_stats.render()
for explsion in self.explosions.sprites():
explsion.render()
self.ship.render()
for bullet in self.bullets.sprites():
bullet.render()
for alien in self.fleet.sprites():
alien.render()
for bunker in self.bunkers.sprites():
bunker.render()
if self.ufo is not None:
self.ufo.render()
def run():
# Initialization
pygame.init()
pygame.mixer.init(frequency=44100, size=-16, channels=2, buffer=4096)
pygame.mixer.music.load("Sounds/ominous_ambience.wav")
pygame.mixer.music.play(-1)
settings = Settings()
stats = GameStats(settings)
screen = pygame.display.set_mode(
(settings.screen_width, settings.screen_height))
pygame.display.set_caption("Alien Invasion")
play_button = Button(settings, screen, "Play")
bg_color = settings.bg_color
sb = Scoreboard(settings, screen, stats)
ship = Ship(screen, settings.ship_width, settings.ship_height)
bullets = Group()
alien_bullets = Group()
ufos = Group()
aliens = Group()
alien_explosions = Group()
gf.create_fleet(settings, screen, aliens)
clock = pygame.time.Clock()
# Game loop
running = True
while stats.running:
clock.tick(60)
gf.check_events(settings, screen, stats, sb, play_button, ship, aliens,
bullets)
if stats.active:
ship.update(settings)
if not ship.explode:
if ship.hit:
gf.ship_hit(settings, screen, stats, sb, ship, aliens,
bullets, alien_bullets)
ship.hit = False
ship.explode = False
else:
if random.randint(1, 1000) == 1000 and len(
ufos.sprites()) == 0:
ufo = UFO(settings, screen, settings.alien_width,
settings.alien_height)
ufos.add(ufo)
pygame.mixer.Sound(
"Sounds/cartoon_flying_ufo.wav").play()
gf.update_bullets(settings, screen, stats, sb, ship,
aliens, bullets, alien_bullets, ufos,
alien_explosions)
gf.update_aliens(settings, screen, stats, sb, ship, aliens,
bullets, alien_bullets, ufos,
alien_explosions)
# Draw objects
gf.update_screen(settings, screen, stats, sb, ship, aliens, bullets,
play_button, alien_bullets, ufos, alien_explosions)
sys.exit()
class AlienInvasion:
"""Overall class to manage game assets and behavior."""
def __init__(self):
"""Initialize the game, and create game resources."""
pygame.init()
self.settings = Settings()
self.screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
self.settings.screen_width = self.screen.get_rect().width
self.settings.screen_height = self.screen.get_rect().height
pygame.display.set_caption("Alien Invasion")
# Create an instance to store game statistics,
# and create a scoreboard.
self.stats = GameStats(self, self.settings)
self.sb = Scoreboard(self)
# Sprites
self.ship = Ship(self)
self.bullets = pygame.sprite.Group()
self.aliens = pygame.sprite.Group()
self.explosions = pygame.sprite.Group()
self.bunkers = pygame.sprite.Group()
self.alienbullets = pygame.sprite.Group()
# UFO variables
self.ufo = None
self.display_ufo_score = False
self.ufo_score = None
self.ufo_rect = None
self._create_fleet()
self._create_bunker_wall()
self._soundmananger = SoundManager()
# TODO: Use wait function to display ufo value on screen
"""
DEFINITION OF EVENTS:
a) '_update_frame_event': EVENTID=25, how often alien animations should be updated
b) '_update_explosion_frame_event': EVENTID=26, how often explosion animations should be updated
c) '_alien_shoot_event': EVENTID=27, how often the aliens have an opportunity to shoot
d) '_ufo_summon_event': EVENTID=28, how often the ufo has an opportunity to spawn
"""
self._update_frame_event = pygame.USEREVENT + 1
self._update_explosion_frame_event = pygame.USEREVENT + 2
self._alien_shoot_event = pygame.USEREVENT + 3
self._ufo_summon_event = pygame.USEREVENT + 4
pygame.time.set_timer(self._update_frame_event, 1000)
pygame.time.set_timer(self._update_explosion_frame_event, 200)
pygame.time.set_timer(self._alien_shoot_event, self.settings.current_fire_interval)
pygame.time.set_timer(self._ufo_summon_event, 10000)
# Make the Play button.
self.play_button = Button(self, "Play", (0, -50))
self.score_button = Button(self, "High Scores", (0, 50))
self.back_button = Button(self, "Main Menu", (0, 50))
def run_game(self):
"""Start the main loop for the game."""
# Game stats == false is here
while True:
self._check_events()
if self.stats.game_active:
self.ship.update()
self._update_bullets()
self._update_aliens()
self._update_screen()
else:
self._draw_main_menu()
def _check_events(self):
"""Respond to keypresses and mouse events."""
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
elif event.type == pygame.KEYDOWN:
self._check_keydown_events(event)
elif event.type == pygame.KEYUP:
self._check_keyup_events(event)
elif event.type == pygame.MOUSEBUTTONDOWN:
mouse_pos = pygame.mouse.get_pos()
self._check_play_button(mouse_pos)
self._check_score_button(mouse_pos)
elif event.type == self._update_frame_event:
self._update_frames()
elif event.type == self._update_explosion_frame_event:
self._update_explosion_frames()
elif event.type == self._alien_shoot_event:
self._alien_shoot()
elif event.type == self._ufo_summon_event:
self._create_ufo()
# Game start function
def _check_play_button(self, mouse_pos):
"""Start a new game when the player clicks Play."""
button_clicked = self.play_button.rect.collidepoint(mouse_pos)
if button_clicked and not self.stats.game_active:
# Reset the game settings.
self.settings.initialize_dynamic_settings()
# Make sure all sprites are destroyed if there was a previous game
self.bullets.empty()
self.bunkers.empty()
self.alienbullets.empty()
self.aliens.empty()
if self.ufo is not None:
self.ufo.kill()
if self._soundmananger.getinstance().getufosoundactive:
self._soundmananger.getinstance().stopufosound()
self.ufo = None
# Reset the game statistics.
self.stats.reset_stats(self.settings)
self.stats.game_active = True
self.sb.prep_score()
self.sb.prep_level()
self.sb.prep_ships()
# Get rid of any remaining aliens and bullets.
self.aliens.empty()
self.bullets.empty()
# Create a new fleet and center the ship.
self._create_fleet()
self._create_bunker_wall()
self.ship.center_ship()
# Update events
pygame.time.set_timer(self._alien_shoot_event, self.settings.current_fire_interval)
# Hide the mouse cursor.
pygame.mouse.set_visible(False)
# Start background music
self._soundmananger.getinstance().startgame()
def _check_score_button(self, mouse_pos):
button_clicked = self.score_button.rect.collidepoint(mouse_pos)
if button_clicked and not self.stats.game_active:
self.screen.fill(self.settings.bg_color)
self.screen.blit(self.settings.screenbackground, self.settings.screenbackgroundrect)
self.stats.display_scores()
self.back_button.rect = self.score_button.rect
self.back_button.prep_msg()
self.back_button.draw_button()
pygame.display.flip()
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_q or event.key == pygame.K_ESCAPE:
pygame.quit()
sys.exit()
elif event.type == pygame.MOUSEBUTTONDOWN:
mouse_pos = pygame.mouse.get_pos()
button_clicked = self.score_button.rect.collidepoint(mouse_pos)
if button_clicked:
return
def _check_keydown_events(self, event):
"""Respond to keypresses."""
if event.key == pygame.K_RIGHT or event.key == pygame.K_d:
self.ship.moving_right = True
elif event.key == pygame.K_LEFT or event.key == pygame.K_a:
self.ship.moving_left = True
elif event.key == pygame.K_q or event.key == pygame.K_ESCAPE:
sys.exit()
elif event.key == pygame.K_SPACE:
self._fire_bullet()
def _check_keyup_events(self, event):
"""Respond to key releases."""
if event.key == pygame.K_RIGHT or event.key == pygame.K_d:
self.ship.moving_right = False
elif event.key == pygame.K_LEFT or event.key == pygame.K_a:
self.ship.moving_left = False
def _fire_bullet(self):
"""Create a new bullet and add it to the bullets group."""
if len(self.bullets) < self.settings.bullets_allowed:
new_bullet = Bullet(self)
self.bullets.add(new_bullet)
def _alien_shoot(self):
for alien in self.aliens:
if random.randint(0, self.settings.current_fire_chance) == self.settings.fire_chance_key:
self._alien_fire_bullet(alien)
def _alien_fire_bullet(self, alien):
new_bullet = AlienBullet(self, alien)
self.alienbullets.add(new_bullet)
def _update_bullets(self):
"""Update position of bullets and get rid of old bullets."""
# Update bullet positions.
self.bullets.update()
# Update alien bullet positions
self.alienbullets.update()
# Get rid of bullets that have disappeared.
for bullet in self.bullets.copy():
if bullet.rect.bottom <= 0:
self.bullets.remove(bullet)
for bullet in self.alienbullets.copy():
if bullet.rect.bottom >= self.settings.screen_height:
self.bullets.remove(bullet)
self._check_bullet_alien_collisions()
self._check_alienbullet_collisions()
def _check_bullet_alien_collisions(self):
"""Respond to bullet-UFO collisions."""
if self.ufo is not None:
collisions = pygame.sprite.spritecollide(self.ufo, self.bullets, False)
if collisions:
self.stats.score += self.ufo.score
self.sb.prep_score()
self.sb.check_high_score()
score_str = "{:,}".format(self.ufo.score)
font = pygame.font.SysFont(None, 36)
self.ufo_score = font.render(score_str, True, (255, 255, 0), self.settings.bg_color)
self.ufo_rect = self.ufo_score.get_rect()
self.ufo_rect.center = self.ufo.rect.center
self.display_ufo_score = True
thread = threading.Thread(target=self._ufo_score_duration, args=[3000], daemon=True)
thread.start()
self.ufo.kill()
if self._soundmananger.getinstance().getufosoundactive():
self._soundmananger.getinstance().stopufosound()
self.ufo = None
"""Respond to bullet-alien collisions."""
# Remove any bullets and aliens that have collided.
collisions = pygame.sprite.groupcollide(self.bullets, self.aliens, True, False)
if collisions:
for aliens in collisions.values():
for alien in aliens:
self.stats.score += alien.score
explosion = AlienExplosion(self, alien)
self.explosions.add(explosion)
alien.kill()
self.sb.prep_score()
self.sb.check_high_score()
if not self.aliens:
# New level created here
# Destroy existing bullets and create new fleet.
self.bullets.empty()
self.bunkers.empty()
self.alienbullets.empty()
if self.ufo is not None:
self.ufo.kill()
if self._soundmananger.getinstance().getufosoundactive:
self._soundmananger.getinstance().stopufosound()
self.ufo = None
# Create new objects
self._create_fleet()
self._create_bunker_wall()
# Adjust stats & increase level
self.stats.level += 1
self.settings.increase_speed(self.stats.level)
pygame.time.set_timer(self._alien_shoot_event, self.settings.current_fire_interval)
self._soundmananger.getinstance().newlevel()
self.sb.prep_level()
# Get a list of collisions between all bunkers and bullets
# Don't kill bullets, as we need the coordinates for bunker pixel destruction
collisions = pygame.sprite.groupcollide(self.bunkers, self.bullets, False, False)
if collisions:
for bunker in collisions:
for bullet in collisions[bunker]:
if bunker.validhit(bullet):
bullet.kill()
def _check_alienbullet_collisions(self):
"""Check to see if ship was hit by a bullet"""
collisions = pygame.sprite.spritecollide(self.ship, self.alienbullets, False)
if collisions:
self._ship_hit()
collisions = pygame.sprite.groupcollide(self.bunkers, self.alienbullets, False, False)
if collisions:
for bunker in collisions:
for bullet in collisions[bunker]:
if bunker.validhit(bullet, True):
bullet.kill()
def _update_aliens(self):
"""
Check if the fleet is at an edge,
then update the positions of all aliens in the fleet.
"""
self._check_fleet_edges()
self.aliens.update()
self.explosions.update()
if self.ufo is not None:
self.ufo.update()
# Look for alien-ship collisions.
if pygame.sprite.spritecollideany(self.ship, self.aliens):
self._ship_hit()
# Look for aliens hitting the bottom of the screen.
self._check_aliens_bottom()
# Check how many aliens are left
remaining = len(self.aliens)
speeds = [0.75, 0.5, 0.25]
# As more aliens are killed, increase the speed of the music
for index in range(len(speeds)):
if remaining < int(self.settings.max_aliens * speeds[index])\
and self._soundmananger.getinstance().musicindex < index + 1:
self._soundmananger.getinstance().increasemusicspeed()
def _update_frames(self):
for alien in self.aliens:
alien.nextframe()
def _update_explosion_frames(self):
for explosion in self.explosions:
explosion.nextframe()
if explosion.finished:
explosion.kill()
def _check_aliens_bottom(self):
"""Check if any aliens have reached the bottom of the screen."""
screen_rect = self.screen.get_rect()
for alien in self.aliens.sprites():
if alien.rect.bottom >= screen_rect.bottom:
# Treat this the same as if the ship got hit.
self._ship_hit()
break
"""Also check for bunker collisions"""
collisions = pygame.sprite.groupcollide(self.bunkers, self.aliens, False, False)
if collisions:
for bunker in collisions:
for alien in collisions[bunker]:
alien.kill()
bunker.kill()
break
def _ship_explosion(self):
for image in self.ship.explosion_frames:
self.ship.setexplosionframe(image)
self._update_screen()
pygame.time.wait(175)
self.ship.resetimage()
self._update_screen()
pygame.time.wait(500)
def _ship_hit(self):
"""Respond to the ship being hit by an alien."""
thread = threading.Thread(target=self._ship_explosion, args=(), daemon=True)
thread.start()
# Threading the explosion function to allow exiting of the game
# pygame.time.wait() locks the window, preventing exiting
while thread.is_alive():
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_q or event.key == pygame.K_ESCAPE:
pygame.quit()
sys.exit()
if self.stats.ships_left > 0:
# Decrement ships_left, and update scoreboard.
self.stats.ships_left -= 1
self.sb.prep_ships()
# Get rid of any remaining aliens, bunkers, and all bullets
self.aliens.empty()
self.bullets.empty()
self.bunkers.empty()
self.alienbullets.empty()
if self.ufo is not None:
self.ufo.kill()
if self._soundmananger.getinstance().getufosoundactive:
self._soundmananger.getinstance().stopufosound()
self.ufo = None
# Create a new fleet and center the ship.
self._create_fleet()
self._create_bunker_wall()
self.ship.center_ship()
self._soundmananger.getinstance().newlevel()
# Pause.
sleep(0.5)
# Game ending control goes here
else:
self.stats.game_active = False
if self._soundmananger.getinstance().getmusicplaying():
self._soundmananger.getinstance().stopmusic()
pygame.mouse.set_visible(True)
if self.stats.checkfornewhighscore():
self._check_score_button(self.score_button.rect.center)
def _create_fleet(self):
"""Create the fleet of aliens."""
# Create an alien and find the number of aliens in a row.
# Spacing between each alien is equal to one alien width.
alien = Alien(self, ['images/alien1frame1.png', 'images/alien1frame2.png'], 0)
alien_width, alien_height = alien.rect.size
available_space_x = self.settings.screen_width - (2 * alien_width)
number_aliens_x = available_space_x // (2 * alien_width)
# Determine the number of rows of aliens that fit on the screen.
# ship_height = self.ship.rect.height
# Available rows
# available_space_y = (self.settings.screen_height - (5 * alien_height) - ship_height)
# number_rows = available_space_y // (2 * alien_height)
number_rows = self.settings.number_of_rows
alienimages = [
['images/alien1frame1.png', 'images/alien1frame2.png'],
['images/alien2frame1.png', 'images/alien2frame2.png'],
['images/alien3frame1.png', 'images/alien3frame2.png']
]
alienimageindex = 0
# Create the full fleet of aliens.
for row_number in range(number_rows):
if row_number % 2 == 0 and row_number is not 0:
alienimageindex += 1
for alien_number in range(number_aliens_x):
self._create_alien(alien_number, row_number, alienimages[alienimageindex],
self.settings.score_values[alienimageindex], alien_number % 2)
self.settings.max_aliens = len(self.aliens)
def _create_alien(self, alien_number, row_number, images, score, offset):
"""Create an alien and place it in the row."""
alien = Alien(self, images, score, offset)
alien_width, alien_height = alien.rect.size
alien.x = alien_width + 2 * alien_width * alien_number
alien.rect.x = alien.x
alien.rect.y = alien.rect.height + 1.25 * alien.rect.height * row_number
self.aliens.add(alien)
def _create_ufo(self):
if not self.stats.game_active:
return
if self.ufo is None and random.randint(0, 5) == 2:
self.ufo = UFO(self, int(self.settings.score_values[2] * random.randint(3, 9) / 1.5))
self.ufo.rect.y = int(self.settings.screen_height * random.randint(15, 75) / 100)
if not self._soundmananger.getinstance().getufosoundactive():
self._soundmananger.getinstance().playufosound()
def _ufo_score_duration(self, duration):
pygame.time.wait(duration)
self.display_ufo_score = False
def _create_bunker_wall(self):
"""Create the row of bunkers."""
# Create an bunker and find the number of bunkers in a row.
# Spacing between each bunker is equal to one alien width.
bunker = Bunker(self)
bunker_width, bunker_height = bunker.rect.size
available_space_x = self.settings.screen_width
number_bunkers_x = (available_space_x // bunker_width) // 2
# Create the full wall of bunkers.
for bunker_number in range(number_bunkers_x):
self._create_bunker(bunker_number)
def _create_bunker(self, bunker_number):
"""Create an bunker and place it in the row."""
bunker = Bunker(self)
bunker_width, bunker_height = bunker.rect.size
bunker.x = (bunker_width // 2) + 2 * bunker_width * bunker_number
bunker.rect.x = bunker.x
bunker.rect.y = int(self.settings.screen_height * 0.80)
self.bunkers.add(bunker)
def _check_fleet_edges(self):
"""Respond appropriately if any aliens have reached an edge."""
for alien in self.aliens.sprites():
if alien.check_edges():
self._change_fleet_direction()
return
for explosion in self.explosions.sprites():
if explosion.check_edges():
self._change_fleet_direction()
return
if self.ufo is not None:
if self.ufo.check_edges():
self.ufo.kill()
if self._soundmananger.getinstance().getufosoundactive:
self._soundmananger.getinstance().stopufosound()
self.ufo = None
def _change_fleet_direction(self):
"""Drop the entire fleet and change the fleet's direction."""
# They do drop down
for alien in self.aliens.sprites():
alien.rect.y += self.settings.fleet_drop_speed
self.settings.fleet_direction *= -1
def _draw_main_menu(self):
self.screen.fill(self.settings.bg_color)
self.screen.blit(self.settings.screenbackground, self.settings.screenbackgroundrect)
height = self.sb.show_main_menu()
self.play_button.rect.bottom = self.play_button.rect.height + height + 75
self.score_button.rect.top = self.play_button.rect.bottom + 50
self.play_button.prep_msg()
self.score_button.prep_msg()
self.play_button.draw_button()
self.score_button.draw_button()
pygame.display.flip()
def _update_screen(self):
"""Update images on the screen, and flip to the new screen."""
self.screen.fill(self.settings.bg_color)
self.screen.blit(self.settings.screenbackground, self.settings.screenbackgroundrect)
self.ship.blitme()
if self.ufo is not None:
self.ufo.blitme()
for bullet in self.bullets.sprites():
bullet.draw_bullet()
for bullet in self.alienbullets.sprites():
bullet.draw_bullet()
# Draw the aliens
self.aliens.draw(self.screen)
# Draw the bunkers
self.bunkers.draw(self.screen)
# Draw the explosions
self.explosions.draw(self.screen)
# Draw the score information.
self.sb.show_score()
if self.display_ufo_score:
self.screen.blit(self.ufo_score, self.ufo_rect)
pygame.display.flip()
def create_ufo(ai_settings, screen, ufos):
ufo = UFO(ai_settings, screen)
ufo.rect.x = -10
ufo.rect.y = 80
ufos.add(ufo)
def update(self):
if len(self.fleet.sprites()) == 0:
self.ufo_sound.stop()
self.background_sound.stop()
self.alien_speed += 0.2
self.reset(self.alien_speed)
print(len(self.fleet.sprites()))
if self.ufo is not None:
if self.ufo.check_edges():
self.ufo = None
self.ufo_sound.stop()
self.ufo_time = random.randint(15, 30) * 1000
self.ufo_ticks = pygame.time.get_ticks()
else:
self.ufo.update()
else:
if pygame.time.get_ticks() - self.ufo_ticks >= \
self.ufo_time:
self.ufo = UFO(self.director.screen, self.alien_speed * 2)
self.ufo_sound.play(-1)
self.check_explosions()
self.explosions.update()
self.ship.update()
self.check_fleet_edges()
self.check_fleet_bottom()
self.fleet.update()
if len(self.fleet.sprites()) > 0 and \
pygame.time.get_ticks() - self.old_ticks >= \
10000 / self.game_stats.level:
fleet = self.fleet.sprites()
self.fire_bullet(fleet[random.randint(0,
len(fleet) - 1)].rect,
"alien")
self.old_ticks = pygame.time.get_ticks()
self.check_bullets()
self.bullets.update()
if len(self.fleet.sprites()) > 0 and \
self.fleet.sprites()[-1].rect.bottom >= \
self.bunkers.sprites()[0].top_left_triangle_rect.top:
for alien in self.fleet.sprites():
for bunker in self.bunkers.sprites():
if bunker.collide(alien.rect):
self.create_explosion(alien.rect.center)
self.fleet.remove(alien)
self.alein_explosion.play()
if not bunker.standing():
self.bunkers.remove(bunker)
self.game_stats.update()
if self.game_stats.ships == 0:
self.ufo_sound.stop()
self.background_sound.stop()
def play(self):
if self.final_boss and self.ufo.health == 0:
return -2, self.score + 200, int(time.time() - self.time)
if self.lives <= 0:
return -1, self.score, int(time.time() - self.time)
# active powerups
new_active = []
for pw in self.active_powerups:
if time.time() - pw.time > 10:
pw.power_up_deactivate(self)
else:
new_active.append(pw)
self.active_powerups = new_active
# move bullets
for bullet in self.paddle_bullets:
bullet.move()
self.paddle_bullets = [
bullet for bullet in self.paddle_bullets if not bullet.dead
]
# bricks
for brick in self.bricks:
brick.change()
if brick.y == self.paddle.y:
return -1, self.score, int(time.time() - self.time)
# move balls
alive_ball = False
for ball in self.balls:
if ball.move() != -1:
alive_ball = True
else:
ball.dead = True
self.balls = [ball for ball in self.balls if not ball.dead]
if not alive_ball:
self.lives -= 1
self.balls.append(Ball(self.width, self.height, 0, 0))
self.ball_on_paddle = True
for powerup in self.active_powerups:
powerup.power_up_deactivate(self)
self.active_powerups = []
if self.lives == 0:
return -1, self.score, int(time.time() - self.time)
# move powerups
new_powerups = []
for powerup in self.powerups:
if powerup.move() != -1:
new_powerups.append(powerup)
self.powerups = new_powerups
# check for collisions
self.check_collision()
# ball on paddle
paddle_x, paddle_y, paddle_show, _, _ = self.paddle.get_dim()
paddle_center = paddle_x + len(paddle_show) / 2
if self.ball_on_paddle:
[
ball.set_x_y(int(paddle_center), paddle_y - 1)
for ball in self.balls
]
# set all the sprites and render
if self.final_boss:
self.ufo.move(paddle_center)
self.screen.set_sprites(paddle=self.paddle,
bricks=self.bricks,
balls=self.balls,
powerups=self.powerups,
bullets=self.paddle_bullets)
cursor_to_top()
pw_time = 0
for pw in self.active_powerups:
if pw.get_type() == PowerUpType.BULLET:
pw_time = time.time() - pw.time
ufo_health = -1
if self.final_boss:
ufo_health = self.ufo.health
self.screen.render(self.time, self.score, self.lives, self.game_level,
pw_time, ufo_health)
# get bullets
new_b = self.paddle.gen_bullets()
if new_b is not None:
self.paddle_bullets = new_b
if self.final_boss and self.ufo.bombTime():
self.spawn_powerup(random.randint(self.ufo.x_start,
self.ufo.x_end),
self.ufo.y + 5,
self.balls[0],
rigged=True)
# self.spawn_powerup(random.randint(self.ufo.x_start, self.ufo.x_end), self.ufo.y + 5, self.balls[0],
# rigged=True)
self.ufo.last_bomb = time.time()
# check for time attack
if not self.time_attack and time.time() - self.time > 5:
self.time_attack = True
# check for level end
level_end = True
for brick in self.bricks:
if brick.strength != 4:
level_end = False
if level_end:
self.game_level += 1
if self.game_level == 4:
return -2, self.score, int(time.time() - self.time)
else:
self.powerups = []
for powerup in self.active_powerups:
powerup.power_up_deactivate(self)
self.active_powerups = []
if self.game_level == 3:
self.final_boss = True
self.ufo = UFO(self.width, self.height, 0, 0)
self.bricks = self.ufo.art_to_bricks()
else:
self.bricks = get_bricks(self.width, self.height,
self.game_level)
self.ball_on_paddle = True
self.time = time.time()
self.time_attack = False
self.balls = [self.balls[0]]
log("level upped")
return 0, 0, 0
def ufo_fleet(g_set, screen, ufos, s_ship):
ufo = UFO(g_set, screen)
no_ufo = get_ufo(g_set, ufo.rect.width)
no_row = get_ufo_row(g_set, s_ship.rect.height, ufo.rect.height)
for row_no in range(no_row):
create_ufo(g_set, screen, ufos, no_ufo, row_no)
