ZhenShiXunYouJi2/Assets/Scripts/HUDState.cs

using System;
using System.Collections;
using System.Collections.Generic;
using CIG;
using CIG.Translation;
using CIG3.ExtensionMethods;
using CIGEnums;
using Engine.DependencyTree;
using SUISS.Cloud;
using SUISS.Core;
using SUISSEngine;
using UnityEngine;

public class HUDState : State
{
    public override bool IsHUDState
    {
        get
        {
            return true;
        }
    }

    public void Start()
    {
        SingletonMonobehaviour<WorldMap>.Instance.VisibilityChangedEvent += this.OnWorldMapVisibility;
        SingletonMonobehaviour<CIGIslandsManager>.Instance.VisitingStartedEvent += this.OnVisitingStarted;
        SingletonMonobehaviour<CIGIslandsManager>.Instance.VisitingStoppedEvent += this.OnVisitingStopped;
        SingletonMonobehaviour<CIGDailyQuestManager>.Instance.UpdatedEvent += ((HUDView)this.View).UpdateDailyQuestButtons;
    }

    public override void Init()
    {
        base.Init();
        SingletonMonobehaviour<CIGGameState>.Instance.ValueChangedEvent += this.GameStateValueChanged;
        if (SingletonMonobehaviour<CIGPurchasedBuildingsManager>.IsAvailable)
        {
            SingletonMonobehaviour<CIGPurchasedBuildingsManager>.Instance.BuildingCountChangedEvent += this.UpdateShopButtonBadge;
            this.UpdateShopButtonBadge();
        }
        this.tutorial = UnityEngine.Object.FindObjectOfType<CIGTutorialManager>();
        VideoAds1Manager instance = SingletonMonobehaviour<VideoAds1Manager>.Instance;
        if (!instance.IsUnlocked)
        {
            instance.UnlockedEvent += this.OnVideoAvailabilityChanged;
        }
        instance.AvailabilityChangedEvent += this.OnVideoAvailabilityChanged;
        this.OnVideoAvailabilityChanged();
        if (SingletonMonobehaviour<DependencyTree>.IsAvailable)
        {
            SingletonMonobehaviour<DependencyTree>.Instance.DependencyAchievedChangedEvent += this.OnDependencyAchievedChanged;
            SingletonMonobehaviour<DependencyTree>.Instance.DependencyActiveChangedEvent += this.OnDependencyActiveChanged;
            SingletonMonobehaviour<DependencyTree>.Instance.DependencyRewardClaimedEvent += this.OnDependencyRewardClaimed;
        }
    }

    protected override void OnUpdate()
    {
        base.OnUpdate();
        if (UnityEngine.Input.GetKeyDown(KeyCode.Escape) && SingletonMonobehaviour<CIGIslandsManager>.Instance.CurrentIsland.IsValid())
        {
            if (SingletonMonobehaviour<WorldMap>.IsAvailable && SingletonMonobehaviour<WorldMap>.Instance.IsVisible)
            {
                if (this._hideWorldMapRoutine != null)
                {
                    base.StopCoroutine(this._hideWorldMapRoutine);
                }
                base.StartCoroutine(this._hideWorldMapRoutine = this.HideWorldMapRoutine());
            }
            else
            {
                CIGApp.Quit();
            }
        }
    }

