三亩地 三亩地SAN MU DI · CODE DIARY
交流投稿
ARTICLE DETAIL

日记详情

真实记录编程学习的某一天，欢迎挑你感兴趣的翻一翻。

首页/学习日记/日记详情

Godot贪吃蛇实战：从零到一掌握2D游戏开发核心

发布时间：2026/8/6 10:51:04 三亩地 编程学习日记
Godot贪吃蛇实战：从零到一掌握2D游戏开发核心

1. 项目概述与核心思路

贪吃蛇这个游戏，相信是很多人编程入门或者游戏开发启蒙的第一个项目。它规则简单，逻辑清晰，但麻雀虽小五脏俱全，涵盖了游戏开发中角色控制、碰撞检测、状态管理、游戏逻辑等多个核心模块。这次，我们选择在 Godot 引擎中，用实战的方式完整地复现一遍贪吃蛇。这不仅仅是“写一个能跑的游戏”，更是希望通过这个经典案例，深入理解 Godot 基于节点和场景的设计哲学，以及如何用 GDScript 高效地组织游戏逻辑。

整个项目我们将拆解为几个核心部分：游戏场景与窗口设置、蛇头的移动与控制、食物的生成与碰撞、蛇身的动态增长与跟随，以及游戏状态（开始、进行中、结束）的管理。我们会从零开始，一步步搭建，并重点讲解每个环节中 Godot 特有的实现方式和可能遇到的“坑”。无论你是刚接触 Godot 的新手，还是想通过一个完整项目巩固引擎使用的中级开发者，相信这个系列都能给你带来实实在在的收获。

2. 项目初始化与场景结构设计

2.1 创建项目与窗口设置

启动 Godot 后，我们创建一个新的 2D 项目。项目名称可以定为“SnakeGame”。创建完成后，第一件事就是设置游戏窗口。贪吃蛇通常在一个固定大小的网格中运行，所以我们不需要窗口缩放。

在项目设置（Project -> Project Settings）中，找到“Display -> Window”：

  1. Size（尺寸）：设置为 1024 x 640。这是一个比较舒适的宽屏比例，方便我们布局游戏区域和可能的UI（如分数显示）。
  2. Stretch -> Mode（拉伸模式）：设置为canvas_items。这是 2D 游戏最常用的模式，它确保所有节点都基于 Canvas 坐标系进行渲染，不受窗口大小影响。
  3. Stretch -> Aspect（拉伸宽高比）：设置为keep。这保证了无论窗口如何调整，游戏画面的宽高比始终保持不变，避免图像被拉伸变形。
  4. Resizable（可调整大小）：务必设置为false。对于贪吃蛇这类基于固定网格的游戏，窗口大小变化会导致坐标计算复杂化，直接禁用窗口缩放是最简单的做法。

注意：很多新手会忽略窗口设置，导致后期做UI适配或全屏时出现各种显示问题。在项目开始时就定好这些基础参数，能省去很多麻烦。

2.2 构建主场景（Main Scene）

主场景是游戏的入口，负责加载和管理所有游戏元素。我们创建一个名为Main.tscn的场景。

  1. 根节点使用Node2D，命名为Main。Node2D是所有 2D 节点的基类，作为根节点很合适。
  2. 在Main节点下，我们添加几个子节点：
    • Snake（Node2D）：作为蛇（包括头和身体）的容器。
    • Food（Node2D）：作为所有食物实例的容器。
    • UI（CanvasLayer）：用于存放所有用户界面元素，如分数、开始按钮、游戏结束提示等。使用CanvasLayer可以确保 UI 始终绘制在最上层，不受游戏内节点层级影响。
    • GameManager（Node）：一个不可见的逻辑节点，用于管理游戏全局状态，如分数、游戏是否开始/结束、重置游戏等。将游戏逻辑与表现分离是良好的设计习惯。

这样的结构清晰地将游戏对象（蛇、食物）、用户界面和游戏逻辑管理分开，便于后续的维护和扩展。

2.3 蛇头场景（SnakeHead）设计

