This article mainly introduces the complete implementation idea of Python alien invasion game programming in detail. The example code in this article is very detailed and has certain reference value. Interested partners can refer to the complete implementation idea of Python game programming alien invasion. The specific contents are as follows

preparation

Download python, such as Anaconda3(64 bit) , import pygame Game Pack

1. Alien settings, alien Py, code:

(PS: here is Source code , need Source code and source material Children's shoes can be clicked download Ready to download

import pygame
from pygame.sprite import Sprite

class Alien(Sprite):
 """Class representing a single alien"""
 
 def __init__(self,ai_settings,screen):
 """Initialize aliens and set other locations"""
 super(Alien,self).__init__()
 self.screen = screen
 self.ai_settings = ai_settings
 
 #Load the alien image and set its rect attribute
 self.image = pygame.image.load('images/alien.bmp')
 self.rect = self.image.get_rect()
 
 #Each alien was initially near the upper 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 at the specified location"""
 self.screen.blit(self.image,self.rect)
 
 def check_edges(self):
 """If the alien is on the edge of the screen, return True"""
 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 to the right"""
 self.x += (self.ai_settings.alien_speed_factor * self.ai_settings.fleet_direction)
 self.rect.x = self.x

2. Main program of the game, alien_invasion.py, code:

import pygame

from settings import Settings
from game_stats import GameStats
from button import Button
from ship import Ship
from pygame.sprite import Group
import game_functions as gf
from scoreboard import Scoreboard

def run_game():
 pygame.init() # Initialize background settings
 ai_settings = Settings() # Global settings

 screen = pygame.display.set_mode(  # Create screen display window
 (ai_settings.screen_width,ai_settings.screen_height)
 )
 pygame.display.set_caption('Alien Invasion') # title
 #New Play button
 play_button = Button(ai_settings,screen,"Play")
 #Create an instance for storing game statistics and create a scoreboard
 stats = GameStats(ai_settings)
 sb = Scoreboard(ai_settings, screen, stats)
 # Create spacecraft
 ship = Ship(ai_settings,screen)
 # Create bullet group
 bullets = Group()
 
 #Create an alien
 aliens = Group()
 #Create alien groups
 gf.create_fleet(ai_settings,screen,ship,aliens)
 
 # Start the main cycle of the game
 while True:
 # Monitor keyboard and mouse events
 gf.check_events(ai_settings,screen,stats,sb,play_button,ship,aliens,bullets)
 
 if stats.game_active:
  # Mobile spacecraft
  gf.update_ship(ship)
  # Update bullet position
  gf.update_bullets(ai_settings,screen,stats,sb,ship,aliens,bullets)
  #Update aliens
  gf.update_aliens(ai_settings,stats,screen,sb,ship,aliens,bullets)
 # Update screen
 gf.update_screen(ai_settings,screen,stats,sb,ship,aliens,bullets,play_button)

run_game()

3. Set bullet Py, code:

import pygame
from pygame.sprite import Sprite
import time

class Bullet(Sprite):
 '''The ship manages bullets'''

 def __init__(self,ai_settings,screen,ship):
 super(Bullet,self).__init__()
 self.screen = screen

 # The initial position (0,0,3,15) of the bullet rectangle corresponds to lef, top, width and height respectively
 self.rect = pygame.Rect(0,0,
 ai_settings.bullet_width, ai_settings.bullet_height)

 self.rect.centerx = ship.rect.centerx # Set the x-axis coordinates of the center point to be consistent with the spacecraft
 self.rect.top = ship.rect.top  # Set the top of the y-axis coordinate to be consistent with the spacecraft

 # Set to decimal for calculation
 self.top = float(self.rect.top)

 self.color = ai_settings.bullet_color
 self.speed_factor = ai_settings.bullet_speed_factor

 def update(self):
 self.top -=self.speed_factor
 self.rect.top = self.top
 print(self.rect.top)

 def draw_bullet(self):
 pygame.draw.rect(self.screen,self.color,self.rect)

4. Set the Play button, button Py, code:

import pygame.font

class Button():
 
 def __init__(self,ai_settings,screen,msg):
 """Initialize button properties"""
 self.screen = screen
 self.screen_rect = screen.get_rect()
 
 #Set the size and other properties of the button
 self.width,self.height = 200,50
 self.button_color = (0,255,0)
 self.text_color = (255,255,255)
 self.font = pygame.font.SysFont(None,48)
 
 #Create a rect object for the button and center it
 self.rect = pygame.Rect(0,0,self.width,self.height)
 self.rect.center = self.screen_rect.center
 
 #The label of the button only needs to be created once
 self.prep_msg(msg)
 
 def prep_msg(self,msg):
 """take msg Render as an image and center it on the button"""
 self.msg_image = self.font.render(msg,True,self.text_color,self.button_color)
 self.msg_image_rect = self.msg_image.get_rect()
 self.msg_image_rect.center =self.rect.center
 
 def draw_button(self):
 #Draw a button filled with color, and then draw the text
 self.screen.fill(self.button_color,self.rect)
 self.screen.blit(self.msg_image,self.msg_image_rect)

5. Set game function, game_functions.py, code:

import sys
import pygame
from bullet import Bullet
from alien import Alien
from time import sleep

def check_events(ai_settings,screen,stats,sb,play_button,ship,aliens,bullets):
 # Monitor keyboard and mouse events
 for event in pygame.event.get():

 if event.type == pygame.QUIT: # Close window exit
  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):
 """Click on the player Play Button to start the game"""
 button_clicked = play_button.rect.collidepoint(mouse_x,mouse_y)
 if button_clicked 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()
 
 #Clear 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 picture on the screen and switch to a new screen'''
 screen.fill(ai_settings.bg_color) # Set background color
 ship.blitme() # Drawing spacecraft
 aliens.draw(screen)
 # The elements in the round bullet group are drawn. If it is empty, it will not be executed
 for bullet in bullets.sprites():
 bullet.draw_bullet() # Draw bullets
 #Show score
 sb.show_score()
 #If the game is inactive, the Play button is displayed
 if not stats.game_active:
 play_button.draw_button()
 # Display the latest screen and wipe the old screen
 pygame.display.flip()
 # print('1')

def check_keydown_events(event,ai_settings,screen,ship,bullets):
 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 check_keyup_events(event,ship):
 if event.key == pygame.K_RIGHT:
 ship.moving_right = False
 elif event.key == pygame.K_LEFT:
 ship.moving_left = False

def update_bullets(ai_settings,screen,stats,sb,ship,aliens,bullets):
 '''Update bullet position and delete bullet'''
 bullets.update() # Each member of the bullet group executes self Update() operation
 for bullet in bullets.sprites():
 if bullet.rect.bottom <= 0: # Bullet out of bounds delete
  bullets.remove(bullet)
 check_bullet_alien_collisions(ai_settings,screen,stats,sb,ship,aliens,bullets)

def check_bullet_alien_collisions(ai_settings,screen,stats,sb,ship,aliens,bullets): 
 """In response to the collision between aliens and bullets"""
 #Delete bullets and aliens in collision
 collisions = pygame.sprite.groupcollide(bullets,aliens,True,True)
 
 if collisions:
 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 the existing bullets and create a new group of aliens to speed up the pace of the game
 bullets.empty()
 ai_settings.increase_speed()
 
 #Raise the level
 stats.level += 1
 sb.prep_level()
 
 create_fleet(ai_settings,screen,ship,aliens)

def update_ship(ship):
 ship.update()

def fire_bullet(ai_settings,screen,ship,bullets):
 # Create a bullet object and add it to the bullet group
 if len(bullets) < ai_settings.bullets_allowed: # Generated when the bullet is less than the allowable value
 new_bullet = Bullet(ai_settings, screen, ship)
 bullets.add(new_bullet)

def get_number_aliens_x(ai_settings,alien_width):
 """Calculate how many aliens can be accommodated in each 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_number_rows(ai_settings,ship_height,alien_height):
 """Calculate how many lines the screen can 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_aliens(ai_settings,screen,aliens,alien_number,row_number):
 """Create an alien and place it on 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):
 """Create alien groups"""
 #Create an alien and calculate how many aliens a row can hold
 #Alien spacing is alien width
 alien = Alien(ai_settings,screen)
 number_aliens_x = get_number_aliens_x(ai_settings,alien.rect.width)
 number_rows = get_number_rows(ai_settings,ship.rect.height,alien.rect.height)
 
 #Create first row
 for row_number in range(number_rows):
 for alien_number in range(number_aliens_x):
  #Create an alien and add it to the current line
  create_aliens(ai_settings,screen,aliens,alien_number,row_number)
 
