346 lines
12 KiB
TypeScript
346 lines
12 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';
|
|
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
|
|
}
|
|
|
|
|
|
}
|