蛇头是玩家直接控制的单位，也是整个蛇身体的“领导者”。我们创建一个独立的场景SnakeHead.tscn。

  1. 根节点类型选择：这里有个关键决策。蛇头需要检测与食物和自身身体的碰撞。因此，我们选择Area2D作为根节点，并命名为SnakeHead。Area2D可以轻松地检测与其他Area2D或PhysicsBody2D的重叠，非常适合处理“吃到食物”或“撞到自己”这类事件。
  2. 视觉表现：在SnakeHead节点下添加一个Sprite2D节点。我们可以用一个简单的正方形纹理（比如在 Godot 内置编辑器中画一个 16x16 的红色方块）来代表蛇头。将纹理赋值给Sprite2D的Texture属性。
  3. 碰撞形状：为了让Area2D生效，必须为其定义碰撞边界。添加一个CollisionShape2D子节点。在其Shape属性中，新建一个RectangleShape2D，大小设置得和蛇头纹理差不多，例如 16x16。这个形状决定了何时会触发碰撞事件。
  4. 移动与方向：蛇头的移动逻辑我们将通过脚本控制。在SnakeHead根节点上附加一个新的脚本SnakeHead.gd。

SnakeHead.gd 初始脚本框架：

extends Area2D # 蛇头的移动速度（像素/秒） @export var speed: float = 200.0 # 蛇头的移动方向向量，初始向右 (1, 0) var direction: Vector2 = Vector2.RIGHT # 下一个方向，用于缓冲输入，防止在一帧内连续转向导致直接反向（自杀） var next_direction: Vector2 = Vector2.RIGHT func _ready(): # 初始位置可以放在场景中心或特定起始点 position = Vector2(512, 320) func _process(delta): # 处理玩家输入，更新 next_direction _handle_input() # 根据当前方向移动 position += direction * speed * delta func _handle_input(): if Input.is_action_just_pressed("ui_right") and direction != Vector2.LEFT: next_direction = Vector2.RIGHT if Input.is_action_just_pressed("ui_left") and direction != Vector2.RIGHT: next_direction = Vector2.LEFT if Input.is_action_just_pressed("ui_down") and direction != Vector2.UP: next_direction = Vector2.DOWN if Input.is_action_just_pressed("ui_up") and direction != Vector2.DOWN: next_direction = Vector2.UP

这里我们使用了_process(delta)函数来实现基于时间的连续移动，这样蛇的移动速度就不会受帧率影响。next_direction是一个重要的技巧，它确保了即使玩家快速连续按键，蛇头也只会在下一个移动更新点（比如我们后面会引入的基于网格的移动）改变方向，并且通过判断direction != 反方向来禁止直接180度转向，这是贪吃蛇的基本规则。

3. 网格化移动与游戏节奏控制

3.1 从连续移动转向网格移动

上面的_process移动会让蛇头平滑移动，但这不符合经典贪吃蛇在固定网格中“一格一格”跳跃的感觉，也会让碰撞检测和身体跟随变得复杂。我们需要将移动改为基于固定时间间隔的网格跳跃。

  1. 定义网格大小：在脚本顶部定义一个常量const CELL_SIZE = 32，表示游戏网格中每一格的像素大小。
  2. 引入计时器：删除_process中的移动代码，改为使用Timer节点来控制移动节奏。在SnakeHead场景中添加一个Timer子节点，命名为MoveTimer。
  3. 配置计时器：在MoveTimer的属性中，将Wait Time设置为 0.15（秒）。这个值决定了蛇的移动速度，值越小蛇移动越快。将Autostart设置为false，我们将在游戏开始时启动它。
  4. 修改移动逻辑：将移动逻辑移到MoveTimer的timeout()信号回调函数中。

更新后的 SnakeHead.gd 核心部分：

extends Area2D @export var speed: float = 200.0 # 这个speed现在可能用于计算计时器间隔，或者暂时不用 const CELL_SIZE = 32 var direction: Vector2 = Vector2.RIGHT var next_direction: Vector2 = Vector2.RIGHT @onready var move_timer = $MoveTimer func _ready(): position = _snap_to_grid(Vector2(512, 320)) # 游戏开始时，由GameManager来启动计时器 # move_timer.start() func _handle_input(): # 输入处理逻辑不变，仍然更新 next_direction pass func _on_move_timer_timeout(): # 在移动前，将缓冲的方向应用到当前方向 direction = next_direction # 计算新位置：当前位置 + 方向向量 * 网格大小 var new_position = position + (direction * CELL_SIZE) # 可选：在这里可以添加边界检查，如果超出屏幕则游戏结束或穿墙 position = new_position # 移动后，发出一个信号，通知身体部分需要更新位置（后续实现） moved.emit(position) # 一个工具函数，将任意位置对齐到网格 func _snap_to_grid(pos: Vector2) -> Vector2: return (pos / CELL_SIZE).floor() * CELL_SIZE # 自定义信号，用于与身体通信 signal moved(new_position: Vector2)