def check_fleet_edges(ai_settings,aliens):
 """Take corresponding measures when aliens reach 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 of movement"""
 for alien in aliens.sprites():
 alien.rect.y += ai_settings.fleet_drop_speed
 ai_settings.fleet_direction *= -1

def ship_hit(ai_settings,stats,screen,sb,ship,aliens,bullets):
 """Responding to a spaceship hit by aliens"""
 if stats.ships_left > 0:
 #ship_left minus 1
 stats.ships_left -= 1
 
 #Update scoreboard
 sb.prep_ships()
 
 #Clear alien list and bullet list
 aliens.empty()
 bullets.empty()
 #Create a new group of aliens and put the spacecraft in the center of the low end 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,screen,sb,ship,aliens,bullets):
 """Check whether aliens have reached the low end of the screen"""
 screen_rect = screen.get_rect()
 for alien in aliens.sprites():
 if alien.rect.bottom >= screen_rect.bottom:
  #Deal with it like a ship was hit
  ship_hit(ai_settings,stats,screen,sb,ship,aliens,bullets)
  break

  
def update_aliens(ai_settings,stats,screen,sb,ship,aliens,bullets):
 """Update the location of all aliens in the alien crowd"""
 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,screen,sb,ship,aliens,bullets)
 #Check whether aliens have reached the low end of the screen
 check_aliens_bottom(ai_settings,stats,screen,sb,ship,aliens,bullets)

