Exemple #1
0
 public static void Relogin()
 {
     MonoSingleton <GameManager> .Instance.IsRelogin = true;
     Network.RequestResult = Network.RequestResults.InvalidSession;
     Network.RemoveAPI();
     Network.ResetError();
     GlobalEvent.Invoke(PredefinedGlobalEvents.ERROR_NETWORK.ToString(), (object)null);
 }
Exemple #2
0
 protected override void OnDestroy()
 {
     if (string.IsNullOrEmpty(this.mRegisteredEventName))
     {
         return;
     }
     GlobalEvent.RemoveListener(this.mRegisteredEventName, new GlobalEvent.Delegate(this.OnGlobalEvent));
 }
Exemple #3
0
 public override void OnActivate(int pinID)
 {
     if (pinID != 100 || string.IsNullOrEmpty(this.EventName))
     {
         return;
     }
     GlobalEvent.Invoke(this.EventName, (object)this);
     this.ActivateOutputLinks(1);
 }
Exemple #4
0
 private void Refresh()
 {
     if (this.mEndTime <= 0L)
     {
         if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.Hour, (UnityEngine.Object)null))
         {
             this.Hour.set_text("00");
         }
         if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.Minute, (UnityEngine.Object)null))
         {
             this.Minute.set_text("00");
         }
         if (!UnityEngine.Object.op_Inequality((UnityEngine.Object) this.Second, (UnityEngine.Object)null))
         {
             return;
         }
         this.Second.set_text("00");
     }
     else
     {
         TimeSpan timeSpan     = TimeManager.FromUnixTime(this.mEndTime) - TimeManager.ServerTime;
         int      totalHours   = (int)timeSpan.TotalHours;
         int      totalMinutes = (int)timeSpan.TotalMinutes;
         int      totalSeconds = (int)timeSpan.TotalSeconds;
         if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.Hour, (UnityEngine.Object)null))
         {
             this.Hour.set_text(string.Format("{0:D2}", (object)totalHours));
         }
         if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.Minute, (UnityEngine.Object)null))
         {
             if (totalHours > 0)
             {
                 this.Minute.set_text(string.Format("{0:D2}", (object)(totalMinutes % (totalHours * 60))));
             }
             else
             {
                 this.Minute.set_text(string.Format("{0:D2}", (object)totalMinutes));
             }
         }
         if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.Second, (UnityEngine.Object)null))
         {
             if (totalMinutes > 0)
             {
                 this.Second.set_text(string.Format("{0:D2}", (object)(totalSeconds % (totalMinutes * 60))));
             }
             else
             {
                 this.Second.set_text(string.Format("{0:D2}", (object)totalSeconds));
             }
         }
         if (!(timeSpan <= TimeSpan.Zero))
         {
             return;
         }
         GlobalEvent.Invoke("FINISH_GUERRILLA_SHOP_SHOW", (object)null);
     }
 }
Exemple #5
0
 protected override void Awake()
 {
     base.Awake();
     if (string.IsNullOrEmpty(this.EventName))
     {
         return;
     }
     GlobalEvent.AddListener(this.EventName, new GlobalEvent.Delegate(this.OnGlobalEvent));
     this.mRegisteredEventName = this.EventName;
 }
Exemple #6
0
 public static void Version()
 {
     Network.RequestResult = Network.RequestResults.VersionMismatch;
     if (Network.IsImmediateMode)
     {
         return;
     }
     Network.RemoveAPI();
     Network.ResetError();
     GlobalEvent.Invoke(PredefinedGlobalEvents.VERSION_MISMATCH_NETWORK.ToString(), (object)null);
 }
Exemple #7
0
 public static void Back()
 {
     Network.RequestResult = Network.RequestResults.Back;
     if (Network.IsImmediateMode)
     {
         return;
     }
     Network.RemoveAPI();
     GlobalEvent.Invoke(PredefinedGlobalEvents.BACK_NETWORK.ToString(), (object)null);
     Network.ResetError();
 }
Exemple #8
0
        private void Success()
        {
            if (this.OnAbilityRankUpCountReset != null)
            {
                this.OnAbilityRankUpCountReset();
            }
            MonoSingleton <GameManager> .Instance.NotifyAbilityRankUpCountChanged();

            GlobalEvent.Invoke(PredefinedGlobalEvents.REFRESH_GOLD_STATUS.ToString(), (object)null);
            GlobalEvent.Invoke(PredefinedGlobalEvents.REFRESH_COIN_STATUS.ToString(), (object)null);
        }
Exemple #9
0
 public static void Maintenance()
 {
     Network.RequestResult = Network.RequestResults.Maintenance;
     if (Network.IsImmediateMode)
     {
         return;
     }
     Network.RemoveAPI();
     Network.ResetError();
     GlobalEvent.Invoke(PredefinedGlobalEvents.MAINTENANCE_NETWORK.ToString(), (object)null);
 }
Exemple #10
0
 public override void Begin(HomeWindow self)
 {
     if (FlowNode_Variable.Get("REDRAW_GACHA_PENDING") == "1")
     {
         self.mStateMachine.GotoState <HomeWindow.State_Default>();
         GlobalEvent.Invoke("MENU_GACHA_REDRAW", (object)this);
     }
     else
     {
         if (string.IsNullOrEmpty(self.LoginInfoPath))
         {
             return;
         }
         this.mReq = AssetManager.LoadAsync <GameObject>(self.LoginInfoPath);
         this.mHasNotifiedRankmatch = false;
     }
 }
Exemple #11
0
 private void StartSceneChange(string new_scene)
 {
     foreach (string allowChangeScene in this.allow_change_scenes)
     {
         if (allowChangeScene == new_scene)
         {
             GameObject gameObject = GameObject.Find("Config_Home(Clone)");
             if (UnityEngine.Object.op_Inequality((UnityEngine.Object)gameObject, (UnityEngine.Object)null))
             {
                 UnityEngine.Object.Destroy((UnityEngine.Object)gameObject);
             }
             UnityEngine.Object.Destroy((UnityEngine.Object)((Component)this).get_gameObject());
             GlobalEvent.Invoke(new_scene, (object)this);
             break;
         }
     }
 }
Exemple #12
0
        private void OnNodeSelect(GameObject go)
        {
            ChapterParam dataOfClass = DataSource.FindDataOfClass <ChapterParam>(go, (ChapterParam)null);

            foreach (ChapterParam chapter in MonoSingleton <GameManager> .Instance.Chapters)
            {
                if (chapter.parent == dataOfClass)
                {
                    if (dataOfClass.IsGpsQuest())
                    {
                        GlobalVars.SelectedChapter.Set(dataOfClass.iname);
                        GlobalEvent.Invoke("GPS_MODE", (object)this);
                        return;
                    }
                    GlobalVars.SelectedChapter.Set(dataOfClass.iname);
                    this.Refresh(this.mEventType);
                    return;
                }
            }
            this.OnItemSelect(go);
        }
