super-hero/assets/cc-game/scripts/global/GameGlobalData.ts

import { _decorator, Component, Node } from 'cc';
import { EGAME_STATE, GameDefine } from '../config/GameDefine';
import { HeroData } from '../game_data/HeroData';
import { EnemyData } from '../game_data/EnemyData';
import { director } from 'cc';
import { Tween } from 'cc';
import { UmClientEvent } from '../../../cc-common/cc-util/UmOneToMultiListener';
import { ActiveSkillData, GameDataConfig, LevelDesignInfo, PassiveSkillInfo } from '../game_data/GameDataConfig';
import { UmLog } from '../../../cc-common/cc-util/UmLog';
import { Vec3 } from 'cc';
import { UserDataSaver } from '../game_data/UserDataSaver';
import { CCClass } from 'cc';
import { SkillInfo } from './GameInterface';
import { UmUtil } from '../../../cc-common/cc-util/UmUtil';
import { MapDataConfig, MapSagaInfo } from '../game_data/MapDataConfig';
const { ccclass, property } = _decorator;

@ccclass('GameGlobalData')
export class GameGlobalData extends Component {
    @property(UserDataSaver) public userDataSaver: UserDataSaver = null!;
    @property(GameDataConfig) public gameDataConfig: GameDataConfig = null!;
    @property(MapDataConfig) public mapDataConfig: MapDataConfig = null!;

    public static Instance: GameGlobalData = null;
    public gameState = EGAME_STATE.INIT;
    public isHeroManaReady: boolean = false;
    public currentActiveSkill: number = 0;
    public lastHeroMoveDirection: Vec3 = new Vec3(0, 1, 0);
    public heroLevel = 1; //hero level
    private levelDesignConfigData: LevelDesignInfo = null;
    public expCollected = 0;
    public goldCollected = 0;
    public ticketCollected = 0;

    public killedCount: any = {};
    public passiveSkillCollected = {};
    public mapObjectCount: any = {};
    public HERO_CONTROL_CONFIG: any = { heroMoveSpeed: 5 };
    public totalWave = 50;
    public waveLevel = 1; //game level
    public currentMapSagaId = 0;
    public currentSagaWaveInfo: MapSagaInfo;
    public ironShieldBonusTime = 0;

    protected onLoad(): void {
        GameGlobalData.Instance = this;
        this.userDataSaver.loadData();
        // this.prepareDataOnStartNewStage();
        UmLog.log("skill_collected = ", JSON.stringify(this.userDataSaver.activeSkillCollected));

    }

    protected start(): void {
        this.checkLevelUp();
    }

    public changeState(state: EGAME_STATE) {
        this.gameState = state;
    }

    public isStatePlay(): boolean {
        return this.gameState == EGAME_STATE.PLAY;
    }

    public isHeroCanMove(): boolean {
        return this.gameState == EGAME_STATE.PLAY || this.gameState == EGAME_STATE.CLEAR_WAVE;
    }

    public isStateWait(): boolean {
        return this.gameState == EGAME_STATE.WAIT;
    }

    public get skillSpecialDataInfo(): any {
        return GameDefine.SKILL_SPECIAL_DATA_INFO;
    }

    public newGame() {
        UmClientEvent.offAll();
        Tween.stopAll();
        director.loadScene("mainscene");
    }

    public manaToTime(mana: number) {
        return mana / GameDefine.MANA_UNIT;
    }

    public timeToMana(time: number) {
        return time * GameDefine.MANA_UNIT;
    }

    resetDataSaveBeforeStartNewMapSaga() {
        this.expCollected = 0;
        this.ticketCollected = 0;
        this.goldCollected = 0;
        this.passiveSkillCollected = {};
        this.killedCount = {};
        this.mapObjectCount = {};
        this.HERO_CONTROL_CONFIG = UmUtil.clone(this.gameDataConfig.HERO_CONTROL_CONFIG);
        this.waveLevel = 1;
        this.totalWave = this.getTotalLevel();
        this.ironShieldBonusTime = 0;
    }

    public setChooseMapSaga(noId: number)
    {
        this.currentMapSagaId = noId;
        this.currentSagaWaveInfo = this.mapDataConfig.getMapSagaInfoByNoId(noId);
        GameGlobalData.Instance.prepareDataOnStartNewStage();
    }

