private static void ResourceLoad()
{
ConfigDictionary.Instance.LoadLocalConfig("local.xml");
StaticData.path = ConfigDictionary.Instance.table_path;
StaticData.Load <TurrentSDS>("Turrent");
StaticData.Load <UnitSDS>("Unit");
StaticData.Load <AuraSDS>("Aura");
StaticData.Load <BattleSDS>("Battle");
Dictionary <int, TurrentSDS> turrendDic = StaticData.GetDic <TurrentSDS>();
Dictionary <int, UnitSDS> unitDic = StaticData.GetDic <UnitSDS>();
Dictionary <int, AuraSDS> auraDic = StaticData.GetDic <AuraSDS>();
BattleCore.Init(unitDic, turrendDic, auraDic);
string summonStr = File.ReadAllText(ConfigDictionary.Instance.ai_path + "ai_summon.xml");
BattleAi.Init(summonStr);
}
public BattlePage()
{
this.InitializeComponent();
Core = new BattleCore();
Core.Page = this;
battleCanvas.core = Core;
}
private void failCond(Unit target, CondEffect effect, ConditionEffectTypes effect_type, EUnitCondition condition, LogMapTrick.TargetInfo log_mt_ti)
{
SceneBattle instance = SceneBattle.Instance;
if (UnityEngine.Object.op_Implicit((UnityEngine.Object)instance))
{
BattleCore battle = instance.Battle;
if (battle != null)
{
LogFailCondition logFailCondition = battle.Log <LogFailCondition>();
logFailCondition.self = target;
logFailCondition.source = (Unit)null;
logFailCondition.condition = condition;
TacticsUnitController unitController = instance.FindUnitController(target);
if (UnityEngine.Object.op_Implicit((UnityEngine.Object)unitController))
{
unitController.LockUpdateBadStatus(condition, false);
}
}
}
CondAttachment condAttachment = this.createCondAttachment(target, effect, effect_type, condition);
target.SetCondAttachment(condAttachment);
if (log_mt_ti == null || !target.IsUnitCondition(condition))
{
return;
}
log_mt_ti.IsEffective = true;
log_mt_ti.FailCondition |= condition;
}
public BattlePage()
{
this.InitializeComponent();
Core = new BattleCore();
Core.Page = this;
battleCanvas.core = Core;
}
public ItemWeapon(string name,BattleCore.elements Element, int BaseDamage, float AttackInterval)
{
this._Name = name;
this._Element = Element;
this._BaseDamage = BaseDamage;
this._AttackInterval = AttackInterval;
}
private void Start()
{
LocalizedText.LoadTable(SceneReplay.QUEST_TEXTTABLE, false);
FadeController.Instance.ResetSceneFade(0.0f);
this.mState = new StateMachine <SceneReplay>(this);
this.mStartCalled = true;
this.mBattle = new BattleCore();
}
public static Unit GetUnitFromAllUnits(BattleCore bc, int idx)
{
if (bc == null || idx < 0 || idx >= bc.AllUnits.Count)
{
return((Unit)null);
}
return(bc.AllUnits[idx]);
}
// Use this for initialization
void Start()
{
m_BattleCore = new BattleCore();
GameObject go = GameObject.Find("AccountManager");
if (go != null)
{
GameObject.Destroy(go);
}
}
private void OnDestroy()
{
LocalizedText.UnloadTable(SceneReplay.QUEST_TEXTTABLE);
if (this.mBattle == null)
{
return;
}
this.mBattle.Release();
this.mBattle = (BattleCore)null;
}
public static Unit GetUnitFromAllUnits(BattleCore bc, int idx)
{
if (bc == null)
{
bc = !UnityEngine.Object.op_Implicit((UnityEngine.Object)SceneBattle.Instance) ? (BattleCore)null : SceneBattle.Instance.Battle;
}
if (bc == null || idx < 0 || idx >= bc.AllUnits.Count)
{
return((Unit)null);
}
return(bc.AllUnits[idx]);
}
private void RequestUpload()
{
PlayerData player = MonoSingleton <GameManager> .Instance.Player;
BattleCore battle = SceneBattle.Instance.Battle;
string fuid = player.FUID;
long btlId = battle.BtlID;
BattleCore.Record questRecord = battle.GetQuestRecord();
int[] beats = new int[questRecord.drops.Length];
for (int index = 0; index < questRecord.drops.Length; ++index)
{
beats[index] = (int)questRecord.drops[index];
}
int[] itemSteals = new int[questRecord.item_steals.Length];
for (int index = 0; index < questRecord.item_steals.Length; ++index)
{
itemSteals[index] = (int)questRecord.item_steals[index];
}
int[] goldSteals = new int[questRecord.gold_steals.Length];
for (int index = 0; index < questRecord.gold_steals.Length; ++index)
{
goldSteals[index] = (int)questRecord.gold_steals[index];
}
int[] missions = new int[questRecord.bonusCount];
for (int index = 0; index < missions.Length; ++index)
{
missions[index] = (questRecord.allBonusFlags & 1 << index) == 0 ? 0 : 1;
}
int[] achieved = new int[3]
{
!battle.PlayByManually ? 1 : 0,
!battle.IsAllAlive() ? 0 : 1,
0
};
QuestParam quest = MonoSingleton <GameManager> .Instance.FindQuest(GlobalVars.SelectedQuestID);
bool flag = true;
if (quest.bonusObjective != null)
{
for (int index = 0; index < questRecord.bonusCount; ++index)
{
if ((questRecord.allBonusFlags & 1 << index) == 0)
{
flag = false;
break;
}
}
}
achieved[2] = !flag ? 0 : 1;
this.ExecRequest((WebAPI) new ReqBtlComRecordUpload(fuid, btlId, achieved, 0, BtlResultTypes.Win, beats, itemSteals, goldSteals, missions, questRecord.used_items, new Network.ResponseCallback(((FlowNode_Network)this).ResponseCallback)));
}
public static WeatherData ChangeWeather(string iname, List <Unit> units, int now_clock, RandXorshift rand, Unit modify_unit = null, int rank = 1, int rankcap = 1)
{
if (string.IsNullOrEmpty(iname))
{
return((WeatherData)null);
}
if (WeatherData.mCurrentWeatherData != null && WeatherData.mCurrentWeatherData.WeatherParam.Iname == iname)
{
return((WeatherData)null);
}
WeatherData weatherData = new WeatherData();
weatherData.setup(iname, modify_unit, rank, rankcap);
if (weatherData.mWeatherParam == null)
{
return((WeatherData)null);
}
if (WeatherData.mCurrentWeatherSet != null)
{
weatherData.mChangeClock = (OInt)WeatherData.mCurrentWeatherSet.GetNextChangeClock(now_clock, rand);
}
WeatherData.mCurrentWeatherData = weatherData;
SceneBattle instance = SceneBattle.Instance;
if (UnityEngine.Object.op_Implicit((UnityEngine.Object)instance))
{
BattleCore battle = instance.Battle;
if (battle != null)
{
LogWeather logWeather = battle.Log <LogWeather>();
if (logWeather != null)
{
logWeather.WeatherData = weatherData;
}
}
}
if (units != null)
{
using (List <Unit> .Enumerator enumerator = units.GetEnumerator())
{
while (enumerator.MoveNext())
{
Unit current = enumerator.Current;
if (!current.IsGimmick)
{
weatherData.updatePassive(current);
}
}
}
}
return(weatherData);
}
void Deploy(Vector2 v)
{
if (pile.selected == null)
{
Debug.Log("No card selected");
return;
}
if (BattleCore.Deploy(avatar, pile.selected.model, v))
{
pile.Select(null);
}
}
public void Refresh(int offset = 0)
{
SceneBattle instance = SceneBattle.Instance;
if (UnityEngine.Object.op_Equality((UnityEngine.Object)instance, (UnityEngine.Object)null))
{
return;
}
BattleCore battle = instance.Battle;
if (battle == null || battle.Order.Count == 0)
{
return;
}
int num = Mathf.Max(this.Items.Length, this.Units.Length);
for (int index1 = 0; index1 < num; ++index1)
{
BattleCore.OrderData data = battle.Order[index1 % battle.Order.Count];
Unit unit = data.Unit;
if (index1 < this.mCurrentUnits.Length)
{
this.mCurrentUnits[index1] = unit;
}
if (index1 < this.Items.Length && UnityEngine.Object.op_Inequality((UnityEngine.Object) this.Items[index1], (UnityEngine.Object)null))
{
DataSource.Bind <Unit>(this.Items[index1], unit);
DataSource.Bind <BattleCore.OrderData>(this.Items[index1], data);
GameParameter.UpdateAll(this.Items[index1]);
}
if (index1 < this.Units.Length)
{
for (int index2 = 0; index2 < this.Units[index1].Layers.Length; ++index2)
{
if (!UnityEngine.Object.op_Equality((UnityEngine.Object) this.Units[index1].Layers[index2], (UnityEngine.Object)null))
{
DataSource.Bind <Unit>(this.Units[index1].Layers[index2], unit);
GameParameter.UpdateAll(this.Units[index1].Layers[index2]);
}
}
}
}
if (!UnityEngine.Object.op_Inequality((UnityEngine.Object) this.LastUnit, (UnityEngine.Object)null))
{
return;
}
DataSource.Bind <Unit>(this.LastUnit, battle.Order[0].Unit);
DataSource.Bind <BattleCore.OrderData>(this.LastUnit, battle.Order[0]);
GameParameter.UpdateAll(this.LastUnit);
}
public static int GetIdxFromAllUnits(BattleCore bc, Unit unit)
{
if (bc == null || unit == null)
{
return(-1);
}
for (int index = 0; index < bc.AllUnits.Count; ++index)
{
if (bc.AllUnits[index].Equals((object)unit))
{
return(index);
}
}
return(-1);
}
private bool CanNotifyGo()
{
if (Object.op_Equality((Object)HomeWindow.Current, (Object)null) && Object.op_Equality((Object)SceneBattle.Instance, (Object)null) || Object.op_Inequality((Object)HomeWindow.Current, (Object)null) && HomeWindow.Current.IsSceneChanging)
{
return(false);
}
if (Object.op_Inequality((Object)SceneBattle.Instance, (Object)null))
{
BattleCore battle = SceneBattle.Instance.Battle;
if (battle != null && string.IsNullOrEmpty(battle.QuestID))
{
return(false);
}
}
return(true);
}
public static void RemoveEffect(int grid_x, int grid_y)
{
List <TrickData> all = TrickData.mTrickDataLists.FindAll((Predicate <TrickData>)(tdl =>
{
if ((int)tdl.mGridX == grid_x)
{
return((int)tdl.mGridY == grid_y);
}
return(false);
}));
if (all == null || all.Count == 0)
{
return;
}
using (List <TrickData> .Enumerator enumerator = all.GetEnumerator())
{
while (enumerator.MoveNext())
{
TrickData current = enumerator.Current;
SceneBattle instance = SceneBattle.Instance;
if (UnityEngine.Object.op_Implicit((UnityEngine.Object)instance))
{
BattleCore battle = instance.Battle;
if (battle != null)
{
battle.GimmickEventTrickKillCount(current);
}
}
}
}
List <TrickData> trickDataList = new List <TrickData>(TrickData.mTrickDataLists.Count);
using (List <TrickData> .Enumerator enumerator = TrickData.mTrickDataLists.GetEnumerator())
{
while (enumerator.MoveNext())
{
TrickData current = enumerator.Current;
if (!all.Contains(current))
{
trickDataList.Add(current);
}
}
}
TrickData.mTrickDataLists = trickDataList;
}
private static void addTargetAreaEff(int grid_x, int grid_y, TrickData trick_data, List <Unit> target_lists)
{
if (trick_data == null || target_lists == null)
{
return;
}
TrickParam mTrickParam = trick_data.mTrickParam;
if (!mTrickParam.IsAreaEff)
{
return;
}
SceneBattle instance = SceneBattle.Instance;
if (!UnityEngine.Object.op_Implicit((UnityEngine.Object)instance))
{
return;
}
BattleCore battle = instance.Battle;
if (battle == null)
{
return;
}
GridMap <bool> scopeGridMap = battle.CreateScopeGridMap(grid_x, grid_y, mTrickParam.EffShape, (int)mTrickParam.EffScope, (int)mTrickParam.EffHeight);
if (scopeGridMap == null)
{
return;
}
for (int x = 0; x < scopeGridMap.w; ++x)
{
for (int y = 0; y < scopeGridMap.h; ++y)
{
if (scopeGridMap.get(x, y))
{
Unit unitAtGrid = battle.FindUnitAtGrid(x, y);
if (unitAtGrid != null && !target_lists.Contains(unitAtGrid) && trick_data.checkTarget(unitAtGrid, true))
{
target_lists.Add(unitAtGrid);
}
}
}
}
}
public static int GetIdxFromAllUnits(BattleCore bc, Unit unit)
{
if (bc == null)
{
bc = !UnityEngine.Object.op_Implicit((UnityEngine.Object)SceneBattle.Instance) ? (BattleCore)null : SceneBattle.Instance.Battle;
}
if (bc == null || unit == null)
{
return(-1);
}
for (int index = 0; index < bc.AllUnits.Count; ++index)
{
if (bc.AllUnits[index].Equals((object)unit))
{
return(index);
}
}
return(-1);
}
public static bool RemoveEffect(TrickData trick_data)
{
if (trick_data == null || !TrickData.mTrickDataLists.Contains(trick_data))
{
return(false);
}
SceneBattle instance = SceneBattle.Instance;
if (UnityEngine.Object.op_Implicit((UnityEngine.Object)instance))
{
BattleCore battle = instance.Battle;
if (battle != null)
{
battle.GimmickEventTrickKillCount(trick_data);
}
}
TrickData.mTrickDataLists.Remove(trick_data);
return(true);
}
public void Init(GameObject _eventGo)
{
eventGo = _eventGo;
Dictionary <int, UnitSDS> unitDic = StaticData.GetDic <UnitSDS>();
Dictionary <int, TurrentSDS> turrentDic = StaticData.GetDic <TurrentSDS>();
Dictionary <int, AuraSDS> auraDic = StaticData.GetDic <AuraSDS>();
BattleCore.Init(unitDic, turrentDic, auraDic);
battle.Init(SendData, RefreshData, ClientUpdate);
SuperFunction.Instance.AddEventListener <BinaryReader>(eventGo, BATTLE_RECEIVE_DATA, ReceiveData);
InitPos();
InitClickBg();
}
public override void OnActivate(int pinID)
{
switch (pinID)
{
case 100:
GlobalVars.SelectedMultiPlayerUnitIDs = new List <int>();
SceneBattle instance = SceneBattle.Instance;
BattleCore battleCore = !Object.op_Equality((Object)instance, (Object)null) ? instance.Battle : (BattleCore)null;
if (battleCore != null)
{
// ISSUE: object of a compiler-generated type is created
// ISSUE: variable of a compiler-generated type
FlowNode_MultiPlaySelectContinue.\u003COnActivate\u003Ec__AnonStorey20F activateCAnonStorey20F = new FlowNode_MultiPlaySelectContinue.\u003COnActivate\u003Ec__AnonStorey20F();
using (List <Unit> .Enumerator enumerator = battleCore.Units.GetEnumerator())
{
while (enumerator.MoveNext())
{
// ISSUE: reference to a compiler-generated field
activateCAnonStorey20F.unit = enumerator.Current;
// ISSUE: reference to a compiler-generated field
// ISSUE: reference to a compiler-generated field
if (activateCAnonStorey20F.unit.OwnerPlayerIndex > 0 && activateCAnonStorey20F.unit.IsDead)
{
// ISSUE: reference to a compiler-generated method
int index = battleCore.AllUnits.FindIndex(new Predicate <Unit>(activateCAnonStorey20F.\u003C\u003Em__1F7));
GlobalVars.SelectedMultiPlayerUnitIDs.Add(index);
}
}
}
}
GlobalVars.SelectedMultiPlayContinue = GlobalVars.EMultiPlayContinue.CONTINUE;
this.ActivateOutputLinks(1);
break;
case 200:
GlobalVars.SelectedMultiPlayContinue = GlobalVars.EMultiPlayContinue.CANCEL;
GlobalVars.SelectedMultiPlayerUnitIDs = new List <int>();
this.ActivateOutputLinks(1);
break;
}
}
void Update()
{
bool deployed = false;
if (UnityEngine.Random.Range(0, 10) < 1)
{
var card = pile.Cards[UnityEngine.Random.Range(0, pile.HandCount)];
var roff = contextOffset;
var rmin = -128.0f + roff;
var rmax = 128.0f + roff;
if (rmin < -256.0f)
{
rmin = -256.0f;
}
if (256.0f < rmax)
{
rmax = 256.0f;
}
Vector2 v = new Vector2(
UnityEngine.Random.Range(rmin, rmax),
UnityEngine.Random.Range(rmin, rmax));
deployed = BattleCore.Deploy(avatar, card, v);
}
if (deployed)
{
contextOffset = -200;
}
else
{
contextOffset += 0.5f;
if (200.0f < contextOffset)
{
contextOffset = -200;
}
}
}
public void ExecuteGimmickEffect(Unit gimmick, Unit target, LogMapEvent log = null)
{
switch (this.GimmickType)
{
case EEventGimmick.Heal:
int num = 0;
if (!target.IsUnitCondition(EUnitCondition.DisableHeal))
{
int hp = (int)target.MaximumStatus.param.hp;
int val = hp * this.IntValue / 100;
num = Math.Min(target.CalcParamRecover(val), hp - (int)target.CurrentStatus.param.hp);
}
target.Heal(num);
if (log == null)
{
break;
}
log.heal = num;
break;
case EEventGimmick.AtkUp:
case EEventGimmick.DefUp:
case EEventGimmick.MagUp:
case EEventGimmick.MndUp:
case EEventGimmick.RecUp:
case EEventGimmick.SpdUp:
case EEventGimmick.CriUp:
case EEventGimmick.LukUp:
case EEventGimmick.MovUp:
BuffAttachment buff = this.MakeBuff(gimmick, target);
target.SetBuffAttachment(buff, false);
if (log == null)
{
break;
}
BattleCore.SetBuffBits(buff.status, ref log.buff, ref log.debuff);
break;
}
}
private void failCond(Unit target, CondEffect effect, ConditionEffectTypes effect_type, EUnitCondition condition)
{
CondAttachment condAttachment = this.createCondAttachment(target, effect, effect_type, condition);
CondAttachment sameCondAttachment = this.getSameCondAttachment(target, condAttachment);
if (sameCondAttachment != null)
{
sameCondAttachment.turn = condAttachment.turn;
}
else
{
target.SetCondAttachment(condAttachment);
if (!WeatherData.mIsEntryConditionLog)
{
return;
}
SceneBattle instance = SceneBattle.Instance;
if (!UnityEngine.Object.op_Implicit((UnityEngine.Object)instance))
{
return;
}
BattleCore battle = instance.Battle;
if (battle == null)
{
return;
}
LogFailCondition logFailCondition = battle.Log <LogFailCondition>();
logFailCondition.self = target;
logFailCondition.source = (Unit)null;
logFailCondition.condition = condition;
TacticsUnitController unitController = instance.FindUnitController(target);
if (!UnityEngine.Object.op_Implicit((UnityEngine.Object)unitController))
{
return;
}
unitController.LockUpdateBadStatus(condition, false);
}
}
private bool actionKnockBack(Unit target, RandXorshift rand, LogMapTrick.TargetInfo log_mt_ti)
{
if (rand == null || (int)this.mTrickParam.KnockBackRate == 0 || (int)this.mTrickParam.KnockBackVal == 0)
{
return(false);
}
SceneBattle instance = SceneBattle.Instance;
if (!UnityEngine.Object.op_Implicit((UnityEngine.Object)instance))
{
return(false);
}
BattleCore battle = instance.Battle;
if (battle == null)
{
return(false);
}
if (!this.checkKnockBack(target, rand))
{
return(true);
}
EUnitDirection dir = this.reverseDirection[(int)target.Direction];
Grid gridKnockBack = battle.GetGridKnockBack(target, dir, (int)this.mTrickParam.KnockBackVal, (SkillData)null, 0, 0);
if (gridKnockBack == null)
{
return(true);
}
if (log_mt_ti != null)
{
log_mt_ti.IsEffective = true;
log_mt_ti.KnockBackGrid = gridKnockBack;
}
target.x = gridKnockBack.x;
target.y = gridKnockBack.y;
return(true);
}
internal static void UnitTakeEffect(BattleCore _battleCore, Unit _unit, int[] _data, int _time)
{
switch ((EffectType)_data[0])
{
case EffectType.PHYSIC_DAMAGE:
_unit.BePhysicDamaged(null, _data[1], _time);
break;
case EffectType.MAGIC_DAMAGE:
_unit.BeMagicDamaged(null, _data[1], _time);
break;
case EffectType.ADD_AURA:
Aura.Init(_battleCore, _unit, _data[1], Aura.AuraRegisterType.EFFECT, _time);
break;
}
}
public void Refresh()
{
GameUtility.DestroyGameObjects <ListItemEvents>(this.mUnitEvents);
this.mUnitEvents.Clear();
if (Object.op_Equality((Object)this.UnitTemplate, (Object)null) || Object.op_Equality((Object)this.EmptyTemplate, (Object)null) || Object.op_Equality((Object)this.ListParent, (Object)null))
{
return;
}
SceneBattle instance = SceneBattle.Instance;
BattleCore battleCore = (BattleCore)null;
if (Object.op_Implicit((Object)instance))
{
battleCore = instance.Battle;
}
if (battleCore == null)
{
return;
}
this.mSubUnitLists.Clear();
using (List <Unit> .Enumerator enumerator = battleCore.Player.GetEnumerator())
{
while (enumerator.MoveNext())
{
Unit current = enumerator.Current;
if (!battleCore.StartingMembers.Contains(current))
{
this.mSubUnitLists.Add(current);
}
}
}
for (int index1 = 0; index1 < 2; ++index1)
{
if (index1 >= this.mSubUnitLists.Count)
{
ListItemEvents listItemEvents = (ListItemEvents)Object.Instantiate <ListItemEvents>((M0)this.EmptyTemplate);
((Component)listItemEvents).get_transform().SetParent((Transform)this.ListParent, false);
this.mUnitEvents.Add(listItemEvents);
((Component)listItemEvents).get_gameObject().SetActive(true);
}
else
{
Unit mSubUnitList = this.mSubUnitLists[index1];
if (mSubUnitList != null)
{
ListItemEvents listItemEvents = (ListItemEvents)Object.Instantiate <ListItemEvents>((M0)this.UnitTemplate);
DataSource.Bind <Unit>(((Component)listItemEvents).get_gameObject(), mSubUnitList);
((Component)listItemEvents).get_transform().SetParent((Transform)this.ListParent, false);
this.mUnitEvents.Add(listItemEvents);
((Component)listItemEvents).get_gameObject().SetActive(true);
bool flag = !mSubUnitList.IsDead && mSubUnitList.IsEntry && mSubUnitList.IsSub;
Selectable[] componentsInChildren = (Selectable[])((Component)listItemEvents).get_gameObject().GetComponentsInChildren <Selectable>(true);
if (componentsInChildren != null)
{
for (int index2 = componentsInChildren.Length - 1; index2 >= 0; --index2)
{
componentsInChildren[index2].set_interactable(flag);
}
}
listItemEvents.OnSelect = (ListItemEvents.ListItemEvent)(go =>
{
if (this.OnSelectUnit == null)
{
return;
}
Unit dataOfClass = DataSource.FindDataOfClass <Unit>(go, (Unit)null);
if (dataOfClass == null)
{
return;
}
this.OnSelectUnit(dataOfClass);
});
}
}
}
}
public static void SetupTreasureList(GameObject list, GameObject node, GameObject newIcon, GameObject owner, List <GameObject> itemNodes)
{
if (UnityEngine.Object.op_Inequality((UnityEngine.Object)node, (UnityEngine.Object)null))
{
node.SetActive(false);
}
if (UnityEngine.Object.op_Inequality((UnityEngine.Object)newIcon, (UnityEngine.Object)null) && newIcon.get_gameObject().get_activeInHierarchy())
{
newIcon.SetActive(false);
}
PlayerData player = MonoSingleton <GameManager> .Instance.Player;
SceneBattle instance = SceneBattle.Instance;
if (!UnityEngine.Object.op_Inequality((UnityEngine.Object)instance, (UnityEngine.Object)null))
{
return;
}
BattleCore battle = instance.Battle;
BattleCore.Record record = new BattleCore.Record();
battle.GainUnitSteal(record);
battle.GainUnitDrop(record, true);
DataSource.Bind <BattleCore.Record>(owner, record);
if (record == null)
{
return;
}
Transform transform = !UnityEngine.Object.op_Inequality((UnityEngine.Object)list, (UnityEngine.Object)null) ? node.get_transform().get_parent() : list.get_transform();
List <QuestResult.DropItemData> dropItemDataList = new List <QuestResult.DropItemData>();
for (int index1 = 0; index1 < record.items.Count; ++index1)
{
bool flag = false;
for (int index2 = 0; index2 < dropItemDataList.Count; ++index2)
{
if (dropItemDataList[index2].mIsSecret == record.items[index1].mIsSecret)
{
if (dropItemDataList[index2].IsItem)
{
if (dropItemDataList[index2].itemParam == record.items[index1].itemParam)
{
dropItemDataList[index2].Gain(1);
flag = true;
break;
}
}
else if (dropItemDataList[index2].IsConceptCard && dropItemDataList[index2].conceptCardParam == record.items[index1].conceptCardParam)
{
dropItemDataList[index2].Gain(1);
flag = true;
break;
}
}
}
if (!flag)
{
QuestResult.DropItemData dropItemData = new QuestResult.DropItemData();
if (record.items[index1].IsItem)
{
dropItemData.SetupDropItemData(EBattleRewardType.Item, 0L, record.items[index1].itemParam.iname, 1);
if (record.items[index1].itemParam.type != EItemType.Unit)
{
ItemData itemDataByItemParam = player.FindItemDataByItemParam(record.items[index1].itemParam);
dropItemData.IsNew = !player.ItemEntryExists(record.items[index1].itemParam.iname) || (itemDataByItemParam == null || itemDataByItemParam.IsNew);
}
else
{
string iid = record.items[index1].itemParam.iname;
if (player.Units.Find((Predicate <UnitData>)(p => p.UnitParam.iname == iid)) == null)
{
dropItemData.IsNew = true;
}
}
}
else if (record.items[index1].IsConceptCard)
{
dropItemData.SetupDropItemData(EBattleRewardType.ConceptCard, 0L, record.items[index1].conceptCardParam.iname, 1);
}
dropItemData.mIsSecret = record.items[index1].mIsSecret;
if (dropItemData.mIsSecret)
{
dropItemData.IsNew = false;
}
dropItemDataList.Add(dropItemData);
}
}
for (int index = 0; index < dropItemDataList.Count; ++index)
{
GameObject itemObject = ConfigWindow.CreateItemObject(node, newIcon, dropItemDataList[index]);
if (UnityEngine.Object.op_Inequality((UnityEngine.Object)itemObject, (UnityEngine.Object)null))
{
itemObject.get_transform().SetParent(transform, false);
itemNodes.Add(itemObject);
}
}
}
public DefencePatern(BattleCore core) : base(core, new List<int> { 3, 5})
{ }
void OnDestroy()
{
Assert.AreEqual(instance, this);
instance = null;
}
public ItemArmour(BattleCore.elements Element, int BaseArmour)
{
this.Element = Element;
this.BaseArmour = BaseArmour;
}
public AttackSpePatern(BattleCore core) : base(core, new List<int> { 1, 2, 3, 4, 5, 6 })
{ }
void Awake()
{
Assert.IsNull(instance);
instance = this;
}
private void RefreshData()
{
GameManager instance1 = MonoSingleton <GameManager> .Instance;
PlayerData player = instance1.Player;
PartyData partyOfType = player.FindPartyOfType(PlayerPartyTypes.Versus);
VsTowerMatchEndParam towerMatchEndParam = instance1.GetVsTowerMatchEndParam();
if (towerMatchEndParam == null)
{
return;
}
if (partyOfType != null)
{
UnitData unitDataByUniqueId = player.FindUnitDataByUniqueID(partyOfType.GetUnitUniqueID(partyOfType.LeaderIndex));
if (unitDataByUniqueId != null)
{
DataSource.Bind <UnitData>(((Component)this).get_gameObject(), unitDataByUniqueId);
}
}
int versusTowerFloor = player.VersusTowerFloor;
if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.floortxt, (UnityEngine.Object)null))
{
this.floortxt.set_text(versusTowerFloor.ToString());
}
if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.floorEfftxt, (UnityEngine.Object)null))
{
this.floorEfftxt.set_text(versusTowerFloor.ToString());
}
int versusTowerKey = player.VersusTowerKey;
if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.key, (UnityEngine.Object)null))
{
VersusTowerParam versusTowerParam = instance1.GetCurrentVersusTowerParam(-1);
if (versusTowerParam != null)
{
int num1 = 0;
while (num1 < (int)versusTowerParam.RankupNum)
{
GameObject go = (GameObject)UnityEngine.Object.Instantiate <GameObject>((M0)this.key);
if (UnityEngine.Object.op_Inequality((UnityEngine.Object)go, (UnityEngine.Object)null))
{
if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.parent, (UnityEngine.Object)null))
{
go.get_transform().SetParent(this.parent.get_transform(), false);
}
if (versusTowerKey > 0)
{
GameUtility.SetAnimatorTrigger(go, this.keyDefAnim);
}
this.mCreateKey.Add(go);
}
++num1;
--versusTowerKey;
}
this.key.SetActive(false);
SceneBattle instance2 = SceneBattle.Instance;
if (UnityEngine.Object.op_Inequality((UnityEngine.Object)instance2, (UnityEngine.Object)null))
{
BattleCore battle = instance2.Battle;
if (battle != null)
{
BattleCore.Record questRecord = battle.GetQuestRecord();
if (questRecord.result == BattleCore.QuestResult.Win)
{
int num2 = !towerMatchEndParam.rankup ? towerMatchEndParam.key : (int)versusTowerParam.RankupNum;
this.mAnimKeyIndex = player.VersusTowerKey;
this.mMaxKeyCount = Mathf.Min(num2, (int)versusTowerParam.RankupNum);
this.mUpdateFloor = towerMatchEndParam.rankup;
this.mBattleRes = VersusTowerKey.RESULT.WIN;
if (this.mUpdateFloor)
{
if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.arrivalNumText, (UnityEngine.Object)null))
{
this.arrivalNumText.set_text(towerMatchEndParam.floor.ToString() + LocalizedText.Get("sys.MULTI_VERSUS_FLOOR"));
}
if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.arrivalEffNumText, (UnityEngine.Object)null))
{
this.arrivalEffNumText.set_text(towerMatchEndParam.floor.ToString() + LocalizedText.Get("sys.MULTI_VERSUS_FLOOR"));
}
}
}
else if (questRecord.result == BattleCore.QuestResult.Lose && (int)versusTowerParam.LoseNum > 0)
{
this.mAnimKeyIndex = player.VersusTowerKey - 1;
this.mMaxKeyCount = Math.Max(towerMatchEndParam.key, 0);
this.mUpdateFloor = this.mAnimKeyIndex < 0 && (int)versusTowerParam.DownFloor > 0;
this.mBattleRes = VersusTowerKey.RESULT.LOSE;
if (this.mUpdateFloor && UnityEngine.Object.op_Inequality((UnityEngine.Object) this.arrivalNumText, (UnityEngine.Object)null))
{
this.arrivalNumText.set_text(Math.Max(towerMatchEndParam.floor, 1).ToString());
}
}
else
{
this.mBattleRes = VersusTowerKey.RESULT.DRAW;
}
}
}
if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.infoText, (UnityEngine.Object)null))
{
this.infoText.SetActive(this.mBattleRes == VersusTowerKey.RESULT.WIN && (int)versusTowerParam.RankupNum > 0);
}
}
}
if (!this.mUpdateFloor)
{
return;
}
this.SetButtonText(true);
}
public DefenceSpePatern(BattleCore core) : base(core, new List<int> { 1, 6, 5, 4, 3, 2 })
{ }
public Patern(BattleCore core, List<int> patern)
{
this.patern = patern;
Core = core;
}
public UseToolsPatern(BattleCore core) : base(core, new List<int> { 3, 5, 2, 6 })
{ }
public ItemMisc(BattleCore.elements Element, int BaseAmount)
{
this.Element = Element;
this.BaseAmount = BaseAmount;
}
void Awake()
{
PopUpManager.getInstance().init();
BattleCore core = new BattleCore();
BattleGlobal.Core = core;
}
public ItemWeapon(BattleCore.elements Element, int BaseDamage)
{
this._Element = Element;
this._BaseDamage = BaseDamage;
}