Exemple #13
0
        private void PostJobChange()
        {
            this.mRequestSent = false;
            if (this.mTargetUnit != null)
            {
                MonoSingleton <GameManager> .Instance.Player.OnJobChange(this.mTargetUnit.UnitID);

                this.mOriginalJobID = this.mTargetUnit.CurrentJob.JobID;
                if (this.UpdateValue != null)
                {
                    this.UpdateValue();
                }
                if (DataSource.FindDataOfClass <PlayerPartyTypes>(((Component)this).get_gameObject(), PlayerPartyTypes.Max) == PlayerPartyTypes.MultiTower)
                {
                    int lastSelectionIndex     = 0;
                    List <PartyEditData> teams = PartyUtility.LoadTeamPresets(PartyWindow2.EditPartyTypes.MultiTower, out lastSelectionIndex, false);
                    if (teams != null && lastSelectionIndex >= 0)
                    {
                        for (int index1 = 0; index1 < teams.Count; ++index1)
                        {
                            if (teams[index1] != null)
                            {
                                for (int index2 = 0; index2 < teams[index1].Units.Length; ++index2)
                                {
                                    if (teams[index1].Units[index2] != null && teams[index1].Units[index2].UnitParam.iname == this.mTargetUnit.UnitParam.iname)
                                    {
                                        teams[index1].Units[index2] = this.mTargetUnit;
                                        break;
                                    }
                                }
                            }
                        }
                        PartyUtility.SaveTeamPresets(PartyWindow2.EditPartyTypes.MultiTower, lastSelectionIndex, teams, false);
                        GlobalEvent.Invoke("SELECT_PARTY_END", (object)null);
                    }
                }
            }
            FlowNode_GameObject.ActivateOutputLinks((Component)this, 11);
        }
Exemple #14
0
 private void OnDisable()
 {
     GlobalEvent.Invoke(this.EVENT_CHALLENGE_ICON_SHOW, (object)this);
 }
 public void Trigger(string eventName)
 {
     GlobalEvent.Invoke(eventName, (object)((Component)this).get_gameObject());
 }
Exemple #16
0
 public static void CloseWebView()
 {
     GlobalEvent.Invoke("WEBVIEW_DELETE", (object)1);
 }
Exemple #17
0
 private void OnEnable()
 {
     GlobalEvent.Invoke(this.EVENT_CHALLENGE_ICON_HIDE, (object)this);
 }
Exemple #18
0
        public void Activated(int pinID)
        {
            if (99 <= pinID && pinID < 123)
            {
                TrophyState[] trophyStates = MonoSingleton <GameManager> .Instance.Player.TrophyStates;
                if (trophyStates != null)
                {
                    for (int index = 0; index < trophyStates.Length; ++index)
                    {
                        if (trophyStates[index].IsCompleted)
                        {
                            TrophyParam trophy = MonoSingleton <GameManager> .Instance.MasterParam.GetTrophy(trophyStates[index].iname);

                            if (trophy != null)
                            {
                                GameCenterManager.SendAchievementProgress(trophy.iname);
                            }
                        }
                    }
                }
                MonoSingleton <GameManager> .Instance.Player.OnPlayerLevelChange(1);

                if (this.mDesirdSceneSet)
                {
                    return;
                }
                // ISSUE: object of a compiler-generated type is created
                // ISSUE: variable of a compiler-generated type
                HomeWindow.\u003CActivated\u003Ec__AnonStorey33C activatedCAnonStorey33C = new HomeWindow.\u003CActivated\u003Ec__AnonStorey33C();
                // ISSUE: reference to a compiler-generated field
                activatedCAnonStorey33C.desiredSceneName = (string)null;
                bool flag1 = false;
                bool flag2 = GlobalVars.ForceSceneChange;
                GlobalVars.ForceSceneChange = false;
                if (pinID == 99)
                {
                    SectionParam homeWorld = HomeUnitController.GetHomeWorld();
                    if (homeWorld != null)
                    {
                        // ISSUE: reference to a compiler-generated field
                        activatedCAnonStorey33C.desiredSceneName = homeWorld.home;
                        flag1 = true;
                    }
                }
                else
                {
                    // ISSUE: reference to a compiler-generated field
                    activatedCAnonStorey33C.desiredSceneName = this.SceneNames[pinID - 100];
                }
                // ISSUE: reference to a compiler-generated method
                if (Array.FindIndex <string>(this.IgnoreSameSceneCheck, new Predicate <string>(activatedCAnonStorey33C.\u003C\u003Em__391)) != -1)
                {
                    flag2 = true;
                }
                // ISSUE: reference to a compiler-generated field
                // ISSUE: reference to a compiler-generated field
                if (!string.IsNullOrEmpty(activatedCAnonStorey33C.desiredSceneName) && (flag2 || this.mLastSceneName != activatedCAnonStorey33C.desiredSceneName))
                {
                    if (!MonoSingleton <GameManager> .Instance.PrepareSceneChange())
                    {
                        return;
                    }
                    this.mDesirdSceneSet = true;
                    // ISSUE: reference to a compiler-generated field
                    this.mDesiredSceneName   = activatedCAnonStorey33C.desiredSceneName;
                    this.mDesiredSceneIsHome = flag1;
                    if ((MonoSingleton <GameManager> .Instance.Player.TutorialFlags & 1L) == 0L)
                    {
                        GameManager instance = MonoSingleton <GameManager> .Instance;
                        if (!this.mDesiredSceneIsHome)
                        {
                            // ISSUE: reference to a compiler-generated field
                            if (activatedCAnonStorey33C.desiredSceneName == "Home_Gacha")
                            {
                                if (instance.GetNextTutorialStep() != "ShowFreeGachaButton" && instance.GetNextTutorialStep() != "ShowSummonButton")
                                {
                                    this.mDesirdSceneSet = false;
                                }
                            }
                            else
                            {
                                // ISSUE: reference to a compiler-generated field
                                if (activatedCAnonStorey33C.desiredSceneName == "Home_UnitList")
                                {
                                    if (instance.GetNextTutorialStep() != "ShowUnitList" && instance.GetNextTutorialStep() != "ShowUnitButton")
                                    {
                                        this.mDesirdSceneSet = false;
                                    }
                                }
                                else
                                {
                                    // ISSUE: reference to a compiler-generated field
                                    if (activatedCAnonStorey33C.desiredSceneName == "world001")
                                    {
                                        if (instance.GetNextTutorialStep() != "ShowQuestItem" && instance.GetNextTutorialStep() != "ShowStoryButton")
                                        {
                                            this.mDesirdSceneSet = false;
                                        }
                                    }
                                    else
                                    {
                                        this.mDesirdSceneSet = false;
                                        return;
                                    }
                                }
                            }
                        }
                    }
                    this.mIgnorePopups = !this.mDesiredSceneIsHome;
                    GlobalVars.SetDropTableGeneratedTime();
                }
                else
                {
                    if (!UnityEngine.Object.op_Inequality((UnityEngine.Object)GameObject.Find("EventQuest"), (UnityEngine.Object)null))
                    {
                        return;
                    }
                    GlobalEvent.Invoke("UPDATE_EVENT_LIST", (object)this);
                }
            }
            else
            {
                switch (pinID)
                {
                case 12:
                    this.mFadingOut = false;
                    break;

                case 30:
                    if (this.RestoreScenes == null)
                    {
                        break;
                    }
                    GlobalVars.IsTutorialEnd = true;
                    if (HomeWindow.mRestorePoint != RestorePoints.Home)
                    {
                        if (!this.IsNotHomeBGM())
                        {
                            FlowNode_PlayBGM.PlayHomeBGM();
                        }
                        for (int index = 0; index < this.RestoreScenes.Length; ++index)
                        {
                            if (this.RestoreScenes[index].Type == HomeWindow.mRestorePoint)
                            {
                                this.Activated(100 + this.RestoreScenes[index].Index);
                                return;
                            }
                        }
                    }
                    this.Activated(99);
                    break;

                case 1002:
                    this.mStateMachine.GotoState <HomeWindow.State_Tutorial>();
                    break;
                }
            }
        }
