#Godot 是什么

Godot 是一个游戏引擎，支持 2D、3D、UI、动画、物理、音频等开发。
它的脚本语言最常用的是 GDScript，语法风格有点像 Python，但它不是 Python。

#一、第一眼要知道的几个核心概念

在 Godot 里，最重要的是这几个东西：

• Scene（场景）：一个功能模块，比如主菜单、玩家、敌人、关卡
• Node（节点）：场景里的组成单位，比如精灵、按钮、相机、角色
• Script（脚本）：给节点写逻辑
• Signal（信号）：事件机制，比如按钮点击、碰撞发生

你可以理解成：

• Scene = 一个组件或页面
• Node = 组件里的 DOM / 实例
• Script = JS / TS 逻辑
• Signal = 事件回调

#二、GDScript 基础语法

#1. 定义变量

复制var name = "hua"
var age = 18
var hp = 100
var speed = 200.5
var is_alive = true

也可以显式写类型：

复制var name: String = "hua"
var age: int = 18
var hp: float = 100.0
var is_alive: bool = true

也可以定义常量：

复制const MAX_HP = 100
const PLAYER_NAME = "Knight"

#2. 输出日志

复制print("Hello Godot")
print("hp =", hp)

格式化字符串：

复制var score = 100
print("score = %d" % score)

或者：

复制var name = "hua"
print("hello %s" % name)

#3. 注释

复制# 这是单行注释

#4. if 条件判断

复制var hp = 50

if hp > 80:
    print("状态很好")
elif hp > 30:
    print("状态一般")
else:
    print("状态危险")

注意：

• Godot 用 缩进 表示代码块
• 结尾有 冒号 :

#5. while 循环

复制var i = 0

while i < 5:
    print(i)
    i += 1

#6. for 循环

复制for i in range(5):
    print(i)

输出 0 到 4。

也可以指定范围：

复制for i in range(2, 6):
    print(i)

输出 2 到 5。

带步长：

复制for i in range(0, 10, 2):
    print(i)

#7. 函数定义

复制func say_hello():
    print("hello")

带参数：

复制func add(a, b):
    return a + b

带类型：

复制func add(a: int, b: int) -> int:
    return a + b

调用：

复制var result = add(2, 3)
print(result)

#三、常用数据类型

#1. 字符串 String

复制var title = "Godot"
print(title.length())
print(title.to_upper())
print(title.to_lower())

字符串拼接：

复制var name = "hua"
print("hello " + name)

#2. 数字 int / float

复制var a = 10
var b = 3.5
var c = a + b

#3. 布尔 bool

复制var is_run = true
var is_dead = false

#4. 数组 Array

复制var arr = [1, 2, 3]
print(arr[0])  # 1

常用操作：

复制arr.append(4)
arr.push_back(5)
arr.remove_at(0)
print(arr.size())

遍历：

复制for item in arr:
    print(item)

带索引遍历：

复制for i in range(arr.size()):
    print(i, arr[i])

类型数组：

复制var nums: Array[int] = [1, 2, 3]

#5. 字典 Dictionary

类似 JS 对象 / Map。

复制var player = {
    "name": "hua",
    "hp": 100,
    "level": 1
}

取值：

复制print(player["name"])
print(player["hp"])

赋值：

复制player["hp"] = 80

判断键是否存在：

复制if player.has("name"):
    print("有 name")

#6. Vector2 / Vector3

游戏开发里非常常用。

#Vector2

复制var pos = Vector2(100, 200)
var dir = Vector2(1, 0)

#Vector3

复制var pos3 = Vector3(0, 1, 2)

常见写法：

复制var a = Vector2(10, 20)
var b = Vector2(5, 5)
var c = a + b
print(c)

长度：

复制print(a.length())

归一化：

复制var dir = Vector2(3, 4).normalized()

#四、脚本挂载与节点基础

在 Godot 里，脚本一般是挂在某个节点上的。

例如：

复制extends Node2D

这表示当前脚本继承自 Node2D，所以它能操作 2D 节点的位置、旋转等。

常见继承：

复制extends Node
extends Node2D
extends CharacterBody2D
extends Control
extends Area2D

你可以理解成“当前脚本所属组件类型”。

#五、生命周期函数

