1, Install Pygame
Enter at the terminal:
pip install --user pygame
2, Start game project
(1) Create Pygame window and respond to user input
Create a file named alien_ The file of invasion.py is the main running file of the program.
import sys import pygame class AlienInvasion: def __init__(self): pygame.init() # Initialize the game and create game resources self.screen = pygame.display.set_mode((1200, 800)) # Set game screen size pygame.display.set_caption("Alien Invasion") # Set game name self.bg_color = (230, 230, 230) # Set background color def run_game(self): while True: for event in pygame.event.get(): # Monitor keyboard and mouse if event.type == pygame.QUIT: # Is the close key pressed sys.exit() # Exit the game self.screen.fill(self.bg_color) # Cycle through the screen each time pygame.display.flip() # Update screen if __name__ == '__main__': ai = AlienInvasion() ai.run_game()
(2) Create settings class
Create a file named settings.py to import new settings when new features are added to the game. Also put the color, size, etc. we set above into this file:
class Settings: def __init__(self): self.screen_width = 1200 self.screen_height = 800 self.bg_color = (230, 230, 230)
(3) Add ship image
Create a new Images folder and add the ship file ship.bmp to it.
class Ship: def __init__(self, ai_game): self.screen = ai_game.screen # Initialize spacecraft self.screen_rect = ai_game.screen.get_rect() # Set initial position self.image = pygame.image.load('Images/ship.bmp') # import images self.rect = self.image.get_rect() # Specify ship location self.rect.midbottom = self.screen_rect.midbottom # Put it in the center at the bottom of the screen def blitme(self): self.screen.blit(self.image, self.rect)
Then write it into the main function and click Run to see the spacecraft in the center of the screen:
(4) Mobile spacecraft
Make it move continuously: when pressed, trigger a flag bit to true. Supplementary points:
KEYDOWN: triggered when the user presses any key on the keyboard.
KEYUP: triggered when the user releases the key on the keyboard.
In check_ Add to event:
def _check_event(self): for event in pygame.event.get(): # Monitor keyboard and mouse if event.type == pygame.QUIT: # Is the close key pressed sys.exit() # Exit the game elif event.type == pygame.KEYDOWN: if event.key == pygame.K_RIGHT: self.ship.moving_right = True elif event.type == pygame.KEYUP: if event.key == pygame.K_RIGHT: self.ship.moving_right = False
The flag bit added is self.ship.moving_right, respond when the user presses the right button, set it to False when it is released, and add an update function to the class of the spacecraft:
def update(self): if self.moving_right: self.rect.x += 1
Similarly, we can set up, down, left and right buttons, and set them not to exceed the screen size:
def update(self): if self.moving_right and self.rect.right < self.screen_rect.right: self.rect.x += 1 elif self.moving_left and self.rect.left > 0: self.rect.x -= 1 elif self.moving_up: self.rect.y -= 1 elif self.moving_down: self.rect.y += 1
def _check_event(self): for event in pygame.event.get(): # Monitor keyboard and mouse if event.type == pygame.QUIT: # Is the close key pressed sys.exit() # Exit the game 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_UP: self.ship.moving_up = True elif event.key == pygame.K_DOWN: self.ship.moving_down = True 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.key == pygame.K_UP: self.ship.moving_up = False elif event.key == pygame.K_DOWN: self.ship.moving_down = False
You can also set the speed of the spaceship, and add in the settings:
#Spacecraft speed self.ship_speed = 1.5
After that, change 1 in the update speed to self.settings.ship_ Before replacing the speed, do the following:
(5) Press Q to exit the game
Add the following statement to the operation of pressing the key:
elif event.key == pygame.K_q: sys.exit()
(6) Full screen game
# display # self.screen = pygame.display.set_mode((self.settings.screen_width, self.settings.screen_height)) # Set game screen size 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
Mask the initial display, and then add the above three sentences.
(7) Add Bullet class
import pygame from pygame.sprite import Sprite class Bullet(Sprite) def __init__(self,ai_game): super().__init__() self.screen = ai_game.screen self.settings = ai_game.settings self.color = self.settings.bullet_color self.rect = pygame.Rect(0,0,self.settings.bullet_width,self.settings.screen_height) #Create a rectangle representing the bullet at (0, 0) and set the correct position self.rect.midtop = ai_game.ship.rect.midtop #Located in the middle and upper part of the spacecraft self.y = float(self.rect.y) def update(self): self.y -= self.settings.bullet_speed #Move the bullet up self.rect.y = self.y def draw_bullet(self): pygame.draw.rect(self.screen,self.color,self.rect) #Draw bullets
After that, create a group for storing bullets in the function:
This group is used to store all valid bullets in order to manage the bullets fired. It is an instance of the pyGame. Sprite. Group class. pygame.sprite.Group is similar to a list, but provides additional features to help develop games. In the main loop, this group is used to draw bullets on the screen and update the position of each bullet.
(8) Fire
When the space button is pressed, a bullet is created and fired. Write when pressed:
elif event.key == pygame.K_SPACE: self._fire_bullet()
Then define a new method:
def _fire_bullet(self): new_bullet = Bullet(self) self.bullets.add(new_bullet)
The method add () is similar to append (), but is written specifically for Pygame marshalling.
Finally, to display the bullet, we need to write in the update screen:
for bullet in self.bullets.sprites(): bullet.draw_bullet()
The method bullets.sprites() returns a list containing all the sprites in the grouped bullets. To draw and fire all bullets on the screen, traverse the sprites in the group bullets, and then call draw_bullet().
(9) Delete missing bullets
At present, the bullet will disappear at the top of the screen, but it does not mean that it has been deleted, because our screen does not contain them, they still exist. Their y-axis coordinates will get smaller and smaller. For the screen we built, the coordinates in the upper left corner are (0, 0), and the lower right corner is the width and height we set.
We need to delete the missing bullets, otherwise the game will do more and more unnecessary work, and the process will be slower and slower. When it reaches the top, the bullet's button value will be equal to 0.
New method:
def _delete_bullet(self): for bullet in self.bullets.copy(): if bullet.rect.bottom <= 0: self.bullets.remove(bullet)
When traversing a list using a for loop, python requires that the length of the list remain unchanged throughout the loop, so you need to make a copy. Use the method copy () to set the for loop, and delete the original bullet. Finally, run_game can be called.
(10) Limit the number of bullets
Add in setting:
self.bullets_allowed = 10
Limit the maximum number of bullets to 10. Add the following to the function generating bullets:
def _fire_bullet(self): if len(self.bullets) < self.settings.self.bullets_allowed: new_bullet = Bullet(self) self.bullets.add(new_bullet)
(11) Add aliens
Create the file alien.py. And write Alien classes to add Alien images.
import pygame from pygame.sprite import Sprite class Alien(Sprite): def __init__(self, ai_game): super.__init__() self.screen = ai_game.screen self.image = pygame.image.load('Images/alien.png') self.rect = self.image.get_rect() #Each alien was initially attached in the upper left corner of the screen self.rect.x = self.rect.width self.rect.y = self.rect.height #Store the exact horizontal position of aliens self.x = float(self.rect.x)
Back to alien_ Modification in invasion.py:
Add method:
def _creat_fleet(self): alien = Alien(self) self.aliens.add(alien)
Then add in the update screen:
Then you can see the appearance of aliens on the screen:
(12) Create a group of Aliens
In order to set the space and width of aliens, we calculate the space between aliens and then display it.
Modify the generated function to:
def _creat_fleet(self): alien = Alien(self) alien_width = alien.rect.width available_space_x = self.settings.screen_width - (2*alien_width) number_aliens_x = available_space_x // (2*alien_width) for alien_number in range(number_aliens_x): alien = Alien(self) alien.x = alien_width + 2*alien_width*alien_number alien.rect.x = alien.x self.aliens.add(alien)
After completing the work of rows, do the work of columns:
def _creat_fleet(self): alien = Alien(self) alien_width, alien_height = alien.rect.size # Calculation line available_space_x = self.settings.screen_width - (2 * alien_width) number_aliens_x = available_space_x // (2 * alien_width) # Calculation column 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._creat_alien(alien_number,row_number)
Finally, a display method is designed to input the calculated columns and rows into the method:
def _creat_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)
The last image displayed is as follows:
(13) Make aliens move
Add the alien movement speed setting in setting.py and alien.py
self.settings = ai_game.settings
Can be referenced. Then write alien movement:
def update(self): self.x += self.settings.alien_speed self.rect.x = self.x
Then put it in the main function and update it. After running this code, the alien will disappear on the right edge:
(14) Make aliens move down when they reach the edge
Setting to make aliens move down and then left after hitting the right edge of the screen.
We need to set the following variables:
Edge function detected:
def check_edges(self): screen_rect = self.screen.get_rect() if self.rect.right >= screen_rect.right or self.rect <= 0: return True
Finally, let's write another way to move down and change the direction of alien movement:
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
In this way, the function of aliens moving down can be realized.
(15) Collision detection
collisions = pygame.sprite.groupcollide(self.bullets, self.aliens, True, True)
The function sprite. Groupcollapse () compares the rect of each element in one group with the rect of each element in another group, and returns a dictionary in which each key is a bullet, and the associated value is the alien hit by the bullet. Set to True to delete, False to retain.
At this point, if you don't shoot aliens, you will go all the way down and finally disappear at the bottom. When a bullet hits an alien, both the alien and the bullet disappear.
所有评论(0)