    protected void OnDestroy()
    {
        if (SingletonMonobehaviour<CIGGameState>.IsAvailable)
        {
            SingletonMonobehaviour<CIGGameState>.Instance.ValueChangedEvent -= this.GameStateValueChanged;
        }
        if (SingletonMonobehaviour<CIGDailyQuestManager>.IsAvailable)
        {
            SingletonMonobehaviour<CIGDailyQuestManager>.Instance.UpdatedEvent -= ((HUDView)this.View).UpdateDailyQuestButtons;
        }
        if (SingletonMonobehaviour<CIGPurchasedBuildingsManager>.IsAvailable)
        {
            SingletonMonobehaviour<CIGPurchasedBuildingsManager>.Instance.BuildingCountChangedEvent -= this.UpdateShopButtonBadge;
        }
        if (SingletonMonobehaviour<VideoAds1Manager>.IsAvailable)
        {
            VideoAds1Manager instance = SingletonMonobehaviour<VideoAds1Manager>.Instance;
            instance.UnlockedEvent -= this.OnVideoAvailabilityChanged;
            instance.AvailabilityChangedEvent -= this.OnVideoAvailabilityChanged;
        }
        if (SingletonMonobehaviour<WorldMap>.IsAvailable)
        {
            SingletonMonobehaviour<WorldMap>.Instance.VisibilityChangedEvent -= this.OnWorldMapVisibility;
        }
        if (SingletonMonobehaviour<DependencyTree>.IsAvailable)
        {
            SingletonMonobehaviour<DependencyTree>.Instance.DependencyAchievedChangedEvent -= this.OnDependencyAchievedChanged;
            SingletonMonobehaviour<DependencyTree>.Instance.DependencyActiveChangedEvent -= this.OnDependencyActiveChanged;
            SingletonMonobehaviour<DependencyTree>.Instance.DependencyRewardClaimedEvent -= this.OnDependencyRewardClaimed;
        }
        if (SingletonMonobehaviour<CIGIslandsManager>.IsAvailable)
        {
            SingletonMonobehaviour<CIGIslandsManager>.Instance.VisitingStartedEvent -= this.OnVisitingStarted;
            SingletonMonobehaviour<CIGIslandsManager>.Instance.VisitingStoppedEvent -= this.OnVisitingStopped;
        }
    }

    public override void Enter(State oldState, bool openView)
    {
        base.Enter(oldState, openView);
        SingletonMonobehaviour<PopupManager>.Instance.PopupsMayOpen = true;
        this.DetermineViewState();
        this.HideArrow();
        this.HideTutorialDialog();
        if (openView)
        {
            this.UpdateAll();
        }
        this.CheckTutorialButton();
        this.UpdateRewardBadge();
        this.OnVideoAvailabilityChanged();
    }

    public override void Leave(State newState, bool closeView)
    {
        SingletonMonobehaviour<PopupManager>.Instance.PopupsMayOpen = false;
        base.Leave(newState, false);
        this.HideArrow();
        this.HideTutorialDialog();
    }

    public void PushSettingsExclamationRequest(object obj)
    {
        if (this._settingsExclamationRequests.Count == 0)
        {
            ((HUDView)this.View).SetSettingsAttention(true);
        }
        this._settingsExclamationRequests.Add(obj);
    }

    public void PopSettingsExclamationRequest(object obj)
    {
        if (this._settingsExclamationRequests.Remove(obj) && this._settingsExclamationRequests.Count == 0)
        {
            ((HUDView)this.View).SetSettingsAttention(false);
        }
    }

    public void OnIslandChange(IsometricIsland oldIsland, IsometricIsland newIsland)
    {
        if (oldIsland != null)
        {
            oldIsland.islandState.ValueChanged -= this.GameStateValueChanged;
        }
        if (newIsland != null)
        {
            newIsland.islandState.ValueChanged += this.GameStateValueChanged;
            ((HUDView)this.View).UpdateDropChestButton(newIsland.DropChestManager);
        }
        this.UpdateAll();
    }

    public void CheckTutorialButton()
    {
        ((HUDView)this.View).SetTutorialButton(!(this.tutorial == null) && !this.tutorial.IsFinished);
    }

    public void UpdateAll()
    {
        this.GameStateValueChanged("Level", null, null);
        this.GameStateValueChanged("GiftedBalance", null, null);
        this.GameStateValueChanged("EarnedBalance", null, null);
        this.GameStateValueChanged("Happiness", null, null);
        this.GameStateValueChanged("Population", null, null);
        this.GameStateValueChanged("Employees", null, null);
        this.GameStateValueChanged("Transport", null, null);
        ((HUDView)this.View).UpdateDailyQuestButtons();
        this.RefreshEyeButtonToggle();
        this.RefreshShowLevelsButtonToggle();
    }

    public void UpdateShopButtonBadge()
    {
        ((HUDView)this.View).UpdateShopBadge();
    }

