跳至主要內容

5. 吃子战斗动画

EVOCOSMOS2026/4/13大约 12 分钟

5. 吃子战斗动画：让吃子"炸"起来

5.1 战魂版的核心体验——吃子动画

传统象棋里，吃子就是把对方的棋子拿掉。但在"战魂版"中，吃子是一场视觉盛宴：

  1. 攻击方棋子冲向目标
  2. 两颗棋子碰撞
  3. 被吃的棋子碎裂/飞走
  4. 粒子爆炸特效
  5. 屏幕震动
  6. 攻击方棋子停在目标位置

动画时序设计

整个吃子动画大约持续 1.5 秒：

阶段时间内容
冲刺0.0-0.3s攻击方飞向目标
碰撞0.3-0.5s屏幕震动 + 碰撞音效
爆炸0.3-0.8s粒子特效 + 被吃棋子飞走
消散0.8-1.5s粒子逐渐消散
归位1.5s攻击方停在目标位置

5.2 Tween 补间动画——棋子平滑移动

Tween（补间动画）就像"自动补全"：你告诉它"从这里到那里"，它自动计算中间的每一帧位置。

普通走子动画（不吃子）

C#
using Godot;

public partial class MoveAnimator : Node
{
    [Export] public float MoveDuration { get; set; } = 0.4f;     // 移动时间
    [Export] public float CaptureDuration { get; set; } = 0.3f;  // 冲刺时间

    /// <summary>
    /// 播放普通走子动画（平滑移动到目标位置）
    /// </summary>
    public void PlayMoveAnimation(Piece3D piece, Vector3 targetPos)
    {
        // 创建一个 Tween
        var tween = CreateTween();

        // 让棋子平滑移动到目标位置
        tween.TweenProperty(piece, "position", targetPos, MoveDuration)
            .SetTrans(Tween.TransitionType.Sine)     // 使用正弦缓动（先快后慢）
            .SetEase(Tween.EaseType.Out);

        // 走子音效
        tween.Parallel().TweenCallback(Callable.From(() =>
            PlaySound("res://audio/move.wav")));

        // 动画结束后通知游戏管理器
        tween.TweenCallback(Callable.From(() =>
            GD.Print("走子动画结束")));
    }

    /// <summary>
    /// 播放吃子战斗动画（冲刺 + 碰撞 + 爆炸）
    /// </summary>
    public void PlayCaptureAnimation(Piece3D attacker, Piece3D target,
        Vector3 targetPos)
    {
        var tween = CreateTween();

        // ===== 第一阶段：冲刺 =====
        // 棋子跳起来冲向目标（Y轴升高再落下）
        Vector3 midPos = new Vector3(
            (attacker.Position.X + targetPos.X) / 2,
            1.5f,  // 跳起高度
            (attacker.Position.Z + targetPos.Z) / 2
        );

        // 先跳起来
        tween.TweenProperty(attacker, "position:y", 1.5f, CaptureDuration * 0.3f)
            .SetTrans(Tween.TransitionType.Quad)
            .SetEase(Tween.EaseType.Out);

        // 同时水平移向目标
        tween.Parallel().TweenProperty(attacker, "position:x", targetPos.X, CaptureDuration)
            .SetTrans(Tween.TransitionType.Back)
            .SetEase(Tween.EaseType.In);
        tween.Parallel().TweenProperty(attacker, "position:z", targetPos.Z, CaptureDuration)
            .SetTrans(Tween.TransitionType.Back)
            .SetEase(Tween.EaseType.In);

        // ===== 第二阶段：碰撞 =====
        // 落下砸向目标
        tween.TweenProperty(attacker, "position:y", 0.2f, 0.1f)
            .SetTrans(Tween.TransitionType.Bounce)
            .SetEase(Tween.EaseType.In);

        // 碰撞瞬间：播放效果
        tween.TweenCallback(Callable.From(() =>
        {
            OnCaptureImpact(attacker, target);
        }));

        // ===== 第三阶段：被吃棋子飞走 =====
        tween.TweenCallback(Callable.From(() =>
        {
            AnimateDefeatedPiece(target);
        }));

        // ===== 第四阶段：攻击方归位 =====
        tween.TweenInterval(1.0f);
        tween.TweenCallback(Callable.From(() =>
        {
            attacker.Position = targetPos;
            GD.Print("吃子动画结束");
        }));
    }

