Redream 编辑器资源使用说明

编辑器源文件 (ccb/)              →  编译  →  运行时文件 (_ccbi/)
───────────────────────────────────────────────────────────────
xxx.red                          →           xxx.redream
xxx.red + xxx.rebolt             →           xxx.redream + 若干 .xml
xxx.anim                         →           xxx.redanim

auto* layer = redutils::QCoreLayer::Layer("xxx.redream");
parentNode->addChild(layer);

auto* loader = RedreamLoader::Layer("xxx.redream");
parentNode->addChild(loader);

auto* loader = RedreamLoader::ReboltLayer("xxx.redream");
parentNode->addChild(loader);

auto* layer = redutils::RUReboltLayer::createReboltLayer("xxx.redream");
parentNode->addChild(layer);
layer->runBehaviacWhitFunName("初始化");

auto* lib = redream::NodeLoaderLibrary::newDefaultNodeLoaderLibrary();
lib->registerNodeLoader("RedreamLoader", RedreamLoaderLoader::loader());
auto* loader = RedreamLoader::LayerWithLib("xxx.redream", lib);

// 写 .redream 后缀（推荐）
auto* layer = RedreamLoader::Layer("xxx.redream");

// 不写后缀，REDReader 自动补 .redream
auto* layer = RedreamLoader::Layer("xxx");

// 两者等价

int nextSeqId = sequence->getChainedSequenceId();
if (nextSeqId != -1) {
    // 当前时间线完成，自动播放下一条
    delegate->completedAnimationAndPlayNextSequenceNamed(...);
    delegate->completedAnimationSequenceNamed(...);
    runAnimationsForSequenceIdTweenDuration(nextSeqId, 0, callback);
} else {
    // 真正播完了，没有后续
    delegate->completedAnimationSequenceNamed(...);
}

// RedreamLoader / QCoreLayer 的简化接口
float duration = loader->playAnim("常态");       // 播放并返回时长
float time = loader->getAnimTime("动画_解锁");   // 仅获取时长

// QCoreLayer 支持播完回调
coreLayer->playAnim("动画名", [](float dt) {
    // 动画播完后执行
});

// 播放后自动从父节点移除自己
coreLayer->playAnimAndRemoveSelf("out");
// 内部实现：播放时间线，注册完成回调，回调中调用 this->removeFromParent()

// 检查时间线是否存在
bool valid = coreLayer->isValidAnim("某条时间线");

// 从节点获取动画管理器
auto* animMgr = REDAnimationManager::fromNode(node);
// 或者
auto* animMgr = dynamic_cast<REDAnimationManager*>(node->getUserObject());

// 按名称播放
animMgr->runAnimationsForSequenceNamed("timeline_name");

// 带过渡时间和完成回调
animMgr->runAnimationsForSequenceNamedTweenDuration("name", 0.3f,
    [](Node* n, AnimationCompleteType type) {
        // type 取值：
        // CHAINED   — 播完但会继续播下一条链式时间线
        // COMPLETED — 完全播放完毕
        // STOPED    — 被 stopAllNodeAction() 停止
    });

// 按 ID 播放
int seqId = animMgr->getSequenceId("timeline_name");
animMgr->runAnimationsForSequenceIdTweenDuration(seqId, 0);

// 获取时间线时长
float dur = animMgr->getSequenceDuration("timeline_name");

// 刷新到首帧状态（不播放动画，只设置属性到第一帧的值）
animMgr->refreshStatusOnFirstFream(seqId, 0);

// 动画速度控制
animMgr->setAnimationSpeed(2.0f);   // 2 倍速
coreLayer->setAnimationSpeed(0.5f); // 半速

// RedreamLoader 方式 — 停止该节点上的所有 cocos2d Action
loader->stopAnimAll();  // 内部调用 this->stopAllActions()

// REDAnimationManager 方式 — 停止所有节点动画并触发回调
animMgr->stopAllNodeAction();

loader->playAnim("常态");  // 重新播放

auto* loader = RedreamLoader::Layer("SL_棋盘模块_基本元素_棋盘格.redream");
parentNode->addChild(loader);

// 获取内部子节点进行静态操作
Sprite* bg = loader->getSprite("棋盘格");
bg->setOpacity(128);

// 加载带 Rebolt 的文件
auto* loader = RedreamLoader::ReboltLayer("xxx.redream");
parentNode->addChild(loader);

// 获取 Rebolt 管理器
auto* reboltMgr = loader->getReboltManager();

auto* loader = RedreamLoader::ReboltLayer("xxx.redream");
loader->_reboltCallBack = [](ReboltRedManager* mgr, NotifyDevelopmentWaiter* waiter,
                              std::string notify, std::string param, bool isWait, Node* outNode) {
    if (notify == "doSomething") {
        // 执行自定义逻辑
    }
    if (isWait) {
        waiter->notifyDevelopmentEnd();  // 通知行为树继续
    }
};

