ElemsConfigTool/datacpp/elemPropertyData.cpp

#include "datahpp/elemPropertyData.h"
#include "plisthpp/redream.h"
#include "datahpp/dataManager.h"
#include <QJsonArray>

ElemPropertyData::ElemPropertyData()
{
    iconPath = ":/icon/icon/菜狗.png";
    labelName = "0";
    maxLayer = "1";
    score = "50";
    dropConfig = DROPOPT::BYSTATE;
    canBeLinked = false;
    canMoveAway = false;
}

int ElemPropertyData::getKeyIndex(int poolIndex, QString key)
{
    for(int i = 0;i<container[poolIndex].table.size();i++){
        if(key == container[poolIndex].table[i].key){
            return i;
        }
    }
    return -1;
}

int ElemPropertyData::getChildElemIndex(QString childElemName)
{
    for(int i=0;i<childElem.size();i++){
        if(childElemName == childElem[i].name){
            return i;
        }
    }
    return -1;
}

int ElemPropertyData::getAnimIndex(QString animName)
{
    for(int i=0;i<statusEffect.size();i++){
        if(statusEffect[i].name == animName){
            return i;
        }
    }
    return -1;
}

int ElemPropertyData::getCollAnimIndex(QString name)
{
    for(int i=0;i<collAnim.size();i++){
        if(collAnim[i].name == name){
            return i;
        }
    }
    return -1;
}

int ElemPropertyData::getStatusValIndex(QString statusVal)
{
    for(int i=0;i<statusConfig.size();i++){
        if(statusConfig[i].statusValue == statusVal){
            return i;
        }
    }
    return -1;
}

int ElemPropertyData::getPoolIndex(QString poolName)
{
    for(int i=0;i<container.size();i++){
        if(container[i].poolName == poolName){
            return i;
        }
    }
    return -1;
}
QList<QString> ElemPropertyData::getTimelineList(QString filePath)
{
    if(timelineListMap.find(filePath) == timelineListMap.end()){
        QList<QString> list = Redream::getInstance()->getTimelineFromRedream(filePath.toStdString());
        timelineListMap[filePath] = list;
        return list;
    }
    return timelineListMap[filePath];
}

void ElemPropertyData::readData(const QJsonObject &json)
{
    if(json.contains("labelName") && json["labelName"].isString()){
        labelName = json["labelName"].toString();
    }
    if(json.contains("pos") && json["pos"].isString()){
        pos = json["pos"].toString();
    }
    if(json.contains("maxLayer") && json["maxLayer"].isString()){
        maxLayer = json["maxLayer"].toString();
    }
    if(json.contains("score") && json["score"].isString()){
        score = json["score"].toString();
    }
    if(json.contains("dropConfig") && json["maxLayer"].isString()){
        dropConfig = static_cast<DROPOPT>(json["dropConfig"].toInt());
    }
    if(json.contains("iconPath") && json["iconPath"].isString()){
        iconPath = json["iconPath"].toString();
    }
    if(json.contains("canBeLinked") && json["canBeLinked"].isBool()){
        canBeLinked = json["canBeLinked"].toBool();
    }
    if(json.contains("canMoveAway") && json["canMoveAway"].isBool()){
        canMoveAway = json["canMoveAway"].toBool();
    }
    if(json.contains("isContainer") && json["isContainer"].isBool()){
        isContainer = json["isContainer"].toBool();
    }
    if(json.contains("beatByOrder") && json["isContainer"].isBool()){
        beatByOrder = json["beatByOrder"].toBool();
    }
    //状态与效果动画
    if(json.contains("anims") && json["anims"].isArray()){
        readStatusEffect(json["anims"].toArray());
    }
    //收集动画
    if(json.contains("collAnim") && json["collAnim"].isArray()){
        readCollAnim(json["collAnim"].toArray());
    }
    //状态配置
    if(json.contains("statusConfig") && json["statusConfig"].isArray()){
        readStatusConfigData(json["statusConfig"].toArray());
    }
    //容器配置
    if(json.contains("container") && json["container"].isArray()){
        readContainerConfig(json["container"].toArray());
    }
    //子元素配置
    if(json.contains("childElem") && json["childElem"].isArray()){
        readChildElem(json["childElem"].toArray());
    }
}

