247 lines
8.3 KiB
TypeScript
247 lines
8.3 KiB
TypeScript
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';
|
|
const { ccclass, property } = _decorator;
|
|
|
|
@ccclass('GameGlobalData')
|
|
export class GameGlobalData extends Component {
|
|
@property(UserDataSaver) public userDataSaver: UserDataSaver = null!;
|
|
@property(GameDataConfig) public gameDataConfig: GameDataConfig = 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 level = 1;
|
|
private levelDesignConfigData: LevelDesignInfo = null;
|
|
public expCollected = 0;
|
|
|
|
public killedData = { creep: 0, boss: 0 };
|
|
public passiveSkillCollected = {};
|
|
public HERO_CONTROL_CONFIG = { heroMoveSpeed : 5};
|
|
|
|
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 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;
|
|
}
|
|
|
|
resetDataSaveBeforeStartNewStage() {
|
|
this.expCollected = 0;
|
|
this.passiveSkillCollected = {};
|
|
this.killedData = { creep: 0, boss: 0 };
|
|
this.HERO_CONTROL_CONFIG = { heroMoveSpeed : 5};
|
|
}
|
|
|
|
listActiveSkillData: ActiveSkillData[];
|
|
listActiveSkillUses = new Array();
|
|
|
|
public prepareDataOnStartNewStage() {
|
|
this.HERO_CONTROL_CONFIG = UmUtil.clone(this.gameDataConfig.HERO_CONTROL_CONFIG);
|
|
this.resetDataSaveBeforeStartNewStage();
|
|
this.userDataSaver.resetData();
|
|
this.level = this.userDataSaver.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.level);
|
|
result.Atk = 50;
|
|
result.Hp = 400;
|
|
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.level) {
|
|
this.levelDesignConfigData = this.gameDataConfig.getLevelDesignByLevel(this.level);
|
|
}
|
|
|
|
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.level++;
|
|
this.level = userDataSaver.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.level++;
|
|
this.level = userDataSaver.level;
|
|
userDataSaver.saveData();
|
|
this.expCollected = 0;
|
|
return true;
|
|
}
|
|
|
|
getListSkillReward(level: number = this.level): 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");
|
|
}
|
|
|
|
// getHeroDataAfterApplyPassiveSkill()
|
|
// {
|
|
// var listNameCollected = Object.keys(this.passiveSkillCollected);
|
|
// var passiveMapCollected = {};
|
|
// for (var skillName in listNameCollected)
|
|
// {
|
|
// //Skill ID = skill name + skill level
|
|
// var skillID = `${skillName}|${this.passiveSkillCollected[skillName]}`;
|
|
// // passiveMapCollected[]
|
|
// }
|
|
// }
|
|
|
|
|
|
}
|