虚幻基础：组件间的联动方式

---

能帮到你的话，就给个赞吧 😘

---

文章目录

• 联动行为：受击组件受击时，攻击组件不能攻击
• • 联动方式
  • • [组件的状态 联动 其他组件的行为：命令模式](#组件的状态 联动 其他组件的行为：命令模式)
    • [组件的行为 受 其他组件的影响：查询模式](#组件的行为 受 其他组件的影响：查询模式)
• 联动方式的实现：
• • 调用
  • 回调
  • 事件驱动
  • 接口
  • 消息队列
• 示例：
• • [受击组件的状态 联动 攻击组件的行为：](#受击组件的状态 联动 攻击组件的行为：)
  • [攻击组件的行为 受 受击组件状态的影响：](#攻击组件的行为 受 受击组件状态的影响：)
• 调用
• 回调
• 事件驱动
• 接口依赖
• 消息队列

联动行为：受击组件受击时，攻击组件不能攻击

联动方式

组件的状态 联动 其他组件的行为：命令模式

组件的行为 受 其他组件的影响：查询模式

联动方式的实现：

调用

回调

事件驱动

接口

消息队列

示例：

受击组件的状态 联动 攻击组件的行为：

攻击组件的行为 受 受击组件状态的影响：

调用

// 直接调用方式：受击组件主动控制攻击组件
#include <iostream>
#include <chrono>
#include <thread>

// 攻击组件
class AttackComponent {
private:
    bool canAttack = true;
    const int cooldownMs = 2000; // 受击后禁止攻击的时间（2秒）

public:
    // 尝试攻击
    void attack() {
        if (canAttack) {
            std::cout << "攻击成功！" << std::endl;
        } else {
            std::cout << "受击后无法攻击！" << std::endl;
        }
    }

    // 禁止攻击（供受击组件直接调用）
    void disableAttack() {
        canAttack = false;
        std::cout << "攻击被禁用..." << std::endl;

        // 启动定时器，一段时间后恢复攻击
        std::thread t([this]() {
            std::this_thread::sleep_for(std::chrono::milliseconds(cooldownMs));
            canAttack = true;
            std::cout << "攻击已恢复！" << std::endl;
        });
        t.detach();
    }
};

// 受击组件
class HitComponent {
private:
    // 直接持有攻击组件的引用（强依赖）
    AttackComponent& attackComp;

public:
    // 构造函数中必须传入攻击组件
    HitComponent(AttackComponent& ac) : attackComp(ac) {}

    // 被攻击时触发
    void takeHit() {
        std::cout << "受到攻击！" << std::endl;
        // 直接调用攻击组件的方法，禁止攻击
        attackComp.disableAttack();
    }
};

// 使用示例
int main() {
    AttackComponent attackComp;
    HitComponent hitComp(attackComp); // 受击组件必须强绑定攻击组件


    attackComp.attack();
    
    hitComp.takeHit();	// 受击组件受击时，调用 攻击组件的禁止攻击
    
    attackComp.attack(); // 攻击失败

    // 等待冷却时间
    std::this_thread::sleep_for(std::chrono::milliseconds(2500));
    
    // 冷却后：可以攻击
    attackComp.attack();

    return 0;
}

回调

// 回调方式：受击组件通过 回调 通知攻击组件响应
#include <iostream>
#include <chrono>
#include <thread>
#include <functional>

// 攻击组件
class AttackComponent {
private:
    bool canAttack = true;
    const int cooldownMs = 2000; // 受击后禁止攻击的时间（2秒）

public:
    // 尝试攻击
    void attack() {
        if (canAttack) {
            std::cout << "攻击成功！" << std::endl;
        } else {
            std::cout << "受击后无法攻击！" << std::endl;
        }
    }

    // 受击事件的回调处理函数（禁止攻击）
    void onHitReceived() {
        canAttack = false;
        std::cout << "攻击被禁用..." << std::endl;

        // 启动定时器，一段时间后恢复攻击
        std::thread t([this]() {
            std::this_thread::sleep_for(std::chrono::milliseconds(cooldownMs));
            canAttack = true;
            std::cout << "攻击已恢复！" << std::endl;
        });
        t.detach();
    }
};

// 受击组件
class HitComponent {
private:
    // 存储回调函数（不依赖具体组件类型）
    std::function<void()> onHitCallback;

public:
    // 提供注册回调的接口
    void setOnHitCallback(std::function<void()> callback) {
        onHitCallback = callback;
    }

    // 被攻击时触发
    void takeHit() {
        std::cout << "受到攻击！" << std::endl;
        // 触发回调（通知攻击组件）
        if (onHitCallback) {
            onHitCallback();
        }
    }
};

// 使用示例
int main() {
    AttackComponent attackComp;
    HitComponent hitComp;		// 受击组件无需绑定攻击组件

    // 注册受击组件的回调
    hitComp.setOnHitCallback([&attackComp]() {
        attackComp.onHitReceived();
    });
    
    attackComp.attack();

    hitComp.takeHit();		// 受击组件受击时，调用 注册的回调
    
    // 攻击失败
    attackComp.attack();	

    // 等待冷却时间
    std::this_thread::sleep_for(std::chrono::milliseconds(2500));
    
    // 冷却后：可以攻击
    attackComp.attack();

    return 0;
}

事件驱动

接口依赖

消息队列