    public get mapLevel(): number {
        return this.currentSagaWaveInfo.start_level + this.waveLevel - 1;
    }

    public getTotalLevel(): number{
        return this.currentSagaWaveInfo.end_level - this.currentSagaWaveInfo.start_level;
    }

    listActiveSkillData: ActiveSkillData[];
    listActiveSkillUses = new Array();

    public prepareDataOnStartNewStage() {
        this.resetDataSaveBeforeStartNewMapSaga();
        this.userDataSaver.resetData();
        this.heroLevel = this.userDataSaver.hero_level;
        this.loadActiveSkillData();
    }

    loadActiveSkillData() {
        var listSkillCollected = this.userDataSaver.activeSkillCollected;
        var listKeys = UmUtil.clone(GameDefine.ACTIVE_SKILL_KEY);

        for (var i = 0; i < listKeys.length; i++) {
            var key = listKeys[i];
            listKeys[i] = `${key}|${listSkillCollected[key]}`;
        }

        this.listActiveSkillData = this.gameDataConfig.getActiveSkillConfig(listKeys);
        UmLog.log("listActiveSkillData => ", JSON.stringify(this.listActiveSkillData));
        this.listActiveSkillUses = this.gameDataConfig.ACTIVE_SKILL_USE_INFO;

        for (var i = 0; i < this.listActiveSkillData.length; i++) {
            var data = this.listActiveSkillData[i];
            this.listActiveSkillUses[i].mana = data.Mana;

            if (i == 2) {
                this.listActiveSkillUses[i].useTime = data.Range;
            }
        }

        UmLog.log("listActiveSkillUses => ", JSON.stringify(this.listActiveSkillUses));
    }

    get heroDataConfig(): any {
        var result = this.gameDataConfig.getHeroDataByLevel(this.heroLevel);
        //hard_hero
        // result.Atk = 1;
        // result.Hp = 1000;
        return result;
    }

    getEnemyDataConfigAfterRatioById(enemyId: string) {
        var enemyData = this.gameDataConfig.getEnemyDataConfigById(enemyId);
        var levelData = this.getLevelDesignConfigData();
        enemyData.atk *= levelData.atkratio;
        enemyData.hp *= levelData.hpratio;
        enemyData.exp *= levelData.expratio;
        return enemyData;
    }

    getBossDataConfigAfterRaitoById(enemyId: string) {
        var bossData = this.gameDataConfig.getBossDataConfigById(enemyId);
        var levelData = this.getLevelDesignConfigData();
        bossData.atk *= levelData.atkratio;
        bossData.hp *= levelData.hpratio;
        bossData.exp *= levelData.expratio;
        return bossData;
    }

    getLevelDesignConfigData(): LevelDesignInfo {
        if (!this.levelDesignConfigData || this.levelDesignConfigData.level != this.waveLevel) {
            this.levelDesignConfigData = this.gameDataConfig.getLevelDesignByLevel(this.waveLevel);
        }

        return this.levelDesignConfigData;
    }

    getExpInlevelNeed(): number {
        return this.heroDataConfig.Exp;
    }

    checkLevelUp(): boolean {
        var userDataSaver = GameGlobalData.Instance.userDataSaver;
        var levelExp = GameGlobalData.Instance.getExpInlevelNeed();

        UmLog.log("checkLevelUp => user exp = ", userDataSaver.expInLevel);
        UmLog.log("checkLevelUp => level exp = ", levelExp);

        if (userDataSaver.expInLevel < levelExp)
            return false;

        userDataSaver.expInLevel -= levelExp;
        userDataSaver.hero_level++;
        this.heroLevel = userDataSaver.hero_level;
        userDataSaver.saveData();
        return true;
    }

    checkLevelUpWithSessionExpCollected(expCollect: number): boolean {
        var userDataSaver = GameGlobalData.Instance.userDataSaver;
        var levelExp = GameGlobalData.Instance.getExpInlevelNeed();
        var expCheck = userDataSaver.expInLevel + expCollect;

        UmLog.log("checkLevelUp => user exp = ", userDataSaver.expInLevel);
        UmLog.log("checkLevelUp => check exp = ", expCheck);
        UmLog.log("checkLevelUp => level exp = ", levelExp);

        if (expCheck < levelExp)
            return false;

        userDataSaver.expInLevel = expCheck - levelExp;
        userDataSaver.hero_level++;
        this.heroLevel = userDataSaver.hero_level;
        userDataSaver.saveData();
        this.expCollected = 0;
        return true;
    }

