programming python

Trò chơi rắn trăn

Rắn là một trò chơi cực kỳ phổ biến, chủ yếu được nhớ đến từ điện thoại di động thời những năm 1990. Đối với nhiều người, đó là trò chơi duy nhất trên điện thoại của họ vào thời điểm đó. Ở dạng cơ bản nhất, đây là một trò chơi cực kỳ đơn giản, nhưng vẫn mang tính giải trí kỳ lạ. Đây cũng là một trò chơi tuyệt vời để tìm hiểu những kiến thức cơ bản về cách tạo trò chơi từ

Trong hướng dẫn này, chúng ta sẽ triển khai dạng Snake cơ bản nhất trong pygame

Tổng quan và yêu cầu

Chúng tôi sẽ sử dụng IDE web Replit để tạo phiên bản Snake của chúng tôi

Hãy suy nghĩ một chút về những gì chúng ta cần làm. Rắn ở dạng cơ bản là một loạt các khối tượng trưng cho một con rắn di chuyển xung quanh lưới, với người chơi điều khiển hướng. Nó cũng có các quy tắc đơn giản – khi con rắn chạm vào các cạnh của màn hình, nó sẽ chết. Nếu con rắn vượt qua chính nó, nó cũng chết. Nếu con rắn ăn một số thức ăn [một loại khối khác], nó sẽ tăng thêm 1 khối. Thức ăn sau đó xuất hiện lại ở một vị trí ngẫu nhiên khác trên màn hình

Một vài thành phần chúng ta sẽ cần xây dựng là

Một cách để vẽ các khối và di chuyển chúng trên màn hình
Một cách để nhận chỉ đạo từ người chơi đến con rắn
Một cách để xác định xem con rắn đã đi ra khỏi giới hạn của màn hình
Một cách để xác định xem con rắn đã vượt qua chính nó [hoặc cắn chính nó, như một phép loại suy khác]
Một cách để đặt thức ăn ngẫu nhiên trên màn hình
Một cách để xác định xem con rắn đã ăn hay chạm vào thức ăn chưa
Một cách để nuôi rắn

Đó là rất nhiều để suy nghĩ về. Hãy bắt đầu và tạo một dự án trong Replit

Tạo một dự án mới

Chuyển đến Replit và tạo một bản thay thế mới. Chọn Python làm ngôn ngữ của bạn. Bây giờ, đặt tên thay thế này, chẳng hạn như "snake-pygame"

Sau khi repl khởi động xong, bạn sẽ thấy tệp

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

1. Đây là nơi chúng ta sẽ bắt đầu mã hóa

Bắt đầu với Pygame

Một khung trò chơi thường được sử dụng trong Python là pygame. Nó có chức năng vẽ các hình dạng và hình ảnh lên màn hình, nhận đầu vào của người dùng, phát âm thanh, v.v. Chúng tôi sẽ sử dụng một số chức năng cơ bản khi xây dựng trò chơi này để xem nó hoạt động như thế nào

Chúng tôi có thể nhập nó vào dự án của mình bằng cách thêm dòng sau vào tệp

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

1 của chúng tôi

import pygame

Để bắt đầu khung pygame, chúng ta cần thêm một số mã khởi tạo

pygame.init[]
bounds = [300,300]
window = pygame.display.set_mode[bounds]
pygame.display.set_caption["Snake"]

Dòng 1 của mã này khởi động hệ thống pygame, bằng cách khởi tạo các mô-đun của nó [ví dụ: mã phông chữ, âm thanh hoặc đồ họa]. Dòng 2 tạo một bộ dữ liệu mới có tên là

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

3. Bộ dữ liệu này chứa các kích thước của cửa sổ mà chúng ta sẽ chạy trò chơi con rắn của mình trong đó. Dòng 3 tạo một cửa sổ mới để chúng tôi hiển thị trò chơi của mình trong. Dòng 4 cung cấp cho cửa sổ chú thích hoặc tiêu đề. Đây có thể là bất cứ điều gì bạn muốn gọi trò chơi

Nếu bạn chạy dự án, sử dụng nút "Chạy >" ở giữa trên cùng của phần thay thế, bạn sẽ thấy một cửa sổ trống nhỏ xuất hiện. Điều đó có nghĩa là mọi thứ được khởi tạo và hoạt động cho đến nay

Tạo lớp rắn

Bây giờ chúng ta đã có khung cơ bản, hãy tạo một lớp để mô hình con rắn của chúng ta. Lớp này sẽ có các nhiệm vụ sau

Theo dõi vị trí của con rắn
Theo dõi chiều dài của con rắn
Cho phép con rắn phát triển
Kiểm tra xung đột với ranh giới cửa sổ
Kiểm tra xem con rắn đã tự vượt qua ['cắn'] chưa
Theo dõi hướng con rắn đang di chuyển

Hãy bắt đầu bằng cách tạo một tệp mới có tên là

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

4. Thêm đoạn mã sau

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