Exemple #19
0
 public override void Update(HomeWindow self)
 {
     if (this.state == 0)
     {
         self.mFadingOut = true;
         FlowNode_GameObject.ActivateOutputLinks((Component)self, 11);
         this.state = 1;
     }
     if (this.state == 1)
     {
         if (!AssetDownloader.isDone)
         {
             return;
         }
         if (AssetManager.IsAssetBundle(self.mDesiredSceneName))
         {
             AssetManager.PrepareAssets(self.mDesiredSceneName);
             if (!AssetDownloader.isDone)
             {
                 ProgressWindow.OpenGenericDownloadWindow();
                 AssetDownloader.StartDownload(false, true, ThreadPriority.Normal);
                 this.state = 2;
                 return;
             }
         }
         this.state = 3;
     }
     if (this.state == 2)
     {
         if (!AssetDownloader.isDone)
         {
             return;
         }
         ProgressWindow.Close();
         this.state = 3;
     }
     if (this.state == 3)
     {
         self.mLastSceneName = self.mDesiredSceneName;
         this.req            = AssetManager.LoadSceneAsync(self.mDesiredSceneName, true);
         this.state          = 4;
     }
     if (this.state == 4)
     {
         if (!this.req.canBeActivated || self.mFadingOut || MonoSingleton <GameManager> .Instance.IsImportantJobRunning)
         {
             return;
         }
         if (!string.IsNullOrEmpty(self.UnloadTrigger))
         {
             GlobalEvent.Invoke(self.UnloadTrigger, (object)this);
         }
         SceneAwakeObserver.AddListener(new SceneAwakeObserver.SceneEvent(this.OnSceneAwake));
         this.req.ActivateScene();
         if (!string.IsNullOrEmpty(self.mLastSceneName))
         {
             AssetManager.UnloadScene(self.mLastSceneName);
         }
         this.state = 5;
     }
     if (this.state == 5)
     {
         if (Object.op_Equality((Object)this.mNewScene, (Object)null) || !this.req.isDone)
         {
             return;
         }
         CriticalSection.Leave(CriticalSections.SceneChange);
         this.state = 6;
     }
     if (this.state == 6)
     {
         if (CriticalSection.IsActive)
         {
             return;
         }
         GC.Collect();
         this.asyncOp = AssetManager.UnloadUnusedAssets();
         this.state   = (MonoSingleton <GameManager> .Instance.Player.TutorialFlags & 1L) != 0L ? 7 : 101;
     }
     if (this.state == 7)
     {
         if (this.asyncOp != null && !this.asyncOp.get_isDone())
         {
             return;
         }
         FlowNode_GameObject.ActivateOutputLinks((Component)self, 10);
         GameUtility.FadeIn(0.5f);
         self.mDesirdSceneSet = false;
         if (!self.mIgnorePopups && !self.mNewsShown && !GlobalVars.IsTitleStart.Get() && (MonoSingleton <GameManager> .Instance.Player.IsFirstLogin || GameUtility.isLoginInfoDisplay()))
         {
             self.mNewsShown = true;
             GlobalVars.IsTitleStart.Set(true);
             self.mStateMachine.GotoState <HomeWindow.State_LoginBonus>();
         }
         else
         {
             self.NotifyNewFriendRequests();
             if (HomeWindow.EnterHomeCount == 0)
             {
                 self.CheckTrophies();
             }
             if (!self.mNewsShown && !GlobalVars.IsTitleStart.Get() && (MonoSingleton <GameManager> .Instance.Player.IsFirstLogin || self.DebugLoginBonus))
             {
                 self.mNewsShown = true;
                 Json_LoginBonus recentLoginBonus = MonoSingleton <GameManager> .Instance.Player.RecentLoginBonus;
                 if (recentLoginBonus != null)
                 {
                     string iname;
                     int    num;
                     if (recentLoginBonus.coin > 0)
                     {
                         iname = "$COIN";
                         num   = recentLoginBonus.coin;
                     }
                     else
                     {
                         iname = recentLoginBonus.iname;
                         num   = recentLoginBonus.num;
                     }
                     ItemData data = new ItemData();
                     if (data.Setup(0L, iname, num))
                     {
                         NotifyList.PushLoginBonus(data);
                     }
                 }
                 self.NotifySupportResult();
             }
             self.mStateMachine.GotoState <HomeWindow.State_Default>();
         }
         if (self.mDesiredSceneIsHome)
         {
             self.UnlockContents();
             self.FgGIDLoginCheck();
             FlowNode_GameObject.ActivateOutputLinks((Component)self, 15);
         }
         else
         {
             FlowNode_GameObject.ActivateOutputLinks((Component)self, 16);
         }
     }
     if (this.state != 101)
     {
         return;
     }
     DebugUtility.LogWarning("TUTORIAL: HERE");
     FlowNode_GameObject.ActivateOutputLinks((Component)self, 16);
     FlowNode_GameObject.ActivateOutputLinks((Component)self, 10);
     GameUtility.FadeIn(0.5f);
     self.mDesirdSceneSet = false;
     self.mStateMachine.GotoState <HomeWindow.State_Tutorial>();
 }
Exemple #20
0
        public override int OnActivate(int pinId)
        {
            switch (pinId)
            {
            case 200:
                if (this.SetTab(MultiInvitationReceiveWindow.Tab.ACTIVE))
                {
                    this.InitializeActiveList();
                    this.InitializeLogList();
                }
                MultiInvitationBadge.isValid = false;
                this.Open();
                break;

            case 210:
                this.m_Destroy = true;
                this.Close(false);
                break;

            case 220:
                if (this.SetTab(MultiInvitationReceiveWindow.Tab.ACTIVE))
                {
                    this.InitializeActiveList();
                }
                return(300);

            case 230:
                if (this.SetTab(MultiInvitationReceiveWindow.Tab.LOG))
                {
                    this.InitializeLogList();
                }
                return(300);

            case 240:
                SerializeValueList currentValue = FlowNode_ButtonEvent.currentValue as SerializeValueList;
                if (currentValue != null)
                {
                    MultiInvitationReceiveWindow.ActiveData.RoomData dataSource = currentValue.GetDataSource <MultiInvitationReceiveWindow.ActiveData.RoomData>("item");
                    if (dataSource != null)
                    {
                        GlobalVars.SelectedMultiPlayRoomID   = dataSource.roomid;
                        GlobalVars.MultiInvitation           = (int)dataSource.multiType;
                        GlobalVars.MultiInvitationRoomOwner  = dataSource.owner.fuid;
                        GlobalVars.MultiInvitationRoomLocked = dataSource.locked;
                        string eventName = "MENU_MULTI";
                        if (dataSource.multiType == MultiInvitationReceiveWindow.MultiType.TOWER)
                        {
                            eventName = "MENU_MULTITOWER";
                            GameManager instance = MonoSingleton <GameManager> .Instance;
                            GlobalVars.SelectedMultiTowerID = dataSource.quest.param.iname;
                        }
                        GlobalEvent.Invoke(eventName, (object)null);
                        this.m_Destroy = true;
                        this.Close(false);
                        break;
                    }
                    break;
                }
                break;

            case 250:
                this.InitializeActiveList();
                break;

            case 260:
                this.InitializeLogList();
                break;
            }
            return(-1);
        }