void ElemPropertyData::writeData(QJsonObject &json) const
{
    //基础属性
    json["labelName"] = labelName;
    json["pos"] = pos;
    json["maxLayer"] = maxLayer;
    json["score"] = score;
    json["dropConfig"] = static_cast<int>(dropConfig);
    json["iconPath"] = iconPath;
    json["canBeLinked"] = canBeLinked;
    json["canMoveAway"] = canMoveAway;
    json["isContainer"] = isContainer;
    json["beatByOrder"] = beatByOrder;
    json.insert("anims",writeStatusEffect());
    json.insert("collAnim",writeCollAnim());
    json.insert("statusConfig",writeStatusConfigData());
    json.insert("container",writeContainerConfig());
    json.insert("childElem",writeChildElem());
}

///读入状态与效果动画数据
void ElemPropertyData::readStatusEffect(const QJsonArray &arr)
{
    statusEffect.clear();
    statusEffect.reserve(arr.size());
    for(int i = 0;i < arr.size();i++){
        QJsonObject animObj = arr[i].toObject();
        StatusEffect anim(animObj["name"].toString());
        anim.res = animObj["res"].toString();
        anim.timeline = animObj["timeline"].toString();
        anim.zOrder = animObj["zOrder"].toString();
        anim.audio = animObj["audio"].toString();
        statusEffect.append(anim);
    }
}

///写入状态与效果动画数据
QJsonArray ElemPropertyData::writeStatusEffect() const
{
    QJsonArray animArray;
    for(const StatusEffect &anim:statusEffect)
    {
        QJsonObject animObj;
        animObj["name"] = anim.name;
        animObj["res"] = anim.res;
        animObj["timeline"] = anim.timeline;
        animObj["zOrder"] = anim.zOrder;
        animObj["audio"] = anim.audio;
        animArray.append(animObj);
    }
    return animArray;
}

///读入收集动画数据
void ElemPropertyData::readCollAnim(const QJsonArray &arr)
{
    collAnim.clear();
    collAnim.reserve(arr.size());
    for(int i=0;i<arr.size();i++){
        QJsonObject collAnimObj = arr[i].toObject();
        CollAnim coll(collAnimObj["name"].toString());
        coll.type = collAnimObj["type"].toString();
        coll.dataMap = readStrStrMap(collAnimObj["dataMap"].toObject());
        collAnim.append(coll);
    }
}

///读一个string-string map数据
QMap<QString,QString> ElemPropertyData::readStrStrMap(const QJsonObject &obj)
{
    QMap<QString,QString> data;
    QStringList keys = obj.keys();
    for(int i=0;i<keys.size();i++)
    {
        QString key = keys[i];
        data[key] = obj[key].toString();
    }
    return data;
}

