熙云的攀登之旅

谨以此，赠予若干年后的自己

Wed, 15 Jul 2026 00:00:00 GMT

本文已加密保护，请访问网站查看。

博客简单使用指南

Tue, 14 Jul 2026 00:00:00 GMT

这个博客模板是基于 Astro 构建的。对于本指南中未提及的内容，您可以在 Astro 文档中找到答案。

文章的 Front-matter#

1
---
2
title: 我的第一篇博客文章
3
published: 2023-09-09
4
description: 这是我新 Astro 博客的第一篇文章。
5
image: ./cover.jpg
6
tags: [前端, 开发]
7
category: 前端开发
8
draft: false
9
---

属性	描述
`title`	文章标题。
`published`	文章发布日期。
`updated`	文章更新日期。如果未设置，将默认使用发布日期。
`pinned`	是否将此文章置顶在文章列表顶部。
`description`	文章的简短描述。显示在首页上。
`image`	文章封面图片路径。 1. 以 `http://` 或 `https://` 开头：使用网络图片 2. 以 `/` 开头：`public` 目录中的图片 3. 不带任何前缀：相对于 markdown 文件的路径
`tags`	文章标签。
`category`	文章分类。
`lang`	文章语言代码（如 `zh-CN`）。仅当文章语言与站点默认语言不同时设置。
`licenseName`	文章内容的许可证名称。
`licenseUrl`	文章内容的许可证链接。
`author`	文章作者。
`sourceLink`	文章内容的来源链接或参考。
`draft`	如果这篇文章仍是草稿，则不会显示。
`comment`	是否启用此文章的评论功能。默认为 `true`。
`slug`	自定义文章 URL 路径。如果不设置，将使用文件名作为 URL。
`password`	文章密码。设置后文章内容将被 AES-256-GCM 加密，访客需输入密码才能查看。
`passwordHint`	密码提示。显示在密码输入框上方，帮助访客回忆密码，也可以不加。

文章文件的放置位置#

您的文章文件应放置在 src/content/posts/ 目录中。您也可以创建子目录来更好地组织您的文章和资源。

1
src/content/posts/
2
├── post-1.md
3
└── post-2/
4
    ├── cover.png
5
    └── index.md

自定义文章 URL (Slug)#

什么是 Slug？#

Slug 是文章 URL 路径的自定义部分。如果不设置 slug，系统将使用文件名作为 URL。

Slug 使用示例#

示例 1：使用文件名作为 URL#

1
---
2
title: 我的第一篇博客文章
3
published: 2023-09-09
4
---

文件：src/content/posts/my-first-blog-post.md

URL：/posts/my-first-blog-post

示例 2：自定义 Slug#

1
---
2
title: 我的第一篇博客文章
3
published: 2023-09-09
4
slug: hello-world
5
---

文件：src/content/posts/my-first-blog-post.md

URL：/posts/hello-world

示例 3：其他语言文件名使用Slug#

1
---
2
title: 如何使用 Firefly 博客主题
3
published: 2023-09-09
4
slug: how-to-use-firefly-blog-theme
5
---

文件：src/content/posts/如何使用Firefly博客主题.md

URL：/posts/how-to-use-firefly-blog-theme

Slug 使用建议#

使用英文和连字符：my-awesome-post 而不是 my awesome post
保持简洁：避免过长的 slug
具有描述性：让 URL 能够反映文章内容
避免特殊字符：只使用字母、数字和连字符
保持一致性：在整个博客中使用相似的命名模式

注意事项#

Slug 一旦设置并发布，建议不要随意更改，以免影响 SEO 和已存在的链接
如果多个文章使用相同的 slug，后面的文章会覆盖前面的
Slug 会自动转换为小写

Godot 游戏开发流程【规划篇】

Wed, 15 Jul 2026 00:00:00 GMT

Godot 游戏开发流程#

1. 项目立项#

明确游戏类型、核心玩法和目标平台。
定义项目范围，包括最低可交付版本 MVP。
确定技术方案：
- 游戏引擎：Godot
- 脚本语言：GDScript
- 资源格式：图片、音频、字体、场景文件
制定开发周期、人员分工和里程碑。
输出基础文档：
- 游戏设计文档 GDD
- 技术设计文档 TDD
- 资源规范文档
- 版本管理规范

2. 项目初始化#

创建 Godot 工程。
配置项目基本信息：
- 分辨率
- 窗口模式
- 输入映射
- 音频总线
建立目录结构，例如：
- scenes/
- scripts/
- assets/
- ui/
- audio/
- data/
配置代码风格与命名规范。
接入版本管理工具，如 Git。