Lớp đầu tiên trong tệp này là một phép liệt kê, đây là một cách hay để nhóm một tập hợp các hằng số liên quan lại với nhau. Chúng tôi sử dụng điều này để xác định hướng cho phép mà con rắn có thể di chuyển và làm cho mã kiểm tra và thay đổi hướng dễ đọc và thay đổi, so với việc chỉ sử dụng số hoặc chuỗi để xác định hướng

Sau đó, chúng tôi định nghĩa chính lớp

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

5. Một vài dòng đầu tiên đang thiết lập một số biến – điều này không thực sự cần thiết trong Python, nhưng nó giúp theo dõi các biến hoặc thuộc tính trong lớp của chúng ta dễ dàng hơn

Sau đó, chúng ta có phương thức khởi tạo trên dòng bắt đầu bằng

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

6. Khi chúng tôi tạo một thể hiện của lớp

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

5, chúng tôi chuyển vào

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

8, đây phải là một số nguyên có kích thước của mỗi khối tạo nên lưới của chúng tôi. Điều này được sử dụng cho kích thước của từng đoạn của con rắn, cũng như để định vị và di chuyển con rắn trên bảng. Chúng tôi cũng chuyển vào

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

3, là một bộ số nguyên có chiều rộng và chiều cao của khu vực có thể phát [cùng kích thước với khu vực màn hình]. Điều này là để chúng tôi có thể kiểm tra xem con rắn đã di chuyển ra khỏi giới hạn chưa. Trong phương thức khởi tạo, chúng tôi gán các đầu vào khởi tạo này cho các biến nội bộ của chúng tôi để chúng tôi có thể sử dụng chúng trong các phương thức khác sau này. Sau đó, chúng tôi gọi phương thức nội bộ

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

20 chứa thiết lập mặc định cho chiều dài của con rắn, định nghĩa đoạn cơ thể ban đầu và hướng bắt đầu. Chúng tôi cũng sẽ gọi

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

20 bất cứ khi nào con rắn gặp sự cố hoặc chết theo những cách khác, để thiết lập lại trò chơi

Hãy xem xét một chút về biến

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

22. Nó là một danh sách Python, chứa các bộ [hoặc cặp] tọa độ. Mỗi tọa độ này mô tả các vị trí màn hình x và y trên cùng bên trái của một đoạn cơ thể hoặc khối. Chúng tôi sẽ thêm [chắp thêm] vào danh sách này khi con rắn lớn lên. Chúng tôi cũng sử dụng danh sách này khi vẽ con rắn

Vẽ con rắn

Bây giờ chúng ta đã có kiến thức cơ bản về lớp

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

5 và mã khởi tạo của nó đang hoạt động, hãy thêm một phương thức để vẽ con rắn lên màn hình. Thêm phần này vào lớp

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

Phương pháp này lấy một thể hiện pygame,

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

25 và một cửa sổ [hoặc bề mặt theo thuật ngữ pygame chung] để vẽ lên. Sau đó, nó lặp qua từng bộ dữ liệu trong thuộc tính

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

22 và sử dụng pygame được xây dựng trong phương thức

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

27 để vẽ một hình chữ nhật cho mỗi khối hoặc đoạn rắn trong danh sách cơ thể. Chúng tôi cũng sử dụng tham số

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

8 của mình để đặt chiều rộng và chiều cao của hình chữ nhật được vẽ

Hãy thử những gì chúng ta có cho đến nay. Chúng ta sẽ chỉ thấy một vài khối tĩnh trên màn hình, nhưng đó là một bài kiểm tra tốt để xem liệu mọi thứ có đang đi đúng hướng hay không. Để nó hoạt động, hãy nhập và tạo một đối tượng

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

5 mới, đồng thời thiết lập phần đầu tiên của vòng lặp trò chơi của chúng ta trong

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

Thêm mã để nhập các lớp trong tệp

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

4 ở đầu tệp

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

1, ngay dưới dòng

import pygame

import pygame

Bây giờ chúng ta thêm đoạn mã sau ngay dưới dòng

import pygame

import pygame

Mã này thiết lập

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

8 cho lưới của chúng tôi thành mặc định là 20 pixel. Sau đó, chúng tôi tạo một phiên bản mới của lớp

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

5 của chúng tôi, với kích thước khối và giới hạn mà chúng tôi đã sử dụng để đặt kích thước cửa sổ của mình và đó là những gì con rắn sẽ sử dụng để kiểm tra xem nó có chạm vào mép cửa sổ hay không

Bây giờ hãy thiết lập vòng lặp trò chơi của chúng ta. Vòng lặp trò chơi là mã điều phối trung tâm của hầu hết các trò chơi. Nó xử lý việc đọc đầu vào của người dùng, cập nhật trạng thái trình phát [e. g. , vị trí, điểm số, v.v. ], kiểm tra các tương tác và va chạm, và xử lý bản vẽ

Thêm phần sau vào tệp

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

1 để thiết lập vòng lặp trò chơi của chúng tôi

pygame.init[]
bounds = [300,300]
window = pygame.display.set_mode[bounds]
pygame.display.set_caption["Snake"]

