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 __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 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 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_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 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 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 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 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 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)
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 create_ufo2(ai_settings, screen, ufo):
ship = UFO(ai_settings, screen)
ufo.add(ship)
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 create_ufo(ai_settings, screen, ufos):
ufo = UFO(ai_settings, screen)
ufo.rect.y = random.randint(20, 80)
ufos.add(ufo)
def run_game():
# Initialize game and create a screen object.
pygame.init()
ai_settings = Settings()
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
screen = pygame.display.set_mode((1200, 800))
pygame.display.set_caption("Alien Invasion")
# Make the Play button.
play_button = Button(ai_settings, screen, "Play")
hi_button = Button2(ai_settings, screen)
# Create an instance to store game statistics.
stats = GameStats(ai_settings)
# foo = open("foo.txt", "w")
# foo.write("0")
# foo.close()
fo = open("foo.txt", "r+")
stats.high_score = int(fo.readline())
stats.high_score2 = int(fo.readline())
stats.high_score3 = int(fo.readline())
fo.close()
print("hiscore: " + str(stats.high_score))
# Create an instance to store game statistics and create a scoreboard.
sb = Scoreboard(ai_settings, screen, stats)
title = Title(ai_settings, screen, "", stats)
# Make a ship, a group of bullets, and a group of aliens.
ship = Ship(ai_settings, screen)
ufo = UFO(ai_settings, screen)
# Make a group to store bullets in.
# blue = Blue(ai_settings, screen)
# red = Red(ai_settings, screen)
# green = Green(ai_settings, screen)
bullets = Group()
alien_bullets = Group()
aliens = Group()
# Create the fleet of aliens.
gf.create_fleet(ai_settings, screen, ship, aliens, alien_bullets)
# Start the main loop for the game.
while True:
title.prep_title("")
title.prep_rules("")
title.prep_blue_msg("")
title.prep_red_msg("")
title.prep_green_msg("")
gf.check_events(ai_settings, screen, stats, sb, play_button, hi_button, ship,
aliens, bullets, alien_bullets)
if stats.game_active:
ship.update(clock)
ufo.update()
# ship.explode(hit)
# if hit == True and ship.image == 'images/Ship Full.gif':
# ship.center_ship()
# We update the aliens’ positions after the bullets have been updated,
# because we’ll soon be checking to see whether any bullets hit any aliens.
gf.update_bullets(ai_settings, screen, stats, sb, ship, aliens,
bullets, alien_bullets)
# print(len(bullets))
gf.update_aliens(ai_settings, screen, stats, sb, ship, aliens,
bullets, alien_bullets)
gf.update_screen(ai_settings, screen, stats, sb, ship, aliens,
ufo, title, bullets, alien_bullets, play_button,
hi_button)
def create_ufo(ai_settings, screen, ufos):
ufo = UFO(ai_settings, screen)
ufo.rect.x = -10
ufo.rect.y = 80
ufos.add(ufo)
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)
def create_ufo(ai_settings, screen, ufogroup):
ufo = UFO(ai_settings, screen)
ufogroup.add(ufo)
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()
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)
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 __init__(self, director, background=(0, 0, 0)):
super().__init__(director)
self.background = background
text_rect = pygame.Rect(0, 20, 300, 140)
text_rect.centerx = director.screen.get_rect().centerx
self.logo = Text(text_rect, 140, (255, 255, 255), director.screen,
"SPACE")
text_rect.centery += 60
self.header = Text(text_rect, 90, (0, 180, 0), director.screen,
"INVADERS")
self.alien_one = Alien(director.screen)
self.alien_two = Alien(screen=director.screen, alien_type=2)
self.alien_three = Alien(screen=director.screen, alien_type=3)
self.alien_four = Alien(screen=director.screen, alien_type=4)
self.ufo = UFO(director.screen)
self.alien_one.rect.center = self.alien_two.rect.center = \
self.alien_three.rect.center = self.alien_four.rect.center = \
self.ufo.rect.center = director.screen.get_rect().center
self.alien_one.rect.centerx -= self.ufo.rect.width + 20
self.alien_two.rect.centerx -= self.ufo.rect.width + 20
self.alien_three.rect.centerx -= self.ufo.rect.width + 20
self.alien_four.rect.centerx -= self.ufo.rect.width + 20
self.ufo.rect.centerx -= self.ufo.rect.width + 20
self.alien_one.rect.centery -= self.alien_one.rect.height * 2 + 40
self.alien_two.rect.centery -= self.alien_two.rect.height + 20
self.alien_four.rect.centery += self.alien_four.rect.height + 20
self.ufo.rect.centery += self.alien_four.rect.height + \
self.ufo.rect.height + 40
self.score_one = Text(self.alien_one.rect, 30, (150, 150, 150),
director.screen, "= 10")
self.score_two = Text(self.alien_two.rect, 30, (150, 150, 150),
director.screen, "= 20")
self.score_three = Text(self.alien_three.rect, 30, (150, 150, 150),
director.screen, "= 30")
self.score_four = Text(self.alien_four.rect, 30, (150, 150, 150),
director.screen, "= 40")
self.score_five = Text(self.ufo.rect, 30, (150, 150, 150),
director.screen, "= ???")
self.score_one.rect.centerx = self.score_two.rect.centerx = \
self.score_three.rect.centerx = self.score_four.rect.centerx = \
self.score_five.rect.centerx = self.ufo.rect.centerx + \
self.ufo.rect.width + 20
self.score_five.rect.centerx += 8
self.score_one.prep_img()
self.score_two.prep_img()
self.score_three.prep_img()
self.score_four.prep_img()
self.score_five.prep_img()
menu_rect = pygame.Rect(0, 0, 100, 30)
menu_rect.center = director.screen.get_rect().center
menu_rect.y = director.screen.get_rect().bottom - 150
self.play = Text(menu_rect, 50, (255, 255, 255), director.screen,
"PLAY GAME")
menu_rect.y += 60
self.high_score = Text(menu_rect, 50, (255, 255, 255), director.screen,
"HIGH SCORES")
self.mouse_on = None