3. 核心系统设计#

设计游戏架构。
拆分主要系统：
- 玩家控制
- 战斗系统
- AI 系统
- UI 系统
- 存档系统
- 关卡系统
- 音频系统
规划场景层级与节点结构。
明确脚本之间的通信方式：
- 信号 Signal
- 单例 Autoload
- 直接引用
- 事件驱动
定义数据驱动方案：
- Resource
- JSON
- ConfigFile

4. 原型开发#

快速实现核心玩法原型。
使用占位资源验证交互和节奏。
优先完成可玩闭环。
验证关键体验：
- 操作手感
- 反馈表现
- 难度曲线
- 关卡节奏
根据测试结果快速迭代。

5. 功能开发#

按模块逐步实现正式功能。
每个功能都包含：
- 需求确认
- 设计实现
- 联调测试
- 问题修复
推荐优先级：
1. 核心玩法
2. UI 与交互
3. 关卡与内容
4. 音效与表现
5. 辅助系统
在 GDScript 中保持脚本职责单一，避免单文件过度膨胀。

6. 资源制作与接入#

制作美术资源、动画资源和音频资源。
统一资源命名与导入规范。
配置动画、材质、碰撞体和 UI 资源。
使用 Godot 的导入设置优化性能与表现。
定期清理未使用资源，减少项目体积。

7. 测试与调试#

功能测试：
- 玩法逻辑是否正确
- UI 是否可用
- 存档是否可靠
性能测试：
- 帧率
- 内存占用
- 加载时间
兼容性测试：
- 分辨率适配
- 输入设备适配
- 不同平台表现
调试手段：
- print 日志
- Godot 调试器
- 性能监视器
- 场景树检查

8. 内容整合#

将关卡、UI、音效、动画和特效整合到主流程中。
完成菜单、设置、暂停、结算等基础页面。
补齐新手引导和错误处理逻辑。
校验所有流程的可达性与可返回性。

9. 性能优化#

优化脚本执行效率。
减少不必要的节点和实时计算。
合理使用对象池。
控制资源加载与卸载。
优化大地图、粒子、动画和物理计算。
根据平台限制调整画质与特效。

10. 版本管理#

使用语义化版本号。
为每次提交建立清晰说明。
按里程碑打标签。
维护变更记录：
- 新增
- 修复
- 调整
- 已知问题
发布前冻结内容并进行回归测试。

11. 发布准备#

检查构建配置。
完成平台打包。
验证启动流程、资源路径和权限设置。
准备发布说明、截图和宣传文案。
确认崩溃日志和反馈渠道可用。

12. 上线与维护#

监控运行数据和玩家反馈。
快速修复严重问题。
规划后续更新内容。
持续优化体验与性能。
维护开发文档与技术债清单。

13. Godot 开发建议#

尽量使用场景复用思路组织功能。
使用 Signal 降低模块耦合。
将全局状态集中到少量 Autoload 中。
为关键逻辑编写独立测试或验证脚本。
保持 GDScript 代码简洁、可读、可维护。
优先使用 Godot 原生能力完成大部分工作，再考虑扩展方案。

14. GDScript 编码规范示例#

1
extends CharacterBody2D
2

3
@export var move_speed: float = 200.0
4

5
func _physics_process(delta: float) -> void:
6
  var input_dir := Input.get_vector("move_left", "move_right", "move_up", "move_down")
7
  velocity = input_dir * move_speed
8
  move_and_slide()

15. 流程总结#

标准的 Godot + GDScript 游戏开发流程可以概括为：

立项
初始化工程
设计架构
制作原型
开发功能
接入资源
测试调试
内容整合
性能优化
版本管理
发布准备
上线维护

如果你需要，我可以继续把这份内容整理成更正式的 README.md 风格，或者改成适合团队协作的 GDD 模板。

Godot 游戏开发流程【代码篇】

Wed, 15 Jul 2026 00:00:00 GMT

Godot 游戏开发标准流程文档#

引擎版本：Godot 4.x
脚本语言：GDScript
适用范围：2D / 3D 独立游戏开发

1. 前期规划阶段#

1.1 游戏设计文档 (GDD)#

在开始编码前，必须完成以下文档：

文档项	说明
核心玩法定义	一句话描述游戏核心循环
目标平台	PC / Mobile / Web / Console
技术选型确认	Godot 版本、渲染器 (Forward+/Mobile/Compatibility)
功能清单 (Feature List)	必须实现 vs 可选实现的功能
关卡/场景规划	场景流程图、关卡设计草图
UI/UX 流程图	菜单结构、HUD 布局

