public static StageMapRecord RefreshStageStar(StageMapRecord stageMap, string stageID)
{
int level = int.Parse(stageID);
stageMap._StarInfos = GetStarInfo(stageMap, level);
return(stageMap);
}
public void ResetSceneLogic(StageInfoRecord sceneRecord)
{
var mapRecord = StageMapRecord.ReadStageMap(sceneRecord.ScenePath);
BallBox.Instance.Init(mapRecord);
BallBox.Instance.InitBallInfo();
UpdateBalls();
RecordBallDamage.LoadingStageID = sceneRecord.Id;
}
private void Refresh()
{
var mapRecord = StageMapRecord.ReadStageMap(_StageInfo.StageRecord.ScenePath);
for (int i = 0; i < _StarImgs.Count; ++i)
{
if (_StageInfo.IsStarOn(i))
{
_StarImgs[i].gameObject.SetActive(true);
}
else
{
_StarImgs[i].gameObject.SetActive(false);
}
_StarTexts[i].text = StarInfoBase.GetStarConditionStr(mapRecord._StarInfos[i]);
}
Dictionary <ELEMENT_TYPE, int> monsterList = new Dictionary <ELEMENT_TYPE, int>();
foreach (var wave in mapRecord._MapStageLogic._Waves)
{
foreach (var monsterID in wave.NPCs)
{
var monRecord = Tables.TableReader.MonsterBase.GetRecord(monsterID);
if (!monsterList.ContainsKey(monRecord.ElementType))
{
monsterList.Add(monRecord.ElementType, 0);
}
++monsterList[monRecord.ElementType];
}
}
int monImgIdx = 0;
foreach (var monsterType in monsterList)
{
if (monImgIdx == _EnemyImgs.Count)
{
break;
}
_EnemyImgs[monImgIdx].transform.parent.gameObject.SetActive(true);
ResourceManager.Instance.SetImage(_EnemyImgs[monImgIdx], CommonDefine.GetElementIcon(monsterType.Key));
_EnemyTexts[monImgIdx].text = monsterType.Value.ToString();
++monImgIdx;
}
for (int i = monImgIdx; i < _EnemyImgs.Count; ++i)
{
_EnemyImgs[i].transform.parent.gameObject.SetActive(false);
}
}
public static StageMapRecord RandomStage(string stageID, StageMapRecord stageMap)
{
int level = int.Parse(stageID);
List <ELEMENT_TYPE> skillEles = GetStageElementTypes(stageMap);
List <ELEMENT_TYPE> atkEles = GetStageExElement(skillEles);
stageMap._MapStageLogic = RandomMonstersV2(stageID, skillEles, atkEles);
stageMap._StarInfos = GetStarInfo(stageMap, level);
stageMap._HPBall = GetHpBalls(stageMap);
return(stageMap);
}
public static void RefreshMonsterHP(StageMapRecord stageMapRecord)
{
int monsterCnt = 0;
foreach (var wave in stageMapRecord._MapStageLogic._Waves)
{
foreach (var monsterInfo in wave.NPCs)
{
++monsterCnt;
}
}
int minHPRate = 4;
int maxHPRate = 10;
if (monsterCnt == 4)
{
maxHPRate = 8;
}
if (monsterCnt == 5)
{
maxHPRate = 7;
}
if (monsterCnt == 6)
{
minHPRate = 2;
maxHPRate = 6;
}
if (monsterCnt == 7)
{
minHPRate = 2;
maxHPRate = 5;
}
if (monsterCnt == 8)
{
minHPRate = 2;
maxHPRate = 5;
}
if (monsterCnt >= 9)
{
minHPRate = 1;
maxHPRate = 4;
}
foreach (var wave in stageMapRecord._MapStageLogic._Waves)
{
foreach (var monsterInfo in wave.NPCs)
{
RandomMonsterList[monsterInfo].HpRate = Random.Range(minHPRate, maxHPRate + 1);
}
}
}
public void PassStage(StageMapRecord passStageMap)
{
List <AwardItem> awardList = new List <AwardItem>();
_FightingStage = LogicManager.Instance.EnterStageInfo;
var baseAward = AwardManager.AddAward(_FightingStage.StageRecord.AwardType[0], _FightingStage.StageRecord.AwardValue[0]);
awardList.Add(baseAward);
int starCnt = 0;
for (int i = 0; i < 3; ++i)
{
if (_FightingStage.IsStarOn(i))
{
continue;
}
bool isGetStar = true;
if (passStageMap._StarInfos.Count > i)
{
isGetStar = StarInfoBase.isCanGetStar(passStageMap._StarInfos[i]);
}
if (isGetStar)
{
StageDataPack.Instance.SetStageStar(_FightingStage.StageRecord.Id, i);
var starAward = AwardManager.AddAward(_FightingStage.StageRecord.AwardType[i + 1], _FightingStage.StageRecord.AwardValue[i + 1]);
awardList.Add(starAward);
}
}
for (int i = 0; i < 3; ++i)
{
if (_FightingStage.IsStarOn(i))
{
++starCnt;
}
}
StageDataPack.Instance.SaveClass(true);
UIFightBox.HideOptMask();
UIStageSucess.ShowAsyn(_FightingStage.StageRecord, starCnt, awardList);
WeaponDataPack.Instance.RefreshUnLock();
}
public void InitBattle(StageInfoRecord stageRecord, StageMapRecord stageMapRecord)
{
_StageRecord = stageRecord;
_StageMapRecord = stageMapRecord;
_BattleRound = 1;
_StageLogic = stageMapRecord._MapStageLogic;
InitRole();
_CurWave = -1;
_CurOptRound = 0;
StartNextWave();
_IsWinBattle = false;
LogicManager.Instance.EnterFightFinish();
_AlreadyReviveTypes = new List <int>();
}
public static StageMapRecord RefreshStageHPBall(StageMapRecord stageMap)
{
if (stageMap._HPBall.Count == 0)
{
Debug.Log("_HPBall Empty:" + stageMap._ResPath);
return(stageMap);
}
List <int> newHPBalls = new List <int>();
newHPBalls.Add(stageMap._HPBall[0]);
for (int i = 1; i < stageMap._HPBall.Count; ++i)
{
newHPBalls.Add(stageMap._HPBall[i] - stageMap._HPBall[i - 1]);
}
stageMap._HPBall = newHPBalls;
return(stageMap);
}
public void EnterFight(StageDataItem enterStage)
{
EnterStageInfo = enterStage;
GameCore.Instance.UIManager.DestoryAllUI();
Hashtable hash = new Hashtable();
hash.Add("StageRecord", enterStage);
GameCore.Instance.EventController.PushEvent(EVENT_TYPE.EVENT_LOGIC_ENTER_STAGE, this, hash);
UIFightBattleField.ShowAsyn();
var mapRecord = StageMapRecord.ReadStageMap(enterStage.StageRecord.ScenePath);
BallBox.Instance.Init(mapRecord);
BallBox.Instance.InitBallInfo();
BattleField.Instance.InitBattle(enterStage.StageRecord, mapRecord);
}
public static List <ELEMENT_TYPE> GetStageElementTypes(StageMapRecord stageMapRecord)
{
List <ELEMENT_TYPE> recordElements = new List <ELEMENT_TYPE>();
foreach (var trap in stageMapRecord._MapDefaults)
{
ELEMENT_TYPE trapElement = ELEMENT_TYPE.NONE;
if (trap.Value.Contains("11"))
{
trapElement = ELEMENT_TYPE.ICE;
}
else if (trap.Value.Contains("12"))
{
trapElement = ELEMENT_TYPE.FIRE;
}
else if (trap.Value.Contains("13"))
{
trapElement = ELEMENT_TYPE.LIGHT;
}
else if (trap.Value.Contains("14"))
{
trapElement = ELEMENT_TYPE.WIND;
}
else if (trap.Value.Contains("15"))
{
trapElement = ELEMENT_TYPE.DARK;
}
if (trapElement != ELEMENT_TYPE.NONE && !recordElements.Contains(trapElement))
{
recordElements.Add(trapElement);
}
}
return(recordElements);
}
public static void RefreshMonsterAtk(StageMapRecord stageMapRecord)
{
int monsterCnt = 0;
int maxAtk = 0;
foreach (var wave in stageMapRecord._MapStageLogic._Waves)
{
foreach (var monsterID in wave.NPCs)
{
var monTable = RandomMonsterList[monsterID];
if (maxAtk < monTable.AttackRate)
{
maxAtk = monTable.AttackRate;
}
}
}
if (maxAtk < 5)
{
var wave = stageMapRecord._MapStageLogic._Waves[stageMapRecord._MapStageLogic._Waves.Count - 1];
int idx = Random.Range(0, wave.NPCs.Count);
RandomMonsterList[wave.NPCs[idx]].AttackRate = Random.Range(5, 10);
}
}
public static List <string> GetStarInfo(StageMapRecord stageMapRecord, int level)
{
List <string> starInfos = new List <string>();
starInfos.Add("PassStage");
int round = 0;
int monAtk = 0;
int roleAtk = 0;
int waveIdx = 0;
while (round < 50)
{
++round;
roleAtk += 1;
float tempAtk = roleAtk;
foreach (var monster in stageMapRecord._MapStageLogic._Waves[waveIdx].NPCs)
{
//var monsterInfo = TableReader.MonsterBase.GetRecord(monster);
var monsterInfo = RandomMonsterList[monster];
float monHP = GameDataValue.GetMonsterHPRate(monsterInfo.HpRate);
tempAtk = tempAtk - monHP;
}
if (tempAtk > 0)
{
++waveIdx;
roleAtk = 0;
if (waveIdx >= stageMapRecord._MapStageLogic._Waves.Count)
{
break;
}
}
}
Debug.Log("GetStarInfo round:" + round);
int randomStar2 = Random.Range(0, 2);
if (randomStar2 == 0)
{
starInfos.Add("FightRound," + (round + 1));
}
else
{
int remainHpRandom = Random.Range(4, 9);
starInfos.Add("RemainHP," + remainHpRandom);
}
int mapTrapCnt = 0;
foreach (var trap in stageMapRecord._MapDefaults)
{
if (trap.Value.Contains("11") ||
trap.Value.Contains("12") ||
trap.Value.Contains("13") ||
trap.Value.Contains("14"))
{
++mapTrapCnt;
}
}
if (mapTrapCnt > 8)
{
if (level > MAX_LEVEL * 0.7f)
{
starInfos.Add("Trap," + (mapTrapCnt));
}
else if (level > MAX_LEVEL * 0.5f)
{
starInfos.Add("Trap," + (mapTrapCnt - 1));
}
else if (level > MAX_LEVEL * 0.3f)
{
starInfos.Add("Trap," + (mapTrapCnt - 2));
}
else
{
starInfos.Add("Trap," + (mapTrapCnt - 3));
}
}
else
{
float levelRate = (level / MAX_LEVEL) * 0.4f + 0.2f;
starInfos.Add("Bomb," + (int)(round * levelRate));
}
return(starInfos);
}
public static List <int> GetHpBalls(StageMapRecord stageRecord)
{
List <int> fullDamageRound = new List <int>();
int round = 0;
int monAtk = 0;
int roleAtk = 0;
int waveIdx = 0;
while (fullDamageRound.Count < 10)
{
++round;
roleAtk += 1;
float tempAtk = roleAtk;
foreach (var monster in stageRecord._MapStageLogic._Waves[waveIdx].NPCs)
{
var monsterInfo = RandomMonsterList[monster];
float monHP = GameDataValue.GetMonsterHPRate(monsterInfo.HpRate);
tempAtk = tempAtk - monHP;
if (tempAtk <= 0)
{
var atkSkill = TableReader.SkillBase.GetRecord(monsterInfo.AttackSkill);
int skillRound = round - 1;
if (skillRound - atkSkill.PreCD == 0)
{
monAtk += monsterInfo.AttackRate;
}
else if (skillRound - atkSkill.PreCD > 0)
{
if (atkSkill.CD == 0)
{
monAtk += monsterInfo.AttackRate;
}
else if ((skillRound - atkSkill.PreCD) % atkSkill.CD == 0)
{
monAtk += monsterInfo.AttackRate;
}
}
}
}
if (tempAtk > 0)
{
++waveIdx;
roleAtk = 0;
if (waveIdx >= stageRecord._MapStageLogic._Waves.Count)
{
break;
}
}
if (monAtk >= 5)
{
monAtk = 0;
fullDamageRound.Add(round);
}
}
List <int> hpBall = new List <int>();
foreach (var fullDamage in fullDamageRound)
{
int ballCnt = 0;
for (int i = 0; i < fullDamage; ++i)
{
if (stageRecord._MapDefaults.Count > 4)
{
ballCnt += Random.Range(10, 15);
}
else if (stageRecord._MapDefaults.Count > 6)
{
ballCnt += Random.Range(6, 12);
}
else
{
ballCnt += Random.Range(12, 20);
}
}
hpBall.Add(ballCnt);
}
return(hpBall);
}
