

信号（Signal）是Godot引擎中最强大、最重要的机制之一，它实现了观察者模式，让节点之间可以松耦合地通信。本教程将通过实际案例，带你全面掌握Godot中的信号使用方法。

<iframe src="//player.bilibili.com/player.html?isOutside=true&aid=115737960125604&bvid=BV1tsqJBtEee&cid=34808792710&p=1" scrolling="no" border="0" frameborder="no" framespacing="0" allowfullscreen="true" width="640" height="480"></iframe>

## 什么是信号？

信号是一种事件通知机制。当一个节点发生某些事情时（比如按钮被点击、分数改变、动画播放完成等），它可以发出一个信号，其他节点可以"监听"这个信号，并在信号发出时执行相应的代码。

**信号的核心优势：**
- **解耦**：节点之间不需要直接引用，降低代码耦合度
- **灵活**：一个信号可以被多个节点监听
- **清晰**：代码结构更清晰，易于维护

---

## 一、内置信号的使用

Godot的许多节点都内置了信号，比如`Button`节点就有`pressed`信号。

### 1.1 场景结构

我们的`main.tscn`场景包含：
- 一个`Button`节点（按钮）
- 一个`Label`节点（标签），绑定`label.gd`脚本

![signal](https://www.suiyan.cc/assets/images/2025/signal/01.png)

### 1.2 在编辑器中连接信号

![signal](https://www.suiyan.cc/assets/images/2025/signal/02.png)

选中button后，在节点面板中设置信号

这表示：当`Button`的`pressed`信号发出时，调用`Label`节点的`_on_button_pressed`方法。

### 1.3 编写响应函数

在`label.gd`中，我们定义了响应函数：

```gdscript
extends Label

func _on_button_pressed() -> void:
    # 这里就是按钮点后会执行代码的地方
    self.text = "按钮被点击啦！！！！！"
```

**运行效果：**
- 点击按钮
- `Button`发出`pressed`信号
- `Label`的`_on_button_pressed`函数被调用
- 标签文本更新为"按钮被点击啦！！！！！"

![signal](https://www.suiyan.cc/assets/images/2025/signal/03.png)
---

## 二、自定义信号

除了内置信号，我们还可以创建自己的信号，用于传递自定义事件。

### 2.1 声明自定义信号

在`score_manager.gd`中，我们声明了一个带参数的信号：

```gdscript
extends Node

# 声明一个带参数的自定义信号，参数类型是整数 (int)
signal score_updated(new_score: int)

var current_score = 0
```

### 2.2 发出信号

当分数改变时，我们发出信号并传递新的分数值：

```gdscript
func increase_score(points: int):
    current_score += points
    # 当分数改变时，发出信号，并附带新的分数值
    emit_signal("score_updated", current_score)
```

这里使用了`emit_signal()`函数，第一个参数是信号名称，后面是传递给信号的参数。

> **注意**：在Godot 4中，你也可以直接使用信号名称来发出信号：
> ```gdscript
> score_updated.emit(current_score)
> ```

### 2.3 连接自定义信号

在`score_label.gd`中，我们连接到这个信号：

```gdscript
extends Label
@onready var score_manager: Node2D = $".." #连接到场景中的根节点ScoreManager

func _ready():
    # 在 _ready 函数中连接信号
    # 当 score_manager 发出 score_updated 信号时，执行 _on_score_manager_score_updated
    score_manager.score_updated.connect(_on_score_manager_score_updated)

# 这是我们响应信号的函数
func _on_score_manager_score_updated(new_score: int):
    # 更新 Label 的文本，显示新的分数
    self.text = "Score: " + str(new_score)
```

**关键点解析：**
- `@onready`：延迟初始化，确保节点树已经构建完成
- `connect()`：连接信号的方法
- 响应函数的参数必须与信号声明的参数一致

### 2.4 测试信号

在`score_manager.gd`的`_ready`函数中，我们测试信号：

```gdscript
func _ready() -> void:
    increase_score(10) # ScoreLabel 显示 Score: 10
    await get_tree().create_timer(2.0).timeout  # 等待2秒
    increase_score(5)  # ScoreLabel 显示 Score: 15
    await get_tree().create_timer(2.0).timeout  # 等待2秒
    increase_score(5)  # ScoreLabel 显示 Score: 20
```

**运行效果：**
- 场景加载后，分数立即变为10
- 等待2秒后，分数变为15
- 再等待2秒后，分数变为20

---

## 三、信号的两种连接方式

### 3.1 在编辑器中连接（可视化方式）

**步骤：**
1. 选择要发出信号的节点（如Button）
2. 在右侧"节点"面板中，找到"信号"选项卡
3. 双击要连接的信号（如pressed）
4. 选择接收信号的节点和方法
5. Godot会自动生成响应函数的框架代码

**优点：**
- 可视化操作，直观易懂
- 不需要写连接代码
- 适合简单的信号连接

### 3.2 在代码中连接（编程方式）

```gdscript
score_manager.score_updated.connect(_on_score_manager_score_updated)
```

**优点：**
- 更灵活，可以在运行时动态连接
- 可以传递额外的参数
- 适合复杂的信号连接

---

## 四、信号的高级用法

### 4.1 断开信号连接

如果不再需要监听某个信号，可以断开连接：

```gdscript
score_manager.score_updated.disconnect(_on_score_manager_score_updated)
```

### 4.2 一次性信号

使用`call_deferred`可以让信号只触发一次：

```gdscript
button.pressed.connect(_on_button_pressed, CONNECT_ONE_SHOT)
```

### 4.3 信号带多个参数

信号可以传递多个参数：

```gdscript
signal player_died(player_name: String, score: int, cause: String)

emit_signal("player_died", "Player1", 100, "Enemy")
```

### 4.4 检查信号是否已连接

```gdscript
if score_manager.score_updated.is_connected(_on_score_manager_score_updated):
    print("信号已连接")
```

---

## 五、最佳实践

### 5.1 命名规范

- 信号名称使用动词形式：`score_updated`、`player_died`、`game_over`
- 响应函数命名：`_on_节点名_信号名`，如`_on_button_pressed`

### 5.2 什么时候使用信号？

**适合使用信号的场景：**
- UI交互（按钮点击、输入框变化）
- 游戏状态变化（分数更新、生命值改变）
- 动画事件（动画播放完成、帧事件）
- 碰撞检测（进入/退出碰撞区域）

**不适合使用信号的场景：**
- 需要返回值的操作
- 高频调用的每帧逻辑（使用`_process`或`_physics_process`）

### 5.3 性能考虑

信号连接本身开销很小，但要注意：
- 避免在`_process`中频繁连接/断开信号
- 大量信号监听者可能影响性能

---

## 六、总结

通过本教程，我们学习了：

1. **内置信号**：使用Godot预定义的信号（如Button的pressed）
2. **自定义信号**：创建和发出自己的信号
3. **信号连接**：在编辑器和代码中连接信号
4. **信号参数**：传递数据给信号监听者
5. **高级用法**：断开连接、一次性信号、多参数信号

**信号是Godot开发中的核心概念，掌握它将让你的代码更加模块化、可维护。**

---

## 项目文件说明

本教程项目包含以下文件：

- `main.tscn`：演示内置信号（Button pressed）
- `label.gd`：响应按钮点击信号
- `score_manager.tscn`：演示自定义信号
- `score_manager.gd`：定义和发出自定义信号
- `score_label.gd`：监听并响应自定义信号

---

**祝你在Godot开发之路上越走越远！** 🚀


信号（Signal）是Godot引擎中最强大、最重要的机制之一，它实现了观察者模式，让节点之间可以松耦合地通信。本教程将通过实际案例，带你全面掌握Godot中的信号使用方法。

Godot 4 信号（Signal）的使用入门


Godot4中的整除和python的不同，容易在使用中造成麻烦，这里记录一下，也方便遇到这类问题的朋友了解一下。


python代码：
    print(5 // 2) # 结果是2

但是，如果在Godot中运行这个代码就会报错：Expected expression after "/" operator.


正确的Godot整除代码是：

    print(5 / 2) # 2
    print(5.0 / 2) # 2.5

也就是说Godot中：两个操作数都是整数时执行整数除法。如果至少有一个是浮点数，就会返回浮点值。


Godot4中的整除和python的不同，容易在使用中造成麻烦，这里记录一下，也方便遇到这类问题的朋友了解一下。

Godot4中的整除报错:Expected expression after "/" operator.


Godot4 学习资源教程推荐，都是自己收藏并学习过的，少走弯路加速你的游戏进度。


## 教程

Godot Engine 4.5 简体中文文档
https://docs.godotengine.org/zh-cn/4.x/



【精品熟肉】想在2024年做游戏？跟着Brackeys来学Godot引擎吧！
https://www.bilibili.com/video/BV17Z421J7uF

转载自YouTube的Brackeys频道：https://www.youtube.com/watch?v=LOhfqjmasi0

项目所需素材：https://brackeysgames.itch.io/brackeys-platformer-bundle


点评：入门Godot绝对不错的一个教程，简单实用，几乎囊括了入门的所有知识点。


做出你的第一个Godot 2D游戏！
https://merxon22.github.io/GodotArchive/zh/posts/beginner_2d/

点评：码客二十二，我就是看他的教程入门的Godot，简单，通俗易懂的全中文视频教程


一些Godot教程的总结
https://ai.feishu.cn/wiki/CQMPwbWtyikKgFkZSmycuWQNnJe?fromScene=spaceOverview

点评：很用心的笔记类型教程，适合看视频犯困的朋友。


游戏编程模式
https://gameprogrammingpatterns.com/contents.html

点评：深入游戏的高级编程之地，了解游戏编程模式



godot2D地图编辑教程：瓦片地图 平台 物理吊桥 脚本化生成
https://www.bilibili.com/video/BV1np3dzNEAw

点评：对于万片地图的应用讲解的很详细，UP主很有才华。

【中文语音】Godot4终极入门教程
https://www.bilibili.com/BV1pu4y1b7p6

点评：搬运油管的教程，质量不错，适合入门。


Godot 4 ARPG游戏教程
https://www.bilibili.com/BV1AJuozuEbq

点评：搬运油管的教程，质量不错，循序渐进，内容充实比较多。


【中文语音】在Godot4中创建一个有限状态机（FSM）

https://www.bilibili.com/BV1xy4y1c72y

## 资源

一些游戏素材资源音效下载站点：

https://kenney.nl/


https://opengameart.org/


https://itch.io/game-assets


https://pixlab24.com/



## 开源

这是一份不同开源视频游戏和商业视频游戏开源重制版的列表。

https://github.com/bobeff/open-source-games


Godot提供的一些案例

https://godotengine.org/asset-library/asset




Godot4 学习资源教程推荐，都是自己收藏并学习过的，少走弯路加速你的游戏进度。

Godot4 学习资源教程推荐

## 为什么要使用状态机？

在游戏开发中，角色的行为（如站立、行走、跳跃、攻击）通常需要复杂的逻辑来控制。如果不使用状态机，代码会充斥着大量的 if/else 或 match 语句，导致代码难以阅读、维护和扩展，这就是所谓的“意大利面条式代码”。例如下边的代码：

    # constants.gd (假设我们有一个全局脚本或内部枚举来定义状态)
    enum PlayerState {
        IDLE,
        MOVE,
        JUMP,
        ATTACK
    }

    # Player.gd 脚本 (所有逻辑集中于此)
    extends CharacterBody2D

    # 运动和重力常量...
    const SPEED = 300.0
    const JUMP_VELOCITY = -500.0
    var gravity = ProjectSettings.get_setting("physics/2d/default_gravity")

    # 追踪当前状态的核心变量
    var current_state: int = PlayerState.IDLE
    # 追踪攻击是否完成
    var is_attack_finished: bool = true
    # 追踪动画播放器
    @onready var animated_sprite = $AnimatedSprite2D 

    func _physics_process(delta):
        # 1. 应用重力 (这部分是通用的，但需要注意JUMP状态下的特殊处理)
        if not is_on_floor():
            velocity.y += gravity * delta

        # 2. 处理攻击完成后的状态清理 (相当于 Attack.gd 的 _exit 逻辑)
        if current_state == PlayerState.ATTACK and is_attack_finished:
            # 攻击完成后，根据是否还在移动来决定回到 IDLE 还是 MOVE
            var input_direction = Input.get_axis("move_left", "move_right")
            if input_direction != 0:
                current_state = PlayerState.MOVE
                # 播放动画 "Move" (重复的动画逻辑)
            else:
                current_state = PlayerState.IDLE
                # 播放动画 "Idle" (重复的动画逻辑)
            is_attack_finished = false # 重置，避免频繁切换 (这里逻辑可能更复杂)
            
        # --- 主状态判断逻辑 (巨大的 if/else 块) ---
        
        # === IDLE 状态逻辑 (对应 Idle.gd) ===
        if current_state == PlayerState.IDLE:
            # 动画播放逻辑 (相当于 _enter)
            animated_sprite.play("Idle")
            
            # 检查转换条件
            if Input.is_action_just_pressed("attack"):
                current_state = PlayerState.ATTACK
                # 转换后的 _enter 逻辑
                animated_sprite.play("Attack")
                is_attack_finished = false
                
            elif Input.is_action_just_pressed("jump") and is_on_floor():
                current_state = PlayerState.JUMP
                # 转换后的 _enter 逻辑
                animated_sprite.play("Jump")
                velocity.y = JUMP_VELOCITY
                
            elif Input.get_axis("move_left", "move_right") != 0:
                current_state = PlayerState.MOVE
                # 转换后的 _enter 逻辑
                animated_sprite.play("Move")

        # === MOVE 状态逻辑 (对应 Move.gd) ===
        elif current_state == PlayerState.MOVE:
            # 动画播放逻辑 (相当于 _enter)
            animated_sprite.play("Move")
            
            # 1. 移动处理 (_physics_update)
            var direction = Input.get_axis("move_left", "move_right")
            velocity.x = direction * SPEED
            
            # 2. 检查转换条件
            if Input.is_action_just_pressed("attack"):
                current_state = PlayerState.ATTACK
                animated_sprite.play("Attack")
                is_attack_finished = false
                
            elif Input.is_action_just_pressed("jump") and is_on_floor():
                current_state = PlayerState.JUMP
                animated_sprite.play("Jump")
                velocity.y = JUMP_VELOCITY
                
            elif direction == 0:
                current_state = PlayerState.IDLE
                # 转换后的 _enter 逻辑 (可以省略动画播放，因为 IDLE 状态会处理)

        # === JUMP 状态逻辑 (对应 Jump.gd) ===
        elif current_state == PlayerState.JUMP:
            # JUMP 状态下的移动处理
            var direction = Input.get_axis("move_left", "move_right")
            velocity.x = direction * SPEED * 0.7 # 跳跃时速度减慢
            
            # 检查转换条件 (落地)
            if is_on_floor():
                var input_direction = Input.get_axis("move_left", "move_right")
                if input_direction != 0:
                    current_state = PlayerState.MOVE
                else:
                    current_state = PlayerState.IDLE
                # JUMP 状态的 _exit 逻辑被省略了，因为它和新状态的 _enter 混合在了一起
                
            # 检查转换条件 (空中攻击)
            if Input.is_action_just_pressed("attack"):
                current_state = PlayerState.ATTACK
                # ... (重复的 Attack 转换逻辑)

        # === ATTACK 状态逻辑 (对应 Attack.gd) ===
        elif current_state == PlayerState.ATTACK:
            # ATTACK 状态下不能接收移动或跳跃输入
            velocity.x = 0
            
            # 攻击动画的自动完成逻辑 (需要一个信号或计时器来设置 is_attack_finished = true)
            # 假设这里有一个处理攻击动画进度的逻辑
            pass # 等待 is_attack_finished 变为 true

        # 3. 最终移动
        move_and_slide()

有限状态机（FSM）提供了一种优雅的解决方案。它将角色的每一个行为定义为一个状态（State），并清晰地定义了状态之间的转换（Transition）规则。本教程将基于 godotfsmtest 项目的代码结构，向您展示如何在 Godot 4.4 中实现一个结构清晰、基于类的 FSM。

## 项目结构

![项目结构](https://www.suiyan.cc/assets/images/2025/QQ20251114-110111.png)

前期准备：Godot4.4 以上的版本，熟悉 GDScript的基本语法、类、类的继承和信号量（Signal）的使用，熟悉场景中的角色添加以及动画的添加，如果这些内容有不熟悉的，查看下边的代码可能会有些迷糊。

状态机的含义简单来说就控制动画来展示是角色所处的状态，例如空闲、行走、跳跃和攻击等。场景中的`AnimatedSprite2D`定义了角色的状态动画。

![角色的状态动画](https://www.suiyan.cc/assets/images/2025/QQ20251114-111006.png)

## 状态机类 State

创建State基类，后续的状态都会继承这个State，通过状态机和信号量来管理当前的状态，例如状态之间的切换。

代码如下：

    # State.gd
    class_name State 
    extends Node

    # 信号：用于通知状态机进行状态转换
    signal transitioned(state_name, new_state_name)

    # 对拥有这个状态机的角色的引用（例如：Player）
    var actor: CharacterBody2D
    var anim_sprite: AnimatedSprite2D

    # 1. 状态被进入时调用
    func enter() -> void:
        pass

    # 2. 状态被退出时调用
    func exit() -> void:
        pass

    # 3. 在 _process (每帧) 中调用
    func update(delta: float) -> void:
        pass

    # 4. 在 _physics_process (物理帧) 中调用
    func physics_update(delta: float) -> void:
        pass



### 状态机类

 State : 状态机基类 

### 方法

![方法](https://www.suiyan.cc/assets/images/2025/QQ20251116-104744.png)

### 信号

![信号](https://www.suiyan.cc/assets/images/2025/QQ20251116-104744.png)

## 状态机管理器

状态机管理器负责管理当前状态、存储所有状态，以及处理状态间的转换。代码如下：

    # StateMachine.gd
    class_name StateMachine extends Node

    # 导出变量：允许在编辑器中设置初始状态
    @export var initial_state_name: State
    var states: Dictionary = {}
    @onready var current_state: State = null
    @export var actor: CharacterBody2D # 引用拥有者
    @export var anim_sprite: AnimatedSprite2D #引用动画

    func _ready() -> void:
        # 收集所有子节点（即所有具体状态）
        for child in get_children():
            if child is State:
                var state = child as State
                child.anim_sprite = self.anim_sprite
                # 将状态添加到字典中，键为节点名
                states[state.name] = state
                state.actor = actor # 传递角色引用
                state.transitioned.connect(on_state_transition)

        # 检查并进入初始状态
        if initial_state_name:
            change_state(initial_state_name)
        else:
            printerr("Error: Initial state not set or not found.")

    # 转换状态的核心函数
    func change_state(new_state: State) -> void:
        # 1. 退出旧状态
        if current_state:
            current_state.exit()  
        # 2. 设置新状态
        current_state = new_state
        # 3. 进入新状态
        current_state.enter()

    # 信号处理函数
    func on_state_transition(state_name: String, new_state_name: String) -> void:
        # 确保是当前状态发出的转换请求
        if current_state and current_state.name == state_name:
            change_state(states[new_state_name])

    func _process(delta: float) -> void:
        if current_state:
            current_state.update(delta)

    func _physics_process(delta: float) -> void:
        if current_state:
            current_state.physics_update(delta)


## 在角色中集成状态机管理器

    # Player.gd (附加到 CharacterBody2D 节点)

    class_name Player 
    extends CharacterBody2D

    # 引用状态机节点
    @onready var state_machine: StateMachine = $StateMachine
    @onready var anim_sprite: AnimatedSprite2D = $AnimatedSprite2D
    func _ready() -> void:
        # 将自身的引用传递给状态机，以便状态可以控制角色
        state_machine.actor = self
        state_machine._ready() # 确保状态机初始化
        
    # 注意：现在 _physics_process 由状态机和当前状态来管理，
    # Player 脚本本身不再直接处理复杂的运动逻辑。
    func _physics_process(delta: float) -> void:
        state_machine._physics_process(delta)

    func _process(delta: float) -> void:
        state_machine._process(delta)


绑定状态机管理器，以及动画节点等相关的节点。


## 创建具体的状态

Idle 角色的空闲状态，

    # Idle.gd (附加到 Idle 节点, 继承 State.gd)

    class_name Idle 
    extends State

    #新增：定义跳跃速度常量
    const JUMP_VELOCITY = -450.0 # 负值表示向上运动
    # Godot 4 默认重力加速度（方便计算）
    var gravity = ProjectSettings.get_setting("physics/2d/default_gravity")

    func enter() -> void:
        # 在进入空闲状态时，确保移动速度为0
        actor.velocity.x = 0
        # 播放 Idle 动画 (假设 actor 有一个 AnimationPlayer 节点)
        anim_sprite.play("idle")

    func physics_update(delta: float) -> void:
        var direction = Input.get_axis("move_left", "move_right")
        # 1. 如果有移动输入，转换到 Move 状态
        if direction != 0:
            transitioned.emit(name, "Move")
            return
            
        # 2. 如果有跳跃输入，转换到 Jump 状态
        if Input.is_action_just_pressed("jump"):
            
            # ⚠️ 关键修正：在转换之前，赋予角色向上的速度
            actor.velocity.y = JUMP_VELOCITY 
            
            transitioned.emit(name, "Jump")
            return
        # 3. 攻击
        if Input.is_action_just_pressed("attack"):
            transitioned.emit(name,"Attack")
            return  
        # 3. 在 Idle 状态下保持重力和移动
        # 仅施加重力（如果角色站在一个活动的平台上，或者检测到不再贴地）
        if not actor.is_on_floor():
            # 这里应该转换到 Fall 状态，但如果只是施加重力，确保使用正确的重力值
            actor.velocity.y += gravity * delta # 使用常量 gravity 更准确
            # 注意：如果角色还在 Idle 状态且 velocity.y > 0，它应该转换到 Fall 状态  
        actor.move_and_slide()

enter()函数中触发当前状态的相关的动画、声音等。

在转态进行时进行判断，transitioned.emit(name, "Jump")发出信号进行状态的切换。

## 总结

通过 FSM，我们成功地将复杂的角色逻辑解耦：

Player.gd 只需要知道它有一个状态机。
StateMachine.gd 负责切换状态。
Idle.gd, Move.gd 等状态脚本只负责各自状态下的具体行为和转换检查。

完整的案例代码仓库：

[案例代码仓库 github](https://github.com/bosichong/godotfsmtest)


[案例代码仓库 国内镜像gitee](https://gitee.com/J_Sky/godotfsmtest)

在游戏开发中，角色的行为（如站立、行走、跳跃、攻击）通常需要复杂的逻辑来控制。如果不使用状态机，代码会充斥着大量的 if/else 或 match 语句，导致代码难以阅读、维护和扩展，这就是所谓的“意大利面条式代码”。有限状态机（FSM）提供了一种优雅的解决方案。它将角色的每一个行为定义为一个状态（...

在 Godot 4.4 中构建灵活的有限状态机 (FSM)


## 为什么选择 Tween？

Godot 4 带来的全新 Tween 系统，摒弃了传统的节点式操作，改用全代码驱动，更加简洁且强大。

Tween：适合程序化、动态的 UI 反馈、物品掉落、数值平滑变化（纯代码控制）。

## 核心语法

创建一个最基本的平移动画：


    var tween = create_tween()
    tween.tween_property($Sprite2D, "position", Vector2(600, 300), 1.0)


只需两行，对象就会在 1 秒内平滑移动到目标位置。


## 让动画有灵魂：Transition 与 Ease

1. set_trans()：过渡类型 (TransitionType) 这是最核心的参数，决定了动画的“性格”。

| 枚举常量 (Tween.TransitionType) | 动画效果描述                     | 最佳用途                         |
|-------------------------------|----------------------------------|----------------------------------|
| `TRANS_LINEAR`                | 匀速。没有任何加减速。           | 简单的旋转、血条数值变化。       |
| `TRANS_SINE`                  | 正弦。非常柔和的加速减速。       | 缓慢漂浮、呼吸灯效果。           |
| `TRANS_QUAD`                  | 二次方。基础的加减速。           | 最常用的平滑移动。               |
| `TRANS_CUBIC`                 | 三次方。比 Quad 更明显的加减速。 | 强调动作起伏。                   |
| `TRANS_QUART`                 | 四次方。加速感更强。             | 快速切入/切出。                  |
| `TRANS_EXPO`                  | 指数级。极端的加减速。           | 闪电般的瞬间移动。               |
| `TRANS_ELASTIC`               | 弹性。像皮筋拉伸后的回弹。       | Q弹的按钮、果冻物体。            |
| `TRANS_BOUNCE`                | 反弹。像球落地后的弹跳。         | 物理掉落效果、菜单撞击边缘。     |
| `TRANS_BACK`                  | 回退。先往后拉一点再冲出去。     | 蓄力感的动作、浮窗弹出。         |
| `TRANS_SPRING`                | 弹簧。真实的物理弹簧震荡。       | Godot 4 新增，比 Elastic 更自然。|

2. set_ease()：缓动模式 (EaseType)这个参数决定了上面选定的曲线如何应用在时间轴上。

| 枚举常量 (Tween.EaseType) | 逻辑描述           | 视觉表现                                      |
|--------------------------|--------------------|-----------------------------------------------|
| `EASE_IN`                | 入场加速。         | 动画开始时很慢，然后加速。常用于离开屏幕。     |
| `EASE_OUT`               | 出场减速。         | 动画开始时很快，快结束时减慢。UI 动画最常用。 |
| `EASE_IN_OUT`            | 两头慢中间快。     | 开始和结束都有缓冲。适合循环往复的动作。       |
| `EASE_OUT_IN`            | 两头快中间慢。     | 较少使用。                                    |


3. 黄金组合建议 如果你不知道该选什么，可以尝试这些经过验证的经典组合：

* 自然的 UI 弹出： set_trans(Tween.TRANS_BACK).set_ease(Tween.EASE_OUT)

* 丝滑的淡入淡出： set_trans(Tween.TRANS_SINE).set_ease(Tween.EASE_IN_OUT)

* 有打击感的移动： set_trans(Tween.TRANS_QUART).set_ease(Tween.EASE_OUT)

* 极度夸张的点击反馈： set_trans(Tween.TRANS_ELASTIC).set_ease(Tween.EASE_OUT)


## 动态演示

你可以将下面的脚本挂载到一个空的 Node2D 场景中。运行后，它会生成一排图标，演示各种常见的 Tween 曲线。

    extends Node2D

    # 使用 Godot 的默认图标作为演示物体
    var icon_texture = preload("res://icon.svg")

    # 定义我们要演示的配置组合
    var setups = [
        {"name": "Linear", "trans": Tween.TRANS_LINEAR, "ease": Tween.EASE_IN_OUT},
        {"name": "Sine Out", "trans": Tween.TRANS_SINE, "ease": Tween.EASE_OUT},
        {"name": "Back Out", "trans": Tween.TRANS_BACK, "ease": Tween.EASE_OUT},
        {"name": "Bounce Out", "trans": Tween.TRANS_BOUNCE, "ease": Tween.EASE_OUT},
        {"name": "Elastic Out", "trans": Tween.TRANS_ELASTIC, "ease": Tween.EASE_OUT},
        {"name": "Quint In", "trans": Tween.TRANS_QUINT, "ease": Tween.EASE_IN}
    ]

    func _ready():
        # 为每种配置创建一个演示行
        for i in range(setups.size()):
            create_demo_row(i, setups[i])

    func create_demo_row(index, config):
        # 1. 创建并添加精灵
        var sprite = Sprite2D.new()
        sprite.texture = icon_texture
        sprite.scale = Vector2(0.5, 0.5)
        sprite.position = Vector2(100, 100 + index * 100)
        add_child(sprite)
        
        # 2. 创建并添加标签文字
        var label = Label.new()
        label.text = config["name"]
        label.position = Vector2(20, 70 + index * 100)
        add_child(label)
        
        # 3. 启动循环动画函数
        animate_sprite(sprite, config)

    func animate_sprite(sprite, config):
        var start_pos = Vector2(100, sprite.position.y)
        var end_pos = Vector2(1000, sprite.position.y)
        
        # 创建 Tween
        var tween = create_tween().set_loops() # 无限循环
        
        # 设置当前行的过渡和缓动参数
        tween.set_trans(config["trans"])
        tween.set_ease(config["ease"])
        
        # 动画序列：移动到右边 -> 等待 -> 瞬移回左边
        tween.tween_property(sprite, "position", end_pos, 2.0)
        tween.tween_interval(0.5)
        tween.tween_property(sprite, "position", start_pos, 0.0) # 瞬移回起始点
        tween.tween_interval(0.5)



运行游戏后的效果：

![效果图](https://www.suiyan.cc/assets/images/2025/Snipaste_2026-01-19_16-10-04.png)


这段代码展示了几个关键技巧：

* set_loops(): 让动画自动重复。注意在 Godot 4 中，不带参数的 set_loops() 表示无限循环。

* tween_interval(): 在往返运动之间加入停顿，方便观察终点的回弹或碰撞效果。

* 瞬移技巧: 将 duration 设置为 0.0 的 tween_property 可以当作“瞬间改变属性”来使用。

* 动态组合: 你可以轻松地在 setups 数组里添加更多组合，比如对比 EASE_IN 和 EASE_OUT 的区别。

## 总结与建议

UI 弹出：首选 TRANS_BACK + EASE_OUT。

打击感：试试 TRANS_QUINT 或 TRANS_EXPO。

生命周期：不需要手动 queue_free()，Tween 运行完会自动消失。

中断处理：如果需要在动画中途停止，可以调用 tween.kill()。

Godot 4 带来的全新 Tween 系统，摒弃了传统的节点式操作，改用全代码驱动，更加简洁且强大。

标签: godot教程

Godot 4 补间动画 (Tween) 指北

Godot 4 信号（Signal）的使用入门

Godot4中的整除报错:Expected expression after "/" operator.

Godot4 学习资源教程推荐

在 Godot 4.4 中构建灵活的有限状态机 (FSM)