    /// <summary>
    /// 碰撞瞬间效果
    /// </summary>
    private void OnCaptureImpact(Piece3D attacker, Piece3D target)
    {
        // 播放碰撞音效
        PlaySound("res://audio/capture.wav");

        // 屏幕震动
        ShakeCamera(0.3f, 0.15f);

        // 粒子爆炸
        SpawnExplosion(target.Position);

        // 闪光效果
        SpawnFlash(target.Position);
    }

    /// <summary>
    /// 被吃棋子飞走的动画
    /// </summary>
    private void AnimateDefeatedPiece(Piece3D piece)
    {
        var tween = CreateTween();

        // 随机飞出方向
        float randomAngle = (float)GD.RandRange(0, Mathf.Tau);
        float flyDistance = 3.0f;
        Vector3 flyTarget = piece.Position + new Vector3(
            Mathf.Cos(randomAngle) * flyDistance,
            3.0f,
            Mathf.Sin(randomAngle) * flyDistance
        );

        // 飞出
        tween.TweenProperty(piece, "position", flyTarget, 0.8f)
            .SetTrans(Tween.TransitionType.Sine)
            .SetEase(Tween.EaseType.Out);

        // 同时旋转
        tween.Parallel().TweenProperty(piece, "rotation_degrees:y", 720, 0.8f)
            .SetTrans(Tween.TransitionType.Linear);

        // 同时缩小
        tween.Parallel().TweenProperty(piece, "scale", Vector3.Zero, 0.8f)
            .SetTrans(Tween.TransitionType.Sine)
            .SetEase(Tween.EaseType.In);

        // 消失后移除
        tween.TweenCallback(Callable.From(() =>
        {
            piece.QueueFree();
        }));
    }

    /// <summary>
    /// 播放音效
    /// </summary>
    private void PlaySound(string path)
    {
        var stream = GD.Load<AudioStream>(path);
        var player = new AudioStreamPlayer3D();
        player.Stream = stream;
        player.VolumeDb = -5.0f;
        AddChild(player);
        player.Play();
        // 播完后自动清理
        player.Finished += () => player.QueueFree();
    }

    /// <summary>
    /// 摄像机震动
    /// </summary>
    private void ShakeCamera(float duration, float intensity)
    {
        var camera = GetViewport().GetCamera3D();
        if (camera == null) return;

        var originalPos = camera.Position;
        var tween = CreateTween();

        for (int i = 0; i < 6; i++)
        {
            var offset = new Vector3(
                (float)GD.RandRange(-intensity, intensity),
                (float)GD.RandRange(-intensity, intensity),
                0
            );
            tween.TweenProperty(camera, "position", originalPos + offset, duration / 6);
        }
        tween.TweenProperty(camera, "position", originalPos, duration / 6);
    }

    // 占位方法，在粒子特效部分实现
    private void SpawnExplosion(Vector3 pos) { }
    private void SpawnFlash(Vector3 pos) { }
}

5.3 粒子爆炸特效

粒子特效就像烟花——从一个点喷出很多小粒子，然后逐渐消散。Godot 使用 GPUParticles3D 节点来实现。

粒子特效原理

GPUParticles3D 的工作流程：

1. 在一个点上"发射"大量小粒子
2. 每个粒子有自己的速度、颜色、大小、生命周期
3. 粒子随时间移动、变色、缩小
4. 生命周期结束后粒子消失
C#
using Godot;