// 直接操作 cocos2d Node 的可见性
loader->setVisible(true);
loader->setVisible(false);

// 操作内部子节点
Node* child = loader->getNode("某个节点");
child->setVisible(false);

// 透明度控制
Sprite* sprite = loader->getSprite("棋盘格");
sprite->setOpacity(0);     // 完全透明
sprite->setOpacity(255);   // 完全不透明

// 通过变量名获取 redream 文件中的定位点节点
Node* locator = loader->getNode("元素定位点");

// 局部坐标 → 世界坐标
Vec2 worldPos = locator->convertToWorldSpace(Vec2::ZERO);

// 世界坐标 → 另一个节点的局部坐标
Vec2 localPos = targetParent->convertToNodeSpace(worldPos);

// redream 库提供的绝对位置计算工具
Vec2 absPos = redream::getAbsolutePosition(pt, posType, containerSize, propName);

RedLabel* label = loader->getRedLabel("标题");
label->setString("Hello");                    // 同时设置前景和背景文本
label->setFrontColor(Color3B::WHITE);         // 前景色
label->setBackColor(Color3B::BLACK);          // 背景色（描边/阴影）
label->setFrontOpacity(255);                  // 前景透明度
label->setBackOpacity(128);                   // 背景透明度
label->setFrontBMFontFilePath("font.fnt");    // 前景字体
label->setBackBMFontFilePath("font_bg.fnt");  // 背景字体
label->setDimensions(200, 50);                // 文本框尺寸
label->setHorizontalAlignment(TextHAlignment::CENTER);  // 水平对齐
label->setVerticalAlignment(TextVAlignment::CENTER);    // 垂直对齐
label->enableWrap(true);                      // 自动换行
label->setLineSpacing(5.0f);                  // 行间距

REDNodeButton* btn = loader->getREDNodeButton("按钮");
btn->setZoomOnTouchDown(true);    // 按下时缩放
btn->setScaleRatio(1.1f);        // 按下缩放比例
btn->setSwallowsTouches(true);   // 吞噬触摸事件
btn->setEnabled(true);           // 启用/禁用
// 触摸移动取消（如在 TableView 中的按钮，滑动时取消点击）
btn->setTouchMovedCanceled(true, 10.0f);

auto* layer = redutils::QCoreLayer::Layer("xxx.redream");

// 直接用 lambda 注册时间线关键帧回调
layer->setTimelineCallback("myCallback", []() {
    // 时间线播到这个关键帧时执行
});

layer->playAnim("某条时间线");

// QCoreLayer 方式 — 直接用 lambda
coreLayer->registerCompletedAniCallBack([](string timeLineName) {
    // timeLineName 是播完的时间线名称
    if (timeLineName == "动画_解锁") {
        // 处理完成逻辑
    }
});

// QCoreLayer 的 playAnim 也支持完成回调
coreLayer->playAnim("动画名", [](float dt) {
    // 播完后执行（通过 scheduleOnce 实现）
});

// RedreamLoader 的实现
bool RedreamLoader::onAssignREDMemberVariable(Ref* pTarget, const char* name, Node* node) {
    if (pTarget == this && node != this && strcmp(name, "") != 0) {
        _mapChilden.insert(pair<string, Node*>(string(name), node));
        return true;
    }
    return false;
}

// 从 .redanim 文件创建（传入文件名，内部自动补 .redanim 后缀）
auto* anim = redream::RedreamAnim::createFromAnimFile("path/to/anim");

// 获取动画时长
float duration = anim->getDuration();

// 设置起止位置（覆盖文件中的默认值，用于路径动画）
anim->setStartPosition(Vec2(100, 200));
anim->setEndPosition(Vec2(500, 300));

// 生成 cocos2d Action（autorelease）
// rotateWith: 是否沿路径方向旋转
Action* action = anim->getAction(true);

// 应用到任意节点
myNode->runAction(action);

// ReboltRedManager 内部实现
void ReboltRedManager::runAnimFile(Node* node, std::string animPath,
    Vec2 startPos, Vec2 endPos, bool rotateWith,
    const std::function<void()>& func, ReboltErrorInfo& errorInfo) {
    Node* par = node->getParent();
    Vec2 localStartPos = par->convertToNodeSpace(startPos);
    Vec2 localEndPos = par->convertToNodeSpace(endPos);

    auto anim = redream::RedreamAnim::createFromAnimFile(animPath);
    anim->setStartPosition(localStartPos);
    anim->setEndPosition(localEndPos);
    auto seq = Sequence::create(anim->getAction(rotateWith), CallFunc::create(func), NULL);
    node->runAction(seq);
}

parent->addChild(child);         // child 加入 parent 的子节点列表，引用计数 +1
parent->addChild(child, zOrder); // 指定渲染层级
child->removeFromParent();       // 从 parent 中移除，引用计数 -1
parent->removeChild(child);      // 同上
parent->removeAllChildren();     // 移除所有子节点
parent->getChildren();           // 获取所有子节点
child->getParent();              // 获取父节点