1.2 技术预研#

确认 Godot 版本（推荐稳定版 Latest Stable）
测试目标平台性能基准
评估需要的第三方插件/工具
确定版本控制方案（Git + Git LFS 管理大型资源）

2. 项目初始化#

2.1 创建项目#

Terminal window

1
# 建议通过 Godot 项目管理器创建
2
# 或使用命令行（Godot 4.x）
3
godot --path ./my_game --editor

2.2 项目设置 (`project.godot`)#

1
; 关键配置项
2
[application]
3
config/name="MyGame"
4
config/description="游戏描述"
5
run/main_scene="res://scenes/main_menu.tscn"
6
config/features=PackedStringArray("4.2", "Forward Plus")
7
config/icon="res://icon.svg"
8

9
[display]
10
window/size/viewport_width=1920
11
window/size/viewport_height=1080
12
window/stretch/mode="canvas_items"  ; 或 "viewport"
13
window/stretch/aspect="expand"
14

15
[rendering]
16
renderer/rendering_method="forward_plus"  ; 根据平台调整
17

18
[autoload]
19
GameManager="*res://autoload/game_manager.gd"
20
AudioManager="*res://autoload/audio_manager.gd"
21
SceneManager="*res://autoload/scene_manager.gd"

展开收起

2.3 版本控制初始化#

Terminal window展开收起

1
git init
2
git lfs install
3

4
# 创建 .gitignore
5
cat > .gitignore << 'EOF'
6
# Godot
7
.import/
8
export.cfg
9
export_presets.cfg
10

11
# IDE
12
.vscode/
13
.idea/
14
*.tmp
15

16
# OS
17
.DS_Store
18
Thumbs.db
19

20
# 构建输出
21
build/
22
EOF
23

24
git add .
25
git commit -m "init: 项目初始化"

展开收起

3. 原型开发阶段#

3.1 核心循环原型 (Core Loop)#

用最简单的几何体验证玩法可行性：

1
# 玩家控制器原型 - proto_player.gd
2
extends CharacterBody2D
3

4
@export var speed: float = 400.0
5
@export var jump_velocity: float = -600.0
6
@export var gravity: float = 980.0
7

8
func _physics_process(delta: float) -> void:
9
    # 重力
10
    if not is_on_floor():
11
        velocity.y += gravity * delta
12

13
    # 输入处理
14
    var direction := Input.get_axis("ui_left", "ui_right")
15
    velocity.x = direction * speed
16

17
    if Input.is_action_just_pressed("ui_accept") and is_on_floor():
18
        velocity.y = jump_velocity
19

20
    move_and_slide()

展开收起

3.2 原型检查清单#

核心操作手感是否流畅？
游戏目标是否清晰？
单次游戏循环时长是否合理？
是否存在明显的性能瓶颈？

3.3 快速迭代原则#

灰盒测试：使用 ColorRect / MeshInstance 代替最终美术资源
参数外置：将关键数值设为 @export 变量，便于实时调试
场景独立：每个原型场景可独立运行测试

4. 核心开发阶段#

4.1 场景架构设计#

1
Main (Node)
2
├── GameManager (AutoLoad)
3
├── SceneManager (AutoLoad)
4
├── AudioManager (AutoLoad)
5
├── CurrentScene (Node)  ← 动态加载的场景根节点
6
│   ├── Level
7
│   │   ├── TileMap
8
│   │   ├── Entities
9
│   │   │   ├── Player
10
│   │   │   └── Enemies
11
│   │   └── Collectibles
12
│   ├── UI
13
│   │   ├── HUD
14
│   │   └── PauseMenu
15
│   └── Camera2D

展开收起

4.2 玩家系统开发#

1
# player.gd - 完整的玩家控制器示例
2
class_name Player
3
extends CharacterBody2D
4

5
# === 导出变量 ===
6
@export_group("Movement")
7
@export var max_speed: float = 300.0
8
@export var acceleration: float = 2000.0
9
@export var friction: float = 1500.0
10
@export var air_resistance: float = 500.0
11

12
@export_group("Jump")
13
@export var jump_force: float = -450.0
14
@export var coyote_time: float = 0.08
15
@export var jump_buffer: float = 0.1
16

17
# === 内部状态 ===
18
var _coyote_timer: float = 0.0
19
var _jump_buffer_timer: float = 0.0
20
var _is_jumping: bool = false
21

