コード例 #1
0
        private bool pushDeploy()
        {
            if (!this.validCheck(TaskStrategyCommandMenu.MENU_NAME.DEPLOY))
            {
                return(false);
            }
            this.keyController.IsRun = false;
            this.CommandMenu.MenuExit();
            this.currentMenu = TaskStrategyCommandMenu.MENU_NAME.DEPLOY;
            StrategyTopTaskManager.ReqMode(StrategyTopTaskManager.StrategyTopTaskManagerMode.Deploy);
            Transform transform = StrategyTopTaskManager.Instance.UIModel.OverView.FindChild("Deploy");

            StrategyTopTaskManager.Instance.GetInfoMng().MoveScreenOut(null, false, false);
            StrategyTaskManager.setCallBack(delegate
            {
                StrategyTopTaskManager.Instance.UIModel.Character.get_transform().set_localPosition(StrategyTopTaskManager.Instance.UIModel.Character.getExitPosition());
                StrategyTopTaskManager.Instance.UIModel.Character.isEnter = false;
                StrategyTopTaskManager.Instance.GetInfoMng().MoveScreenIn(null, true, false);
                this.keyController.IsRun = true;
            });
            if (StrategyTopTaskManager.Instance.TutorialGuide9_1 != null)
            {
                if (SingletonMonoBehaviour <PortObjectManager> .Instance.GetTutorialGuide() != null)
                {
                    SingletonMonoBehaviour <PortObjectManager> .Instance.GetTutorialGuide().HideAndDestroy();
                }
                StrategyTopTaskManager.Instance.TutorialGuide9_1.HideAndDestroy();
            }
            this.sceneChange = false;
            return(true);
        }
コード例 #2
0
        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);
        }
コード例 #3
0
 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();
 }
コード例 #4
0
 public void ExitCommandMenu()
 {
     Debug.Log("ExitCommandMenu");
     if (!isChangeingDeck)
     {
         CommandMenu.MenuExit();
         StrategyTopTaskManager.ReqMode(StrategyTopTaskManager.StrategyTopTaskManagerMode.StrategyTopTaskManagerMode_ST);
         StrategyTopTaskManager.Instance.GetInfoMng().EnterInfoPanel(0.4f);
         sceneChange = false;
         SoundUtils.PlayOneShotSE(SEFIleInfos.SE_037);
     }
 }
コード例 #5
0
 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());
 }
コード例 #6
0
 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);
 }
コード例 #7
0
 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);
 }
コード例 #8
0
 private bool pushTurnEnd()
 {
     Debug.Log("ターンエンド");
     StrategyTopTaskManager.GetTurnEnd().TurnEnd();
     this.CommandMenu.MenuExit();
     StrategyTopTaskManager.ReqMode(StrategyTopTaskManager.StrategyTopTaskManagerMode.TurnEnd);
     this.sceneChange = false;
     if (StrategyTopTaskManager.Instance.TutorialGuide8_1 != null)
     {
         if (SingletonMonoBehaviour <PortObjectManager> .Instance.GetTutorialGuide() != null)
         {
             SingletonMonoBehaviour <PortObjectManager> .Instance.GetTutorialGuide().HideAndDestroy();
         }
         StrategyTopTaskManager.Instance.TutorialGuide8_1.HideAndDestroy();
     }
     return(true);
 }
コード例 #9
0
 public void OpenCommandMenu()
 {
     if (StrategyTopTaskManager.GetCommandMenu().CommandMenu.isOpen)
     {
         return;
     }
     changeDeckAreaSelect(StrategyTopTaskManager.Instance.TileManager.FocusTile.areaID);
     StrategyTopTaskManager.Instance.GetInfoMng().ExitInfoPanel();
     if (UnityEngine.Random.Range(0, 3) == 0)
     {
         if (SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeck.GetFlagShip() != null && SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeck.MissionState == MissionStates.NONE)
         {
             ShipUtils.PlayShipVoice(SingletonMonoBehaviour <AppInformation> .Instance.FlagShipModel, 3);
         }
     }
     else
     {
         SoundUtils.PlaySE(SEFIleInfos.CommonEnter1);
     }
     StrategyTopTaskManager.ReqMode(StrategyTopTaskManager.StrategyTopTaskManagerMode.CommandMenu);
     Close();
 }