    public void OpenCurrencyPopup(ShopMenuTabs shopMenuTab)
    {
        SingletonMonobehaviour<PopupManager>.Instance.RequestFirstPopup<ShopPopupState>(delegate (State state)
        {
            ((ShopPopupState)state).OpenPopup(shopMenuTab, false);
        });
    }

    public void OpenRewardsPopup()
    {
        SingletonMonobehaviour<PopupManager>.Instance.RequestFirstPopup<QuestsPopupState>(delegate (State state)
        {
            ((QuestsPopupState)state).Init(QuestsMenuTabs.OngoingQuests);
        });
    }

    public void ConfirmStateEntered()
    {
        this.DetermineViewState();
    }

    public void OpenShopPopup()
    {
        SingletonMonobehaviour<PopupManager>.Instance.RequestFirstPopup<ShopPopupState>(delegate (State state)
        {
            CIGTutorialManager instanceIfAvailable = SingletonMonobehaviour<CIGTutorialManager>.InstanceIfAvailable;
            if (instanceIfAvailable != null)
            {
                if (instanceIfAvailable.state == CIGTutorialState.BuildFarm)
                {
                    ((ShopPopupState)state).OpenPopup(ShopMenuTabs.Commercial, false);
                    return;
                }
                if (instanceIfAvailable.state == CIGTutorialState.BuildHouse)
                {
                    ((ShopPopupState)state).OpenPopup(ShopMenuTabs.Residential, false);
                    return;
                }
            }
            ((ShopPopupState)state).OpenPopup(ShopMenuTabs.Gold, true);
        });
    }

    public void OpenDailyQuest()
    {
        SingletonMonobehaviour<PopupManager>.Instance.ShowDailyQuestPopup();
    }

    public void OpenBuildDemolishPopup(BuildDemolishTabs buildDemolishTab)
    {
        SingletonMonobehaviour<PopupManager>.Instance.ShowBuildDemolishPopup(buildDemolishTab);
    }

    public void OpenSocialPopup()
    {
        SingletonMonobehaviour<PopupManager>.Instance.RequestFirstPopup<SparkSocMenuPopupState>(null);
    }

    public void OpenFacebook()
    {
        Application.OpenURL(SingletonMonobehaviour<CIGGameConstants>.Instance.SSFacebookUrl);
    }

    public void OpenGameFacebook()
    {
        Application.OpenURL(SingletonMonobehaviour<CIGGameConstants>.Instance.FacebookUrl);
    }

    public void OpenTelegram()
    {
        Application.OpenURL("https://t.me/MagnetGame_CityIsland3");
    }

    public void OpenWorldMap()
    {
        if (this._showWorldMapRoutine != null)
        {
            base.StopCoroutine(this._showWorldMapRoutine);
        }
        base.StartCoroutine(this._showWorldMapRoutine = this.ShowWorldMapRoutine());
    }

    public void OpenRoadSelectionPopup()
    {
        SingletonMonobehaviour<PopupManager>.Instance.OpenRoadMenu();
    }

    public void OpenSettingsPopup()
    {
        SingletonMonobehaviour<PopupManager>.Instance.RequestFirstPopup<SettingsPopupState>(null);
    }

    public void OpenLeaderboardsPopup()
    {
        SingletonMonobehaviour<PopupManager>.Instance.RequestFirstPopup<LeaderboardsPopupState>(null);
    }

    public void OpenCityAdvisorPopup()
    {
        CIGGameState instance = SingletonMonobehaviour<CIGGameState>.Instance;
        instance.SetValue("cityAdvisorOpened", true);
        SingletonMonobehaviour<CIGCityAdvisor>.Instance.Show();
    }

    public void ToggleBuildingsHidden()
    {
        IsometricIsland.Current.builder.TilesHidden = !IsometricIsland.Current.builder.TilesHidden;
        this.RefreshEyeButtonToggle();
    }

    public void ToggleUpgradeLevelView()
    {
        UpgradableBuilding.SetLevelIconsHidden(!UpgradableBuilding.LevelIconsHidden, IsometricIsland.Current.grid);
        this.RefreshShowLevelsButtonToggle();
    }