22
# === 节点引用 ===
23
@onready var _sprite: AnimatedSprite2D = $AnimatedSprite2D
24
@onready var _state_machine: StateMachine = $StateMachine
25

26
func _ready() -> void:
27
    add_to_group("player")
28

29
func _physics_process(delta: float) -> void:
30
    _handle_coyote_time(delta)
31
    _handle_jump_buffer(delta)
32
    _handle_movement(delta)
33
    _handle_jump()
34
    _update_animation()
35

36
    move_and_slide()
37

38
func _handle_movement(delta: float) -> void:
39
    var input_dir := Input.get_axis("move_left", "move_right")
40

41
    if input_dir != 0:
42
        var accel := acceleration if is_on_floor() else air_resistance
43
        velocity.x = move_toward(velocity.x, input_dir * max_speed, accel * delta)
44
        _sprite.flip_h = input_dir < 0
45
    else:
46
        var decel := friction if is_on_floor() else air_resistance
47
        velocity.x = move_toward(velocity.x, 0.0, decel * delta)
48

49
func _handle_jump() -> void:
50
    if _jump_buffer_timer > 0 and (_coyote_timer > 0 or is_on_floor()):
51
        velocity.y = jump_force
52
        _is_jumping = true
53
        _jump_buffer_timer = 0.0
54
        _coyote_timer = 0.0
55

56
    if Input.is_action_just_released("jump") and velocity.y < 0:
57
        velocity.y *= 0.5  # 短按小跳
58

59
func _handle_coyote_time(delta: float) -> void:
60
    if is_on_floor():
61
        _coyote_timer = coyote_time
62
        _is_jumping = false
63
    else:
64
        _coyote_timer -= delta
65

66
func _handle_jump_buffer(delta: float) -> void:
67
    if Input.is_action_just_pressed("jump"):
68
        _jump_buffer_timer = jump_buffer
69
    elif _jump_buffer_timer > 0:
70
        _jump_buffer_timer -= delta
71

72
func _update_animation() -> void:
73
    if not is_on_floor():
74
        _sprite.play("jump")
75
    elif abs(velocity.x) > 10:
76
        _sprite.play("run")
77
    else:
78
        _sprite.play("idle")
79

80
func take_damage(amount: int) -> void:
81
    GameManager.player_health -= amount
82
    if GameManager.player_health <= 0:
83
        _die()
84

85
func _die() -> void:
86
    GameManager.emit_signal("player_died")
87
    queue_free()

展开收起

4.3 状态机模式#

state_machine.gd展开收起

1
class_name StateMachine
2
extends Node
3

4
@export var initial_state: State
5

6
var current_state: State
7
var states: Dictionary = {}
8

9
func _ready() -> void:
10
    for child in get_children():
11
        if child is State:
12
            states[child.name.to_lower()] = child
13
            child.state_machine = self
14

15
    if initial_state:
16
        transition_to(initial_state.name)
17

18
func _process(delta: float) -> void:
19
    if current_state:
20
        current_state.update(delta)
21

22
func _physics_process(delta: float) -> void:
23
    if current_state:
24
        current_state.physics_update(delta)
25

26
func transition_to(state_name: String, msg: Dictionary = {}) -> void:
27
    if not states.has(state_name.to_lower()):
28
        push_warning("State '%s' not found" % state_name)
29
        return
30

31
    if current_state:
32
        current_state.exit()
33

34
    current_state = states[state_name.to_lower()]
35
    current_state.enter(msg)
36

37
# state.gd (基类)
38
class_name State
39
extends Node
40

41
var state_machine: StateMachine
42

43
func enter(_msg: Dictionary = {}) -> void:
44
    pass
45

46
func exit() -> void:
47
    pass
48

49
func update(_delta: float) -> void:
50
    pass
51

52
func physics_update(_delta: float) -> void:
53
    pass

展开收起

4.4 信号系统与解耦通信#

1
# game_manager.gd (AutoLoad)
2
extends Node
3

4
signal player_health_changed(new_health: int, max_health: int)
5
signal player_died
6
signal score_changed(new_score: int)
7
signal game_paused(is_paused: bool)
8

9
var player_health: int = 100:
10
    set(value):
11
        player_health = clamp(value, 0, max_health)
12
        player_health_changed.emit(player_health, max_health)
13
        if player_health <= 0:
14
            player_died.emit()
15

16
var max_health: int = 100
17
var score: int = 0:
18
    set(value):
19
        score = value