Mã này thiết lập một vòng lặp lặp lại cứ sau 100 mili giây cho đến khi nhận được tín hiệu thoát từ cửa sổ. Điều này được kích hoạt khi người chơi nhấp vào nút "Đóng cửa sổ" ở đầu cửa sổ. Pygame có khái niệm về hàng đợi sự kiện mà nó viết các sự kiện khác nhau đã được kích hoạt. Chúng tôi có thể đọc hàng đợi sự kiện này mỗi khi chúng tôi lặp lại vòng lặp trò chơi của mình và kiểm tra xem liệu có bất kỳ sự kiện nào là tín hiệu

import pygame

68 không. Sau đó, chúng tôi có thể đặt điều kiện để vòng lặp chạy thành

import pygame

69 và lần tiếp theo vòng lặp lặp lại, điều kiện

import pygame

90 của chúng tôi sẽ không còn đúng nữa và trò chơi sẽ thoát

Vòng lặp của chúng tôi cũng xóa cửa sổ trên mỗi vòng để chuẩn bị vẽ trạng thái trò chơi được cập nhật. Bạn có thể thấy điều đó trên dòng

import pygame

91. Thao tác này lấp đầy toàn bộ cửa sổ bằng màu đen, được chỉ định trong bộ màu RGB

import pygame

92. Bây giờ chúng ta có một phương tiện rõ ràng, chúng ta có thể gọi phương thức

import pygame

93 trên đối tượng con rắn của chúng ta. Chúng tôi chuyển các đối tượng pygame và Window để Snake có thể vẽ chúng. Khi chúng tôi kết xuất thức ăn của mình, chúng tôi sẽ gọi nó sau dòng này

Cuối cùng, chúng tôi thực hiện kết xuất cuối cùng cho màn hình bằng cách gọi

import pygame

94. Điều này lấy tất cả các bản cập nhật của chúng tôi và "lật" chúng từ bộ đệm cửa sổ sang màn hình

Để kiểm tra xem vòng lặp trò chơi và bản vẽ có hoạt động hay không, hãy chạy chương trình bằng cách nhấp vào nút "Chạy >" lớn ở đầu thay thế. Ở phần trên cùng bên phải của phần thay thế, bạn sẽ thấy một cửa sổ màu đen với một vài khối tượng trưng cho một con rắn trên đó

Di chuyển con rắn

Bước tiếp theo của chúng ta là làm cho con rắn di chuyển trên màn hình. Một cách để làm điều này là kiểm tra xem con rắn đang đi theo hướng nào và thêm một khối ở phía trước con rắn theo hướng đó. Sau đó, chúng ta sẽ cần loại bỏ một khối ở phần đuôi của con rắn

Để làm điều này, hãy thêm phương thức này vào lớp

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

5 trong tệp

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

Phương thức này lấy "đầu" của con rắn, là phần tử cuối cùng trong danh sách

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

22 của chúng ta. Python có một tính năng tiện dụng của các chỉ số âm. Điều này có nghĩa là chỉ mục của

import pygame

98 trả về phần tử cuối cùng trong danh sách,

import pygame

99 trả về phần tử cuối cùng thứ hai, v.v. Điều này cho phép chúng tôi dễ dàng lấy phần tử cuối cùng hoặc phần trước của con rắn trong danh sách cơ thể của chúng tôi bằng cách sử dụng mã

pygame.init[]
bounds = [300,300]
window = pygame.display.set_mode[bounds]
pygame.display.set_caption["Snake"]

Sau khi lấy được đầu con rắn, chúng ta kiểm tra xem con rắn đang đi về hướng nào. Nếu nó đang đi lên hoặc đi xuống, chúng tôi sẽ nối thêm một khối mới bằng cách sao chép tọa độ x của đầu hiện tại và cộng hoặc trừ [tùy thuộc vào việc con rắn đang đi lên hay đi xuống] một lưới

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

8 vào tọa độ y. Tương tự, nếu con rắn đang hướng sang trái hoặc phải, chúng tôi sẽ thêm một khối mới vào danh sách

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

22, sử dụng tọa độ y của đầu hiện tại, nhưng sửa đổi tọa độ x bằng một

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

Khi đã xong, chúng tôi loại bỏ một khối ở phần đuôi của con rắn, sử dụng mã

pygame.init[]
bounds = [300,300]
window = pygame.display.set_mode[bounds]
pygame.display.set_caption["Snake"]

34. Chúng tôi có một điều kiện trước đó mặc dù.

pygame.init[]
bounds = [300,300]
window = pygame.display.set_mode[bounds]
pygame.display.set_caption["Snake"]

35. Điều này rất quan trọng khi chúng ta bắt gặp con rắn đang ăn hoặc đang lớn. Mỗi khi con rắn ăn, chúng ta sẽ tăng thuộc tính

pygame.init[]
bounds = [300,300]
window = pygame.display.set_mode[bounds]
pygame.display.set_caption["Snake"]

36 của con rắn. Sau đó, chúng ta có thể sử dụng thuộc tính

pygame.init[]
bounds = [300,300]
window = pygame.display.set_mode[bounds]
pygame.display.set_caption["Snake"]