public partial class BattleEffects : Node3D
{
    /// <summary>
    /// 在指定位置生成爆炸粒子特效
    /// </summary>
    public void SpawnExplosion(Vector3 position)
    {
        var particles = new GPUParticles3D();
        particles.Name = "Explosion";
        particles.Position = position;

        // ===== 粒子材质（控制粒子的外观和行为）=====
        var processMaterial = new ParticleProcessMaterial();
        processMaterial.EmissionShape = ParticleProcessMaterial.EmissionShapeEnum.Point;
        processMaterial.ParticleFlagDisableZ = false;

        // 粒子发射方向：球形扩散
        processMaterial.Direction = new Vector3(0, 1, 0);
        processMaterial.Spread = 180.0f;  // 360度扩散

        // 粒子初始速度
        processMaterial.InitialVelocityMin = 2.0f;
        processMaterial.InitialVelocityMax = 5.0f;

        // 重力（让粒子往下掉）
        processMaterial.Gravity = new Vector3(0, -5.0f, 0);

        // 粒子大小随时间变化（先大后小）
        var scaleCurve = new Curve();
        scaleCurve.AddPoint(new Vector2(0, 1.0f));     // 开始时满大小
        scaleCurve.AddPoint(new Vector2(0.5f, 0.8f));   // 中间缩小一点
        scaleCurve.AddPoint(new Vector2(1.0f, 0.0f));   // 结束时消失
        processMaterial.ScaleCurve = scaleCurve;

        // 颜色随时间变化（亮黄 → 橙红 → 灰色）
        var colorRamp = new Gradient();
        colorRamp.Colors = new Color[]
        {
            new Color(1.0f, 1.0f, 0.5f, 1.0f),  // 亮黄色
            new Color(1.0f, 0.5f, 0.0f, 0.8f),  // 橙色
            new Color(0.5f, 0.2f, 0.1f, 0.0f)   // 暗红色（透明）
        };
        colorRamp.Offsets = new float[] { 0.0f, 0.5f, 1.0f };
        processMaterial.ColorRamp = colorRamp;

        particles.ProcessMaterial = processMaterial;

        // ===== 粒子数量和生命周期 =====
        particles.Amount = 50;               // 50个粒子
        particles.Lifetime = 1.0f;           // 每个粒子存活1秒
        particles.OneShot = true;            // 只发射一次
        particles.Explosiveness = 0.9f;      // 几乎同时发射所有粒子
        particles.Randomness = 0.5f;         // 50%随机性

        // 粒子网格（每个粒子的形状）
        var quadMesh = new QuadMesh();
        quadMesh.Size = new Vector2(0.2f, 0.2f);
        particles.DrawPass1 = quadMesh;

        AddChild(particles);

        // 自动清理：粒子播放完后移除节点
        particles.Emitting = true;
        GetTree().CreateTimer(particles.Lifetime + 0.5).Timeout +=
            () => particles.QueueFree();
    }

    /// <summary>
    /// 在指定位置生成闪光效果
    /// </summary>
    public void SpawnFlash(Vector3 position)
    {
        // 使用 OmniLight3D 模拟闪光
        var light = new OmniLight3D();
        light.Position = position;
        light.LightColor = new Color(1.0f, 0.9f, 0.5f);  // 暖黄色
        light.LightEnergy = 10.0f;                         // 非常亮
        light.OmniRange = 5.0f;
        light.ShadowEnabled = false;

        AddChild(light);

        // 闪光渐灭
        var tween = CreateTween();
        tween.TweenProperty(light, "light_energy", 0.0f, 0.3f)
            .SetTrans(Tween.TransitionType.Sine)
            .SetEase(Tween.EaseType.Out);
        tween.TweenCallback(Callable.From(() => light.QueueFree()));
    }