///写收集动画数据
QJsonArray ElemPropertyData::writeCollAnim() const
{
    QJsonArray collAnimArray;
    for(const CollAnim &coll:collAnim){
        QJsonObject collAnimObj;
        collAnimObj["name"] = coll.name;
        collAnimObj["type"] = coll.type;
        collAnimObj["dataMap"] = writeStrStrMap(coll.dataMap);
        collAnimArray.append(collAnimObj);
    }
    return collAnimArray;
}
///写string-string map数据
QJsonObject ElemPropertyData::writeStrStrMap(const QMap<QString,QString> &data) const
{
    QStringList keys = data.keys();
    QJsonObject dataObj;
    for(int i=0;i<keys.size();i++)
    {
        QString key = keys[i];
        dataObj.insert(key,data[key]);
    }
    return dataObj;
}
///读状态配置数据
void ElemPropertyData::readStatusConfigData(const QJsonArray &arr)
{
    statusConfig.clear();
    statusConfig.reserve(arr.size());
    for(int i=0;i<arr.size();i++){
        QJsonObject statusConfigObj = arr[i].toObject();
        StatusConfig configData(statusConfigObj["statusValue"].toString());
        configData.initAnim = statusConfigObj["initAnim"].toString();
        configData.clickAnim = statusConfigObj["clickAnim"].toString();
        configData.multiHit = statusConfigObj["multiHit"].toBool();
        configData.beatSubItem = statusConfigObj["beatSubItem"].toBool();
        configData.dropable = statusConfigObj["dropable"].toBool();
        configData.needCollect = statusConfigObj["needCollect"].toBool();
        configData.collTargetType = statusConfigObj["collTargetType"].toString();
        configData.collAnim = statusConfigObj["collAnim"].toString();
        readAction(statusConfigObj["action"].toObject(), configData);
        configData.eventConfig = readEventConfig(statusConfigObj["eventConfig"].toArray());
        statusConfig.append(configData);
    }
}
///读事件配置表格数据
QVector<ElemPropertyData::EventConfig> ElemPropertyData::readEventConfig(const QJsonArray &arr)
{
    QVector<ElemPropertyData::EventConfig> eventTable;
    eventTable.reserve(arr.size());
    for(int i=0;i<arr.size();i++){
        QJsonObject eventObj = arr[i].toObject();
        EventConfig event;
        event.name = eventObj["name"].toString();
        event.consisColor = eventObj["consisColor"].toBool();
        event.changeMagnitude = eventObj["changeMagnitude"].toInt();
        event.specialEffect = eventObj["specialEffect"].toString();
        event.elimATLattices = eventObj["elimATLattices"].toBool();
        eventTable.append(event);
    }
    return eventTable;
}
void ElemPropertyData::readAction(const QJsonObject &arr, StatusConfig& status)
{
    if (arr.isEmpty()) {
        return;
    }
    for (const QString& k : arr.keys()) {
        status.action = k;
        status.actionConfig = readStrStrMap(arr[k].toObject());
    }
}
///写状态配置数据
QJsonArray ElemPropertyData::writeStatusConfigData() const
{
    QJsonArray statusConfigArray;
    for(const StatusConfig &status:statusConfig){
        QJsonObject statusObj;
        statusObj["statusValue"] = status.statusValue;
        statusObj["initAnim"] = status.initAnim;
        statusObj["clickAnim"] = status.clickAnim;
        statusObj["multiHit"] = status.multiHit;
        statusObj["beatSubItem"] = status.beatSubItem;
        statusObj["dropable"] = status.dropable;
        statusObj["needCollect"] = status.needCollect;
        statusObj["collTargetType"] = status.collTargetType;
        statusObj["collAnim"] = status.collAnim;
        statusObj["action"] =  writeAction(status);
        statusObj.insert("eventConfig",writeEventConfig(status.eventConfig));
        statusConfigArray.append(statusObj);
    }
    return statusConfigArray;
}

QJsonObject ElemPropertyData::writeAction(const StatusConfig &status) const
{
    QJsonObject actionObj;
    if (status.action != "尚未选择") {
        actionObj[status.action] = writeStrStrMap(status.actionConfig);
    }
    return actionObj;
}