Exemple #21
0
        public void Activated(int pinID)
        {
            if (99 <= pinID && pinID < 129)
            {
                if (this.mDesirdSceneSet)
                {
                    return;
                }
                string desiredSceneName = (string)null;
                bool   flag1            = false;
                bool   flag2            = GlobalVars.ForceSceneChange;
                GlobalVars.ForceSceneChange = false;
                if (pinID == 99)
                {
                    SectionParam homeWorld = HomeUnitController.GetHomeWorld();
                    if (homeWorld != null)
                    {
                        desiredSceneName = homeWorld.home;
                        flag1            = true;
                    }
                }
                else
                {
                    desiredSceneName = this.SceneNames[pinID - 100];
                }
                if (Array.FindIndex <string>(this.IgnoreSameSceneCheck, (Predicate <string>)(scene => scene.Equals(desiredSceneName))) != -1)
                {
                    flag2 = true;
                }
                if (!string.IsNullOrEmpty(desiredSceneName) && (flag2 || this.mLastSceneName != desiredSceneName))
                {
                    if (!MonoSingleton <GameManager> .Instance.PrepareSceneChange())
                    {
                        return;
                    }
                    this.SceneChangeSendLog(this.mDesiredSceneName, desiredSceneName);
                    this.mDesirdSceneSet     = true;
                    this.mDesiredSceneName   = desiredSceneName;
                    this.mDesiredSceneIsHome = flag1;
                    this.mIgnorePopups       = !this.mDesiredSceneIsHome;
                    GlobalVars.SetDropTableGeneratedTime();
                }
                else
                {
                    if (!UnityEngine.Object.op_Inequality((UnityEngine.Object)GameObject.Find("EventQuest"), (UnityEngine.Object)null))
                    {
                        return;
                    }
                    GlobalEvent.Invoke("UPDATE_EVENT_LIST", (object)this);
                }
            }
            else
            {
                switch (pinID)
                {
                case 12:
                    this.mFadingOut = false;
                    break;

                case 30:
                    if (this.RestoreScenes == null)
                    {
                        break;
                    }
                    GlobalVars.IsTutorialEnd = true;
                    if (HomeWindow.mRestorePoint != RestorePoints.Home)
                    {
                        if (!this.IsNotHomeBGM())
                        {
                            FlowNode_PlayBGM.PlayHomeBGM();
                        }
                        for (int index = 0; index < this.RestoreScenes.Length; ++index)
                        {
                            if (this.RestoreScenes[index].Type == HomeWindow.mRestorePoint)
                            {
                                this.Activated(100 + this.RestoreScenes[index].Index);
                                return;
                            }
                        }
                    }
                    this.Activated(99);
                    break;

                case 1001:
                    this.mRankmatchRewarded = true;
                    break;

                case 2001:
                    HomeWindow.BeginnerNotified = true;
                    break;
                }
            }
        }
        private void Initalize()
        {
            if (this.IsInialize)
            {
                this.RefreshIcons(true);
                if (this.IsFinishedBonus)
                {
                    return;
                }
                ButtonEvent.Lock("gacha_initialize");
                FlowNode_GameObject.ActivateOutputLinks((Component)this, 60);
            }
            else
            {
                if (GachaResultData.drops == null)
                {
                    return;
                }
                if (GachaResultData.IsRedrawGacha)
                {
                    GlobalEvent.Invoke("DISABLE_HOME_BUTTON", (object)this);
                }
                this.mRequest = (GachaRequestParam)null;
                GachaRequestParam dataOfClass = DataSource.FindDataOfClass <GachaRequestParam>(((Component)this).get_gameObject(), (GachaRequestParam)null);
                if (dataOfClass != null)
                {
                    this.mRequest = dataOfClass;
                }
                this.SetDetailActiveStatus(false);
                this.is_gift = this.CheckIsGiftData(GachaResultData.drops);
                for (int index = 0; index < GachaResultData.drops.Length; ++index)
                {
                    if (GachaResultData.drops[index].type == GachaDropData.Type.Unit)
                    {
                        MonoSingleton <GameManager> .Instance.Player.UpdateUnitTrophyStates(false);

                        break;
                    }
                }
                if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.m_OnemoreBtn, (UnityEngine.Object)null))
                {
                    this.RefreshGachaCostObject(((Component)this.m_OnemoreBtn).get_gameObject());
                    ((Component)this.m_OnemoreBtn).get_gameObject().SetActive(GachaResultData.UseOneMore && !GachaResultData.IsRedrawGacha);
                }
                if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.m_BonusBtn, (UnityEngine.Object)null))
                {
                    ((Component)this.m_BonusBtn).get_gameObject().SetActive(GachaResultData.dropMails != null && GachaResultData.dropMails.Length > 0);
                }
                if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.m_RedrawBtn, (UnityEngine.Object)null))
                {
                    SerializeValueBehaviour component = (SerializeValueBehaviour)((Component)this.m_RedrawBtn).GetComponent <SerializeValueBehaviour>();
                    if (UnityEngine.Object.op_Inequality((UnityEngine.Object)component, (UnityEngine.Object)null))
                    {
                        GameObject gameObject = component.list.GetGameObject("option");
                        if (UnityEngine.Object.op_Inequality((UnityEngine.Object)gameObject, (UnityEngine.Object)null))
                        {
                            gameObject.SetActive(GachaResultData.IsPending);
                        }
                        Text uiLabel = component.list.GetUILabel("txt_count");
                        if (UnityEngine.Object.op_Inequality((UnityEngine.Object)uiLabel, (UnityEngine.Object)null))
                        {
                            string empty;
                            if (GachaResultData.IsPending)
                            {
                                empty = LocalizedText.Get("sys.GACHA_REDRAW_COUNT_LIMIT", new object[1]
                                {
                                    (object)GachaResultData.RedrawRest
                                });
                            }
                            else
                            {
                                empty = string.Empty;
                            }
                            string str = empty;
                            uiLabel.set_text(str);
                        }
                    }
                    ((Component)this.m_RedrawBtn).get_gameObject().SetActive(GachaResultData.IsRedrawGacha);
                    ((Selectable)this.m_RedrawBtn).set_interactable(GachaResultData.IsPending && GachaResultData.RedrawRest > 0);
                }
                if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.m_DefaultBtn, (UnityEngine.Object)null))
                {
                    SerializeValueBehaviour component = (SerializeValueBehaviour)((Component)this.m_DefaultBtn).GetComponent <SerializeValueBehaviour>();
                    if (UnityEngine.Object.op_Inequality((UnityEngine.Object)component, (UnityEngine.Object)null))
                    {
                        component.list.GetUILabel("text").set_text(!GachaResultData.IsPending ? LocalizedText.Get("sys.BTN_GACHA_OK") : LocalizedText.Get("sys.BTN_DECIDE_CONFIRM"));
                    }
                }
                this.Refresh();
                this.m_inialize = true;
            }
        }
