def __init__(self):
"""Initialize the game, and create game resources."""
pygame.init()
self.settings = Settings()
self.screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
self.settings.screen_width = self.screen.get_rect().width
self.settings.screen_height = self.screen.get_rect().height
pygame.display.set_caption("Alien Invasion")
# Create an instance to store game statistics and 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.sound_effects = SoundEffects()
self._create_fleet()
# Make the play buttons -- TO REFACTOR.
self.play_button = Button(self, (0, 255, 0), 200, 50)
self.hard_button = Button(self, (0, 0, 255), 100, 50)
self.crazy_button = Button(self, (255, 0, 0), 100, 50)
def __init__(self):
self.number_of_user = 0
self.userList = []
self.player_list = []
self.screen = None
self.sfx = SoundEffects()
self.display_init()
self.sprite_group = pygame.sprite.Group()
self.focus_effect_group = pygame.sprite.Group()
self.goal_effect_group = pygame.sprite.Group()
self.ball = self.ball_init(self.sfx)
self.user_init(self.ball, self.sfx)
self.platform = None
self.platform_init()
self.done = False
self.focus_effect_blue = None
self.focus_effect_red = None
self.focus_effect_list = []
self.focus_effect_init()
self.collision = Collision()
self.scoreboard = Scoreboard(self.screen)
self.ball_reset_delay = 2000
self.goal_effect_init()
self.max_score = 3
class GameManager:
clock = pygame.time.Clock()
def __init__(self):
self.number_of_user = 0
self.userList = []
self.player_list = []
self.screen = None
self.sfx = SoundEffects()
self.display_init()
self.sprite_group = pygame.sprite.Group()
self.focus_effect_group = pygame.sprite.Group()
self.goal_effect_group = pygame.sprite.Group()
self.ball = self.ball_init(self.sfx)
self.user_init(self.ball, self.sfx)
self.platform = None
self.platform_init()
self.done = False
self.focus_effect_blue = None
self.focus_effect_red = None
self.focus_effect_list = []
self.focus_effect_init()
self.collision = Collision()
self.scoreboard = Scoreboard(self.screen)
self.ball_reset_delay = 2000
self.goal_effect_init()
self.max_score = 3
def display_init(self):
size = [constants.SCREEN_WIDTH, constants.SCREEN_HEIGHT]
self.screen = pygame.display.set_mode(size)
pygame.display.set_caption("Hello world")
def user_init(self, ball, sfx):
player_sprite = SpriteFactory("images/player.png")
user1_players_initial_positions = constants.USER1_PLAYERS_INITIAL_POS
user2_players_initial_positions = constants.USER2_PLAYERS_INITIAL_POS
user1 = User(self.sprite_group, player_sprite, data.playerBlueFramesData, user1_players_initial_positions, ball, sfx)
self.add_user(user1)
self.add_player(user1)
user2 = User(self.sprite_group, player_sprite, data.playerRedFramesData, user2_players_initial_positions, ball, sfx)
self.add_user(user2)
self.add_player(user2)
def ball_init(self, sfx):
ball_sprite = SpriteFactory("images/ball-small.png")
ball_frames = SpriteFactory.generate_frames(ball_sprite, data.ballFramesData)
ball = Ball(self.sprite_group, (constants.BALL_INIT_POS[0], constants.BALL_INIT_POS[1]), ball_frames, sfx, speed=100)
ball.play(Animation.INFINITE)
ball_shadow_sprite = SpriteFactory("images/ball-shadow.png")
ball_shadow_frames = SpriteFactory.generate_frames(ball_shadow_sprite, data.ballShadowFramesData)
ball_shadow = BallShadow(self.focus_effect_group, ball, ball_shadow_frames, speed=1000)
ball_shadow.play(Animation.INFINITE)
return ball
def platform_init(self):
self.platform = Platform(self.screen)
def focus_effect_init(self):
focus_effect_sprite_red = SpriteFactory("images/hover-red.png")
focus_effect_frames_red = SpriteFactory.generate_frames(focus_effect_sprite_red, data.hoverEffectFramesData)
focus_effect_sprite_blue = SpriteFactory("images/hover-blue.png")
focus_effect_frames_blue = SpriteFactory.generate_frames(focus_effect_sprite_blue, data.hoverEffectFramesData)
focus_effect_blue = FocusEffect(self.focus_effect_group,
self.userList[0].players_list[self.userList[0].current_selected_player],
focus_effect_frames_blue, speed=1000)
self.focus_effect_list.append(focus_effect_blue)
self.focus_effect_list[0].play(Animation.INFINITE)
focus_effect_red = FocusEffect(self.focus_effect_group,
self.userList[1].players_list[self.userList[1].current_selected_player],
focus_effect_frames_red, speed=1000)
self.focus_effect_list.append(focus_effect_red)
self.focus_effect_list[1].play(Animation.INFINITE)
def goal_effect_init(self):
goal_effect_sprite = SpriteFactory("images/goal-screen.png")
goal_effect_frames = SpriteFactory.generate_frames(goal_effect_sprite, data.goalEffectFramesData)
self.goal_effect = GoalScreen(self.goal_effect_group, goal_effect_frames)
# self.userList[0].players_list[1].rect.x = 200
# self.userList[1].players_list[1].rect.y = 700
# @param user: type User
def add_user(self, user):
self.userList.append(user)
def add_player(self, user):
for x in range(0, user.num_of_players):
self.player_list.append(user.players_list[x])
def is_game_over(self):
user1_score = self.scoreboard.scores[0]
user2_score = self.scoreboard.scores[1]
if user1_score > self.max_score / 2 and user1_score > user2_score: # user1 win
return True
elif user2_score > self.max_score / 2 and user2_score > user1_score: # user2 win
return True
else:
return False
def gameover_screen(self):
exitLoop = False
while not exitLoop:
for event in pygame.event.get():
if event.type == pygame.QUIT:
exitLoop = True
self.done = True
if event.type == pygame.MOUSEBUTTONDOWN:
for i in range(0, len(self.platform.gameover_button_list), 1):
if self.platform.gameover_button_list[i].is_mouse_over(mouse.get_pos()):
if i == constants.GAMEOVER_BUTTON_TYPE["mute"]:
self.sfx.play_mouseover()
if self.sfx.is_muted == True:
self.sfx.set_unmute()
else:
self.sfx.set_mute()
elif i == constants.GAMEOVER_BUTTON_TYPE["replay"]:
self.sfx.play_mouseover()
exitLoop = True
self.scoreboard.reset_score()
self.start(False)
elif i == constants.GAMEOVER_BUTTON_TYPE["exit"]:
self.sfx.play_mouseover()
exitLoop = True
self.done = True
self.platform.gameover_screen(mouse.get_pos(), pygame.event.get(), self.scoreboard.scores)
pygame.display.update()
GameManager.clock.tick(constants.FPS)
def start_screen(self):
exitLoop = False
self.sfx.play_start_screen()
while not exitLoop:
# for i in range(0, len(self.platform.gamestart_button_list), 1):
# if self.platform.gamestart_button_list[i].is_mouse_over(mouse.get_pos()) and i is not constants.GAMESTART_BUTTON_TYPE["mute"]:
# self.sfx.play_mouseover()
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
if event.type == pygame.MOUSEBUTTONDOWN:
for i in range(0, len(self.platform.gamestart_button_list), 1):
if self.platform.gamestart_button_list[i].is_mouse_over(mouse.get_pos()):
if i == constants.GAMESTART_BUTTON_TYPE["mute"]:
self.sfx.play_mouseover()
self.platform.gamestart_mute_button.toggle_frame()
if self.sfx.is_muted == True:
self.sfx.set_unmute()
else:
self.sfx.set_mute()
elif i == constants.GAMESTART_BUTTON_TYPE["play"]:
self.sfx.play_mouseover()
exitLoop = True
self.sfx.stop_start_screen()
self.scoreboard.reset_score()
self.start(False)
elif i == constants.GAMESTART_BUTTON_TYPE["exit"]:
self.sfx.play_mouseover()
exitLoop = True
self.done = True
self.platform.gamestart_screen(mouse.get_pos(), pygame.event.get())
pygame.display.update()
GameManager.clock.tick(constants.FPS)
def start(self, is_show_start_screen):
if is_show_start_screen:
self.start_screen()
pygame.mixer.music.play(-1) # Play the fans cheering music
self.sfx.play_start_game()
last_time_updated = pygame.time.get_ticks()
is_resetting_game = False
for user in self.userList:
user.reset_players_position()
pygame.key.set_repeat(1, 20)
# Main Program Loop
while not self.done:
# Move all players in a team at the same time
keys = pygame.key.get_pressed()
# Move all user1's players
if keys[pygame.K_LSHIFT]:
if keys[pygame.K_d]:
for player in self.userList[0].players_list:
player.go_right()
elif keys[pygame.K_a]:
for player in self.userList[0].players_list:
player.go_left()
elif keys[pygame.K_w]:
for player in self.userList[0].players_list:
player.go_up()
elif keys[pygame.K_s]:
for player in self.userList[0].players_list:
player.go_down()
# Move all user2's players
if keys[pygame.K_RCTRL]:
if keys[pygame.K_RIGHT]:
for player in self.userList[1].players_list:
player.go_right()
elif keys[pygame.K_LEFT]:
for player in self.userList[1].players_list:
player.go_left()
elif keys[pygame.K_UP]:
for player in self.userList[1].players_list:
player.go_up()
elif keys[pygame.K_DOWN]:
for player in self.userList[1].players_list:
player.go_down()
for event in pygame.event.get():
if event.type == pygame.QUIT:
self.done = True
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_ESCAPE:
self.done = True
# User1 input handlers
for i in range(0, len(data.controllerSetting), 1):
user_setting = data.controllerSetting[i]
user = self.userList[i]
# if event.key == user_setting['next'] and not self.automatic_choose:
# user.players_list[user.current_selected_player].stop()
# user.current_selected_player = (user.current_selected_player + 1) % user.num_of_players
# user.focused_player_index = user.current_selected_player
# self.focus_effect_list[i].set_player(user.players_list[user.current_selected_player])
if event.key == user_setting['left']:
user.players_list[user.current_selected_player].go_left()
if event.key == user_setting['right']:
user.players_list[user.current_selected_player].go_right()
if event.key == user_setting['up']:
user.players_list[user.current_selected_player].go_up()
if event.key == user_setting['down']:
user.players_list[user.current_selected_player].go_down()
if event.type == pygame.KEYUP:
if event.key == pygame.K_F5:
# Hot reset the game
self.scoreboard.reset_score()
self.ball.goal = False
self.ball.is_ball_going_in = False
self.ball.change_x = 0
self.ball.change_y = 0
self.ball.set_position_center(constants.BALL_INIT_POS[0], constants.BALL_INIT_POS[1])
self.ball.is_ball_hit_wall = False
self.start(False)
if event.key == pygame.K_m:
if self.sfx.is_muted == True:
self.sfx.set_unmute()
else:
self.sfx.set_mute()
for i in range(0, len(data.controllerSetting), 1):
user_setting = data.controllerSetting[i]
user = self.userList[i]
if event.key == user_setting['next'] or event.key == user_setting['left'] or event.key == \
user_setting['right'] or event.key == user_setting['up'] or event.key == user_setting[
'down']:
user.players_list[user.current_selected_player].stop()
user.isInControl = False
# TODO a goal scored !
if self.ball.goal:
self.goal_effect.play(2)
if is_resetting_game == False:
self.sfx.play_goal()
now = pygame.time.get_ticks()
if is_resetting_game == True and (now - last_time_updated) >= self.ball_reset_delay:
# Update score
self.scoreboard.inc_score(data.winner)
self.ball.goal = False
self.ball.is_ball_going_in = False
self.ball.change_x = 0
self.ball.change_y = 0
self.ball.set_position_center(constants.BALL_INIT_POS[0], constants.BALL_INIT_POS[1])
self.ball.is_ball_hit_wall = False
for user in self.userList:
user.reset_players_position()
if self.is_game_over():
print("GAME OVER")
self.sfx.play_goal()
self.sfx.play_end_game()
self.gameover_screen()
else:
self.sfx.play_start_game()
is_resetting_game = False
continue
is_resetting_game = True
if is_resetting_game == False:
last_time_updated = pygame.time.get_ticks()
# Update the players
self.focus_effect_group.update()
# test
for x in range(0, len(self.player_list)):
for y in range(x + 1, len(self.player_list)):
self.collision.collisionPlayer2Player(self.player_list[x], self.player_list[y], self.sfx)
# Update the player
self.focus_effect_group.update()
self.sprite_group.update()
self.platform.update()
self.goal_effect_group.update()
for i in range(0, len(self.userList), 1):
self.userList[i].update(self.focus_effect_list[i])
# ALL CODE TO DRAW SHOULD GO BELOW THIS COMMENT
self.platform.draw()
self.focus_effect_group.draw(self.screen)
self.sprite_group.draw(self.screen)
self.platform.draw_goal()
self.scoreboard.update()
self.goal_effect_group.draw(self.screen)
# ALL CODE TO DRAW SHOULD GO ABOVE THIS COMMENT
# rect = self.user_init(self.ball_init()).players_list[0].rect.center
# pygame.draw.circle(self.screen, (255,255,255), (rect[0]+2,rect[1]), 37)
# Limit to 60 frames per second
GameManager.clock.tick(constants.FPS)
# Go ahead and update the screen with what we've drawn
pygame.display.flip()
# Be IDLE friendly. If you forget this line, the program will 'hange'
# on exit.
pygame.quit()
from sound_effects import SoundEffects effects = SoundEffects() loc = '../sounds/Yee.wav' effects.play_wave_file(loc) effects.play_wave_file(loc)
class AlienInvasion:
"""Overall class to manage game assets and behavior"""
def __init__(self):
"""Initialize the game, and create game resources."""
pygame.init()
self.settings = Settings()
self.screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
self.settings.screen_width = self.screen.get_rect().width
self.settings.screen_height = self.screen.get_rect().height
pygame.display.set_caption("Alien Invasion")
# Create an instance to store game statistics and 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.sound_effects = SoundEffects()
self._create_fleet()
# Make the play buttons -- TO REFACTOR.
self.play_button = Button(self, (0, 255, 0), 200, 50)
self.hard_button = Button(self, (0, 0, 255), 100, 50)
self.crazy_button = Button(self, (255, 0, 0), 100, 50)
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._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)
self._check_hard_button(mouse_pos)
self._check_crazy_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 game statistics
self._start_game()
def _check_hard_button(self, mouse_pos):
button_clicked = self.hard_button.rect.collidepoint(mouse_pos)
if button_clicked and not self.stats.game_active:
self.settings.difficulty_level = 'hard'
def _check_crazy_button(self, mouse_pos):
button_clicked = self.crazy_button.rect.collidepoint(mouse_pos)
if button_clicked and not self.stats.game_active:
self.settings.difficulty_level = 'crazy'
def _start_game(self):
# reset game stats
self.stats.reset_stats()
self.sb.prep_images()
# get rid of aliens and bullets
self.aliens.empty()
self.bullets.empty()
# create new fleet and re-center ship
self._create_fleet()
self.ship.center_ship()
# Hide the mouse cursor
pygame.mouse.set_visible(False)
self.settings.set_speedup_scale()
def _check_keydown_events(self, event):
"""respond to key presses"""
if event.key == pygame.K_RIGHT:
# Move the ship to 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_SPACE:
self._fire_bullet()
elif event.key == pygame.K_p and not self.stats.game_active:
self._start_game()
elif event.key == pygame.K_q:
sys.exit()
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:
# Move the ship to the left
self.ship.moving_left = False
def _fire_bullet(self):
"""Create 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)
self.sound_effects.play_shoot()
def _update_bullets(self):
"""Update 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_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()
self.sound_effects.play_alien_hit()
if not self.aliens:
self._start_new_level()
def _start_new_level(self):
"""Begin new level"""
# Destroy existing bullets and create new fleet.
self.bullets.empty()
self._create_fleet()
self.settings.increase_speed()
self.stats.level += 1
self.sb.prep_level()
def _update_aliens(self):
"""Check if fleet is at an edge, then update the positions of all aliens in the fleet"""
self._check_fleet_edges()
self.aliens.update()
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 _create_fleet(self):
"""Create a fleet of aliens"""
# Make an alien
alien = Alien(self)
alien_width, alien_height = alien.rect.size
available_space_x = self.settings.screen_width - (2 * alien_width)
number_aliens_x = available_space_x // (2 * alien_width)
# Determine number of rows of aliens that fit on screen
ship_height = self.ship.rect.height
available_space_y = (self.settings.screen_height - (3 * alien_height) -
ship_height)
number_rows = available_space_y // (2 * alien_height)
# Create 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 and alien and place in row
alien = Alien(self)
alien_width, alien_height = alien.rect.size
alien.x = alien_width + 2 * alien_width * alien_number
alien.rect.x = alien.x
alien.rect.y = alien.rect.height + 2 * alien.rect.height * row_number
self.aliens.add(alien)
def _update_screen(self):
"""Update images on 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 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("Play")
self.hard_button.draw_button("Hard",
self.screen.get_rect().bottom,
self.screen.get_rect().left)
self.crazy_button.draw_button("Crazy",
self.screen.get_rect().bottom - 70,
self.screen.get_rect().left)
pygame.display.flip()
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
self.sound_effects.play_alien_change_dir()
def _ship_hit(self):
"""Respond to the ship being hit by an alien."""
if self.stats.ships_left > 0:
# Decrement ships_left, 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
self.settings.reset_speed()
pygame.mouse.set_visible(True)
self.stats.update_high_score()
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
