Hướng dẫn python code for shooting game - code python cho game bắn súng

Hoạt động

Đúng

$ mkdir awesome_pygame_project
$ cd awesome_pygame_project

Xoay tàu vũ trụ bên phải

Bên trái

Xoay tàu vũ trụ bên trái

(venv) $ python -m pip install -r requirements.txt

Lên

(venv) $ python -m pygame.examples.aliens

Tăng tốc tàu vũ trụ về phía trước

Không gian

Bắn

 1initialize_pygame()
 2
 3while True:
 4    handle_input()
 5    process_game_logic()
 6    draw_game_elements()

Dòng 3 bắt đầu một vòng lặp, được gọi là vòng lặp trò chơi. Mỗi lần lặp của vòng lặp này tạo ra một khung của trò chơi và thường thực hiện các hoạt động sau:game loop. Each iteration of this loop generates a single frame of the game and usually performs the following operations:

1. Xử lý đầu vào: Đầu vào như các nút nhấn, chuyển động chuột và vị trí bộ điều khiển VR được thu thập và sau đó được xử lý. Tùy thuộc vào trò chơi, nó có thể khiến các đối tượng thay đổi vị trí của chúng, tạo các đối tượng mới, yêu cầu kết thúc trò chơi, v.v. Input like pressed buttons, mouse motion, and VR controllers position is gathered and then handled. Depending on the game, it can cause objects to change their position, create new objects, request the end of the game, and so on.

2. Trò chơi Logic: Đây là nơi mà hầu hết các cơ chế trò chơi được thực hiện. Ở đây, các quy tắc vật lý được áp dụng, va chạm được phát hiện và xử lý, trí tuệ nhân tạo thực hiện công việc của nó, v.v. Phần này cũng chịu trách nhiệm kiểm tra xem người chơi đã thắng hay thua trò chơi. This is where most of the game mechanics are implemented. Here, the rules of physics are applied, collisions are detected and handled, artificial intelligence does its job, and so on. This part is also responsible for checking if the player has won or lost the game.

3. Vẽ: Nếu trò chơi đã kết thúc, thì đây là nơi khung sẽ được vẽ trên màn hình. Nó sẽ bao gồm tất cả các mục hiện đang có trong trò chơi và có thể nhìn thấy người chơi. If the game hasn’t ended yet, then this is where the frame will be drawn on screen. It will include all the items that are currently in the game and are visible to the player.

Cấu trúc chung của một chương trình pygame không phức tạp, và có lẽ bạn có thể thoát khỏi việc đặt nó vào một vòng lặp cơ bản. Tuy nhiên, xem xét rằng bạn có thể mở rộng trò chơi tiểu hành tinh của mình trong tương lai, đó là một ý tưởng tốt để gói gọn tất cả các hoạt động này trong một lớp Python.

Tạo một lớp có nghĩa là bạn cần chọn một tên cho trò chơi của mình, nhưng các tiểu hành tinh đã được thực hiện. Làm thế nào về đá không gian đá?

Tạo một thư mục

def _handle_input(self):
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            quit()

def _handle_input(self):
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            quit()

def _handle_input(self):
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            quit()

 1import pygame
 2
 3class SpaceRocks:
 4    def __init__(self):
 5        self._init_pygame()
 6        self.screen = pygame.display.set_mode((800, 600))
 7
 8    def main_loop(self):
 9        while True:
10            self._handle_input()
11            self._process_game_logic()
12            self._draw()
13
14    def _init_pygame(self):
15        pygame.init()
16        pygame.display.set_caption("Space Rocks")
17
18    def _handle_input(self):
19        pass
20
21    def _process_game_logic(self):
22        pass
23
24    def _draw(self):
25        self.screen.fill((0, 0, 255))
26        pygame.display.flip()

Ở đây, những gì mà xảy ra trong mã, từng bước:

• Dòng 1 nhập mô -đun pygame để có quyền truy cập vào tất cả các tính năng tuyệt vời của nó. imports the Pygame module to get access to all its amazing features.

• Dòng 3 tạo ra lớp

  def _handle_input(self):
      for event in pygame.event.get():
          if event.type == pygame.QUIT:
              quit()
  

  6. creates the

  def _handle_input(self):
      for event in pygame.event.get():
          if event.type == pygame.QUIT:
              quit()
  

  6 class.

• Dòng 4 là hàm tạo của lớp

  def _handle_input(self):
      for event in pygame.event.get():
          if event.type == pygame.QUIT:
              quit()
  

  6 và nó là một nơi hoàn hảo để đặt bất kỳ phương pháp nào cần thiết để khởi tạo pygame. Việc khởi tạo pygame thực tế xảy ra trong

  def _handle_input(self):
      for event in pygame.event.get():
          if event.type == pygame.QUIT:
              quit()
  

  9. Bạn sẽ tìm hiểu thêm về phương pháp này trong một khoảnh khắc. is the constructor of the

  def _handle_input(self):
      for event in pygame.event.get():
          if event.type == pygame.QUIT:
              quit()
  

  6 class, and it’s a perfect place to put any methods required to initialize Pygame. The actual Pygame initialization happens in

  def _handle_input(self):
      for event in pygame.event.get():
          if event.type == pygame.QUIT:
              quit()
  

  9. You’ll learn more about this method in a moment.