现在，蛇头每过 0.15 秒就会向当前方向跳跃 32 像素。这种网格化移动使得蛇的轨迹是离散的，便于计算食物位置和身体跟随。

3.2 边界检测与穿墙逻辑

经典贪吃蛇有两种边界处理方式：撞墙即死，或者穿墙从另一侧出现。我们来实现穿墙逻辑，它稍微复杂但更有趣。

在_on_move_timer_timeout()函数中，计算new_position之后，添加边界检查：

func _on_move_timer_timeout(): direction = next_direction var new_position = position + (direction * CELL_SIZE) # 获取游戏窗口的可视区域大小（在项目设置中定义的1024x640） var viewport_size = get_viewport_rect().size # 穿墙逻辑 if new_position.x < 0: new_position.x = viewport_size.x - CELL_SIZE elif new_position.x >= viewport_size.x: new_position.x = 0 if new_position.y < 0: new_position.y = viewport_size.y - CELL_SIZE elif new_position.y >= viewport_size.y: new_position.y = 0 position = new_position moved.emit(position)

这段代码检查蛇头是否移出了屏幕左/右/上/下边界。如果移出，则将其位置设置到对边的边界内侧。注意new_position.x >= viewport_size.x的判断，因为我们的位置是左上角坐标，当x等于窗口宽度时，蛇头其实刚好完全移出右侧屏幕。

实操心得：穿墙逻辑的难点在于精确判断“出界”的时机。使用>=而不是>可以确保在蛇头刚好到达边界的那一刻就进行传送，视觉上更连贯。你也可以尝试实现“撞墙即死”的逻辑，只需在检测到出界时，调用游戏结束函数即可。

4. 食物系统实现

4.1 食物场景（Food）创建

食物也是一个简单的可交互对象。创建Food.tscn场景。

  1. 根节点使用Area2D，命名为Food。这样当蛇头（也是Area2D）与之重叠时，可以发出信号。
  2. 添加Sprite2D子节点，使用一个不同颜色的方块（如绿色）作为纹理。
  3. 添加CollisionShape2D子节点，形状同样为RectangleShape2D，大小与纹理匹配。
  4. 为根节点Food附加脚本Food.gd。这个脚本很简单，主要功能就是在被吃掉后重新随机放置自己。

Food.gd 脚本：

extends Area2D const CELL_SIZE = 32 # 与蛇头保持一致 @onready var sprite = $Sprite2D func _ready(): # 初始随机位置 randomize_position() func randomize_position(): # 获取游戏区域大小 var viewport_rect = get_viewport_rect() # 计算网格的行数和列数 var grid_width = int(viewport_rect.size.x / CELL_SIZE) var grid_height = int(viewport_rect.size.y / CELL_SIZE) # 生成网格内的随机坐标 var grid_x = randi() % grid_width var grid_y = randi() % grid_height # 将网格坐标转换为像素坐标 position = Vector2(grid_x * CELL_SIZE, grid_y * CELL_SIZE)

randomize_position函数将食物的位置随机放置在游戏窗口的网格点上。randi()生成随机整数，%运算符确保结果在[0, grid_width-1]范围内。

4.2 将食物实例添加到主场景

回到Main.tscn。在之前创建的Food（Node2D容器）节点下，实例化刚才创建的Food.tscn。这样，我们的场景中就有了一个食物。

4.3 实现“吃食物”逻辑

“吃”这个行为，本质是蛇头与食物的碰撞检测。我们需要在蛇头脚本中监听与食物的碰撞。

  1. 连接信号：在SnakeHead.tscn编辑器中，选择根节点SnakeHead（Area2D）。在右侧的“节点”选项卡中，切换到“信号”标签页。找到area_entered(area: Area2D)信号，双击它，连接到SnakeHead节点自身。这会在SnakeHead.gd脚本中生成一个_on_area_entered的回调函数。
  2. 编写碰撞处理逻辑：