    public void StartDestroying()
    {
        if (CityIsland.Current != null)
        {
            CityIsland.Current.StartDestroying();
        }
        else
        {
            UnityEngine.Debug.LogWarning("Have no CityIsland");
        }
    }

    public void StopVisiting()
    {
        SingletonMonobehaviour<CIGIslandsManager>.Instance.StopVisiting();
    }

    public void ShowArrowAboveButtonIndex(int index, int duration = 0)
    {
        ((HUDView)this.View).ShowArrowAboveButtonIndex(index, duration);
    }

    public void HideArrow()
    {
        ((HUDView)this.View).HideArrow();
    }

    public void ShowTutorialDialog(ILocalizedString tutorialText, Action dialogHiddenAction)
    {
        ((HUDView)this.View).ShowTutorialDialog(tutorialText);
        this._dialogHiddenAction = dialogHiddenAction;
    }

    public void HideTutorialDialog()
    {
        ((HUDView)this.View).HideTutorialDialog();
        if (this._dialogHiddenAction != null)
        {
            this._dialogHiddenAction();
            this._dialogHiddenAction = null;
        }
    }

    public void QuitTutorial()
    {
        SingletonMonobehaviour<PopupManager>.Instance.ShowOkCancelPopup(UISpriteType.DemolishIcon, Localization.Key("quit_tutorial"), Localization.Key("tutorial_quit_confirm"), delegate ()
        {
            if (this != null && this.tutorial != null)
            {
                this.tutorial.QuitTutorial();
                if (this._isInState)
                {
                    this.HideArrow();
                    this.HideTutorialDialog();
                    ((HUDView)this.View).SetTutorialButton(false);
                }
            }
        }, null);
    }

    public void UpdateBuildQueueButton()
    {
        ((HUDView)this.View).UpdateBuildQueueButton();
    }

    public void UpdateDemolishQueueButton()
    {
        ((HUDView)this.View).UpdateDemolishQueueButton();
    }

    public void WatchVideo()
    {
        Action greenButtonAction = delegate ()
        {
            if (SingletonMonobehaviour<VideoAds1Manager>.Instance.ShowVideoQuestAd())
            {
                ((HUDView)this.View).SetWatchVideoButtonVisible(false);
            }
        };
        if (SingletonMonobehaviour<VideoAds1Manager>.Instance.IsReady)
        {
            decimal m = 1m;
            Dependency dependency = SingletonMonobehaviour<DependencyTree>.Instance["quests"];
            Dependency child = dependency.GetChild((Dependency q) => q.Identifier == "game/videos_gold");
            if (child != null)
            {
                Dependency dependency2 = child.GetChild((Dependency l) => !l.IsAchieved || !l.RewardClaimed) ?? child.Children[child.Children.Count - 1];
                m = dependency2.Reward.GetValue("Gold");
            }
            SingletonMonobehaviour<PopupManager>.Instance.RequestFirstGenericPopup(UISpriteType.GoldLarge, Localization.Key("watch_video"), Localization.Format(Localization.Key("watch_video_popup_text"), new ILocalizedString[]
            {
                Localization.Integer(m),
                Localization.Key("gold")
            }), Localization.Key("ok"), Localization.EmptyLocalizedString, greenButtonAction, null, null, true);
        }
    }

