pygame alien invasion v1.2 (enhanced version 1)

Optimization over the original game
1. Game background music, launch and collision sound effects
2. Permanent record of maximum score
Main module: alien? Investment.py

#coding=utf-8
import sys
import pygame
from pygame.sprite import Group
from settings import Settings
from game_stats import GameStats
from scoreboard import Scoreboard
from button import Button
from ship import Ship
import game_functions as gf
#Music loading
pygame.mixer.init()
pygame.mixer.music.load("D:/intro.mp3")
def run_game():
 #Initializing pygame, settings, and screen objects
 pygame.init()
 ai_settings = Settings()
 screen = pygame.display.set_mode(
  (ai_settings.screen_width,ai_settings.screen_height))
 pygame.display.set_caption("Alien Invasion")
 #Create an instance to store game statistics and create a scoreboard
 stats = GameStats(ai_settings)
 sb = Scoreboard(ai_settings,screen,stats)
 #Create a spaceship
 ship = Ship(ai_settings,screen)
 #Create a group to store bullets
 bullets = Group()
 aliens = Group()
 #Creating alien groups
 gf.create_fleet(ai_settings,screen,ship,aliens)
 #Create play button
 play_button = Button(ai_settings,screen,"Play")
 #Start the main cycle of the game
 while True:
  gf.bg_mcsic()
  gf.check_events(ai_settings,screen,stats,sb,play_button,ship,aliens,bullets)
  if stats.game_active:
   ship.update()
   gf.update_bullets(ai_settings,screen,stats,sb,ship,aliens,bullets)
   gf.update_aliens(ai_settings,stats,sb,screen,ship,aliens,bullets)
  gf.update_screen(ai_settings,screen,stats,sb,ship,aliens,bullets,play_button)
run_game()

bullet.py

#coding=utf-8
import pygame
from pygame.sprite import Sprite
class Bullet(Sprite):
 #A class that manages the bullets fired by a spaceship
 def __init__(self,ai_settings,screen,ship):
  #Create a bullet object where the ship is located
  super(Bullet,self).__init__()
  self.screen = screen
  #Create a rectangle representing the bullet at (0, 0) and set the correct position
  self.rect = pygame.Rect(0,0,ai_settings.bullet_width,
   ai_settings.bullet_height)
  self.rect.centerx = ship.rect.centerx
  self.rect.top = ship.rect.top
  #Store bullet position in decimal
  self.y = float(self.rect.y)
  self.color = ai_settings.bullet_color
  self.speed_factor = ai_settings.bullet_speed_factor
 def update(self):
  #Move the bullet up
  #Update the small value indicating the bullet position
  self.y-=self.speed_factor
  #Update indicates the location of the bullet rect
  self.rect.y = self.y
 def draw_bullet(self):
  #Draw bullets on the screen
  pygame.draw.rect(self.screen,self.color,self.rect)

Function function game? Functions.py

#coding=utf-8
import json
import sys
from time import sleep
import pygame
from bullet import Bullet
from alien import Alien
def check_keydown_events(event,ai_settings,screen,ship,bullets):
 #Response button
 if event.key == pygame.K_RIGHT:
  ship.moving_right = True
 elif event.key == pygame.K_LEFT:
  ship.moving_left = True
 elif event.key == pygame.K_SPACE:
  fire_bullet(ai_settings,screen,ship,bullets)
 elif event.key == pygame.K_q:
  sys.exit() 
def fire_bullet(ai_settings,screen,ship,bullets):
 #If you haven't reached the limit, fire a bullet
 #Create a bullet and add it to the group bullets
 if len(bullets)<ai_settings.bullets_allowed:
  pygame.mixer.Sound("biu.wav").play()
  new_bullet = Bullet(ai_settings,screen,ship)
  bullets.add(new_bullet)
def check_keyup_events(event,ship):
 #Response loosening
 if event.key == pygame.K_RIGHT:
  ship.moving_right = False 
 elif event.key == pygame.K_LEFT:
  ship.moving_left = False
def check_events(ai_settings,screen,stats,sb,play_button,ship,aliens,bullets):
 #Respond to key and mouse events
 for event in pygame.event.get():
  if event.type == pygame.QUIT:
   sys.exit()
  elif event.type == pygame.KEYDOWN:
   check_keydown_events(event,ai_settings,screen,ship,bullets)
  elif event.type == pygame.KEYUP:
   check_keyup_events(event,ship)
  elif event.type == pygame.MOUSEBUTTONDOWN:
   mouse_x,mouse_y = pygame.mouse.get_pos()
   check_play_button(ai_settings,screen,stats,sb,play_button,ship,
         aliens,bullets,mouse_x,mouse_y)
