tbd-station-14/Content.Client/Research/UI/ResearchConsoleMenu.cs

using System.Collections.Generic;
using Content.Shared.Research.Prototypes;
using Robust.Client.Graphics;
using Robust.Client.UserInterface.Controls;
using Robust.Client.UserInterface.CustomControls;
using Robust.Client.Utility;
using Robust.Shared.IoC;
using Robust.Shared.Localization;
using Robust.Shared.Prototypes;

namespace Content.Client.Research.UI
{
    public class ResearchConsoleMenu : SS14Window
    {
        public ResearchConsoleBoundUserInterface Owner { get; }

        private readonly List<TechnologyPrototype> _unlockedTechnologyPrototypes = new();
        private readonly List<TechnologyPrototype> _unlockableTechnologyPrototypes = new();
        private readonly List<TechnologyPrototype> _futureTechnologyPrototypes = new();

        private readonly Label _pointLabel;
        private readonly Label _pointsPerSecondLabel;
        private readonly Label _technologyName;
        private readonly Label _technologyDescription;
        private readonly Label _technologyRequirements;
        private readonly TextureRect _technologyIcon;
        private readonly ItemList _unlockedTechnologies;
        private readonly ItemList _unlockableTechnologies;
        private readonly ItemList _futureTechnologies;

        public Button UnlockButton { get; private set; }
        public Button ServerSelectionButton { get; private set; }
        public Button ServerSyncButton { get; private set; }

        public TechnologyPrototype? TechnologySelected;

        public ResearchConsoleMenu(ResearchConsoleBoundUserInterface owner)
        {
            SetSize = MinSize = (800, 400);

            IoCManager.InjectDependencies(this);

            Title = Loc.GetString("research-console-menu-title");

            Owner = owner;

            _unlockedTechnologies = new ItemList()
            {
                SelectMode = ItemList.ItemListSelectMode.Button,
                HorizontalExpand = true,
                VerticalExpand = true,
            };

            _unlockedTechnologies.OnItemSelected += UnlockedTechnologySelected;

            _unlockableTechnologies = new ItemList()
            {
                SelectMode = ItemList.ItemListSelectMode.Button,
                HorizontalExpand = true,
                VerticalExpand = true,
            };

            _unlockableTechnologies.OnItemSelected += UnlockableTechnologySelected;

            _futureTechnologies = new ItemList()
            {
                SelectMode = ItemList.ItemListSelectMode.Button,
                HorizontalExpand = true,
                VerticalExpand = true,
            };

            _futureTechnologies.OnItemSelected += FutureTechnologySelected;

            var vbox = new VBoxContainer()
            {
                HorizontalExpand = true,
                VerticalExpand = true,
            };

            var hboxTechnologies = new HBoxContainer()
            {
                HorizontalExpand = true,
                VerticalExpand = true,
                SizeFlagsStretchRatio = 2,
                SeparationOverride = 10,
            };

            var hboxSelected = new HBoxContainer()
            {
                HorizontalExpand = true,
                VerticalExpand = true,
                SizeFlagsStretchRatio = 1
            };

            var vboxPoints = new VBoxContainer()
            {
                HorizontalExpand = true,
                VerticalExpand = true,
                SizeFlagsStretchRatio = 1,
            };

            var vboxTechInfo = new VBoxContainer()
            {
                HorizontalExpand = true,
                VerticalExpand = true,
                SizeFlagsStretchRatio = 3,
            };

            _pointLabel = new Label() { Text = Loc.GetString("research-console-menu-research-points-text", ("points", 0)) };
            _pointsPerSecondLabel = new Label() { Text = Loc.GetString("research-console-menu-points-per-second-text", ("pointsPerSecond", 0)) };

            var vboxPointsButtons = new VBoxContainer()
            {
                Align = BoxContainer.AlignMode.End,
                HorizontalExpand = true,
                VerticalExpand = true,
            };

            ServerSelectionButton = new Button() { Text = Loc.GetString("research-console-menu-server-selection-button") };
            ServerSyncButton = new Button() { Text = Loc.GetString("research-console-menu-server-sync-button") };
            UnlockButton = new Button() { Text = Loc.GetString("research-console-menu-server-unlock-button"), Disabled = true };


            vboxPointsButtons.AddChild(ServerSelectionButton);
            vboxPointsButtons.AddChild(ServerSyncButton);
            vboxPointsButtons.AddChild(UnlockButton);

            vboxPoints.AddChild(_pointLabel);
            vboxPoints.AddChild(_pointsPerSecondLabel);
            vboxPoints.AddChild(vboxPointsButtons);

            _technologyIcon = new TextureRect()
            {
                HorizontalExpand = true,
                VerticalExpand = true,
                SizeFlagsStretchRatio = 1,
                Stretch = TextureRect.StretchMode.KeepAspectCentered,
            };
            _technologyName = new Label();
            _technologyDescription = new Label();
            _technologyRequirements = new Label();

            vboxTechInfo.AddChild(_technologyName);
            vboxTechInfo.AddChild(_technologyDescription);
            vboxTechInfo.AddChild(_technologyRequirements);

            hboxSelected.AddChild(_technologyIcon);
            hboxSelected.AddChild(vboxTechInfo);
            hboxSelected.AddChild(vboxPoints);

            hboxTechnologies.AddChild(_unlockedTechnologies);
            hboxTechnologies.AddChild(_unlockableTechnologies);
            hboxTechnologies.AddChild(_futureTechnologies);

            vbox.AddChild(hboxTechnologies);
            vbox.AddChild(hboxSelected);

            Contents.AddChild(vbox);

            UnlockButton.OnPressed += (args) =>
            {
                CleanSelectedTechnology();
            };

            Populate();
        }

