class AlienInvasion:
def __init__(self):
pygame.init()
self.settings = Settings()
self.screen = pygame.display.set_mode(
(self.settings.screen_width, self.settings.screen_height))
self.ship = Ship(self)
pygame.display.set_caption('Alien Invasion')
def check_events(self):
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)
def check_keydown_events(self, event):
if event.key == pygame.K_RIGHT:
self.ship.moving_right = True
elif event.key == pygame.K_LEFT:
self.ship.moving_left = True
elif event.key == pygame.K_q:
sys.exit()
def check_keyup_events(self, event):
if event.key == pygame.K_RIGHT:
self.ship.moving_right = False
elif event.key == pygame.K_LEFT:
self.ship.moving_left = False
def update_screen(self):
self.screen.fill(self.settings.background_color)
self.ship.blitme()
def run_game(self):
while True:
self.check_events()
self.ship.update()
self.update_screen()
pygame.display.flip()
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")
#创建一艘飞船
ship = Ship(ai_settings,screen)
bullets = Group()
#创建一个外星人
alien = Alien(ai_settings,screen)
#开始游戏的主循环
while True:
gf.check_events(ai_settings,screen,ship,bullets)
ship.update()
# gf.update_bullets(bullets)
gf.update_screen(ai_settings,screen,ship,alien,bullets)
bullets.update()
# gf.update_screen(ai_settings,screen,ship,bullets)
# 删除已消失的子弹
for bullet in bullets.copy():
if bullet.rect.bottom <= 0:
bullets.remove(bullet)
print(len(bullets))
gf.update_screen(ai_settings, screen, ship, alien, bullets)
# 监视键盘和鼠标事件
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
# 每次循环绘制屏幕
screen.fill(ai_settings.bg_color)
ship.blitme()
# 让最近绘制的屏幕可见
pygame.display.flip()
def run_game():
"""初始化"""
pygame.init()
'''
"""设置背景和桌面"""
screen = pygame.display.set_mode((1360,760))
"""设置背景颜色"""
bg_color = (230,230,230)
'''
"""设置标题"""
pygame.display.set_caption("Aline Invasion")
ai_setting = Settings()
screen = pygame.display.set_mode(
(ai_setting.screen_width, ai_setting.screen_height))
ship = Ship(screen)
stats = GameStats(ai_setting)
bullets = Group()
bullet_one = Bullet(ai_setting, screen, ship)
alien = Alien(ai_setting, screen)
aliens = Group()
alien.create_fleet(ai_setting, screen, aliens, ship)
play_button = Button(ai_setting, screen, "Play!")
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_RIGHT:
ship.move_right = True
if event.key == pygame.K_LEFT:
ship.move_left = True
if event.key == pygame.K_UP:
ship.move_up = True
if event.key == pygame.K_DOWN:
ship.move_down = True
if event.key == pygame.K_SPACE:
bullet_one.bullet_space = True
if event.key == pygame.K_q:
sys.exit()
if event.key == pygame.K_k:
stats.game_active = True
stats.ships_left = ai_setting.ship_limit
elif event.type == pygame.KEYUP:
if event.key == pygame.K_RIGHT:
ship.move_right = False
if event.key == pygame.K_LEFT:
ship.move_left = False
if event.key == pygame.K_UP:
ship.move_up = False
if event.key == pygame.K_DOWN:
ship.move_down = False
if event.key == pygame.K_SPACE:
bullet_one.bullet_space = False
elif event.type == pygame.MOUSEBUTTONDOWN:
if not stats.game_active:
mouse_x, mouse_y = pygame.mouse.get_pos()
play_button.check_paly_button(ai_setting, stats,
play_button, mouse_x,
mouse_y)
"""让最近绘制的屏幕可见"""
screen.fill(ai_setting.bg_color)
if stats.game_active:
if stats.ships_left > 0:
bullet_one.fire_bullet(ai_setting, screen, ship, bullets)
bullet_one.update_bullets(bullets, aliens)
aliens.draw(screen)
ship.update(ai_setting.ship_speed_factor)
ship.blitme()
alien.update_aliens(ai_setting, aliens, ship, screen, stats,
bullets)
if len(aliens) == 0:
bullets.empty()
alien.create_fleet(ai_setting, screen, aliens, ship)
if not stats.game_active:
pygame.mouse.set_visible(True)
play_button.draw_button()
"""
bullets.update()
for bullet in bullets.sprites():
bullet.draw_bullet()
for bullet in bullets.copy():
if bullet.rect.bottom <= 0:
bullets.remove(bullet)
"""
#alien.biltme()
pygame.display.flip()
class TargetPractice:
"""The class to manage game assets and behavior. """
def __init__(self):
"""Initialize the game and create the resources. """
pygame.init()
self.settings = Settings()
self.screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
self.screen_rect = self.screen.get_rect()
self.settings.screen_width = self.screen.get_rect().width
self.settings.screen_height = self.screen.get_rect().height
pygame.display.set_caption("Target Practice")
self.stats = Stats(self)
self.ship =Ship(self)
self.rockets = pygame.sprite.Group()
self.play_button = rectangle(self)
self.play_but = p_button(self, "Click to Play")
def _check_events(self):
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)
def _check_rect_edges(self):
if self.play_button._check_edges():
self._change_rect_direction()
def fire_rocket(self):
if len(self.rockets) <= self.settings.rockets_allowed:
new_rocket = Rocket(self)
self.rockets.add(new_rocket)
def check_play_button(self, mouse_pos):
#Start a new game when the player clicks Play.
button_clicked = self.play_but.rect.collidepoint(mouse_pos)
if button_clicked and not self.stats.game_active:
#Reset the game settings
self.stats.reset_stats()
self.stats.game_active = True
self.rockets.empty()
self.ship.center_ship
pygame.mouse.set_visible(False)
def update_rockets(self):
self.rockets.update()
for rocket in self.rockets.copy():
if rocket.rect.right >= self.screen_rect.right:
self.rockets.remove(rocket)
self._check_rocket_rect_collisions()
def target_hit(self):
self.settings.enhanced_settings()
self.rockets.empty()
self.ship.center_ship()
sleep(0.5)
def _check_rocket_rect_collisions(self):
if pygame.sprite.spritecollideany(self.play_button, self.rockets):
self.target_hit()
def _change_rect_direction(self):
self.settings.rect_direction *= -1
def _check_keydown_events(self, event):
if event.key == pygame.K_UP:
self.ship.moving_top = True
elif event.key == pygame.K_DOWN:
self.ship.moving_down = True
elif event.key == pygame.K_q:
sys.exit()
elif event.key == pygame.K_SPACE:
self.fire_rocket()
def _check_keyup_events(self, event):
if event.key == pygame.K_UP:
self.ship.moving_top = False
elif event.key == pygame.K_DOWN:
self.ship.moving_down = False
def _run_game(self):
"""Start the main loop of the game. """
while True:
self._check_events()
if self.stats.game_active:
self.ship.update()
self.update_rockets()
self.update_rect()
self._update_screen()
def update_rect(self):
self._check_rect_edges()
self.play_button.update()
def _update_screen(self):
self.screen.fill(self.settings.bg_color)
self.ship.blitme()
for rocket in self.rockets.sprites():
rocket.draw_rocket()
self.play_button.draw_button()
if not self.stats.game_active:
self.play_but.draw_button()
pygame.display.flip()
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(
(self.settings.screen_height, self.settings.screen_width))
# full screen 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.
self.stats = GameStats(self)
self.sb = Scoreboard(self)
self.ship = Ship(self)
self.bullets = pygame.sprite.Group()
self.aliens = pygame.sprite.Group()
self._create_fleet()
self.play_button = Button(self, "Play")
def run_game(self):
""""Start the main loop for the game"""
while True:
self._check_events()
if self.stats.game_active:
self.ship.update()
self._update_bullets()
self._update_aliens()
self._update_screen()
# Get rid of bullets that have gone off screen
def _check_events(self):
"""Respond to keypress and mouse events"""
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
elif event.type == pygame.MOUSEBUTTONDOWN:
mouse_pos = pygame.mouse.get_pos()
self._check_play_button(mouse_pos)
elif event.type == pygame.KEYDOWN:
self._check_keydown_events(event)
elif event.type == pygame.KEYUP:
self._check_keyup_events(event)
def _check_play_button(self, mouse_pos):
""""Start a new game when player clicks play"""
button_clicked = self.play_button.rect.collidepoint(mouse_pos)
if button_clicked and not self.stats.game_active:
# Reset the game stats
self.settings.initialize_dynamic_settings()
self.stats.reset_stats()
self.stats.game_active = True
self.sb.prep_score()
self.sb.prep_level()
self.sb.prep_ships()
# Get rid of any remaining game assets
self.aliens.empty()
self.bullets.empty()
# Create new fleet and center ship
self._create_fleet()
self.ship.center_ship()
# Hide mouse cursor
pygame.mouse.set_visible(False)
def _check_keydown_events(self, event):
"""Respond to keypresses. """
if event.key == pygame.K_RIGHT:
self.ship.moving_right = True
elif event.key == pygame.K_LEFT:
self.ship.moving_left = True
elif event.key == pygame.K_SPACE:
self._fire_bullet()
def _check_keyup_events(self, event):
if event.key == pygame.K_RIGHT:
self.ship.moving_right = False
elif event.key == pygame.K_LEFT:
self.ship.moving_left = False
elif event.key == pygame.K_q:
sys.exit()
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 _create_fleet(self):
"""Create a fleet of Aliens"""
# create an alien and find the number of aliens in a row
# spacing between the aliens is equal to one alien width
alien = Alien(self)
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 number of rows of aliens that fit on screen
ship_height = self.ship.rect.height
available_space_y = (self.settings.screen_height - (3 * alien_height) -
ship_height)
number_rows = available_space_y // (2 * alien_height)
# create fleet of aliens
for row_number in range(number_rows):
for alien_number in range(number_aliens_x):
self._create_alien(alien_number, row_number)
def _create_alien(self, alien_number, row_number):
"""create an alien and place it in row """
alien = Alien(self)
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 + 2 * alien.rect.height * row_number
self.aliens.add(alien)
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()
break
def _change_fleet_direction(self):
"""Drop the entire fleet and change the fleet's direction"""
for alien in self.aliens.sprites():
alien.rect.y += self.settings.fleet_drop_speed
self.settings.fleet_direction *= -1
def _update_screen(self):
"""Updates images on the screen, and flips to new screen"""
self.screen.fill(self.settings.bg_color)
self.ship.blitme()
for bullet in self.bullets.sprites():
bullet.draw_bullet()
self.aliens.draw(self.screen)
self.sb.show_score()
# Draw play button if game is inactive
if not self.stats.game_active:
self.play_button.draw_button()
pygame.display.flip()
def _update_bullets(self):
"""Update position of bullets and gets rid of old bullets"""
# Update bullet positions
self.bullets.update()
# Get rid of bullets that have gone off screen
for bullet in self.bullets.copy():
if bullet.rect.bottom <= 0:
self.bullets.remove(bullet)
# print(f" bullets generated : {len(self.bullets)}")
self._check_bullet_alien_collision()
def _check_bullet_alien_collision(self):
# Check for bullet alien collisions
collisions = pygame.sprite.groupcollide(self.bullets, self.aliens,
True, True)
# check if all aliens in fleet destroyed
if collisions:
for aliens in collisions.values():
self.stats.score += self.settings.alien_points * len(aliens)
self.sb.prep_score()
self.sb.prep_high_score()
if not self.aliens:
# Destroy existing bullets and create new fleet
self.bullets.empty()
self._create_fleet()
self.settings.increase_speed()
# Increase level.
self.stats.level += 1
self.sb.prep_level()
def _update_aliens(self):
""" Check if the fleet is at an edge,
Update the positions of all aliens in the fleet
"""
self._check_fleet_edges()
self.aliens.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()
def _ship_hit(self):
"""Respond to ship being hit by an alien """
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 and bullets
self.aliens.empty()
self.bullets.empty()
# Create a new fleet and center the ship
self._create_fleet()
self.ship.center_ship()
# Pause
sleep(0.5)
else:
self.stats.game_active = False
pygame.mouse.set_visible(True)
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 got hit.
self._ship_hit()
break
class AlienInvasion:
'''Main class, base of the program'''
def __init__(self):
'''initialize game and resources'''
pygame.init()
self.settings = Settings()
self.screen = pygame.display.set_mode(
(self.settings.screen_width, self.settings.screen_height))
self.stats = Game_stats(self)
self.score = Scoreboard(self)
pygame.display.set_caption("Alien Invasion")
# ship
self.ship = Ship(self)
# bullets
self.bullets = pygame.sprite.Group()
# alien
self.aliens = pygame.sprite.Group()
self._create_invasion()
#control
self.play_button = Button(self, "Play")
# helper method - start with _(underscore)
def _update_screen(self):
# basic redraw
self.screen.fill(self.settings.bg_color)
self.ship.blitme()
for bullet in self.bullets.sprites():
bullet.draw_bullet()
self.aliens.draw(self.screen)
#draw score
self.score.show_score()
#Draw button if game is inactive
if not self.settings.game_active:
self.play_button.draw_button()
# make most recent screen visible
pygame.display.flip()
def _check_events(self):
'''keyboard and mouse events'''
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
elif event.type == pygame.KEYDOWN:
self._check_keyDown(event)
elif event.type == pygame.KEYUP:
self._check_keyUP(event)
elif event.type == pygame.MOUSEBUTTONDOWN:
mouse_position = pygame.mouse.get_pos()
self._check_play_button(mouse_position)
def _check_keyUP(self, event):
if event.key == pygame.K_a or event.key == pygame.K_d:
self.ship.moving = False
self.ship.moving_x = 0
def _check_keyDown(self, event):
if event.key == pygame.K_ESCAPE:
sys.exit(0)
elif event.key == pygame.K_SPACE:
if len(self.bullets) < self.settings.bullets_allowed:
self._fire_bullet()
if event.key == pygame.K_d:
# move ship to the right
self.ship.moving = True
self.ship.moving_x = self.settings.ship_speed
if event.key == pygame.K_a:
# move ship to the left
self.ship.moving = True
self.ship.moving_x = -self.settings.ship_speed
def _check_play_button(self, mouse_position):
'''start new game when player clicks play'''
if self.play_button.rect.collidepoint(
mouse_position) and not self.settings.game_active:
self._game_reset()
self.settings.game_active = True
#hide mouse cursor
pygame.mouse.set_visible(False)
def _game_reset(self):
'''Reset game'''
self.stats.reset_stats()
self.settings.init_dynamic_settings()
self.score.prep_score()
self.score.prep_level()
self.score.prep_ships()
# get rid of previous game objects
self.aliens.empty()
self.bullets.empty()
self._create_invasion()
self.ship.center_ship()
def _fire_bullet(self):
'''create bullet and add it to bullets'''
self.bullets.add(Bullet(self))
def _remove_obsole_bullets(self):
'''remove obsolete bullets and aliens if hit'''
for bullet in self.bullets:
if bullet.rect.bottom <= 0:
self.bullets.remove(bullet)
def _alien_bullet_collision(self):
#Check for bullet sthat have hit aliens
collisions = pygame.sprite.groupcollide(
self.bullets, self.aliens, self.settings.bullet_single_kill, True)
if collisions:
for alien in collisions.values():
self.stats.score += self.settings.alien_points * len(alien)
self.score.prep_score()
self.score.check_high_score()
def _create_alien(self, alien_number, row_number):
alien = Alien(self)
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_height + 2 * alien_height * row_number
self.aliens.add(alien)
def _create_invasion(self):
'''create fleet of invading aliens'''
# settings for fleet
test_alien = Alien(self)
alien_width, alien_height = test_alien.rect.size
available_space_x = self.settings.screen_width - (2 * alien_width)
num_of_aliens_x = available_space_x // (
2 *
alien_width) + 1 # +1 is my correction - remove if game too hard
available_space_y = self.settings.screen_height - (3 * alien_height)
num_of_aliens_y = available_space_y // (
2 * alien_height) - self.settings.alien_buffer_zone
for row_number in range(num_of_aliens_y):
for alien_number in range(num_of_aliens_x):
self._create_alien(alien_number, row_number)
def _update_aliens(self):
'''
Check if fleet hits an edge, then update alien position
'''
self._check_fleet_edges()
self.aliens.update()
self._alien_ship_collision()
self._check_aliens_landed()
def _alien_ship_collision(self):
'''check if aliens hit the ship'''
if pygame.sprite.spritecollideany(self.ship, self.aliens):
self._ship_hit()
def _ship_hit(self):
'''Ship has been hit logic'''
#remove ship life if you can
if self.stats.ship_left > 0:
self.stats.ship_left -= 1
self.score.prep_ships()
# reset game state
self.aliens.empty()
self._reset_state()
self.ship.center_ship()
#pause game for a bit
sleep(self.settings.hit_freeze_time)
else:
self._game_over()
def _check_fleet_edges(self):
'''Respond if any alien hit an edge'''
for alien in self.aliens.sprites():
if alien.check_edges():
self._change_fleet_direction()
break
def _change_fleet_direction(self):
'''Drop fleet and change direction'''
for alien in self.aliens.sprites():
alien.rect.y += self.settings.alien_speed_vertical
self.settings.alien_moving_right = not self.settings.alien_moving_right
def _code_relentless_horde(self):
if not self.aliens:
self._reset_state()
self.settings.increase_speed()
self.stats.level += 1
self.score.prep_level()
def _check_aliens_landed(self):
'''check if aliens reached bottom of screen'''
screen_rect = self.screen.get_rect()
for alien in self.aliens.sprites():
if alien.rect.bottom >= screen_rect.bottom:
self._ship_hit()
break
def _reset_state(self):
'''Destroy bullets, reset aliens'''
self.bullets.empty()
self._create_invasion()
def _update_game_state(self):
self._remove_obsole_bullets()
self._alien_bullet_collision()
self._code_relentless_horde()
def _game_over(self):
self.settings.game_active = False
self.stats.save_high_score(self.stats.high_score)
pygame.mouse.set_visible(True)
def run(self):
'''Main loop'''
while True:
self._check_events()
if self.settings.game_active:
self.ship.update()
self.bullets.update()
self._update_game_state()
self._update_aliens()
self._update_screen()
class AlienInvasion:
def __init__(self):
pygame.init()
self.settings = Settings()
self.screen = pygame.display.set_mode((1000, 800), pygame.FULLSCREEN)
self.settings.screen_height = self.screen.get_rect().height
self.settings.screen_width = self.screen.get_rect().width
pygame.display.set_caption("Alien Invasion")
self.stats = GameStats(self)
self.sb = Scoreboard(self)
self.bg_color = self.settings.bg_color
self.ship = Ship(self)
self.bullets = pygame.sprite.Group()
self.aliens = pygame.sprite.Group()
self._create_fleet()
self.play_button = Button(self, "Play")
def run_game(self):
while True:
self._check_events()
if self.stats.game_active:
self.ship.update()
self._update_bullets()
self._update_aliens()
self._update_screen()
def _update_bullets(self):
self.bullets.update()
for bullet in self.bullets.copy():
if bullet.rect.bottom <= 0:
self.bullets.remove(bullet)
self._check_bullet_alien_collisions()
def _check_bullet_alien_collisions(self):
collisions = pygame.sprite.groupcollide(self.bullets, self.aliens,
True, True)
if collisions:
for aliens in collisions.values():
self.stats.score += self.settings.alien_points * len(aliens)
self.stats.score += self.settings.alien_points
self.sb.prep_score()
self.sb.check_high_score()
if not self.aliens:
self.bullets.empty()
self._create_fleet()
self.settings.increase_speed()
self.stats.level += 1
self.sb.prep_level()
def _update_screen(self):
self.screen.fill(self.bg_color)
self.ship.blitme()
for bullet in self.bullets.sprites():
bullet.draw_bullet()
self.aliens.draw(self.screen)
self.sb.show_score()
if not self.stats.game_active:
self.play_button.draw_button()
pygame.display.flip()
def _check_events(self):
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)
def _check_keydown_events(self, event):
if event.key == pygame.K_RIGHT:
self.ship.moving_right = True
elif event.key == pygame.K_LEFT:
self.ship.moving_left = True
elif event.key == pygame.K_q:
sys.exit()
elif event.key == pygame.K_SPACE:
self._fire_bullet()
def _check_keyup_events(self, event):
if event.key == pygame.K_RIGHT:
self.ship.moving_right = False
elif event.key == pygame.K_LEFT:
self.ship.moving_left = False
def _fire_bullet(self):
if len(self.bullets) < self.settings.bullets_allowed:
new_bullet = Bullet(self)
self.bullets.add(new_bullet)
def _create_fleet(self):
alien = Alien(self)
alien_width, alien_height = alien.rect.size
alien_width = alien.rect.width
available_space_x = self.settings.screen_width - (2 * alien_width)
number_aliens_x = available_space_x // (2 * alien_width)
ship_height = self.ship.rect.height
available_space_y = (self.settings.screen_height - (3 * alien_height) -
ship_height)
number_rows = available_space_y // (2 * alien_height)
for row_number in range(number_rows):
for alien_number in range(number_aliens_x):
self._create_alien(alien_number, row_number)
def _create_alien(self, alien_number, row_number):
alien = Alien(self)
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 + 2 * alien.rect.height * row_number
self.aliens.add(alien)
def _update_aliens(self):
self._check_fleet_edges()
self.aliens.update()
if pygame.sprite.spritecollideany(self.ship, self.aliens):
self._ship_hit()
self._check_aliens_bottom()
def _check_fleet_edges(self):
for alien in self.aliens.sprites():
if alien.check_edges():
self._change_fleet_directions()
break
def _change_fleet_directions(self):
for alien in self.aliens.sprites():
alien.rect.y += self.settings.fleet_drop_speed
self.settings.fleet_direction *= -1
def _ship_hit(self):
if self.stats.ships_left > 0:
self.stats.ships_left -= 1
self.sb.prep_ships()
self.aliens.empty()
self.bullets.empty()
self._create_fleet()
self.ship.center_ship()
sleep(0.5)
else:
self.stats.game_active = False
pygame.mouse.set_visible(True)
def _check_aliens_bottom(self):
screen_rect = self.screen.get_rect()
for alien in self.aliens.sprites():
if alien.rect.bottom >= screen_rect.bottom:
self._ship_hit()
break
def _check_play_button(self, mouse_pos):
button_clicked = self.play_button.rect.collidepoint(mouse_pos)
if button_clicked and not self.stats.game_active:
self.settings.initialize_dynamic_settings()
self.stats.reset_stats()
self.stats.game_active = True
self.sb.prep_score()
self.sb.prep_level()
self.sb.prep_ships()
self.aliens.empty()
self.bullets.empty()
self._create_fleet()
self.ship.center_ship()
pygame.mouse.set_visible(False)
class AlienInvasion:
def __init__(self):
#initialize game
pygame.init()
#icon
self.icon = pygame.image.load('images/icon.png')
pygame.display.set_icon(self.icon)
#screen size
self.screen = pygame.display.set_mode((800, 600))
#ships object
self.ship = Ship(self)
self.bullet = Bullets(self)
#game name
pygame.display.set_caption('my game')
#background image
self.background = pygame.image.load('images/background.png')
#load ship sound when moving
self.accelarate = pygame.mixer.Sound('music/accelarate.wav')
def _updateScreen(self):
self.bullet.shootBullet()
self.ship.update()
pygame.display.flip()
def _keyDownEvents(self, event):
#play sound when ship is moving
self.accelarate.play()
#makes sure the ship does not disappear
if event.key == pygame.K_RIGHT:
#moves the ship on the x axsis
self.ship.moving_right = True
if event.key == pygame.K_LEFT:
self.ship.moving_left = True
if event.key == pygame.K_UP:
self.ship.moving_up = True
if event.key == pygame.K_q:
self.bullet.shoot = True
def _keyUpEvents(self, event):
#stop sound when key up
self.accelarate.stop()
if event.key == pygame.K_RIGHT:
self.ship.moving_right = False
if event.key == pygame.K_LEFT:
self.ship.moving_left = False
if event.key == pygame.K_UP:
self.ship.moving_up = False
def run_game(self):
while True:
self.screen.fill((212, 215, 210))
self.screen.blit(self.background, (0, 0))
self.ship.blitme()
self.bullet.drawBullet()
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
elif event.type == pygame.KEYDOWN:
self._keyDownEvents(event)
elif event.type == pygame.KEYUP:
self._keyUpEvents(event)
self._updateScreen()