コード例 #10
0
 private bool CategorySelectMode()
 {
     keyController.SilentChangeIndex(SeachActiveIndex(keyController.Index, Category, keyController.prevIndexChangeValue == 1));
     cursol.transform.position       = Category[keyController.Index].transform.position;
     cursol.transform.localPosition += cursolOffset;
     if (keyController.keyState[1].down)
     {
         ChangeMode(keyController.Index + 1);
     }
     if (keyController.keyState[0].down)
     {
         rootPrefab.SetActive(false);
         SingletonMonoBehaviour <UIShortCutMenu> .Instance.IsInputEnable = true;
         StrategyTopTaskManager.ReqMode(StrategyTopTaskManager.StrategyTopTaskManagerMode.StrategyTopTaskManagerMode_ST);
         return(false);
     }
     if (keyController.keyState[3].down)
     {
         Live2DModel.__DEBUG_MotionNAME_Draw = !Live2DModel.__DEBUG_MotionNAME_Draw;
         CommonPopupDialog.Instance.StartPopup("モ\u30fcション名表示:" + Live2DModel.__DEBUG_MotionNAME_Draw);
     }
     return(true);
 }
コード例 #11
0
 private bool pushInfo()
 {
     if (!this.isInfoOpenEnable)
     {
         return(true);
     }
     this.CommandMenu.MenuExit();
     this.currentMenu = TaskStrategyCommandMenu.MENU_NAME.INFO;
     StrategyTopTaskManager.ReqMode(StrategyTopTaskManager.StrategyTopTaskManagerMode.Info);
     this.keyController.IsRun = false;
     this.sceneChange         = false;
     if (SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeck.GetFlagShip() != null && SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeck.MissionState == MissionStates.NONE)
     {
         ShipUtils.PlayShipVoice(SingletonMonoBehaviour <AppInformation> .Instance.FlagShipModel, 8);
     }
     StrategyTopTaskManager.Instance.GetInfoMng().MoveScreenOut(null, false, false);
     StrategyTopTaskManager.GetAreaInfoTask().setExitAction(delegate
     {
         if (SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeck.MissionState == MissionStates.NONE)
         {
             this.isInfoOpenEnable = false;
             StrategyTopTaskManager.Instance.UIModel.Character.moveCharacterX(StrategyTopTaskManager.Instance.UIModel.Character.getModelDefaultPosX(), 0.4f, delegate
             {
                 this.isInfoOpenEnable = true;
             });
             StrategyTopTaskManager.Instance.GetInfoMng().MoveScreenIn(null, false, false);
         }
         else
         {
             StrategyTopTaskManager.Instance.GetInfoMng().MoveScreenIn(delegate
             {
                 this.isInfoOpenEnable = true;
             }, false, false);
         }
     });
     return(true);
 }
コード例 #12
0
 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);
 }