///写事件配置表格数据
QJsonArray ElemPropertyData::writeEventConfig(const QVector<EventConfig> &eventConfig) const
{
    QJsonArray eventArray;
    for(const EventConfig &event:eventConfig){
        QJsonObject eventObj;
        eventObj["name"] = event.name;
        eventObj["consisColor"] = event.consisColor;
        eventObj["changeMagnitude"] = event.changeMagnitude;
        eventObj["specialEffect"] = event.specialEffect;
        eventObj["elimATLattices"] = event.elimATLattices;
        eventArray.append(eventObj);
    }
    return eventArray;
}
///读容器池数据
void ElemPropertyData::readContainerConfig(const QJsonArray &arr)
{
    container.clear();
    container.reserve(arr.size());
    for(int i=0;i<arr.size();i++){
        QJsonObject poolObj = arr[i].toObject();
        ContainerConfig pool(poolObj["poolName"].toString());
        pool.type = poolObj["type"].toString();
        pool.table = readContainerTable(poolObj["table"].toArray());
        container.append(pool);
    }
}
///读容器池表格数据
QVector<ElemPropertyData::ContainTable> ElemPropertyData::readContainerTable(const QJsonArray &arr)
{
    QVector<ContainTable> table;
    for(int i=0;i<arr.size();i++){
        QJsonObject containObj = arr[i].toObject();
        ContainTable contain(containObj["key"].toString());
        contain.res = containObj["res"].toString();
        contain.initTimeline = containObj["initTimeline"].toString();
        contain.clickTimeline = containObj["clickTimeline"].toString();
        contain.effectTimeline = containObj["effectTimeline"].toString();
        contain.vanishTimeline = containObj["vanishTimeline"].toString();
        contain.zOrder = containObj["zOrder"].toString();
        table.append(contain);
    }
    return table;
}
///写容器池数据
QJsonArray ElemPropertyData::writeContainerConfig() const
{
    QJsonArray containConfigArray;
    for(const ContainerConfig &contain:container){
        QJsonObject containObj;
        containObj["poolName"] = contain.poolName;
        containObj["type"] = contain.type;
        containObj["table"] = writeContainerTable(contain.table);
        containConfigArray.append(containObj);
    }
    return containConfigArray;
}
///写容器池表格数据
QJsonArray ElemPropertyData::writeContainerTable(const QVector<ContainTable> &containTable) const
{
    QJsonArray tableArray;
    for(const ContainTable &table:containTable){
        QJsonObject tableObj;
        tableObj["key"] = table.key;
        tableObj["res"] = table.res;
        tableObj["initTimeline"] = table.initTimeline;
        tableObj["clickTimeline"] = table.clickTimeline;
        tableObj["effectTimeline"] = table.effectTimeline;
        tableObj["vanishTimeline"] = table.vanishTimeline;
        tableObj["zOrder"] = table.zOrder;
        tableArray.append(tableObj);
    }
    return tableArray;
}
///读子元素数据
void ElemPropertyData::readChildElem(const QJsonArray &arr)
{
    childElem.clear();
    childElem.reserve(arr.size());
    for(int i=0;i<arr.size();i++)
    {
        QJsonObject childElemObj = arr[i].toObject();
        ChildElem elem(childElemObj["name"].toString());
        elem.container = childElemObj["container"].toString();
        childElem.append(elem);
    }
}
///写子元素数据
QJsonArray ElemPropertyData::writeChildElem() const
{
    QJsonArray elemArray;
    for(const ChildElem &elem:childElem){
        QJsonObject childElemObj;
        childElemObj["name"] = elem.name;
        childElemObj["container"] = elem.container;
        elemArray.append(childElemObj);
    }
    return elemArray;
}