        /// <summary>
        ///     Cleans the selected technology controls to blank.
        /// </summary>
        private void CleanSelectedTechnology()
        {
            UnlockButton.Disabled = true;
            _technologyIcon.Texture = Texture.Transparent;
            _technologyName.Text = string.Empty;
            _technologyDescription.Text = string.Empty;
            _technologyRequirements.Text = string.Empty;
        }

        /// <summary>
        ///     Called when an unlocked technology is selected.
        /// </summary>
        private void UnlockedTechnologySelected(ItemList.ItemListSelectedEventArgs obj)
        {
            TechnologySelected = _unlockedTechnologyPrototypes[obj.ItemIndex];

            UnlockButton.Disabled = true;

            PopulateSelectedTechnology();
        }

        /// <summary>
        ///     Called when an unlockable technology is selected.
        /// </summary>
        private void UnlockableTechnologySelected(ItemList.ItemListSelectedEventArgs obj)
        {
            TechnologySelected = _unlockableTechnologyPrototypes[obj.ItemIndex];

            UnlockButton.Disabled = Owner.Points < TechnologySelected.RequiredPoints;

            PopulateSelectedTechnology();
        }

        /// <summary>
        ///     Called when a future technology is selected
        /// </summary>
        private void FutureTechnologySelected(ItemList.ItemListSelectedEventArgs obj)
        {
            TechnologySelected = _futureTechnologyPrototypes[obj.ItemIndex];

            UnlockButton.Disabled = true;

            PopulateSelectedTechnology();
        }

        /// <summary>
        ///     Populate all technologies in the ItemLists.
        /// </summary>
        public void PopulateItemLists()
        {
            _unlockedTechnologies.Clear();
            _unlockableTechnologies.Clear();
            _futureTechnologies.Clear();

            _unlockedTechnologyPrototypes.Clear();
            _unlockableTechnologyPrototypes.Clear();
            _futureTechnologyPrototypes.Clear();

            var prototypeMan = IoCManager.Resolve<IPrototypeManager>();

            // For now, we retrieve all technologies. In the future, this should be changed.
            foreach (var tech in prototypeMan.EnumeratePrototypes<TechnologyPrototype>())
            {
                if (Owner.IsTechnologyUnlocked(tech))
                {
                    _unlockedTechnologies.AddItem(tech.Name, tech.Icon.Frame0());
                    _unlockedTechnologyPrototypes.Add(tech);
                }
                else if (Owner.CanUnlockTechnology(tech))
                {
                    _unlockableTechnologies.AddItem(tech.Name, tech.Icon.Frame0());
                    _unlockableTechnologyPrototypes.Add(tech);
                }
                else
                {
                    _futureTechnologies.AddItem(tech.Name, tech.Icon.Frame0());
                    _futureTechnologyPrototypes.Add(tech);
                }
            }
        }

        /// <summary>
        ///     Fills the selected technology controls with details.
        /// </summary>
        public void PopulateSelectedTechnology()
        {
            if (TechnologySelected == null)
            {
                _technologyName.Text = string.Empty;
                _technologyDescription.Text = string.Empty;
                _technologyRequirements.Text = string.Empty;
                return;
            }

            _technologyIcon.Texture = TechnologySelected.Icon.Frame0();
            _technologyName.Text = TechnologySelected.Name;
            _technologyDescription.Text = TechnologySelected.Description + $"\n{TechnologySelected.RequiredPoints} " + Loc.GetString("research-console-menu-research-points-text" ,("points", Owner.Points)).ToLowerInvariant();
            _technologyRequirements.Text = Loc.GetString("research-console-tech-requirements-none");

            var prototypeMan = IoCManager.Resolve<IPrototypeManager>();

            for (var i = 0; i < TechnologySelected.RequiredTechnologies.Count; i++)
            {
                var requiredId = TechnologySelected.RequiredTechnologies[i];
                if (!prototypeMan.TryIndex(requiredId, out TechnologyPrototype? prototype)) continue;
                if (i == 0)
                    _technologyRequirements.Text = Loc.GetString("research-console-tech-requirements-prototype-name", ("prototypeName", prototype.Name));
                else
                    _technologyRequirements.Text += $", {prototype.Name}";
            }
        }

        /// <summary>
        ///     Updates the research point labels.
        /// </summary>
        public void PopulatePoints()
        {
            _pointLabel.Text = Loc.GetString("research-console-menu-research-points-text", ("points", Owner.Points));
            _pointsPerSecondLabel.Text = Loc.GetString("research-console-menu-points-per-second-text", ("pointsPerSecond", Owner.PointsPerSecond));
        }

        /// <summary>
        ///     Updates the whole user interface.
        /// </summary>
        public void Populate()
        {
            PopulatePoints();
            PopulateSelectedTechnology();
            PopulateItemLists();
        }
    }
}