36 đó để xác định xem chúng ta có thực sự nên loại bỏ đoạn đuôi khỏi con rắn khi nó di chuyển hay không

Bây giờ, hãy thêm lệnh gọi tới phương thức

pygame.init[]
bounds = [300,300]
window = pygame.display.set_mode[bounds]
pygame.display.set_caption["Snake"]

38 này trong vòng lặp trò chơi của chúng ta. Trong tệp

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

1, sửa đổi vòng lặp trò chơi để gọi phương thức này

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

Lưu ý rằng chúng tôi đã thêm dòng

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

30. Điều này sẽ gọi phương thức

pygame.init[]
bounds = [300,300]
window = pygame.display.set_mode[bounds]
pygame.display.set_caption["Snake"]

38 của chúng tôi mà chúng tôi đã thêm vào con rắn của mình trên mỗi vòng lặp. Điều này sẽ tạo ấn tượng về con rắn di chuyển mượt mà trên màn hình. Kiểm tra nó bằng cách nhấp vào nút "Chạy>" ở trung tâm trên cùng của thay thế. Con rắn sẽ bắt đầu ở trên cùng bên trái của cửa sổ và di chuyển xuống màn hình, cho đến khi nó biến mất khỏi giới hạn cửa sổ

Điều khiển con rắn

Chúng tôi đã có con rắn di chuyển. Nhiệm vụ tiếp theo của chúng ta là lấy thông tin đầu vào của người chơi để điều khiển con rắn. Chúng ta sẽ bắt đầu bằng cách thêm phương thức sau vào lớp

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

5 trong tệp

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

Phương pháp này hoạt động bằng cách chấp nhận một đối số

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

34, phải là một trong các giá trị liệt kê

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

35 mà chúng tôi đã xác định trước đó. Sau đó, chúng tôi kiểm tra từng hướng có thể để đảm bảo rằng hướng đầu vào mới không phải là hướng hoàn toàn ngược lại với hướng mà con rắn hiện đang di chuyển – điều này là do chúng tôi không muốn cho phép đảo ngược con rắn trong trò chơi của mình. Nếu hướng đầu vào là một động thái hợp lệ, chúng tôi cập nhật thuộc tính

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

34 của con rắn. Nhớ lại từ phương pháp

pygame.init[]
bounds = [300,300]
window = pygame.display.set_mode[bounds]
pygame.display.set_caption["Snake"]

38 của chúng tôi, thuộc tính này được sử dụng để xác định cách cập nhật thuộc tính danh sách

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

22 của con rắn, để tạo chuyển động của con rắn

Bây giờ chúng ta có thể cập nhật hướng của con rắn thông qua lệnh điều khiển, chúng ta cần lấy thông tin đầu vào của người chơi. Pygame có một phương thức hữu ích

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

39, trả về một danh sách chứa phần tử boolean cho mỗi phím trên bàn phím. Điều này cho phép chúng tôi tìm thấy phím nào mà người chơi đang đẩy bằng cách tra cứu giá trị tại chỉ mục chính xác trong danh sách phím này. May mắn thay, chúng tôi không cần phải ghi nhớ chỉ mục chính xác cho mọi khóa, vì pygame có các tên dễ đọc được định nghĩa là các hằng số mà chúng tôi có thể sử dụng. Ví dụ: để biết liệu 'Mũi tên lên' có đang được nhấn hay không, chúng ta có thể gọi

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

70 để nhận danh sách trạng thái cho tất cả các phím. Sau đó, chúng ta có thể tìm trạng thái của phím 'Mũi tên lên' bằng cách xem mục nhập của phím đó, với mã

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

71. Nếu phím đang được nhấn, nó sẽ có giá trị

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

72;

Hãy thêm mã vào vòng lặp trò chơi của chúng ta để kiểm tra xem các phím mũi tên "Lên", "Xuống", "Trái" hoặc "Phải" có đang được nhấn hay không. Sau đó, tùy thuộc vào phím được nhấn, chúng ta có thể gọi phương thức

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

74 của mình bằng lệnh hướng được cập nhật. Thêm mã sau vào dòng

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

30 trong vòng lặp trò chơi, trong tệp

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

pygame.init[]
bounds = [300,300]
window = pygame.display.set_mode[bounds]
pygame.display.set_caption["Snake"]

Hãy kiểm tra điều này. Nhấp vào nút "Chạy>" ở trung tâm trên cùng của thay thế. Để Pygame nhận đầu vào bàn phím, trước tiên bạn cần nhấp nhanh vào cửa sổ trò chơi vì trò chơi đang bắt đầu. Bây giờ bạn có thể sử dụng các phím con trỏ để điều khiển con rắn quanh màn hình. Chúng tôi chưa kiểm tra giới hạn, vì vậy con rắn có thể biến mất khỏi mép cửa sổ

Thêm thức ăn

Chúng tôi có một con rắn, nó di chuyển và người chơi có thể điều khiển nó. Hãy thêm một số thức ăn mà con rắn có thể ăn để nó dài ra