20
        score_changed.emit(score)
21

22
var is_paused: bool = false:
23
    set(value):
24
        is_paused = value
25
        get_tree().paused = is_paused
26
        game_paused.emit(is_paused)
27

28
func add_score(points: int) -> void:
29
    score += points
30

31
func pause_game() -> void:
32
    is_paused = true
33

34
func resume_game() -> void:
35
    is_paused = false

展开收起

4.5 场景切换管理#

1
# scene_manager.gd (AutoLoad)
2
extends Node
3

4
const FADE_DURATION := 0.3
5

6
@onready var _transition_rect: ColorRect = $CanvasLayer/TransitionRect
7

8
func change_scene(path: String, transition: bool = true) -> void:
9
    if transition:
10
        await _fade_out()
11

12
    get_tree().change_scene_to_file(path)
13

14
    if transition:
15
        await get_tree().process_frame
16
        _fade_in()
17

18
func _fade_out() -> void:
19
    var tween := create_tween()
20
    tween.tween_property(_transition_rect, "modulate:a", 1.0, FADE_DURATION)
21
    await tween.finished
22

23
func _fade_in() -> void:
24
    var tween := create_tween()
25
    tween.tween_property(_transition_rect, "modulate:a", 0.0, FADE_DURATION)

展开收起

5. 美术与音效集成#

5.1 资源导入规范#

资源类型	推荐格式	导入设置
2D 精灵图	PNG (无损)	Filter: Nearest (像素风) / Linear (高清)
3D 模型	GLTF 2.0 / GLB	嵌入纹理，启用压缩
音频 (音效)	WAV / OGG	短音效用 WAV，长音频用 OGG
音频 (音乐)	OGG Vorbis	流式播放 (Stream)
字体	TTF / OTF	动态字体，按需预渲染
TileSet	PNG + JSON	使用 Godot TileSet 编辑器

5.2 资源组织#

1
res://
2
├── assets/
3
│   ├── sprites/          # 2D 精灵图
4
│   ├── textures/         # 通用纹理
5
│   ├── models/           # 3D 模型
6
│   ├── animations/       # 动画资源
7
│   ├── audio/
8
│   │   ├── sfx/          # 音效
9
│   │   └── music/        # 背景音乐
10
│   ├── fonts/            # 字体文件
11
│   └── shaders/          # 自定义着色器

5.3 音频管理器#

1
# audio_manager.gd (AutoLoad)
2
extends Node
3

4
@onready var _music_player: AudioStreamPlayer = $MusicPlayer
5
@onready var _sfx_players: Node = $SFXPlayers
6

7
const MAX_SFX_PLAYERS := 8
8

9
func _ready() -> void:
10
    # 预创建 SFX 播放器池
11
    for i in MAX_SFX_PLAYERS:
12
        var player := AudioStreamPlayer.new()
13
        player.bus = "SFX"
14
        _sfx_players.add_child(player)
15

16
func play_music(stream: AudioStream, fade_duration: float = 1.0) -> void:
17
    if _music_player.playing:
18
        var tween := create_tween()
19
        tween.tween_property(_music_player, "volume_db", -80.0, fade_duration)
20
        await tween.finished
21

22
    _music_player.stream = stream
23
    _music_player.volume_db = -80.0
24
    _music_player.play()
25

26
    var tween := create_tween()
27
    tween.tween_property(_music_player, "volume_db", 0.0, fade_duration)
28

29
func play_sfx(stream: AudioStream, pitch_random: float = 0.0) -> void:
30
    var player := _get_available_sfx_player()
31
    if not player:
32
        return
33

34
    player.stream = stream
35
    if pitch_random > 0:
36
        player.pitch_scale = 1.0 + randf_range(-pitch_random, pitch_random)
37
    player.play()
38

39
func _get_available_sfx_player() -> AudioStreamPlayer:
40
    for player in _sfx_players.get_children():
41
        if not player.playing:
42
            return player
43
    return null

展开收起

6. 测试与优化阶段#

6.1 调试工具#

1
# debug_overlay.gd - 运行时调试信息
2
extends CanvasLayer
3

4
@onready var _fps_label: Label = $FPSLabel
5
@onready var _memory_label: Label = $MemoryLabel
6
@onready var _object_count_label: Label = $ObjectCountLabel
7

8
func _process(_delta: float) -> void:
9
    _fps_label.text = "FPS: %d" % Engine.get_frames_per_second()
10
    _memory_label.text = "Memory: %.1f MB" % (OS.get_static_memory_usage() / 1048576.0)
