Example #1
0
        private void SetupEmptyButton()
        {
            var building = BuildingManager.instance.m_buildings
                           .m_buffer[ServiceRestrictTool.instance.SelectedBuildingID].Info;

            Inputs.Add(UIUtils.CreateButton(this, "Restrict Emptying", (component, e) =>
            {
                if (ServiceRestrictTool.instance.CustomServiceBuildingOptions.TryGetValue(
                        ServiceRestrictTool.instance.SelectedBuildingID, out var options))
                {
                    options.RestrictEmptying = !options.RestrictEmptying;
                }
                else
                {
                    ServiceBuildingOptions newOptions = new ServiceBuildingOptions {
                        RestrictEmptying = true
                    };
                    ServiceRestrictTool.instance.CustomServiceBuildingOptions.Add(
                        ServiceRestrictTool.instance.SelectedBuildingID, newOptions);
                }
            }, 0.6f));

            var emptyButton = Inputs.Find(x => x.name == "Restrict EmptyingButton");

            if (!building.m_buildingAI.CanBeEmptied())
            {
                emptyButton.isEnabled = false;
                emptyButton.tooltip   = "This Building doesn't require emptying.";
            }
        }
Example #2
0
        private static void OnParkCheckChanged(UIComponent comp, bool value)
        {
            if (ServiceRestrictTool.instance.CustomServiceBuildingOptions.TryGetValue(
                    ServiceRestrictTool.instance.SelectedBuildingID, out var options))
            {
                if (value)
                {
                    options.CoveredParks.Add(DistrictHelper.RetrieveParkIDFromName(comp.name));
                }
                else
                {
                    options.CoveredParks.Remove(DistrictHelper.RetrieveParkIDFromName(comp.name));
                }
            }
            else
            {
                if (!value)
                {
                    return;
                }

                ServiceBuildingOptions serviceBuildingOptions = new ServiceBuildingOptions();
                serviceBuildingOptions.CoveredParks.Add(DistrictHelper.RetrieveParkIDFromName(comp.name));

                ServiceRestrictTool.instance.CustomServiceBuildingOptions.Add(
                    ServiceRestrictTool.instance.SelectedBuildingID, serviceBuildingOptions);
            }
        }
Example #3
0
        public static void CopyOptions(ServiceBuildingOptions options, ushort buildingID)
        {
            CopiedOptions = new ServiceBuildingOptions
            {
                CoveredDistricts = options.CoveredDistricts,
                Inverted         = options.Inverted,
                RestrictEmptying = options.RestrictEmptying
            };

            CopiedBuildingID = buildingID;
        }
Example #4
0
        public static ServiceBuildingOptions PasteOptions()
        {
            if (CopiedOptions == null)
            {
                return(new ServiceBuildingOptions());
            }

            var options = new ServiceBuildingOptions
            {
                CoveredDistricts = CopiedOptions.CoveredDistricts,
                Inverted         = CopiedOptions.Inverted,
                RestrictEmptying = CopiedOptions.RestrictEmptying
            };

            return(options);
        }
Example #5
0
 public BuildingOptionsEntry(ushort key, ServiceBuildingOptions options)
 {
     Key   = key;
     Value = options;
 }
Example #6
0
        private void Setup()
        {
            name             = "ServiceRestrictionRestrictDistrictsPanel";
            isVisible        = false;
            canFocus         = true;
            isInteractive    = true;
            relativePosition = new Vector3(0f, UiTitleBar.Instance.height);
            width            = parent.width;

            float widestWidth = 0f;

            Inputs  = new List <UIComponent>();
            _labels = new List <UILabel>();

            foreach (var district in DistrictHelper.RetrieveAllDistrictNames().Where(x =>
                                                                                     x != DistrictManager.instance.GetDistrictName(DistrictManager.instance.GetDistrict(BuildingManager
                                                                                                                                                                        .instance.m_buildings.m_buffer[ServiceRestrictTool.instance.SelectedBuildingID].m_position))))
            {
                var label = AddUIComponent <UILabel>();
                label.name          = district + "Label";
                label.text          = district;
                label.textScale     = 0.9f;
                label.isInteractive = false;

                try
                {
                    Inputs.Add(UIUtils.CreateCheckbox(this, district));
                    _labels.Add(label);


                    if (label.width + UIUtils.FieldWidth + UIUtils.FieldMargin * 6 > widestWidth)
                    {
                        widestWidth = label.width + UIUtils.FieldWidth + UIUtils.FieldMargin * 6;
                    }
                }
                catch (Exception e)
                {
                    Debug.Log($"Couldn't create Checkbox for {district}. {e.Message} - {e.StackTrace}");
                }
            }

            Inputs.Add(UIUtils.CreateCheckbox(this, "aaThisDistrictOnly"));

            var thisDistrictLabel = AddUIComponent <UILabel>();

            thisDistrictLabel.name = "aaThisDistrictOnlyLabel";
            thisDistrictLabel.text = DistrictManager.instance.GetDistrictName(
                DistrictManager.instance.GetDistrict(BuildingManager.instance.m_buildings
                                                     .m_buffer[ServiceRestrictTool.instance.SelectedBuildingID].m_position));
            thisDistrictLabel.textScale     = 0.9f;
            thisDistrictLabel.isInteractive = false;
            thisDistrictLabel.textColor     = Color.green;

            _labels.Add(thisDistrictLabel);

            Inputs.Sort((x, y) => x.name.CompareTo(y.name));
            _labels.Sort((x, y) => x.name.CompareTo(y.name));

            SetupEmptyButton();

            Inputs.Add(UIUtils.CreateCheckbox(this, "Invert", (component, value) =>
            {
                if (ServiceRestrictTool.instance.CustomServiceBuildingOptions.TryGetValue(
                        ServiceRestrictTool.instance.SelectedBuildingID, out var options))
                {
                    options.Inverted = !options.Inverted;
                }
                else
                {
                    ServiceBuildingOptions newOptions = new ServiceBuildingOptions {
                        Inverted = true
                    };
                    ServiceRestrictTool.instance.CustomServiceBuildingOptions.Add(
                        ServiceRestrictTool.instance.SelectedBuildingID, newOptions);
                }
            }));


            SetupButtons();
            SetupCopyButtons();

            width = RestrictedDistrictPanelWrapper.Instance.width =
                UiTitleBar.Instance.width = UiTitleBar.Instance.DragHandle.width = widestWidth;

            UiTitleBar.Instance.RecenterElements();
            Align();
            AlignButtons();

            height = Inputs.Count * (UIUtils.FieldHeight + UIUtils.FieldMargin) + UIUtils.FieldMargin * 3;

            RestrictedDistrictPanelWrapper.Instance.height = height + UiTitleBar.Instance.height;

            RestrictedDistrictPanelWrapper.Instance.relativePosition =
                new Vector3(ServiceRestrictionsMod.Settings.PanelX, ServiceRestrictionsMod.Settings.PanelY);

            isVisible = RestrictedDistrictPanelWrapper.Instance.isVisible =
                UiTitleBar.Instance.isVisible = UiTitleBar.Instance.DragHandle.isVisible = true;
        }
