private void GetGoNextData()
{
ShipRecoveryType recovery = ShipRecoveryType.None;
if (RetentionData.GetData().ContainsKey("shipRecoveryType"))
{
recovery = (ShipRecoveryType)((int)RetentionData.GetData().get_Item("shipRecoveryType"));
}
if ((int)RetentionData.GetData().get_Item("rootType") == 0)
{
SingletonMonoBehaviour <FadeCamera> .Instance.SetActive(false);
this.UpdateUIMapManager();
}
else
{
this.UpdateUIMapManager();
SortieMapTaskManager._uiMapManager.InitAfterBattle();
if (SingletonMonoBehaviour <FadeCamera> .Instance.isFadeOut)
{
Observable.Timer(TimeSpan.FromSeconds(0.5)).Subscribe(delegate(long _)
{
SingletonMonoBehaviour <FadeCamera> .Instance.FadeIn(0.2f, delegate
{
this.GoNext(recovery);
});
});
}
}
}
private DamagedStates __GetDamageEvent(DamageState_Battle before, DamageState_Battle after)
{
if (before != after)
{
if (after == DamageState_Battle.Shouha)
{
return(DamagedStates.Shouha);
}
if (after == DamageState_Battle.Tyuuha)
{
return(DamagedStates.Tyuuha);
}
if (after == DamageState_Battle.Taiha)
{
return(DamagedStates.Taiha);
}
if (after == DamageState_Battle.Gekichin)
{
ShipRecoveryType shipRecoveryType = Utils.__HasRecoveryItem__(this.SlotitemListBefore, this.SlotitemExBefore);
if (shipRecoveryType == ShipRecoveryType.None)
{
return(DamagedStates.Gekichin);
}
if (shipRecoveryType == ShipRecoveryType.Personnel)
{
return(DamagedStates.Youin);
}
if (shipRecoveryType == ShipRecoveryType.Goddes)
{
return(DamagedStates.Megami);
}
}
}
return(DamagedStates.None);
}
private void GetGoNextData()
{
ShipRecoveryType recovery = ShipRecoveryType.None;
if (RetentionData.GetData().ContainsKey("shipRecoveryType"))
{
recovery = (ShipRecoveryType)(int)RetentionData.GetData()["shipRecoveryType"];
}
if ((int)RetentionData.GetData()["rootType"] == 0)
{
SingletonMonoBehaviour <FadeCamera> .Instance.SetActive(isActive : false);
UpdateUIMapManager();
return;
}
UpdateUIMapManager();
_uiMapManager.InitAfterBattle();
if (SingletonMonoBehaviour <FadeCamera> .Instance.isFadeOut)
{
Observable.Timer(TimeSpan.FromSeconds(0.5)).Subscribe(delegate
{
SingletonMonoBehaviour <FadeCamera> .Instance.FadeIn(0.2f, delegate
{
GoNext(recovery);
});
});
}
}
private void Awake()
{
SortieBattleTaskManager._clsInput = new KeyControl(0, 0, 0.4f, 0.1f);
SortieBattleTaskManager._iRecoveryType = ShipRecoveryType.None;
SortieBattleTaskManager._clsTasks = this.SafeGetComponent <SceneTasksMono>();
SortieBattleTaskManager._clsTasks.Init();
SortieBattleTaskManager._iMode = (SortieBattleTaskManager._iModeReq = SortieBattleMode.SortieBattleMode_BEF);
this._camTransitionCamera.set_enabled(false);
}
private void Awake()
{
_clsInput = new KeyControl();
_iRecoveryType = ShipRecoveryType.None;
_clsTasks = this.SafeGetComponent <SceneTasksMono>();
_clsTasks.Init();
_iMode = (_iModeReq = SortieBattleMode.SortieBattleMode_BEF);
_camTransitionCamera.enabled = false;
}
protected void UpdateMode()
{
if (_iModeReq == SortieBattleMode.SortieBattleMode_BEF)
{
return;
}
switch (_iModeReq)
{
case SortieBattleMode.SortieBattleMode_ST:
if (_clsTasks.Open(_clsSortieMapTaskManager) < 0)
{
return;
}
break;
case SortieBattleMode.Battle:
if (_clsBattleTaskManager == null)
{
_clsBattleTaskManager = BattleTaskManager.Instantiate(((Component)_clsSortieBattlePrefabFile.prefabBattleTaskManager).GetComponent <BattleTaskManager>(), delegate(ShipRecoveryType x)
{
_iRecoveryType = x;
ReqMode(SortieBattleMode.SortieBattleMode_ST);
Mem.DelComponentSafe(ref _clsBattleTaskManager);
});
CheckDiscardSortieMapTaskManager();
}
break;
case SortieBattleMode.BattleCut:
if (_clsBattleCutManager == null)
{
_clsBattleCutManager = BattleCutManager.Instantiate(((Component)GetSortieBattlePrefabFile().prefabBattleCutManager).GetComponent <BattleCutManager>(), Vector3.left * 20f);
_clsBattleCutManager.StartBattleCut(GetMapManager(), delegate
{
_clsSortieMapTaskManager.GetCamera().isCulling = true;
}, delegate(ShipRecoveryType x)
{
_iRecoveryType = x;
ReqMode(SortieBattleMode.SortieBattleMode_ST);
Mem.DelComponentSafe(ref _clsBattleCutManager);
});
CheckDiscardSortieMapTaskManager();
}
break;
}
_iMode = _iModeReq;
_iModeReq = SortieBattleMode.SortieBattleMode_BEF;
}
public void Decide()
{
_isInputPossible = false;
_listLabelButton.ForEach(delegate(UILabelButton x)
{
x.toggle.enabled = false;
});
UIBattleCutNavigation navigation = BattleCutManager.GetNavigation();
navigation.Hide(Defines.PHASE_FADE_TIME, null);
ShipRecoveryType type = BattleUtils.GetShipRecoveryType(_iSelectType);
Hide().setOnComplete((Action) delegate
{
Dlg.Call(ref _actOnDecide, _iSelectType, type);
});
}
public static void EndBattleCut(ShipRecoveryType iType)
{
Dlg.Call(ref BattleCutManager._actOnStartFadeOut);
List <UIPanel> panels = new List <UIPanel>(Enumerable.Where <UIPanel>(BattleCutManager.Instance.GetComponentsInChildren <UIPanel>(), (UIPanel x) => x.alpha != 0f));
BattleCutManager.Instance.get_transform().LTValue(1f, 0f, Defines.PHASE_FADE_TIME).setEase(LeanTweenType.linear).setOnUpdate(delegate(float x)
{
panels.ForEach(delegate(UIPanel y)
{
y.alpha = x;
});
}).setOnComplete(delegate
{
BattleCutManager.Instance.SetActive(false);
Dlg.Call <ShipRecoveryType>(ref BattleCutManager._actOnFinishedRecoveryType, iType);
});
}
public void Decide()
{
this._isInputPossible = false;
this._listLabelButton.ForEach(delegate(UILabelButton x)
{
x.toggle.set_enabled(false);
});
UIBattleCutNavigation navigation = BattleCutManager.GetNavigation();
navigation.Hide(Defines.PHASE_FADE_TIME, null);
ShipRecoveryType type = BattleUtils.GetShipRecoveryType(this._iSelectType);
this.Hide().setOnComplete(delegate
{
Dlg.Call <AdvancingWithdrawalDCType, ShipRecoveryType>(ref this._actOnDecide, this._iSelectType, type);
});
}
private void GoNext(ShipRecoveryType iRecoveryType)
{
MapManager mm = SortieBattleTaskManager.GetMapManager();
if (mm.GetNextCellCandidate().Count != 0)
{
Instance._ctrlActiveBranching = new CtrlActiveBranching(mm.GetNextCellCandidate(), delegate(int x)
{
mm.GoNext(iRecoveryType, x);
Instance.UpdateUIMapManager();
ReqMode(SortieMapTaskManagerMode.SortieMapTaskManagerMode_ST);
Mem.DelIDisposableSafe(ref Instance._ctrlActiveBranching);
});
return;
}
mm.GoNext(iRecoveryType);
Instance.UpdateUIMapManager();
ReqMode(SortieMapTaskManagerMode.SortieMapTaskManagerMode_ST);
}
public static Hashtable GetRetentionDataFlagshipWreck(MapManager manager, ShipRecoveryType iRecovery)
{
Hashtable hashtable = new Hashtable();
if (manager is SortieMapManager)
{
SortieMapManager value = manager as SortieMapManager;
hashtable.Add("sortieMapManager", value);
hashtable.Add("rootType", 1);
hashtable.Add("shipRecoveryType", iRecovery);
}
else if (manager is RebellionMapManager)
{
RebellionMapManager value2 = manager as RebellionMapManager;
hashtable.Add("rebellionMapManager", value2);
hashtable.Add("rootType", 2);
hashtable.Add("shipRecoveryType", iRecovery);
}
return(hashtable);
}
public static void EndBattleCut(ShipRecoveryType iType)
{
Dlg.Call(ref _actOnStartFadeOut);
List <UIPanel> panels = new List <UIPanel>(from x in Instance.GetComponentsInChildren <UIPanel>()
where x.alpha != 0f
select x);
Instance.transform.LTValue(1f, 0f, Defines.PHASE_FADE_TIME).setEase(LeanTweenType.linear).setOnUpdate(delegate(float x)
{
panels.ForEach(delegate(UIPanel y)
{
y.alpha = x;
});
})
.setOnComplete((Action) delegate
{
Instance.SetActive(isActive: false);
Dlg.Call(ref _actOnFinishedRecoveryType, iType);
});
}
private void GoNext(ShipRecoveryType iRecoveryType)
{
MapManager mm = SortieBattleTaskManager.GetMapManager();
if (mm.GetNextCellCandidate().get_Count() != 0)
{
SortieMapTaskManager.Instance._ctrlActiveBranching = new CtrlActiveBranching(mm.GetNextCellCandidate(), delegate(int x)
{
mm.GoNext(iRecoveryType, x);
SortieMapTaskManager.Instance.UpdateUIMapManager();
SortieMapTaskManager.ReqMode(SortieMapTaskManagerMode.SortieMapTaskManagerMode_ST);
Mem.DelIDisposableSafe <CtrlActiveBranching>(ref SortieMapTaskManager.Instance._ctrlActiveBranching);
});
}
else
{
mm.GoNext(iRecoveryType);
SortieMapTaskManager.Instance.UpdateUIMapManager();
SortieMapTaskManager.ReqMode(SortieMapTaskManagerMode.SortieMapTaskManagerMode_ST);
}
}
public bool GoNext(ShipRecoveryType recovery_type, int selected_next_cell_no)
{
Api_get_Member api_get_mem = new Api_get_Member();
base.UserInfo.__UpdateDeck__(api_get_mem);
Api_Result <Map_ResultFmt> api_Result = (selected_next_cell_no == -1) ? this._req_map.Next(recovery_type) : this._req_map.Next(recovery_type, selected_next_cell_no);
if (api_Result.state == Api_Result_State.Success)
{
this._now_cell_no = this.NextCell.CellNo;
this._next_cell = api_Result.data;
this._passed.Add(this._now_cell_no);
if (this._map.MapHP != null && api_Result.data.MapHp != null)
{
this._map.MapHP.__Update__(api_Result.data.MapHp);
}
if (this._next_cell.Event_id == enumMapEventType.ItemGet)
{
this._items.Add(this.GetItemEvent());
}
return(true);
}
return(false);
}
private void OnDecideAdvancingWithdrawal(AdvancingWithdrawalDCType iType, ShipRecoveryType iRecoveryType)
{
RetentionData.SetData(BattleUtils.GetRetentionDataAdvancingWithdrawalDC(BattleCutManager.GetMapManager(), iRecoveryType));
switch (iType)
{
case AdvancingWithdrawalDCType.Withdrawal:
if (SingletonMonoBehaviour <FadeCamera> .Instance != null)
{
SingletonMonoBehaviour <FadeCamera> .Instance.SetActive(isActive : true);
SingletonMonoBehaviour <FadeCamera> .Instance.FadeOut(0.2f, delegate
{
Mst_DataManager.Instance.PurgeUIBattleMaster();
SingletonMonoBehaviour <FadeCamera> .Instance.isDrawNowLoading = false;
SingletonMonoBehaviour <AppInformation> .Instance.NextLoadScene = Generics.Scene.Strategy;
Application.LoadLevel(Generics.Scene.LoadingScene.ToString());
});
}
break;
case AdvancingWithdrawalDCType.Youin:
case AdvancingWithdrawalDCType.Megami:
TrophyUtil.Unlock_At_GoNext();
BattleCutManager.EndBattleCut(iRecoveryType);
break;
case AdvancingWithdrawalDCType.AdvancePrimary:
BattleCutManager.GetMapManager().ChangeCurrentDeck();
BattleCutManager.EndBattleCut(iRecoveryType);
break;
}
SingletonMonoBehaviour <SoundManager> .Instance.soundVolume.BGM = BattleDefines.SOUND_KEEP.BGMVolume;
SingletonMonoBehaviour <SoundManager> .Instance.rawBGMVolume = BattleDefines.SOUND_KEEP.BGMVolume;
Object.Destroy(_prodBCAdvancingWithdrawalDC.gameObject);
Mem.Del(ref _prodBCAdvancingWithdrawalDC);
}
public static Hashtable GetRetentionDataAdvancingWithdrawalDC(MapManager manager, ShipRecoveryType iRecovery)
{
Hashtable hashtable = new Hashtable();
if (manager is SortieMapManager)
{
SortieMapManager sortieMapManager = manager as SortieMapManager;
hashtable.Add("sortieMapManager", sortieMapManager);
hashtable.Add("rootType", 1);
hashtable.Add("shipRecoveryType", iRecovery);
}
else if (manager is RebellionMapManager)
{
RebellionMapManager rebellionMapManager = manager as RebellionMapManager;
hashtable.Add("rebellionMapManager", rebellionMapManager);
hashtable.Add("rootType", 2);
hashtable.Add("shipRecoveryType", iRecovery);
}
return(hashtable);
}
private void GotoSortieMap(ShipRecoveryType iType)
{
Dlg.Call(ref _actOnFinished, iType);
}
public bool GoNext(ShipRecoveryType recovery_type)
{
return(this.GoNext(recovery_type, -1));
}