func _on_area_entered(area): # 检查进入的区域是否是食物 if area.is_in_group("food"): # 调用食物的被吃方法 area.queue_free() # 简单做法：删除当前食物实例 # 更优做法：通知食物容器或GameManager生成新食物 # 例如：get_parent().get_node("../Food").spawn_food() # 蛇身增长（后续实现） # 增加分数（后续实现） print("Ate food!")
  1. 为食物添加分组：为了让蛇头能识别食物，我们需要给食物打上标签。在Food.tscn中，选择根节点Food，在检查器面板的“节点”分组中，添加一个分组，命名为food。这样，area.is_in_group("food")的判断就会成立。

注意事项：直接在碰撞回调中queue_free()删除食物虽然简单，但在实际游戏中，我们通常希望由某个中心管理器（如GameManager或Food容器）来统一管理食物的生成和回收。这样逻辑更清晰，也便于实现“食物被吃后立即在随机位置生成新食物”的效果。我们可以让SnakeHead发出一个“吃到食物”的信号，由Main或GameManager来监听并处理。

5. 蛇身系统的实现（核心难点）

这是贪吃蛇游戏最核心也最具技巧性的部分。蛇身需要跟随蛇头运动，形成连贯的身体。

5.1 身体段场景（BodySegment）

首先创建一个身体段的场景BodySegment.tscn。

  1. 根节点使用Node2D，命名为BodySegment。
  2. 添加Sprite2D子节点，使用一个与蛇头颜色不同（如蓝色）的方块纹理。
  3. （可选）为了后续可能的碰撞检测，也可以添加Area2D和CollisionShape2D，这样身体也能触发碰撞事件（用于检测撞到自己）。
  4. 附加一个简单的脚本BodySegment.gd，它可能只需要存储自己的网格位置，或者提供一个更新位置的方法。
extends Node2D var target_position: Vector2 func update_position(new_pos: Vector2): # 可以在这里添加一些平滑移动的动画效果，但经典贪吃蛇是瞬间移动 position = new_pos

5.2 在蛇头中管理身体

我们选择在SnakeHead.gd中管理身体段的列表。这是一种直接的方式。

  1. 定义身体列表和预制体：
extends Area2D # ... 之前的变量 ... @export var body_segment_scene: PackedScene # 用于在编辑器中指定BodySegment场景 var body_segments: Array = [] # 存储身体段实例的数组 var body_positions: Array = [] # 存储身体段历史位置的数组（另一种实现思路）
  1. 初始化身体：在_ready()中，可以初始化几节身体。例如，开始时蛇头后面跟着两节身体。
func _ready(): position = _snap_to_grid(Vector2(512, 320)) # 初始化两节身体 for i in range(2): add_body_segment()
  1. 添加身体段的方法：
func add_body_segment(): if not body_segment_scene: return var new_segment = body_segment_scene.instantiate() # 新身体应该添加到哪里？通常添加到蛇头所在的容器（Snake节点）下 var snake_container = get_parent() # 假设SnakeHead的父节点是Snake容器 snake_container.add_child(new_segment) # 设置新身体的位置 if body_segments.is_empty(): # 如果还没有身体，新身体放在蛇头上一帧的位置 new_segment.global_position = position - (direction * CELL_SIZE) else: # 如果有身体，新身体放在最后一节身体的后面 var last_segment = body_segments[-1] new_segment.global_position = last_segment.global_position body_segments.append(new_segment)
  1. 移动时更新身体位置：这是关键。每次蛇头移动时，所有身体段都要移动到前一个身体段（或蛇头）之前的位置。我们修改_on_move_timer_timeout函数。
func _on_move_timer_timeout(): # 1. 保存蛇头移动前的位置，这是第一节身体要去的位置 var prev_head_position = position # 2. 更新蛇头位置（包含穿墙逻辑） direction = next_direction var new_head_position = position + (direction * CELL_SIZE) # ... (此处是之前的穿墙边界检查代码) ... position = new_head_position # 3. 更新所有身体段的位置 var current_position_to_assign = prev_head_position for segment in body_segments: var segment_prev_position = segment.global_position segment.global_position = current_position_to_assign current_position_to_assign = segment_prev_position # 4. 移动后，检查碰撞（与自身身体） _check_self_collision()

