class AlienInvasion:
'''overall class to manage game assets and behavior'''
def __init__(self):
pygame.init()
self.setting1 = Setting()
self.screen = pygame.display.set_mode((0, 0), pygame.FULLSCREEN)
self.screen_rect = self.screen.get_rect()
pygame.display.set_caption('Alien Invasion')
self.stats = Gamestats(self)
self.ship = Ship(self)
self.bullets = pygame.sprite.Group()
self.aliens = pygame.sprite.Group()
self._create_fleet()
self.play_button = Button(self, 'PLAY')
self.sb = Scoreboard(self)
def run_game(self):
while True:
self._check_event()
if self.stats.game_active:
self.ship.update_ship()
self._update_bullet()
self._update_alien()
self._update_screen()
def _check_event(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_RIGHT:
self.ship.move_to_right = True
elif event.key == pygame.K_LEFT:
self.ship.move_to_left = True
elif event.key == pygame.K_q:
sys.exit()
elif event.key == pygame.K_SPACE:
self._fire_bullet()
elif event.type == pygame.KEYUP:
if event.key == pygame.K_RIGHT:
self.ship.move_to_right = False
elif event.key == pygame.K_LEFT:
self.ship.move_to_left = False
elif event.type == pygame.MOUSEBUTTONDOWN:
mouse_pos = pygame.mouse.get_pos()
self._check_play_button(mouse_pos)
def _check_play_button(self, mouse_pos):
if self.play_button.rect.collidepoint(
mouse_pos) and self.stats.game_active == False:
self.stats.game_active = True
self.stats.reset_stats()
self.sb.prep_score()
self.sb.prep_ship()
self.aliens.empty()
self.bullets.empty()
self.setting1.initialized_dynamic_setting()
self._create_fleet()
self.ship.recenter_ship()
pygame.mouse.set_visible(False)
def _update_screen(self):
self.screen.fill(self.setting1.bg_color)
self.ship.blitme()
for bullet in self.bullets.sprites():
bullet.draw_bullet()
self.aliens.draw(self.screen)
self.sb.draw_score()
if not self.stats.game_active:
self.play_button.draw_button()
pygame.display.flip()
def _fire_bullet(self):
if len(self.bullets) < self.setting1.max_valid_bullet:
new_bullet = Bullets(self)
self.bullets.add(new_bullet)
def _update_bullet(self):
self.bullets.update()
self._remove_invalid_bullet()
self._hit_alien()
self._refill_fleet()
def _remove_invalid_bullet(self):
for bullet in self.bullets.copy():
if bullet.rect.bottom <= 0:
self.bullets.remove(bullet)
def _refill_fleet(self):
if not self.aliens:
self.bullets.empty()
self._create_fleet()
self.setting1.increase_speed()
self.stats.level += 1
self.sb.prep_level()
def _hit_alien(self):
collisions = pygame.sprite.groupcollide(self.bullets, self.aliens,
False, True)
if collisions:
for aliens in collisions.values():
self.stats.score += len(aliens) * self.setting1.hit_score
self.sb.prep_score()
if self.stats.score > self.stats.high_score:
self.stats.high_score = self.stats.score
self.sb.high_score()
def _create_fleet(self):
alien = Alien(self)
alien.width, alien.height = alien.rect.size
avalible_y = self.screen_rect.height - 3 * alien.height - self.ship.rect.height
row_numbers = avalible_y // (2 * alien.height)
avalible_x = self.screen_rect.width - 2 * alien.width
column_numbers = avalible_x // (2 * alien.width)
for row_number in range(row_numbers):
for column_number in range(column_numbers):
self._add_alien(row_number, column_number)
def _add_alien(self, row_number, column_number):
alien = Alien(self)
alien.rect.x = alien.rect.width + 2 * alien.rect.width * column_number
alien.rect.y = alien.rect.height + 2 * alien.rect.height * row_number
self.aliens.add(alien)
def _check_edges(self):
for alien in self.aliens.sprites():
if alien.check_edge():
self._change_direction()
break
def _change_direction(self):
for alien in self.aliens.sprites():
alien.rect.y += self.setting1.alien_drop_speed
self.setting1.direction *= -1
def _update_alien(self):
self._check_edges()
self.aliens.update()
if pygame.sprite.spritecollideany(self.ship, self.aliens):
self._hit_ship()
for alien in self.aliens:
if alien.rect.bottom >= self.screen_rect.bottom:
self._hit_ship()
break
def _hit_ship(self):
if self.stats.ship_left > 0:
self.stats.ship_left -= 1
self.sb.prep_ship()
self.aliens.empty()
self.bullets.empty()
self._create_fleet()
self.ship.recenter_ship()
sleep(0.5)
else:
self.stats.game_active = False
pygame.mouse.set_visible(True)
class AlienInvasion:
# overall class for game assets and behaviour
def __init__(self):
pygame.init() # initialize the game
self.settings = Settings()
# self.screen = pygame.display.set_mode((self.settings.screen_width, self.settings.screen_height))
# for 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")
self.stats = Gamestats(self) # instance for game stats
self.sb = Scoreboard(self)
self.ship = Ship(self)
self.stars = pygame.sprite.Group()
self.bullets = pygame.sprite.Group()
self.aliens = pygame.sprite.Group()
self._create_tara()
self._create_fleet()
self.play_button = Button(self, "START!")
def run_game(self):
while True: # starts the main loop for game
self._check_events() # watch for keyboard and mouse movements
self.stars.update()
if self.stats.game_active:
self.ship.update()
self._update_bullets()
self._update_aliens()
self._update_screen()
def _create_tara(self):
star = Star(self) # make a star
star_width, star_height = star.rect.size
available_space_x = self.settings.screen_width - 10*star_width
number_stars_x = available_space_x // (25*star_width)
ship_height = self.ship.rect.height
available_space_y = (self.settings.screen_height - (3*star_height) - ship_height)
number_rows = available_space_y // (2*star_height)
for row_number in range (number_rows):
for star_number in range(number_stars_x):
self._create_star(star_number, row_number)
def _create_star(self, star_number, row_number):
star = Star(self)
star_width, star_height = star.rect.size
star.x = star_width + 40*star_width*star_number
star.rect.x = star.x + 10
star.rect.y = (5*star.rect.height + 40*star.rect.height*row_number)
self.stars.add(star)
def _create_fleet(self):
# create a fleet of aliens
alien = Alien(self) # make an alien
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 to 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 the full sleet 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):
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):
# drop the entire fleet and change its direction
for alien in self.aliens.sprites():
alien.rect.y += self.settings.fleet_drop_speed
self.settings.fleet_direction *= (-1)
def _update_aliens(self):
self._check_fleet_edges() # check if fleet is at an edge
self.aliens.update() # update the position of all aliens
# look for alien-ship collisions
if pygame.sprite.spritecollideany(self.ship, self.aliens):
self._ship_hit()
self._check_aliens_bottom() # check if alien has hit 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:
self.stats.ships_left -= 1 # decreament ships left
# get rid of remaining aliens and bullets
self.aliens.empty()
self.bullets.empty()
# create new fleet and centre the ship
self._create_fleet()
self.ship.center_ship
sleep(0.5) #pause
else:
self.stats.game_active = False
pygame.mouse.set_visible(True)
def _update_bullets(self):
self.bullets.update()
# deleting bullets vanished from screen
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):
# check if a bullet has hit an alien; if hits, get reid of 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) # score update
self.sb.prep_score()
self.sb.check_high_score()
# if aliens group is empty, 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 _check_events(self):
for event in pygame.event.get():
if event.type == pygame.QUIT:
lekho = open(r"highscore.txt", "w")
lekho.write(str(self.stats.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: # keydown=pressing/holding key, keyup=releasing
self._check_keydown_events(event)
elif event.type == pygame.KEYUP:
self._check_keyup_events(event)
def _check_play_button(self, mouse_pos):
# start game when user hit play button
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() # reset the game stat
self.stats.game_active = True
self.sb.prep_score()
self.sb.prep_level
self.aliens.empty()
self.bullets.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_UP:
self.ship.moving_up = True
elif event.key == pygame.K_DOWN:
self.ship.moving_down = True
elif event.key == pygame.K_SPACE:
self._fire_bullet()
elif event.key == pygame.K_ESCAPE:
lekho = open(r"highscore.txt", "w")
lekho.write(str(self.stats.high_score))
sys.exit()
def _check_keyup_events (self, event):
if event.key == pygame.K_RIGHT:
self.ship.moving_right = False
elif event.key == pygame.K_LEFT:
self.ship.moving_left = False
elif event.key == pygame.K_UP:
self.ship.moving_up = False
elif event.key == pygame.K_DOWN:
self.ship.moving_down = False
def _fire_bullet(self):
if len(self.bullets) < self.settings.bullets_allowed:
new_bullet = Bullet(self) # create new bullet and add it in group
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.stars.draw(self.screen)
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 the game is inactive
if not self.stats.game_active:
self.play_button.draw_button()
pygame.display.flip() # make the recent screen visible
class AlienInvasion:
# Display settings as adding alien,ship and bullets to the screen
def __init__(self):
pygame.init()
self.setting = Settings()
# Setting the screen
self.screen = pygame.display.set_mode(
(self.setting.screen_width, self.setting.screen_height))
self.setting.screen_width = self.screen.get_rect().width
self.setting.screen_height = self.screen.get_rect().height
self.background = pygame.image.load("starfield.png")
# Setting a Caption
pygame.display.set_caption("Alien Invasion")
# Setting a value for other python pages that are imported
self.stats = Gamestats(self)
self.S_B = scoreboard(self)
self.ship = ship(self)
self.bullets = pygame.sprite.Group()
self.aliens = pygame.sprite.Group()
self.S_B.check_high_score()
self.create_fleet()
# Setting button and a message
self.play_button = Button(self, "Play")
# Runs the game/functions
def run_game(self):
while True:
self.check_event()
if self.stats.game_active:
self.ship.update()
self.bullets.update()
self.update_bullet()
self.update_alien()
self.update_screen()
# runs the two function key up and key down
def check_event(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)
# sees if the key is still pressed or not to continue the movement
def Check_KEYDOWN(self, event):
if event.key == pygame.K_RIGHT:
self.ship.moving_right = True
if event.key == pygame.K_LEFT:
self.ship.moving_left = True
if event.key == pygame.K_UP:
self.ship.moving_top = True
if event.key == pygame.K_DOWN:
self.ship.moving_bottom = True
if event.key == pygame.K_SPACE:
self._fire_bullet()
if event.key == pygame.K_q:
sys.exit()
# sees if the key is still pressed or not to stop the movement
def Check_KEYUP(self, event):
if event.key == pygame.K_RIGHT:
self.ship.moving_right = False
if event.key == pygame.K_LEFT:
self.ship.moving_left = False
if event.key == pygame.K_UP:
self.ship.moving_top = False
if event.key == pygame.K_DOWN:
self.ship.moving_bottom = False
# Fires the bullets
def _fire_bullet(self):
# Amount of bullets that are allowed
if len(self.bullets) < self.setting.allowed_bullet:
new_bullet = Bullet(self)
self.bullets.add(new_bullet)
# Takes the alien and fills the screen with the alien image
def create_fleet(self):
alien = Alien(self)
alien_width, alien_height = alien.rect.size
available_space_x = self.setting.screen_width - (2 * alien_width)
number_alien_x = available_space_x // (2 * alien_width)
ship_height = self.ship.rect.height
available_space_y = (self.setting.screen_height - (5 * alien_height) -
ship_height)
number_alien_y = available_space_y // (2 * alien_height)
for row_number in range(number_alien_y):
for alien_number in range(number_alien_x):
self.create_alien(alien_number, row_number)
# Creates an alien
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)
# Checks if the fleet (the alien) have hit the edge or not
def check_fleet_edges(self):
# check if alien hit the edge
for alien in self.aliens.sprites():
if alien.check_edge():
self.change_fleet_direction()
break
# Changing direction of the aliens
def change_fleet_direction(self):
# change the fleet direction and drops the alien
for alien in self.aliens.sprites():
alien.rect.y += self.setting.fleet_drop_speed
self.setting.fleet_direction *= -1
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.setting.initialize_dynamic_settings()
self.stats.reset_stats()
self.stats.game_active = True
self.S_B.prep_score()
self.aliens.empty()
self.bullets.empty()
self.create_fleet()
self.ship.center_ship()
self.S_B.prep_ship()
# mouse unvisible
pygame.mouse.set_visible(False)
# If ship gets hit by alien
def ship_hit(self):
if self.stats.ships_left > 0:
# Removes a life of a player
self.stats.ships_left -= 1
self.S_B.prep_ship()
# Removes bullets and aliens fleets
self.aliens.empty()
self.bullets.empty()
# recenter the ship and recreate a fleet
self.create_fleet()
self.ship.center_ship()
# Pause
sleep(0.5)
else:
self.stats.game_active = False
# Mouse visible
pygame.mouse.set_visible(True)
def check_alien_bottom(self):
# Makes the screen a rectangle
screen_rect = self.screen.get_rect()
# Checks if the alien ship have hit the bottom screen
for alien in self.aliens.sprites():
if alien.rect.bottom >= screen_rect.bottom:
self.ship_hit()
break
# Removing the bullets and checking for a collision between alien and bullet
def update_bullet(self):
# Removes the bullet if goes throw the top if the display
for bullet in self.bullets.copy():
if bullet.rect.bottom <= 0:
self.bullets.remove(bullet)
self.check_bullet_hit()
# Collision to see if the bullets have hit the alien ship
def check_bullet_hit(self):
collision = pygame.sprite.groupcollide(self.bullets, self.aliens, True,
True)
# Adding points
if collision:
self.stats.score += self.setting.alien_points
self.S_B.prep_score()
self.S_B.check_high_score()
# Repopulating and Increasing speed
if not self.aliens:
self.bullets.empty()
self.create_fleet()
self.setting.increase_speed()
# Running two function that moves and checks if the alien hit the edges
def update_alien(self):
# Runs two functions the first one moves the fleet of alien and the second checks if the alien have hit and edge
self.aliens.update()
self.check_fleet_edges()
# Runs an if function to check for a collide between ship and alien
if pygame.sprite.spritecollideany(self.ship, self.aliens):
self.ship_hit()
# Runs a function that checks if the alien have hit the bottom of the screen
self.check_alien_bottom()
# filling the screen and drawing bullets
def update_screen(self):
# Fills the screen with a background
self.screen.blit(self.background, (0, 0))
# Display the Ship
self.ship.blit()
# Draw bullets on the screen
for bullet in self.bullets.sprites():
bullet.draw_bullet()
# Draw alien to the display
self.aliens.draw(self.screen)
self.S_B.show_score()
self.S_B.check_high_score()
# Play Button
if not self.stats.game_active:
self.play_button.draw_button()
# display flip
pygame.display.flip()
class AlienInvasion:
#It's a master class
def __init__(self):
pygame.init() #Initializing the game
self.screen = pygame.display.set_mode((800, 600))
# sets a 1200 pixel wide and 800 pixels high screen called surface
# Surface returned by pygame.display.set_mode() represents entire game window
self.bg = pygame.image.load(background_image)
pygame.display.set_caption("Alien Invasion")
self.stats = Gamestats(self) # creating instanc to store game-stats
self.sb = Scoreboard(self)
self.alien_speed = 1
self.Ship = ship(self)
self.our_speed = 1
self.bullets = pygame.sprite.Group()
self.aliens = pygame.sprite.Group()
self.fleet_direction = 1
self.val = 5
self._create_fleet()
self.bullet_speed = 1
self.bullet_width = 4
self.bullet_height = 15
self.bullet_color = (255, 0, 0)
self.bullet_allowed = 3
self.play_button = Button(self, "Play")
#self.win_button = Button(self,"You Won!!")
#self.Ship_speed = 2
def _create_fleet(self):
alien = Alien(self)
#self.aliens.add(alien)
#alien_width = 70
available_space_x = 800
number_aliens_x = available_space_x // (140)
ship_height = self.Ship.rect.height
alien_width, alien_height = alien.rect.size
available_space_y = 600 - (3 * alien_height) - ship_height
number_rows = available_space_y // (alien_height)
#print(number_rows)
#print(number_aliens_x)
for alien_row in range(number_rows):
for alien_number in range(number_aliens_x):
self.create_alien(alien_number, alien_row)
def create_alien(self, alien_number, alien_row):
alien = Alien(self)
alien_width, alien_height = alien.rect.size
alien.x = alien_width * alien_number + 50
alien.rect.x = alien.x
alien.rect.y = alien_height * alien_row
self.aliens.add(alien)
def _update_aliens(self):
for alien in self.aliens.sprites():
if alien.check_edge():
self.newer_update()
break
self.aliens.update(self.fleet_direction)
def newer_update(self):
for alien in self.aliens.sprites():
alien.rect.y += self.val #note that you can't increment with value < 1
self.fleet_direction *= -1
self.aliens.update(self.fleet_direction)
def _ship_newwave(self):
#print(self.stats.ship_left)
if self.stats.ship_left > 0:
self.stats.ship_left -= 1
self.val *= 1.5
self.bullet_speed *= 1.5
self.alien_speed *= 2
self.our_speed *= 2
self.sb.stats.level += 1
self.sb.prep_level()
#val_upadte()
self.aliens.empty()
self.bullets.empty()
# Create a new fleet and center the ship.
self._create_fleet()
self.Ship.center_ship()
sleep(0.5)
else:
self.stats.game_active = False
#self.win_button.draw_button()
pygame.mouse.set_visible(True)
def _check_play_button(self, mouse_pos):
if self.play_button.rect.collidepoint(
mouse_pos) and not self.stats.game_active:
self.stats.game_active = True
self.stats.reset_stats()
#print(self.stats.score)
self.sb.prep_level()
self.sb.prep_score()
pygame.mouse.set_visible(False)
self.aliens.empty()
self.bullets.empty()
self._create_fleet()
self.Ship.center_ship()
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.stats.game_active = False
self.stats.reset_stats()
self.sb.prep_score()
self.sb.prep_level()
break
def run_game(self): # Game is controlled by this function
self.stats.reset_stats()
while (True): #Infinte loop until game gives order to quit
for event in pygame.event.get():
#pygame.event.get() function returns a list of events occured since the last time it was called
if event.type == pygame.QUIT:
sys.exit()
elif event.type == pygame.KEYDOWN:
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:
new_bullet = Bullet(self)
self.bullets.add(new_bullet)
elif event.key == pygame.K_q:
sys.exit()
elif event.type == pygame.KEYUP:
if event.key == pygame.K_RIGHT:
self.Ship.moving_right = False
elif event.key == pygame.K_LEFT:
self.Ship.moving_left = False
elif event.type == pygame.MOUSEBUTTONDOWN:
mouse_pos = pygame.mouse.get_pos()
self.stats.reset_stats()
self._check_play_button(mouse_pos)
if self.stats.game_active:
self.Ship.update()
self.bullets.update()
self._update_aliens()
self.screen.blit(self.bg, [0, 0])
self.Ship.blitme()
for bullet in self.bullets.sprites():
bullet.draw_bullet()
self.aliens.draw(self.screen)
for bullet in self.bullets.copy(): #To save memory
if bullet.rect.bottom <= 0:
self.bullets.remove(bullet)
collisions = pygame.sprite.groupcollide(self.bullets, self.aliens,
True, True)
if collisions:
self.stats.score += 50
self.sb.prep_score()
self.sb.check_highscore()
#print(len(self.bullets))
#print(len(self.bullets))
self.sb.show_scorecard()
if not self.aliens:
# Destroy existing bullets and create new fleet.
self.bullets.empty()
#self._create_fleet()
self._ship_newwave()
if pygame.sprite.spritecollideany(self.Ship, self.aliens):
self.stats.game_active = False
pygame.mouse.set_visible(True)
self._check_aliens_bottom()
if not self.stats.game_active: #remember to keep it just before flip() func
self.play_button.draw_button()
pygame.mouse.set_visible(True)
#self.stats.reset_stats()
#self.sb.prep_score()
#self.sb.prep_level()
pygame.display.flip(
) # Makes the most recently drawn screen visible
