super-hero/assets/cc-game/scripts/game_data/GameDataConfig.ts

import { JsonAsset } from 'cc';
import { TextAsset } from 'cc';
import { _decorator, Component, Node } from 'cc';
import { UmLog } from '../../../cc-common/cc-util/UmLog';
const { ccclass, property } = _decorator;


@ccclass('GameDataConfig')
export class GameDataConfig extends Component {
    @property(JsonAsset) heroAsset: JsonAsset = null!;
    @property(JsonAsset) enemyAsset: JsonAsset = null!;
    @property(JsonAsset) bossAsset: JsonAsset = null!;
    @property(JsonAsset) activeSkillAsset: JsonAsset = null!;
    @property(JsonAsset) levelDesignAsset: JsonAsset = null!;
    @property(JsonAsset) skillUnlockAsset: JsonAsset = null!;
    @property(JsonAsset) passiveSkillAsset: JsonAsset = null!;

    activeSkillDataConfigMap = {};
    enemyDataConfigMap = {};
    bossDataConfigMap = {};
    passiveSkillDataConfigMap = {};

    protected onLoad(): void {
        this.convertActiveSkillDataConfig();
        this.convertEnemyDataConfig();
        this.convertBossDataConfig();
        this.convertPassiveSkillDataConfig();
    }

    convertActiveSkillDataConfig()
    {
        for (var i = 0; i < this.activeSkillAsset.json.length; i++) {
            var data = this.activeSkillAsset.json[i];
            var converData = {
                No: data["no"],
                Skill_ID: data["skillid"],
                Skill_Name: data["skillname"],
                LevelSkill: data["levelskill"],
                Visual_Name: data["visualname"],
                DMG: data["dmg"],
                Mana: data["mana"],
                Range: data["range"],
            };

            this.activeSkillDataConfigMap[converData.Skill_ID] = converData;
        }
    }

    convertEnemyDataConfig() {
        for (var i = 0; i < this.enemyAsset.json.length; i++) {
            var data = this.enemyAsset.json[i];
            var converData = {
                No: data["no"],
                Name_Id: data["nameid"],
                Group: data["group"],
                Visual_Name: data["visualname"],
                Atk: data["atk"],
                Hp: data["hp"],
                Exp: data["exp"],
                AtkSpeed: data["atkspeed"],
                AtkCoolDown: data["atkcooldown"],
                MoveSpeed: data["movespeed"],
                AtkRange: data["atkrange"],
                VisualRange: data["visualrange"],
                AoEDmg: data["aoedmg"],
                AoERange: data["aoerange"],
            };

            this.enemyDataConfigMap[converData.Name_Id] = converData;
        }
        // this.enemyAsset.destroy();
    }

    convertBossDataConfig() {
        for (var i = 0; i < this.bossAsset.json.length; i++) {
            var data = this.bossAsset.json[i];
            var converData = {
                No: data["no"],
                Name_Id: data["nameid"],
                Group: data["group"],
                Visual_Name: data["visualname"],
                Atk: data["atk"],
                Hp: data["hp"],
                AtkSpeed: data["atkspeed"],
                Exp: data["exp"],
                MoveSpeed: data["movespeed"],
                AtkRange: data["atkrange"],
                AtkCoolDown: data["atkcooldown"],
                VisualRange: data["visualrange"],
                SkillDmg: data["Skilldmg"],
                SkillEffect: data["skilleffect"],
            };

            this.bossDataConfigMap[converData.Name_Id] = converData;
        }
        // this.bossAsset.destroy();
    }

    convertPassiveSkillDataConfig() {
        for (var i = 0; i < this.passiveSkillAsset.json.length; i++) {
            var data = this.passiveSkillAsset.json[i];
            var converData: PassiveSkillInfo = JSON.parse(JSON.stringify(data));
            this.passiveSkillDataConfigMap[converData.skillid] = converData;
        }
    }

    public ACTIVE_SKILL_USE_INFO = [
        { skillId: "AS1", skillName: "AS1", mana: 10, useType: 0, useTime: 2 },
        { skillId: "AS2", skillName: "AS2", mana: 15, useType: 1, useTime: 1 },
        { skillId: "AS3", skillName: "AS3", mana: 30, useType: 0, useTime: 10.0 },
    ];

    getActiveSkill(level: number = 1): ActiveSkillData[] {
        return [this.activeSkillDataConfigMap[`AS1|${level}`], this.activeSkillDataConfigMap[`AS2|${level}`], this.activeSkillDataConfigMap[`AS3|${level}`]];
    }

   getActiveSkillDataByNameAndLevel(skillName: string, skillLevel: number) {
       return this.activeSkillDataConfigMap[`${skillName}|${skillLevel}`];
    }

    getActiveSkillConfig(listSkillCollect: string[]): ActiveSkillData[] {
        var results = new Array();
        for (var i = 0; i < listSkillCollect.length; i++)
        {   
            results.push(this.activeSkillDataConfigMap[listSkillCollect[i]]);
        }
        return results;
    }

    getPassiveSkillDataById(skillId: string)
    {
        return this.passiveSkillDataConfigMap[skillId];
    }

    getPassiveSkillDataByNameAndLevel(skillName: string, skillLevel: number): PassiveSkillInfo {
        return this.passiveSkillDataConfigMap[`${skillName}|${skillLevel}`];
    }

    public HERO_CONTROL_CONFIG = {
        heroMoveSpeed: 5
    }

    public stageInfo = {
        creep: 3, boss: 1
    }

    protected start(): void {
        UmLog.log("hero json => ", this.getHeroDataByLevel(1));

        UmLog.log("leveldesign json => ", this.getLevelDesignByLevel(1).goldcollect);

        UmLog.log("getSkillUnlockDataByLevel json => ", JSON.stringify(this.getSkillUnlockDataByLevel(1)));
    }

    public getHeroDataByLevel(level: number): any
    {
        var data = this.heroAsset.json[level - 1];
        var result = {
            Level: data["level"],
            Atk: data["atk"],
            Hp: data["hp"],
            AtkRange: data["atkrange"],
            AtkSpeed: data["atkspeed"],
            AtkCoolDown: data["atkcooldown"],
            ManaMax: data["manamax"],
            ManaGenerate: data["managenerate"],
            HpHeal: data["hpheal"],
            Exp: data["exp"],
            AoEDmg: data["aoedmg"],
            AoERange: data["aoerange"],

        };
        return result;
    }

    public getEnemyDataConfigById(enemyId: string)
    {
        return this.enemyDataConfigMap[enemyId];
    }

    public getBossDataConfigById(bossId: string) {
        return this.bossDataConfigMap[bossId];
    }

    public getLevelDesignByLevel(level: number): LevelDesignInfo
    {
        var result: LevelDesignInfo = JSON.parse(JSON.stringify(this.levelDesignAsset.json[level - 1]));
        return result;
    }

    public getSkillUnlockDataByLevel(level: number)
    {
        return this.skillUnlockAsset.json[level - 1]["skillunlock"];
    }
}


export interface ActiveSkillData {
    No: number;
    Skill_ID: string;
    Skill_Name: string;
    LevelSkill: number;
    Visual_Name: string;
    DMG: number;
    Mana: number;
    Range: number
}

export interface StageInfo 
{
    creep: number;
    boos: number;
}

export interface LevelDesignInfo {
    level: number;
    atkratio: number;
    hpratio: number;
    expratio: number;
    goldcollect: number;
    formations: string;
    reward: string;
}

export interface PassiveSkillInfo {
    no: number;
    skillid: string;
    skillname: string;
    levelskill: number;
    visualname: string;
    value: number;
}