    public void Like()
    {
        bool flag = false;
        CIGSparkSocServices instanceIfAvailable = SingletonMonobehaviour<CIGSparkSocServices>.InstanceIfAvailable;
        if (instanceIfAvailable != null)
        {
            flag = instanceIfAvailable.IsLogedInAndLinked();
        }
        if (!flag)
        {
            SingletonMonobehaviour<PopupManager>.Instance.RequestFirstPopup<SparkSocLoginPopupState>(delegate (State state)
            {
                ((SparkSocLoginPopupState)state).SetLoggedInCallback(new Action(this.OnLoggedIn));
            });
        }
        else
        {
            CIGIslandsManager instanceIfAvailable2 = SingletonMonobehaviour<CIGIslandsManager>.InstanceIfAvailable;
            if (instanceIfAvailable2 != null && instanceIfAvailable2.IsVisiting)
            {
                LeaderboardEntry visitingPlayer = SingletonMonobehaviour<CIGIslandsManager>.Instance.VisitingPlayer;
                if (LikeRegistrar.HaveVotedFor(visitingPlayer.InstallUuid))
                {
                    UnityEngine.Debug.LogError("Interface should have stopped double vote for player");
                }
                else
                {
                    instanceIfAvailable.VoteForPlayer(visitingPlayer.InstallUuid);
                    LikeRegistrar.SaveVoteFor(visitingPlayer.InstallUuid);
                    int num = LikeRegistrar.GetNumberOfLikes(visitingPlayer.InstallUuid);
                    num = Mathf.Max(num, Mathf.Max(visitingPlayer.Votes, 0));
                    LikeRegistrar.SaveNumberOfLikes(visitingPlayer.InstallUuid, num + 1);
                    ((HUDView)this.View).SetLikeButton();
                }
            }
            else
            {
                UnityEngine.Debug.LogError("No SparkSoc service!");
            }
        }
    }

    private void OnLoggedIn()
    {
        CIGIslandsManager instanceIfAvailable = SingletonMonobehaviour<CIGIslandsManager>.InstanceIfAvailable;
        if (instanceIfAvailable != null && instanceIfAvailable.IsVisiting)
        {
            ((HUDView)this.View).SetLikeButton();
        }
    }

    protected void UpdateSpeedupCost()
    {
    }

    protected void GameStateValueChanged(string key, object oldValue, object newValue)
    {
        CIGGameState instance = SingletonMonobehaviour<CIGGameState>.Instance;
        CIGIslandState cigislandState = UnityEngine.Object.FindObjectOfType<CIGIslandState>();
        HUDView hudview = (HUDView)this.View;
        if (key.StartsWith("UnlockedIsland"))
        {
            if (!true.Equals(oldValue) && true.Equals(newValue))
            {
                hudview.ShowWorldMapExclamationMark();
            }
            return;
        }
        if (key.Equals("Level"))
        {
            hudview.UpdateLevel(instance);
        }
        if (cigislandState == null)
        {
            return;
        }
        int num = cigislandState.Population;
        int num2 = cigislandState.Housing;
        int num3 = cigislandState.Employees;
        int num4 = cigislandState.Jobs;
        int num5 = cigislandState.AvailableHappiness;
        if (this.alwaysShowGlobalState || SingletonMonobehaviour<WorldMap>.Instance.IsVisible)
        {
            num = instance.GlobalPopulation;
            num2 = instance.GlobalHousing;
            num3 = instance.GlobalEmployees;
            num4 = instance.GlobalJobs;
            num5 = instance.GlobalHappiness;
        }
        int num6 = Mathf.Max(Mathf.Max(Mathf.Max(num2, num4), num5), num);
        if (key.Equals("EarnedBalance") || key.Equals("GiftedBalance"))
        {
            hudview.UpdateBalance(instance);
        }
        if (key.Equals("Happiness") || key.Equals("Housing") || key.Equals("GlobalHappiness") || key.Equals("GlobalHousing"))
        {
            hudview.UpdateHappiness(num5, num2);
        }
        if (key.Equals("Population") || key.Equals("Housing") || key.Equals("GlobalPopulation") || key.Equals("GlobalHousing"))
        {
            float progress = (num6 != 0) ? ((float)num / (float)num6) : 0f;
            hudview.UpdatePopulation(progress, num, num2);
        }
        if (key.Equals("Employees") || key.Equals("Jobs") || key.Equals("GlobalEmployees") || key.Equals("GlobalJobs"))
        {
            float progress2 = (num6 != 0) ? ((float)num3 / (float)num6) : 0f;
            hudview.UpdateEmployees(progress2, num3, num4);
        }
    }