def check_play_button(ai_settings,screen,stats,sb,play_button,ship,aliens,
       bullets,mouse_x,mouse_y):
 #Start a new game when the player has a single Play button
 button_checked = play_button.rect.collidepoint(mouse_x,mouse_y)
 if button_checked and not stats.game_active:
  #Reset game settings
  ai_settings.initialize_dynamic_settings()
  #hide cursor
  pygame.mouse.set_visible(False)
  #Reset game statistics
  stats.reset_stats()
  stats.game_active = True
  #Reset scoreboard image
  sb.prep_score()
  sb.prep_high_score()
  sb.prep_level()
  sb.prep_ships()
  #Empty alien list and bullet list
  aliens.empty()
  bullets.empty()
  #Create a new group of aliens and center the spacecraft
  create_fleet(ai_settings,screen,ship,aliens)
  ship.center_ship()
def update_screen(ai_settings,screen,stats,sb,ship,aliens,bullets,play_button):
 #Update the image on the screen and switch to the new screen
 #Redraw the screen every time you cycle
 screen.fill(ai_settings.bg_color)
 #Redraw all the bullets behind the spaceship and the alien
 for bullet in bullets:
  bullet.draw_bullet()
 ship.blitme()
 aliens.draw(screen)
 #Display score
 sb.show_score()
 #If the game is inactive, draw the Play button
 if not stats.game_active:
  play_button.draw_button()
 #Make the most recently drawn screen visible
 pygame.display.flip()
def update_bullets(ai_settings,screen,stats,sb,ship,aliens,bullets):
 #Update the location of bullets and delete the disappeared bullets
 #Update bullet position
 bullets.update()
 #Delete bullets that have disappeared
 for bullet in bullets.copy():
  if bullet.rect.bottom<=0:
   bullets.remove(bullet)
 check_bullets_alien_collisions(ai_settings,screen,stats,sb,
          ship,aliens,bullets)
def check_bullets_alien_collisions(ai_settings,screen,stats,sb,ship,
          aliens,bullets):
 #In response to the collision between the bullet and the alien
 #Delete bullets and aliens in collision
 collisions = pygame.sprite.groupcollide(bullets,aliens,True,True)
 if collisions:
  pygame.mixer.Sound("boom.wav").play()
  for aliens in collisions.values():
   stats.score+=ai_settings.alien_points*len(aliens)
   sb.prep_score()
  check_high_score(stats,sb)
 if len(aliens) == 0:
  #Delete existing bullets and create a new group of Aliens
  bullets.empty()
  ai_settings.increase_speed()
  #Raise grade
  stats.level+=1
  sb.prep_level()
  create_fleet(ai_settings,screen,ship,aliens)
def bg_mcsic():
 if pygame.mixer.music.get_busy()==False:
  pygame.mixer.music.play()
def get_number_aliens_x(ai_settings,alien_width):
 #Calculate how many aliens per row
 available_space_x = ai_settings.screen_width-2 * alien_width
 number_aliens_x = int(available_space_x / (2 * alien_width))
 return number_aliens_x
def get_mumber_rows(ai_settings,ship_height,alien_height):
 #How many lines of aliens can the screen hold
 available_space_y = (ai_settings.screen_height - 
       (3 * alien_height) - ship_height)
 number_rows = int(available_space_y / (2 * alien_height))
 return number_rows      