Chúng ta sẽ tạo ra thức ăn theo cách tương tự như chúng ta đã tạo ra con rắn. Tạo một tệp mới có tên là

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

77. Trong tệp này, chúng tôi sẽ tạo một lớp

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

78, để quản lý vị trí và vẽ thực phẩm trên lưới

Trong trò chơi rắn, khi một khối thức ăn được ăn, một khối khác sẽ xuất hiện ở một vị trí ngẫu nhiên trên lưới. Điều này có nghĩa là chúng tôi sẽ cần một trình tạo số ngẫu nhiên để xác định vị trí của thực phẩm. Python có một mô-đun gọi là

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

79. Cái này có chức năng gọi là

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

20 mà chúng ta có thể sử dụng để tìm một vị trí ngẫu nhiên trên màn hình để đặt thức ăn. Chúng tôi sẽ bắt đầu bằng cách thêm một tham chiếu đến mô-đun

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

79 trong tệp

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

77. Sau đó, chúng tôi sẽ thêm lớp

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

pygame.init[]
bounds = [300,300]
window = pygame.display.set_mode[bounds]
pygame.display.set_caption["Snake"]

Lưu ý điểm chung với lớp

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

5. Cả hai đều có phương pháp

import pygame

93 và phương pháp

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

20. Nói chung trong các trò chơi, hầu hết các đối tượng sẽ có chức năng này

Lớp

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

78 cũng có các thuộc tính tương tự như lớp

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

5. Nó có một

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

8, đề cập đến kích thước của mỗi khối trên lưới ảo của chúng tôi. Nó có một bộ dữ liệu

pygame.init[]
bounds = [300,300]
window = pygame.display.set_mode[bounds]
pygame.display.set_caption["Snake"]

00, mà chúng ta sẽ sử dụng khi vẽ đồ ăn. Nó cũng có một bản ghi

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

3 của cửa sổ, để chúng tôi không vẽ thức ăn bên ngoài cửa sổ có thể nhìn thấy. Tuy nhiên, vì thức ăn chỉ được tạo thành từ 1 khối nên chúng ta không cần mảng

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

22 như lớp rắn. Chúng ta có thể theo dõi vị trí của nó với các biến tọa độ x và y

Phương thức

import pygame

93 là phiên bản đơn giản hóa của phương thức trong lớp rắn. Điều này là do chúng ta chỉ cần vẽ 1 khối

Phương pháp

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

20 thật thú vị. Chúng ta cần căn chỉnh thực phẩm của mình với lưới ảo của mình, được xác định bởi

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

8. Tuy nhiên, nếu chúng ta chỉ đơn giản gọi

pygame.init[]
bounds = [300,300]
window = pygame.display.set_mode[bounds]
pygame.display.set_caption["Snake"]

06 để tìm vị trí x và y cho thực phẩm, nó có thể rơi xuống giữa một khối trên lưới. Điều này sẽ khiến việc nhắm mục tiêu với con rắn trở nên kỳ lạ, vì con rắn sẽ không thẳng hàng với thức ăn

Để giữ cho mọi thứ được căn chỉnh, chúng tôi cần lấy thông tin về kích thước của cửa sổ, được gói gọn trong thuộc tính

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

3 và kiến thức của chúng tôi về

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

8 của lưới để tìm ra kích thước của cửa sổ theo khối. Vì vậy, ví dụ: nếu kích thước cửa sổ của chúng tôi hoặc

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

3 là 300x300 pixel và

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

8 của chúng tôi là 20px, thì có 300px/20px = 15 khối trong mỗi chiều. Sau đó, chúng tôi có thể chọn một vị trí ngẫu nhiên về kích thước khối, tôi. e chọn số từ 1-15 để đặt thức ăn. Để có tọa độ màn hình x và y thực tế để vẽ khối, chúng ta chỉ cần nhân số khối của mình với ________ 08

Trong 2 dòng đầu tiên của phương pháp

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

20, chúng tôi tìm thấy số lượng khối trong mỗi thứ nguyên, như được mô tả ở trên. Sau đó, 2 dòng tiếp theo tìm một khối ngẫu nhiên và dịch khối đó sang tọa độ x và y. Bạn có thể nhận thấy rằng thay vì tìm một số ngẫu nhiên trong khoảng từ 1 đến số khối trong một thứ nguyên, chúng tôi tìm một số từ 0 đến số khối trừ 1. Điều này là do cửa sổ x và y bắt đầu từ 0, không phải 1, vì vậy chúng ta cần chuyển phạm vi lên 1 để bù lại

Chúng tôi có một lớp

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

78, vì vậy chúng tôi có thể tạo một phiên bản của nó và thêm nó vào vòng lặp trò chơi của chúng tôi

Trước tiên, chúng ta cần thêm một tham chiếu đến tệp

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

77 và nhập lớp

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

78. Trong tệp

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

1, ngay bên dưới dòng

import pygame

63, hãy thêm dòng sau

pygame.init[]
bounds = [300,300]
window = pygame.display.set_mode[bounds]
pygame.display.set_caption["Snake"]