コード例 #13
0
 protected override bool Run()
 {
     keyController.Update();
     if (!isControl)
     {
         if (keyController.keyState[0].down)
         {
             rootPrefab.SetActive(false);
             StrategyTopTaskManager.ReqMode(StrategyTopTaskManager.StrategyTopTaskManagerMode.StrategyTopTaskManagerMode_ST);
             return(false);
         }
         return(true);
     }
     if (keyController.keyState[1].down)
     {
         SoundUtils.PlaySE(SEFIleInfos.CommonEnter1);
     }
     setMag();
     if (keyController.keyState[6].down && keyController.keyState[5].press)
     {
         Application.LoadLevel(Generics.Scene.Ending.ToString());
     }
     else if (keyController.keyState[5].press && keyController.keyState[2].down)
     {
         App.isInvincible = !App.isInvincible;
         CommonPopupDialog.Instance.StartPopup("無敵モ\u30fcド" + App.isInvincible);
     }
     else if (keyController.keyState[4].press && keyController.keyState[2].down)
     {
         for (int i = 1; i < 15; i++)
         {
             EscortDeckManager escortDeckManager = new EscortDeckManager(i);
             MemberMaxInfo     memberMaxInfo     = StrategyTopTaskManager.GetLogicManager().UserInfo.ShipCountData();
             if (memberMaxInfo.NowCount > 300)
             {
                 for (int j = 0; j < 300 && (StrategyTopTaskManager.GetLogicManager().UserInfo.GetShip(1 + j).IsInEscortDeck() != -1 || !escortDeckManager.ChangeOrganize(6, 1 + j)); j++)
                 {
                 }
             }
             StrategyTopTaskManager.GetLogicManager().Deploy(i, 10, escortDeckManager);
         }
         CommonPopupDialog.Instance.StartPopup("自動配備しました");
     }
     else if (keyController.keyState[6].down && keyController.keyState[4].press)
     {
         CommonPopupDialog.Instance.StartPopup("ゲ\u30fcムクリア!!");
         ForceEnding = true;
     }
     else if (keyController.keyState[6].down && keyController.keyState[3].press)
     {
         if (turnend == null)
         {
             turnend = StartCoroutine(TurnEndSpeed(3495));
         }
     }
     else if (keyController.keyState[6].press && keyController.keyState[2].press)
     {
         StrategyTopTaskManager.GetTurnEnd().DebugTurnEnd();
         CommonPopupDialog.Instance.StartPopup(StrategyTopTaskManager.GetLogicManager().Turn.ToString());
     }
     else if (keyController.keyState[6].down)
     {
         StrategyTopTaskManager.Instance.GameOver();
         keyController.firstUpdate = true;
     }
     else if (keyController.keyState[3].down)
     {
         TutorialModel tutorial = StrategyTopTaskManager.GetLogicManager().UserInfo.Tutorial;
         for (int k = 0; k < 20; k++)
         {
             tutorial.SetStepTutorialFlg(k);
         }
         for (int l = 0; l < 99; l++)
         {
             tutorial.SetKeyTutorialFlg(l);
         }
         if (SingletonMonoBehaviour <PortObjectManager> .Instance.GetTutorialGuide() != null)
         {
             SingletonMonoBehaviour <PortObjectManager> .Instance.GetTutorialGuide().HideAndDestroy();
         }
     }
     if (keyController.keyState[7].down && keyController.keyState[4].press)
     {
         GameObject.Find("SingletonObject").AddComponent <TEST_Voyage>().StartVoyage();
     }
     if (keyController.keyState[7].down && keyController.keyState[5].press)
     {
         UnityEngine.Object.Destroy(GameObject.Find("Live2DRender").gameObject);
         UnityEngine.Object.Destroy(SingletonMonoBehaviour <PortObjectManager> .Instance.gameObject);
         UnityEngine.Object.Destroy(GameObject.Find("SingletonObject").gameObject);
         this.DelayActionFrame(3, delegate
         {
             Application.LoadLevel("TestEmptyScene");
             this.DelayAction(5f, delegate
             {
                 Resources.UnloadUnusedAssets();
             });
         });
     }
     if (keyController.keyState[4].hold && keyController.keyState[5].hold)
     {
         if (base.gameObject.name == "DebugMenuNormal")
         {
             DebugMenuNormal.SetActive(isActive: false);
             DebugMode1.SetActive(isActive: true);
             DebugMode3.SetActive(isActive: true);
         }
         else
         {
             DebugMenuNormal.SetActive(isActive: true);
             DebugMode1.SetActive(isActive: false);
             DebugMode3.SetActive(isActive: false);
         }
         StrategyTopTaskManager.SetDebug(AnotherMode);
         StrategyTopTaskManager.ReqMode(StrategyTopTaskManager.StrategyTopTaskManagerMode.Debug);
         return(false);
     }
     if (!Diagnostics.enableHUD && keyController.keyState[4].press && keyController.keyState[5].press && keyController.keyState[2].down)
     {
         Diagnostics.enableHUD = true;
     }
     return(ModeRun());
 }
コード例 #14
0
 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);
 }