    protected void DetermineViewState()
    {
        if (SingletonMonobehaviour<CIGIslandsManager>.IsAvailable && SingletonMonobehaviour<CIGIslandsManager>.Instance.IsVisiting)
        {
            if (SingletonMonobehaviour<WorldMap>.IsAvailable && SingletonMonobehaviour<WorldMap>.Instance.IsVisible)
            {
                ((HUDView)this.View).SetViewState(HUDViewState.VisitingWorldMap);
            }
            else
            {
                ((HUDView)this.View).SetViewState(HUDViewState.VisitingIsland);
            }
        }
        else if (SingletonMonobehaviour<WorldMap>.IsAvailable && SingletonMonobehaviour<WorldMap>.Instance.IsVisible)
        {
            ((HUDView)this.View).SetViewState(HUDViewState.WorldMap);
        }
        else if (base.fsm != null && base.fsm.CurrentState is HUDConfirmState)
        {
            ((HUDView)this.View).SetViewState(HUDViewState.Confirm);
        }
        else
        {
            ((HUDView)this.View).SetViewState(HUDViewState.Island);
        }
    }

    private IEnumerator ShowWorldMapRoutine()
    {
        yield return SingletonMonobehaviour<CinematicEffect>.Instance.ShowAnimated();
        SingletonMonobehaviour<WorldMap>.Instance.ShowInstant();
        yield return SingletonMonobehaviour<CinematicEffect>.Instance.HideAnimated();
        yield break;
    }

    private IEnumerator HideWorldMapRoutine()
    {
        yield return SingletonMonobehaviour<CinematicEffect>.Instance.ShowAnimated();
        SingletonMonobehaviour<WorldMap>.Instance.HideInstant();
        yield return SingletonMonobehaviour<CinematicEffect>.Instance.HideAnimated();
        yield break;
    }

    private void OnVideoAvailabilityChanged()
    {
        ((HUDView)this.View).SetWatchVideoButtonVisible(SingletonMonobehaviour<VideoAds1Manager>.Instance.IsReady);
    }

    private void OnVisitingStarted()
    {
        ((HUDView)this.View).SetVisitingInfo(SingletonMonobehaviour<CIGIslandsManager>.Instance.VisitingPlayer);
    }

    private void OnVisitingStopped()
    {
        this.DetermineViewState();
    }

    private void RefreshEyeButtonToggle()
    {
        ((HUDView)this.View).SetEyeButtonToggle(IsometricIsland.Current != null && IsometricIsland.Current.builder.TilesHidden);
    }

    private void RefreshShowLevelsButtonToggle()
    {
        ((HUDView)this.View).SetShowLevelsButtonToggle(!UpgradableBuilding.LevelIconsHidden);
    }

    private void OnWorldMapVisibility(bool visible)
    {
        this.DetermineViewState();
        this.HideArrow();
        this.HideTutorialDialog();
        this.UpdateAll();
    }

    protected void OnDependencyAchievedChanged(Dependency dependency, bool achieved)
    {
        this.UpdateRewardBadge();
    }

    protected void OnDependencyActiveChanged(Dependency dependency, bool active)
    {
        this.UpdateRewardBadge();
    }

    protected void OnDependencyRewardClaimed(Dependency dependency, bool claimed)
    {
        this.UpdateRewardBadge();
    }

    protected void UpdateRewardBadge()
    {
        int num = 0;
        Dependency dependency = SingletonMonobehaviour<DependencyTree>.Instance["quests"];
        int count = dependency.Children.Count;
        for (int i = 0; i < count; i++)
        {
            Dependency dependency2 = dependency.Children[i];
            if (dependency2.IsActive)
            {
                int count2 = dependency2.Children.Count;
                for (int j = 0; j < count2; j++)
                {
                    Dependency dependency3 = dependency2.Children[j];
                    if (dependency3.IsAchieved && !dependency3.RewardClaimed)
                    {
                        num++;
                    }
                }
            }
        }
        ((HUDView)this.View).SetRewardBadge(num > 0);
    }

    public bool alwaysShowGlobalState = true;

    private CIGTutorialManager tutorial;

    private Action _dialogHiddenAction;

    private IEnumerator _showWorldMapRoutine;

    private IEnumerator _hideWorldMapRoutine;

    private List<object> _settingsExclamationRequests = new List<object>();
}