private bool OnKeyControlCross()
{
if (!mKeyController.IsRun)
{
return(false);
}
if (mStageConfirm.Shown)
{
Debug.Log("Shown:Hide");
mRouletteSelector.controllable = true;
mRouletteSelector.ScaleForce(0.3f, 1f);
OnBackSelectStageCover();
return(true);
}
UnityEngine.Object.Destroy(mTransform_AnimationTile.gameObject);
mTransform_StageCovers.SetActive(isActive: false);
TweenAlpha.Begin(GameObject.Find("Information Root"), 0.3f, 1f);
TweenAlpha.Begin(GameObject.Find("Map_BG"), 0.3f, 1f);
Transform transform = mTransform_StageCovers.Find("UIStageCovers");
foreach (Transform item in transform)
{
UnityEngine.Object.Destroy(item.gameObject);
}
StrategyTopTaskManager.GetSailSelect().moveCharacterScreen(isEnter: true, null);
StrategyTopTaskManager.Instance.ShipIconManager.SetVisible(isVisible: true);
List <int> openTileIDs = StrategyTopTaskManager.Instance.GetAreaMng().tileRouteManager.CreateOpenTileIDs();
StrategyTopTaskManager.Instance.GetAreaMng().tileRouteManager.UpdateTileRouteState(openTileIDs);
StrategyTopTaskManager.Instance.TileManager.SetVisible(isVisible: true);
StrategyTopTaskManager.ReqMode(StrategyTopTaskManager.StrategyTopTaskManagerMode.CommandMenu);
return(false);
}
private void OnPushFocusChange()
{
if (StrategyTopTaskManager.GetSailSelect().isRun || StrategyTopTaskManager.GetShipMove().isRun)
{
StrategyTopTaskManager.Instance.GetAreaMng().UpdateSelectArea(areaID);
}
}
public void sortAreaShipIcon(int targetAreaID, bool isMoveCharacter, bool isUpdateOrganizeMessage)
{
DeckModel[] enableDecks = getEnableDecks(StrategyTopTaskManager.GetLogicManager().UserInfo.GetDecksFromArea(targetAreaID));
for (int i = 0; i < enableDecks.Length; i++)
{
int num = enableDecks[i].Id - 1;
Hashtable hashtable = new Hashtable();
hashtable.Add("position", GetShipIconPosition(targetAreaID, i));
hashtable.Add("time", 2f);
hashtable.Add("easetype", iTween.EaseType.linear);
if (i == enableDecks.Length - 1)
{
hashtable.Add("oncomplete", "OnCompleteMove");
hashtable.Add("oncompletetarget", base.gameObject);
int id = SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeck.Id;
hashtable.Add("oncompleteparams", id);
if (isMoveCharacter)
{
CharacterMove = delegate
{
StrategyTopTaskManager.GetSailSelect().moveCharacterScreen(isEnter: true, null);
};
}
}
iTween.MoveTo(allShipIcons[num].gameObject, hashtable);
allShipIcons[num].setColliderEnable(isEnable: false);
}
if (isUpdateOrganizeMessage)
{
OrganizeMessage.UpdateVisible();
}
}
private void OnPushFocusChange()
{
if (!StrategyTopTaskManager.GetSailSelect().isRun&& !StrategyTopTaskManager.GetShipMove().isRun)
{
return;
}
StrategyTopTaskManager.Instance.GetAreaMng().UpdateSelectArea(this.areaID, false);
}
private void ChangeCurrentDeck()
{
SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeck = deck;
StrategyTopTaskManager.GetSailSelect().changeDeck(deck.Id);
StrategyTopTaskManager.Instance.GetAreaMng().ChangeFocusTile(deck.AreaId);
StrategyTopTaskManager.Instance.ShipIconManager.changeFocus();
StrategyTopTaskManager.Instance.UIModel.Character.PlayVoice(SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeck);
}
public void OnMoveCancel()
{
StrategyTopTaskManager.Instance.GetAreaMng().UpdateSelectArea(SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeck.AreaId);
StrategyTopTaskManager.ReqMode(StrategyTopTaskManager.StrategyTopTaskManagerMode.CommandMenu);
StrategyTopTaskManager.GetSailSelect().moveCharacterScreen(isEnter: true, null);
StrategyTopTaskManager.Instance.GetInfoMng().ExitInfoPanel();
StrategyTopTaskManager.Instance.TileManager.ChangeTileColorMove(null);
SoundUtils.PlaySE(SEFIleInfos.CommonCancel1);
Close();
}
public void PlayBoundAnimation()
{
if (StrategyTopTaskManager.GetSailSelect().isRun || StrategyTopTaskManager.GetShipMove().isRun)
{
ScaleAnimation.delay = 0f;
ScaleAnimation.from = new Vector3(0.9f, 0.9f, 0.9f);
ScaleAnimation.ResetToBeginning();
ScaleAnimation.PlayForward();
}
}
public void MoveScreenOut(Action Onfinished, bool isCharacterExit = true, bool isPanelOff = false)
{
this.SidePanel.Exit(this.nowInfoMode);
this.SidePanel.ExitBG(isPanelOff);
this.UpperInfo.Exit();
this.FooterInfo.Exit();
if (isCharacterExit)
{
StrategyTopTaskManager.GetSailSelect().moveCharacterScreen(false, Onfinished);
}
}
protected override void Start()
{
this.OverScene = TaskStrategyCommandMenu.Scene.NONE;
this.keyController = new KeyControl(0, 0, 0.4f, 0.1f);
this.keyController.setChangeValue(-1f, 0f, 1f, 0f);
this.keyController.KeyInputInterval = 0.2f;
this.CommandMenu.Init(this.keyController);
this.currentMenu = TaskStrategyCommandMenu.MENU_NAME.SALLY;
this.sailSelect = StrategyTopTaskManager.GetSailSelect();
this.isInfoOpenEnable = true;
}
protected override void Start()
{
OverScene = Scene.NONE;
keyController = new KeyControl();
keyController.setChangeValue(-1f, 0f, 1f, 0f);
keyController.KeyInputInterval = 0.2f;
CommandMenu.Init(keyController);
currentMenu = MENU_NAME.SALLY;
sailSelect = StrategyTopTaskManager.GetSailSelect();
isInfoOpenEnable = true;
}
private void MoveStart()
{
Debug.Log("MoveStart" + Time.realtimeSinceStartup);
StrategyTopTaskManager.GetSailSelect().isEnableCharacterEnter = true;
moveDeckID = SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeck.Id;
StrategyTopTaskManager.GetLogicManager().Move(moveDeckID, sailID);
StrategyTopTaskManager.Instance.GetAreaMng().UpdateSelectArea(sailID);
SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeckAreaModel = StrategyTopTaskManager.GetLogicManager().Area[sailID];
shipIconManager.sortAreaShipIcon(currentAreaID, isMoveCharacter: false, isUpdateOrganizeMessage: false);
shipIconManager.sortAreaShipIcon(sailID, isMoveCharacter: false, isUpdateOrganizeMessage: true);
returnPrevInfoMode();
StrategyTopTaskManager.ReqMode(StrategyTopTaskManager.StrategyTopTaskManagerMode.StrategyTopTaskManagerMode_ST);
Debug.Log("MoveEnd" + Time.realtimeSinceStartup);
}
private bool pushMove()
{
if (!this.validCheck(TaskStrategyCommandMenu.MENU_NAME.MOVE))
{
return(false);
}
this.CommandMenu.MenuExit();
StrategyTopTaskManager.GetSailSelect().moveCharacterScreen(false, null);
StrategyTopTaskManager.ReqMode(StrategyTopTaskManager.StrategyTopTaskManagerMode.ShipMove);
ShipUtils.PlayShipVoice(SingletonMonoBehaviour <AppInformation> .Instance.FlagShipModel, 14);
this.currentMenu = TaskStrategyCommandMenu.MENU_NAME.MOVE;
this.sceneChange = false;
return(true);
}
private void MoveStart()
{
Debug.Log("MoveStart" + Time.get_realtimeSinceStartup());
StrategyTopTaskManager.GetSailSelect().isEnableCharacterEnter = true;
this.moveDeckID = SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeck.Id;
StrategyTopTaskManager.GetLogicManager().Move(this.moveDeckID, this.sailID);
StrategyTopTaskManager.Instance.GetAreaMng().UpdateSelectArea(this.sailID, false);
SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeckAreaModel = StrategyTopTaskManager.GetLogicManager().Area.get_Item(this.sailID);
this.shipIconManager.sortAreaShipIcon(this.currentAreaID, false, false);
this.shipIconManager.sortAreaShipIcon(this.sailID, false, true);
this.returnPrevInfoMode();
StrategyTopTaskManager.ReqMode(StrategyTopTaskManager.StrategyTopTaskManagerMode.StrategyTopTaskManagerMode_ST);
Debug.Log("MoveEnd" + Time.get_realtimeSinceStartup());
}
private void OnIconTouch()
{
if (!(StrategyTopTaskManager.Instance != null) || StrategyTopTaskManager.GetSailSelect().isRun)
{
popUpShipIcon();
if (SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeck == deck && StrategyTopTaskManager.Instance.TileManager.FocusTile.areaID == deck.AreaId)
{
StrategyTopTaskManager.GetSailSelect().OpenCommandMenu();
}
else
{
ChangeCurrentDeck();
}
}
}
public void MenuEnter(int offset)
{
swipeEvent.enabled = true;
cancelTouch.enabled = true;
myOffset = offset;
StrategyTopTaskManager.GetSailSelect().moveCharacterScreen(isEnter: true, null);
for (int i = 0; i < menuButton.Length; i++)
{
if (i == 0 && MenuEnable[offset])
{
menuButton[i].GetComponent <UIButton>().isEnabled = true;
menuButton[i].GetComponentInChildren <UISprite>().spriteName = MenuButtonName[offset] + "on";
}
else
{
menuButton[i].GetComponent <UIButton>().isEnabled = false;
menuButton[i].GetComponentInChildren <UISprite>().spriteName = MenuButtonName[(int)Util.LoopValue(i + offset, 0f, 6f)] + "off";
}
TweenRotation component = menuButton[i].GetComponent <TweenRotation>();
component.from = default(Vector3);
menuButton[i].transform.eulerAngles = component.from;
if (i <= footerNo)
{
component.to = new Vector3(0f, 0f, i * -25);
}
if (i >= upperNo)
{
component.to = new Vector3(0f, 0f, 25 * footerNo + -25 * (i - upperNo));
}
nowRotateZ[i] = component.to.z;
component.delay = 0.3f;
component.duration = 0.3f;
}
for (int j = 0; j < Buttons.Count; j++)
{
Buttons[j].GetComponent <UISprite>().enabled = true;
Buttons[j].GetComponent <TweenScale>().delay = 0.6f;
}
base.gameObject.GetComponent <UIPlayTween>().Play(forward: true);
for (int k = 0; k < Buttons.Count; k++)
{
Buttons[k].GetComponent <TweenScale>().delay = 0f;
Buttons[k].GetComponent <TweenScale>().from = new Vector3(0.7f, 0.7f, 0.7f);
}
}
public void MenuEnter(int offset)
{
this.swipeEvent.set_enabled(true);
this.cancelTouch.set_enabled(true);
this.myOffset = offset;
StrategyTopTaskManager.GetSailSelect().moveCharacterScreen(true, null);
for (int i = 0; i < this.menuButton.Length; i++)
{
if (i == 0 && this.MenuEnable[offset])
{
this.menuButton[i].GetComponent <UIButton>().isEnabled = true;
this.menuButton[i].GetComponentInChildren <UISprite>().spriteName = this.MenuButtonName[offset] + "on";
}
else
{
this.menuButton[i].GetComponent <UIButton>().isEnabled = false;
this.menuButton[i].GetComponentInChildren <UISprite>().spriteName = this.MenuButtonName[(int)Util.LoopValue(i + offset, 0f, 6f)] + "off";
}
TweenRotation component = this.menuButton[i].GetComponent <TweenRotation>();
component.from = default(Vector3);
this.menuButton[i].get_transform().set_eulerAngles(component.from);
if (i <= this.footerNo)
{
component.to = new Vector3(0f, 0f, (float)(i * -25));
}
if (i >= this.upperNo)
{
component.to = new Vector3(0f, 0f, (float)(25 * this.footerNo + -25 * (i - this.upperNo)));
}
this.nowRotateZ[i] = component.to.z;
component.delay = 0.3f;
component.duration = 0.3f;
}
for (int j = 0; j < this.Buttons.get_Count(); j++)
{
this.Buttons.get_Item(j).GetComponent <UISprite>().set_enabled(true);
this.Buttons.get_Item(j).GetComponent <TweenScale>().delay = 0.6f;
}
base.get_gameObject().GetComponent <UIPlayTween>().Play(true);
for (int k = 0; k < this.Buttons.get_Count(); k++)
{
this.Buttons.get_Item(k).GetComponent <TweenScale>().delay = 0f;
this.Buttons.get_Item(k).GetComponent <TweenScale>().from = new Vector3(0.7f, 0.7f, 0.7f);
}
}
public void MoveScreenIn(Action Onfinished, bool isCharacterEnter = true, bool isSidePanelEnter = true)
{
if (isSidePanelEnter && !this.RotateMenu.isOpen)
{
this.SidePanel.Enter(this.nowInfoMode, 0f);
}
this.UpperInfo.Enter();
this.FooterInfo.Enter(this.nowInfoMode);
this.SidePanel.EnterBG();
if (isCharacterEnter)
{
StrategyTopTaskManager.GetSailSelect().moveCharacterScreen(true, Onfinished);
}
else if (Onfinished != null)
{
this.DelayAction(0.2f, Onfinished);
}
}
private void OnPushFocusArea()
{
if ((StrategyTopTaskManager.GetSailSelect().isRun || StrategyTopTaskManager.GetShipMove().isRun) && StrategyTopTaskManager.Instance.TileManager.FocusTile == this)
{
if (StrategyTopTaskManager.GetSailSelect().isRun)
{
StrategyTopTaskManager.GetSailSelect().OpenCommandMenu();
}
else if (areaID == SingletonMonoBehaviour <AppInformation> .Instance.CurrentAreaID)
{
StrategyTopTaskManager.GetShipMove().OnMoveCancel();
}
else
{
StrategyTopTaskManager.GetShipMove().OnMoveDeside();
}
}
}
private void Start()
{
SingletonMonoBehaviour <UIShortCutMenu> .Instance.IsInputEnable = false;
SingletonMonoBehaviour <FadeCamera> .Instance.SetTransitionRule(FadeCamera.TransitionRule.Transition1);
this.DelayActionFrame(1, delegate
{
int deckID = (!this.isNoneCurrentFlagShip()) ? SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeck.Id : 1;
SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeck = StrategyTopTaskManager.GetSailSelect().changeDeck(deckID);
StrategyTopTaskManager.GetSailSelect().sailSelectFirstInit();
this.GetAreaMng().init();
this.GetInfoMng().init();
SingletonMonoBehaviour <FadeCamera> .Instance.isDrawNowLoading = true;
SingletonMonoBehaviour <NowLoadingAnimation> .Instance.isNowLoadingAnimation = false;
Debug.Log("StrategyTopTaskManager Start");
this.GetAreaMng().UpdateSelectArea(StrategyAreaManager.FocusAreaID, true);
this.TileManager.setVisibleFocusObject(false);
});
}
private void ChangeDeck(bool isNext)
{
int num = isNext ? 1 : (-1);
int id = CurrentDeck.Id;
id = (int)Util.LoopValue(id + num, 1f, StrategyTopTaskManager.GetLogicManager().UserInfo.GetDecks().Length);
StrategyTopTaskManager.GetSailSelect().DeckSelectController.SilentChangeIndex(id - 1);
DeckModel deckModel = StrategyTopTaskManager.GetSailSelect().changeDeck(id);
if (deckModel != null)
{
SoundUtils.PlayOneShotSE(SEFIleInfos.CommonEnter1);
SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeck = deckModel;
CurrentDeck = SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeck;
UpdateView(CurrentDeck);
UpdateFlagShip();
StrategyTopTaskManager.Instance.GetAreaMng().UpdateSelectArea(SingletonMonoBehaviour <AppInformation> .Instance.CurrentAreaID);
OrganizeMng = new OrganizeManager(SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeck.AreaId);
ListParent.Initialize(OrganizeMng, DialogCamera);
}
}
private IEnumerator RebellionTutorialGuide(TutorialModel model)
{
bool TutorialFinished = false;
if (SingletonMonoBehaviour <TutorialGuideManager> .Instance.CheckFirstTutorial(model, TutorialGuideManager.TutorialID.RebellionPreparation))
{
int currentAreaID = StrategyTopTaskManager.Instance.TileManager.FocusTile.areaID;
int TargetAreaID = StrategyTopTaskManager.Instance.TileManager.GetColorChangedTileID();
StrategyTopTaskManager.Instance.GetInfoMng().MoveScreenOut(null);
StrategyTopTaskManager.GetSailSelect().isEnableCharacterEnter = false;
if (SingletonMonoBehaviour <PortObjectManager> .Instance.GetTutorialGuide() != null)
{
SingletonMonoBehaviour <PortObjectManager> .Instance.GetTutorialGuide().Hide();
}
yield return(StrategyTopTaskManager.Instance.UIModel.MapCamera.MoveToTargetTile(TargetAreaID));
yield return(new WaitForSeconds(0.5f));
SingletonMonoBehaviour <TutorialGuideManager> .Instance.CheckAndShowFirstTutorial(model, TutorialGuideManager.TutorialID.RebellionPreparation, delegate
{
SingletonMonoBehaviour <TutorialGuideManager> .Instance.GetTutorialDialog().OnClosed = delegate
{
TutorialFinished = true;
};
});
while (!TutorialFinished)
{
yield return(new WaitForEndOfFrame());
}
StrategyTopTaskManager.GetSailSelect().isEnableCharacterEnter = true;
StrategyTopTaskManager.Instance.GetInfoMng().MoveScreenIn(null);
if (SingletonMonoBehaviour <PortObjectManager> .Instance.GetTutorialGuide() != null)
{
SingletonMonoBehaviour <PortObjectManager> .Instance.GetTutorialGuide().Show();
}
yield return(StrategyTopTaskManager.Instance.UIModel.MapCamera.MoveToTargetTile(currentAreaID));
}
}
private void BackToSailSelect()
{
StrategyTopTaskManager.Instance.UIModel.HowToStrategy.isForceHide();
StrategyTopTaskManager.Instance.GetInfoMng().updateFooterInfo(isUpdateMaterial: true);
dialogKeyController.IsRun = true;
StrategyTopTaskManager.GetSailSelect().CloseCommonDialog();
StrategyTopTaskManager.Instance.setActiveStrategy(isActive: true);
SingletonMonoBehaviour <UIShortCutMenu> .Instance.IsInputEnable = true;
SingletonMonoBehaviour <Live2DModel> .Instance.Enable();
ListParent.SetActive(isActive: false);
if (CurrentDeck.GetFlagShip() == null)
{
StrategyTopTaskManager.GetSailSelect().SearchAndChangeDeck(isNext: false, isSeachLocalArea: false);
StrategyTopTaskManager.Instance.UIModel.Character.ChangeCharacter(SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeck);
}
UIRebellionOrgaizeShipBanner[] shipStates = ShipStates;
foreach (UIRebellionOrgaizeShipBanner uIRebellionOrgaizeShipBanner in shipStates)
{
uIRebellionOrgaizeShipBanner.UnsetFocus();
}
FocusBanner = null;
}
public void OnTouch()
{
if (!StrategyTopTaskManager.GetSailSelect().isRun)
{
return;
}
ShipModel flagShip = SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeck.GetFlagShip();
if (flagShip == null)
{
CommonPopupDialog.Instance.StartPopup("艦隊が編成されていません");
return;
}
Initialize(flagShip);
if (isShow)
{
Hide();
}
else
{
Show();
}
}
private bool pushSally()
{
if (!this.validCheck(TaskStrategyCommandMenu.MENU_NAME.SALLY))
{
return(false);
}
if (StrategyTopTaskManager.Instance.UIModel.MapCamera.GetComponent <iTween>() != null)
{
return(true);
}
this.CommandMenu.MenuExit();
StrategyTopTaskManager.Instance.ShipIconManager.SetVisible(false);
StrategyTopTaskManager.Instance.GetAreaMng().tileRouteManager.HideRoute();
StrategyTopTaskManager.Instance.TileManager.SetVisible(false);
StrategyTopTaskManager.ReqMode(StrategyTopTaskManager.StrategyTopTaskManagerMode.MapSelect);
StrategyTopTaskManager.GetSailSelect().moveCharacterScreen(false, null);
this.sceneChange = false;
this.currentMenu = TaskStrategyCommandMenu.MENU_NAME.SALLY;
if (StrategyTopTaskManager.Instance.TutorialGuide6_2 != null)
{
StrategyTopTaskManager.Instance.TutorialGuide6_2.Hide();
}
return(true);
}
private bool KeyAction()
{
if (DeckSelectController.IsChangeIndex)
{
bool isNext = (DeckSelectController.prevIndexChangeValue == 1) ? true : false;
SearchAndChangeDeck(isNext, isSeachLocalArea: false);
if (prevDeckID != SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeckID)
{
changeDeck(SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeckID);
StrategyTopTaskManager.Instance.UIModel.Character.PlayVoice(SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeck);
if (StrategyTopTaskManager.Instance.UIModel.Character.shipModel != null)
{
StrategyTopTaskManager.GetSailSelect().moveCharacterScreen(isEnter: true, null);
}
}
return(true);
}
if (StrategyAreaManager.sailKeyController.IsChangeIndex)
{
areaManager.UpdateSelectArea(StrategyAreaManager.sailKeyController.Index);
}
else if (DeckSelectController.keyState[1].down)
{
if (SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeck.GetFlagShip() == null)
{
GotoOrganize();
}
else
{
OpenCommandMenu();
}
}
else if (DeckSelectController.keyState[3].down)
{
if (SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeck.GetShipCount() != 0)
{
if (prevDeckID != SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeckID)
{
changeDeck(SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeckID);
StrategyTopTaskManager.Instance.UIModel.Character.PlayVoice(SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeck);
}
if (SingletonMonoBehaviour <PortObjectManager> .Instance.GetTutorialGuide() != null)
{
SingletonMonoBehaviour <PortObjectManager> .Instance.GetTutorialGuide().Hide();
}
uiGoSortieConfirm.SetKeyController(new KeyControl());
commonDialog.OpenDialog(2, DialogAnimation.AnimType.FEAD);
uiGoSortieConfirm.Initialize(SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeck, isConfirm: false);
commonDialog.setCloseAction(delegate
{
KeyControlManager.Instance.KeyController = DeckSelectController;
if (SingletonMonoBehaviour <PortObjectManager> .Instance.GetTutorialGuide() != null)
{
TutorialModel tutorial = StrategyTopTaskManager.GetLogicManager().UserInfo.Tutorial;
SingletonMonoBehaviour <PortObjectManager> .Instance.GetTutorialGuide().Show();
}
});
SoundUtils.PlaySE(SEFIleInfos.CommonEnter1);
}
}
else if (DeckSelectController.keyState[5].down)
{
SingletonMonoBehaviour <PortObjectManager> .Instance.BackToPortOrOrganize();
}
else if (DeckSelectController.keyState[0].down)
{
areaManager.UpdateSelectArea(SingletonMonoBehaviour <AppInformation> .Instance.CurrentAreaID);
}
else if (DeckSelectController.keyState[2].down)
{
if (SingletonMonoBehaviour <PortObjectManager> .Instance.GetTutorialGuide() != null)
{
SingletonMonoBehaviour <PortObjectManager> .Instance.GetTutorialGuide().Hide();
}
commonDialog.OpenDialog(4);
commonDialog.keyController.IsRun = false;
commonDialog.setOpenAction(delegate
{
commonDialog.keyController.IsRun = true;
});
commonDialog.ShikakuButtonAction = delegate
{
Close();
StrategyTopTaskManager.ReqMode(StrategyTopTaskManager.StrategyTopTaskManagerMode.TurnEnd);
StrategyTopTaskManager.GetTurnEnd().TurnEnd();
if (StrategyTopTaskManager.Instance.TutorialGuide8_1 != null)
{
if (SingletonMonoBehaviour <PortObjectManager> .Instance.GetTutorialGuide() != null)
{
SingletonMonoBehaviour <PortObjectManager> .Instance.GetTutorialGuide().HideAndDestroy();
}
StrategyTopTaskManager.Instance.TutorialGuide8_1.HideAndDestroy();
}
};
commonDialog.BatuButtonAction = delegate
{
if (SingletonMonoBehaviour <PortObjectManager> .Instance.GetTutorialGuide() != null)
{
SingletonMonoBehaviour <PortObjectManager> .Instance.GetTutorialGuide().Show();
}
};
}
return(true);
}
private bool KeyAction()
{
if (this.DeckSelectController.IsChangeIndex)
{
bool isNext = this.DeckSelectController.prevIndexChangeValue == 1;
this.SearchAndChangeDeck(isNext, false);
if (this.prevDeckID != SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeckID)
{
this.changeDeck(SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeckID);
StrategyTopTaskManager.Instance.UIModel.Character.PlayVoice(SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeck);
if (StrategyTopTaskManager.Instance.UIModel.Character.shipModel != null)
{
StrategyTopTaskManager.GetSailSelect().moveCharacterScreen(true, null);
}
}
return(true);
}
if (StrategyAreaManager.sailKeyController.IsChangeIndex)
{
this.areaManager.UpdateSelectArea(StrategyAreaManager.sailKeyController.Index, false);
}
else if (this.DeckSelectController.keyState.get_Item(1).down)
{
if (SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeck.GetFlagShip() == null)
{
this.GotoOrganize();
}
else
{
this.OpenCommandMenu();
}
}
else if (this.DeckSelectController.keyState.get_Item(3).down)
{
if (SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeck.GetShipCount() != 0)
{
if (this.prevDeckID != SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeckID)
{
this.changeDeck(SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeckID);
StrategyTopTaskManager.Instance.UIModel.Character.PlayVoice(SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeck);
}
if (SingletonMonoBehaviour <PortObjectManager> .Instance.GetTutorialGuide() != null)
{
SingletonMonoBehaviour <PortObjectManager> .Instance.GetTutorialGuide().Hide();
}
this.uiGoSortieConfirm.SetKeyController(new KeyControl(0, 0, 0.4f, 0.1f));
this.commonDialog.OpenDialog(2, DialogAnimation.AnimType.FEAD);
this.uiGoSortieConfirm.Initialize(SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeck, false);
this.commonDialog.setCloseAction(delegate
{
KeyControlManager.Instance.KeyController = this.DeckSelectController;
if (SingletonMonoBehaviour <PortObjectManager> .Instance.GetTutorialGuide() != null)
{
TutorialModel tutorial = StrategyTopTaskManager.GetLogicManager().UserInfo.Tutorial;
SingletonMonoBehaviour <PortObjectManager> .Instance.GetTutorialGuide().Show();
}
});
SoundUtils.PlaySE(SEFIleInfos.CommonEnter1);
}
}
else if (this.DeckSelectController.keyState.get_Item(5).down)
{
SingletonMonoBehaviour <PortObjectManager> .Instance.BackToPortOrOrganize();
}
else if (this.DeckSelectController.keyState.get_Item(0).down)
{
this.areaManager.UpdateSelectArea(SingletonMonoBehaviour <AppInformation> .Instance.CurrentAreaID, false);
}
else if (this.DeckSelectController.keyState.get_Item(2).down)
{
if (SingletonMonoBehaviour <PortObjectManager> .Instance.GetTutorialGuide() != null)
{
SingletonMonoBehaviour <PortObjectManager> .Instance.GetTutorialGuide().Hide();
}
this.commonDialog.OpenDialog(4, DialogAnimation.AnimType.POPUP);
this.commonDialog.keyController.IsRun = false;
this.commonDialog.setOpenAction(delegate
{
this.commonDialog.keyController.IsRun = true;
});
this.commonDialog.ShikakuButtonAction = delegate
{
base.Close();
StrategyTopTaskManager.ReqMode(StrategyTopTaskManager.StrategyTopTaskManagerMode.TurnEnd);
StrategyTopTaskManager.GetTurnEnd().TurnEnd();
if (StrategyTopTaskManager.Instance.TutorialGuide8_1 != null)
{
if (SingletonMonoBehaviour <PortObjectManager> .Instance.GetTutorialGuide() != null)
{
SingletonMonoBehaviour <PortObjectManager> .Instance.GetTutorialGuide().HideAndDestroy();
}
StrategyTopTaskManager.Instance.TutorialGuide8_1.HideAndDestroy();
}
};
this.commonDialog.BatuButtonAction = delegate
{
if (SingletonMonoBehaviour <PortObjectManager> .Instance.GetTutorialGuide() != null)
{
SingletonMonoBehaviour <PortObjectManager> .Instance.GetTutorialGuide().Show();
}
};
}
return(true);
}
protected override bool Run()
{
if (OverScene != 0)
{
return(true);
}
if (StopExpeditionPanel != null)
{
return(true);
}
keyController.Update();
if (IndexChange != 0 && !keyController.IsChangeIndex)
{
keyController.Index += IndexChange;
IndexChange = 0;
}
if (keyController.IsRightDown())
{
StrategyTopTaskManager.GetSailSelect().DeckSelectController.Index++;
StrategyTopTaskManager.GetSailSelect().SearchAndChangeDeck(isNext: true, isSeachLocalArea: true);
if (StrategyTopTaskManager.GetSailSelect().PrevDeckID != SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeckID)
{
StrategyTopTaskManager.GetSailSelect().changeDeck(SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeckID);
StrategyTopTaskManager.Instance.UIModel.Character.PlayVoice(SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeck);
DeckEnableCheck();
CommandMenu.setFocus();
}
}
else if (keyController.IsLeftDown())
{
StrategyTopTaskManager.GetSailSelect().DeckSelectController.Index--;
StrategyTopTaskManager.GetSailSelect().SearchAndChangeDeck(isNext: false, isSeachLocalArea: true);
if (StrategyTopTaskManager.GetSailSelect().PrevDeckID != SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeckID)
{
StrategyTopTaskManager.GetSailSelect().changeDeck(SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeckID);
StrategyTopTaskManager.Instance.UIModel.Character.PlayVoice(SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeck);
DeckEnableCheck();
CommandMenu.setFocus();
}
}
if (keyController.IsChangeIndex && !SingletonMonoBehaviour <UIShortCutMenu> .Instance.IsFocus)
{
CommandMenu.moveCursol();
}
if (keyController.keyState[14].press || keyController.keyState[10].press)
{
isChangeingDeck = true;
}
else
{
isChangeingDeck = false;
}
if (keyController.keyState[1].down)
{
pushMenuButton();
}
else if (keyController.keyState[0].down)
{
currentMenu = MENU_NAME.SALLY;
ExitCommandMenu();
}
if (keyController.keyState[5].down)
{
pushPort();
}
return(sceneChange);
}
protected override bool Run()
{
if (this.OverScene != TaskStrategyCommandMenu.Scene.NONE)
{
return(true);
}
if (this.StopExpeditionPanel != null)
{
return(true);
}
this.keyController.Update();
if (this.IndexChange != 0 && !this.keyController.IsChangeIndex)
{
this.keyController.Index += this.IndexChange;
this.IndexChange = 0;
}
if (this.keyController.IsRightDown())
{
StrategyTopTaskManager.GetSailSelect().DeckSelectController.Index++;
StrategyTopTaskManager.GetSailSelect().SearchAndChangeDeck(true, true);
if (StrategyTopTaskManager.GetSailSelect().PrevDeckID != SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeckID)
{
StrategyTopTaskManager.GetSailSelect().changeDeck(SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeckID);
StrategyTopTaskManager.Instance.UIModel.Character.PlayVoice(SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeck);
this.DeckEnableCheck();
this.CommandMenu.setFocus();
}
}
else if (this.keyController.IsLeftDown())
{
StrategyTopTaskManager.GetSailSelect().DeckSelectController.Index--;
StrategyTopTaskManager.GetSailSelect().SearchAndChangeDeck(false, true);
if (StrategyTopTaskManager.GetSailSelect().PrevDeckID != SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeckID)
{
StrategyTopTaskManager.GetSailSelect().changeDeck(SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeckID);
StrategyTopTaskManager.Instance.UIModel.Character.PlayVoice(SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeck);
this.DeckEnableCheck();
this.CommandMenu.setFocus();
}
}
if (this.keyController.IsChangeIndex && !SingletonMonoBehaviour <UIShortCutMenu> .Instance.IsFocus)
{
this.CommandMenu.moveCursol();
}
if (this.keyController.keyState.get_Item(14).press || this.keyController.keyState.get_Item(10).press)
{
this.isChangeingDeck = true;
}
else
{
this.isChangeingDeck = false;
}
if (this.keyController.keyState.get_Item(1).down)
{
this.pushMenuButton();
}
else if (this.keyController.keyState.get_Item(0).down)
{
this.currentMenu = TaskStrategyCommandMenu.MENU_NAME.SALLY;
this.ExitCommandMenu();
}
if (this.keyController.keyState.get_Item(5).down)
{
this.pushPort();
}
return(this.sceneChange);
}
protected override void Start()
{
sttm = StrategyTaskManager.GetStrategyTop();
TaskSailSelect = StrategyTopTaskManager.GetSailSelect();
shipIconManager = StrategyTopTaskManager.Instance.ShipIconManager;
}