Godot 里最常用的几个函数：

#1.****_ready()

节点进入场景树后执行一次。
类似初始化、mounted。

复制extends Node2D

func _ready():
    print("节点准备好了")

#2.****_process(delta)

每一帧执行一次，适合做普通刷新逻辑。

复制func _process(delta):
    print("每帧执行", delta)

delta 表示距离上一帧经过的时间。

#3.****_physics_process(delta)

物理帧执行，适合角色移动、碰撞相关。

复制func _physics_process(delta):
    print("物理帧执行")

一般角色移动优先放这里。

#4.****_input(event)

处理输入事件。

复制func _input(event):
    if event.is_action_pressed("ui_accept"):
        print("按下确认键")

#六、节点获取与操作

#1. 获取子节点

复制var sprite = $Sprite2D

这是一种快捷写法。

等价于：

复制var sprite = get_node("Sprite2D")

更深层路径：

复制var label = get_node("CanvasLayer/Label")

#2. 获取当前节点父节点

复制var parent = get_parent()

#3. 修改节点属性

比如修改位置：

复制position = Vector2(100, 200)

修改子节点位置：

复制$Sprite2D.position = Vector2(50, 50)

隐藏显示：

复制$Sprite2D.visible = false
$Sprite2D.show()
$Sprite2D.hide()

---

#4. 删除节点

复制queue_free()

删除当前节点。

删除别的节点：

复制$Enemy.queue_free()

#七、输入系统

Godot 推荐通过 Input Map 配置按键，而不是写死键盘码。

比如你在项目设置里配置：

• move_left
• move_right
• jump

然后脚本里这样写：

复制func _process(delta):
    if Input.is_action_pressed("move_left"):
        print("向左")
    
    if Input.is_action_pressed("move_right"):
        print("向右")

按下一次：

复制if Input.is_action_just_pressed("jump"):
    print("刚按下跳跃")

刚松开：

复制if Input.is_action_just_released("jump"):
    print("刚松开")

#八、一个最简单的角色移动例子

这是 Godot 入门一定会写的。

复制extends CharacterBody2D

var speed = 200.0

func _physics_process(delta):
    var direction = Vector2.ZERO

    if Input.is_action_pressed("move_left"):
        direction.x -= 1
    if Input.is_action_pressed("move_right"):
        direction.x += 1
    if Input.is_action_pressed("move_up"):
        direction.y -= 1
    if Input.is_action_pressed("move_down"):
        direction.y += 1

    direction = direction.normalized()
    velocity = direction * speed
    move_and_slide()

这里重点理解：

• direction：输入方向
• normalized()：防止斜向移动更快
• velocity：角色速度
• move_and_slide()：让角色移动并处理碰撞

#九、信号 Signal

信号就是 Godot 的事件系统。

比如按钮点击：

复制func _on_button_pressed():
    print("按钮被点击了")

这个函数一般是通过编辑器连接信号自动生成的。

也可以自己定义信号：

复制signal hp_changed(new_hp)

触发信号：

复制emit_signal("hp_changed", 80)

Godot 4 也常写成：

复制hp_changed.emit(80)

连接信号：

复制func _ready():
    hp_changed.connect(_on_hp_changed)

func _on_hp_changed(new_hp):
    print("hp 更新为", new_hp)

这个机制非常重要，后面 UI 更新、怪物死亡、任务系统都会用到。

#十、预加载与实例化场景

游戏里经常需要动态生成对象，比如子弹、敌人。

#1. preload

复制const BulletScene = preload("res://scenes/bullet.tscn")

提前加载资源。

#2. 实例化

复制var bullet = BulletScene.instantiate()
add_child(bullet)

设置位置：

复制bullet.position = position

完整例子：

复制extends Node2D

const BulletScene = preload("res://bullet.tscn")

func shoot():
    var bullet = BulletScene.instantiate()
    bullet.position = position
    get_parent().add_child(bullet)

#十一、类与面向对象基础

GDScript 支持类。

#1. class_name

复制extends Node
class_name Player

这样这个脚本会注册成一个全局类，别的地方可以直接用 Player。

#2. 成员变量和函数

复制extends Node
class_name Player

var hp = 100

func take_damage(value):
    hp -= value