Exemple #23
0
 public override void Update(HomeWindow self)
 {
     if (this.state == 0)
     {
         self.mFadingOut = true;
         FlowNode_GameObject.ActivateOutputLinks((Component)self, 11);
         this.state = 1;
     }
     if (this.state == 1)
     {
         if (!AssetDownloader.isDone)
         {
             return;
         }
         if (AssetManager.IsAssetBundle(self.mDesiredSceneName))
         {
             AssetManager.PrepareAssets(self.mDesiredSceneName);
             if (self.mDesiredSceneIsHome)
             {
                 foreach (string resourcePath in FlowNode_PlayBGM.GetHomeBGM())
                 {
                     AssetManager.PrepareAssets(resourcePath);
                 }
             }
             if (!AssetDownloader.isDone)
             {
                 ProgressWindow.OpenGenericDownloadWindow();
                 AssetDownloader.StartDownload(false, true, ThreadPriority.Normal);
                 this.state = 2;
                 return;
             }
         }
         this.state = 3;
     }
     if (this.state == 2)
     {
         if (!AssetDownloader.isDone)
         {
             return;
         }
         ProgressWindow.Close();
         this.state = 3;
     }
     if (this.state == 3)
     {
         if (self.mDesiredSceneIsHome)
         {
             FlowNode_PlayBGM.PlayHomeBGM();
         }
         self.mLastSceneName = self.mDesiredSceneName;
         this.req            = AssetManager.LoadSceneAsync(self.mDesiredSceneName, true);
         this.state          = 4;
     }
     if (this.state == 4)
     {
         if (!this.req.canBeActivated || self.mFadingOut || MonoSingleton <GameManager> .Instance.IsImportantJobRunning)
         {
             return;
         }
         if (!string.IsNullOrEmpty(self.UnloadTrigger))
         {
             GlobalEvent.Invoke(self.UnloadTrigger, (object)this);
         }
         SceneAwakeObserver.AddListener(new SceneAwakeObserver.SceneEvent(this.OnSceneAwake));
         this.req.ActivateScene();
         if (!string.IsNullOrEmpty(self.mLastSceneName))
         {
             AssetManager.UnloadScene(self.mLastSceneName);
         }
         this.state = 5;
     }
     if (this.state == 5)
     {
         if (UnityEngine.Object.op_Equality((UnityEngine.Object) this.mNewScene, (UnityEngine.Object)null) || !this.req.isDone)
         {
             return;
         }
         CriticalSection.Leave(CriticalSections.SceneChange);
         this.state = 6;
     }
     if (this.state == 6)
     {
         if (CriticalSection.IsActive)
         {
             return;
         }
         this.asyncOp = AssetManager.UnloadUnusedAssets();
         this.state   = 7;
     }
     if (this.state != 7 || this.asyncOp != null && !this.asyncOp.get_isDone())
     {
         return;
     }
     FlowNode_GameObject.ActivateOutputLinks((Component)self, 10);
     GameUtility.FadeIn(0.5f);
     self.mDesirdSceneSet = false;
     if (!self.mIgnorePopups && !self.mNewsShown && !GlobalVars.IsTitleStart.Get() && (MonoSingleton <GameManager> .Instance.Player.IsFirstLogin || GameUtility.isLoginInfoDisplay()))
     {
         self.mNewsShown = true;
         GlobalVars.IsTitleStart.Set(true);
         self.mStateMachine.GotoState <HomeWindow.State_LoginBonus>();
     }
     else if (!self.mIgnorePopups && !GlobalVars.IsTitleStart.Get() && !self.mBeginnerShown)
     {
         self.mBeginnerShown = true;
         self.mStateMachine.GotoState <HomeWindow.State_BeginnerNotify>();
     }
     else
     {
         self.MiscBeforeDefaultState();
         self.mStateMachine.GotoState <HomeWindow.State_Default>();
     }
     if (self.mDesiredSceneIsHome)
     {
         self.UnlockContents();
         self.FgGIDLoginCheck();
         FlowNode_GameObject.ActivateOutputLinks((Component)self, 15);
     }
     else
     {
         FlowNode_GameObject.ActivateOutputLinks((Component)self, 16);
     }
 }
        public void Refresh(Unit unit)
        {
            if (this.mBc == null || unit == null)
            {
                return;
            }
            DataSource component1 = (DataSource)((Component)this).get_gameObject().GetComponent <DataSource>();

            if (UnityEngine.Object.op_Implicit((UnityEngine.Object)component1))
            {
                component1.Clear();
            }
            if (UnityEngine.Object.op_Implicit((UnityEngine.Object) this.GoLeaderSkill))
            {
                DataSource component2 = (DataSource)this.GoLeaderSkill.GetComponent <DataSource>();
                if (UnityEngine.Object.op_Implicit((UnityEngine.Object)component2))
                {
                    component2.Clear();
                }
            }
            if (UnityEngine.Object.op_Implicit((UnityEngine.Object) this.GoLeader2Skill))
            {
                DataSource component2 = (DataSource)this.GoLeader2Skill.GetComponent <DataSource>();
                if (UnityEngine.Object.op_Implicit((UnityEngine.Object)component2))
                {
                    component2.Clear();
                }
            }
            if (UnityEngine.Object.op_Implicit((UnityEngine.Object) this.GoFriendSkill))
            {
                DataSource component2 = (DataSource)this.GoFriendSkill.GetComponent <DataSource>();
                if (UnityEngine.Object.op_Implicit((UnityEngine.Object)component2))
                {
                    component2.Clear();
                }
            }
            DataSource.Bind <Unit>(((Component)this).get_gameObject(), unit);
            BaseStatus status        = unit.UnitData.Status;
            BaseStatus currentStatus = unit.CurrentStatus;
            BaseStatus maximumStatus = unit.MaximumStatus;
            SkillData  data1         = (SkillData)null;
            SkillData  data2         = (SkillData)null;
            SkillData  data3         = (SkillData)null;

            if (!this.mBc.IsMultiTower)
            {
                if (unit.Side == EUnitSide.Player)
                {
                    if (this.mBc.Leader != null)
                    {
                        data1 = this.mBc.Leader.LeaderSkill;
                    }
                    if (this.mBc.Friend != null && this.mBc.IsFriendStatus)
                    {
                        data3 = this.mBc.Friend.LeaderSkill;
                    }
                }
                if (this.mBc.IsMultiVersus && unit.Side == EUnitSide.Enemy && this.mBc.EnemyLeader != null)
                {
                    data1 = this.mBc.EnemyLeader.LeaderSkill;
                }
            }
            else
            {
                List <Unit> unitList = new List <Unit>();
                if (unit.Side == EUnitSide.Player)
                {
                    unitList = this.mBc.Player;
                }
                else if (unit.Side == EUnitSide.Enemy)
                {
                    unitList = this.mBc.Enemys;
                }
                int index1 = unitList.FindIndex((Predicate <Unit>)(data => data.OwnerPlayerIndex == 1));
                if (index1 >= 0)
                {
                    data1 = unitList[index1].LeaderSkill;
                }
                int index2 = unitList.FindIndex((Predicate <Unit>)(data => data.OwnerPlayerIndex == 2));
                if (index2 >= 0)
                {
                    data2 = unitList[index2].LeaderSkill;
                }
            }
            if (UnityEngine.Object.op_Implicit((UnityEngine.Object) this.GoLeaderSkill) && data1 != null)
            {
                DataSource.Bind <SkillData>(this.GoLeaderSkill, data1);
            }
            if (UnityEngine.Object.op_Implicit((UnityEngine.Object) this.GoLeader2Skill) && data2 != null)
            {
                DataSource.Bind <SkillData>(this.GoLeader2Skill, data2);
            }
            if (UnityEngine.Object.op_Implicit((UnityEngine.Object) this.GoFriendSkill) && data3 != null)
            {
                DataSource.Bind <SkillData>(this.GoFriendSkill, data3);
            }
            if (UnityEngine.Object.op_Implicit((UnityEngine.Object) this.GoStatusParent) && UnityEngine.Object.op_Implicit((UnityEngine.Object) this.StatusBaseItem))
            {
                ((Component)this.StatusBaseItem).get_gameObject().SetActive(false);
                BattleUnitDetail.DestroyChildGameObjects(this.GoStatusParent, new List <GameObject>((IEnumerable <GameObject>) new GameObject[1]
                {
                    ((Component)this.StatusBaseItem).get_gameObject()
                }));
                for (int index = 0; index < 13; ++index)
                {
                    BattleUnitDetailStatus unitDetailStatus = (BattleUnitDetailStatus)UnityEngine.Object.Instantiate <BattleUnitDetailStatus>((M0)this.StatusBaseItem);
                    if (UnityEngine.Object.op_Implicit((UnityEngine.Object)unitDetailStatus))
                    {
                        ((Component)unitDetailStatus).get_transform().SetParent(this.GoStatusParent.get_transform());
                        ((Component)unitDetailStatus).get_transform().set_localScale(Vector3.get_one());
                        int val = 0;
                        int add = 0;
                        switch (index)
                        {
                        case 0:
                            val = (int)maximumStatus.param.hp;
                            add = (int)maximumStatus.param.hp - (int)status.param.hp;
                            break;

                        case 1:
                            val = (int)maximumStatus.param.mp;
                            add = (int)maximumStatus.param.mp - (int)status.param.mp;
                            break;

                        case 2:
                            val = (int)currentStatus.param.atk;
                            add = (int)currentStatus.param.atk - (int)status.param.atk;
                            break;

                        case 3:
                            val = (int)currentStatus.param.def;
                            add = (int)currentStatus.param.def - (int)status.param.def;
                            break;

                        case 4:
                            val = (int)currentStatus.param.mag;
                            add = (int)currentStatus.param.mag - (int)status.param.mag;
                            break;

                        case 5:
                            val = (int)currentStatus.param.mnd;
                            add = (int)currentStatus.param.mnd - (int)status.param.mnd;
                            break;

                        case 6:
                            val = (int)currentStatus.param.dex;
                            add = (int)currentStatus.param.dex - (int)status.param.dex;
                            break;

                        case 7:
                            val = (int)currentStatus.param.spd;
                            add = (int)currentStatus.param.spd - (int)status.param.spd;
                            break;

                        case 8:
                            val = (int)currentStatus.param.cri;
                            add = (int)currentStatus.param.cri - (int)status.param.cri;
                            break;

                        case 9:
                            val = (int)currentStatus.param.luk;
                            add = (int)currentStatus.param.luk - (int)status.param.luk;
                            break;

                        case 10:
                            val = unit.GetCombination();
                            add = 0;
                            break;

                        case 11:
                            val = (int)currentStatus.param.mov;
                            add = (int)currentStatus.param.mov - (int)status.param.mov;
                            break;

                        case 12:
                            val = (int)currentStatus.param.jmp;
                            add = (int)currentStatus.param.jmp - (int)status.param.jmp;
                            break;
                        }
                        unitDetailStatus.SetStatus((BattleUnitDetailStatus.eBudStat)index, val, add);
                        ((Component)unitDetailStatus).get_gameObject().SetActive(true);
                    }
                }
            }
            if (UnityEngine.Object.op_Implicit((UnityEngine.Object) this.GoElementParent) && UnityEngine.Object.op_Implicit((UnityEngine.Object) this.ElementBaseItem))
            {
                ((Component)this.ElementBaseItem).get_gameObject().SetActive(false);
                BattleUnitDetail.DestroyChildGameObjects(this.GoElementParent, new List <GameObject>((IEnumerable <GameObject>) new GameObject[1]
                {
                    ((Component)this.ElementBaseItem).get_gameObject()
                }));
                int length = Enum.GetNames(typeof(EElement)).Length;
                for (int index = 1; index < length; ++index)
                {
                    BattleUnitDetailElement unitDetailElement = (BattleUnitDetailElement)UnityEngine.Object.Instantiate <BattleUnitDetailElement>((M0)this.ElementBaseItem);
                    if (UnityEngine.Object.op_Implicit((UnityEngine.Object)unitDetailElement))
                    {
                        ((Component)unitDetailElement).get_transform().SetParent(this.GoElementParent.get_transform());
                        ((Component)unitDetailElement).get_transform().set_localScale(Vector3.get_one());
                        int per = 0;
                        switch (index)
                        {
                        case 1:
                            per = (int)currentStatus.element_resist.fire;
                            break;

                        case 2:
                            per = (int)currentStatus.element_resist.water;
                            break;

                        case 3:
                            per = (int)currentStatus.element_resist.wind;
                            break;

                        case 4:
                            per = (int)currentStatus.element_resist.thunder;
                            break;

                        case 5:
                            per = (int)currentStatus.element_resist.shine;
                            break;

                        case 6:
                            per = (int)currentStatus.element_resist.dark;
                            break;
                        }
                        BattleUnitDetail.eBudFluct fluct = BattleUnitDetail.ExchgBudFluct(per, BattleUnitDetail.eFluctChk.ELEMENT);
                        unitDetailElement.SetElement((EElement)index, fluct);
                        ((Component)unitDetailElement).get_gameObject().SetActive(true);
                    }
                }
            }
            if (UnityEngine.Object.op_Implicit((UnityEngine.Object) this.GoTagParent) && UnityEngine.Object.op_Implicit((UnityEngine.Object) this.TagBaseItem) && UnityEngine.Object.op_Implicit((UnityEngine.Object) this.TagBaseWideItem))
            {
                ((Component)this.TagBaseItem).get_gameObject().SetActive(false);
                ((Component)this.TagBaseWideItem).get_gameObject().SetActive(false);
                BattleUnitDetail.DestroyChildGameObjects(this.GoTagParent, new List <GameObject>((IEnumerable <GameObject>) new GameObject[2]
                {
                    ((Component)this.TagBaseItem).get_gameObject(),
                    ((Component)this.TagBaseWideItem).get_gameObject()
                }));
                int      num  = 0;
                string[] tags = unit.GetTags();
                if (tags != null)
                {
                    foreach (string tag in tags)
                    {
                        BattleUnitDetailTag battleUnitDetailTag;
                        if (tag.Length <= 2)
                        {
                            if (num + 1 <= 8)
                            {
                                battleUnitDetailTag = (BattleUnitDetailTag)UnityEngine.Object.Instantiate <BattleUnitDetailTag>((M0)this.TagBaseItem);
                                ++num;
                            }
                            else
                            {
                                break;
                            }
                        }
                        else if (num + 2 <= 8)
                        {
                            battleUnitDetailTag = (BattleUnitDetailTag)UnityEngine.Object.Instantiate <BattleUnitDetailTag>((M0)this.TagBaseWideItem);
                            num += 2;
                        }
                        else
                        {
                            break;
                        }
                        if (UnityEngine.Object.op_Implicit((UnityEngine.Object)battleUnitDetailTag))
                        {
                            ((Component)battleUnitDetailTag).get_transform().SetParent(this.GoTagParent.get_transform());
                            ((Component)battleUnitDetailTag).get_transform().set_localScale(Vector3.get_one());
                            battleUnitDetailTag.SetTag(tag);
                            ((Component)battleUnitDetailTag).get_gameObject().SetActive(true);
                        }
                    }
                }
            }
            if (UnityEngine.Object.op_Implicit((UnityEngine.Object) this.GoAtkDetailParent) && UnityEngine.Object.op_Implicit((UnityEngine.Object) this.AtkDetailBaseItem))
            {
                ((Component)this.AtkDetailBaseItem).get_gameObject().SetActive(false);
                BattleUnitDetail.DestroyChildGameObjects <BattleUnitDetailAtkDetail>(this.GoAtkDetailParent, new List <GameObject>((IEnumerable <GameObject>) new GameObject[1]
                {
                    ((Component)this.AtkDetailBaseItem).get_gameObject()
                }));
                int[] numArray = new int[3]
                {
                    (int)currentStatus[BattleBonus.HitRate],
                    (int)currentStatus[BattleBonus.AvoidRate],
                    (int)currentStatus[ParamTypes.Rec] - 100
                };
                for (int index = 0; index < numArray.Length; ++index)
                {
                    BattleUnitDetail.eBudFluct fluct = BattleUnitDetail.ExchgBudFluct(numArray[index], BattleUnitDetail.eFluctChk.DEFAULT);
                    if (fluct != BattleUnitDetail.eBudFluct.NONE)
                    {
                        BattleUnitDetailAtkDetail unitDetailAtkDetail = (BattleUnitDetailAtkDetail)UnityEngine.Object.Instantiate <BattleUnitDetailAtkDetail>((M0)this.AtkDetailBaseItem);
                        if (UnityEngine.Object.op_Implicit((UnityEngine.Object)unitDetailAtkDetail))
                        {
                            ((Component)unitDetailAtkDetail).get_transform().SetParent(this.GoAtkDetailParent.get_transform());
                            ((Component)unitDetailAtkDetail).get_transform().set_localScale(Vector3.get_one());
                            unitDetailAtkDetail.SetAll((BattleUnitDetailAtkDetail.eAllType)(7 + index), fluct);
                            ((Component)unitDetailAtkDetail).get_gameObject().SetActive(true);
                        }
                    }
                }
                int length = Enum.GetNames(typeof(AttackDetailTypes)).Length;
                for (int index1 = 0; index1 < 3; ++index1)
                {
                    BattleUnitDetailAtkDetail.eType type = (BattleUnitDetailAtkDetail.eType)index1;
                    for (int index2 = 1; index2 < length; ++index2)
                    {
                        int per = 0;
                        switch (index2)
                        {
                        case 1:
                            switch (type)
                            {
                            case BattleUnitDetailAtkDetail.eType.ASSIST:
                                per = (int)currentStatus[BattleBonus.SlashAttack];
                                break;

                            case BattleUnitDetailAtkDetail.eType.RESIST:
                                per = (int)currentStatus[BattleBonus.Resist_Slash];
                                break;

                            case BattleUnitDetailAtkDetail.eType.AVOID:
                                per = (int)currentStatus[BattleBonus.Avoid_Slash];
                                break;
                            }

                        case 2:
                            switch (type)
                            {
                            case BattleUnitDetailAtkDetail.eType.ASSIST:
                                per = (int)currentStatus[BattleBonus.PierceAttack];
                                break;

                            case BattleUnitDetailAtkDetail.eType.RESIST:
                                per = (int)currentStatus[BattleBonus.Resist_Pierce];
                                break;

                            case BattleUnitDetailAtkDetail.eType.AVOID:
                                per = (int)currentStatus[BattleBonus.Avoid_Pierce];
                                break;
                            }

                        case 3:
                            switch (type)
                            {
                            case BattleUnitDetailAtkDetail.eType.ASSIST:
                                per = (int)currentStatus[BattleBonus.BlowAttack];
                                break;

                            case BattleUnitDetailAtkDetail.eType.RESIST:
                                per = (int)currentStatus[BattleBonus.Resist_Blow];
                                break;

                            case BattleUnitDetailAtkDetail.eType.AVOID:
                                per = (int)currentStatus[BattleBonus.Avoid_Blow];
                                break;
                            }

                        case 4:
                            switch (type)
                            {
                            case BattleUnitDetailAtkDetail.eType.ASSIST:
                                per = (int)currentStatus[BattleBonus.ShotAttack];
                                break;

                            case BattleUnitDetailAtkDetail.eType.RESIST:
                                per = (int)currentStatus[BattleBonus.Resist_Shot];
                                break;

                            case BattleUnitDetailAtkDetail.eType.AVOID:
                                per = (int)currentStatus[BattleBonus.Avoid_Shot];
                                break;
                            }

                        case 5:
                            switch (type)
                            {
                            case BattleUnitDetailAtkDetail.eType.ASSIST:
                                per = (int)currentStatus[BattleBonus.MagicAttack];
                                break;

                            case BattleUnitDetailAtkDetail.eType.RESIST:
                                per = (int)currentStatus[BattleBonus.Resist_Magic];
                                break;

                            case BattleUnitDetailAtkDetail.eType.AVOID:
                                per = (int)currentStatus[BattleBonus.Avoid_Magic];
                                break;
                            }

                        case 6:
                            switch (type)
                            {
                            case BattleUnitDetailAtkDetail.eType.ASSIST:
                                per = (int)currentStatus[BattleBonus.JumpAttack];
                                break;

                            case BattleUnitDetailAtkDetail.eType.RESIST:
                                per = (int)currentStatus[BattleBonus.Resist_Jump];
                                break;

                            case BattleUnitDetailAtkDetail.eType.AVOID:
                                per = (int)currentStatus[BattleBonus.Avoid_Jump];
                                break;
                            }
                        }
                        BattleUnitDetail.eBudFluct fluct = BattleUnitDetail.ExchgBudFluct(per, BattleUnitDetail.eFluctChk.ATK_DETAIL);
                        if (fluct != BattleUnitDetail.eBudFluct.NONE)
                        {
                            BattleUnitDetailAtkDetail unitDetailAtkDetail = (BattleUnitDetailAtkDetail)UnityEngine.Object.Instantiate <BattleUnitDetailAtkDetail>((M0)this.AtkDetailBaseItem);
                            if (UnityEngine.Object.op_Implicit((UnityEngine.Object)unitDetailAtkDetail))
                            {
                                ((Component)unitDetailAtkDetail).get_transform().SetParent(this.GoAtkDetailParent.get_transform());
                                ((Component)unitDetailAtkDetail).get_transform().set_localScale(Vector3.get_one());
                                unitDetailAtkDetail.SetAtkDetail((AttackDetailTypes)index2, type, fluct);
                                ((Component)unitDetailAtkDetail).get_gameObject().SetActive(true);
                            }
                        }
                    }
                }
            }
            if (UnityEngine.Object.op_Implicit((UnityEngine.Object) this.GoCondParent) && UnityEngine.Object.op_Implicit((UnityEngine.Object) this.CondBaseItem))
            {
                ((Component)this.CondBaseItem).get_gameObject().SetActive(false);
                BattleUnitDetail.DestroyChildGameObjects <BattleUnitDetailCond>(this.GoCondParent, new List <GameObject>((IEnumerable <GameObject>) new GameObject[1]
                {
                    ((Component)this.CondBaseItem).get_gameObject()
                }));
                using (List <Unit.UnitShield> .Enumerator enumerator = unit.Shields.GetEnumerator())
                {
                    while (enumerator.MoveNext())
                    {
                        Unit.UnitShield      current = enumerator.Current;
                        BattleUnitDetailCond battleUnitDetailCond = (BattleUnitDetailCond)UnityEngine.Object.Instantiate <BattleUnitDetailCond>((M0)this.CondBaseItem);
                        if (UnityEngine.Object.op_Implicit((UnityEngine.Object)battleUnitDetailCond))
                        {
                            ((Component)battleUnitDetailCond).get_transform().SetParent(this.GoCondParent.get_transform());
                            ((Component)battleUnitDetailCond).get_transform().set_localScale(Vector3.get_one());
                            battleUnitDetailCond.SetCondShield(current.shieldType, (int)current.hp);
                            ((Component)battleUnitDetailCond).get_gameObject().SetActive(true);
                        }
                    }
                }
                EUnitCondition[] values = (EUnitCondition[])Enum.GetValues(typeof(EUnitCondition));
                for (int index = 0; index < values.Length; ++index)
                {
                    if (unit.IsUnitCondition(values[index]))
                    {
                        BattleUnitDetailCond battleUnitDetailCond = (BattleUnitDetailCond)UnityEngine.Object.Instantiate <BattleUnitDetailCond>((M0)this.CondBaseItem);
                        if (UnityEngine.Object.op_Implicit((UnityEngine.Object)battleUnitDetailCond))
                        {
                            ((Component)battleUnitDetailCond).get_transform().SetParent(this.GoCondParent.get_transform());
                            ((Component)battleUnitDetailCond).get_transform().set_localScale(Vector3.get_one());
                            battleUnitDetailCond.SetCond(values[index]);
                            ((Component)battleUnitDetailCond).get_gameObject().SetActive(true);
                        }
                    }
                }
            }
            GameParameter.UpdateAll(((Component)this).get_gameObject());
            GlobalEvent.Invoke("BATTLE_UNIT_DETAIL_REFRESH", (object)this);
        }