    /// <summary>
    /// 在指定位置生成火花粒子（小规模特效）
    /// </summary>
    public void SpawnSparks(Vector3 position)
    {
        var particles = new GPUParticles3D();
        particles.Position = position;

        var processMaterial = new ParticleProcessMaterial();
        processMaterial.EmissionShape = ParticleProcessMaterial.EmissionShapeEnum.Point;
        processMaterial.Direction = new Vector3(0, 1, 0);
        processMaterial.Spread = 30.0f;  // 较窄的角度
        processMaterial.InitialVelocityMin = 3.0f;
        processMaterial.InitialVelocityMax = 8.0f;
        processMaterial.Gravity = new Vector3(0, -9.8f, 0);

        // 火花颜色（白 → 黄 → 红）
        var colorRamp = new Gradient();
        colorRamp.Colors = new Color[]
        {
            new Color(1.0f, 1.0f, 1.0f, 1.0f),
            new Color(1.0f, 0.8f, 0.0f, 0.6f),
            new Color(1.0f, 0.2f, 0.0f, 0.0f)
        };
        colorRamp.Offsets = new float[] { 0.0f, 0.3f, 1.0f };
        processMaterial.ColorRamp = colorRamp;

        particles.ProcessMaterial = processMaterial;
        particles.Amount = 20;
        particles.Lifetime = 0.5f;
        particles.OneShot = true;
        particles.Explosiveness = 1.0f;

        AddChild(particles);
        particles.Emitting = true;
        GetTree().CreateTimer(1.0).Timeout +=
            () => particles.QueueFree();
    }
}

5.4 粒子参数详解

GPUParticles3D 关键参数

参数含义推荐值
Amount同时存在的粒子数量20-100
Lifetime每个粒子存活的时间（秒）0.5-2.0
OneShot是否只发射一次true（爆炸用）
Explosiveness发射间隔的随机性（0=均匀, 1=同时）0.8-1.0（爆炸用）
Randomness各种参数的随机程度0.3-0.5

ParticleProcessMaterial 关键参数

参数含义爆炸效果推荐值
EmissionShape粒子从哪里出来Point（从一个点）
Direction粒子初始方向(0,1,0)
Spread扩散角度180（360度）
InitialVelocityMin/Max初始速度范围2-8
Gravity重力(0, -5, 0)
ScaleCurve大小随时间变化先大后小
ColorRamp颜色随时间变化亮 → 暗 → 透明

5.5 AnimationPlayer 制作复杂动画

对于更复杂的动画序列（比如棋子变形、光环扩散等），可以使用 AnimationPlayer。

在编辑器中制作动画

  1. 选中棋子节点
  2. 添加 AnimationPlayer 子节点
  3. 打开动画面板（底部）
  4. 点击"创建新动画"
  5. 添加轨道（属性动画）
C#
using Godot;

public partial class PieceAnimationPlayer : Node3D
{
    private AnimationPlayer _animPlayer;

    public override void _Ready()
    {
        _animPlayer = new AnimationPlayer();
        _animPlayer.Name = "AnimationPlayer";
        AddChild(_animPlayer);

        CreateCaptureAnimation();
    }

    /// <summary>
    /// 代码创建吃子动画（等同于在编辑器里手动制作的动画）
    /// </summary>
    private void CreateCaptureAnimation()
    {
        var anim = new Animation();
        anim.Length = 1.5f;
        int trackIdx;

        // 轨道1：棋子上跳
        trackIdx = anim.AddTrack(Animation.TrackType.Value);
        anim.TrackSetPath(trackIdx, "PieceMesh:position:y");
        anim.TrackInsertKey(trackIdx, 0.0f, 0.0f);
        anim.TrackInsertKey(trackIdx, 0.15f, 0.8f);   // 跳起
        anim.TrackInsertKey(trackIdx, 0.3f, 0.0f);    // 落下

        // 轨道2：棋子缩放（碰撞时膨胀再缩小）
        trackIdx = anim.AddTrack(Animation.TrackType.Value);
        anim.TrackSetPath(trackIdx, "PieceMesh:scale");
        anim.TrackInsertKey(trackIdx, 0.0f, new Vector3(1, 1, 1));
        anim.TrackInsertKey(trackIdx, 0.25f, new Vector3(1.2f, 1.2f, 1.2f));  // 膨胀
        anim.TrackInsertKey(trackIdx, 0.35f, new Vector3(0.9f, 0.9f, 0.9f));  // 压扁
        anim.TrackInsertKey(trackIdx, 0.5f, new Vector3(1.0f, 1.0f, 1.0f));   // 恢复

        // 轨道3：旋转
        trackIdx = anim.AddTrack(Animation.TrackType.Value);
        anim.TrackSetPath(trackIdx, "PieceMesh:rotation_degrees:y");
        anim.TrackInsertKey(trackIdx, 0.0f, 0.0f);
        anim.TrackInsertKey(trackIdx, 0.3f, 180.0f);   // 翻转半圈
        anim.TrackInsertKey(trackIdx, 0.5f, 360.0f);   // 翻转一圈

        // 添加到 AnimationPlayer
        var lib = new AnimationLibrary();
        lib.AddAnimation("capture", anim);
        _animPlayer.AddLibrary("default", lib);
    }