    getListSkillReward(level: number = this.heroLevel): SkillInfo[] {
        var skillConfig: string = this.gameDataConfig.getSkillUnlockDataByLevel(level);

        var skillSplits = skillConfig.split("_");
        var skillRewards = new Array();

        for (var i = 0; i < skillSplits.length; i++) {
            var skillls = skillSplits[i].split("|");
            if (skillls.length < 2)
                continue;

            var skillInfo: SkillInfo = { skillName: skillls[0], level: Number(skillls[1]) };
            skillRewards.push(skillInfo);
        }

        skillRewards.shuffleArray();
        skillRewards.splice(3, skillRewards.length - 3);
        return skillRewards;
    }

    //Passive Skill

    collectPassiveSkill(skillName: string, plusLevel: number): PassiveSkillInfo {
        var skillLevel = 0;
        if (this.passiveSkillCollected.hasOwnProperty((skillName)))
            skillLevel = this.passiveSkillCollected[skillName];

        skillLevel += plusLevel;
        skillLevel = Math.min(skillLevel, GameDefine.MAX_PASSIVE_SKILL_LEVEL);
        this.passiveSkillCollected[skillName] = skillLevel;
        return this.gameDataConfig.getPassiveSkillDataByNameAndLevel(skillName, skillLevel);
    }

    isActiveSkill(skillName: string) {
        return skillName.includes("AS");
    }

    getGold(): number {
        return this.userDataSaver.gold;
    }

    setGold(value: number) {
        this.userDataSaver.gold = value;
        this.userDataSaver.saveData();
    }

    addGold(value: number) {
        this.userDataSaver.gold += value;
        this.userDataSaver.saveData();
    }

    isClearWave() {

        UmLog.log("KILL CREEP => ", this.killedCount[GameDefine.OBJECT_GROUP.CREEP]);

        return this.waveLevel > this.totalWave ||
            (this.getKilledCount(GameDefine.OBJECT_GROUP.CREEP) >= this.getMapObjectCountByGroup(GameDefine.OBJECT_GROUP.CREEP)
                && this.getKilledCount(GameDefine.OBJECT_GROUP.BOSS) >= this.getMapObjectCountByGroup(GameDefine.OBJECT_GROUP.BOSS)
            && this.getKilledCount(GameDefine.OBJECT_GROUP.GATE) >= this.getMapObjectCountByGroup(GameDefine.OBJECT_GROUP.GATE));
    }

    collectKilledCount(objectGroup: string) {
        objectGroup = objectGroup.toLowerCase();
        var count = this.getKilledCount(objectGroup);
        count++;
        this.killedCount[objectGroup] = count;
        return count;
    }

    getKilledCount(objectGroup: string) {
        objectGroup = objectGroup.toLowerCase();
        var count = 0;
        if (this.killedCount.hasOwnProperty(objectGroup))
            count = this.killedCount[objectGroup];

        return count;
    }

    getMapObjectCountByGroup(objectGroup: string) {
        objectGroup = objectGroup.toLowerCase();
        var count = 0;
        if (this.mapObjectCount.hasOwnProperty(objectGroup))
            count = this.mapObjectCount[objectGroup];

        return count;
    }

    addCountMapOjectGroup(objectGroup: string) {
        objectGroup = objectGroup.toLowerCase();
        var mapObjectCount = GameGlobalData.Instance.mapObjectCount;
        var count = 0;
        if (mapObjectCount.hasOwnProperty(objectGroup))
            count = mapObjectCount[objectGroup];

        count++;
        mapObjectCount[objectGroup] = count;
        return count;
    }



    getRewardData() {
        var rewardData = {};
        rewardData[GameDefine.REWARD_TYPE.GOLD] = this.goldCollected;
        rewardData[GameDefine.REWARD_TYPE.KEY] = this.ticketCollected;
        rewardData[GameDefine.REWARD_TYPE.ENERGY] = this.expCollected;
        return rewardData;
    }

    collectRewardDataWhenClearWave() {
        var levelDataConfig = GameGlobalData.Instance.getLevelDesignConfigData();
        this.goldCollected += levelDataConfig.goldcollect;
        //TODO
    }


}