Trong tệp

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

1, sau dòng

pygame.init[]
bounds = [300,300]
window = pygame.display.set_mode[bounds]
pygame.display.set_caption["Snake"]

19 và ngay trước vòng lặp trò chơi, hãy tạo một đối tượng

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

78 mới bằng cách thêm dòng

pygame.init[]
bounds = [300,300]
window = pygame.display.set_mode[bounds]
pygame.display.set_caption["Snake"]

Trong trò chơi vòng lặp ở

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

1, ngay sau dòng

pygame.init[]
bounds = [300,300]
window = pygame.display.set_mode[bounds]
pygame.display.set_caption["Snake"]

22, chúng ta có thể thêm một dòng để vẽ đồ ăn. Thêm dòng sau

pygame.init[]
bounds = [300,300]
window = pygame.display.set_mode[bounds]
pygame.display.set_caption["Snake"]

Tuyệt quá. Hãy kiểm tra đến điểm này bằng cách nhấp lại vào nút "Chạy >". Bây giờ bạn sẽ thấy con rắn, cũng như một khối màu xanh lá cây đại diện cho thức ăn

Thêm tính năng phát hiện va chạm cho thực phẩm

Bạn sẽ nhận thấy rằng con rắn có thể đi ngay trên thức ăn và không có gì xảy ra. Một khái niệm cốt lõi trong trò chơi là phát hiện va chạm. Vì chúng tôi đang sử dụng một hệ thống lưới nghiêm ngặt, chúng tôi có thể sử dụng phiên bản phát hiện va chạm đơn giản hóa. Chúng tôi sẽ sử dụng thông tin này để xác định xem con rắn có di chuyển qua hoặc va chạm với đồ ăn hay không. Sau đó, chúng ta có thể tăng chiều dài của con rắn và hồi sinh lại thức ăn

Chúng ta sẽ giao trách nhiệm kiểm tra va chạm cho lớp

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

5. Trong tệp

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

4, thêm hai phương thức sau vào lớp

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

pygame.init[]
bounds = [300,300]
window = pygame.display.set_mode[bounds]
pygame.display.set_caption["Snake"]

Phương pháp đầu tiên,

pygame.init[]
bounds = [300,300]
window = pygame.display.set_mode[bounds]
pygame.display.set_caption["Snake"]

26, tăng chiều dài cho phép của con rắn. Hãy nhớ rằng thuộc tính

pygame.init[]
bounds = [300,300]
window = pygame.display.set_mode[bounds]
pygame.display.set_caption["Snake"]

36 được sử dụng trong phương thức

pygame.init[]
bounds = [300,300]
window = pygame.display.set_mode[bounds]
pygame.display.set_caption["Snake"]

38 để xác định xem có cần xóa đoạn đuôi hay không

Sau đó, chúng ta có phương thức

pygame.init[]
bounds = [300,300]
window = pygame.display.set_mode[bounds]
pygame.display.set_caption["Snake"]

29. Điều này chấp nhận đối tượng

pygame.init[]
bounds = [300,300]
window = pygame.display.set_mode[bounds]
pygame.display.set_caption["Snake"]

30 làm đối số. Trong chức năng này, chúng tôi lấy khối phía trước nhất của con rắn hoặc

pygame.init[]
bounds = [300,300]
window = pygame.display.set_mode[bounds]
pygame.display.set_caption["Snake"]

31 bằng cách truy cập phần tử cuối cùng trong danh sách

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

22. Nhớ lại rằng chúng ta có thể sử dụng chỉ mục phủ định để truy cập phần tử cuối cùng. Sau đó, vì chúng tôi đang sử dụng một hệ thống lưới nghiêm ngặt để bố trí trò chơi của mình, chúng tôi chỉ cần kiểm tra xem tọa độ x và y của đầu rắn có bằng với tọa độ x và y của đối tượng thức ăn hay không. Nếu đúng như vậy, chúng tôi gọi phương pháp

pygame.init[]
bounds = [300,300]
window = pygame.display.set_mode[bounds]
pygame.display.set_caption["Snake"]

26 để tăng chiều dài của con rắn. Chúng tôi cũng gọi

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

20 trên thực phẩm để làm cho nó biến mất khỏi vị trí hiện tại và xuất hiện lại ở một vị trí khác

Trong vòng lặp trò chơi trong tệp

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

1, hãy thêm đoạn mã sau, ngay sau dòng

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

pygame.init[]
bounds = [300,300]
window = pygame.display.set_mode[bounds]
pygame.display.set_caption["Snake"]

Điều này thêm một cuộc gọi vào phương pháp phát hiện va chạm thực phẩm của chúng tôi trên mỗi vòng lặp của trò chơi, ngay sau khi con rắn di chuyển vào một khối mới

Chúng ta có thể kiểm tra lại điều này và xem liệu con rắn của chúng ta có lớn lên khi chúng ta ăn một số thức ăn không. Nhấp lại vào nút "Chạy >" để kiểm tra

Phát hiện va chạm đuôi và ràng buộc