11
    _object_count_label.text = "Objects: %d" % Performance.get_monitor(Performance.OBJECT_COUNT)

6.2 性能优化检查清单#

Draw Calls：2D 使用 Sprite2D 的 z_index 合并，3D 使用 LOD
碰撞优化：使用 Layer/Mask 过滤不必要的碰撞检测
对象池：频繁创建/销毁的对象（子弹、粒子）使用对象池
纹理尺寸：最大纹理尺寸不超过目标平台限制
阴影：移动端减少阴影质量或禁用实时阴影
物理：减少每帧的物理计算，调整 Physics FPS
GDScript：避免在 _process 中进行 heavy 计算

6.3 对象池实现#

object_pool.gd展开收起

1
class_name ObjectPool
2
extends Node
3

4
@export var scene: PackedScene
5
@export var pool_size: int = 20
6

7
var _available: Array[Node] = []
8
var _in_use: Array[Node] = []
9

10
func _ready() -> void:
11
    for i in pool_size:
12
        var obj := scene.instantiate()
13
        obj.set_process(false)
14
        obj.hide()
15
        _available.append(obj)
16
        add_child(obj)
17

18
func acquire() -> Node:
19
    if _available.is_empty():
20
        return null
21

22
    var obj := _available.pop_back()
23
    obj.set_process(true)
24
    obj.show()
25
    _in_use.append(obj)
26
    return obj
27

28
func release(obj: Node) -> void:
29
    if obj in _in_use:
30
        _in_use.erase(obj)
31
        obj.set_process(false)
32
        obj.hide()
33
        _available.append(obj)
34

35
func release_all() -> void:
36
    while not _in_use.is_empty():
37
        release(_in_use[0])

展开收起

7. 发布与维护#

7.1 导出配置#

1
项目 → 导出 → 添加预设
2
├── Windows Desktop
3
│   ├── 架构: x86_64
4
│   ├── 可执行图标: res://assets/icon.ico
5
│   └── 自定义模板: (如需裁剪引擎)
6
├── macOS
7
│   ├── 应用标识符: com.yourcompany.game
8
│   └── 签名证书: (如需上架 App Store)
9
├── Android
10
│   ├── 包名: com.yourcompany.game
11
│   ├── 目标 SDK: 最新稳定版
12
│   ├── 密钥库: 创建/导入
13
│   └── 权限: 按需申请
14
└── Web
15
    ├── 导出类型: Regular
16
    └── 线程支持: (视浏览器兼容性)

展开收起

7.2 发布前检查清单#

所有场景可正常加载，无报错
输入映射完整测试（键盘、手柄、触屏）
分辨率适配测试（最小/推荐/最大）
存档系统验证
音效/音乐音量平衡
无调试代码残留（print、@tool 调试节点）
最终构建使用 Release 模板
版本号更新 (project.godot → config/version)

7.3 版本号规范#

采用语义化版本：MAJOR.MINOR.PATCH

version_manager.gd

1
const VERSION := "1.0.0"
2
const BUILD_NUMBER := 100  # CI/CD 自动递增

8. GDScript 编码规范#

8.1 命名规范#

类型	规范	示例
类名 (class_name)	PascalCase	`PlayerController`, `EnemyBase`
节点名	PascalCase	`Player`, `MainCamera`
变量/属性	snake_case	`max_speed`, `is_jumping`
常量	UPPER_SNAKE_CASE	`MAX_HEALTH`, `GRAVITY`
信号	snake_case	`health_changed`, `player_died`
函数	snake_case	`take_damage()`, `move_to()`
私有函数/变量	下划线前缀	`_calculate_damage()`
枚举	PascalCase + 大写成员	`enum State { IDLE, RUN, JUMP }`

8.2 代码格式#

1
# 类型标注（Godot 4.x 推荐）
2
var health: int = 100
3
var speed: float = 300.0
4
var target: Node2D
5

6
# 函数签名
7
func take_damage(amount: int, source: Node = null) -> void:
8
    pass
9

10
# 信号定义
11
signal health_changed(new_health: int, max_health: int)
12

13
# 枚举
14
enum State {
15
    IDLE,
16
    RUN,
17
    ATTACK,
18
    DEAD
19
}
20

21
# 数组/字典类型
22
var enemies: Array[Enemy] = []
23
var stats: Dictionary[String, int] = {}
24

25
# 常量分组
26
const MAX_SPEED: float = 500.0
27
const JUMP_FORCE: float = -450.0
28
const COYOTE_TIME: float = 0.08

