def run_game():
FPS = 60
# Initialize game, settings and create a screen object.
pygame.init()
fps_clock = pygame.time.Clock()
ai_settings = Settings()
# FOR THE DQN #
agent = DQNAgent()
counter_games = 0
score_plot = []
counter_plot = []
record = 0
# FOR THE DQN #
while counter_games < 150:
# Create statistics.
stats = GameStats(ai_settings)
# Create game items.
game_items = GameItems(ai_settings, stats)
# Create a fleet of aliens.
gf.create_fleet(ai_settings, game_items)
played = False
gf.start_new_game(ai_settings, stats, game_items)
# Start the main loop for the game.
while stats.game_active:
stats.time_passed = fps_clock.tick(FPS) / 1000 # Time in seconds since previous loop.
gf.check_events(ai_settings, stats, game_items)
if stats.game_active:
game_items.ship.update(stats)
gf.update_bullets(ai_settings, stats, game_items)
gf.update_aliens(ai_settings, stats, game_items)
# FOR THE DQN #
agent.epsilon = 80 - counter_games
state_old = gf.get_state(ai_settings, stats, game_items)
if randint(0, 200) < agent.epsilon:
final_move = to_categorical(randint(0, 3), num_classes=4)
else:
# predict action based on the old state
prediction = agent.model.predict(state_old.reshape((1, 3536)))
final_move = to_categorical(np.argmax(prediction[0]), num_classes=4)
# FOR THE DQN #
# DQN #
# perform new move and get new state
gf.do_move(final_move, ai_settings, stats, game_items)
state_new = gf.get_state(ai_settings, stats, game_items)
# set reward for the new state
reward = agent.set_reward(stats.score, stats.ships_left)
# train short memory base on the new action and state
agent.train_short_memory(state_old, final_move, reward, state_new, stats.game_active)
# store the new data into a long term memory
# TO:DO agent.remember(state_old, final_move, reward, state_new, game.crash)
# Get value of played game
# TO:DO record = get_record(game.score, record)
# DQN #
played = True
elif played:
user = ask(game_items.screen)
if len(user) > 0:
coll = connect_and_collect()
add_score(user , stats.score, coll)
played = False
# gf.update_screen(ai_settings, stats, game_items)
# FOR THE DQN #
agent.replay_new(agent.memory)
counter_games += 1
print('Game', counter_games, ' Score:', stats.score)
score_plot.append(stats.score)
counter_plot.append(counter_games)
agent.model.save_weights('weights.hdf5')
plot_seaborn(counter_plot, score_plot)
class AlienInvasion:
"""Overall class to manage game assets and behavior."""
def __init__(self):
"""Initialize the game, and create game resources."""
pygame.init() #初始化所有Pygame模块，主要为了安全
self.settings = Settings() #创建一个Settings类的实例，这样在程序中就可以引用Settings中的属性了
# self.screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN) # display 是一个模块，set_mode 是该模块内部的功能，创建了Pygame.Surface该类的实例，并返回该实例。
self.screen = pygame.display.set_mode((1200, 800))
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.sb = Scoreboard(self)
self.ship = Ship(self) #创建战舰这个类的实例
self.bullets = pygame.sprite.Group()
self.aliens = pygame.sprite.Group()
self._create_fleet()
# Make the play button.
self.play_button = Button(self, "Play")
def _ship_hit(self):
"""Respond to the ship being hit by an alien."""
if self.stats.ships_left > 0:
# Decrement ship_left.
self.stats.ships_left -= 1
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 _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)
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_space_y = (self.settings.screen_height - (3 * alien_height) -
ship_height)
number_rows = available_space_y // (2 * alien_height)
# Create the full 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 the 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 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()
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_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:
self._ship_hit()
break
def _check_bullet_alien_collisions(self):
""" Respond to bullet-alien collision."""
#Remove any bullets and aliens that have collided.
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.sb.prep_score()
self.sb.check_high_score()
if not self.aliens:
self.bullets.empty()
self._create_fleet()
self.settings.increase_speed()
def _update_aliens(self):
"""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()
self._check_aliens_bottom()
def _check_fleet_edges(self):
"""Respond appropriately if any aliens have reched an edge."""
for alien in self.aliens.sprites():
if alien.check_edges():
self._change_fleet_directions()
break
def _change_fleet_directions(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 _check_events(self):
# Watch for keyboard and mouse events.
for event in pygame.event.get(): # 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_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()
self.stats.reset_stats()
self.stats.game_active = True
self.sb.prep_score()
# Hide the mouse cursor.
pygame.mouse.set_visible(False)
# 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()
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):
"""Creat 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 _update_screen(self):
# Redraw the screen during each pass through the loop.
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 the score information
self.sb.show_score()
# Draw the play button if the game is inactive.
if not self.stats.game_active:
self.play_button.draw_button()
# Make the most recently drawn screen visible.
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.count = 0
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 (press 'CTRL + x' to quit)")
# Create an instance to store game statistics and create a scoreboard.
self.stats = GameStats(self)
self.sb = Scoreboard(self)
self.ship = Ship(self)
self.bullets = pygame.sprite.Group()
self.aliens = pygame.sprite.Group()
# Make the Play button.
self.play_button = Button(self, "Play")
def run_game(self):
"""Start the main loop for the game."""
pygame.mixer.Sound.play(self.settings.welcome)
while True:
self._check_events() # Calls helper method
if self.stats.game_active:
self.ship.update(
) # Updates ship's position based on user events
self._update_bullets(
) # Updates the bullet's position when fired
self._update_aliens() # Updates the alien fleet
self._update_screen() # Calls helper method
def _check_events(self):
"""Listen and respond to key presses 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 the player clicks Play button."""
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()
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 aliens and bullets.
self.aliens.empty()
self.bullets.empty()
# Create a new fleet and center the ship.
self._create_fleet()
self.ship.center_ship()
# Hide mouse cursor.
pygame.mouse.set_visible(False)
def _check_keydown_events(self, event):
"""Respond to key press down events."""
if event.key == pygame.K_d:
self.ship.moving_right = True
elif event.key == pygame.K_a:
self.ship.moving_left = True
elif event.key == pygame.K_w:
self.ship.moving_up = True
elif event.key == pygame.K_s:
self.ship.moving_down = True
elif event.key == (pygame.key.get_mods() & pygame.KMOD_CTRL
and pygame.K_x):
sys.exit()
elif event.key == pygame.K_SPACE:
self._fire_bullet()
def _check_keyup_events(self, event):
"""Respond to key up events."""
if event.key == pygame.K_d:
self.ship.moving_right = False
elif event.key == pygame.K_a:
self.ship.moving_left = False
elif event.key == pygame.K_w:
self.ship.moving_up = False
elif event.key == pygame.K_s:
self.ship.moving_down = False
def _fire_bullet(self):
"""Create a new bullet and add it to the bullets group."""
pygame.mixer.Sound.play(self.settings.shoot_sound)
if len(self.bullets) < self.settings.bullets_allowed:
new_bullet = Bullet(self)
self.bullets.add(new_bullet)
def _update_bullets(self):
"""Update position of bullets and get rid of old bullets."""
# Update bullet positions.
self.bullets.update() # Updates the bullet's position
# Get rid of bullets that have disappeared.
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):
"""Respond to bullet-alien collisions."""
# Remove any bullets and aliens that have collided.
collisions = pygame.sprite.groupcollide(self.bullets, self.aliens,
True, True)
if collisions:
pygame.mixer.Sound.play(self.settings.hit)
for aliens in collisions.values():
self.stats.score += self.settings.alien_points * len(aliens)
self.sb.prep_score()
self.sb.check_high_score()
if not self.aliens:
# Destroy existing bullets and create new fleet.
self.bullets.empty()
self._create_fleet()
self.settings.increase_difficulty()
# Increase level.
self.stats.level += 1
self.sb.prep_level()
def _ship_hit(self):
"""Respond to the 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)
self.count = 0
pygame.mixer.Sound.play(self.settings.game_over)
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()
pygame.mixer.Sound.play(self.settings.ship_explode)
break
def _update_aliens(self):
"""
Check if the fleet is at the edge then update the positions in the
fleet.
"""
self._check_fleet_edges()
self.aliens.update()
# Look for alien-ship collisions.
if pygame.sprite.spritecollideany(self.ship, self.aliens):
pygame.mixer.Sound.play(self.settings.ship_explode)
self.count -= 1
self._ship_hit()
# Look for aliens hitting the bottom of the screen.
self._check_aliens_bottom()
def _create_fleet(self):
"""Create the fleet of aliens."""
self.count += 1
if self.count == 1 and self.stats.game_active:
pygame.mixer.Sound.play(self.settings.round_one)
sleep(1.5)
elif self.count == 2:
pygame.mixer.Sound.play(self.settings.round_two)
elif self.count == 3:
pygame.mixer.Sound.play(self.settings.round_three)
elif self.count > 3:
pygame.mixer.Sound.play(self.settings.haha)
# 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)
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_space_y = (self.settings.screen_height - (4 * alien_height) -
ship_height)
number_rows = available_space_y // (2 * alien_height)
# Create the full 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 the 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 direct."""
for alien in self.aliens.sprites():
alien.rect.y += self.settings.fleet_drop_speed
self.settings.fleet_direction *= -1
def _update_screen(self):
"""Update images on screen and flip to show newest 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)
# Draw the score information.
self.sb.show_score()
# Draw the play button if the game is inactive.
if not self.stats.game_active:
self.play_button.draw_button()
# Make the most recently drawn screen visible.
pygame.display.flip()
class AlienInvasion:
def __init__(self):
pygame.init()
self.settings = Settings()
self.screen = pygame.display.set_mode(
(self.settings.screen_width, self.settings.screen_height))
pygame.display.set_caption('Alien Invasion')
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):
while True:
self._check_events()
if self.stats.game_active:
self.ship.update()
self._update_bullets()
self._update_aliens()
self._update_screen()
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_play_button(self, mouse_pos):
button_clicked = self.play_button.rect.collidepoint(mouse_pos)
if button_clicked and not self.stats.game_active:
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)
self.settings.initialize_dynamic_settings()
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 _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.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 _create_fleet(self):
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)
ship_height = self.ship.rect.height
available_space_y = (self.settings.screen_height - (5 * 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_direction()
break
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 _change_fleet_direction(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 _update_screen(self):
self.screen.fill(self.settings.bg_color)
self.ship.blitme()
for bullet in self.bullets.sprites():
bullet.draw_bullet()
self.aliens.draw(self.screen)
if not self.stats.game_active:
self.play_button.draw_button()
self.sb.show_score()
pygame.display.flip()
def run_game():
pygame.init()
ai_settings = Settings()
#pygame.display.set_mode返回一个surface对象
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
bullet_sound = pygame.mixer.Sound('sound/bullet.wav')
bullet_sound.set_volume(0.3)
pygame.mixer.music.load('sound/game_music.wav')
pygame.mixer.music.play(-1, 0.0)
pygame.mixer.music.set_volume(0.25)
enemy1_down_sound = pygame.mixer.Sound("sound/enemy1_down.wav")
enemy2_down_sound = pygame.mixer.Sound("sound/enemy2_down.wav")
enemy3_down_sound = pygame.mixer.Sound("sound/enemy3_down.wav")
game_over_sound = pygame.mixer.Sound('sound/game_over.wav')
enemy1_down_sound.set_volume(0.3)
enemy2_down_sound.set_volume(0.4)
enemy3_down_sound.set_volume(0.5)
game_over_sound.set_volume(0.3)
shoot_frequency = 0
enemy_frequency = 0
background = pygame.image.load("images\\background_1.png").convert()
_game_over = pygame.image.load('images/gameover.png')
game_over = pygame.transform.scale(_game_over, (320, 568))
pygame.display.set_caption("plane_war")
play_button = Button(ai_settings, screen, "play")
stats = GameStats(ai_settings)
s = Score(ai_settings, screen, stats)
plane = Plane(ai_settings, screen)
bullets = Group()
framerate = pygame.time.Clock()
Heroplane = Mysprite(screen)
Heroplane.load("images//hero_plane_1.png", 66, 80, 2)
group = pygame.sprite.Group()
group.add(Heroplane)
enemys = Group()
middle = Group()
middle_frequency = 0
enemies_down = pygame.sprite.Group()
breakplane = Group()
middle_down = pygame.sprite.Group()
bosses = Group()
break_boss = Group()
delay = 0
delay_1 = 0
delay_2 = 0
delay_3 = 0
while True:
framerate.tick(60)
#blit用于在screen上绘制图像
screen.blit(background, (0, 0))
gf.check_events(ai_settings, screen, stats, play_button, plane, enemys,
bullets, bullet_sound, s)
if stats.game_active and not stats.boss_state:
plane.update()
middle.update()
gf.update_bullets(ai_settings, screen, plane, enemys, bullets,
stats, s, shoot_frequency, enemies_down,
enemy1_down_sound, middle, middle_down,
enemy2_down_sound, bosses, break_boss,
enemy3_down_sound)
gf.update_enemys(ai_settings, stats, screen, plane, enemys,
bullets, s, play_button, breakplane,
game_over_sound, enemies_down, middle,
middle_down, bosses)
if enemy_frequency % 60 == 0 and len(
enemys) < ai_settings.min_enemy_number:
gf.create_fleet(ai_settings, screen, plane, enemys)
else:
enemy_frequency += 1
if middle_frequency % 100 == 0 and len(
middle) < ai_settings.min_middle_number:
gf.create_middle_enemys(ai_settings, screen, middle)
else:
middle_frequency += 1
if stats.game_active and stats.boss_state:
plane.update()
gf.update_bullets(ai_settings, screen, plane, enemys, bullets,
stats, s, shoot_frequency, enemies_down,
enemy1_down_sound, middle, middle_down,
enemy2_down_sound, bosses, break_boss,
enemy3_down_sound)
gf.update_bosses(ai_settings, plane, breakplane, stats, s,
game_over_sound, play_button, bosses)
if (len(bosses) <= 0):
gf.create_boss(ai_settings, screen, bosses)
bosses.update()
if not stats.game_active and stats.game_state:
enemys.empty()
bullets.empty()
screen.blit(game_over, (0, 0))
for planes in breakplane:
if delay < 10:
planes.image = pygame.image.load("images\\hero_break1.png")
delay += 1
elif delay < 20:
planes.image = pygame.image.load("images\\hero_break2.png")
delay += 1
elif delay < 30:
planes.image = pygame.image.load("images\\hero_break3.png")
delay += 1
elif delay < 40:
planes.image = pygame.image.load("images\\hero_break4.png")
delay += 1
screen.blit(planes.image, plane.rect)
if delay >= 40:
delay = 0
breakplane.remove(plane)
for enemy_down in enemies_down:
if delay_1 < 10:
enemy_down.image = pygame.image.load("images\\enemy1_1.png")
delay_1 += 1
elif delay_1 < 20:
enemy_down.image = pygame.image.load("images\\enemy1_2.png")
delay_1 += 1
elif delay_1 < 30:
enemy_down.image = pygame.image.load("images\\enemy1_3.png")
delay_1 += 1
elif delay_1 < 40:
enemy_down.image = pygame.image.load("images\\enemy1_4.png")
delay_1 += 1
screen.blit(enemy_down.image, enemy_down.rect)
if delay_1 >= 40:
delay_1 = 0
enemies_down.remove(enemy_down)
for mi_down in middle_down:
if delay_2 < 10:
mi_down.image = pygame.image.load("images\\middle_1.png")
delay_2 += 1
elif delay_2 < 20:
mi_down.image = pygame.image.load("images\\middle_2.png")
delay_2 += 1
elif delay_2 < 30:
mi_down.image = pygame.image.load("images\\middle_3.png")
delay_2 += 1
elif delay_2 < 40:
mi_down.image = pygame.image.load("images\\middle_4.png")
delay_2 += 1
screen.blit(mi_down.image, mi_down.rect)
if delay_2 >= 40:
delay_2 = 0
middle_down.remove(mi_down)
for boss_down in break_boss:
if delay_3 < 10:
boss_down.image = pygame.image.load("images\\boss_1.png")
delay_3 += 1
elif delay_3 < 20:
boss_down.image = pygame.image.load("images\\boss_2.png")
delay_3 += 1
elif delay_3 < 30:
boss_down.image = pygame.image.load("images\\boss_3.png")
delay_3 += 1
elif delay_3 < 40:
boss_down.image = pygame.image.load("images\\boss_4.png")
delay_3 += 1
elif delay_3 < 50:
boss_down.image = pygame.image.load("images\\boss_4.png")
delay_3 += 1
elif delay_3 < 60:
boss_down.image = pygame.image.load("images\\boss_4.png")
delay_3 += 1
screen.blit(boss_down.image, boss_down.rect)
if delay_3 >= 60:
delay_3 = 0
break_boss.remove(boss_down)
gf.update_screen(ai_settings, screen, stats, plane, enemys, bullets,
play_button, s, middle, bosses)
pygame.display.update()
def run_game():
# Initializes background setting needed to run properly
pygame.init()
# Initializes settings
ai_settings = Settings()
# Creates a display window where all of the game's graphic elements are drawn
# The numbers represent the dimensions of the window
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
pygame.display.set_caption("Alien Invasion")
# Delay time
delay = 0
timer = random.randint(400, 1001)
# Create an instance to store game statistics amd create a scoreboard
stats = GameStats(ai_settings)
sb = Scoreboard(ai_settings, screen, stats)
# Makes a ship, group of bullets, alien bullets, group of aliens, and ufos
ship = Ship(ai_settings, screen, stats)
bunkers = Group()
bullets = Group()
aliens_1 = Group()
aliens_2 = Group()
aliens_3 = Group()
alien_bullets = Group()
ufo = Group()
# Make the play button that also contains the startup screen
play_button = Button(screen, "Play", ai_settings, alien_bullets, stats)
score_button = ScoreButton(screen, "High Scores", ai_settings)
back_button = ScoreButton(screen, "Back (B)", ai_settings)
# Starts the main loop for the game
while True:
# Checks for any type of event
gf.check_events(ai_settings, screen, stats, sb, play_button, score_button, ship, aliens_1,
aliens_2, aliens_3, ufo, bullets, alien_bullets, bunkers)
# Creates a new UFO at a random interval
# Delay to prevent too many from spawning at once
if delay == timer:
gf.create_ufo(ai_settings, screen, ufo, alien_bullets, stats)
# plays ufo sound
ai_settings.ufo_sound.play()
delay = 0
timer = random.randint(700, 1001)
else:
delay += 1
# Runs the game is active
if stats.game_active:
ship.update()
gf.update_bullets(ai_settings, screen, stats, sb, ship, aliens_1, aliens_2, aliens_3,
ufo, bullets, alien_bullets, bunkers)
gf.update_aliens(ai_settings, screen, stats, sb, ship, aliens_1, aliens_2, aliens_3,
ufo, bullets, alien_bullets, bunkers)
gf.update_ufo(ai_settings, screen, stats, sb, ship, aliens_1, aliens_2, aliens_3,
ufo, bullets, alien_bullets, bunkers)
# Manages the screen updates
gf.update_screen(ai_settings, screen, stats, sb, ship, aliens_1, aliens_2, aliens_3, ufo,
bullets, alien_bullets, bunkers, play_button, score_button, back_button)
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()
# Window mode
# self.screen = pygame.display.set_mode(
# (self.settings.screen_width, self.settings.screen_height))
# Full screen mode
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 instances to store statistics and results pane.
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()
# Create a Play button.
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()
def _check_events(self):
# Watch for 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_events(event)
elif event.type == pygame.KEYUP:
self._check_keyup_event(event)
elif event.type == pygame.MOUSEBUTTONDOWN:
mouse_pos = pygame.mouse.get_pos()
self._check_play_button(mouse_pos)
def _check_play_button(self, mouse_pos):
"""Launches a new game when the Play button is pressed."""
button_clicked = self.play_button.rect.collidepoint(mouse_pos)
if button_clicked and not self.stats.game_active:
# Reset game settings.
self.settings.initialize_dynamic_settings()
# Reset game statistics.
self.stats.reset_stats()
self.stats.game_active = True
self.sb.prep_score()
self.sb.prep_level()
self.sb.prep_ships()
# Clearing the lists of aliens and projectiles.
self.aliens.empty()
self.bullets.empty()
# Create a new fleet and place the ship in the center.
self._create_fleet()
self.ship.center_ship()
# The mouse pointer is hidden.
pygame.mouse.set_visible(False)
def _check_keydown_events(self, event):
"""Reacts to keystrokes."""
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()
elif event.key == pygame.K_q:
sys.exit()
def _fire_bullet(self):
"""Create a new bullet and add to bullets group"""
if len(self.bullets) < self.settings.bullets_allowed:
new_bullet = Bullet(self)
self.bullets.add(new_bullet)
def _check_keyup_event(self, event):
"""Reacts when keys are released."""
if event.key == pygame.K_RIGHT:
self.ship.moving_right = False
elif event.key == pygame.K_LEFT:
self.ship.moving_left = False
def _create_fleet(self):
"""Create alien fleet."""
# Create alien and calculating the number of aliens in a row
# The spacing between adjacent aliens is equal to the alien's 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)
"""Determines the number of rows that fit on the 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 alien fleet
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 alien and place in row."""
alien = Alien(self)
alien_width, alien_height = alien.rect.size
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.aliens.add(alien)
def _check_fleet_edges(self):
"""Reacts when an alien reaches the edge of the screen."""
for alien in self.aliens.sprites():
if alien.check_edges():
self._change_fleet_direction()
break
def _change_fleet_direction(self):
"""Drops the entire fleet and changes the direction of the fleet."""
for alien in self.aliens.sprites():
alien.rect.y += self.settings.fleet_drop_speed
self.settings.fleet_direction *= -1
def _update_bullets(self):
"""Refresh bullets position and remove the old bullets"""
# Refresh bullets position
self.bullets.update()
# Delete bullets, that went off-screen
for bullet in self.bullets.copy():
if bullet.rect.bottom <= 0:
self.bullets.remove(bullet)
self._check_bullet_alien_collisions()
def _update_aliens(self):
"""Checks if the fleet has reached the edge of the screen, and then updates the position of all aliens in the fleet.."""
self._check_fleet_edges()
self.aliens.update()
# Checking collisions "alien - ship".
if pygame.sprite.spritecollideany(self.ship, self.aliens):
self._ship_hit()
# Check if the aliens have reached the bottom edge of the screen.
self._check_aliens_bottom()
def _check_bullet_alien_collisions(self):
"""Handling collisions between bullets and aliens."""
# Removal of projectiles and aliens involved in collisions.
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.sb.prep_score()
self.sb.check_high_score()
if not self.aliens:
# Destruction of existing shells and creation of a new fleet.
self.bullets.empty()
self._create_fleet()
self.settings.increase_speed()
# level up.
self.stats.level += 1
self.sb.prep_level()
def _ship_hit(self):
"""Handles a collision between a ship and an alien."""
if self.stats.ships_left > 0:
# Decrease ships_left and update scoreboard.
self.stats.ships_left -= 1
self.sb.prep_ships()
# Clearing the lists of aliens and bullets.
self.aliens.empty()
self.bullets.empty()
# Create a new fleet and place the ship in the center.
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):
"""Checks if the aliens have made it to the bottom of the screen."""
screen_rect = self.screen.get_rect()
for alien in self.aliens.sprites():
if alien.rect.bottom >= screen_rect.bottom:
# What happens is the same as in a collision with a ship.
self._ship_hit()
break
def _update_screen(self):
# Redraw the screen during each pass through the loop.
self.screen.fill(self.settings.bg_color)
self.ship.blitme()
for bullet in self.bullets.sprites():
bullet.draw_bullet()
self.aliens.draw(self.screen)
# Displaying information about the account.
self.sb.show_score()
# The Play button is displayed if the game is inactive.
if not self.stats.game_active:
self.play_button.draw_button()
# Make the most recently drawn screen visible.
pygame.display.flip()
# Framerate
clock.tick(30)
def run_game():
# initialize pygame, clock, settings, and screen objects
pygame.init()
clock = pygame.time.Clock()
p_settings = Settings()
screen = pygame.display.set_mode(
(p_settings.screen_width, p_settings.screen_height))
screen_rect = screen.get_rect()
pygame.display.set_caption("Pong")
# create the game over message
play_button = Button(screen, "Play")
# Create an instance to store game statistics, and a scoreboard.
stats = GameStats(p_settings)
sb = Scoreboard(p_settings, screen, stats)
# set the background color
bg_color = (230, 230, 230)
# make a paddle
paddle_right = Paddle(p_settings, screen, 'right', 'vert')
paddle_left = Paddle(p_settings, screen, 'left', 'vert')
paddle_tr = Paddle(p_settings, screen, 'tr', 'hor')
paddle_tl = Paddle(p_settings, screen, 'tl', 'hor')
paddle_br = Paddle(p_settings, screen, 'br', 'hor')
paddle_bl = Paddle(p_settings, screen, 'bl', 'hor')
# make a ball
ball = Ball(p_settings, screen)
balls = Group(ball)
# make a group of paddles
paddles = Group(paddle_right, paddle_left, paddle_tr, paddle_tl, paddle_br,
paddle_bl)
# start screen
gi.Game_Intro(p_settings, screen, stats, sb, play_button, paddles, ball,
paddle_right, paddle_tr, paddle_br, clock)
# start the main loop for the game
while True:
gf.check_events(p_settings, screen, stats, sb, play_button, paddles,
ball, paddle_right, paddle_tr, paddle_br)
if stats.game_active:
gf.track_ball(ball, paddle_left, paddle_tl, paddle_bl)
paddle_right.update()
paddle_tr.update()
paddle_br.update()
paddle_left.update()
paddle_tl.update()
paddle_bl.update()
paddles.update()
ball.update()
# print ("game active")
gf.check_ball_paddle_collisions(p_settings, screen, ball,
paddle_right, paddle_left,
paddle_tr, paddle_tl, paddle_br,
paddle_bl)
# print("player score " + str(stats.p_score))
# print("ai score " + str(stats.ai_score))
gf.update_screen(p_settings, screen, paddles, ball, sb, stats,
play_button, paddle_right, paddle_left, paddle_tr,
paddle_tl, paddle_br, paddle_bl)
gf.check_ball_out(p_settings, screen, screen_rect, stats, sb, paddles,
ball, paddle_right, paddle_left, paddle_tr,
paddle_tl, paddle_br, paddle_bl)
# checks if score limit has been reached
if stats.ai_score == 5 or stats.p_score == 5:
# game over screen
go.Game_Over(p_settings, screen, stats, sb, play_button, paddles,
ball, paddle_right, paddle_tr, paddle_br, clock)
stats.reset_stats()
sb.prep_p_score()
sb.prep_ai_score()
# set the game fps
clock.tick(60)
def check_high_score(stats: GameStats, game_items: GameItems):
"""Check if high score is achieved."""
if stats.score > stats.high_score:
stats.high_score = stats.score
game_items.sb.prep_high_score()
class AlienInvasion:
"""Overall class to manage game assets and behavior."""
def __init__(self):
"""Initialize the game, and create game resources."""
pygame.init(
) # initilizes the background setting that pygame needs to work properly
self.settings = Settings(
) # asign instance of settings to self.settings
self.screen = pygame.display.set_mode(
(0, 0), pygame.FULLSCREEN
) # tells pygame to figure out a window size taht will fill screen
self.settings.screen_width = self.screen.get_rect().width
self.settings.screen_height = self.screen.get_rect().height
pygame.display.set_caption(
"Alien Invasion"
) # self.screen is a SUFRACE, each element can be returned by display.set_mode
# create an instance to store game statistics and create a scoreboard
self.stats = GameStats(self)
self.sb = Scoreboard(self)
self.ship = Ship(
self) # make an instance of Ship after the screen had been created
self.bullets = pygame.sprite.Group() # storing bullets in a group
self.aliens = pygame.sprite.Group() # storing aliens in a group
self._create_fleet()
# make the Play Button
self.play_button = Button(
self, "Play"
) # creates an instance of the button but does not draw button to the screen
# set the background color.
self.bg_color = (
230,
230,
230,
) # light grey = background equal amounts (red, green, blue)
def run_game(self):
"""Start the main loop for the game."""
while (
True
): # while loop that runs continually and includes event loop (for loop)
# watche for keyboard and mouse events. #EVENT: an action that the user performs while playing the game ( pressing key or moving the mouse)
self._check_events(
) # even if game is inactive, still need to call _check_events
if self.stats.game_active:
self.ship.update()
self._update_bullets()
self._update_aliens()
self._update_screen(
) # must continually update the screen, while waiting to see the player choose to start a new game
# redraw the screen during the pass thorugh the loop.
def _check_events(self): # make new check events method
"""Rspond 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)
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) # button_clicked stores T/F
if (
button_clicked and not self.stats.game_active
): # game will only restart in Play is clicked AND the game is not currently active
# reset the game settings.
self.settings.initialize_dynamic_settings()
# reset the game statistics
self.stats.reset_stats()
self.stats.game_active = True
self.sb.prep_score()
# 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()
# hide the mouse cursor.
pygame.mouse.set_visible(False)
def _check_keydown_events(self, event):
"""respond to keypress"""
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: # exit out of screen by pressing "q"
sys.exit()
elif event.key == pygame.K_SPACE: # call _fire_bullet whith the space bar
self._fire_bullet()
def _check_keyup_events(self, event):
"""respond to keyreleases"""
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):
"""create a new bullet and add it to the bullets group."""
if len(self.bullets) < self.settings.bullets_allowed:
# if the number of bullets still available to the player then....
new_bullet = Bullet(self) # make an instance of Bullet
self.bullets.add(
new_bullet) # add it to the bullet group using add()
def _update_bullets(self):
# update bullet position
self.bullets.update() # storign bullets in a group
# get rid oof bullets that have disappeared.
for (bullet) in (
self.bullets.copy()
): # copy() method in the for loop allows us to modify bullets inside the loop
if (bullet.rect.bottom <=
0): # check to see if each bullet has moved off the screen
self.bullets.remove(
bullet
) # remove the bullets if they are no longer on the screen
self._check_bullet_aliens_collisions()
def _check_bullet_aliens_collisions(self):
"""Respond to bullet-alien collisions."""
# check for any bullets that have hit aliens.
# if so, get rid of the bullet and the alien.
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.sb.prep_score()
if not self.aliens: # check is alien group is empty
# destroy existing bullets and create a new fleet
self.bullets.empty()
self._create_fleet()
self.settings.increase_speed()
def _update_aliens(self):
"""check if the fleet is at an edge"""
self._check_fleet_edges()
"""Update the positions of all aliens in the fleet."""
self.aliens.update()
# look for alien-ship collisions.
# spritecollideany() takes two arguments, a sprite and a group, in this case loops through the group aliens
if pygame.sprite.spritecollideany(self.ship, self.aliens):
self._ship_hit() # calling _ship_hit when an alien hits a ship
# look for aliens hitting the bottom of the screen.
self._check_aliens_bottom()
def _create_fleet(self):
"""Create the fleet of aliens."""
# creating an alien and find the number of aliens in a row
# spacing between each alien 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 the number of rows of aliens that fit on the 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 the full 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 the 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(
)): # loop thorugh alien and call check_edges on each alien
if alien.check_edges():
self._change_fleet_direction(
) # if check_edges returns true, the fleet changes 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
) # loop through all aliens, a drop each one using the fleet_drop _speed
self.settings.fleet_direction *= -1
def _ship_hit(self):
"""Respond to the ship being hit by an alien."""
# the following tests to be sure that the player has atleast one ship remaining, if they do not, game_active is set to false
if self.stats.ships_left > 0:
# Decrement ships_left.
self.stats.ships_left -= 1 # number of ships left is reduced by 1
# 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
) # so the play can see that they have been hit for half a second
else:
self.stats.game_active = False
pygame.mouse.set_visible(True)
def _check_aliens_bottom(self):
"""check if any aliens have reached the bottome 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
def _update_screen(self):
"""update images on the screen, and flip to the new screen."""
self.screen.fill(
self.settings.bg_color
) # Fill method, acts on the surface and take one argument a color
self.ship.blitme(
) # after filling background, this draw ships to appear on top of back ground
for (bullet) in (
self.bullets.sprites()
): # sprite method returns a list of all sprites in the group bullets, loop through the sprites
bullet.draw_bullet() # and call draw_bullet on each one
self.aliens.draw(self.screen)
# draw the score information
self.sb.show_score()
# draw the play button if the game is inactive
if not self.stats.game_active:
self.play_button.draw_button()
# make the most recently drawn screen visible.
pygame.display.flip(
) # tells pygame to make the most recently drawn screen visible, continually updates to show the
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.screen = pygame.display.set_mode((1200, 800))
# self.settings.screen_width = self.screen.get_rect().width
# self.settings.screen_height = self.screen.get_rect().height
# # A part of the screen where a game can be displayed.
self.screen = pygame.display.set_mode(
(self.settings.screen_width, self.settings.screen_height))
pygame.display.set_caption("Alien Invasion")
# Create an instance to store game statistics.
self.stats = GameStats(self)
self.ship = Ship(self)
self.bullets = pygame.sprite.Group()
self.aliens = pygame.sprite.Group()
self._create_fleet()
# Set the background color:
self.bg_color = (230, 230, 230)
# Make the play button:
self.play_button = Button(self, "Play")
# Create an instance to store game statistics, and
# create scoreboard.
self.stats = GameStats(self)
self.sb = Scoreboard(self)
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.bullets.update()
self._update_aliens()
self._delete_old_bullets()
self._update_screen()
def _update_aliens(self):
""" Update the positions of all aliens in the fleet."""
"""
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()
# 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 _delete_old_bullets(self):
""" Update position of bullets and get rid of old bullets."""
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):
"""Respond to bullet-alien collisions."""
# Remove any bullets and aliens that have collided.
# # Check for any bullets that have it aliens.
# If so, get rid of the bullet and the alien.
collisions = pygame.sprite.groupcollide(self.bullets, self.aliens,
True, True)
if collisions:
# self.stats.score += self.settings.alien_points
for aliens in collisions.values():
self.stats.score += self.settings.alien_points + len(aliens)
self.sb.prep_score()
self.sb.check_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 _check_events(self):
# Watch for the 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_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_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 self.play_button.rect.collidepoint(mouse_pos):
# Reset the game settings:
self.settings.initialize_dynamic_settings()
# Reset the game statistics.
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 aliens and bullets.
self.aliens.empty()
self.bullets.empty()
# Create a new fleet and center the ship.
self._create_fleet()
self.ship.center_ship()
# Hide the mouse cursor.
pygame.mouse.set_visible(False)
def _update_screen(self):
# Redraw the screen during each pass through the loop.
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 the score informtion.
self.sb.show_score()
# Draw the play button if the game is inactive.
if not self.stats.game_active:
self.play_button.draw_button()
# Make the most recently drawn screen visible.
pygame.display.flip()
def _check_keydown_events(self, event):
if event.key == pygame.K_RIGHT:
# Move the ship to the right:
self.ship.moving_right = True
elif event.key == pygame.K_LEFT:
self.ship.moving_left = True
elif event.key == pygame.K_q:
print("Bye ...")
sys.exit(0)
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:
""" Create a new bullet and add it to the bullets group """
new_bullet = Bullet(self)
self.bullets.add(new_bullet)
def _create_fleet(self):
""" Create the fleet of aliens. """
# Make an alien:
alien = Alien(self)
# alien_width = alien.rect.width
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_space_y = (self.settings.screen_height - (3 * alien_height) -
ship_height)
number_rows = available_space_y // (2 * alien_height)
# Create the full 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 a row """
# Create an alien and place it in a row:
alien = Alien(self)
#alien_width = alien.rect.width
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 appropiately 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 _ship_hit(self):
# Decrement ships_left, and update scoreboard.
if self.stats.ships_left > 0:
# Decrement ships_left.
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 ship got hit.
self._ship_hit()
break
class AlienInvasion:
"""Overall Class"""
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
# self.screen = pygame.display.set_mode(
# (self.settings.screen_width, self.settings.screen_height)
# )
# self.screen = pygame.display.set_mode((1200,800))
pygame.display.set_caption("Alien Invasion")
# Create an instance to stats, and create a scoreboard
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()
# Create the Button
self.play_button = Button(self, "Play")
def run_game(self):
"""Begin game loop"""
while True:
self._check_events()
if self.stats.game_active:
# These functions will only run when the game is active
self.ship.update()
self._update_bullets()
self._update_aliens()
self._update_screen()
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)
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()
# Reset the game stats
self.stats.reset_stats()
self.stats.game_active = True
self.sb.prep_score()
self.sb.prep_level()
self.sb.prep_ships()
# remove 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()
# Hide the mouse cursor
pygame.mouse.set_visible(False)
# Keydown functions
def _check_keydown_events(self, event):
"""When a key is pressed down"""
if event.key == pygame.K_RIGHT:
self.ship.moving_right = True
if 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()
# Key Up functions
def _check_keyup_events(self, event):
"""When a key is released"""
if event.key == pygame.K_RIGHT:
self.ship.moving_right = False
if event.key == pygame.K_LEFT:
self.ship.moving_left = False
# Firing Bullets
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 _update_bullets(self):
"""Update position of bullets and get rid of old bullets"""
# update bullet positions
self.bullets.update()
# Remove bullets once they get off screen to save memory
for bullet in self.bullets.copy():
if bullet.rect.bottom <= 0:
self.bullets.remove(bullet)
self._check_bullet_alien_collision()
def _check_bullet_alien_collision(self):
"""Respond to bullet alien collision"""
# Remove any bullets and aliens that collided
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.sb.prep_score()
self.sb.check_high_score()
if not self.aliens:
# Remove existing bullets and create a new fleet
self.bullets.empty()
self._create_fleet()
self.settings.increase_speed()
# Increase the level
self.stats.level += 1
self.sb.prep_level()
def _update_aliens(self):
"""check if alien is at the edge, then update the positions of all aliens"""
self._check_fleet_edges()
self.aliens.update()
# alien and ship collision
if pygame.sprite.spritecollideany(self.ship, self.aliens):
self._ship_hit()
# Look for any aliens that hit the bottom of the screen
self._check_aliens_bottom()
def _check_aliens_bottom(self):
""" When an alien reaches the bottom of the screen"""
screen_rect = self.screen.get_rect()
for alien in self.aliens.sprites():
if alien.rect.bottom >= screen_rect.bottom:
# reset fleet and decrease lives by 1
self._ship_hit()
break
def _ship_hit(self):
"""Respond to the ship being hit by an alien"""
if self.stats.ships_left > 0:
# Decrease the amount of ships left, and update scoreboard
self.stats.ships_left -= 1
self.sb.prep_ships()
# remove all remaining ships and bullets
self.aliens.empty()
self.bullets.empty()
# Create a new fleet and center the ship
self._create_fleet()
self.ship.center_ship()
# Pause the game for player to realize the collision
sleep(0.5)
else:
self.stats.game_active = False
pygame.mouse.set_visible(True)
def _create_fleet(self):
"""Create the alien fleet"""
alien = Alien(self)
# Figure out how many aliens can fit in one row
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)
# Create the number of rows that would fit on one screen
ship_height = self.ship.rect.height
available_space_y = (self.settings.screen_height - (9 * alien_height) -
ship_height)
number_rows = available_space_y // (2 * alien_height)
# Create the alien fleet
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 the row"""
# Make the aliens
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 if alien reaches the edge of the screen"""
for alien in self.aliens.sprites():
if alien.check_edges():
self._change_fleet_direction()
break
def _change_fleet_direction(self):
"""Drop the fleet and change directions"""
for alien in self.aliens.sprites():
alien.rect.y += self.settings.fleet_drop_speed
self.settings.fleet_direction *= -1
def _update_screen(self):
"""Update images and flip to a 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)
# Draw the score information
self.sb.show_score()
# Draw the play button if the game is inactive
if not self.stats.game_active:
self.play_button.draw_button()
pygame.display.flip()
def run_game():
# 初始化游戏并创建一个屏幕对象
pygame.init() #初始化背景设置
gf.music_run() #开启音乐
ai_settings = Settings() #创建设置类对象
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height)) #设置分辨率
pygame.display.set_caption("thunder plane") #设置标题
background = pygame.image.load('images/timg.jpg').convert() # 设置背景图片
# 创建Play按钮
play_button = Button(ai_settings, screen, "Play")
#创建一个用于存储游戏统计信息的实例,并创建记分牌
stats = GameStats(ai_settings)
sb = Scoreboard(ai_settings, screen, stats)
#创建一艘飞船，一个子弹编组和一个外星人编组
ship = Ship(ai_settings, screen)
bullets = Group()
aliens = Group()
bbulets = Group()
boss = Boss(ai_settings, screen)
# 标志信息0,1,5为提示框提示开关
# 标志信息2为大招2不加点数开关
# 标志信息3是给boss血量初始化开关
# 标志信息4是boss每隔几秒发射子弹开关
flag = [1, 1, 1, 1, 1, 1]
#创建外星人群
gf.create_fleet(ai_settings, screen, ship, aliens)
#开始游戏主循环
while True:
#监视键盘和鼠标事件
gf.check_events(ai_settings, screen, stats, sb, play_button, ship,
aliens, bullets, flag, bbulets)
#检查提示框是否触发
gf.check_message(stats, flag, ai_settings)
if stats.game_active and stats.level < ai_settings.boss_level:
#根据移动标志调整飞船的位置
ship.update()
#更新子弹位置，并删除已经消失的子弹
gf.update_bullets(ai_settings, screen, stats, sb, ship, aliens,
bullets, flag)
gf.update_aliens(ai_settings, stats, sb, screen, ship, aliens,
bullets)
#如果到达相应的级别触发boss站
if stats.game_active and stats.level == ai_settings.boss_level:
aliens.empty()
#根据移动标志调整飞船的位置
ship.update()
#更新子弹位置，并删除已经消失的子弹
if flag[3]:
stats.boss_blood = 10000 #重新给boss赋值
flag[3] = 0
gb.update_bullets(ai_settings, screen, stats, sb, ship, boss,
bullets, play_button, bbulets)
gb.update_boss(ai_settings, stats, sb, screen, ship, boss, bullets,
bbulets, flag)
#更新屏幕上的图像,并切换到新屏幕
gf.update_screen(ai_settings, screen, stats, sb, ship, aliens, bullets,
play_button, background, boss, bbulets)
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.
self.stats = GameStats(self)
self.ship = Ship(self)
self.bullets = pygame.sprite.Group()
self.aliens = pygame.sprite.Group()
self._create_fleet()
self.score = Score(self)
self.score.scoring()
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()
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)
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_q:
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:
self.ship.moving_right = False
elif event.key == pygame.K_LEFT:
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 _update_bullets(self):
"""Update position of bullets and get rid of old bullets."""
# Update bullet positions.
self.bullets.update()
# Get rid of bullets that have disappeared.
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):
"""Respond to bullet-alien collisions."""
# Remove any bullets and aliens that have collided.
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.score.scoring()
if not self.aliens:
# Destroy existing bullets and create new fleet.
self.bullets.empty()
self._create_fleet()
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()
# 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 _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
def _ship_hit(self):
"""Respond to the ship being hit by an alien."""
if self.stats.ships_left > 0:
savescore = self.stats.score
with open('score_history.txt', 'a', encoding = 'utf-8') as file:
file.write(f'Score: {savescore}\n')
self.stats.reset_stats()
# Decrement ships_left.
self.stats.ships_left -= 1
# 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
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)
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_space_y = (self.settings.screen_height - (3 * alien_height) - ship_height)
number_rows = available_space_y // (2 * alien_height)
# Create the full fleet of aliens.
for row_number in range(number_rows):
result = row_number % 2
if result != 0:
image = pygame.image.load('images/alien1.png')
for alien_number in range(number_aliens_x):
self._create_alien(alien_number, row_number,image)
elif result == 0:
image = pygame.image.load('images/alien2.png')
for alien_number in range(number_aliens_x):
self._create_alien(alien_number, row_number,image)
def _create_alien(self, alien_number, row_number, image):
"""Create an alien and place it in the row."""
alien = Alien(self)
alien.image = image
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):
"""Update images on the screen, and flip to the 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.score.display_score()
pygame.display.flip()
class AlienInvasion:
"""Класс для управления ресурсами и поведением игры."""
def __init__(self):
"""Инициализирует игру и создает игровые ресурсы."""
global ai
pygame.init()
self.settings = Settings()
if self.settings.fullscreen:
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
else:
self.screen = pygame.display.set_mode((self.settings.screen_width,
self.settings.screen_height))
pygame.display.set_caption("Alien Invasion")
# Создание экземпляра для хранения игровой статистики.
self.stats = GameStats(self)
self.sb = Scoreboard(self)
self.ship = Ship(self)
self.hero = Hero(self.screen)
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 _check_keydown_enents(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_enents(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 _check_events(self):
"""Отслеживание событий клавиатуры и мыши."""
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
elif event.type == pygame.KEYDOWN:
self._check_keydown_enents(event)
elif event.type == pygame.KEYUP:
self._check_keyup_enents(event)
elif event.type == pygame.MOUSEBUTTONDOWN:
mouse_pos = pygame.mouse.get_pos()
self._check_play_button(mouse_pos)
def _check_play_button(self, mouse_pos):
"""Запускает новую игру при нажатии кнопки Play."""
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)
def _fire_bullet(self):
"""Создание нового снаряда и включение его в группу bullets."""
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
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 _check_fleet_edges(self):
"""Реагирует на достижение пришельцем края экрана."""
for alien in self.aliens.sprites():
if alien.check_edges():
self._change_fleet_direction()
break
def _change_fleet_direction(self):
"""Опускает весь флот и меняет направление флота."""
for alien in self.aliens.sprites():
alien.rect.y += self.settings.fleet_drop_speed
self.settings.fleet_direction *= -1
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.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_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_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 _ship_hit(self):
"""Обрабатывает столкновение корабля с пришельцем."""
if self.stats.ships_left > 0:
# Уменьшение ships_left.
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 _update_screen(self):
"""Отображение последнего прорисованного экрана."""
self.screen.fill(self.settings.bg_color)
self.ship.blitme()
self.hero.blitme()
for bullet in self.bullets.sprites():
bullet.draw_bullet()
self.aliens.draw(self.screen)
self.sb.show_score()
# Кнопка Play отображается в том случае, если игра неактивна.
if not self.stats.game_active:
self.play_button.draw_button()
pygame.display.flip()
class AlienInvasion:
"""Overall class to manage game assets and behavior."""
def __init__(self):
"""Initialize the game, and creat game resources."""
# Initializes the background settings that Pygame
# needs to work properly.
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
# If you prefer run game in window mode, comment the above three lines,
# and uncomment the following code.
# self.screen = pygame.display.set_mode((self.settings.screen_width,
# self.settings.screen_height))
pygame.display.set_caption("Alien Invasion")
# Create an instance to store game statistics and create a scoreboard.
self.stats = GameStats(self)
self.sb = Scoreboard(self)
# Make the Start Game button.
self.play_button = Button(self, "Start Game")
self.ship = Ship(self)
# 'self' here is the argument that refers to the parameter 'ai_game'
# in the Ship class. Indicating the current instance of AlienInvasion.
self.bullets = pygame.sprite.Group()
self.aliens = pygame.sprite.Group()
self._create_fleet()
def run_game(self):
"""Start the main loop for the game."""
while True:
self._check_events()
# The parts that only run when the game is active.
if self.stats.game_active:
self.ship.update()
self._update_bullets()
self._update_aliens()
self._update_screen()
def _check_events(self):
"""Respond to key and mouse events."""
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit() # Here is the place using the sys module
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):
"""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_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:
self.ship.moving_right = False
elif event.key == pygame.K_LEFT:
self.ship.moving_left = False
def _check_play_button(self, mouse_pos):
"""
Start a new game only when the player clicks the Start Game button.
"""
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()
# Reset the game statistics.
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 aliens and bullets.
self.aliens.empty()
self.bullets.empty()
# Create a new fleet and center the ship.
self._create_fleet()
self.ship.center_ship()
# Hide the mouse cursor.
pygame.mouse.set_visible(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 _update_bullets(self):
"""Update position of bullets and get rid of old bullets."""
# Update bullet positions.
self.bullets.update()
# Get rid of bullets that have disappeared.
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):
"""Respond to bullet-alien collisions."""
# Remove any bullets and aliens that have collided.
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.sb.prep_score()
self.sb.check_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 _create_fleet(self):
"""Create the fleet of aliens."""
# Create an alien and find the number of aliens in a row.
# Spacing between each aliens is equal to one alien width.
# This alien is created for calculations, won't be added to the Group.
alien = Alien(self)
alien_width, alien_height = alien.rect.size
# Determine the number of aliens that fit in one row.
available_space_x = self.settings.screen_width - (4 * 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_space_y = (self.settings.screen_height - (6 * alien_height) -
ship_height)
number_rows = available_space_y // (2 * alien_height)
# Create the full 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 the 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.y = alien_height + 2 * alien_height * row_number
alien.rect.y = alien.y
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 _check_aliens_bottom(self):
"""Check if any alien has 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
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()
# 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 the ship being hit by an alien"""
if self.stats.ships_remains > 0:
# Decrement ships_remains, and update scoreboard.
self.stats.ships_remains -= 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 game before a new round starts.
sleep(1)
else:
self.stats.game_active = False
pygame.mouse.set_visible(True)
def _update_screen(self):
"""Update (redraw) images on the screen, and flip to the new screen."""
# Redraw the screen each pass through the loop,
# not needed if a background image exists
# self.screen.fill(self.settings.bg_color)
self.screen.blit(self.settings.bg_image, self.settings.bg_rect)
self.ship.blitme()
for bullet in self.bullets.sprites():
bullet.draw_bullet()
self.aliens.draw(self.screen)
# Draw the score information.
self.sb.show_score()
# Draw the play button if the game is inactive.
if not self.stats.game_active:
self.play_button.draw_button()
# Make the most recently drawn screen visible.
pygame.display.flip()
class AlienInvasion:
def __init__(self):
pygame.init()
self.settings = Settings()
self.screen = pygame.display.set_mode(
(self.settings.screen_width, self.settings.screen_height))
pygame.display.set_caption("Alien Invasion")
#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
# Create an instance to store game statistics, and creat a scoreboard
self.stats = GameStats(self)
self.sb = Scoreboard(self)
self.ship = Ship(self)
self.bullets = pygame.sprite.Group()
self.aliens = pygame.sprite.Group()
#self._create_AlienGrid()
self._create_AlienBoss()
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 _check_events(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit(0)
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_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:
# Rese the game statistices.
self.settings.initialize_dynamic_settings()
self.stats.reset_stats()
self.stats.game_active = True
self.sb.prep_score()
# Hide the mouse cursor.
pygame.mouse.set_visible(False)
# Get rid of any remaining aliens and bullets.
self.aliens.empty()
self.bullets.empty()
# Create a new fleet and center the ship
self._create_AlienBoss
self.ship.center_ship()
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(0)
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_AlienGrid(self):
alien = Alien(self, False)
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)
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_AlienBoss(self):
self._create_alien(20, 80)
self._create_alien(780, 200)
def _create_alien(self, xlocation, ylocation):
alien = Alien(self)
alien.x = xlocation
alien.rect.x = alien.x
alien.y = ylocation
alien.rect.y = alien.y
self.aliens.add(alien)
def _update_bullets(self):
self.bullets.update()
collisons = pygame.sprite.groupcollide(self.bullets, self.aliens, True,
True)
for bullet in self.bullets.copy():
if bullet.rect.bottom <= 0:
self.bullets.remove(bullet)
print(len(self.bullets))
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(AlienBoss)
self.sb.prep_score()
if not self.aliens:
self.bullets.empty()
#self._create_AlienGrid()
self._create_AlienBoss()
self.settings.increase_speed()
def _check_fleet_edges(self):
for alien in self.aliens.sprites():
if alien.check_edges():
self._change_fleet_direction()
break
def _change_fleet_direction(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.aliens.empty()
self.bullets.empty()
#self._create_AlienGrid()
self._create_AlienBoss()
self.ship.center_ship()
sleep(0.5)
else:
self.stats.game_active = False
pygame.mouse.set_visible(Ture)
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 _update_aliens(self):
self._check_fleet_edges()
self.aliens.update()
if pygame.sprite.spritecollideany(self.ship, self.aliens):
self._ship_hit()
print("Ship Hit!!!")
self._check_aliens_bottom()
def _update_screen(self):
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 teh score information.
self.sb.show_score()
# Draw the play button if the game is inactive.
if not self.stats.game_active:
self.play_button.draw_button()
pygame.display.flip()
class AlienInvasion:
'''Класс для управления ресурсами и поведением игры'''
def __init__(self):
'''Инициализирует игру и создает игровые ресурсы'''
# pygame.init() - эта строчка есть в книге, но не влияет на запуск кода
self.settings = Settings()
self.screen = pygame.display.set_mode(
(self.settings.screen_width, self.settings.screen_height))
pygame.display.set_caption('Alien Invasion. Meow')
self.stats = GameStats(self)
self.sb = Scoreboard(self)
self.ship = Ship(self)
self.bullet = pygame.sprite.Group()
self.aliens = pygame.sprite.Group()
self._create_fleet()
# Создание кнопки Play
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 _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_play_button(self, mouse_pos):
''' Запускает новую игру по нажатию кнопки Play '''
button_clicked = self.play_button.rect.collidepoint(mouse_pos)
if button_clicked and not self.stats.game_active:
# Сброс игровой статистики и настроек
self.stats.reset_stats()
self.stats.game_active = True
self.settings.initialize_dynamic_settings()
self.sb.prep_level()
self.sb.prep_ships()
# Очистка списка пришельцев и снарядов
self.aliens.empty()
self.bullet.empty()
# Создание нового флота и размещение корабля в центре
self._create_fleet()
self.ship.center_ship()
# Указатель мыши скрывается
pygame.mouse.set_visible(False)
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):
'''Создание нового снаряда и вкл. его в группу bullets'''
if len(self.bullet) < self.settings.bullet_allowed:
new_bullet = Bullet(self)
self.bullet.add(new_bullet)
def _update_bullets(self):
'''Обновляет позиции снарядов и уничтожает старые снаряды'''
# Обновляет позиции снарядов
self.bullet.update()
# Удаление снарядов, вышедших за экран
for bullet in self.bullet.copy():
if bullet.rect.bottom <= 0:
self.bullet.remove(bullet)
self._check_bullet_alien_collisions()
def _check_bullet_alien_collisions(self):
''' Обработка коллизий снарядов с пришельцами '''
if not self.aliens:
# Уничтожение текужих сарядов и создание нового флота
self.bullet.empty()
self._create_fleet()
self.settings.increase_speed()
self.stats.level += 1
self.sb.prep_level()
# проверка попадания в пришельцев
# При обнаружени попадания удалить снаряд и пришельца
collisions = pygame.sprite.groupcollide(self.bullet, self.aliens, True,
True)
if collisions:
for alien in collisions.values():
self.stats.score += self.settings.alien_points * len(alien)
self.sb.prep_score()
#self.sb.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.rect.height + 2 * alien.rect.height * row_number
self.aliens.add(alien)
def _create_fleet(self):
''' Создать флот'''
# Создание пришельца
alien = Alien(self)
alien_width, alien_height = alien.rect.size
avalibale_space_x = self.settings.screen_width - (2 * alien_width)
number_aliens_x = avalibale_space_x // (2 * alien_width)
self.aliens.add(alien)
# определяет количество рядов, помещ. на экране
ship_height = self.ship.rect.height
available_spase_y = (self.settings.screen_height - (2 * alien_height) -
ship_height)
number_rows = available_spase_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 _update_aliens(self):
''' обнвляет позицию всех пришельцев во флоте '''
self.aliens.update()
self._check_fleet_edges()
# Проверка коллизий "пришелец - корабль"
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_direction()
break
def _change_fleet_direction(self):
''' Опускает весь флот и меняет направление флота'''
for alien in self.aliens.sprites():
alien.rect.y += self.settings.fleet_drop_speed
self.settings.fleet_direction *= -1
def _ship_hit(self):
''' Обрабатывает столкновение корабля с пришельцом '''
# Уменьшает ship_left
if self.stats.ship_left > 0:
self.stats.ship_left -= 1
self.sb.prep_ships()
# Очистка пришельцев и снарядов
self.aliens.empty()
self.bullet.empty()
# Создание нового флота и размещение корабля в центре
self._create_fleet()
self.ship.center_ship()
# Пауза
sleep(1.1)
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 _update_screen(self):
# При каждом проходе цикла перерисовывается цвет экрана
self.screen.fill(self.settings.bg_color)
self.ship.blitme()
for bullet in self.bullet.sprites():
bullet.draw_bullet()
self.aliens.draw(self.screen)
# Выводит информацию о счёте
self.sb.show_score()
#Кнопка Play отображается только если игра неактивна
if not self.stats.game_active:
self.play_button.draw_buton()
# Отображение последнего прорисованного экрана
pygame.display.flip()
def run_game():
# 初始化游戏并创建一个屏幕对象：初始化背景设置,让Pygame能够正确地工作
pygame.init()
# 初始化全部音频，并加载爆炸声音乐
pygame.mixer.init()
# 爆炸声
explode_sound = pygame.mixer.Sound("sound\EXPLO6.wav")
# 子弹射击的声音
bullet_sound = pygame.mixer.Sound("sound\shot1.wav")
pw_settings = Settings()
"""实参(1200, 800)是一个元组，指定了游戏窗口的尺寸。
通过将这些尺寸值传递给pygame.display.set_mode()
我们创建了一个宽1200像素、高800像素的游戏窗口"""
"""调用pygame.display.set_mode()来创建一个名为screen的显示窗口，
这个游戏的所有图形元素都将在其中绘制。每个元素（如外星人或飞船）都是一个surface对象"""
screen = pygame.display.set_mode(
(pw_settings.screen_width, pw_settings.screen_height))
# 窗口标题
pygame.display.set_caption('Plane War')
# 创建Play按钮
play_button = Button(pw_settings, screen, "Play")
# 创建一个用于存储游戏统计信息的实例，并创建记分牌
stats = GameStats(pw_settings)
sb = Scoreboard(pw_settings, screen, stats)
# 创建一艘飞船、一个子弹编组和一个外星人编组
# 创建一艘飞船
ship = Ship(pw_settings, screen)
# 创建一个用于存储子弹的编组，添加进去实例后对bullets调用 就能对bullets里面的每个bullet调用
bullets = Group()
# 创建一个外星人编组
aliens = Group()
# 创建外星人群
gf.create_fleet(pw_settings, screen, aliens)
timer = 1
# 开始游戏的主循环
while True:
timer += 1
gf.check_events(pw_settings, screen, stats, sb, play_button, ship,
aliens, bullets, bullet_sound)
if stats.game_active:
ship.update()
gf.update_bullets(pw_settings, screen, stats, sb, ship, aliens,
bullets, explode_sound)
gf.update_aliens(pw_settings, screen, stats, sb, ship, aliens,
bullets)
gf.update_screen(pw_settings, screen, stats, sb, ship, aliens, bullets,
play_button)
class SpaceImpact:
"""Main 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_width, self.settings.screen_height),
HWSURFACE | DOUBLEBUF | RESIZABLE)
pygame.display.set_caption("Space Impact")
self.ship = Ship(self)
self.bullets = pygame.sprite.Group()
self.aliens = pygame.sprite.Group()
self._create_fleet_1()
self._create_fleet_2()
self._create_fleet_3()
# Set the background image
self.bg_image = self.settings.bg_image
self.imageship = self.ship.image
# Instance to store game statistic.
self.stats = GameStats(self)
# Draw the score information.
self.scoreboard = Scoreboard(self)
self.scoreboard.show_score()
# Make the Play button.
self.play_button = Button(self)
def run_game(self):
"""Start the main loop for the game."""
while True:
# Watch for keyboard and mouse events.
self._check_events()
if self.stats.game_active:
self.ship.update()
self.bullets.update()
self._update_aliens()
self._update_bullets()
# Redraw the screen during each pass through the loop.
self._update_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.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):
"""Respond to keydown events."""
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_UP:
self.ship.moving_up = 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_bullet()
def _check_keyup_events(self, event):
"""Respond to keydown events."""
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_UP:
self.ship.moving_up = False
elif event.key == pygame.K_DOWN:
self.ship.moving_down = False
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:
self.stats.reset_stats()
self.settings.initialize_dynamic_settings()
self.stats.game_active = True
self.scoreboard.prep_score()
self.scoreboard.prep_level()
self.scoreboard.prep_hearts()
# Hide the mouse cursor.
pygame.mouse.set_visible(False)
# Get rid of any remaining aliens and bullets.
self.aliens.empty()
self.bullets.empty()
self.ship.center_ship()
self._create_fleet_1()
self._create_fleet_2()
self._create_fleet_3()
def _fire_bullet(self):
"""Create a new bullet and add it to the bullets group."""
new_bullet = Bullet(self)
self.bullets.add(new_bullet)
def _create_fleet_1(self):
"""Create the fleet of aliens."""
# Make an alien.
alien = Alien(self, self.settings)
self.aliens.add(alien)
alien = Alien(self, self.settings)
self.aliens.add(alien)
alien = Alien(self, self.settings)
self.aliens.add(alien)
def _create_fleet_2(self):
"""Create the fleet of aliens."""
# Make an alien.
alien_2 = Alien2(self, self.settings)
self.aliens.add(alien_2)
def _create_fleet_3(self):
"""Create the fleet of aliens."""
# Make an alien.
alien_3 = Alien3(self, self.settings)
self.aliens.add(alien_3)
def _ship_hit(self):
"""Respong to the ship being hit by an alien."""
if self.stats.ships_left > 0:
# Lower ships left.
self.stats.ships_left -= 1
self.scoreboard.prep_hearts()
# Get rid of any remaining aliens and bullets.
self.aliens.empty()
self.bullets.empty()
# Create a new fleet and center the ship.
self.ship.center_ship()
self._create_fleet_1()
self._create_fleet_2()
self._create_fleet_3()
print(self.stats.ships_left)
# Pause.
sleep(1)
else:
self.stats.game_active = False
pygame.mouse.set_visible(True)
def _update_aliens(self):
"""Update the position of all liens in the fleet."""
self.aliens.update()
# Look for alien-ship collision.
if pygame.sprite.spritecollideany(self.ship, self.aliens):
self._ship_hit()
def _update_bullets(self):
# Check for any bullets that have hit aliens.
# If so, get rid of the bullet and the alien.
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.scoreboard.prep_score()
self.scoreboard.check_high_score()
# Delete bullets that are off the screen
for bullet in self.bullets.copy():
if bullet.rect.right >= resolution_width * 1.1:
self.bullets.remove(bullet)
if not self.aliens:
self.settings.increase_speed()
self.stats.level += 1
self.scoreboard.prep_level()
self._create_fleet_1()
self._create_fleet_2()
self._create_fleet_3()
def _update_screen(self):
"""Update images on the screen and flip to the new screen."""
self.screen.blit(pygame.transform.scale
(self.bg_image, [self.settings.screen_width, self.settings.screen_height]), (0, 0))
self.ship.blitme()
for bullet in self.bullets.sprites():
bullet.draw_bullet()
self.aliens.draw(self.screen)
self.scoreboard.show_score()
# Delete aliens that are off the screen
for alien in self.aliens.copy():
if alien.rect.right < 0:
self.aliens.remove(alien)
# Lines of code to show FPS counter
# font = pygame.font.Font(None, 30)
# fps = font.render(str(int(clock.get_fps())), True, pygame.Color('white'))
# self.screen.blit(fps, (50, 50))
# Regulate speed of the game by limiting FPS count.
clock.tick(60)
# Draw the play button if the game is inactive.
if not self.stats.game_active:
self.play_button.draw_button()
# Make the most recently draw screen visible.
pygame.display.flip()
class AlienInvasion:
def __init__(self):
"""ИНИЦИАЛИЗАЦИЯ ИГРЫ"""
pygame.init() #HERE IS EVERYTHING ALRIGHT
self.settings = Settings()
self.screen = pygame.display.set_mode(
(self.settings.screen_width, self.settings.screen_height)) # 4
self.screen_rect = self.screen.get_rect()
# ЕС ХОТИТЕ СДЕЛАТЬ НА ФУЛ ЭКРАН - УБИРАЙТЕ # В 1 , 2 , 3 ПУНКТЕ И ПОСТАВЬТЕ # В 4 ПУНКТЕ
# self.screen=pygame.display.set_mode((0,0), pygame.FULLSCREEN) # 1
# self.settings.screen_width=self.screen.get_rect().width # 2
# self.settings.screen_height=self.screen.get_rect().height # 3
pygame.display.set_caption("ALIEN INVASION")
self.ship = Ship(self)
self.bullets = pygame.sprite.Group()
self.stats = GameStats(self)
self.sb = Scoreboard(self)
self.aliens = pygame.sprite.Group() #объявление группы пришельцев
#self.charecter=Character(self) # MB I WILL DO IT
self._create_fleet() #при первом вызыове
self.play_button = Button(self, "LETS START")
self.filename = "saved_data.json"
def run_game(self):
"""ЗАПУСК ИГРЫ"""
while True: #ОТСЛЕЖИВАНИЕ ДЕЙСТВИЙ С КЛАВЫ
self._check_events()
if self.stats.game_active:
self.ship.update()
self._update_bullet()
self._update_aliens()
self._update_screen()
def _update_screen(self): #отвечает за то, что вообще на экране творится
self.screen.fill(
self.settings.bg_colour) #Заполнить экран определенным цветом
self.ship.blitme() # Использовать метод показа корабля
#self.charecter.blitme() #MB I WILL DO IT
for bullet in self.bullets.sprites():
bullet.draw_bullet()
self.aliens.draw(
self.screen) #показывает пришельцев на self.screen (общий экран)
if not self.stats.game_active:
self.play_button.draw_button()
self.sb.show_score() #Метод показа очков
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(event)
elif event.type == pygame.KEYUP:
self._check_keyUP(event)
elif event.type == pygame.MOUSEBUTTONDOWN:
mouse_pos = pygame.mouse.get_pos()
self._check_play_button(mouse_pos)
def _check_keyDOWN(self, event): #проверка нажатой клавиши
if event.key == pygame.K_RIGHT:
self.ship.moving_right = True
elif event.key == pygame.K_LEFT:
self.ship.moving_left = True
if event.key == pygame.K_UP:
self.ship.moving_up = True
elif event.key == pygame.K_DOWN:
self.ship.moving_down = True
elif event.key == pygame.K_ESCAPE: #стоп слово
some_score = self.stats.high_score
with open(self.filename, "w") as f: #Открытие файла
print("d") #Лоигрование, что запись в файл идет
json.dump(some_score, f) #Сохранение результата
sys.exit()
elif event.key == pygame.K_SPACE: #Вызов метода стрельбы пули
self._fire_bullet()
def _check_keyUP(
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_UP:
self.ship.moving_up = False
elif event.key == pygame.K_DOWN:
self.ship.moving_down = False
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) #Метод, чтобы мышка исчезла
def _fire_bullet(self): #отвечает за запуск пули
if len(
self.bullets
) < self.settings.bullet_allowed: #Если длина меньше кол-во разрешенных пуль
new_bullet = Bullet(self)
self.bullets.add(new_bullet)
def _update_bullet(
self
): #отвечает за устраниение пули, когда она достигнет определенной точки
self.bullets.update()
for bullet in self.bullets.copy():
if bullet.rect.bottom <= 0:
self.bullets.remove(bullet)
#print (len(self.bullets))
self._check_bullet()
def _check_bullet(self):
collisions = pygame.sprite.groupcollide(
self.bullets, self.aliens, False,
True) #Проверка взаимодействия группы пули и группы пришельцев
if collisions: #Если есть коллизия
for aliens in collisions.values():
self.stats.score += self.settings.alien_score * len(aliens)
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 _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) #Остановить игру на 0.5 сек
else:
self.stats.game_active = False
pygame.mouse.set_visible(True)
def _create_fleet(self): #Создание флота пришельцев
alien = Alien(self)
alien_width, alien_height = alien.rect.size #метод alien.rect.size возвращает ширину и длину пришельца
ship_height = self.ship.rect.height #высота корабля
available_space_x = self.settings.screen_width - (
2 * alien_width
) #настройки экрана - ширина пришельца * 2 (чтобы было место)
available_space_y = self.settings.screen_height - (
3 * alien_height
) - ship_height #получаем настройки, чтобы узнать кол-во рядов, мы можем сделать
number_rows = available_space_y // (
2 * alien_height
) #считаем точное кол-во, чтобы у игрока был шанс нормально играть без проблем
number_aliends = available_space_x // (2 * alien_width
) #кол-во пришельцев в ряду
for row in range((number_rows - 2) // 2): #допилить вариацию ряда
for number in range(
number_aliends): # вводим цикл для каждого пришельца
self._create_alien(
number, row
) #для каждого нового пришельца, мы вызываем метод создания пришельца (указываем кол-во в ряду и кол-во рядом)
self._create_alien_1(number, row + 1)
def _create_alien(self, alien_number, 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_height + 2 * alien_height * row
self.aliens.add(alien) #добавление пришельца в "список пришельцев"
def _create_alien_1(self, alien_number, row):
alien = Alien(self)
alien_width, alien_height = alien.rect.size
alien.x = alien_width + alien_width + 2 * alien_width * alien_number
alien.rect.x = alien.x
alien.rect.y = 2 * alien_height * row
self.aliens.add(alien)
def _update_aliens(self):
self.aliens.update()
if pygame.sprite.spritecollideany(self.ship, self.aliens):
self._ship_hit()
self._aliens_check_bottom()
self._check_fleet()
def _aliens_check_bottom(self): #Проверка достиг ли пришелец дна
for alien in self.aliens.sprites():
if alien.rect.bottom >= self.screen_rect.bottom:
self._ship_hit()
break
def _check_fleet(self): #Проверка дошел ли пришелец до края
for alien in self.aliens.sprites():
if alien.check_edges():
self._change_direction()
break
def _change_direction(self): #Смена направления
for alien in self.aliens.sprites(
): #меняем направление каждого пришельца с помощью группы спрайт
alien.rect.y += self.settings.fleet_drop_speed
self.settings.fleet_direction *= -1
class TunnelEscape:
"""Overall class to manage game assets and behaivor"""
def __init__(self):
""" initialize the game, and create game resources"""
pygame.init()
self.settings = Settings()
self.controlador = controlador()
#lo uso para pruebas de terminal
#self.screen = pygame.display.set_mode(
#(self.settings.screen_width, self.settings.screen_height))
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("Tunnel escape")
# Create an instance to store game statics,
# And create a scoreboard
self.stats = GameStats(self)
self.sb = Scoreboard(self)
# Crea una nueva nave a partir de la clase
self.ship = Ship(self)
self.bullets = pygame.sprite.Group()
self.aliens = pygame.sprite.Group()
self._create_fleet()
# Make the play button.
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()
def _check_events(self):
"""check for new 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.JOYAXISMOTION:
self._check_axis_events(event)
elif event.type == pygame.JOYBUTTONDOWN:
self._check_buttonDown_events(event)
elif event.type == pygame.JOYBUTTONUP:
self._check_buttonUp_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):
""" 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_q:
sys.exit()
elif event.key == pygame.K_SPACE:
self._fire_bullet()
def _check_keyup_events(self,event):
""" respond to keyReleased"""
if event.key == pygame.K_RIGHT:
self.ship.moving_right = False
elif event.key == pygame.K_LEFT:
self.ship.moving_left = False
def _check_axis_events(self,event):
""" respond to analog stick events"""
if event.axis == 1:
if self.controlador.gamepad.get_axis(0) > 0.1:
self.ship.moving_left = False
self.ship.moving_right = True
elif self.controlador.gamepad.get_axis(0) < -0.1:
self.ship.moving_right = False
self.ship.moving_left = True
elif self.controlador.gamepad.get_axis(0) == 0:
self.ship.moving_right = False
self.ship.moving_left = False
def _check_buttonDown_events(self,event):
""" respond to buttonpresses gamepad events"""
if event.button == 6:
sys.exit()
elif event.button == 0:
self._fire_bullet()
elif event.button == 7:
# Reset the game settings.
self.settings.initialize_dynamic_settings()
# Reset the game statistics.
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 aliens and bullets
self.aliens.empty()
self.bullets.empty()
#create a new fllet and center
self._create_fleet
self.ship.center_ship()
# hide the mouse cursor.
pygame.mouse.set_visible(False)
def _check_buttonUp_events(self,event):
""" respond to buttonReleased gamepad events"""
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()
# Reset the game statistics.
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 aliens and bullets
self.aliens.empty()
self.bullets.empty()
#create a new fllet and center
self._create_fleet
self.ship.center_ship()
# hide the mouse cursor.
pygame.mouse.set_visible(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 _update_bullets(self):
"""Update position of bullets and get rid of old bullets."""
# update bullet positions.
self.bullets.update()
if not self.aliens:
# Destroy existing bullets and create new fleet
self.bullets.empty()
self._create_fleet()
# Get rid of bullets that have disappeared.
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):
"""Respond to bullet-allien collisions."""
# Remove any bullets and aliens that have collide
collisions = pygame.sprite.groupcollide(self.bullets,self.aliens,
True,True)
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()
if collisions:
for aliens in collisions.values():
self.stats.score += self.settings.alien_points * len(aliens)
self.sb.prep_score()
self.sb.check_high_score()
def _update_aliens(self):
""" check if the fleet is at an edge, then update the position of
aliens in the fleet"""
self._check_fleet_edges()
self.aliens.update()
# Look for an alien-ship collisions.
if pygame.sprite.spritecollideany(self.ship,self.aliens):
self._ship_hit()
# Look for aliens hiting the bottom of the screen.
self._check_aliens_bottom()
def _ship_hit(self):
"""Respond to the 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 ship got hit.
self._ship_hit()
break
def _create_fleet(self):
"""create the fleet of aliens"""
alien = Alien(self)
alien_width,alien_height = alien.rect.size
# Determine the number of columns of aliens that fit in the screen.
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 in the screen.
ship_height = self.ship.rect.height
avaiable_space_y = (self.settings.screen_height-(3*alien_height)
-ship_height)
number_rows = avaiable_space_y//(2*alien_height)
#create the full flate of aliens
for row_number in range(number_rows):
#create the first row of aliens.
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 the 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_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 direction"""
for alien in self.aliens.sprites():
alien.rect.y += self.settings.fleet_drop_speed
self.settings.fleet_direction *= -1
def _update_screen(self):
"""make the most recently drawn screen visible."""
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 the score information.
self.sb.show_score()
# Draw the play button if the game is inactive
if not self.stats.game_active:
self.play_button.draw_button()
# make the most recently drawn screen visible
pygame.display.flip()
class Game():
def __init__(self):
pygame.init()
self.ai_settings = Settings()
self.screen = pygame.display.set_mode(
(self.ai_settings.screen_width, self.ai_settings.screen_height))
pygame.display.set_caption("Inwazja obcych")
# Utworzenie przycisku Gra
self.play_button = Button(self.ai_settings, self.screen, 'Gra')
# Utworzenie egzemplarza przenaczonego do przechowywania danych
# statystycznych gry oraz utworzenie egzemplarza klasy Scoreboard
self.stats = GameStats(self.ai_settings)
self.sb = Scoreboard(self.ai_settings, self.screen, self.stats)
#Utworzenie statku kosmicznego, grupy pocisków oraz grupy obcych
self.ship = Ship(self.ai_settings, self.screen)
self.bullets = Group()
self.aliens = Group()
# Utworzenie floty obcych
self.create_fleet()
def run(self):
while True:
self.check_events()
if self.stats.game_active:
self.ship.update()
self.update_bullets()
self.update_aliens()
self.update_screen()
def create_fleet(self):
'''Utworzenie pełnej floty obcych.'''
alien = Alien(self.ai_settings, self.screen)
number_aliens_x = self.get_number_aliens_x(alien.rect.width)
number_rows = self.get_number_rows(alien.rect.height)
for row_number in range(number_rows):
for alien_number in range(number_aliens_x):
self.create_alien(alien_number, row_number)
def get_number_aliens_x(self, alien_width):
'''Ustalenie liczby obcych, którzy zmieszczą się w rzędzie.'''
available_space_x = self.ai_settings.screen_width - 2 * alien_width
number_aliens_x = int(available_space_x / (2 * alien_width))
return number_aliens_x
def get_number_rows(self, alien_height):
'''Ustalenie ile rzędów obcych zmieści się na ekranie'''
available_space_y = (self.ai_settings.screen_height -
3 * alien_height - self.ship.rect.height)
number_rows = int(available_space_y / (2 * alien_height))
return number_rows
def create_alien(self, alien_number, row_number):
'''Utwórz nowego obcego.'''
alien = Alien(self.ai_settings, self.screen)
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.aliens.add(alien)
def check_events(self):
'''Reakcja na zdarzenia generowane przez klawiaturę i mysz.'''
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_x, mouse_y = pygame.mouse.get_pos()
self.check_play_button(mouse_x, mouse_y)
def check_keydown_events(self, event):
'''Reakcja na naciśnięcie klawisza.'''
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()
elif event.key == pygame.K_g:
self.start_game()
elif event.key == pygame.K_q:
sys.exit()
def fire_bullet(self):
# Utworzenie nowego pocisku i dodanie go do grupy pocisków
if len(self.bullets) < self.ai_settings.bullets_allowed:
new_bullet = Bullet(self.ai_settings, self.screen, self.ship)
self.bullets.add(new_bullet)
def start_game(self):
'''Rozpoczęcie gry poprzez wywołanie domyślnych ustawień.'''
if not self.stats.game_active:
# Wyzerowanie ustawień dotyczących gry.
self.ai_settings.initialize_dynamic_settings()
# Ukrycie kursora myszy
pygame.mouse.set_visible(False)
# Wyzerowanie danych statystycznych gry
self.stats.reset_stats()
self.stats.game_active = True
# Wyzerowanie obrazów tablicy wyników.
self.sb.prep_score()
self.sb.prep_high_score()
self.sb.prep_level()
# Usunięcie zawartości list aliens i bullets
self.aliens.empty()
self.bullets.empty()
# Utworzenie nowej floty i wyśrodkowanie statku
self.create_fleet()
self.ship.center_ship()
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 check_play_button(self, mouse_x, mouse_y):
'''Rozpoczęcie nowej gry po kliknięciu przycisku Gra przez użytkownika'''
button_clicked = play_button.rect.collidepoint(mouse_x, mouse_y)
if button_clicked and not self.stats.game_active:
self.start_game()
def update_bullets(self):
self.bullets.update()
# Usunięcie pocisków, które znajdą się poza ekranem
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):
'''Reakcja na kolizję między pociskiem i obcym.'''
collisions = pygame.sprite.groupcollide(self.bullets, self.aliens,
True, True)
if collisions:
for aliens in collisions.values():
self.stats.score += self.ai_settings.alien_points * len(aliens)
self.sb.prep_score()
self.check_high_score()
if len(self.aliens) == 0:
# Jeżeli cała flota została zniszczona, gracz przechodzi na kolejny poziom.
self.bullets.empty()
self.ai_settings.increase_speed()
# Inkrementacja numeru poziomu.
self.stats.level += 1
self.sb.prep_level()
self.create_fleet()
def check_high_score(self):
'''Sprawdzenie, czy mamy nowy najlpeszy wynik osiągnięty dotąd w grze.'''
if self.stats.score > self.stats.high_score:
self.stats.high_score = self.stats.score
self.sb.prep_high_score()
def update_aliens(self):
'''Uaktualnienie położenia wszystkich obcych we flocie'''
self.check_fleet_edges()
self.aliens.update()
# Wykrywanie kolizji między obcym i statkiem
if pygame.sprite.spritecollideany(self.ship, self.aliens):
self.ship_hit()
# Wyszukiwanie obcych docierających do dolnej krawędzi ekranu
self.check_aliens_bottom()
def check_fleet_edges(self):
'''Odpowiednia reakcja, gdy obcy dotrze do krawędzi ekranu.'''
for alien in self.aliens.sprites():
if alien.check_edges():
self.change_fleet_direction()
break
def change_fleet_direction(self):
'''Przesunięcie całej floty w dół i zmiana kierunku, w którym się ona porusza.'''
for alien in self.aliens.sprites():
alien.rect.y += self.ai_settings.fleet_drop_speed
self.ai_settings.fleet_direction *= -1
def ship_hit(self):
'''Reakcja na uderzenie obcego w statek.'''
if self.stats.ships_left > 0:
# Zmniejszenie wartości przechowywanej w ships_left
self.stats.ships_left -= 1
# Uaktualnienie tablicy wyników.
self.sb.prep_ships()
# Usunięcie zawartości list aliens i bullets
self.aliens.empty()
self.bullets.empty()
# Utworzenie nowej floty i wyśrodkowanie statku
self.create_fleet()
self.ship.center_ship()
# Pauza
sleep(0.5)
else:
self.stats.game_active = False
pygame.mouse.set_visible(True)
def check_aliens_bottom(self):
'''Sprawdzenie, czy którykolwiek obcy dotarł do dolnej krawędzi ekranu'''
screen_rect = self.screen.get_rect()
for alien in self.aliens.sprites():
if alien.rect.bottom >= screen_rect.bottom:
self.ship_hit()
break
def update_screen(self):
'''Uaktualnienie obrazów na ekranie i przejście do nowego ekranu.'''
self.screen.fill(self.ai_settings.bg_color)
# Ponowne wyświetlenie wszystkich pocisków pod warstwami statku kosmicznego i obcych
for bullet in self.bullets.sprites():
bullet.draw_bullet()
self.ship.blitme()
self.aliens.draw(self.screen)
# Wyświetlenie informacji o punktacji.
self.sb.show_score()
# Wyświetlenie przycisku tylko wtedy, gdy gra jest nieaktywna
if not self.stats.game_active:
self.play_button.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.mixer.pre_init(44100, 16, 2, 4096)
pygame.init()
self.settings = Settings()
self.screen = pygame.display.set_mode(
(self.settings.screen_width, self.settings.screen_height))
"""
# running the screen fullscreen
self.screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
self.settings.screen_width = self.screen.get_rect().width
self.settings.sreen_height = self.screen.get_rect().height
"""
pygame.display.set_caption("Alien Invasion")
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()
# make the play button
self.play_button = Button(self, "Play")
pygame.mixer.music.load("music/starwarstheme.mp3")
pygame.mixer.music.set_volume(0.5)
pygame.mixer.music.play(-1)
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()
def _check_events(self):
"""respond to keyboard and mouse events"""
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.save_high_score()
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_play_button(self, mouse_pos):
"""start a new game when the player clicks Play"""
if self.play_button.rect.collidepoint(
mouse_pos) and not self.stats.game_active:
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()
# reset speed
self.settings.initialize_dynamic_settings()
# hide the mouse cursor over the game window
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()
elif event.key == pygame.K_q:
self.save_high_score()
sys.exit()
elif event.key == pygame.K_b:
self._bigger()
elif event.key == pygame.K_p:
self._start_game()
elif event.key == pygame.K_d:
self.save_high_score()
with open("description.txt") as f:
print(f.readline())
sys.exit()
def _check_keyup_events(self, event):
"""respond to lifting finger from key"""
if event.key == pygame.K_RIGHT:
self.ship.moving_right = False
elif event.key == pygame.K_LEFT:
self.ship.moving_left = False
def _start_game(self):
"""respond to p button to start/restart the game"""
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()
# reset speed
self.settings.initialize_dynamic_settings()
# hide the mouse cursor over the game window
pygame.mouse.set_visible(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 _update_bullets(self):
"""update the position of bullets and get rid of old bullets"""
self.bullets.update()
# get rid of bullets that have disappeared
for bullet in self.bullets.copy():
if bullet.rect.bottom <= 0:
self.bullets.remove(bullet)
self._check_bullet_alien_collision()
def _check_bullet_alien_collision(self):
"""respond to bullet-alien collisions"""
# remove any bullets and aliens that have collided
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.sb.prep_score()
self.sb.check_high_score()
# no aliens left in the fleet
if not self.aliens:
# destroy existing bullets and create a new fleet
self.bullets.empty()
self._create_fleet()
self.stats.level += 1
self.sb.prep_level()
self.settings.increase_speed()
def _create_fleet(self):
"""create a 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)
alien_width, alien_height = alien.rect.size
# available_space_x decides how much space is available
# after allowing for margins on the screen
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 can fit on the 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 the full 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 in the fleet"""
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 _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_aliens(self):
"""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 _update_screen(self):
"""update images on the screen and flip to the 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)
# draw the score information
self.sb.show_score()
# draw the play button if the game is inactive
if not self.stats.game_active:
self.play_button.draw_button()
pygame.display.flip()
def _bigger(self):
"""switch to a bigger display"""
self.screen = pygame.display.set_mode((1350, 700))
self.settings.screen_width = self.screen.get_rect().width
self.settings.sreen_height = self.screen.get_rect().height
self.ship = Ship(self)
self.sb = Scoreboard(self)
def _ship_hit(self):
"""respond to the ship being hit by an alien"""
if self.stats.ships_left > 1: # allow n ships, not n backup ships
# decrement the ships_left
self.stats.ships_left -= 1
self.sb.prep_ships()
# get rid of bullets and aliens left
self.aliens.empty()
self.bullets.empty()
# create a new fleet and center the ship
self._create_fleet()
self.ship.center_ship()
# pause
sleep(1)
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:
self._ship_hit()
break
def save_high_score(self):
"""save high score, if made, in the game"""
with open("high.data", "w") as f:
f.write(str(self.sb.stats.high_score))
class AlienInvasion:
"""Overall class to manage game assets and behavior."""
def __init__(self):
"""Initialize the game, and create game resources."""
pygame.init()
# Set up the window screen, and background image
self.screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
self.image = pygame.image.load('images/ufo-4987627_1920.bmp')
self.image = pygame.transform.scale(
self.image, (self.screen.get_width(), self.screen.get_height()))
self.rect = self.image.get_rect()
# Control the settings of the game via Settings class
self.settings = Settings()
self.settings.screen_width = self.screen.get_rect().width
self.settings.screen_height = self.screen.get_rect().height
pygame.display.set_caption("Alien Invasion")
self.music = self.settings.bg_music()
# Manipulate game statistics & Scoreboard.
self.stats = GameStats(self)
self.sb = Scoreboard(self)
# Create the actors of the game
self.ship = Ship(self)
self.bullets = pygame.sprite.Group()
self.aliens = pygame.sprite.Group()
self._create_fleet()
# Make the Play button.
self.play_button = Button(self, "Play")
# flags
self.keep_firing = False
def run_game(self):
"""Start the main loop for the game."""
""" Main Function of the game."""
while True:
self._check_events()
if self.stats.game_active:
self.ship.update()
self._update_bullets()
self._update_aliens()
self._fire_bullet()
self._update_screen()
def _check_events(self):
""" Watch for keyboard and mouse events. """
for event in pygame.event.get():
# Press x on top to quit
if event.type == pygame.QUIT:
sys.exit()
# Check if any key is pressed down or released
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_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:
# initialize the game settings every time
self.settings.initialize_dynamic_settings()
# Reset the game statistics and prep the scoreboard.
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 aliens and bullets.
self.aliens.empty()
self.bullets.empty()
# Create a new fleet and center the ship.
self._create_fleet()
self.ship.center_ship()
# Hide the mouse cursor.
pygame.mouse.set_visible(False)
def _check_keydown_events(self, event):
"""Respond to key presses."""
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(0)
elif event.key == pygame.K_SPACE:
self.keep_firing = True
def _check_keyup_events(self, event):
"""Respond to key releases."""
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_SPACE:
self.keep_firing = False
def _fire_bullet(self):
"""Create a new bullet and add it to the bullets group."""
if self.keep_firing and len(
self.bullets) < self.settings.max_num_bullets:
new_bullet = Bullet(self)
self.bullets.add(new_bullet)
def _update_bullets(self):
""" Update the bullets positions """
self.bullets.update()
# Get rid of bullets that have disappeared.
for bullet in self.bullets.copy():
if bullet.rect.bottom <= 0:
self.bullets.remove(bullet)
# Check if any bullet collided with alien
self._check_bullet_alien_collisions()
def _check_bullet_alien_collisions(self):
"""Respond to bullet-alien collisions."""
# Remove any bullets and aliens that have collided.
# Check for any bullets that have hit aliens.
# If so, get rid of the bullet and the alien.
collisions = pygame.sprite.groupcollide(self.bullets, self.aliens,
True, True)
# If there is a collision, loop through the dict and increase score
# check if the high score has been attained, and update it if so
if collisions:
for aliens in collisions.values():
self.stats.score += self.settings.alien_points * len(aliens)
self.sb.prep_score()
self.sb.check_high_score()
# If all aliens have been destroyed
if not self.aliens:
# Start a new level, by doing the following
# 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 _create_fleet(self):
"""Create the fleet of aliens."""
# Make an alien.
alien = Alien(self)
alien_width, alien_height = alien.rect.size
# see how much space we have to fit in some number of aliens
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
# see how much space we have to fit in some number of aliens
available_space_y = (self.settings.screen_height - (4 * alien_height) -
ship_height)
number_rows = available_space_y // (2 * alien_height)
# Create all rows and columns 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 the row.
alien = Alien(self)
alien_width, alien_height = alien.rect.size
# set up the aliens position accordingly
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
# Add it to the group of aliens through the sprite class
self.aliens.add(alien)
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()
# 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 _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 _ship_hit(self):
"""Respond to the ship being hit by an alien."""
# If no more lives, then end the game by setting the flag
if self.stats.ships_left == 0:
self.stats.game_active = False
pygame.mouse.set_visible(True)
else:
# Decrement ships_left.
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 for 0.7 seconds.
sleep(0.7)
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
def _update_screen(self):
""" Redraw the screen during each pass through the loop. """
self.screen.fill(self.settings.bg_color)
self.screen.blit(self.image, self.rect)
# draw the ship on the screen
self.ship.blitme()
# Draw the bullets on the screen
for bullet in self.bullets.sprites():
bullet.draw_bullet()
# Draw the group of aliens
self.aliens.draw(self.screen)
# show the scoreboard on screen
self.sb.show_score()
# Draw the play button if the game is inactive.
if not self.stats.game_active:
self.play_button.draw_button()
# Make the most recently drawn screen visible.
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()
if self.settings.fullscreen == True:
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
else:
self.screen = pygame.display.set_mode(
(self.settings.screen_width, self.settings.screen_height))
pygame.display.set_caption("Alien Invasion")
# Create an instance to store game stats
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()
def _check_events(self):
"""Respond to keyboard and mouse events"""
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.stats.save_high_score()
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_keydown_events(self, event):
""""Respond to keydown events"""
if event.key == pygame.K_RIGHT:
#Move the ship to the right
self.ship.moving_right = True
elif event.key == pygame.K_LEFT:
self.ship.moving_left = True
elif event.key == pygame.K_q:
self.stats.save_high_score()
sys.exit()
elif event.key == pygame.K_r:
#New game
self._reset_game()
elif event.key == pygame.K_SPACE:
self._fire_bullet()
def _check_keyup_events(self, event):
"""Respond to keyup events"""
if event.key == pygame.K_RIGHT:
self.ship.moving_right = False
elif event.key == pygame.K_LEFT:
self.ship.moving_left = False
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._reset_game()
def _ship_hit(self):
"""Respond to ship being hit"""
if self.stats.ships_left > 0:
# Decrement ships left
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, center ship, and pause for .5 seconds
self._create_fleet()
self.ship.center_ship()
sleep(0.5)
else:
self.stats.game_active = False
pygame.mouse.set_visible(True)
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 _update_bullets(self):
"""Update position of bullets and get rid of old ones"""
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):
"""Check for bullet alien collisions and remove both"""
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.sb.prep_score()
self.sb.check_high_score()
# If all aliens are dead create new fleet
if not self.aliens:
self.bullets.empty()
self._create_fleet()
self.settings.increase_speed()
self.stats.level += 1
self.sb.prep_level()
def _create_fleet(self):
"""Create the fleet of aliens"""
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 the number of rows of aliends 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 full 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 the 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 _update_aliens(self):
"""Update position of the alien fleet"""
self._check_fleet_edges()
self.aliens.update()
# Look for alien-shop collisions
if pygame.sprite.spritecollideany(self.ship, self.aliens):
self._ship_hit()
# Look for aliens reaching bottom
self._check_aliens_bottom()
def _check_fleet_edges(self):
"""Respond if any aliens reach an edge"""
for alien in self.aliens.sprites():
if alien.check_edges():
self._change_fleet_direction()
break
def _change_fleet_direction(self):
"""Drop the fleet and change direction"""
for alien in self.aliens.sprites():
alien.rect.y += self.settings.fleet_drop_speed
self.settings.fleet_direction *= -1
def _check_aliens_bottom(self):
"""Chck if any aliens hit bottom of screen"""
screen_rect = self.screen.get_rect()
for alien in self.aliens.sprites():
if alien.rect.bottom >= screen_rect.bottom:
#treat this as if ship was hit
self._ship_hit()
break
def _update_screen(self):
"""Update images on the screen, and flip to the 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 the play button if game not active
if not self.stats.game_active:
self.play_button.draw_button()
pygame.display.flip()
def _reset_game(self):
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)
def run_game():
# Initialize game and create a screen object
pygame.init()
si_settings = Settings()
screen = pygame.display.set_mode((si_settings.screen_width, si_settings.screen_height))
pygame.display.set_caption("Space Invaders")
# Make the Menu and the Play Game and High Scores buttons.
menu = Menu(si_settings, screen)
play_button = Button(si_settings, screen, "PLAY GAME", (si_settings.screen_width * 2.75) / 7, (si_settings.screen_height * 5.25) / 7)
high_scores_button = Button(si_settings, screen, "HIGH SCORES", (si_settings.screen_width * 2.65) / 7, (si_settings.screen_height * 6) / 7)
# Create an instance to store game statistics and create a scoreboard.
stats = GameStats(si_settings)
sb = Scoreboard(si_settings, screen, stats)
# Make a ship, a group of bullets, and a group of aliens
ship = Ship(si_settings, screen)
bullets = Group()
alienBullets = Group()
aliens = Group()
images = ["images/alien1.png", "images/alien2.png", "images/alien3.png"]
random = randint(0, 10)
ufo_random = randint(0, 10)
start_ticks = pygame.time.get_ticks()
# Create the ufo
ufo = None
# Create the fleet of aliens.
gf.create_fleet(si_settings, screen, ship, aliens, images)
# Load the background music
# bg_music = pygame.mixer.music("audio/background_music.mp3")
# Start the main loop for the game
while True:
# Watch for keyboard and mouse events.
gf.check_events(si_settings, screen, stats, sb, menu, play_button, high_scores_button, ship, aliens, bullets, alienBullets, images)
if stats.game_active:
seconds = int((pygame.time.get_ticks() - start_ticks) / 1000)
if seconds - previous_time == random:
gf.fire_back(si_settings, screen, aliens, alienBullets)
previous_time = seconds
random = randint(5, 10)
if seconds - ufo_previous_time == ufo_random:
ufo = gf.create_ufo(si_settings)
ufo_previous_time = seconds
ufo_random = randint(20, 30)
print("UFO Random: " + str(ufo_random) + " Seconds: " + str(seconds) + " UFO Previous Time: " + str(ufo_previous_time))
ship.update()
gf.update_bullets(si_settings, screen, stats, sb, ship, aliens, bullets, alienBullets, images)
gf.update_aliens(si_settings, screen, stats, sb, ship, aliens, bullets, alienBullets, images, (seconds - previous_time), ufo)
else:
previous_time = int(pygame.time.get_ticks() / 1000)
ufo_previous_time = int(pygame.time.get_ticks() / 1000)
gf.update_screen(si_settings, screen, stats, sb, ship, aliens, bullets, alienBullets, menu, play_button, high_scores_button)
def run_game(screenmode=0):
# Initialize pygame, settings, and screen object.
pygame.init()
ai_settings = Settings()
if screenmode:
#fullscreen speeds up game, but cannot see terminal output for debugging
screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
ai_settings.screen_width = screen.get_rect().width
ai_settings.screen_height = screen.get_rect().height
print(screenmode)
else:
screen = pygame.display.set_mode(
(ai_settings.screen_width, ai_settings.screen_height))
print('windowed mode')
pygame.display.set_caption("Alien Invasion - Press p to exit")
# Creat instances of several class objects.
play_button = Button(ai_settings, screen, "Play")
stats = GameStats(ai_settings)
ship = Ship(ai_settings, screen, 1)
ship2 = Ship(ai_settings, screen, 2)
bullets = Group()
alien_bullets = Group()
aliens = Group()
leaderboard = Leaderboard(stats, screen, ai_settings)
sb = Scoreboard(ai_settings, screen, stats)
textinput = ti.TextInput()
# Create the fleet of aliens.
gf.create_fleet(ai_settings, screen, ship, aliens, stats)
# Start the main loop for the game.
while ai_settings.quitflag:
gf.check_events(ai_settings, screen, stats, sb, play_button, ship,
aliens, bullets, ship2)
if stats.game_active:
gf.update_ships(ai_settings, screen, stats, sb, ship, aliens,
bullets, alien_bullets, ship2, leaderboard,
textinput)
gf.update_bullets(ai_settings, screen, stats, sb, ship, aliens,
bullets, alien_bullets, ship2, leaderboard,
textinput)
gf.update_aliens(ai_settings, screen, stats, sb, ship, aliens,
bullets, alien_bullets, ship2, leaderboard,
textinput)
gf.update_screen(ai_settings, screen, stats, sb, ship, aliens, bullets,
play_button, alien_bullets, ship2)
leaderboard.read_high_score(stats)
if stats.score > leaderboard.previous_high_score:
leaderboard.new_high_score(ai_settings, screen, textinput, stats)
ai_settings.quitflag = 1
while ai_settings.quitflag:
gf.check_events(ai_settings, screen, stats, sb, play_button, ship,
aliens, bullets, ship2)
leaderboard.display(ai_settings, screen)
pygame.display.quit()
pygame.quit()
exit()
class AlienInvasion:
"""overall class to manage game assets and behavior"""
def __init__(self):
"""initialize the game, and create the 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 stats and create a scoreboard
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()
# Make the play button
self.play_button = Button(self, "Play")
def run_game(self):
"""starts the main loop for the game."""
while True:
# Watch for the keyboard and mouse events.
self._check_events()
if self.stats.game_active:
self.ship.update()
self._update_bullets()
self._update_aliens()
self._update_screen()
def _check_events(self):
"""Responds to keypresses and mouse events."""
# Watch for the keyboard 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 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()
# Reset the game statistics
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 aliens and bullets.
self.aliens.empty()
self.bullets.empty()
# Create a new fleet and center the ship
self._create_fleet()
self.ship.center_ship()
# Hide the mouse cursor
pygame.mouse.set_visible(False)
def _check_keydown_events(self, event):
"""Respond to keypresses."""
if event.key == pygame.K_RIGHT:
# Move the ship to the right
self.ship.moving_right = True
elif event.key == pygame.K_LEFT:
# Move the ship to the 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):
"""REspond to key releases."""
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):
"""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 _update_screen(self):
"""Update image on the screen and flip to the 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)
# Draw th score information
self.sb.show_score()
# Draw the play button if the 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 get rid of old bullets."""
# Update bullet positions.
self.bullets.update()
# Get rid of bullets that have disappeared
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):
"""Respond to bullet-alien collisions."""
# remove any bullets and aliens that have collided
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.sb.prep_score()
self.sb.check_high_score()
if not self.aliens:
# Destroy existing bullets and creat a new fleet
self.bullets.empty()
self._create_fleet()
self.settings.increase_speed()
# Increase level
self.stats.level += 1
self.sb.prep_level()
def _create_alien(self, alien_number, row_number):
"""Create an alien and place it in the 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 _create_fleet(self):
"""Create the fleet of aliens."""
# Create an aliena nd find the number of aliens in row
# Spacing between each alien 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_alien_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_space_y = (self.settings.screen_height - (3 * alien_height) -
ship_height)
number_rows = available_space_y // (2 * alien_height)
# Create the ful fleet of alines
for row_number in range(number_rows):
for alien_number in range(number_alien_x):
# Create an alien and place it in the row.
self._create_alien(alien_number, row_number)
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 _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
def _change_fleet_direction(self):
"""Droip 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_aliens(self):
"""Update the positions of all aliens in teh 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 the 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 run_game():
# initialize pygame, settings, and create 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 play and high score button
play_button = Button(screen, "Play", 650)
high_score_button = Button(screen, "High Score", 700)
# make start screen text
title1 = Text(screen, "SPACE",
screen.get_rect().centerx, 65, 500, 100, (255, 255, 255),
250)
title2 = Text(screen, "INVADERS",
screen.get_rect().centerx, 175, 500, 100, (0, 255, 0), 158)
high_score_title1 = Text(screen, "HIGH", (screen.get_rect().centerx - 125),
30, 180, 70, (255, 255, 255), 100)
high_score_title2 = Text(screen, "SCORE", (screen.get_rect().centerx + 90),
30, 250, 70, (0, 255, 0), 100)
alien_1_score = Text(screen, "= 10 PTS", (screen.get_rect().centerx + 65),
300, 220, 50, (255, 255, 255), 70)
alien_2_score = Text(screen, "= 20 PTS", (screen.get_rect().centerx + 65),
380, 220, 50, (255, 255, 255), 70)
alien_3_score = Text(screen, "= 40 PTS", (screen.get_rect().centerx + 65),
460, 220, 50, (255, 255, 255), 70)
ufo_score = Text(screen, "= ?? PTS", (screen.get_rect().centerx + 65), 540,
220, 50, (255, 255, 255), 70)
hs1 = Text(screen, "1", (screen.get_rect().centerx - 125), 100, 50, 50,
(255, 255, 255), 65)
hs2 = Text(screen, "2", (screen.get_rect().centerx - 125), 155, 50, 50,
(255, 255, 255), 65)
hs3 = Text(screen, "3", (screen.get_rect().centerx - 125), 210, 50, 50,
(255, 255, 255), 65)
hs4 = Text(screen, "4", (screen.get_rect().centerx - 125), 265, 50, 50,
(255, 255, 255), 65)
hs5 = Text(screen, "5", (screen.get_rect().centerx - 125), 320, 50, 50,
(255, 255, 255), 65)
hs6 = Text(screen, "6", (screen.get_rect().centerx - 125), 375, 50, 50,
(255, 255, 255), 65)
hs7 = Text(screen, "7", (screen.get_rect().centerx - 125), 430, 50, 50,
(255, 255, 255), 65)
hs8 = Text(screen, "8", (screen.get_rect().centerx - 125), 485, 50, 50,
(255, 255, 255), 65)
hs9 = Text(screen, "9", (screen.get_rect().centerx - 125), 540, 50, 50,
(255, 255, 255), 65)
hs10 = Text(screen, "10", (screen.get_rect().centerx - 125), 595, 50, 50,
(255, 255, 255), 65)
# make start screen images
alien_1_img = Image(screen, 'images/alien_1_1.bmp',
(screen.get_rect().centerx - 150), 300)
alien_2_img = Image(screen, 'images/alien_2_1.bmp',
(screen.get_rect().centerx - 150), 380)
alien_3_img = Image(screen, 'images/alien_3_1.bmp',
(screen.get_rect().centerx - 150), 460)
ufo_img = Image(screen, 'images/ufo_1.bmp',
(screen.get_rect().centerx - 178), 540)
# Create an instance to store game stats and create a scoreboard
high_scores = HighScores()
stats = GameStats(ai_settings, high_scores)
sb = Scoreboard(ai_settings, screen, stats)
# Make a ship, a group of bullets, and a group of aliens, and ufo group
bullets_ship = Group()
bullets_alien = Group()
bunker1 = Group()
bunker2 = Group()
bunker3 = Group()
aliens = Group()
alien_type = ['images/alien_1_1.bmp', 'images/alien_1_2.bmp']
ufo = Group()
ufo_imgs = ['images/ufo_1.bmp', 'images/ufo_2.bmp']
points = 10
# create a fleet of aliens
gf.create_fleet(ai_settings, screen, stats, alien_type, points, aliens,
ufo_imgs, ufo)
gf.create_bunker(screen, 1, bunker1)
gf.create_bunker(screen, 2, bunker2)
gf.create_bunker(screen, 3, bunker3)
# create ship
ship = Ship(ai_settings, screen)
# add music
pygame.mixer.set_reserved(0)
pygame.mixer.set_reserved(1)
pygame.mixer.set_reserved(2)
pygame.mixer.set_reserved(3)
pygame.mixer.set_reserved(4)
pygame.mixer.set_reserved(5)
ship_shoot = pygame.mixer.Sound('audio/ship_shoot.wav')
alien_shoot = pygame.mixer.Sound('audio/alien_shoot.wav')
alien_exp = pygame.mixer.Sound('audio/alien_exp.wav')
ship_exp = pygame.mixer.Sound('audio/ship_exp.wav')
ufo_sound = pygame.mixer.Sound('audio/ufo_sound.wav')
pygame.mixer.music.load('audio/bg_music_1.wav')
pygame.mixer.music.play(-1, 0.0)
ufo_sound_playing = False
# Start the main loop for the game.
while True:
gf.check_events(ai_settings, screen, stats, sb, play_button,
high_score_button, ship, aliens, alien_type, points,
bullets_ship, bullets_alien, bunker1, bunker2, bunker3,
ufo_imgs, ufo, ship_shoot)
if stats.game_active:
ship.update()
if ship.timer.finished is True:
gf.ship_hit(ai_settings, stats, screen, sb, ship, aliens,
alien_type, points, bullets_alien, bullets_ship,
high_scores, bunker1, bunker2, bunker3, ufo_imgs,
ufo, ship_exp)
gf.update_bullets(ai_settings, screen, stats, sb, ship, aliens,
alien_type, points, bullets_ship, bullets_alien,
high_scores, bunker1, bunker2, bunker3, ufo_imgs,
ufo, alien_shoot, alien_exp, ship_exp)
gf.update_aliens(ai_settings, stats, screen, sb, ship, aliens,
alien_type, points, bullets_alien, bullets_ship,
high_scores, bunker1, bunker2, bunker3, ufo_imgs,
ufo, ship_exp)
gf.update_sound(aliens, ai_settings, stats)
gf.update_screen(ai_settings, screen, stats, sb, ship, aliens,
bullets_ship, bullets_alien, play_button,
high_score_button, title1, title2, alien_1_score,
alien_2_score, alien_3_score, ufo_score, alien_1_img,
alien_2_img, alien_3_img, ufo_img, high_score_title1,
high_score_title2, hs1, hs2, hs3, hs4, hs5, hs6, hs7,
hs8, hs9, hs10, high_scores, bunker1, bunker2,
bunker3, ufo, ufo_sound, ufo_sound_playing)