Bây giờ chúng ta cần thêm tính năng phát hiện va chạm nếu con rắn băng qua chính nó. Đây là nước đi chết người, và là một trong những cách dẫn đến "Game Over" trong Snake. Tương tự để kiểm tra xem con rắn đã ăn thức ăn chưa, chúng ta có thể thêm một phương thức vào lớp

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

5 trong tệp

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

4 để kiểm tra xem con rắn có băng qua hay cắn chính nó không

pygame.init[]
bounds = [300,300]
window = pygame.display.set_mode[bounds]
pygame.display.set_caption["Snake"]

Phương pháp này nhận được

pygame.init[]
bounds = [300,300]
window = pygame.display.set_mode[bounds]
pygame.display.set_caption["Snake"]

31 của con rắn, như trước đây trong phương pháp

pygame.init[]
bounds = [300,300]
window = pygame.display.set_mode[bounds]
pygame.display.set_caption["Snake"]

29 của chúng tôi. Sau đó, chúng tôi đặt một biến cờ để xác định xem con rắn đã ăn đuôi của nó chưa và khởi tạo nó thành

import pygame

Phần tiếp theo của phương thức chạy qua tất cả các phân đoạn tạo nên

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

22 của con rắn, ngoại trừ phần tử cuối cùng của danh sách

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

22, vì phần tử này đại diện cho phần đầu của con rắn. Sau đó, chúng tôi kiểm tra tọa độ x và y của

pygame.init[]
bounds = [300,300]
window = pygame.display.set_mode[bounds]
pygame.display.set_caption["Snake"]

31 và đoạn hiện tại. Nếu chúng khớp nhau, điều đó có nghĩa là đầu rắn nằm trên một đoạn cơ thể, vì vậy chúng ta có thể đặt cờ

pygame.init[]
bounds = [300,300]
window = pygame.display.set_mode[bounds]
pygame.display.set_caption["Snake"]

45 thành true

Sau khi tất cả các phân đoạn được kiểm tra, chúng tôi trả về giá trị của cờ

pygame.init[]
bounds = [300,300]
window = pygame.display.set_mode[bounds]
pygame.display.set_caption["Snake"]

Phát hiện cuối cùng chúng ta cần thêm là nếu con rắn di chuyển ra ngoài giới hạn của cửa sổ. Chúng ta có thể thêm phương thức sau vào lớp

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

5 để làm điều đó

pygame.init[]
bounds = [300,300]
window = pygame.display.set_mode[bounds]
pygame.display.set_caption["Snake"]

Mã này một lần nữa truy xuất khối

pygame.init[]
bounds = [300,300]
window = pygame.display.set_mode[bounds]
pygame.display.set_caption["Snake"]

31 của con rắn từ cuối danh sách

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

22. Sau đó, nó kiểm tra từng kích thước so với giới hạn của cửa sổ. Nếu nó nằm ngoài bất kỳ giới hạn nào trong số này, phương thức sẽ trả về

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

72. Nếu đầu rắn vẫn nằm trong giới hạn, nó sẽ trả về

import pygame

Thêm màn hình "Trò chơi kết thúc"

Bây giờ chúng ta có thể phát hiện các xung đột khi kết thúc trò chơi, chúng ta có thể thêm mã vào vòng lặp trò chơi để gọi các phương thức này và xử lý khi kết thúc trò chơi. Khi trò chơi kết thúc, chúng tôi sẽ hiển thị thông báo "Trò chơi kết thúc" cho người chơi trong một hoặc hai giây. Sau đó, chúng tôi có thể đặt lại con rắn và thức ăn để cho người chơi một cơ hội khác

Để thêm thông báo "Trò chơi kết thúc", chúng ta có thể sử dụng mô-đun phông chữ của pygame. Các bước cơ bản để sử dụng phông chữ để vẽ văn bản lên màn hình là

Tạo một đối tượng phông chữ mới, chỉ định loại phông chữ, kích thước và các tùy chọn in đậm/nghiêng, sử dụng phương thức khởi tạo
```
pygame.init[]
bounds = [300,300]
window = pygame.display.set_mode[bounds]
pygame.display.set_caption["Snake"]
```
52
Kết xuất văn bản mong muốn lên một bề mặt bằng phương pháp
```
pygame.init[]
bounds = [300,300]
window = pygame.display.set_mode[bounds]
pygame.display.set_caption["Snake"]
```
53 trên đối tượng phông chữ được tạo ở trên

pygame.init[]
bounds = [300,300]
window = pygame.display.set_mode[bounds]
pygame.display.set_caption["Snake"]

54 văn bản được hiển thị trên bề mặt cửa sổ chính

Cập nhật màn hình cửa sổ để hiển thị điều này

Để thực hiện các bước trên, hãy tạo một đối tượng

pygame.init[]
bounds = [300,300]
window = pygame.display.set_mode[bounds]
pygame.display.set_caption["Snake"]

55 mới bằng cách thêm đoạn mã sau vào dòng

pygame.init[]
bounds = [300,300]
window = pygame.display.set_mode[bounds]
pygame.display.set_caption["Snake"]

56 trong tệp

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