展开收起

8.3 文档注释#

1
## 玩家核心控制器类
2
## 处理移动、跳跃、受伤等基础逻辑
3
class_name Player
4
extends CharacterBody2D
5

6
## 最大移动速度 (像素/秒)
7
@export var max_speed: float = 300.0
8

9
## 对玩家造成伤害
10
## [param amount]: 伤害数值
11
## [param source]: 伤害来源节点（可选）
12
func take_damage(amount: int, source: Node = null) -> void:
13
    pass

8.4 代码组织顺序#

1
extends Node
2

3
# 1. 类名与继承
4
class_name MyClass
5

6
# 2. 信号
7
signal my_signal
8

9
# 3. 枚举
10
enum MyEnum { A, B, C }
11

12
# 4. 常量
13
const MY_CONSTANT := 10
14

15
# 5. 导出变量 (按分组)
16
@export_group("Movement")
17
@export var speed: float
18

19
@export_group("Combat")
20
@export var damage: int
21

22
# 6. 普通变量
23
var _private_var: int
24

25
# 7. @onready 变量
26
@onready var _sprite: Sprite2D = $Sprite2D
27

28
# 8. 内置虚函数
29
func _ready() -> void:
30
    pass
31

32
func _process(delta: float) -> void:
33
    pass
34

35
func _physics_process(delta: float) -> void:
36
    pass
37

38
# 9. 公共函数
39
func public_function() -> void:
40
    pass
41

42
# 10. 私有函数
43
func _private_function() -> void:
44
    pass

展开收起

9. 常用 Godot 设计模式#

9.1 观察者模式（信号）#

1
# 发布者
2
signal enemy_died(position: Vector2, score_value: int)
3

4
func _on_health_depleted() -> void:
5
    enemy_died.emit(global_position, score_value)
6
    queue_free()
7

8
# 订阅者
9
func _ready() -> void:
10
    for enemy in get_tree().get_nodes_in_group("enemies"):
11
        enemy.enemy_died.connect(_on_enemy_died)
12

13
func _on_enemy_died(pos: Vector2, score: int) -> void:
14
    GameManager.add_score(score)
15
    spawn_death_effect(pos)

展开收起

9.2 单例模式（AutoLoad）#

1
# game_data.gd (AutoLoad)
2
extends Node
3

4
var player_data: PlayerData
5
var settings: GameSettings
6

7
func save_game() -> void:
8
    var save_file := FileAccess.open("user://savegame.save", FileAccess.WRITE)
9
    var data := {
10
        "player": player_data.to_dict(),
11
        "settings": settings.to_dict()
12
    }
13
    save_file.store_var(data)
14

15
func load_game() -> bool:
16
    if not FileAccess.file_exists("user://savegame.save"):
17
        return false
18
    var save_file := FileAccess.open("user://savegame.save", FileAccess.READ)
19
    var data := save_file.get_var()
20
    player_data.from_dict(data["player"])
21
    settings.from_dict(data["settings"])
22
    return true

展开收起

9.3 组件模式#

health_component.gd展开收起

1
class_name HealthComponent
2
extends Node
3

4
signal health_changed(new_health: int, max_health: int)
5
signal died
6

7
@export var max_health: int = 100
8

9
var current_health: int:
10
    set(value):
11
        current_health = clamp(value, 0, max_health)
12
        health_changed.emit(current_health, max_health)
13
        if current_health <= 0:
14
            died.emit()
15

16
func _ready() -> void:
17
    current_health = max_health
18

19
func take_damage(amount: int) -> void:
20
    current_health -= amount
21

22
func heal(amount: int) -> void:
23
    current_health += amount
24

25
# 使用方式：将 HealthComponent 作为子节点添加到任何需要血条的节点

展开收起

9.4 资源模式（数据驱动）#

weapon_data.gd

1
class_name WeaponData
2
extends Resource
3

4
@export var name: String
5
@export var damage: int
6
@export var fire_rate: float
7
@export var projectile_scene: PackedScene
8
@export var icon: Texture2D
9

10
# 创建资源文件：右键 → 新建资源 → WeaponData
11
# 可在编辑器中直接配置武器数据，无需修改代码

10. 项目目录结构规范#