コード例 #15
0
        public IEnumerator TurnEndCoroutine()
        {
            SingletonMonoBehaviour <UIShortCutMenu> .Instance.IsInputEnable = false;
            LogicMng = StrategyTopTaskManager.GetLogicManager();
            TutorialModel model             = StrategyTopTaskManager.GetLogicManager().UserInfo.Tutorial;
            bool          isFlagShipDamaged = SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeck.GetFlagShip()?.IsDamaged() ?? false;

            StrategyTopTaskManager.GetLogicManager().GetResult_UserActionPhase();
            StrategyTopTaskManager.GetLogicManager().GetResult_EnemyPreActionPhase();
            EnemyActionPhaseResultModel enemyResult = StrategyTopTaskManager.GetLogicManager().GetResult_EnemyActionPhase();

            TurnResult = StrategyTopTaskManager.GetLogicManager().GetResult_Turn();
            StrategyMapManager j = StrategyTopTaskManager.GetLogicManager();

            EnemyResult(enemyResult);
            if (TurnResult.RadingResult != null)
            {
                bool TutorialFinished3 = false;
                SingletonMonoBehaviour <TutorialGuideManager> .Instance.CheckAndShowFirstTutorial(model, TutorialGuideManager.TutorialID.Raider, delegate
                {
                    SingletonMonoBehaviour <TutorialGuideManager> .Instance.GetTutorialDialog().OnClosed = delegate
                    {
                        TutorialFinished3 = true;
                    };
                });

                while (!TutorialFinished3)
                {
                    TutorialDialog t = SingletonMonoBehaviour <TutorialGuideManager> .Instance.GetTutorialDialog();

                    if (t == null && !SingletonMonoBehaviour <TutorialGuideManager> .Instance.isRequest())
                    {
                        break;
                    }
                    yield return(new WaitForEndOfFrame());
                }
                TileAnimationManager tam = GetComponent <TileAnimationManager>();
                bool isFirst             = true;
                StrategyTopTaskManager.Instance.ShipIconManager.SetVisible(isVisible: false);
                StrategyTopTaskManager.Instance.TileManager.SetVisibleAllAreaDockIcons(isVisible: false);
                for (int i = 0; i < TurnResult.RadingResult.Count; i++)
                {
                    tam.Initialize(TurnResult.RadingResult[i], j.Area[TurnResult.RadingResult[i].AreaId], isFirst);
                    isFirst = false;
                    while (!tam.isFinished)
                    {
                        yield return(new WaitForEndOfFrame());
                    }
                    tam.isFinished = false;
                }
                StrategyTopTaskManager.Instance.ShipIconManager.SetVisible(isVisible: true);
                StrategyTopTaskManager.Instance.TileManager.SetVisibleAllAreaDockIcons(isVisible: true);
                bool isShow = SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeck.MissionState == MissionStates.NONE;
                StrategyTopTaskManager.Instance.GetInfoMng().MoveScreenIn(null, isShow);
                StrategyTopTaskManager.Instance.UIModel.MapCamera.MoveToTargetTile(StrategyTopTaskManager.Instance.TileManager.FocusTile.areaID);
            }
            StartCoroutine(UserPreAction());
            dayAnimation.SetActive(isActive: true);
            StrategyTopTaskManager.Instance.GetInfoMng().updateUpperInfo();
            StrategyTopTaskManager.Instance.GetInfoMng().updateInfoPanel(SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeck.AreaId);
            while (!finished)
            {
                yield return(new WaitForEndOfFrame());
            }
            finished = false;
            yield return(StartCoroutine(dayAnimation.StartDayAnimation(LogicMng, isDebug)));

            yield return(StartCoroutine(dayAnimation.StartMonthAnimation(LogicMng, userPreAction, isDebug)));

            yield return(StartCoroutine(dayAnimation.StartWeekAnimation(LogicMng, userPreAction, isDebug)));

            yield return(StartCoroutine(dayAnimation.StartSendChocoAnimation(LogicMng, userPreAction, isDebug)));

            yield return(StartCoroutine(dayAnimation.EndDayAnimation(LogicMng, isDebug)));

            isDebug = false;
            dayAnimation.SetActive(isActive: false);
            StrategyTopTaskManager.Instance.UIModel.UIMapManager.ShipIconManager.setShipIconsState();
            StrategyTopTaskManager.Instance.TileManager.updateTilesColor();
            if (StrategyTopTaskManager.Instance.TileManager.isExistRebellionTargetTile())
            {
                yield return(StartCoroutine(RebellionTutorialGuide(model)));
            }
            if (SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeck.GetFlagShip() != null && isFlagShipDamaged != SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeck.GetFlagShip().IsDamaged())
            {
                StrategyTopTaskManager.Instance.UIModel.Character.ChangeCharacter();
                StrategyTopTaskManager.Instance.UIModel.Character.setState(SingletonMonoBehaviour <AppInformation> .Instance.CurrentDeck);
            }
            bool TutorialFinished2 = !SingletonMonoBehaviour <TutorialGuideManager> .Instance.CheckAndShowFirstTutorial(model, TutorialGuideManager.TutorialID.ResourceRecovery, delegate
            {
                SingletonMonoBehaviour <TutorialGuideManager> .Instance.GetTutorialDialog().OnClosed = delegate
                {
                    TutorialFinished2 = true;
                };
            });

            while (!TutorialFinished2)
            {
                yield return(new WaitForEndOfFrame());
            }
            StrategyTopTaskManager.Instance.GetInfoMng().updateFooterInfo(isUpdateMaterial: true);
            StrategyTopTaskManager.Instance.TileManager.UpdateAllAreaDockIcons();
            Close();
            if (model.GetStep() == 8 && !model.GetStepTutorialFlg(9))
            {
                StartCoroutine(StrategyTopTaskManager.Instance.TutorialCheck());
            }
            if (isRebellion)
            {
                if (SingletonMonoBehaviour <PortObjectManager> .Instance.GetTutorialGuide() != null)
                {
                    SingletonMonoBehaviour <PortObjectManager> .Instance.GetTutorialGuide().Hide();
                }
                StrategyTaskManager.ReqMode(StrategyTaskManager.StrategyTaskManagerMode.Rebellion);
            }
            else
            {
                StrategyTopTaskManager.ReqMode(StrategyTopTaskManager.StrategyTopTaskManagerMode.StrategyTopTaskManagerMode_ST);
            }
            yield return(null);
        }