pygame.init[]
bounds = [300,300]
window = pygame.display.set_mode[bounds]
pygame.display.set_caption["Snake"]

Trong vòng lặp trò chơi, chúng ta cần gọi các phương thức kiểm tra va chạm mà chúng ta đã thêm vào lớp rắn trước đó. Nếu phát hiện xung đột, chúng tôi có thể hiển thị thông báo "Trò chơi kết thúc", tạm dừng và đặt lại trò chơi. Thêm mã sau vào dòng

pygame.init[]
bounds = [300,300]
window = pygame.display.set_mode[bounds]
pygame.display.set_caption["Snake"]

58 trong vòng lặp trò chơi trong tệp

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

Mã này gọi các phương thức kiểm tra giới hạn và xung đột đuôi của chúng tôi. Nếu một trong số họ quay lại

from enum import Enum

class Direction[Enum]:
  UP = 0
  DOWN = 1
  LEFT = 2
  RIGHT = 3

class Snake:
  length = None
  direction = None
  body = None
  block_size = None
  color = [0,0,255]
  bounds = None

  def __init__[self, block_size, bounds]:
    self.block_size = block_size
    self.bounds = bounds
    self.respawn[]

  def respawn[self]:
    self.length = 3
    self.body = [[20,20],[20,40],[20,60]]
    self.direction = Direction.DOWN

72, chúng tôi sẽ hiển thị thông báo "Trò chơi kết thúc" mới bằng cách sử dụng các bước phông chữ ở trên và đưa thông báo đó vào cửa sổ chính của chúng tôi. Sau đó, chúng tôi trì hoãn trong 1000 mili giây [hoặc 1 giây], sau đó hồi sinh cả rắn và đồ ăn cho một trò chơi mới

Xin chúc mừng. Trò chơi Snake cơ bản đã hoàn tất. Nhấp vào nút "Chạy>" ở đầu bản thay thế để dùng thử. Khi con rắn đâm vào chính nó hoặc bay ra khỏi mép cửa sổ, trò chơi sẽ kết thúc và thiết lập lại sang một trò chơi mới

Trò chơi rắn có dễ không?

Trò chơi rắn là một trò chơi đơn giản mà bạn có thể thực hiện bằng cách sử dụng kiến thức cơ bản về JavaScript và HTML . Mục tiêu cơ bản là điều hướng một con rắn và ăn càng nhiều táo càng tốt mà không chạm vào tường hoặc cơ thể của con rắn. Trong bài viết này, chúng tôi sẽ hướng dẫn từng bước cách tạo Trò chơi rắn này bằng JavaScript và HTML.

Bạn có thể viết mã trò chơi bằng Python không?

Do đó, Python cũng là một ngôn ngữ lý tưởng để bạn bắt đầu cuộc phiêu lưu tạo trò chơi , bất kể bạn đã thông thạo ngôn ngữ này hay chưa. . Do cú pháp thân thiện với người mới của Python, các nhà phát triển có thể tập trung vào những điều cơ bản của lập trình trò chơi, chứ không phải sự phức tạp của chính ngôn ngữ này.

Làm cách nào để tạo trò chơi bằng Python?

Đây là ví dụ sau về việc tạo một cửa sổ pygame đơn giản. .

nhập pygame

pygame. trong đó[]

màn hình = pygame. trưng bày. set_mode[[400,500]]

xong = Sai

trong khi chưa hoàn thành

cho sự kiện trong pygame. Sự kiện. được[]

nếu sự kiện. gõ == pygame. TỪ BỎ

xong = Đúng

Làm cách nào để tạo một chú chim flappy bằng Python?

TẠO BIẾN TOÀN CẦU CHO FLAPPY Bird TRONG PYTHON PYGAME .

nhập ngẫu nhiên #để tạo số ngẫu nhiên

nhập sys #Để thoát khỏi trò chơi

nhập pygame

từ pygame. nhập địa phương * Nhập Pygame #Basic

#Biến toàn cầu cho trò chơi

FPS = 32

RỘNG MÀN HÌNH = 289

CHIỀU CAO MÀN HÌNH = 511

Tổng quan và yêu cầu

Tạo một dự án mới

Bắt đầu với Pygame​

Tạo lớp rắn​

Vẽ con rắn

Di chuyển con rắn

Điều khiển con rắn

Thêm thức ăn

Thêm tính năng phát hiện va chạm cho thực phẩm​

Phát hiện va chạm đuôi và ràng buộc​

Thêm màn hình "Trò chơi kết thúc"​

Trò chơi rắn có dễ không?

Bạn có thể viết mã trò chơi bằng Python không?

Làm cách nào để tạo trò chơi bằng Python?

Làm cách nào để tạo một chú chim flappy bằng Python?

Bài Viết Liên Quan

Toplist mới

Bài mới nhất

Chủ Đề

Bắt đầu với Pygame

Tạo lớp rắn

Thêm tính năng phát hiện va chạm cho thực phẩm

Phát hiện va chạm đuôi và ràng buộc

Thêm màn hình "Trò chơi kết thúc"