Example #7
0
        private void SetupCopyButtons()
        {
            Inputs.Add(UIUtils.CreateButton(this, "Copy Options", (component, value) =>
            {
                if (!ServiceRestrictTool.instance.CustomServiceBuildingOptions.TryGetValue(
                        ServiceRestrictTool.instance.SelectedBuildingID, out var options))
                {
                    return;
                }

                Clipboard.CopyOptions(options, ServiceRestrictTool.instance.SelectedBuildingID);
            }, 0.6f));


            var copyButton = Inputs.Find(x => x.name == "Copy OptionsButton");

            if (!ServiceRestrictTool.instance.CustomServiceBuildingOptions.TryGetValue(
                    ServiceRestrictTool.instance.SelectedBuildingID, out var _))
            {
                copyButton.isEnabled = false;
                copyButton.tooltip   = "No Options are present on this building.";
            }

            copyButton.tooltip = "Copies the existing options to the clipboard." + Environment.NewLine +
                                 "This will overwrite any previous copied settings on the clipboard.";


            Inputs.Add(UIUtils.CreateButton(this, "Paste Options", (component, param) =>
            {
                if (Clipboard.CopiedOptions == null)
                {
                    return;
                }

                if (!ServiceRestrictTool.instance.CustomServiceBuildingOptions.TryGetValue(
                        ServiceRestrictTool.instance.SelectedBuildingID, out var _))
                {
                    ServiceBuildingOptions newOptions = Clipboard.PasteOptions();

                    ServiceRestrictTool.instance.CustomServiceBuildingOptions.Add(
                        ServiceRestrictTool.instance.SelectedBuildingID, newOptions);
                }
                else
                {
                    var tempOptions = Clipboard.PasteOptions();
                    ServiceRestrictTool.instance.CustomServiceBuildingOptions[
                        ServiceRestrictTool.instance.SelectedBuildingID] = tempOptions;
                }

                foreach (var input in Inputs)
                {
                    if (input is UICheckBox checkbox)
                    {
                        switch (checkbox.name)
                        {
                        case "Areas without a district.":
                            {
                                checkbox.isChecked =
                                    ServiceRestrictTool.instance.CustomServiceBuildingOptions.TryGetValue(
                                        ServiceRestrictTool.instance.SelectedBuildingID, out var props) &&
                                    props.CoveredDistricts.Contains(0);
                            }
                            break;

                        case "aaThisDistrictOnly":
                            {
                                checkbox.isChecked =
                                    ServiceRestrictTool.instance.CustomServiceBuildingOptions.TryGetValue(
                                        ServiceRestrictTool.instance.SelectedBuildingID, out var props) &&
                                    props.CoveredDistricts.Contains(DistrictHelper.RetrieveDistrictIDFromName(
                                                                        DistrictManager.instance.GetDistrictName(
                                                                            DistrictManager.instance.GetDistrict(BuildingManager.instance.m_buildings
                                                                                                                 .m_buffer[ServiceRestrictTool.instance.SelectedBuildingID]
                                                                                                                 .m_position))));
                            }
                            break;

                        default:
                            {
                                checkbox.isChecked =
                                    ServiceRestrictTool.instance.CustomServiceBuildingOptions.TryGetValue(
                                        ServiceRestrictTool.instance.SelectedBuildingID, out var props) &&
                                    props.CoveredDistricts.Contains(
                                        DistrictHelper.RetrieveDistrictIDFromName(checkbox.name));
                            }
                            break;
                        }
                    }
                }
            }, 0.6f));

            var pasteButton = Inputs.Find(x => x.name == "Paste OptionsButton");

            if (Clipboard.CopiedOptions == null)
            {
                pasteButton.isEnabled = false;
                pasteButton.tooltip   = "No Options have been copied yet.";
            }

            pasteButton.tooltip =
                $"Pastes the copied settings from {CustomizeItExtendedCompatibility.RetrieveBuildingName(Clipboard.CopiedBuildingID)} onto this building." +
                Environment.NewLine +
                "This will overwrite this buildings current settings.";
        }