コード例 #16
0
 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);
 }
コード例 #17
0
 private void backToCommandMenu()
 {
     AreaInfo.SetActive(false);
     ExitAction();
     StrategyTopTaskManager.ReqMode(StrategyTopTaskManager.StrategyTopTaskManagerMode.CommandMenu);
 }
コード例 #18
0
 private void backToCommandMenu()
 {
     this.AreaInfo.SetActive(false);
     this.ExitAction.Invoke();
     StrategyTopTaskManager.ReqMode(StrategyTopTaskManager.StrategyTopTaskManagerMode.CommandMenu);
 }
コード例 #19
0
 protected override bool Run()
 {
     this.keyController.Update();
     if (!TaskStrategyDebug.isControl)
     {
         if (this.keyController.keyState.get_Item(0).down)
         {
             this.rootPrefab.SetActive(false);
             StrategyTopTaskManager.ReqMode(StrategyTopTaskManager.StrategyTopTaskManagerMode.StrategyTopTaskManagerMode_ST);
             return(false);
         }
         return(true);
     }
     else
     {
         if (this.keyController.keyState.get_Item(1).down)
         {
             SoundUtils.PlaySE(SEFIleInfos.CommonEnter1);
         }
         this.setMag();
         if (this.keyController.keyState.get_Item(6).down&& this.keyController.keyState.get_Item(5).press)
         {
             Application.LoadLevel(Generics.Scene.Ending.ToString());
         }
         else if (this.keyController.keyState.get_Item(5).press&& this.keyController.keyState.get_Item(2).down)
         {
             App.isInvincible = !App.isInvincible;
             CommonPopupDialog.Instance.StartPopup("無敵モード" + App.isInvincible);
         }
         else if (this.keyController.keyState.get_Item(4).press&& this.keyController.keyState.get_Item(2).down)
         {
             for (int i = 1; i < 15; i++)
             {
                 EscortDeckManager escortDeckManager = new EscortDeckManager(i);
                 if (StrategyTopTaskManager.GetLogicManager().UserInfo.ShipCountData().NowCount > 300)
                 {
                     for (int j = 0; j < 300; j++)
                     {
                         if (StrategyTopTaskManager.GetLogicManager().UserInfo.GetShip(1 + j).IsInEscortDeck() == -1 && escortDeckManager.ChangeOrganize(6, 1 + j))
                         {
                             break;
                         }
                     }
                 }
                 StrategyTopTaskManager.GetLogicManager().Deploy(i, 10, escortDeckManager);
             }
             CommonPopupDialog.Instance.StartPopup("自動配備しました");
         }
         else if (this.keyController.keyState.get_Item(6).down&& this.keyController.keyState.get_Item(4).press)
         {
             CommonPopupDialog.Instance.StartPopup("ゲームクリア!!");
             TaskStrategyDebug.ForceEnding = true;
         }
         else if (this.keyController.keyState.get_Item(6).down&& this.keyController.keyState.get_Item(3).press)
         {
             if (this.turnend == null)
             {
                 this.turnend = base.StartCoroutine(this.TurnEndSpeed(3495));
             }
         }
         else if (this.keyController.keyState.get_Item(6).press&& this.keyController.keyState.get_Item(2).press)
         {
             StrategyTopTaskManager.GetTurnEnd().DebugTurnEnd();
             CommonPopupDialog.Instance.StartPopup(StrategyTopTaskManager.GetLogicManager().Turn.ToString());
         }
         else if (this.keyController.keyState.get_Item(6).down)
         {
             StrategyTopTaskManager.Instance.GameOver();
             this.keyController.firstUpdate = true;
         }
         else if (this.keyController.keyState.get_Item(3).down)
         {
             TutorialModel tutorial = StrategyTopTaskManager.GetLogicManager().UserInfo.Tutorial;
             for (int k = 0; k < 20; k++)
             {
                 tutorial.SetStepTutorialFlg(k);
             }
             for (int l = 0; l < 99; l++)
             {
                 tutorial.SetKeyTutorialFlg(l);
             }
             if (SingletonMonoBehaviour <PortObjectManager> .Instance.GetTutorialGuide() != null)
             {
                 SingletonMonoBehaviour <PortObjectManager> .Instance.GetTutorialGuide().HideAndDestroy();
             }
         }
         if (this.keyController.keyState.get_Item(7).down&& this.keyController.keyState.get_Item(4).press)
         {
             GameObject.Find("SingletonObject").AddComponent <TEST_Voyage>().StartVoyage();
         }
         if (this.keyController.keyState.get_Item(7).down&& this.keyController.keyState.get_Item(5).press)
         {
             Object.Destroy(GameObject.Find("Live2DRender").get_gameObject());
             Object.Destroy(SingletonMonoBehaviour <PortObjectManager> .Instance.get_gameObject());
             Object.Destroy(GameObject.Find("SingletonObject").get_gameObject());
             this.DelayActionFrame(3, delegate
             {
                 Application.LoadLevel("TestEmptyScene");
                 this.DelayAction(5f, delegate
                 {
                     Resources.UnloadUnusedAssets();
                 });
             });
         }
         if (this.keyController.keyState.get_Item(4).hold&& this.keyController.keyState.get_Item(5).hold)
         {
             if (base.get_gameObject().get_name() == "DebugMenuNormal")
             {
                 this.DebugMenuNormal.SetActive(false);
                 this.DebugMode1.SetActive(true);
                 this.DebugMode3.SetActive(true);
             }
             else
             {
                 this.DebugMenuNormal.SetActive(true);
                 this.DebugMode1.SetActive(false);
                 this.DebugMode3.SetActive(false);
             }
             StrategyTopTaskManager.SetDebug(this.AnotherMode);
             StrategyTopTaskManager.ReqMode(StrategyTopTaskManager.StrategyTopTaskManagerMode.Debug);
             return(false);
         }
         if (!Diagnostics.get_enableHUD() && this.keyController.keyState.get_Item(4).press&& this.keyController.keyState.get_Item(5).press&& this.keyController.keyState.get_Item(2).down)
         {
             Diagnostics.set_enableHUD(true);
         }
         return(this.ModeRun());
     }
 }