def create_alien(ai_settings,screen,aliens,alien_number,row_number):
 #Create an alien and add it to the current line
 alien = Alien(ai_settings,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
 aliens.add(alien)
def create_fleet(ai_settings,screen,ship,aliens):
 #Creating alien groups
 #Create an alien and calculate how many aliens each row can hold
 alien = Alien(ai_settings,screen)
 number_aliens_x = get_number_aliens_x(ai_settings,alien.rect.width) 
 number_rows = get_mumber_rows(ai_settings,ship.rect.height,
  alien.rect.height)
 #Creating alien groups
 for row_number in range(number_rows):
  for alien_number in range(number_aliens_x):
   create_alien(ai_settings,screen,aliens,alien_number,
    row_number)
def check_fleet_edges(ai_settings,aliens):
  #Take action when an alien reaches the edge
  for alien in aliens.sprites():
   if alien.check_edges():
    change_fleet_direction(ai_settings,aliens)
    break
def change_fleet_direction(ai_settings,aliens):
 #Move the whole group of aliens down and change their direction
 for alien in aliens.sprites():
  alien.rect.y+= ai_settings.fleet_drop_speed
 ai_settings.fleet_direction *= -1
def ship_hit(ai_settings,stats,sb,screen,ship,aliens,bullets):
 #Responding to a spaceship hit by an alien
 if stats.ship_left > 0:
  #Subtract 1 from "shifts" left
  stats.ship_left -= 1
  #Update scoreboard
  sb.prep_ships()
  #Empty alien list and bullet list
  aliens.empty()
  bullets.empty()
  #Create a new group of aliens and place the spacecraft in the bottom center of the screen
  create_fleet(ai_settings,screen,ship,aliens)
  ship.center_ship()
  #suspend
  sleep(0.5)
 else:
  stats.game_active = False
  pygame.mouse.set_visible(True)
def check_aliens_bottom(ai_settings,stats,sb,screen,ship,aliens,bullets):
 #Check if there are aliens at the bottom of the screen
 screen_rect = screen.get_rect()
 for alien in aliens.sprites():
  if alien.rect.bottom >= screen_rect.bottom:
   #Deal with it as if the ship had been hit
   ship_hit(ai_settings,stats,sb,screen,ship,aliens,bullets)
   break
def update_aliens(ai_settings,stats,sb,screen,ship,aliens,bullets):
 #Check if there are aliens on the edge of the screen and update the location of the entire group
 check_fleet_edges(ai_settings,aliens)
 aliens.update() 
 #Detect collisions between aliens and spacecraft
 if pygame.sprite.spritecollideany(ship,aliens):
  ship_hit(ai_settings,stats,sb,screen,ship,aliens,bullets)      
 #Check if there are aliens at the bottom of the screen
 check_aliens_bottom(ai_settings,stats,sb,screen,ship,aliens,bullets)
def check_high_score(stats,sb):
 #Check if the new highest score has appeared
 if stats.score>stats.high_score:
  stats.high_score=stats.score
  filename = 'alien_invasion.json'
  with open(filename, 'w') as f_obj:
   json.dump(stats.high_score,f_obj)
  sb.prep_high_score()

Initial message settings.py

#coding=utf-8
class Settings:
 #Class that stores all settings of alien invasion
 def __init__(self):
  #Initialize game settings
  #screen setting
  self.screen_width = 1200
  self.screen_height = 800
  self.bg_color = (230, 230, 230)
  #Position of the spacecraft
  self.ship_limit = 3
  #Bullet setting
  self.bullet_width = 3
  self.bullet_height = 15
  self.bullet_color = 60,60,60
  self.bullets_allowed = 4
  #Alien settings
  self.fleet_drop_speed = 10
  #How to speed up the game
  self.speedup_scale = 1.1
  #Alien points increase speed
  self.score_scale = 1.5
  self.initialize_dynamic_settings()
 def initialize_dynamic_settings(self):
  #Initialize settings that change as the game progresses
  self.ship_speed_factor = 1.5
  self.alien_speed_factor = 1
  self.bullet_speed_factor = 3
  #If the flight direction is 1, it means to the right; if it is - 1, it means to the left
  self.fleet_direction = 1
  #Score
  self.alien_points = 50
 def increase_speed(self):
  #Increase speed settings
  self.ship_speed_factor *= self.speedup_scale
  self.bullet_speed_factor *= self.speedup_scale
  self.alien_speed_factor *= self.speedup_scale
  self.alien_points = int(self.alien_points*self.score_scale)

ship.py

#coding=utf-8
import pygame
from pygame.sprite import Sprite
class Ship(Sprite):
 def __init__(self,ai_settings,screen):
  #Initialize the spacecraft and set its initial position
  super(Ship,self).__init__()
  self.screen = screen
  self.ai_settings = ai_settings
  #Loading spacecraft image and obtaining its external rectangle
  self.image = pygame.image.load('images/ship.bmp')
  self.rect = self.image.get_rect()
  self.screen_rect = screen.get_rect()
  #Put each new ship in the center of the bottom of the screen
  self.rect.centerx = self.screen_rect.centerx
  self.rect.bottom = self.screen_rect.bottom
  #Store the minimum value in the ship's attribute center
  self.center = float(self.rect.centerx)
  #Mobile logo
  self.moving_right = False
  self.moving_left = False
 def update(self):
  #Adjust the position of the spacecraft according to the moving signs
  #Update the center value of the ship instead of rect
  if self.moving_right and self.rect.right<self.screen_rect.right:
   self.center+=self.ai_settings.ship_speed_factor
  if self.moving_left and self.rect.left>0:
   self.center-=self.ai_settings.ship_speed_factor
  #Update rect object according to self.center
  self.rect.centerx = self.center
 def blitme(self):
  #Draw the spacecraft at the designated location
  self.screen.blit(self.image,self.rect)
 def center_ship(self):
  #Center the ship on the screen
  self.center = self.screen_rect.centerx

Alien alien.py

#coding=utf-8
import pygame
from pygame.sprite import Sprite
class Alien(Sprite):
 #Class representing a single alien
 def __init__(self,ai_settings,screen):
  #Initialize the alien and set its starting position
  super(Alien,self).__init__()
  self.screen = screen
  self.ai_settings = ai_settings
  #Load the alien image and set its rect property
  self.image = pygame.image.load('images/alien.bmp')
  self.rect = self.image.get_rect()
  #Each alien was initially near the top left corner of the screen
  self.rect.x = self.rect.width
  self.rect.y = self.rect.height
  #Store the exact location of Aliens
  self.x = float(self.rect.x)
 def blitme(self):
  #Draw aliens in designated locations
  self.screen.blit(self.image,self.rect)
 def update(self):
  #Move aliens right
  self.x+= self.ai_settings.alien_speed_factor
  self.rect.x = self.x
 def check_edges(self):
  #Returns True if the alien is on the edge of the screen
  screen_rect = self.screen.get_rect()
  if self.rect.right >= screen_rect.right:
   return True
  elif self.rect.left <= 0:
   return True
 def update(self):
  #Move aliens left or right
  self.x+= (self.ai_settings.alien_speed_factor * 
      self.ai_settings.fleet_direction) 
  self.rect.x = self.x

Game data

#coding=utf-8
import json
class GameStats():
 #Track game statistics
 def __init__(self,ai_settings):
  #Initialize statistics
  self.ai_settings = ai_settings
  self.reset_stats()
  #The game was inactive when it was first started
  self.game_active = False
  #In no case should the maximum score be reset
  self.filename = 'alien_invasion.json'
  with open(self.filename) as f_obj:
   self.high_score = json.load(f_obj)
 def reset_stats(self):
  #Initialize statistics that may change during the game run
  self.ship_left = self.ai_settings.ship_limit
  self.score = 0
  self.level = 1

scoreboard.py

#coding=utf-8
import pygame.font
from pygame.sprite import Group
from ship import Ship
class Scoreboard():
 #Category displaying score information
 def __init__(self,ai_settings,screen,stats):
  #Attribute involved in initializing display score
  self.screen = screen
  self.screen_rect = screen.get_rect()
  self.ai_settings = ai_settings
  self.stats = stats
  #Font settings used to display score information
  self.text_color = (30,30,30)
  self.font = pygame.font.SysFont(None, 48)
  #Prepare to include current score and highest score image
  self.prep_score()
  self.prep_high_score()
  self.prep_level()
  self.prep_level()
  self.prep_ships()
 def prep_score(self):
  #Show score as a rendered image
  rounded_score = int(round(self.stats.score,-1))
  score_str = "{:,}".format(rounded_score)
  self.score_image = self.font.render(score_str,True,self.text_color,
            self.ai_settings.bg_color)
  #Put the score in the top right corner of the screen
  self.score_rect = self.score_image.get_rect()
  self.score_rect.right = self.screen_rect.right - 20
  self.score_rect.top = 20
 def prep_high_score(self):
  #Display the highest score as a rendered image
  high_score = int(round(self.stats.high_score,-1))
  high_score_str = "{:,}".format(high_score)
  self.high_score_image = self.font.render(high_score_str,True,
       self.text_color,self.ai_settings.bg_color)
  #Display the highest score in the top center of the screen
  self.high_score_rect = self.high_score_image.get_rect()
  self.high_score_rect.right = self.screen_rect.centerx
  self.high_score_rect.top = self.score_rect.top
 def prep_level(self):
  #Convert levels to rendered images
  self.level_image = self.font.render(str(self.stats.level),True,
       self.text_color,self.ai_settings.bg_color)
  #Put the grade below the score
  self.level_rect = self.level_image.get_rect()
  self.level_rect.right = self.score_rect.right
  self.level_rect.top = self.score_rect.bottom+10
 def prep_ships(self):
  #Show how many ships are left
  self.ships = Group()
  for ship_number in range(self.stats.ship_left):
   ship = Ship(self.ai_settings,self.screen)
   ship.rect.x = 10+ship_number*ship.rect.width
   ship.rect.y = 10
   self.ships.add(ship)
 def show_score(self):
  #Show score on screen
  self.screen.blit(self.score_image,self.score_rect)
  self.screen.blit(self.high_score_image,self.high_score_rect)
  self.screen.blit(self.level_image,self.level_rect)
  #Mapping spacecraft
  self.ships.draw(self.screen)

Music download link
Link: https://pan.baidu.com/s/1rbSDhb9YLo6LDURoVJeWng
Extraction code: mge3
Picture download link: https://pan.baidu.com/s/12AMkT6N2nGdtZE-J6o_Wbw
Extraction code: 2adh
If you have any questions, please comment

Published 23 original articles, won praise 3, visited 459
Private letter follow

Tags: JSON Attribute Mobile

Posted on Thu, 13 Feb 2020 10:13:15 -0500 by SuprSpy79