原理：我们用一个临时变量current_position_to_assign来记录下一个身体段应该去的位置。开始时，这个位置是蛇头移动前的位置prev_head_position。然后遍历每一节身体，先记录它当前的位置segment_prev_position，然后将它移动到current_position_to_assign。最后，将current_position_to_assign更新为这节身体移动前的位置，供下一节身体使用。这个过程就像传递一个位置“接力棒”。

5.3 自我碰撞检测

当蛇头移动后，需要检查是否与任何身体段发生了碰撞（即坐标相同）。我们在_check_self_collision函数中实现。

func _check_self_collision(): for segment in body_segments: if position.distance_to(segment.global_position) < 1: # 因为是基于网格的，可以直接比较坐标 # 游戏结束！ print("Game Over! Hit body.") # 停止移动计时器 move_timer.stop() # 发出游戏结束信号，由GameManager处理 game_over.emit() return signal game_over

这里我们遍历所有身体段，检查蛇头当前位置是否与某节身体的位置“足够近”。由于是网格移动，理论上可以直接判断position == segment.global_position，但使用distance_to并设置一个很小的阈值（如1像素）容错更稳健。

6. 游戏状态管理与UI

6.1 创建GameManager

GameManager是一个全局状态管理器。在Main.tscn中，为GameManager节点创建脚本GameManager.gd。

extends Node var score: int = 0 var is_game_active: bool = false @onready var snake_head = $"../Snake/SnakeHead" # 根据实际节点路径调整 @onready var food_container = $"../Food" @onready var ui_layer = $"../UI" func _ready(): # 初始状态，等待玩家开始 pass func start_game(): score = 0 is_game_active = true # 重置蛇的位置和身体 # 生成第一个食物 # 启动蛇头的移动计时器 snake_head.get_node("MoveTimer").start() # 更新UI分数 ui_layer.update_score(score) func end_game(): is_game_active = false snake_head.get_node("MoveTimer").stop() # 显示游戏结束UI ui_layer.show_game_over(score) func on_food_eaten(): if not is_game_active: return score += 10 ui_layer.update_score(score) # 通知蛇头增加身体 snake_head.add_body_segment() # 在食物容器中生成新的食物（需要实现） food_container.spawn_food()

6.2 构建简单UI

在UI（CanvasLayer）节点下，创建几个Label节点来显示分数和游戏状态。

  1. ScoreLabel：用于显示当前分数。
  2. GameOverLabel：游戏结束时显示“Game Over”和最终分数，初始状态隐藏。
  3. 还可以添加一个Button作为开始/重新开始按钮。

为UI节点创建脚本UI.gd：

extends CanvasLayer @onready var score_label = $ScoreLabel @onready var game_over_label = $GameOverLabel @onready var restart_button = $RestartButton func _ready(): game_over_label.hide() restart_button.hide() func update_score(new_score: int): score_label.text = "Score: %d" % new_score func show_game_over(final_score: int): game_over_label.text = "Game Over!\nFinal Score: %d" % final_score game_over_label.show() restart_button.show() func _on_restart_button_pressed(): # 发送信号或直接调用GameManager的重新开始方法 get_parent().get_node("GameManager").start_game() game_over_label.hide() restart_button.hide()

6.3 信号连接与整合

现在需要将各个部分通过信号连接起来。

  1. 在SnakeHead.gd中，定义并发出信号：
    signal food_eaten signal game_over
    在_on_area_entered中，当检测到食物时，发出food_eaten信号，并queue_free()食物。 在_check_self_collision中，检测到撞到自己时，发出game_over信号。
  2. 在Main.tscn编辑器中，进行信号连接：
    • 将SnakeHead的food_eaten信号连接到GameManager的on_food_eaten方法。
    • 将SnakeHead的game_over信号连接到GameManager的end_game方法。
    • 将UI中RestartButton的pressed信号连接到UI.gd的_on_restart_button_pressed方法。
  3. 修改Food容器：创建一个FoodSpawner.gd脚本附加到Food节点上，负责管理食物实例的生成。当收到GameManager的生成食物指令或当前食物被吃后，在随机且不与蛇身重叠的位置生成一个新的食物实例。这涉及到遍历蛇头和所有身体段的位置进行比对，是一个稍微复杂的逻辑，但能保证游戏体验。

7. 功能扩展与优化思路

一个基础版本的贪吃蛇已经完成了。但我们可以让它变得更好玩、更健壮。

7.1 增加难度阶梯