    /// <summary>
    /// 播放吃子动画
    /// </summary>
    public void PlayCapture()
    {
        _animPlayer.Play("capture");
    }
}

5.6 音效系统

音效让游戏"有感觉"。走子的"哒"声、吃子的"砰"声、将军的警告声，都是游戏体验的重要组成部分。

音效文件准备

音效来源格式时长
move.wav棋子放下的"啪"声WAV0.2s
capture.wav碰撞爆炸声WAV0.5s
check.wav将军警告声WAV0.3s
victory.wav胜利音乐OGG3.0s
select.wav选中棋子的轻响WAV0.1s

音效获取途径

  1. 免费音效网站：freesound.org、opengameart.org
  2. 自己录制：用手机录下棋子碰撞的声音
  3. 合成音效：用 Bfxr、sfxr 等工具生成

音效管理器

C#
using Godot;
using System.Collections.Generic;

public partial class AudioManager : Node
{
    public static AudioManager Instance { get; private set; }

    private Dictionary<string, AudioStream> _sounds = new();
    private AudioStreamPlayer _musicPlayer;

    public override void _Ready()
    {
        Instance = this;
        LoadSounds();
    }

    private void LoadSounds()
    {
        _sounds["move"] = GD.Load<AudioStream>("res://audio/move.wav");
        _sounds["capture"] = GD.Load<AudioStream>("res://audio/capture.wav");
        _sounds["check"] = GD.Load<AudioStream>("res://audio/check.wav");
        _sounds["select"] = GD.Load<AudioStream>("res://audio/select.wav");
        _sounds["victory"] = GD.Load<AudioStream>("res://audio/victory.ogg");
    }

    /// <summary>
    /// 播放音效
    /// </summary>
    public void PlaySound(string name, float volumeDb = 0.0f)
    {
        if (!_sounds.ContainsKey(name))
        {
            GD.PrintErr($"音效不存在: {name}");
            return;
        }

        var player = new AudioStreamPlayer();
        player.Stream = _sounds[name];
        player.VolumeDb = volumeDb;
        AddChild(player);
        player.Play();
        player.Finished += () => player.QueueFree();
    }

    /// <summary>
    /// 播放 3D 空间音效
    /// </summary>
    public void PlaySound3D(string name, Vector3 position, float volumeDb = 0.0f)
    {
        if (!_sounds.ContainsKey(name)) return;

        var player = new AudioStreamPlayer3D();
        player.Stream = _sounds[name];
        player.Position = position;
        player.VolumeDb = volumeDb;
        AddChild(player);
        player.Play();
        player.Finished += () => player.QueueFree();
    }
}

5.7 特效等级对比

根据设备性能，你可以调整特效的"豪华程度"：

等级粒子数量屏幕震动闪光火花适用场景
低10个无无无低端手机
中30个轻微有无中端设备
高50个明显有有高端设备
极高100个强烈有有展示/截屏

本章小结

要点说明
Tween 动画用于走子和吃子的平滑移动动画
吃子流程冲刺 → 碰撞 → 爆炸 → 被吃棋子飞走 → 归位
粒子特效GPUParticles3D 实现爆炸、火花效果
闪光效果OmniLight3D 模拟碰撞闪光
音效系统AudioStreamPlayer 管理走子/吃子/将军音效
AnimationPlayer用于制作更复杂的动画序列

→ 6. 3D摄像机表现

最近更新:
贡献者: zefeng.peng,bobokaka
EVOCOSMOS
Copyright © 2026 EVOCOSMOS