1
res://
2
├── project.godot              # 项目配置文件
3
├── icon.svg                   # 项目图标
4
├── README.md                  # 项目说明
5
│
6
├── autoload/                  # 全局单例（AutoLoad）
7
│   ├── game_manager.gd
8
│   ├── audio_manager.gd
9
│   ├── scene_manager.gd
10
│   └── save_manager.gd
11
│
12
├── assets/                    # 原始资源文件
13
│   ├── sprites/
14
│   ├── textures/
15
│   ├── models/
16
│   ├── animations/
17
│   ├── audio/
18
│   │   ├── sfx/
19
│   │   └── music/
20
│   ├── fonts/
21
│   └── shaders/
22
│
23
├── resources/                 # .tres 数据资源
24
│   ├── weapons/
25
│   ├── items/
26
│   └── dialogues/
27
│
28
├── scenes/                    # 场景文件 (.tscn)
29
│   ├── levels/                # 关卡场景
30
│   ├── ui/                    # UI 场景
31
│   ├── characters/            # 角色场景
32
│   ├── enemies/               # 敌人场景
33
│   └── effects/               # 特效场景
34
│
35
├── scripts/                   # 脚本文件 (.gd)
36
│   ├── components/            # 可复用组件
37
│   ├── states/                # 状态机状态
38
│   ├── utils/                 # 工具类
39
│   └── interfaces/            # 接口/抽象类
40
│
41
├── tests/                     # 测试场景和脚本
42
│   ├── unit/
43
│   └── integration/
44
│
45
└── docs/                      # 项目文档
46
    ├── gdd.md                 # 游戏设计文档
47
    ├── api.md                 # 内部 API 文档
48
    └── changelog.md           # 更新日志

展开收起

附录#

A. 推荐 Godot 插件#

插件	用途
Godot Git Plugin	内置 Git 版本控制
Aseprite Wizard	Aseprite 动画导入
Dialogue Manager	可视化对话系统
Phantom Camera	高级相机控制
SoundManager	高级音频管理

B. 学习资源#

C. 常用快捷键#

快捷键	功能
`F5`	运行项目
`F6`	运行当前场景
`F7`	逐语句调试
`Ctrl + Shift + F`	全局搜索
`Ctrl + K`	注释/取消注释
`Ctrl + Shift + O`	快速打开文件

本文档遵循 Godot 4.x 最佳实践，根据项目实际需求可灵活调整。

熙云的攀登之旅

谨以此，赠予若干年后的自己

博客简单使用指南

文章的 Front-matter#

文章文件的放置位置#

自定义文章 URL (Slug)#

什么是 Slug？#

Slug 使用示例#

示例 1：使用文件名作为 URL#

示例 2：自定义 Slug#

示例 3：其他语言文件名使用Slug#

Slug 使用建议#

注意事项#

Godot 游戏开发流程【规划篇】

Godot 游戏开发流程#

1. 项目立项#

2. 项目初始化#

3. 核心系统设计#

4. 原型开发#

5. 功能开发#

6. 资源制作与接入#

7. 测试与调试#

8. 内容整合#

9. 性能优化#

10. 版本管理#

11. 发布准备#

12. 上线与维护#

13. Godot 开发建议#

14. GDScript 编码规范示例#

15. 流程总结#

Godot 游戏开发流程【代码篇】

Godot 游戏开发标准流程文档#

目录#

1. 前期规划阶段#

1.1 游戏设计文档 (GDD)#

1.2 技术预研#

2. 项目初始化#

2.1 创建项目#

2.2 项目设置 (project.godot)#

2.3 版本控制初始化#

3. 原型开发阶段#

3.1 核心循环原型 (Core Loop)#

3.2 原型检查清单#

3.3 快速迭代原则#

4. 核心开发阶段#

4.1 场景架构设计#

4.2 玩家系统开发#

4.3 状态机模式#

4.4 信号系统与解耦通信#

4.5 场景切换管理#

5. 美术与音效集成#

5.1 资源导入规范#

5.2 资源组织#

5.3 音频管理器#

6. 测试与优化阶段#

6.1 调试工具#

6.2 性能优化检查清单#

6.3 对象池实现#

7. 发布与维护#

7.1 导出配置#

7.2 发布前检查清单#

7.3 版本号规范#

8. GDScript 编码规范#

8.1 命名规范#

8.2 代码格式#

8.3 文档注释#

8.4 代码组织顺序#

9. 常用 Godot 设计模式#

9.1 观察者模式（信号）#

9.2 单例模式（AutoLoad）#

9.3 组件模式#

9.4 资源模式（数据驱动）#

10. 项目目录结构规范#

附录#

A. 推荐 Godot 插件#

B. 学习资源#

C. 常用快捷键#

2.2 项目设置 (`project.godot`)#