• Dòng 6 tạo ra một bề mặt hiển thị. Hình ảnh trong pygame được thể hiện bằng các bề mặt. Dưới đây là một vài điều cần biết về chúng: creates a display surface. Images in Pygame are represented by surfaces. Here are a few things to know about them:

  • Bề mặt có thể được vẽ trên nhau, cho phép bạn tạo ra những cảnh phức tạp từ các hình ảnh đơn giản.

  • Có một bề mặt đặc biệt trong mỗi dự án pygame. Bề mặt đó đại diện cho màn hình và là hình ảnh cuối cùng sẽ được hiển thị cho người chơi. Tất cả các bề mặt khác phải được vẽ trên này tại một số điểm. Nếu không, họ đã thắng được hiển thị.

  • Để tạo bề mặt hiển thị, chương trình của bạn sử dụng

    def _handle_input(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT or (
                event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE
            ):
                quit()
    

    0. Đối số duy nhất bạn chuyển sang phương pháp này là kích thước của màn hình, được biểu thị bằng một bộ ba giá trị: chiều rộng và chiều cao. Trong trường hợp này, pygame sẽ tạo một màn hình có chiều rộng

    def _handle_input(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT or (
                event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE
            ):
                quit()
    

    1 pixel và chiều cao

    def _handle_input(self):
        for event in pygame.event.get():
            if event.type == pygame.QUIT or (
                event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE
            ):
                quit()
    

    2 pixel.

• Dòng 8 là vòng lặp trò chơi được thảo luận ở trên. Nó chứa ba bước giống nhau cho mỗi khung hình: is the game loop discussed above. It contains the same three steps for each frame:

  1. Dòng 10 chứa xử lý đầu vào. contains input handling.

  2. Dòng 11 chứa logic trò chơi. contains game logic.

  3. Dòng 12 chứa bản vẽ. contains drawing.

• Dòng 14 xác định một phương thức gọi là

  def _handle_input(self):
      for event in pygame.event.get():
          if event.type == pygame.QUIT:
              quit()
  

  9. Đây là nơi khởi tạo một lần của pygame xảy ra. Phương pháp làm hai điều: defines a method called

  def _handle_input(self):
      for event in pygame.event.get():
          if event.type == pygame.QUIT:
              quit()
  

  9. This is where a one-time initialization of Pygame happens. The method does two things:

  1. Dòng 15 gọi

     def _handle_input(self):
         for event in pygame.event.get():
             if event.type == pygame.QUIT or (
                 event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE
             ):
                 quit()
     

     4. Dòng mã duy nhất này chịu trách nhiệm thiết lập các tính năng tuyệt vời của pygame. Mỗi khi bạn làm việc với pygame, bạn nên gọi

     def _handle_input(self):
         for event in pygame.event.get():
             if event.type == pygame.QUIT or (
                 event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE
             ):
                 quit()
     

     4 khi bắt đầu chương trình để đảm bảo rằng khung sẽ hoạt động chính xác. calls

     def _handle_input(self):
         for event in pygame.event.get():
             if event.type == pygame.QUIT or (
                 event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE
             ):
                 quit()
     

     4. This single line of code is responsible for setting up the amazing features of Pygame. Every time you work with Pygame, you should call

     def _handle_input(self):
         for event in pygame.event.get():
             if event.type == pygame.QUIT or (
                 event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE
             ):
                 quit()
     

     4 at the beginning of your program to make sure that the framework will work correctly.

  2. Dòng 16 Đặt chú thích của chương trình pygame của bạn bằng

     def _handle_input(self):
         for event in pygame.event.get():
             if event.type == pygame.QUIT or (
                 event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE
             ):
                 quit()
     

     6. Trong trường hợp này, chú thích sẽ là tên của trò chơi của bạn:

     def _handle_input(self):
         for event in pygame.event.get():
             if event.type == pygame.QUIT or (
                 event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE
             ):
                 quit()
     

     7. sets the caption of your Pygame program using

     def _handle_input(self):
         for event in pygame.event.get():
             if event.type == pygame.QUIT or (
                 event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE
             ):
                 quit()
     

     6. In this case, the caption will be the name of your game:

     def _handle_input(self):
         for event in pygame.event.get():
             if event.type == pygame.QUIT or (
                 event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE
             ):
                 quit()
     

     7.

• Dòng 18 và 21 xác định

  def _handle_input(self):
      for event in pygame.event.get():
          if event.type == pygame.QUIT or (
              event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE
          ):
              quit()
  

  8 và

  def _handle_input(self):
      for event in pygame.event.get():
          if event.type == pygame.QUIT or (
              event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE
          ):
              quit()
  

  9. Bây giờ chúng trống rỗng, nhưng trong các phần sau, bạn sẽ thêm một số mã để làm cho trò chơi của bạn thú vị hơn. define

  def _handle_input(self):
      for event in pygame.event.get():
          if event.type == pygame.QUIT or (
              event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE
          ):
              quit()
  

  8 and

  def _handle_input(self):
      for event in pygame.event.get():
          if event.type == pygame.QUIT or (
              event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE
          ):
              quit()
  

  9. They’re empty for now, but in the following sections you’ll add some code to make your game more interesting.

• Dòng 24 Xác định

  (venv) $ python -m pip install -r requirements.txt
  

  00. Sẽ rất có ý nghĩa khi tạo một mẫu cho trò chơi của bạn mà không hiển thị bất cứ thứ gì trên màn hình, vì vậy phương thức này đã có một số mã. Nó đã gọi mọi khung hình để vẽ nội dung của màn hình và nó thực hiện điều đó trong hai bước: defines

  (venv) $ python -m pip install -r requirements.txt
  

  00. It wouldn’t make much sense to create a template for your game without displaying anything on the screen, so this method already has some code. It’s called every frame to draw the content of the screen, and it does that in two steps:

  1. Dòng 25 lấp đầy màn hình bằng một màu bằng

     (venv) $ python -m pip install -r requirements.txt
     

     01. Phương pháp có một bộ xử lý với ba giá trị, đại diện cho ba màu cơ bản: đỏ, xanh lá cây và xanh dương. Mỗi giá trị màu nằm trong khoảng từ

     (venv) $ python -m pip install -r requirements.txt
     

     02 và

     (venv) $ python -m pip install -r requirements.txt
     

     03, biểu thị cường độ của nó. Trong ví dụ này, một tuple là (0, 0, 255) có nghĩa là màu sẽ chỉ bao gồm màu xanh lam, không có dấu vết màu đỏ hoặc màu xanh lá cây. fills the screen with a color using

     (venv) $ python -m pip install -r requirements.txt
     

     01. The method takes a tuple with three values, representing three base colors: red, green, and blue. Each color value ranges between

     (venv) $ python -m pip install -r requirements.txt
     

     02 and

     (venv) $ python -m pip install -r requirements.txt
     

     03, representing its intensity. In this example, a tuple of (0, 0, 255) means that the color will consist only of blue, with no traces of red or green.

  2. Dòng 26 Cập nhật nội dung của màn hình bằng

     (venv) $ python -m pip install -r requirements.txt
     

     04. Vì trò chơi của bạn cuối cùng sẽ hiển thị các đối tượng di chuyển, bạn sẽ gọi phương thức này mỗi khung hình để cập nhật màn hình. Do đó, bạn cần lấp đầy màn hình của mình bằng màu sắc mỗi khung hình, vì phương thức sẽ xóa các nội dung được tạo trong khung trước. updates the content of the screen using

     (venv) $ python -m pip install -r requirements.txt
     

     04. Because your game will eventually display moving objects, you’ll call this method every frame to update the display. Because of this, you need to fill your screen with color every frame, as the method will clear the contents generated during the previous frame.

Điều này có vẻ như rất nhiều bước bổ sung, nhưng bây giờ mã của bạn được cấu trúc độc đáo và có các phương pháp với tên mô tả. Lần tới khi bạn cần thay đổi một cái gì đó liên quan đến bản vẽ, bạn sẽ biết sử dụng

(venv) $ python -m pip install -r requirements.txt

def _handle_input(self):
    for event in pygame.event.get():
        if event.type == pygame.QUIT or (
            event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE
        ):
            quit()

Tiếp theo, tạo tệp

(venv) $ python -m pip install -r requirements.txt

def _handle_input(self):
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            quit()

(venv) $ python -m pip install -r requirements.txt

from game import SpaceRocks

if __name__ == "__main__":
    space_rocks = SpaceRocks()
    space_rocks.main_loop()

Cấu trúc của dự án của bạn bây giờ trông như thế này:

awesome_pygame_project/
|
├── space_rocks/
|   ├── __main__.py
|   └── game.py
|
└── requirements.txt

Đi trước và chạy trò chơi:

(venv) $ python space_rocks

Bạn sẽ thấy một cửa sổ có nền màu xanh:

Xin chúc mừng, bạn vừa tạo ra một dự án pygame! Tuy nhiên, không có điều kiện thoát nào tại thời điểm này, vì vậy bạn vẫn phải sử dụng Ctrl+C trong dòng lệnh để thoát khỏi nó. Đó là lý do tại sao bạn sẽ tìm hiểu về xử lý đầu vào tiếp theo.Ctrl+C in the command line to quit it. That’s why you’ll learn about input handling next.

Hành vi nâng cao

Bạn đã sử dụng các bề mặt, nhưng Pygame cũng cung cấp một lớp khác,

(venv) $ python -m pip install -r requirements.txt

Một hạn chế là một đối tượng trò chơi không chỉ là một sprite. Nó chứa dữ liệu bổ sung, như hướng và vận tốc của nó. Nó cũng cần các hành vi tiên tiến hơn, như bắn đạn hoặc phát âm thanh. Hầu hết các thông tin và hành vi bổ sung này được cung cấp bởi lớp

(venv) $ python -m pip install -r requirements.txt

Một vấn đề khác là pygame rút ra các sprites bắt đầu từ góc trên bên trái. Trong trò chơi của bạn, có thể dễ dàng hơn để lưu trữ vị trí trung tâm của một đối tượng cho mục đích di chuyển và xoay nó. Trong trường hợp đó, bạn sẽ phải thực hiện một cách để biến vị trí đó thành một góc trên cùng theo yêu cầu của Pygame.

Cuối cùng, mặc dù pygame đã có các phương thức phát hiện sự chồng chéo giữa các hình ảnh, nhưng chúng có thể không tốt để phát hiện các va chạm giữa các đối tượng. Một tàu vũ trụ có thể xoay hoặc một tiểu hành tinh có thể đã giành được toàn bộ hình ảnh, nhưng thay vào đó là khu vực tròn trong đó. Trong trường hợp đó, vụ va chạm chỉ nên tính đến khu vực tròn đó, không phải toàn bộ bề mặt của sprite. Nếu không, bạn có thể nhận được kết quả không chính xác:

Trong ví dụ này, các Sprites va chạm, nhưng các đối tượng trò chơi don lồng.

Đây thực sự là nơi lớp

(venv) $ python -m pip install -r requirements.txt

(venv) $ python -m pip install -r requirements.txt

Với những vấn đề này, nó nhanh chóng trở nên rõ ràng rằng lớp Pygame

(venv) $ python -m pip install -r requirements.txt

Lớp GameObject

Trong phần này, bạn sẽ giới thiệu lớp

(venv) $ python -m pip install -r requirements.txt

Lớp

(venv) $ python -m pip install -r requirements.txt

• (venv) $ python -m pip install -r requirements.txt
  

  43: Một điểm ở giữa đối tượng trên màn hình 2D A point in the center of the object on the 2D screen

• (venv) $ python -m pip install -r requirements.txt
  

  44: Một hình ảnh được sử dụng để hiển thị đối tượng An image used to display the object

• (venv) $ python -m pip install -r requirements.txt
  

  45: Một giá trị đại diện cho vùng va chạm xung quanh vị trí đối tượng A value representing the collision zone around the object’s position

• (venv) $ python -m pip install -r requirements.txt
  

  46: Một giá trị được sử dụng cho chuyển động A value used for movement

Ở đây, một đại diện đồ họa của đối tượng trò chơi:

(venv) $ python -m pip install -r requirements.txt

(venv) $ python -m pip install -r requirements.txt

(venv) $ python -m pip install -r requirements.txt

(venv) $ python -m pip install -r requirements.txt

(venv) $ python -m pip install -r requirements.txt

Các vectơ tương tự như bộ dữ liệu. Trong một thế giới 2D (giống như thế giới trong trò chơi của bạn), các vectơ được thể hiện bằng hai giá trị biểu thị tọa độ x và y. Các tọa độ này có thể chỉ ra một vị trí, nhưng chúng cũng có thể đại diện cho chuyển động hoặc gia tốc theo một hướng nhất định. Các vectơ có thể được thêm, trừ hoặc thậm chí nhân để nhanh chóng cập nhật vị trí của một sprite. Bạn có thể đọc thêm về các vectơ trong các vectơ trong không gian 2 chiều.

Do các vectơ hữu ích như thế nào trong các trò chơi, pygame đã có một lớp cho chúng:

(venv) $ python -m pip install -r requirements.txt

(venv) $ python -m pip install -r requirements.txt

Trong thư mục

def _handle_input(self):
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            quit()

(venv) $ python -m pip install -r requirements.txt

(venv) $ python -m pip install -r requirements.txt

(venv) $ python -m pip install -r requirements.txt

Ở đây, một sự cố:

• Dòng 1 nhập lớp

  (venv) $ python -m pip install -r requirements.txt
  

  52 được đề cập trước đó. imports the

  (venv) $ python -m pip install -r requirements.txt
  

  52 class mentioned earlier.

• Dòng 3 tạo ra lớp

  (venv) $ python -m pip install -r requirements.txt
  

  41, mà bạn sẽ sử dụng để đại diện cho tất cả các đối tượng trò chơi trong Space Rocks. creates the

  (venv) $ python -m pip install -r requirements.txt
  

  41 class, which you’ll use to represent all game objects in Space Rocks.

• Dòng 4 là hàm tạo của lớp

  (venv) $ python -m pip install -r requirements.txt
  

  41. Nó cần ba đối số: is the constructor of the

  (venv) $ python -m pip install -r requirements.txt
  

  41 class. It needs three arguments:

  1. (venv) $ python -m pip install -r requirements.txt
     

     43: trung tâm của đối tượng The center of the object

  2. (venv) $ python -m pip install -r requirements.txt
     

     44: Hình ảnh được sử dụng để vẽ đối tượng này The image used to draw this object

  3. (venv) $ python -m pip install -r requirements.txt
     

     46: Cập nhật

     (venv) $ python -m pip install -r requirements.txt
     

     43 của đối tượng mỗi khung hình Updates the

     (venv) $ python -m pip install -r requirements.txt
     

     43 of the object each frame

• Các dòng 5 và 8 đảm bảo rằng

  (venv) $ python -m pip install -r requirements.txt
  

  43 và

  (venv) $ python -m pip install -r requirements.txt
  

  46 sẽ luôn được biểu diễn dưới dạng vectơ cho các tính toán trong tương lai, ngay cả khi các bộ đếm được truyền cho hàm tạo. Bạn làm điều đó bằng cách gọi hàm xây dựng

  (venv) $ python -m pip install -r requirements.txt
  

  66. Nếu nó đưa ra một tuple, thì nó sẽ tạo ra một vectơ mới từ nó. Nếu nó cung cấp một vectơ, thì nó sẽ tạo ra một bản sao của vectơ đó. ensure that the

  (venv) $ python -m pip install -r requirements.txt
  

  43 and the

  (venv) $ python -m pip install -r requirements.txt
  

  46 will always be represented as vectors for future calculations, even if tuples are passed to the constructor. You do that by calling the

  (venv) $ python -m pip install -r requirements.txt
  

  66 constructor. If it’s given a tuple, then it will create a new vector out of it. If it’s given a vector, then it will create a copy of that vector.

• Dòng 7 tính toán

  (venv) $ python -m pip install -r requirements.txt
  

  45 là một nửa chiều rộng của hình ảnh

  (venv) $ python -m pip install -r requirements.txt
  

  44. Trong chương trình này, trò chơi đối tượng Sprites sẽ luôn là hình vuông với nền tảng trong suốt. Bạn cũng có thể sử dụng chiều cao của hình ảnh, nó sẽ không có gì khác biệt. calculates the

  (venv) $ python -m pip install -r requirements.txt
  

  45 as half the width of the

  (venv) $ python -m pip install -r requirements.txt
  

  44 image. In this program, game object sprites will always be squares with transparent backgrounds. You could also use the height of the image—it would make no difference.

• Dòng 10 Xác định

  (venv) $ python -m pip install -r requirements.txt
  

  69, sẽ vẽ đối tượng trên

  (venv) $ python -m pip install -r requirements.txt
  

  44 trên bề mặt được truyền như một đối số. defines

  (venv) $ python -m pip install -r requirements.txt
  

  69, which will draw the object’s

  (venv) $ python -m pip install -r requirements.txt
  

  44 on the surface passed as an argument.

• Dòng 11 tính toán vị trí chính xác để làm mờ hình ảnh. Quá trình được mô tả chi tiết hơn dưới đây. Lưu ý rằng hàm tạo

  (venv) $ python -m pip install -r requirements.txt
  

  66 nhận được một số duy nhất thay vì một tuple. Trong trường hợp đó, nó sẽ sử dụng số đó cho cả hai giá trị. Vì vậy,

  (venv) $ python -m pip install -r requirements.txt
  

  72 là tương đương với

  (venv) $ python -m pip install -r requirements.txt
  

  73. calculates the correct position for blitting the image. The process is described in more detail below. Notice that the

  (venv) $ python -m pip install -r requirements.txt
  

  66 constructor receives a single number instead of a tuple. In that case, it will use that number for both values. So

  (venv) $ python -m pip install -r requirements.txt
  

  72 is the equivalent of

  (venv) $ python -m pip install -r requirements.txt
  

  73.

• Dòng 12 sử dụng vị trí blit mới được tính toán để đặt đối tượng của bạn Sprite vào một vị trí chính xác trên bề mặt đã cho. uses the newly calculated blit position to put your object’s sprite in a correct place on the given surface.

• Dòng 14 xác định

  (venv) $ python -m pip install -r requirements.txt
  

  74. Nó sẽ cập nhật vị trí của đối tượng trò chơi. defines

  (venv) $ python -m pip install -r requirements.txt
  

  74. It will update the position of the game object.

• Dòng 15 thêm vận tốc vào vị trí và kết quả là nhận được một vectơ vị trí được cập nhật. Pygame làm cho các vectơ thao túng đơn giản, cho phép bạn thêm chúng như số. adds the velocity to the position and gets an updated position vector as a result. Pygame makes manipulating vectors straightforward, allowing you to add them like numbers.

• Dòng 17 Xác định phương pháp

  (venv) $ python -m pip install -r requirements.txt
  

  75, sẽ được sử dụng để phát hiện các va chạm. defines the

  (venv) $ python -m pip install -r requirements.txt
  

  75 method, that will be used to detect collisions.

• Dòng 18 tính toán khoảng cách giữa hai đối tượng bằng cách sử dụng

  (venv) $ python -m pip install -r requirements.txt
  

  76. calculates the distance between two objects by using

  (venv) $ python -m pip install -r requirements.txt
  

  76.

• Dòng 19 kiểm tra xem khoảng cách đó có nhỏ hơn tổng của các đối tượng bán kính không. Nếu vậy, các đối tượng va chạm. checks if that distance is smaller than the sum of the objects’ radiuses. If so, the objects collide.

Xin lưu ý rằng các đối tượng trò chơi của bạn có vị trí trung tâm, nhưng

(venv) $ python -m pip install -r requirements.txt

Quá trình đó xảy ra trong

(venv) $ python -m pip install -r requirements.txt

Bạn có thể kiểm tra điều này bằng cách thêm một tàu vũ trụ và một tiểu hành tinh duy nhất. Đầu tiên, sao chép hình ảnh tàu vũ trụ và tiểu hành tinh thành

(venv) $ python -m pip install -r requirements.txt

Cấu trúc của dự án của bạn sẽ trông như thế này:

(venv) $ python -m pip install -r requirements.txt

Bây giờ sửa đổi tệp

(venv) $ python -m pip install -r requirements.txt

(venv) $ python -m pip install -r requirements.txt

Cả hai đối tượng được đặt ở giữa màn hình, sử dụng tọa độ

(venv) $ python -m pip install -r requirements.txt

def _handle_input(self):
    for event in pygame.event.get():
        if event.type == pygame.QUIT or (
            event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE
        ):
            quit()

(venv) $ python -m pip install -r requirements.txt

Chạy chương trình này và bạn sẽ thấy một tiểu hành tinh di chuyển sang phải và một con tàu vũ trụ đứng yên ở giữa màn hình:

Bạn cũng có thể kiểm tra

(venv) $ python -m pip install -r requirements.txt

(venv) $ python -m pip install -r requirements.txt

(venv) $ python -m pip install -r requirements.txt

Trong dòng lệnh, bạn sẽ nhận thấy cách phương thức ban đầu in

(venv) $ python -m pip install -r requirements.txt

(venv) $ python -m pip install -r requirements.txt

Kiểm soát tốc độ

Bây giờ bạn có các đối tượng di chuyển trên màn hình, đó là thời gian để suy nghĩ về cách trò chơi của bạn sẽ hoạt động trên các máy khác nhau với các bộ xử lý khác nhau. Đôi khi, nó sẽ chạy nhanh hơn, và đôi khi nó sẽ chạy chậm hơn.

Do đó, các tiểu hành tinh (và các viên đạn sớm) sẽ di chuyển với tốc độ khác nhau, làm cho trò chơi đôi khi dễ dàng hơn và đôi khi khó hơn. Đó không phải là thứ mà bạn muốn. Những gì bạn muốn là trò chơi của bạn chạy với số lượng khung cố định mỗi giây (FPS).frames per second (FPS).

May mắn thay, pygame có thể chăm sóc điều đó. Nó cung cấp một lớp

(venv) $ python -m pip install -r requirements.txt

(venv) $ python -m pip install -r requirements.txt

Đi trước và cập nhật

(venv) $ python -m pip install -r requirements.txt

(venv) $ python -m pip install -r requirements.txt

Nếu bạn chạy trò chơi của mình ngay bây giờ, thì tiểu hành tinh có thể di chuyển với tốc độ khác so với ban đầu. Tuy nhiên, bây giờ bạn có thể chắc chắn rằng tốc độ này sẽ vẫn giữ nguyên, ngay cả trên các máy tính có bộ xử lý siêu nhanh. Đó là vì trò chơi của bạn sẽ luôn chạy ở tốc độ 60 khung hình / giây. Bạn cũng có thể thử nghiệm với các giá trị khác nhau được truyền đến

(venv) $ python -m pip install -r requirements.txt

Bạn chỉ học cách hiển thị và di chuyển các đối tượng trên màn hình. Bây giờ bạn có thể thêm một số logic nâng cao hơn vào trò chơi của bạn.

Tạo một lớp học

Hình ảnh của tàu vũ trụ đã có trong thư mục

(venv) $ python -m pip install -r requirements.txt

(venv) $ python -m pip install -r requirements.txt

(venv) $ python -m pip install -r requirements.txt

Bây giờ bạn có thể tạo, trong cùng một tệp, lớp

(venv) $ python -m pip install -r requirements.txt

(venv) $ python -m pip install -r requirements.txt

(venv) $ python -m pip install -r requirements.txt

Nó không làm rất nhiều điều tại thời điểm này, nó chỉ gọi hàm tạo

(venv) $ python -m pip install -r requirements.txt

Để sử dụng lớp mới này, trước tiên bạn cần nhập nó. Cập nhật nhập khẩu trong tệp

(venv) $ python -m pip install -r requirements.txt

(venv) $ python -m pygame.examples.aliens

Bạn có thể nhận thấy rằng nhập khẩu ban đầu của lớp

(venv) $ python -m pip install -r requirements.txt

(venv) $ python -m pip install -r requirements.txt

Điều này có nghĩa là tiểu hành tinh từ bước trước sẽ ngừng hoạt động, nhưng đó không phải là vấn đề lớn. Bạn sẽ sớm thêm một lớp thích hợp đại diện cho các tiểu hành tinh. Cho đến lúc đó, bạn nên tập trung vào tàu vũ trụ.

Đi trước và chỉnh sửa lớp

def _handle_input(self):
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            quit()

(venv) $ python -m pygame.examples.aliens

Hai điều đã xảy ra:

1. Trong dòng 7, bạn đã thay thế lớp cơ sở

   (venv) $ python -m pip install -r requirements.txt
   

   41 bằng lớp

   (venv) $ python -m pip install -r requirements.txt
   

   95 chuyên dụng.

2. Bạn đã xóa tất cả các tài liệu tham khảo

   (venv) $ python -m pygame.examples.aliens
   

   04 từ

   (venv) $ python -m pygame.examples.aliens
   

   05,

   def _handle_input(self):
       for event in pygame.event.get():
           if event.type == pygame.QUIT or (
               event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE
           ):
               quit()
   

   9 và

   (venv) $ python -m pip install -r requirements.txt
   

   00.

Nếu bạn chạy trò chơi của mình ngay bây giờ, thì bạn sẽ thấy một con tàu vũ trụ ở giữa màn hình:

Những thay đổi đã không thêm bất kỳ hành vi mới nào, nhưng bây giờ bạn có một lớp mà bạn có thể mở rộng.

Xoay tàu vũ trụ

Theo mặc định, tàu vũ trụ đang hướng lên, hướng về phía trên màn hình. Người chơi của bạn sẽ có thể xoay nó trái và phải. May mắn thay, pygame có các phương pháp tích hợp để xoay sprites, nhưng có một vấn đề nhỏ.

Nói chung, xoay hình ảnh là một quá trình phức tạp đòi hỏi các pixel tính toán lại trong hình ảnh mới. Trong quá trình tính toán lại đó, thông tin về các pixel ban đầu bị mất và hình ảnh bị biến dạng một chút. Với mỗi vòng quay, biến dạng ngày càng trở nên rõ ràng hơn.

Do đó, có thể là một ý tưởng tốt hơn để lưu trữ sprite ban đầu trong lớp

(venv) $ python -m pip install -r requirements.txt

Đối với cách tiếp cận đó để làm việc, bạn sẽ cần phải biết góc mà tàu vũ trụ được xoay. Điều này có thể được thực hiện theo hai cách:

1. Giữ góc như một giá trị điểm nổi và cập nhật nó trong quá trình xoay.
2. Giữ vectơ biểu thị hướng mà tàu vũ trụ đang đối mặt và tính toán góc bằng vectơ đó.

Cả hai cách đều tốt, nhưng bạn cần chọn một trước khi tiến hành. Vì vị trí và vận tốc của tàu vũ trụ đã là vectơ, nên sử dụng một vectơ khác để thể hiện hướng. Điều đó sẽ làm cho nó đơn giản hơn khi thêm các vectơ và cập nhật vị trí sau. May mắn thay, lớp

(venv) $ python -m pip install -r requirements.txt

Đầu tiên, tạo một vectơ không đổi gọi là

(venv) $ python -m pip install -r requirements.txt

(venv) $ python -m pip install -r requirements.txt

Hãy nhớ rằng trục y Pygame từ trên từ trên xuống dưới, do đó, một giá trị âm thực sự chỉ lên trên:

Tiếp theo, sửa đổi lớp

(venv) $ python -m pip install -r requirements.txt

(venv) $ python -m pygame.examples.aliens

Giá trị

(venv) $ python -m pygame.examples.aliens

Tiếp theo, thêm một hướng vào lớp

(venv) $ python -m pip install -r requirements.txt

(venv) $ python -m pygame.examples.aliens

Vectơ hướng ban đầu sẽ giống như vectơ

(venv) $ python -m pip install -r requirements.txt

Tiếp theo, bạn cần tạo một phương thức mới trong lớp

(venv) $ python -m pip install -r requirements.txt

(venv) $ python -m pygame.examples.aliens

(venv) $ python -m pygame.examples.aliens

Phương pháp này sẽ thay đổi hướng bằng cách xoay nó theo chiều kim đồng hồ hoặc ngược chiều kim đồng hồ. Phương pháp

(venv) $ python -m pygame.examples.aliens

(venv) $ python -m pip install -r requirements.txt

Tất cả những gì còn lại là để cập nhật bản vẽ của

(venv) $ python -m pip install -r requirements.txt

(venv) $ python -m pygame.examples.aliens

(venv) $ python -m pygame.examples.aliens

Sau đó, bạn có thể ghi đè phương thức

(venv) $ python -m pip install -r requirements.txt

(venv) $ python -m pip install -r requirements.txt

(venv) $ python -m pygame.examples.aliens

Ở đây, một sự cố từng bước:

• Dòng 2 sử dụng phương pháp

  (venv) $ python -m pygame.examples.aliens
  

  24 của lớp

  (venv) $ python -m pip install -r requirements.txt
  

  52 để tính toán góc mà một vectơ cần được xoay để chỉ theo cùng một hướng với vectơ khác. Điều này làm cho nó không đau khi dịch hướng tàu vũ trụ vào góc quay theo độ. uses the

  (venv) $ python -m pygame.examples.aliens
  

  24 method of the

  (venv) $ python -m pip install -r requirements.txt
  

  52 class to calculate the angle by which one vector needs to be rotated in order to point in the same direction as the other vector. This makes it painless to translate the spaceship’s direction into the rotation angle in degrees.

• Dòng 3 xoay sprite bằng

  (venv) $ python -m pygame.examples.aliens
  

  26. Nó lấy hình ảnh gốc, góc mà nó nên được xoay và tỷ lệ nên được áp dụng cho sprite. Trong trường hợp này, bạn không muốn thay đổi kích thước, vì vậy bạn giữ thang đo là

  (venv) $ python -m pygame.examples.aliens
  

  27. rotates the sprite using

  (venv) $ python -m pygame.examples.aliens
  

  26. It takes the original image, the angle by which it should be rotated, and the scale that should be applied to the sprite. In this case, you don’t want to change the size, so you keep the scale as

  (venv) $ python -m pygame.examples.aliens
  

  27.

• Các dòng 4 và 5 tính toán lại vị trí blit, sử dụng kích thước

  (venv) $ python -m pygame.examples.aliens
  

  28. Quá trình được mô tả dưới đây. recalculate the blit position, using the size of

  (venv) $ python -m pygame.examples.aliens
  

  28. The process is described below.

• Dòng 5 chứa hoạt động

  (venv) $ python -m pygame.examples.aliens
  

  29. Đó là một điều khác mà bạn có thể làm với các vectơ trong pygame. Khi bạn nhân một vectơ với một số, tất cả các tọa độ của nó được nhân với số đó. Do đó, nhân với

  (venv) $ python -m pygame.examples.aliens
  

  30 sẽ trả về một vectơ với một nửa chiều dài của bản gốc. contains the

  (venv) $ python -m pygame.examples.aliens
  

  29 operation. That’s another thing you can do with vectors in Pygame. When you multiply a vector by a number, all its coordinates are multiplied by that number. As a result, multiplying by

  (venv) $ python -m pygame.examples.aliens
  

  30 will return a vector with half the length of the original.

• Dòng 6 sử dụng vị trí Blit mới được tính toán để đặt hình ảnh lên màn hình. uses the newly calculated blit position to put the image on the screen.

Lưu ý rằng

(venv) $ python -m pygame.examples.aliens

Kích thước của hình ảnh mới có thể khác biệt đáng kể so với hình ảnh gốc. Đó là lý do tại sao

(venv) $ python -m pip install -r requirements.txt

(venv) $ python -m pygame.examples.aliens

(venv) $ python -m pip install -r requirements.txt

Bây giờ bạn cần thêm xử lý đầu vào. Tuy nhiên, vòng lặp sự kiện đã giành chiến thắng chính xác ở đây. Các sự kiện được ghi lại khi chúng xảy ra, nhưng bạn cần liên tục kiểm tra xem phím có được nhấn không. Rốt cuộc, tàu vũ trụ sẽ tăng tốc miễn là bạn ấn lên, và nó sẽ quay liên tục khi bạn nhấn bên trái hoặc phải.Up, and it should rotate constantly when you press Left or Right.

Bạn có thể tạo một lá cờ cho mỗi phím, đặt nó khi nhấn phím và đặt lại khi nó được phát hành. Tuy nhiên, có một cách tốt hơn.

Trạng thái hiện tại của bàn phím được lưu trữ trong pygame và có thể thu được bằng cách sử dụng

(venv) $ python -m pygame.examples.aliens

(venv) $ python -m pip install -r requirements.txt

(venv) $ python -m pip install -r requirements.txt

(venv) $ python -m pip install -r requirements.txt

Biết được điều này, bạn có thể chỉnh sửa tệp

(venv) $ python -m pip install -r requirements.txt

def _handle_input(self):
    for event in pygame.event.get():
        if event.type == pygame.QUIT or (
            event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE
        ):
            quit()

def _handle_input(self):
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            quit()

(venv) $ python -m pygame.examples.aliens

(venv) $ python -m pygame.examples.aliens

(venv) $ python -m pygame.examples.aliens

Bây giờ tàu vũ trụ của bạn sẽ xoay trái và phải khi bạn nhấn các phím mũi tên:

Như bạn có thể thấy, tàu vũ trụ quay chính xác. Tuy nhiên, nó vẫn không di chuyển. Bạn sẽ sửa chữa điều đó tiếp theo.

Tăng tốc tàu vũ trụ

Trong phần này, bạn sẽ thêm gia tốc vào tàu vũ trụ của mình. Hãy nhớ rằng, theo cơ chế trò chơi của các tiểu hành tinh, tàu vũ trụ chỉ có thể tiến về phía trước.

Trong trò chơi của bạn, khi bạn nhấn lên, tốc độ tàu vũ trụ sẽ tăng lên. Khi bạn phát hành khóa, tàu vũ trụ sẽ duy trì tốc độ hiện tại của nó nhưng không còn tăng tốc nữa. Vì vậy, để làm chậm nó, bạn sẽ phải xoay tàu vũ trụ và ấn lại.Up, the spaceship’s speed will increase. When you release the key, the spaceship will maintain its current speed but should no longer accelerate. So in order to slow it down, you’ll have to turn the spaceship around and press Up again.

Quá trình này có vẻ hơi phức tạp, vì vậy trước khi bạn tiến hành, đây là một bản tóm tắt ngắn:

• (venv) $ python -m pygame.examples.aliens
  

  44 là một vector mô tả nơi tàu vũ trụ đang chỉ. is a vector describing where the spaceship is pointing.

• (venv) $ python -m pip install -r requirements.txt
  

  46 là một vectơ mô tả nơi tàu vũ trụ di chuyển từng khung hình. is a vector describing where the spaceship moves each frame.

• (venv) $ python -m pygame.examples.aliens
  

  46 là một số không đổi mô tả mức độ nhanh chóng của tàu vũ trụ có thể tăng tốc từng khung hình. is a constant number describing how fast the spaceship can speed up each frame.

Bạn có thể tính toán thay đổi vận tốc bằng cách nhân vectơ

(venv) $ python -m pygame.examples.aliens

(venv) $ python -m pygame.examples.aliens

(venv) $ python -m pip install -r requirements.txt

Biết được điều này, bạn có thể thêm giá trị

(venv) $ python -m pygame.examples.aliens

(venv) $ python -m pip install -r requirements.txt

(venv) $ python -m pygame.examples.aliens

Sau đó, tạo

(venv) $ python -m pygame.examples.aliens

(venv) $ python -m pip install -r requirements.txt

(venv) $ python -m pygame.examples.aliens

Bây giờ bạn có thể thêm xử lý đầu vào vào

def _handle_input(self):
    for event in pygame.event.get():
        if event.type == pygame.QUIT or (
            event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE
        ):
            quit()

def _handle_input(self):
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            quit()

(venv) $ python -m pygame.examples.aliens

(venv) $ python -m pygame.examples.aliens

 1initialize_pygame()
 2
 3while True:
 4    handle_input()
 5    process_game_logic()
 6    draw_game_elements()

Đi trước và kiểm tra điều này. Chạy trò chơi của bạn, xoay tàu vũ trụ và bật động cơ:

Tàu vũ trụ của bạn bây giờ có thể di chuyển và xoay! Tuy nhiên, khi nó đến cạnh của màn hình, nó chỉ tiếp tục di chuyển. Đó là một cái gì đó bạn nên sửa!

Bao bọc các đối tượng xung quanh màn hình

Một yếu tố quan trọng của trò chơi này là đảm bảo rằng các đối tượng trò chơi không rời khỏi màn hình. Bạn có thể để chúng bật ra khỏi cạnh hoặc làm cho chúng xuất hiện lại ở cạnh đối diện của màn hình. Trong dự án này, bạn sẽ thực hiện cái sau.

Bắt đầu bằng cách nhập lớp

(venv) $ python -m pip install -r requirements.txt

(venv) $ python -m pip install -r requirements.txt

 1initialize_pygame()
 2
 3while True:
 4    handle_input()
 5    process_game_logic()
 6    draw_game_elements()

Tiếp theo, tạo

(venv) $ python -m pygame.examples.aliens

 1initialize_pygame()
 2
 3while True:
 4    handle_input()
 5    process_game_logic()
 6    draw_game_elements()

Bằng cách sử dụng toán tử modulo trên dòng 4, bạn đảm bảo rằng vị trí không bao giờ rời khỏi khu vực của bề mặt đã cho. Trong trò chơi của bạn, bề mặt đó sẽ là màn hình.

Nhập phương thức mới này trong

(venv) $ python -m pip install -r requirements.txt

 1initialize_pygame()
 2
 3while True:
 4    handle_input()
 5    process_game_logic()
 6    draw_game_elements()

Bây giờ bạn có thể cập nhật

(venv) $ python -m pip install -r requirements.txt

(venv) $ python -m pip install -r requirements.txt

 1initialize_pygame()
 2
 3while True:
 4    handle_input()
 5    process_game_logic()
 6    draw_game_elements()

Lưu ý rằng việc sử dụng

(venv) $ python -m pygame.examples.aliens

(venv) $ python -m pygame.examples.aliens

def _handle_input(self):
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            quit()

 1initialize_pygame()
 2
 3while True:
 4    handle_input()
 5    process_game_logic()
 6    draw_game_elements()

Bây giờ tàu vũ trụ của bạn xuất hiện lại ở phía bên kia của màn hình.

Logic của việc di chuyển và xoay tàu vũ trụ đã sẵn sàng. Nhưng con tàu vẫn cô đơn trong không gian trống. Thời gian để thêm một số tiểu hành tinh!

Tạo một lớp học

Tương tự như

(venv) $ python -m pip install -r requirements.txt

(venv) $ python -m pygame.examples.aliens

(venv) $ python -m pip install -r requirements.txt

(venv) $ python -m pip install -r requirements.txt

 1initialize_pygame()
 2
 3while True:
 4    handle_input()
 5    process_game_logic()
 6    draw_game_elements()

Giống như trước đây, bạn bắt đầu bằng cách gọi hàm xây dựng

(venv) $ python -m pip install -r requirements.txt

Tiếp theo, nhập lớp mới trong

(venv) $ python -m pip install -r requirements.txt

 1initialize_pygame()
 2
 3while True:
 4    handle_input()
 5    process_game_logic()
 6    draw_game_elements()

Cuối cùng, chỉnh sửa hàm tạo của lớp

def _handle_input(self):
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            quit()

 1initialize_pygame()
 2
 3while True:
 4    handle_input()
 5    process_game_logic()
 6    draw_game_elements()

Bây giờ bạn có nhiều đối tượng trò chơi hơn, sẽ là một ý tưởng tốt để tạo ra một phương pháp trợ giúp trong lớp

def _handle_input(self):
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            quit()

Gọi phương thức này

(venv) $ python -m pygame.examples.aliens

 1initialize_pygame()
 2
 3while True:
 4    handle_input()
 5    process_game_logic()
 6    draw_game_elements()

Bây giờ sử dụng nó để di chuyển tất cả các đối tượng trò chơi trong một vòng lặp duy nhất bằng cách chỉnh sửa

def _handle_input(self):
    for event in pygame.event.get():
        if event.type == pygame.QUIT or (
            event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE
        ):
            quit()

 1import pygame
 2
 3class SpaceRocks:
 4    def __init__(self):
 5        self._init_pygame()
 6        self.screen = pygame.display.set_mode((800, 600))
 7
 8    def main_loop(self):
 9        while True:
10            self._handle_input()
11            self._process_game_logic()
12            self._draw()
13
14    def _init_pygame(self):
15        pygame.init()
16        pygame.display.set_caption("Space Rocks")
17
18    def _handle_input(self):
19        pass
20
21    def _process_game_logic(self):
22        pass
23
24    def _draw(self):
25        self.screen.fill((0, 0, 255))
26        pygame.display.flip()

Điều tương tự cũng xảy ra với

(venv) $ python -m pip install -r requirements.txt

 1import pygame
 2
 3class SpaceRocks:
 4    def __init__(self):
 5        self._init_pygame()
 6        self.screen = pygame.display.set_mode((800, 600))
 7
 8    def main_loop(self):
 9        while True:
10            self._handle_input()
11            self._process_game_logic()
12            self._draw()
13
14    def _init_pygame(self):
15        pygame.init()
16        pygame.display.set_caption("Space Rocks")
17
18    def _handle_input(self):
19        pass
20
21    def _process_game_logic(self):
22        pass
23
24    def _draw(self):
25        self.screen.fill((0, 0, 255))
26        pygame.display.flip()

Chạy trò chơi của bạn ngay bây giờ và bạn sẽ thấy một màn hình với các tiểu hành tinh:

Thật không may, tất cả các tiểu hành tinh được chất đống ở một góc của màn hình.

Chà, đó là loại mong đợi, vì tất cả các tiểu hành tinh được tạo ra với vị trí

(venv) $ python -m pip install -r requirements.txt

Ngẫu nhiên vị trí

Để tạo một vị trí ngẫu nhiên, bạn sẽ phải thêm một số nhập vào tệp

(venv) $ python -m pip install -r requirements.txt

 1import pygame
 2
 3class SpaceRocks:
 4    def __init__(self):
 5        self._init_pygame()
 6        self.screen = pygame.display.set_mode((800, 600))
 7
 8    def main_loop(self):
 9        while True:
10            self._handle_input()
11            self._process_game_logic()
12            self._draw()
13
14    def _init_pygame(self):
15        pygame.init()
16        pygame.display.set_caption("Space Rocks")
17
18    def _handle_input(self):
19        pass
20
21    def _process_game_logic(self):
22        pass
23
24    def _draw(self):
25        self.screen.fill((0, 0, 255))
26        pygame.display.flip()

Sau đó, tạo một phương thức gọi là

(venv) $ python -m pygame.examples.aliens

 1import pygame
 2
 3class SpaceRocks:
 4    def __init__(self):
 5        self._init_pygame()
 6        self.screen = pygame.display.set_mode((800, 600))
 7
 8    def main_loop(self):
 9        while True:
10            self._handle_input()
11            self._process_game_logic()
12            self._draw()
13
14    def _init_pygame(self):
15        pygame.init()
16        pygame.display.set_caption("Space Rocks")
17
18    def _handle_input(self):
19        pass
20
21    def _process_game_logic(self):
22        pass
23
24    def _draw(self):
25        self.screen.fill((0, 0, 255))
26        pygame.display.flip()

Điều này sẽ tạo ra một tập hợp tọa độ ngẫu nhiên trên một bề mặt nhất định và trả về kết quả dưới dạng một ví dụ

(venv) $ python -m pip install -r requirements.txt

Tiếp theo, nhập phương thức này vào tệp

(venv) $ python -m pip install -r requirements.txt

 1import pygame
 2
 3class SpaceRocks:
 4    def __init__(self):
 5        self._init_pygame()
 6        self.screen = pygame.display.set_mode((800, 600))
 7
 8    def main_loop(self):
 9        while True:
10            self._handle_input()
11            self._process_game_logic()
12            self._draw()
13
14    def _init_pygame(self):
15        pygame.init()
16        pygame.display.set_caption("Space Rocks")
17
18    def _handle_input(self):
19        pass
20
21    def _process_game_logic(self):
22        pass
23
24    def _draw(self):
25        self.screen.fill((0, 0, 255))
26        pygame.display.flip()

Bây giờ sử dụng

(venv) $ python -m pygame.examples.aliens

def _handle_input(self):
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            quit()

 1import pygame
 2
 3class SpaceRocks:
 4    def __init__(self):
 5        self._init_pygame()
 6        self.screen = pygame.display.set_mode((800, 600))
 7
 8    def main_loop(self):
 9        while True:
10            self._handle_input()
11            self._process_game_logic()
12            self._draw()
13
14    def _init_pygame(self):
15        pygame.init()
16        pygame.display.set_caption("Space Rocks")
17
18    def _handle_input(self):
19        pass
20
21    def _process_game_logic(self):
22        pass
23
24    def _draw(self):
25        self.screen.fill((0, 0, 255))
26        pygame.display.flip()

Bây giờ khi bạn chạy trò chơi, bạn sẽ thấy một bản phân phối ngẫu nhiên, ngẫu nhiên của các tiểu hành tinh trên màn hình:

Điều này có vẻ tốt hơn nhiều, nhưng có một vấn đề nhỏ: các tiểu hành tinh được tạo ra trong cùng khu vực với tàu vũ trụ. Sau khi bạn thêm các va chạm, điều này sẽ khiến người chơi thua ngay sau khi bắt đầu trò chơi. Điều đó sẽ rất không công bằng!

Một giải pháp cho vấn đề này là kiểm tra xem vị trí có quá gần với tàu vũ trụ không, và nếu vậy, hãy tạo một vị trí mới cho đến khi tìm thấy vị trí hợp lệ.

Bắt đầu bằng cách tạo một liên tục đại diện cho một khu vực phải trống. Giá trị của

(venv) $ python -m pygame.examples.aliens

 1import pygame
 2
 3class SpaceRocks:
 4    def __init__(self):
 5        self._init_pygame()
 6        self.screen = pygame.display.set_mode((800, 600))
 7
 8    def main_loop(self):
 9        while True:
10            self._handle_input()
11            self._process_game_logic()
12            self._draw()
13
14    def _init_pygame(self):
15        pygame.init()
16        pygame.display.set_caption("Space Rocks")
17
18    def _handle_input(self):
19        pass
20
21    def _process_game_logic(self):
22        pass
23
24    def _draw(self):
25        self.screen.fill((0, 0, 255))
26        pygame.display.flip()

Bây giờ bạn có thể sửa đổi hàm tạo của lớp

def _handle_input(self):
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            quit()

 1import pygame
 2
 3class SpaceRocks:
 4    def __init__(self):
 5        self._init_pygame()
 6        self.screen = pygame.display.set_mode((800, 600))
 7
 8    def main_loop(self):
 9        while True:
10            self._handle_input()
11            self._process_game_logic()
12            self._draw()
13
14    def _init_pygame(self):
15        pygame.init()
16        pygame.display.set_caption("Space Rocks")
17
18    def _handle_input(self):
19        pass
20
21    def _process_game_logic(self):
22        pass
23
24    def _draw(self):
25        self.screen.fill((0, 0, 255))
26        pygame.display.flip()

Trong một vòng lặp, mã của bạn kiểm tra xem vị trí của một tiểu hành tinh lớn hơn khoảng cách tiểu hành tinh tối thiểu. Nếu không, thì vòng lặp chạy lại cho đến khi tìm thấy vị trí như vậy.

Chạy lại chương trình và không có tiểu hành tinh nào chồng chéo với tàu vũ trụ:

Bạn có thể chạy trò chơi nhiều lần để đảm bảo rằng mỗi lần có một số không gian trống xung quanh tàu vũ trụ.

Di chuyển các tiểu hành tinh

Hiện tại, chương trình của bạn cho thấy sáu tiểu hành tinh ở các vị trí ngẫu nhiên và bạn đã sẵn sàng để thêm gia vị một chút bằng cách di chuyển chúng! Tương tự như vị trí, vận tốc của một tiểu hành tinh cũng phải là ngẫu nhiên, không chỉ theo hướng, mà còn cả giá trị.

Bắt đầu bằng cách tạo một phương thức gọi là

(venv) $ python -m pygame.examples.aliens

(venv) $ python -m pip install -r requirements.txt

 1import pygame
 2
 3class SpaceRocks:
 4    def __init__(self):
 5        self._init_pygame()
 6        self.screen = pygame.display.set_mode((800, 600))
 7
 8    def main_loop(self):
 9        while True:
10            self._handle_input()
11            self._process_game_logic()
12            self._draw()
13
14    def _init_pygame(self):
15        pygame.init()
16        pygame.display.set_caption("Space Rocks")
17
18    def _handle_input(self):
19        pass
20
21    def _process_game_logic(self):
22        pass
23
24    def _draw(self):
25        self.screen.fill((0, 0, 255))
26        pygame.display.flip()

Phương pháp này sẽ tạo ra một giá trị ngẫu nhiên giữa

(venv) $ python -m pygame.examples.aliens

(venv) $ python -m pygame.examples.aliens

Bởi vì vận tốc tiểu hành tinh nên là ngẫu nhiên cho dù nó được đặt ở đâu, hãy để sử dụng phương pháp này trực tiếp trong lớp

(venv) $ python -m pygame.examples.aliens

(venv) $ python -m pip install -r requirements.txt

 1import pygame
 2
 3class SpaceRocks:
 4    def __init__(self):
 5        self._init_pygame()
 6        self.screen = pygame.display.set_mode((800, 600))
 7
 8    def main_loop(self):
 9        while True:
10            self._handle_input()
11            self._process_game_logic()
12            self._draw()
13
14    def _init_pygame(self):
15        pygame.init()
16        pygame.display.set_caption("Space Rocks")
17
18    def _handle_input(self):
19        pass
20
21    def _process_game_logic(self):
22        pass
23
24    def _draw(self):
25        self.screen.fill((0, 0, 255))
26        pygame.display.flip()

Lưu ý rằng bạn đã đặt một vị trí ngẫu nhiên của bạn ở một nơi và vận tốc ngẫu nhiên của bạn ở một nơi khác. Điều đó bởi vì vị trí chỉ nên ngẫu nhiên cho sáu tiểu hành tinh mà bạn bắt đầu, do đó, nó được đặt trong tệp

(venv) $ python -m pip install -r requirements.txt

(venv) $ python -m pygame.examples.aliens

Sau đó sử dụng phương thức mới trong hàm tạo của lớp

(venv) $ python -m pygame.examples.aliens

from game import SpaceRocks

if __name__ == "__main__":
    space_rocks = SpaceRocks()
    space_rocks.main_loop()

Lưu ý rằng phương pháp sử dụng giá trị tối thiểu là

(venv) $ python -m pygame.examples.aliens

Chạy lại trò chơi của bạn để thấy các tiểu hành tinh di chuyển:

Bạn cũng có thể di chuyển tàu vũ trụ xung quanh màn hình. Thật không may, khi nó gặp một tiểu hành tinh, không có gì xảy ra. Nó thời gian để thêm một số va chạm.

Va chạm với tàu vũ trụ

Một phần rất quan trọng của trò chơi này là khả năng tàu vũ trụ của bạn bị phá hủy bởi một vụ va chạm tiểu hành tinh. Bạn có thể kiểm tra các va chạm bằng cách sử dụng

(venv) $ python -m pygame.examples.aliens

Chỉnh sửa phương thức

def _handle_input(self):
    for event in pygame.event.get():
        if event.type == pygame.QUIT or (
            event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE
        ):
            quit()

def _handle_input(self):
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            quit()

from game import SpaceRocks

if __name__ == "__main__":
    space_rocks = SpaceRocks()
    space_rocks.main_loop()

Nếu bất kỳ tiểu hành tinh nào va chạm với tàu vũ trụ, thì tàu vũ trụ sẽ bị phá hủy. Trong trò chơi này, bạn sẽ đại diện cho điều này bằng cách đặt

(venv) $ python -m pygame.examples.aliens

 1initialize_pygame()
 2
 3while True:
 4    handle_input()
 5    process_game_logic()
 6    draw_game_elements()

Lưu ý rằng cũng có một tấm séc cho

(venv) $ python -m pygame.examples.aliens

 1initialize_pygame()
 2
 3while True:
 4    handle_input()
 5    process_game_logic()
 6    draw_game_elements()

Bây giờ, tàu vũ trụ có thể có giá trị

 1initialize_pygame()
 2
 3while True:
 4    handle_input()
 5    process_game_logic()
 6    draw_game_elements()

(venv) $ python -m pygame.examples.aliens

def _handle_input(self):
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            quit()

from game import SpaceRocks

if __name__ == "__main__":
    space_rocks = SpaceRocks()
    space_rocks.main_loop()

Điều tương tự cũng xảy ra đối với việc xử lý đầu vào:

from game import SpaceRocks

if __name__ == "__main__":
    space_rocks = SpaceRocks()
    space_rocks.main_loop()

Bạn có thể chạy trò chơi của mình ngay bây giờ và thấy rằng tàu vũ trụ biến mất sau khi va chạm với một tiểu hành tinh:

Tàu vũ trụ của bạn bây giờ có thể bay xung quanh và bị phá hủy khi nó va chạm với các tiểu hành tinh. Bạn đã sẵn sàng để làm cho các tiểu hành tinh có thể bị phá hủy.

Tạo một lớp học

Bắt đầu với việc thêm một hình ảnh của một viên đạn vào

(venv) $ python -m pip install -r requirements.txt

Cấu trúc của dự án của bạn sẽ trông như thế này:

from game import SpaceRocks

if __name__ == "__main__":
    space_rocks = SpaceRocks()
    space_rocks.main_loop()

Sau đó, chỉnh sửa tệp

(venv) $ python -m pip install -r requirements.txt

 1initialize_pygame()
 2
 3while True:
 4    handle_input()
 5    process_game_logic()
 6    draw_game_elements()

(venv) $ python -m pip install -r requirements.txt

from game import SpaceRocks

if __name__ == "__main__":
    space_rocks = SpaceRocks()
    space_rocks.main_loop()

Giống như trước đây, điều này sẽ chỉ gọi hàm xây dựng

(venv) $ python -m pip install -r requirements.txt

Tiếp theo, bạn nên thêm một cách để theo dõi các viên đạn, tương tự như những gì bạn đã làm cho các tiểu hành tinh. Chỉnh sửa hàm tạo của lớp

def _handle_input(self):
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            quit()

(venv) $ python -m pip install -r requirements.txt

from game import SpaceRocks

if __name__ == "__main__":
    space_rocks = SpaceRocks()
    space_rocks.main_loop()

Đạn nên được xử lý giống như các đối tượng trò chơi khác, vì vậy hãy chỉnh sửa phương pháp

 1initialize_pygame()
 2
 3while True:
 4    handle_input()
 5    process_game_logic()
 6    draw_game_elements()

def _handle_input(self):
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            quit()

from game import SpaceRocks

if __name__ == "__main__":
    space_rocks = SpaceRocks()
    space_rocks.main_loop()

Danh sách các viên đạn là có, nhưng bây giờ nó trống rỗng. Bạn có thể sửa chữa điều đó.

Chụp một viên đạn

Có một vấn đề nhỏ với bắn súng. Đạn được lưu trữ trong đối tượng trò chơi chính, được đại diện bởi lớp

def _handle_input(self):
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            quit()

(venv) $ python -m pip install -r requirements.txt

def _handle_input(self):
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            quit()

Để sửa lỗi này, bạn có thể thêm chức năng gọi lại vào lớp

(venv) $ python -m pip install -r requirements.txt

def _handle_input(self):
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            quit()

 1initialize_pygame()
 2
 3while True:
 4    handle_input()
 5    process_game_logic()
 6    draw_game_elements()

Bắt đầu bằng cách thêm một cuộc gọi lại vào hàm tạo của lớp

(venv) $ python -m pip install -r requirements.txt

(venv) $ python -m pip install -r requirements.txt

from game import SpaceRocks

if __name__ == "__main__":
    space_rocks = SpaceRocks()
    space_rocks.main_loop()

Bạn cũng sẽ cần giá trị của tốc độ của viên đạn:

from game import SpaceRocks

if __name__ == "__main__":
    space_rocks = SpaceRocks()
    space_rocks.main_loop()

Tiếp theo, tạo một phương thức gọi là

 1initialize_pygame()
 2
 3while True:
 4    handle_input()
 5    process_game_logic()
 6    draw_game_elements()

(venv) $ python -m pip install -r requirements.txt

awesome_pygame_project/
|
├── space_rocks/
|   ├── __main__.py
|   └── game.py
|
└── requirements.txt

Bạn bắt đầu bằng cách tính toán vận tốc của viên đạn. Viên đạn luôn được bắn về phía trước, vì vậy bạn sử dụng hướng của tàu vũ trụ nhân với tốc độ của viên đạn. Bởi vì tàu vũ trụ không nhất thiết phải đứng yên, bạn thêm vận tốc của nó vào vận tốc của viên đạn. Bằng cách đó, bạn có thể tạo những viên đạn tốc độ cao nếu tàu vũ trụ đang di chuyển rất nhanh.

Sau đó, bạn tạo một thể hiện của lớp

 1initialize_pygame()
 2
 3while True:
 4    handle_input()
 5    process_game_logic()
 6    draw_game_elements()

Bây giờ thêm cuộc gọi lại vào tàu vũ trụ khi nó tạo ra. Đạn được lưu trữ dưới dạng danh sách, và điều duy nhất mà cuộc gọi lại phải làm là thêm các mục mới vào danh sách đó. Do đó, phương pháp

 1initialize_pygame()
 2
 3while True:
 4    handle_input()
 5    process_game_logic()
 6    draw_game_elements()

def _handle_input(self):
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            quit()

(venv) $ python -m pip install -r requirements.txt

awesome_pygame_project/
|
├── space_rocks/
|   ├── __main__.py
|   └── game.py
|
└── requirements.txt

Điều cuối cùng bạn cần thêm là xử lý đầu vào. Bullet chỉ nên được tạo ra khi không gian nhấn, vì vậy bạn có thể sử dụng vòng lặp sự kiện. Hằng số cho không gian là

 1initialize_pygame()
 2
 3while True:
 4    handle_input()
 5    process_game_logic()
 6    draw_game_elements()

 1initialize_pygame()
 2
 3while True:
 4    handle_input()
 5    process_game_logic()
 6    draw_game_elements()

Sửa đổi phương thức

def _handle_input(self):
    for event in pygame.event.get():
        if event.type == pygame.QUIT or (
            event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE
        ):
            quit()

def _handle_input(self):
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            quit()

awesome_pygame_project/
|
├── space_rocks/
|   ├── __main__.py
|   └── game.py
|
└── requirements.txt

Lưu ý rằng việc xử lý đầu vào mới cũng kiểm tra xem tàu ​​vũ trụ có tồn tại không. Nếu không, bạn có thể gặp lỗi khi cố gắng gọi

 1initialize_pygame()
 2
 3while True:
 4    handle_input()
 5    process_game_logic()
 6    draw_game_elements()

 1initialize_pygame()
 2
 3while True:
 4    handle_input()
 5    process_game_logic()
 6    draw_game_elements()

Chạy trò chơi của bạn ngay bây giờ và bắn một số viên đạn:

Tàu vũ trụ của bạn cuối cùng có thể bắn! Tuy nhiên, những viên đạn không rời khỏi màn hình, có thể là một vấn đề.

Gói đạn

Hiện tại, tất cả các đối tượng trò chơi được quấn quanh màn hình. Điều đó bao gồm đạn. Tuy nhiên, vì gói này, màn hình nhanh chóng chứa đầy những viên đạn bay theo mọi hướng. Điều đó có thể làm cho trò chơi hơi quá dễ dàng!

Bạn có thể giải quyết vấn đề này bằng cách vô hiệu hóa chỉ gói cho đạn. Ghi đè

(venv) $ python -m pip install -r requirements.txt

 1initialize_pygame()
 2
 3while True:
 4    handle_input()
 5    process_game_logic()
 6    draw_game_elements()

(venv) $ python -m pip install -r requirements.txt

awesome_pygame_project/
|
├── space_rocks/
|   ├── __main__.py
|   └── game.py
|
└── requirements.txt

Bằng cách đó, những viên đạn đã giành được bao quanh màn hình. Tuy nhiên, họ cũng giành chiến thắng bị phá hủy. Thay vào đó, họ sẽ tiếp tục bay vào vực thẳm vô hạn của vũ trụ. Ngay sau đó, danh sách các viên đạn của bạn sẽ chứa hàng ngàn yếu tố và tất cả chúng sẽ được xử lý trong mỗi khung hình, dẫn đến sự suy giảm hiệu suất của trò chơi của bạn.

Để tránh tình huống đó, trò chơi của bạn sẽ loại bỏ các viên đạn ngay khi chúng rời khỏi màn hình. Cập nhật phương thức

def _handle_input(self):
    for event in pygame.event.get():
        if event.type == pygame.QUIT or (
            event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE
        ):
            quit()

def _handle_input(self):
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            quit()

(venv) $ python -m pip install -r requirements.txt

awesome_pygame_project/
|
├── space_rocks/
|   ├── __main__.py
|   └── game.py
|
└── requirements.txt

Lưu ý rằng thay vì sử dụng danh sách ban đầu,

 1initialize_pygame()
 2
 3while True:
 4    handle_input()
 5    process_game_logic()
 6    draw_game_elements()

 1initialize_pygame()
 2
 3while True:
 4    handle_input()
 5    process_game_logic()
 6    draw_game_elements()

Các bề mặt trong pygame có phương pháp

 1initialize_pygame()
 2
 3while True:
 4    handle_input()
 5    process_game_logic()
 6    draw_game_elements()

 1initialize_pygame()
 2
 3while True:
 4    handle_input()
 5    process_game_logic()
 6    draw_game_elements()

(venv) $ python -m pip install -r requirements.txt

(venv) $ python -m pip install -r requirements.txt

Va chạm với các tiểu hành tinh

Một yếu tố quan trọng trong viên đạn của bạn vẫn còn thiếu: khả năng phá hủy các tiểu hành tinh! Bạn sẽ sửa nó trong phần này.

Cập nhật phương thức

def _handle_input(self):
    for event in pygame.event.get():
        if event.type == pygame.QUIT or (
            event.type == pygame.KEYDOWN and event.key == pygame.K_ESCAPE
        ):
            quit()

def _handle_input(self):
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            quit()

awesome_pygame_project/
|
├── space_rocks/
|   ├── __main__.py
|   └── game.py
|
└── requirements.txt

Bây giờ, bất cứ khi nào một vụ va chạm được phát hiện giữa một viên đạn và tiểu hành tinh, cả hai sẽ bị loại khỏi trò chơi. Lưu ý rằng, giống như trước đây trong Vòng đạn, bạn không sử dụng danh sách ban đầu ở đây. Thay vào đó, bạn tạo các bản sao bằng

 1initialize_pygame()
 2
 3while True:
 4    handle_input()
 5    process_game_logic()
 6    draw_game_elements()

Nếu bạn chạy trò chơi của mình ngay bây giờ và có mục tiêu tốt khi chụp, thì bạn sẽ có thể phá hủy một số tiểu hành tinh:

Tàu vũ trụ của bạn cuối cùng có thể tự bảo vệ mình! Tuy nhiên, chỉ có sáu mục tiêu lớn trong trò chơi. Tiếp theo, bạn sẽ làm cho nó khó khăn hơn một chút.