Exemple #25
0
 private void SceneInvoke(string event_name)
 {
     GlobalVars.ForceSceneChange = this.SceneChange;
     GlobalEvent.Invoke(event_name, (object)this);
     this.ActivateOutputLinks(1);
 }
        public void Activated(int pinID)
        {
            if (pinID == this.IN_REFRESH)
            {
                if (!this.m_inialize || !UnityEngine.Object.op_Inequality((UnityEngine.Object) this.m_Thumbnail, (UnityEngine.Object)null))
                {
                    return;
                }
                this.m_UnitDetail.SetActive(false);
                this.m_Thumbnail.SetActive(true);
            }
            else if (pinID == this.IN_BACKTO_UNITDETAIL)
            {
                if (this.CheckTutorial())
                {
                    this.m_inialize = false;
                    FlowNode_GameObject.ActivateOutputLinks((Component)this, 210);
                }
                else
                {
                    this.m_UnitDetail.SetActive(false);
                    this.m_Thumbnail.SetActive(true);
                }
            }
            else if (pinID == this.IN_BACK_TOP)
            {
                if (GachaResultData.IsRedrawGacha)
                {
                    FlowNode_GameObject.ActivateOutputLinks((Component)this, 80);
                }
                else
                {
                    this.m_inialize            = false;
                    this.m_FinishedBonusEffect = false;
                    FlowNode_GameObject.ActivateOutputLinks((Component)this, this.OUT_BACK_TOP);
                }
            }
            else if (pinID == this.IN_ONEMORE_GACHA)
            {
                this.m_inialize            = false;
                this.m_FinishedBonusEffect = false;
                if (UnityEngine.Object.op_Inequality((UnityEngine.Object) this.m_Thumbnail, (UnityEngine.Object)null))
                {
                    this.m_Thumbnail.SetActive(false);
                }
                FlowNode_GameObject.ActivateOutputLinks((Component)this, this.OUT_ONEMORE_GACHA);
            }
            else
            {
                switch (pinID)
                {
                case 50:
                    this.OnSelectIcon();
                    break;

                case 51:
                    this.OnSelectCardUnitIcon();
                    break;

                case 61:
                    if (!this.IsFinishedBonus && this.IsThumbnailActive())
                    {
                        if (GachaResultData.dropMails != null && GachaResultData.dropMails.Length > 0)
                        {
                            this.StartCoroutine(this.ShowBonus(true));
                            break;
                        }
                        ButtonEvent.UnLock("gacha_result_initalize");
                        this.m_FinishedBonusEffect = true;
                        FlowNode_GameObject.ActivateOutputLinks((Component)this, 70);
                        break;
                    }
                    FlowNode_GameObject.ActivateOutputLinks((Component)this, 70);
                    break;

                case 71:
                    if (GachaResultData.dropMails != null && GachaResultData.dropMails.Length > 0)
                    {
                        this.StartCoroutine(this.ShowBonus(false));
                        break;
                    }
                    FlowNode_GameObject.ActivateOutputLinks((Component)this, 70);
                    break;

                case 81:
                    FlowNode_Variable.Set("REDRAW_GACHA_PENDING", "0");
                    GlobalEvent.Invoke("ENABLE_HOME_BUTTON", (object)this);
                    FlowNode_GameObject.ActivateOutputLinks((Component)this, 82);
                    break;

                case 90:
                    this.RefreshButtonInteractable(true);
                    break;

                case 91:
                    this.RefreshButtonInteractable(false);
                    break;
                }
            }
        }