//导出数据
void ElemPropertyData::exportData(QJsonObject &json) const
{
    //基础元素
    json["maxNum"] = maxLayer.toInt();
    json["canBeLinked"] = canBeLinked;
    json["isContainer"] = isContainer;
    json["beatByOrder"] = beatByOrder;
    json["beatScore"] = score.toInt();
    json["gridPos"] = exportGridPos();
    json["animation"] = exportAnim();
    json["states"] = exportStates();
    //容器池
    json["subitem_pools"] = exportPools();
    //子元素
    json["subitems"] = exportChildElems();
    //收集动画
    json["collectConfig"] = exportCollAnim();
}
///导出位置
QJsonArray ElemPropertyData::exportGridPos() const
{
    QJsonArray posArray;
    QVector<QVector<int>> posVec = DataManager::getGridPos(pos);
    for(int i=0;i<posVec.size();i++)
    {
        QJsonArray posPair;
        posPair.append(posVec[i][0]);
        posPair.append(posVec[i][1]);
        posArray.append(posPair);
    }
    return posArray;
}
///导出状态与效果动画
QJsonObject ElemPropertyData::exportAnim() const
{
    QJsonObject json;
    for(int i=0;i<statusEffect.size();i++)
    {
        QJsonObject animObj;
        animObj["showCcbi"] = DataManager::getFileName(statusEffect[i].res);
        animObj["showAnim"] = statusEffect[i].timeline;
        animObj["localZOrder"] = statusEffect[i].zOrder.toInt();
        animObj["audio"] = statusEffect[i].audio;
        json.insert(statusEffect[i].name,animObj);
    }
    return json;
}
///导出状态配置
 QJsonObject ElemPropertyData::exportStates() const
 {
     QJsonObject json;
     for(int i=0;i<statusConfig.size();i++)
     {
         QJsonObject statusObj;
         statusObj["playAnim"] = statusConfig[i].initAnim;
         statusObj["tapAnim"] = statusConfig[i].clickAnim;
         statusObj["supportMutliBeats"] = statusConfig[i].multiHit;
         statusObj["canDrop"] = statusConfig[i].dropable;
         statusObj["beatSubItem"] = statusConfig[i].beatSubItem;
         //收集
        if(statusConfig[i].needCollect){
            QJsonObject collObj;
            collObj["goalType"] = statusConfig[i].collTargetType.toInt();
            if(statusConfig[i].collAnim != "尚未选择"){
                collObj["collConf"] = statusConfig[i].collAnim;
            }
            statusObj["collect"] = collObj;
        }
        //动作
        if (statusConfig[i].action != "尚未选择") {
            QJsonObject actionObj;
            QJsonObject cfgObj;
            QMap<QString,QString> data = statusConfig[i].actionConfig;
            QStringList dataKeys = data.keys();
            for(int j=0;j<dataKeys.size();j++)
            {
                QString dataKey = dataKeys[j];
                QString objKey = DataManager::getInstance()->getTempFieldId("actionTemp", statusConfig[i].action, dataKey);
                cfgObj[objKey] = data[dataKey];
            }
            auto id = DataManager::getInstance()->getTempId("actionTemp", statusConfig[i].action);
            actionObj[id] = cfgObj;
            statusObj["action"] = actionObj;
        } else {
            QJsonObject actionObj;
            statusObj["action"] = actionObj;
        }
        //事件
        QJsonObject eventObj;
        QVector<EventConfig> eventVec = statusConfig[i].eventConfig;
        for(int j=0;j<eventVec.size();j++)
        {
            QJsonObject obj;
            obj["needColor"] = eventVec[j].consisColor;
            obj["dataDec"] = eventVec[j].changeMagnitude;
            obj["efx"] = eventVec[j].specialEffect;
            obj["isByGridCnt"] = eventVec[j].elimATLattices;
            eventObj.insert(DataManager::getInstance()->getTempId("eventTemp",eventVec[j].name),obj);
        }
        statusObj["eventHandlers"] = eventObj;
        json.insert(statusConfig[i].statusValue,statusObj);
     }
     return json;
 }
///导出容器池
 QJsonObject ElemPropertyData::exportPools() const
 {
     QJsonObject obj;
     for(int i=0;i<container.size();i++)
     {
         QJsonObject poolObj;
         poolObj["method"] = DataManager::getInstance()->getTempId("poolTemp",container[i].type);
         QJsonObject tableObj;
         QVector<ContainTable> table = container[i].table;
         for(int j=0;j<table.size();j++)
         {
             QJsonObject keyObj;
             keyObj["res"] = DataManager::getFileName(table[j].res);
             keyObj["init"] = table[j].initTimeline;
             keyObj["tap"] = table[j].clickTimeline;
             keyObj["affect"] = table[j].effectTimeline;
             keyObj["beat"] = table[j].vanishTimeline;
             keyObj["localZOrder"] = table[j].zOrder.toInt();
             tableObj[table[j].key] = keyObj;
         }
         poolObj["candidates"] = tableObj;
         obj.insert(container[i].poolName,poolObj);
     }
     return obj;
 }
 ///导出子元素
QJsonArray ElemPropertyData::exportChildElems() const
{
    QJsonArray childElemArray;
    for(int i=0;i<childElem.size();i++)
    {
        QJsonObject childElemObj;
        childElemObj[childElem[i].name] = childElem[i].container;
        childElemArray.append(childElemObj);
    }
    return childElemArray;
}
///导出收集动画
QJsonObject ElemPropertyData::exportCollAnim() const
{
    QJsonObject obj;
    for(int i=0;i<collAnim.size();i++)
    {
        QJsonObject collAnimObj;
        collAnimObj["template"] = DataManager::getInstance()->getTempId("collAnimTemp",collAnim[i].type);
        QMap<QString,QString> data = collAnim[i].dataMap;
        QStringList dataKeys = data.keys();
        for(int j=0;j<dataKeys.size();j++)
        {
            QString dataKey = dataKeys[j];
            QString objKey = DataManager::getInstance()->getTempFieldId("collAnimTemp",collAnim[i].type,dataKey);
            collAnimObj[objKey] = data[dataKey];
        }
        obj[collAnim[i].name] = collAnimObj;
    }
    return obj;
}