def check_high_score(stats,sb):
 """Check to see if there is a new record"""
 if stats.score > stats.high_score:
 stats.high_score = stats.score
 sb.prep_high_score() 

6. Game statistics, game_stats.py, code:

class GameStats():
 """Track game statistics"""
 def __init__(self,ai_settings):
 """Initialization statistics"""
 self.ai_settings = ai_settings
 self.reset_stats()
 #The game was inactive when it first started
 self.game_active = False
 #Under no circumstances should the highest score be reset
 self.high_score = 0
 self.level = 1
 
 def reset_stats(self):
 """Initializes statistics that may change during game operation"""
 self.ships_left = self.ai_settings.ship_limit
 self.score = 0

7. Score setting, scoreboard Py, code:

import pygame.font
from pygame.sprite import Group

from ship import Ship

class Scoreboard():
 """Class that displays score information"""
 
 def __init__(self, ai_settings, screen, stats):
 """Initialize the attributes involved in displaying scores"""
 self.screen =screen
 self.screen_rect = screen.get_rect()
 self.ai_settings = ai_settings
 self.stats = stats
 
 #Font settings used when displaying score information
 self.text_color = (30, 30, 30)
 self.font = pygame.font.SysFont(None, 48)
 
 #Ready to initialize score image and current maximum score
 self.prep_score()
 self.prep_high_score()
 self.prep_level()
 self.prep_ships()
 
 def prep_score(self):
 """Convert the score to 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 upper right corner
 self.score_rect = self.score_image.get_rect()
 self.score_rect.right = self.screen_rect.right - 20
 self.score_rect.top = 5
 
 def prep_high_score(self):
 """Converts the highest score to 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)
 
 #Place the highest score in the center of the screen
 self.high_score_rect = self.high_score_image.get_rect()
 self.high_score_rect.centerx = self.screen_rect.centerx
 self.high_score_rect.top = 5
 
 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 score in the upper right corner
 self.level_rect = self.score_image.get_rect()
 self.level_rect.right = self.screen_rect.right
 self.level_rect.top = self.score_rect.bottom 
 
 def prep_ships(self):
 """Show how many ships are left"""
 self.ships = Group()
 for ship_number in range(self.stats.ships_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):
 """Displays scores and grades on the 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)
 #Drawing spacecraft
 self.ships.draw(self.screen)

8. Settings Py, code:

class Settings():
 '''Store all settings in alien invasion'''

 def __init__(self):
 '''Initialization settings'''
 #screen setting
 self.screen_width = 1200
 self.screen_height = 600
 self.bg_color = (230,230,230) # Set background color gray
 
 #Spacecraft setup
 self.ship_limit = 3
 self.ship_image_path = 'images/ship.bmp' # Spacecraft picture path
 
 #Bullet setting
 self.bullet_width = 3
 self.bullet_height = 15
 self.bullet_color = 60,60,60
 self.bullets_allowed = 3  # Number of bullets allowed on the screen
 
 #Alien settings
 self.fleet_drop_speed = 10
 
 
 #What kind of speed to accelerate the pace of 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.bullet_speed_factor = 3
 self.alien_speed_factor = 1
 
 #fleet_ A direction of 1 means to move to the right, and a direction of - 1 means to move to the left
 self.fleet_direction = 1
 
 #scoring
 self.alien_points = 50
 
 def increase_speed(self):
 """Increase speed setting,Alien points"""
 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)
 print(self.alien_points)

9. Spacecraft settings, ship Py, code:

import pygame
from pygame.sprite import Sprite

class Ship(Sprite):
 '''All information of the spacecraft'''

 def __init__(self,ai_settings,screen):
 """Initialize the spacecraft and set its starting position"""
 super(Ship,self).__init__()
 self.screen=screen
 self.ai_settings = ai_settings

 # Load the ship picture and obtain the external rectangle
 self.image = pygame.image.load(self.ai_settings.ship_image_path) # Load picture
 self.image = pygame.transform.smoothscale(self.image,(40,60))
 self.rect = self.image.get_rect() # Get picture circumscribed rectangle
 self.screen_rect = screen.get_rect() #Get screen bounding rectangle

 # Put each new spacecraft in the center of the wooden bottom
 self.rect.centerx = self.screen_rect.centerx
 self.rect.bottom = self.screen_rect.bottom
 # Set to floating point type
 self.center = float(self.rect.centerx) # self.rect.centerx cannot set floating-point numbers. You can only set another variable for operation

 # Move flag
 self.moving_right = False
 self.moving_left = False

 def blitme(self):
 '''Draw the spaceship at the specified location'''
 self.screen.blit(self.image,self.rect)

 def update(self):
 # Move the ship to the right
 if self.moving_right and self.rect.right < self.screen_rect.right:
  self.center +=self.ai_settings.ship_speed_factor
 # Move the ship to the left
 if self.moving_left and self.rect.left > self.screen_rect.left:
  self.center -= self.ai_settings.ship_speed_factor

 self.rect.centerx = self.center

 def center_ship(self):
 """Center the ship on the screen"""
 self.center = self.screen_rect.centerx

Effect display:

Game resources: picture resources

ending

As the saying goes, a good memory is not as good as a bad pen. Practical operation is far easier for people to master technology than theory! Here the blogger recommends one for you Practical cases of enterprise Python project in 2020 Video tutorial, hope to help you learn Python, click receive You can get it for free

The text and pictures of this article come from the Internet and their own ideas. They are only for learning and communication. They do not have any commercial use. The copyright belongs to the original author. If you have any questions, please contact us in time for handling.