obj->retain();      // 引用计数 +1（你想持有它时调用）
obj->release();     // 引用计数 -1（不再需要时调用）
obj->autorelease(); // 放入自动释放池，这一帧结束时自动 release 一次
// 引用计数归 0 时自动 delete

// CREATE_FUNC 宏展开后等价于：
static MyType* create() {
    MyType* pRet = new(std::nothrow) MyType();  // 堆上分配，引用计数 = 1
    if (pRet && pRet->init()) {
        pRet->autorelease();  // 放入自动释放池
        return pRet;
    } else {
        delete pRet;
        return nullptr;
    }
}

auto* sprite = Sprite::create("image.png");
// 此时引用计数 = 1，且已标记 autorelease
// 如果这一帧内没有人 retain 它（比如 addChild），帧末它就会被释放

parent->addChild(sprite);
// addChild 内部调用 sprite->retain()，引用计数 = 2
// 帧末 autorelease 池清理，release 一次，引用计数 = 1
// sprite 安全存活

parent->removeChild(sprite);
// removeChild 内部调用 sprite->release()，引用计数 = 0
// 触发 delete，sprite 被析构

// RedreamLoader::ReboltLayer 中的实际例子
ReboltRedManager* reboltM = reboltReader->getReboltRedManager();
reboltM->retain();  // 手动 retain，因为 ReboltRedManager 不会被 addChild

// 对应地，在析构函数中必须手动 release：
RedreamLoader::~RedreamLoader() {
    if (_loaderReboltRedManager != nullptr) {
        _loaderReboltRedManager->release();
        _loaderReboltRedManager = nullptr;
    }
}

// 每帧调用
node->schedule([](float dt) { /* dt 是距上一帧的秒数 */ }, "key");

// 延迟一次性调用
node->scheduleOnce([](float dt) { /* 只执行一次 */ }, 2.0f, "key");

// 固定间隔调用
node->schedule([](float dt) { }, 0.5f, "key");  // 每 0.5 秒

// 取消定时器
node->unschedule("key");

void QCoreLayer::playAnim(std::string animName, const std::function<void(float)>& cbFinishAnim, std::string cbScheduleKey) {
    _mAnimCtrl->runAnimationsForSequenceNamed(animName.c_str());
    if (cbFinishAnim) {
        float animTime = getAnimTime(animName);
        scheduleOnce(cbFinishAnim, animTime, cbScheduleKey);
    }
}

class IRedream : public cocos2d::Node {
public:
    virtual void initRebolt() = 0;
};

class KeyRedream : public IRedream {
    void initRebolt() override {
        _redream = RedreamLoader::Layer(_file);  // 加载
        addChild(_redream);                       // 挂到场景树
        _redream->playAnim("常态");               // 播放默认时间线
    }

    void refreshVisualState(int type) {
        _redream->playAnim("常态");               // 切换状态时重新播放
    }

private:
    std::string _file = "YJ_棋盘模块_特殊元素_钥匙.redream";
    RedreamLoader* _redream = nullptr;
};

class SpoolCellRedream : public IRedream {
    void initRebolt() override {
        _redream = RedreamLoader::Layer(_file);
        addChild(_redream);
    }

    void setCellSize(float width, float height) {
        Sprite* bgSprite = _redream->getSprite("棋盘格");
        Size originalSize = bgSprite->getContentSize();
        float scale = std::min(width / originalSize.width, height / originalSize.height);
        _contentRoot->setScale(scale);
    }

    Node* getElementLocatorNode() const {
        return _redream->getNode("元素定位点");
    }

    Node* getBundleLocatorNode(BundleLocatorType type) const {
        switch (type) {
            case BundleLocatorType::HorizontalBackLeftTop:
                return _redream->getNode("绳子横向_左上");
            // ...
        }
    }

private:
    std::string _file = "SL_棋盘模块_基本元素_棋盘格.redream";
    RedreamLoader* _redream = nullptr;
};

// 播放动画并在完成后恢复常态
_redream->playAnim("动画_激活");
const float delay = _redream->getAnimTime("动画_激活");
runAction(Sequence::create(
    DelayTime::create(delay),
    CallFunc::create([this]() {
        _redream->playAnim("常态");
    }),
    nullptr
));

auto* efx = redutils::QCoreLayer::Layer("shop_loading.redream");
scene->addChild(efx);
efx->playAnim("1");

// 播完 "out" 动画后自动从场景中移除并释放
efx->playAnimAndRemoveSelf("out");

auto* layer = redutils::RUReboltLayer::createReboltLayer("shop_interface.redream");
parentNode->addChild(layer);

// 注册通知回调
layer->registerOnNotify([this](const redutils::ReboltNotifyData& data) {
    // 处理行为树发出的通知
});

// 运行行为树中的指定函数
layer->runBehaviacWhitFunName("初始化");