让游戏随着分数增加而变快，是最简单的难度提升方式。在GameManager的on_food_eaten中：

func on_food_eaten(): score += 10 ui_layer.update_score(score) snake_head.add_body_segment() food_container.spawn_food() # 每得50分，增加一次速度 if score % 50 == 0: var timer = snake_head.get_node("MoveTimer") timer.wait_time = max(0.05, timer.wait_time - 0.01) # 加快，但设置一个下限

通过减少MoveTimer的wait_time来让蛇移动得更快。max(0.05, ...)确保速度不会无限快。

7.2 食物类型多样化

创建不同的食物预制体（如Food_Red.tscn,Food_Green.tscn），赋予它们不同的分数和特殊效果（例如，绿色食物加10分，红色食物加50分但会让蛇速暂时加快）。在FoodSpawner中随机生成不同类型的食物，并在SnakeHead的碰撞处理中根据食物类型触发不同效果。

7.3 音效与粒子效果

为吃到食物、撞到自己、游戏开始/结束等事件添加音效。Godot 中可以通过AudioStreamPlayer节点轻松实现。 在蛇头移动或吃到食物时，添加简单的粒子效果（如GPUParticles2D）可以大大增强游戏的表现力。

7.4 输入缓冲优化

我们之前实现了基础的输入缓冲（next_direction），但在高速移动下，玩家可能按下多个方向键。一个更健壮的缓冲系统是使用队列（Queue）来存储输入序列，每次移动时从队列中取出最早的有效输入作为方向。这能更精确地响应玩家的快速操作。

7.5 网格调试可视化

在开发过程中，绘制网格线对于调试位置非常有帮助。可以创建一个GridDebug.tscn场景，使用Line2D节点在_ready()中动态绘制出所有网格线，并设置为仅在开发模式下可见。

8. 常见问题与调试技巧

  1. 身体段位置错乱：这是最常见的问题。确保在更新身体位置时，传递位置的逻辑正确。使用打印语句（print）在每次移动时输出蛇头和前几节身体的位置，检查“接力棒”传递是否正确。关键点：更新顺序必须是从蛇头后面的第一节身体开始，依次向后，不能反过来。

  2. 碰撞检测失灵：

    • 检查碰撞层和掩码：确保蛇头（Area2D）和食物/身体（Area2D）的Collision Layer和Collision Mask设置正确，使得它们能够相互检测。通常保持默认即可。
    • 检查碰撞形状：确认CollisionShape2D的大小和位置覆盖了节点的视觉部分。
    • 检查信号连接：在编辑器中确认area_entered信号已正确连接到处理函数。

  3. 食物生成在蛇身上：在FoodSpawner的spawn_food函数中，生成随机位置后，需要与蛇头及所有身体段的当前位置进行比较。如果重合，则重新生成，直到找到一个空闲位置。可以使用循环来实现，但要设置一个最大尝试次数，避免死循环。

  4. 游戏卡顿或闪烁：如果蛇身很长，每帧遍历大量身体段进行位置更新和碰撞检测可能会影响性能。确保这些操作只在MoveTimer的timeout时进行，而不是在_process中。对于非常长的蛇，可以考虑使用更高效的数据结构（如队列存储位置历史）来管理身体。

  5. 穿墙逻辑的视觉跳跃：如果你发现蛇头在边界处传送时有一帧的视觉跳跃，可能是因为渲染顺序。尝试确保所有位置更新在同一个_on_move_timer_timeout函数中完成，然后再进行绘制。

  6. 使用 Godot 调试工具：

    • 远程场景树：运行游戏后，在编辑器底部点击“远程”选项卡，可以查看运行中游戏的完整节点树，检查节点是否存在、属性是否正确。
    • 调试器：在脚本中设置断点，可以逐步执行代码，查看变量状态。
    • 性能分析器：如果游戏变慢，使用 Profiler 查看是哪个函数耗时最多。

通过这个完整的贪吃蛇项目，我们实践了 Godot 2D 游戏开发的核心流程：场景组织、节点通信（信号）、物理交互（Area2D）、游戏循环控制（Timer）以及状态管理。虽然是一个小游戏，但它涵盖的模式和技巧是许多更大、更复杂项目的基础。希望你在实现的过程中，不仅能收获一个可以运行的游戏，更能深入理解 Godot 引擎的工作方式。

编程学习 学习日记 实战经验
← 返回列表