---

#3.****_init()

构造

复制func _init():
    print("对象初始化")

带参数：

复制func _init(name: String, hp: int):
    self.name = name
    self.hp = hp

不过在场景节点开发里，更多还是依赖节点实例，而不是手动 new 很多类。

#十二、导出变量

@export

这个非常重要。
它可以让变量显示在编辑器里，方便调参。

复制@export var speed: float = 200.0
@export var hp: int = 100

这样你在编辑器选中节点时，就能直接改 speed 和 hp。

还可以导出节点引用、资源等。

例如范围：

复制@export_range(0, 1000, 10) var move_speed = 200

#十三、onready

有些节点要等场景准备好后才能拿到，常配合 @onready 使用。

复制@onready var sprite = $Sprite2D
@onready var label = $CanvasLayer/Label

这样 _ready() 前就能安全拿到引用。

例如：

复制extends Node2D

@onready var sprite = $Sprite2D

func _ready():
    sprite.rotation = 1.0

#十四、常见判断与语法糖

#1. 三元表达式

复制var result = "大于10" if score > 10 else "小于等于10"

#2. 判空

复制if target != null:
    print("有目标")

#3. 逻辑运算

复制if hp > 0 and is_alive:
    print("还能行动")

if hp <= 0 or not is_alive:
    print("已经不能行动")

#十五、常用内置函数

#1. 随机数

Godot 4 一般这样：

复制var num = randi()
var f = randf()

范围随机：

复制var n = randi_range(1, 10)
var f = randf_range(0.0, 1.0)

#2. 取绝对值、夹紧

复制var a = abs(-10)
var b = clamp(150, 0, 100)

#3. 类型转换

复制var a = int(3.8)
var b = float(10)
var c = str(123)

#十六、数组和字典的实战例子

#1. 背包数组

复制var items = ["sword", "shield", "potion"]

func add_item(item_name: String):
    items.append(item_name)

#2. 玩家属性字典

复制var player_data = {
    "name": "hero",
    "hp": 100,
    "mp": 50
}

func take_damage(damage: int):
    player_data["hp"] -= damage
    print(player_data["hp"])

#十七、一个完整入门示例

下面给你一个比较像正式项目的入门写法：

复制extends CharacterBody2D

@export var speed: float = 200.0
@export var max_hp: int = 100

var hp: int = 100

@onready var sprite = $Sprite2D
@onready var hp_label = $CanvasLayer/HpLabel

func _ready():
    hp = max_hp
    update_hp_ui()

func _physics_process(delta):
    var direction = Vector2.ZERO

    if Input.is_action_pressed("move_left"):
        direction.x -= 1
    if Input.is_action_pressed("move_right"):
        direction.x += 1
    if Input.is_action_pressed("move_up"):
        direction.y -= 1
    if Input.is_action_pressed("move_down"):
        direction.y += 1

    direction = direction.normalized()
    velocity = direction * speed
    move_and_slide()

func take_damage(value: int):
    hp -= value
    hp = clamp(hp, 0, max_hp)
    update_hp_ui()

    if hp <= 0:
        die()

func update_hp_ui():
    hp_label.text = "HP: %d" % hp

func die():
    print("角色死亡")
    queue_free()

这个脚本里面已经包含了：

• 导出变量
• onready 获取节点
• _ready
• _physics_process
• 输入控制
• UI 更新
• 血量处理
• 销毁节点

你看懂这个，就已经能开始做一个非常基础的小项目了。

#十八、Godot 新手最容易犯的错误

#1. 忘了缩进

GDScript 和 Python 一样很依赖缩进。

错误：

复制if true:
print("hello")

正确：

复制if true:
    print("hello")

#2. 节点路径写错

复制$Sprite2D

前提是场景里真的有这个节点名。

#3. 在**_process**里做物理移动

角色移动一般建议放在：

复制func _physics_process(delta):

而不是 _process。

#4. 没有在 Input Map 配置动作

你代码里写：

复制Input.is_action_pressed("jump")

但是项目设置里没加 jump，就不会生效。

#5. 把 GDScript 当 Python 用

它像 Python，但不是 Python。
有些语法类似，但 Godot 的 API、装饰器、节点系统都是自己的。