FREE UiMergeFramework : 1.1.0 1.1.0

// Все права принадлежат дискорд сообществу https://discord.gg/VgNHPpNrz6
using Color = UnityEngine.Color;
using Net = Network.Net;
using Network;
using Newtonsoft.Json;
using Pool = Facepunch.Pool;
using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Text.RegularExpressions;
using UnityEngine;

//UiMergeFramework created with PluginMerge v(1.0.0.0) by MJSU
namespace Oxide.Plugins
{
    //Define:Framework
    //[Info("Rust UI Framework", "MJSU", "1.1.0")]
    //[Description("UI Framework for Rust")]
    public partial class UiMergeFramework : RustPlugin
    {
        #region Plugin\UiFramework.Methods.cs
        #region JSON Sending
        public void DestroyUi(BasePlayer player, string name)
        {
            CommunityEntity.ServerInstance.ClientRPCEx(new SendInfo(player.Connection), null, "DestroyUI", name);
        }
        
        public void DestroyUi(List<Connection> connections, string name)
        {
            CommunityEntity.ServerInstance.ClientRPCEx(new SendInfo(connections), null, "DestroyUI", name);
        }
        
        private void DestroyUiAll(string name)
        {
            CommunityEntity.ServerInstance.ClientRPCEx(new SendInfo(Net.sv.connections), null, "DestroyUI", name);
        }
        #endregion
        #endregion

        #region Plugin\UiFramework.PreventMovement.cs
        private const string ChairPrefab = "assets/prefabs/vehicle/seats/standingdriver.prefab";
        private const ulong PreventMovementSkinId = ulong.MaxValue - 51234;
        
        private uint _prefabId;
        
        public void InitPreventMovement()
        {
            if (_prefabId == 0)
            {
                _prefabId = StringPool.Get(ChairPrefab);
            }
        }
        
        public void PreventMovement(BasePlayer player)
        {
            InitPreventMovement();
            
            BaseMountable currentMount = player.GetMounted();
            if (currentMount != null)
            {
                return;
            }
            
            Transform transform = player.transform;
            BaseVehicleSeat chair = GameManager.server.CreateEntity(ChairPrefab, transform.position, transform.rotation) as BaseVehicleSeat;
            chair.skinID = PreventMovementSkinId;
            chair.Spawn();
            player.MountObject(chair);
        }
        
        public void AllowMovement(BasePlayer player)
        {
            InitPreventMovement();
            BaseMountable mounted = player.GetMounted();
            if (mounted != null && mounted.prefabID == _prefabId && mounted.parentEntity.uid == 0 && mounted.skinID == PreventMovementSkinId)
            {
                player.DismountObject();
                mounted.Kill();
            }
        }
        #endregion

    }

    #region Constants.cs
    public class Constants
    {
        public static class UiFonts
        {
            public static readonly string DroidSansMono = "droidsansmono.ttf";
            public static readonly string PermanentMarker = "permanentmarker.ttf";
            public static readonly string RobotoCondensedBold = "robotocondensed-bold.ttf";
            public static readonly string RobotoCondensedRegular = "robotocondensed-regular.ttf";
            
            private static readonly Hash<UiFont, string> _fonts = new Hash<UiFont, string>
            {
                [UiFont.DroidSansMono] = DroidSansMono,
                [UiFont.PermanentMarker] = PermanentMarker,
                [UiFont.RobotoCondensedBold] = RobotoCondensedBold,
                [UiFont.RobotoCondensedRegular] = RobotoCondensedRegular,
            };
            
            public static string GetUiFont(UiFont font)
            {
                return _fonts[font];
            }
        }
        
        public static class UiLayers
        {
            public static readonly string Overall = "Overall";
            public static readonly string Overlay = "Overlay";
            public static readonly string Hud = "Hud";
            public static readonly string HudMenu = "Hud.Menu";
            public static readonly string Under = "Under";
            
            private static readonly Hash<UiLayer, string> _layers = new Hash<UiLayer, string>
            {
                [UiLayer.Overall] = Overall,
                [UiLayer.Overlay] = Overlay,
                [UiLayer.Hud] = Hud,
                [UiLayer.HudMenu] = HudMenu,
                [UiLayer.Under] = Under,
            };
            
            public static string GetLayer(UiLayer layer)
            {
                return _layers[layer];
            }
        }
        
        public static class RpcFunctions
        {
            public static readonly string AddUiFunc = "AddUI";
            public static readonly string DestroyUiFunc = "DestroyUI";
        }
        
        public static class Json
        {
            public static readonly char QuoteChar = '\"';
        }
    }
    #endregion

    #region Builder\UiBuilder.cs
    public partial class UiBuilder : IDisposable
    {
        public BaseUiComponent Root;
        
        private string _cachedJson;
        private bool _disposed;
        
        private List<BaseUiComponent> _components = Pool.GetList<BaseUiComponent>();
        
        private static string _font;
        
        #region Constructor
        static UiBuilder()
        {
            SetFont(UiFont.RobotoCondensedRegular);
        }
        
        public UiBuilder(UiColor color, UiPosition pos, UiOffset offset, bool useCursor, string name, string parent)
        {
            UiPanel panel = UiPanel.Create(pos, offset, color);
            panel.NeedsCursor = useCursor;
            SetRoot(panel, name, parent);
        }
        
        public UiBuilder(UiColor color, UiPosition pos, bool useCursor, string name, string parent) : this(color, pos, null, useCursor, name, parent)
        {
            
        }
        
        public UiBuilder(UiColor color, UiPosition pos, bool useCursor, string name, UiLayer parent = UiLayer.Overlay) : this(color, pos, null, useCursor, name, Constants.UiLayers.GetLayer(parent))
        {
            
        }
        
        public UiBuilder(UiColor color, UiPosition pos, UiOffset offset, bool useCursor, string name, UiLayer parent = UiLayer.Overlay) : this(color, pos, offset, useCursor, name, Constants.UiLayers.GetLayer(parent))
        {
            
        }
        
        public UiBuilder(BaseUiComponent root, string name, string parent)
        {
            SetRoot(root, name, parent);
        }
        
        public UiBuilder()
        {
            
        }
        
        public void SetRoot(BaseUiComponent component, string name, string parent)
        {
            Root = component;
            component.Parent = parent;
            component.Name = name;
            _components.Add(component);
        }
        
        public static void SetFont(UiFont font)
        {
            _font = Constants.UiFonts.GetUiFont(font);
        }
        #endregion
        
        #region Decontructor
        ~UiBuilder()
        {
            Dispose();
        }
        
        public void Dispose()
        {
            if (_disposed)
            {
                return;
            }
            
            _disposed = true;
            
            for (int index = 0; index < _components.Count; index++)
            {
                BaseUiComponent component = _components[index];
                Pool.Free(ref component);
            }
            
            Pool.FreeList(ref _components);
            Root = null;
            _cachedJson = null;
        }
        #endregion
        
        #region Add UI
        public void AddComponent(BaseUiComponent component, BaseUiComponent parent)
        {
            component.Parent = parent.Name;
            component.Name = GetComponentName();
            _components.Add(component);
        }
        
        public string GetComponentName()
        {
            return string.Concat(Root.Name, "_", _components.Count.ToString());
        }
        
        public UiPanel Section(BaseUiComponent parent, UiPosition pos)
        {
            UiPanel section = UiPanel.Create(pos, null, UiColors.Clear);
            AddComponent(section, parent);
            return section;
        }
        
        public UiPanel Panel(BaseUiComponent parent, UiColor color, UiPosition pos)
        {
            UiPanel panel = UiPanel.Create(pos, null, color);
            AddComponent(panel, parent);
            return panel;
        }
        
        public UiPanel Panel(BaseUiComponent parent, UiColor color, UiPosition pos, UiOffset offset)
        {
            UiPanel panel = UiPanel.Create(pos, offset, color);
            AddComponent(panel, parent);
            return panel;
        }
        
        public UiButton EmptyCommandButton(BaseUiComponent parent, UiColor color, UiPosition pos, string cmd)
        {
            UiButton button = UiButton.CreateCommand(pos, color , cmd);
            AddComponent(button, parent);
            return button;
        }
        
        public UiButton EmptyCloseButton(BaseUiComponent parent, UiColor color, UiPosition pos, string close)
        {
            UiButton button = UiButton.CreateClose(pos, color, close);
            AddComponent(button, parent);
            return button;
        }
        
        public UiButton TextButton(BaseUiComponent parent, string text, int textSize, UiColor textColor, UiColor buttonColor, UiPosition pos, string cmd, TextAnchor align = TextAnchor.MiddleCenter)
        {
            UiButton button = EmptyCommandButton(parent, buttonColor, pos, cmd);
            Label(button, text, textSize, textColor, UiPosition.FullPosition, align);
            return button;
        }
        
        public UiButton ImageButton(BaseUiComponent parent, UiColor buttonColor, string png, UiPosition pos, string cmd)
        {
            UiButton button = EmptyCommandButton(parent, buttonColor, pos, cmd);
            Image(button, png, UiPosition.FullPosition);
            return button;
        }
        
        public UiButton TextCloseButton(BaseUiComponent parent, string text, int textSize, UiColor textColor, UiColor buttonColor, UiPosition pos, string close, TextAnchor align = TextAnchor.MiddleCenter)
        {
            UiButton button = EmptyCloseButton(parent, buttonColor, pos, close);
            Label(button, text, textSize, textColor, UiPosition.FullPosition, align);
            return button;
        }
        
        public UiButton ImageCloseButton(BaseUiComponent parent, UiColor buttonColor, string png, UiPosition pos, string close)
        {
            UiButton button = EmptyCloseButton(parent, buttonColor, pos, close);
            Image(button, png, UiPosition.FullPosition);
            return button;
        }
        
        public UiImage Image(BaseUiComponent parent, string png, UiPosition pos, UiColor color)
        {
            UiImage image = UiImage.Create(png, pos, color);
            AddComponent(image, parent);
            return image;
        }
        
        public UiImage Image(BaseUiComponent parent, string png, UiPosition pos)
        {
            return Image(parent, png, pos, UiColors.White);
        }
        
        public UiLabel Label(BaseUiComponent parent, string text, int size, UiColor color, UiPosition pos, TextAnchor align = TextAnchor.MiddleCenter)
        {
            UiLabel label = UiLabel.Create(text, size, color, pos, _font, align);
            AddComponent(label, parent);
            return label;
        }
        
        public UiLabel LabelBackground(BaseUiComponent parent, string text, int size, UiColor color, UiColor backgroundColor, UiPosition pos, TextAnchor align = TextAnchor.MiddleCenter)
        {
            UiPanel panel = Panel(parent, backgroundColor, pos);
            UiLabel label = UiLabel.Create(text, size, color, UiPosition.FullPosition, _font, align);
            AddComponent(label, panel);
            return label;
        }
        
        public UiInput Input(BaseUiComponent parent, int size, UiColor textColor, UiColor backgroundColor, UiPosition pos, string cmd, TextAnchor align = TextAnchor.MiddleCenter, int charsLimit = 0, bool isPassword = false)
        {
            parent = Panel(parent, backgroundColor, pos);
            UiInput input = UiInput.Create(size, textColor, pos, cmd, _font, align,  charsLimit, isPassword);
            AddComponent(input, parent);
            return input;
        }
        
        private readonly Position _boarderTop = new Position("0 1", "1 1");
        private readonly Position _boarderBottom = new Position("0 0", "1 0");
        private readonly Position _boarderLeft = new Position("0 0", "0 1");
        private readonly Position _boarderRight = new Position("1 0", "1 1");
        
        public void Border(BaseUiComponent parent, UiColor color, int size = 0, BorderMode border = BorderMode.Top | BorderMode.Bottom | BorderMode.Left | BorderMode.Right)
        {
            string sizeString = size.ToString();
            if (HasBorderFlag(border, BorderMode.Top))
            {
                UiPanel panel = UiPanel.Create(_boarderTop, new Offset("0 -1", $"0 {sizeString}"), color);
                AddComponent(panel, parent);
            }
            
            if (HasBorderFlag(border, BorderMode.Left))
            {
                UiPanel panel = UiPanel.Create(_boarderLeft, new Offset($"-{sizeString} -{sizeString}", "1 0"), color);
                AddComponent(panel, parent);
            }
            
            if(HasBorderFlag(border, BorderMode.Bottom))
            {
                UiPanel panel = UiPanel.Create(_boarderBottom, new Offset($"0 -{sizeString}", "0 1"), color);
                AddComponent(panel, parent);
            }
            
            if (HasBorderFlag(border, BorderMode.Right))
            {
                UiPanel panel = UiPanel.Create(_boarderRight, new Offset("-1 0", $"{sizeString} 0"), color);
                AddComponent(panel, parent);
            }
        }
        
        private bool HasBorderFlag(BorderMode mode, BorderMode flag)
        {
            return (mode & flag) != 0;
        }
        #endregion
        
        #region JSON
        public string ToJson()
        {
            return JsonCreator.CreateJson(_components);
        }
        
        public void CacheJson()
        {
            _cachedJson = ToJson();
        }
        #endregion
        
        #region Add UI
        public void AddUi(BasePlayer player)
        {
            AddUi(player.Connection);
        }
        
        public void AddUiCached(BasePlayer player)
        {
            AddUiCached(player.Connection);
        }
        
        public void AddUi(Connection connection)
        {
            AddUi(connection, ToJson());
        }
        
        public void AddUiCached(Connection connection)
        {
            AddUi(connection, _cachedJson);
        }
        
        public void AddUi(List<Connection> connections)
        {
            AddUi(connections, ToJson());
        }
        
        public void AddUiCached(List<Connection> connections)
        {
            AddUi(connections, _cachedJson);
        }
        
        public void AddUi()
        {
            AddUi(ToJson());
        }
        
        public void AddUiCached()
        {
            AddUi(_cachedJson);
        }
        
        public static void AddUi(BasePlayer player, string json)
        {
            AddUi(player.Connection, json);
        }
        
        public static void AddUi(string json)
        {
            AddUi(Net.sv.connections, json);
        }
        
        public static void AddUi(Connection connection, string json)
        {
            CommunityEntity.ServerInstance.ClientRPCEx(new SendInfo(connection), null, Constants.RpcFunctions.AddUiFunc, json);
        }
        
        public static void AddUi(List<Connection> connections, string json)
        {
            CommunityEntity.ServerInstance.ClientRPCEx(new SendInfo(connections), null, Constants.RpcFunctions.AddUiFunc, json);
        }
        #endregion
        
        #region Destroy Ui
        public void DestroyUi(BasePlayer player)
        {
            DestroyUi(player, Root.Name);
        }
        
        public void DestroyUi(Connection connection)
        {
            DestroyUi(connection, Root.Name);
        }
        
        public void DestroyUi(List<Connection> connections)
        {
            DestroyUi(connections, Root.Name);
        }
        
        public void DestroyUi()
        {
            DestroyUi(Root.Name);
        }
        
        public void DestroyUiImages(BasePlayer player)
        {
            DestroyUiImages(player.Connection);
        }
        
        public void DestroyUiImages()
        {
            DestroyUiImages(Net.sv.connections);
        }
        
        public void DestroyUiImages(Connection connection)
        {
            for (int index = _components.Count - 1; index >= 0; index--)
            {
                BaseUiComponent component = _components[index];
                if (component is UiImage)
                {
                    DestroyUi(connection, component.Name);
                }
            }
        }
        
        public void DestroyUiImages(List<Connection> connections)
        {
            for (int index = _components.Count - 1; index >= 0; index--)
            {
                BaseUiComponent component = _components[index];
                if (component is UiImage)
                {
                    DestroyUi(connections, component.Name);
                }
            }
        }
        
        public static void DestroyUi(BasePlayer player, string name)
        {
            DestroyUi(player.Connection, name);
        }
        
        public static void DestroyUi(string name)
        {
            DestroyUi(Net.sv.connections, name);
        }
        
        public static void DestroyUi(Connection connection, string name)
        {
            CommunityEntity.ServerInstance.ClientRPCEx(new SendInfo(connection), null, Constants.RpcFunctions.DestroyUiFunc, name);
        }
        
        public static void DestroyUi(List<Connection> connections, string name)
        {
            CommunityEntity.ServerInstance.ClientRPCEx(new SendInfo(connections), null, Constants.RpcFunctions.DestroyUiFunc, name);
        }
        #endregion
    }
    #endregion

    #region Colors\UiColor.cs
    public class UiColor
    {
        public string Color { get; private set; }
        public int Value { get; private set; }
        
        /// <summary>
        /// Checks for format "0.0 0.0 0.0 0.0"
        /// Any permutation of normal rust color string will work
        /// </summary>
        private static readonly Regex _rustColorFormat = new Regex("\\d*.?\\d* \\d*.?\\d* \\d*.?\\d* \\d*.?\\d*", RegexOptions.Compiled | RegexOptions.ECMAScript);
        
        /// <summary>
        /// Valid Hex Color Formats
        /// #RGB
        /// #RRGGBB
        /// #RGBA
        /// #RRGGBBAA
        /// </summary>
        /// <param name="color"></param>
        public UiColor(string color)
        {
            Color colorValue;
            if (_rustColorFormat.IsMatch(color))
            {
                colorValue = ColorEx.Parse(color);
            }
            else
            {
                if (!color.StartsWith("#"))
                {
                    color = "#" + color;
                }
                
                ColorUtility.TryParseHtmlString(color, out colorValue);
            }
            
            SetValue(colorValue);
        }
        
        public UiColor(Color color)
        {
            SetValue(color);
        }
        
        public UiColor(string hexColor, int alpha = 255) : this(hexColor, alpha / 255f)
        {
            
        }
        
        public UiColor(string hexColor, float alpha = 1f)
        {
            if (!hexColor.StartsWith("#"))
            {
                hexColor = "#" + hexColor;
            }
            
            alpha = Mathf.Clamp01(alpha);
            Color colorValue;
            ColorUtility.TryParseHtmlString(hexColor, out colorValue);
            colorValue.a = alpha;
            SetValue(colorValue);
        }
        
        public UiColor(int red, int green, int blue, int alpha = 255) : this(red / 255f, green / 255f, blue / 255f, alpha / 255f)
        {
            
        }
        
        public UiColor(float red, float green, float blue, float alpha = 1f)
        {
            red = Mathf.Clamp01(red);
            green = Mathf.Clamp01(green);
            blue = Mathf.Clamp01(blue);
            alpha = Mathf.Clamp01(alpha);
            
            SetValue(red, green, blue, alpha);
        }
        
        public UiColor WithAlpha(string hex)
        {
            return WithAlpha(int.Parse(hex, System.Globalization.NumberStyles.HexNumber));
        }
        
        public UiColor WithAlpha(int alpha)
        {
            return WithAlpha(alpha / 255f);
        }
        
        public UiColor WithAlpha(float alpha)
        {
            Color color = ColorEx.Parse(Color);
            color.a = Mathf.Clamp01(alpha);
            return new UiColor(color);
        }
        
        private void SetValue(Color color)
        {
            SetValue(color.r, color.g, color.b, color.a);
        }
        
        private void SetValue(float red, float green, float blue, float alpha)
        {
            Color = $"{red:0.###} {green:0.###} {blue:0.###} {alpha:0.###}";
            Value = ((int)(red * 255) << 24) + ((int)(green * 255) << 16) + ((int)(blue * 255) << 8) + (int)(alpha * 255);
        }
        
        public static implicit operator UiColor(string value) => new UiColor(value);
    }
    #endregion

    #region Colors\UiColors.cs
    public static class UiColors
    {
        public static class BootStrap
        {
            public static readonly UiColor BootStrapBlue = "#007bff";
            public static readonly UiColor BootStrapIndigo = "#6610f2";
            public static readonly UiColor BootStrapPurple = "#6f42c1";
            public static readonly UiColor BootStrapPink = "#e83e8c";
            public static readonly UiColor BootStrapRed = "#dc3545";
            public static readonly UiColor BootStrapOrange = "#fd7e14";
            public static readonly UiColor BootStrapYellow = "#ffc107";
            public static readonly UiColor BootStrapGreen = "#28a745";
            public static readonly UiColor BootStrapTeal = "#20c997";
            public static readonly UiColor BootStrapCyan = "#17a2b8";
            public static readonly UiColor BootStrapWhite = "#fff";
            public static readonly UiColor BootStrapGray = "#6c757d";
            public static readonly UiColor BootStrapDarkGray = "#343a40";
            public static readonly UiColor BootStrapPrimary = "#007bff";
            public static readonly UiColor BootStrapSecondary = "#6c757d";
            public static readonly UiColor BootStrapSuccess = "#28a745";
            public static readonly UiColor BootStrapInfo = "#17a2b8";
            public static readonly UiColor BootStrapWarning = "#ffc107";
            public static readonly UiColor BootStrapDanger = "#dc3545";
            public static readonly UiColor BootStrapLight = "#f8f9fa";
            public static readonly UiColor BootStrapDark = "#343a40";
        }
        
        public static class Material
        {
            public static readonly UiColor MatPrimary = "#dfe6e9";
            public static readonly UiColor MatPrimaryLight = "#b2bec3";
            public static readonly UiColor MatPrimaryDark = "#636e72";
            public static readonly UiColor MatSecondary = "#2d3436";
            public static readonly UiColor MatSecondaryLight = "#74b9ff";
            public static readonly UiColor MatSecondaryDark = "#0984e3";
            public static readonly UiColor MatTextOnPrimary = "#0984e3";
            public static readonly UiColor MatTextOnSecondary = "#0984e3";
        }
        
        public static class StandardColors
        {
            public static readonly UiColor White = "#FFFFFF";
            public static readonly UiColor Silver = "#C0C0C0";
            public static readonly UiColor Gray = "#808080";
            public static readonly UiColor Black = "#000000";
            public static readonly UiColor Red = "#FF0000";
            public static readonly UiColor Maroon = "#800000";
            public static readonly UiColor Yellow = "#FFFF00";
            public static readonly UiColor Olive = "#808000";
            public static readonly UiColor Lime = "#00FF00";
            public static readonly UiColor Green = "#008000";
            public static readonly UiColor Aqua = "#00FFFF";
            public static readonly UiColor Teal = "#008080";
            public static readonly UiColor Blue = "#0000FF";
            public static readonly UiColor Navy = "#000080";
            public static readonly UiColor Fuchsia = "#FF00FF";
            public static readonly UiColor Purple = "#800080";
        }
        
        public static class Supreme
        {
            public static readonly UiColor Lime = "#acfa58";
            public static readonly UiColor SilverText = "#e3e3e3";
            public static readonly UiColor K1lly0usRed = "#ce422b";
        }
        
        public static class MJSU
        {
            public static readonly UiColor Orange = "#de8732";
        }
        
        public static class Rust
        {
            public static readonly UiColor Red = "#cd4632";
            public static readonly UiColor Green = "#8cc83c";
            public static readonly UiColor Panel = "#CCCCCC";
            
            public static class Ui
            {
                public static readonly UiColor Panel = "#A6A6A60F";
                public static readonly UiColor Header = "#DBDBDB33";
                public static readonly UiColor PanelButton = "#A6A6A60F";
                public static readonly UiColor OkButton = "#6A804266";
                public static readonly UiColor Button = "#BFBFBF1A";
                public static readonly UiColor PanelText = "#E8dED4";
                public static readonly UiColor PanelButtonText = "#C4C4C4";
                public static readonly UiColor OkButtonText = "#9BB46E";
                public static readonly UiColor ButtonText = "#E8DED4CC";
            }
            
            public static class Chat
            {
                public static readonly UiColor Player = "#55AAFF";
                public static readonly UiColor Developer = "#FFAA55";
                public static readonly UiColor Admin = "#AAFF55";
            }
        }
        
        public static class Form
        {
            public static readonly UiColor Body = "#00001F";
            public static readonly UiColor Header = "#00001F";
            public static readonly UiColor Text = StandardColors.White;
            public static readonly UiColor Panel = "#2B2B2B";
            public static readonly UiColor PanelSecondary = "#3f3f3f";
            public static readonly UiColor PanelTertiary = "#525252";
            public static readonly UiColor ButtonPrimary = Rust.Red;
            public static readonly UiColor ButtonSecondary = "#666666";
        }
        
        #region UI Colors
        public static readonly UiColor Clear = StandardColors.Black.WithAlpha(0f);
        public static readonly UiColor White = StandardColors.White;
        public static readonly UiColor Black = StandardColors.Black;
        public static readonly UiColor Body = Form.Body.WithAlpha("B2");
        public static readonly UiColor BodyHeader = Form.Header;
        public static readonly UiColor Text = Form.Text.WithAlpha("80");
        public static readonly UiColor Panel = Form.Panel;
        public static readonly UiColor PanelSecondary = Form.PanelSecondary;
        public static readonly UiColor PanelTertiary = Form.PanelTertiary;
        public static readonly UiColor CloseButton = Form.ButtonPrimary;
        public static readonly UiColor ButtonPrimary = Form.ButtonPrimary;
        public static readonly UiColor ButtonSecondary = Form.ButtonSecondary;
        public static readonly UiColor RustRed = Rust.Red;
        public static readonly UiColor RustGreen = Rust.Green;
        #endregion
    }
    #endregion

    #region Components\BaseComponent.cs
    public class BaseComponent : Pool.IPooled
    {
        public UiColor Color;
        
        public virtual void EnterPool()
        {
            Color = null;
        }
        
        public virtual void LeavePool()
        {
        }
    }
    #endregion

    #region Components\BaseTextComponent.cs
    public class BaseTextComponent : BaseComponent
    {
        public int FontSize = 14;
        public string Font;
        public TextAnchor Align;
        
        public override void EnterPool()
        {
            base.EnterPool();
            FontSize = 14;
            Font = null;
            Align = TextAnchor.UpperLeft;
        }
    }
    #endregion

    #region Components\ButtonComponent.cs
    public class ButtonComponent : BaseComponent
    {
        public static string Type = "UnityEngine.UI.Button";
        
        public string Command;
        public string Close;
        public string Sprite;
        public string Material;
        
        public override void EnterPool()
        {
            base.EnterPool();
            Command = null;
            Close = null;
            Sprite = null;
            Material = null;
        }
    }
    #endregion

    #region Components\ImageComponent.cs
    public class ImageComponent : BaseComponent
    {
        public static string Type = "UnityEngine.UI.Image";
        
        public string Sprite;
        public string Material;
        public string Png;
        
        public override void EnterPool()
        {
            base.EnterPool();
            Sprite = null;
            Material = null;
            Png = null;
        }
    }
    #endregion

    #region Components\InputComponent.cs
    public class InputComponent : BaseTextComponent
    {
        public static string Type = "UnityEngine.UI.InputField";
        
        public int CharsLimit;
        public string Command;
        public bool IsPassword;
        
        public override void EnterPool()
        {
            base.EnterPool();
            CharsLimit = 0;
            Command = null;
            IsPassword = false;
        }
    }
    #endregion

    #region Components\OutlineComponent.cs
    public class OutlineComponent : BaseComponent
    {
        public static string Type = "UnityEngine.UI.Outline";
        
        public string Distance;
        public bool UseGraphicAlpha;
        
        public override void EnterPool()
        {
            base.EnterPool();
            Distance = null;
            UseGraphicAlpha = false;
        }
    }
    #endregion

    #region Components\RawImageComponent.cs
    public class RawImageComponent : BaseComponent
    {
        public static string Type = "UnityEngine.UI.RawImage";
        
        public string Sprite;
        public string Url;
        public string Png;
        
        public override void EnterPool()
        {
            base.EnterPool();
            Sprite = null;
            Url = null;
            Png = null;
        }
    }
    #endregion

    #region Components\TextComponent.cs
    public class TextComponent : BaseTextComponent
    {
        public static string Type = "UnityEngine.UI.Text";
        
        public string Text;
        
        public override void EnterPool()
        {
            base.EnterPool();
            Text = null;
        }
    }
    #endregion

    #region Enums\BorderMode.cs
    [Flags]
    public enum BorderMode : byte
    {
        Top = 1 << 0,
        Left = 1 << 1,
        Bottom = 1 << 2,
        Right = 1 << 3,
    }
    #endregion

    #region Enums\UiFont.cs
    public enum UiFont : byte
    {
        /// <summary>
        /// droidsansmono.ttf
        /// </summary>
        DroidSansMono,
        
        /// <summary>
        /// permanentmarker.ttf
        /// </summary>
        PermanentMarker,
        
        /// <summary>
        /// robotocondensed-bold.ttf
        /// </summary>
        RobotoCondensedBold,
        
        /// <summary>
        /// robotocondensed-regular.ttf
        /// </summary>
        RobotoCondensedRegular
    }
    #endregion

    #region Enums\UiLayer.cs
    public enum UiLayer
    {
        Overall,
        Overlay,
        Hud,
        HudMenu,
        Under,
    }
    #endregion

    #region Json\JsonCreator.cs
    public static class JsonCreator
    {
        private static readonly StringBuilder _sb = new StringBuilder();
        
        public static string CreateJson(List<BaseUiComponent> components)
        {
            StringWriter sw = new StringWriter();
            JsonTextWriter writer = new JsonTextWriter(sw);
            
            writer.WriteStartArray();
            
            for (int index = 0; index < components.Count; index++)
            {
                BaseUiComponent component = components[index];
                writer.WriteStartObject();
                AddFieldRaw(writer, JsonDefaults.ComponentName, component.Name);
                AddFieldRaw(writer, JsonDefaults.ParentName, component.Parent);
                AddField(writer, JsonDefaults.FadeInName, ref component.FadeIn, ref JsonDefaults.FadeoutValue);
                AddField(writer, JsonDefaults.FadeoutName, ref component.FadeOut, ref JsonDefaults.FadeoutValue);
                
                writer.WritePropertyName("components");
                writer.WriteStartArray();
                component.WriteComponents(writer);
                writer.WriteEndArray();
                writer.WriteEndObject();
            }
            
            writer.WriteEndArray();
            
            return sw.ToString();
        }
        
        public static void AddFieldRaw(JsonTextWriter writer, string name, string value)
        {
            writer.WritePropertyName(name);
            writer.WriteValue(value);
        }
        
        public static void AddField(JsonTextWriter writer, string name, string value, string defaultValue)
        {
            if (value != null && value != defaultValue)
            {
                writer.WritePropertyName(name);
                writer.WriteValue(value);
            }
        }
        
        public static void AddTextField(JsonTextWriter writer, string name, string value, string defaultValue)
        {
            if (value != null && value != defaultValue)
            {
                writer.WritePropertyName(name);
                _sb.Clear();
                _sb.Append(Constants.Json.QuoteChar);
                _sb.Append(value);
                _sb.Append(Constants.Json.QuoteChar);
                writer.WriteRawValue(_sb.ToString());
            }
        }
        
        public static void AddMultiField(JsonTextWriter writer, string name, string value, string[] defaultValues)
        {
            if (value != null && !defaultValues.Contains(value))
            {
                writer.WritePropertyName(name);
                writer.WriteValue(value);
            }
        }
        
        public static void AddField(JsonTextWriter writer, string name, ref int value, ref int defaultValue)
        {
            if (value != defaultValue)
            {
                writer.WritePropertyName(name);
                writer.WriteValue(value);
            }
        }
        
        public static void AddField(JsonTextWriter writer, string name, ref float value, ref float defaultValue)
        {
            if (value != defaultValue)
            {
                writer.WritePropertyName(name);
                writer.WriteValue(value);
            }
        }
        
        public static void AddField(JsonTextWriter writer, string name, UiColor value, UiColor defaultValue)
        {
            if (value.Value != defaultValue.Value)
            {
                writer.WritePropertyName(name);
                writer.WriteValue(value.Color);
            }
        }
        
        public static void Add(JsonTextWriter writer, ref Position position, ref Offset? offset)
        {
            writer.WriteStartObject();
            AddFieldRaw(writer, JsonDefaults.ComponentTypeName, JsonDefaults.RectTransformName);
            AddMultiField(writer, JsonDefaults.AnchorMinName, position.Min, JsonDefaults.DefaultMinValues);
            AddMultiField(writer, JsonDefaults.AnchorMaxName, position.Max, JsonDefaults.DefaultMaxValues);
            
            if (offset.HasValue)
            {
                string min = offset.Value.Min;
                string max = offset.Value.Max;
                AddMultiField(writer, JsonDefaults.OffsetMinName, min, JsonDefaults.DefaultMinValues);
                AddMultiField(writer, JsonDefaults.OffsetMaxName, max, JsonDefaults.DefaultMaxValues);
            }
            else
            {
                //Fixes issue with UI going outside of bounds
                AddFieldRaw(writer, JsonDefaults.OffsetMaxName, JsonDefaults.OffsetMaxValue);
            }
            
            writer.WriteEndObject();
        }
        
        public static void Add(JsonTextWriter writer, ButtonComponent button)
        {
            writer.WriteStartObject();
            AddFieldRaw(writer, JsonDefaults.ComponentTypeName, ButtonComponent.Type);
            AddField(writer, JsonDefaults.CommandName, button.Command, JsonDefaults.NullValue);
            AddField(writer, JsonDefaults.CloseName, button.Close, JsonDefaults.NullValue);
            AddField(writer, JsonDefaults.ColorName, button.Color, JsonDefaults.ColorValue);
            AddField(writer, JsonDefaults.SpriteName, button.Sprite, JsonDefaults.SpriteValue);
            writer.WriteEndObject();
        }
        
        public static void Add(JsonTextWriter writer, TextComponent textComponent)
        {
            writer.WriteStartObject();
            AddFieldRaw(writer, JsonDefaults.ComponentTypeName, TextComponent.Type);
            AddTextField(writer, JsonDefaults.TextName, textComponent.Text, JsonDefaults.TextValue);
            AddField(writer, JsonDefaults.FontSizeName, ref textComponent.FontSize, ref JsonDefaults.FontSizeValue);
            AddField(writer, JsonDefaults.FontName, textComponent.Font, JsonDefaults.FontValue);
            AddField(writer, JsonDefaults.ColorName, textComponent.Color, JsonDefaults.ColorValue);
            string align = textComponent.Align.ToString();
            AddField(writer, JsonDefaults.AlignName, align, JsonDefaults.AlignValue);
            writer.WriteEndObject();
        }
        
        public static void Add(JsonTextWriter writer, RawImageComponent image)
        {
            writer.WriteStartObject();
            AddFieldRaw(writer, JsonDefaults.ComponentTypeName, RawImageComponent.Type);
            AddField(writer, JsonDefaults.ColorName, image.Color, JsonDefaults.ColorValue);
            AddField(writer, JsonDefaults.SpriteName, image.Sprite, JsonDefaults.SpriteImageValue);
            if (!string.IsNullOrEmpty(image.Png))
            {
                AddField(writer, JsonDefaults.PNGName, image.Png, JsonDefaults.EmptyString);
            }
            
            if (!string.IsNullOrEmpty(image.Url))
            {
                AddField(writer, JsonDefaults.URLName, image.Url, JsonDefaults.EmptyString);
            }
            
            writer.WriteEndObject();
        }
        
        public static void Add(JsonTextWriter writer, ImageComponent image)
        {
            writer.WriteStartObject();
            AddFieldRaw(writer, JsonDefaults.ComponentTypeName, ImageComponent.Type);
            AddField(writer, JsonDefaults.ColorName, image.Color, JsonDefaults.ColorValue);
            AddField(writer, JsonDefaults.SpriteName, image.Sprite, JsonDefaults.SpriteValue);
            AddField(writer, JsonDefaults.MaterialName, image.Material, JsonDefaults.MaterialValue);
            writer.WriteEndObject();
        }
        
        public static void AddCursor(JsonTextWriter writer)
        {
            writer.WriteStartObject();
            AddFieldRaw(writer, JsonDefaults.ComponentTypeName, JsonDefaults.NeedsCursorValue);
            writer.WriteEndObject();
        }
        
        public static void Add(JsonTextWriter writer, OutlineComponent outline)
        {
            writer.WriteStartObject();
            AddFieldRaw(writer, JsonDefaults.ComponentTypeName, OutlineComponent.Type);
            AddField(writer, JsonDefaults.ColorName, outline.Color, JsonDefaults.ColorValue);
            AddField(writer, JsonDefaults.DistanceName, outline.Distance, JsonDefaults.DistanceValue);
            if (outline.UseGraphicAlpha)
            {
                AddFieldRaw(writer, JsonDefaults.UseGraphicAlphaName, JsonDefaults.UseGraphicAlphaValue);
            }
            
            writer.WriteEndObject();
        }
        
        public static void Add(JsonTextWriter writer, InputComponent input)
        {
            writer.WriteStartObject();
            AddFieldRaw(writer, JsonDefaults.ComponentTypeName, InputComponent.Type);
            AddField(writer, JsonDefaults.FontSizeName, ref input.FontSize, ref JsonDefaults.FontSizeValue);
            AddField(writer, JsonDefaults.FontName, input.Font, JsonDefaults.FontValue);
            string align = input.Align.ToString();
            AddField(writer, JsonDefaults.AlignName, align, JsonDefaults.AlignValue);
            AddField(writer, JsonDefaults.ColorName, input.Color, JsonDefaults.ColorValue);
            AddField(writer, JsonDefaults.CharacterLimitName, ref input.CharsLimit, ref JsonDefaults.CharacterLimitValue);
            AddField(writer, JsonDefaults.CommandName, input.Command, JsonDefaults.NullValue);
            
            if (input.IsPassword)
            {
                AddFieldRaw(writer, JsonDefaults.PasswordName, JsonDefaults.PasswordValue);
            }
            
            writer.WriteEndObject();
        }
    }
    #endregion

    #region Json\JsonDefaults.cs
    public class JsonDefaults
    {
        //Position & Offset
        private const string DefaultMin = "0.0 0.0";
        private const string DefaultMax = "1.0 1.0";
        public static readonly string RectTransformName = "RectTransform";
        public static readonly string AnchorMinName = "anchormin";
        public static readonly string AnchorMaxName = "anchormax";
        public static readonly string OffsetMinName = "offsetmin";
        public static readonly string OffsetMaxName = "offsetmax";
        public static readonly string[] DefaultMinValues = { DefaultMin, "0 0" };
        public static readonly string[] DefaultMaxValues = { DefaultMax, "1 1" };
        public static readonly string OffsetMaxValue = "0 0";
        
        //Text
        public static readonly string AlignValue = "UpperLeft";
        public static int FontSizeValue = 14;
        public static readonly string FontValue = "RobotoCondensed-Bold.ttf";
        public static readonly string FontName = "font";
        public static readonly string TextName = "text";
        public static readonly string TextValue = "Text";
        public static readonly string FontSizeName = "fontSize";
        public static readonly string AlignName = "align";
        
        //Material & Sprite
        public static readonly string SpriteName = "sprite";
        public static readonly string MaterialName = "material";
        public static readonly string SpriteValue = "Assets/Content/UI/UI.Background.Tile.psd";
        public static readonly string SpriteImageValue = "Assets/Icons/rust.png";
        public static readonly string MaterialValue = "Assets/Icons/IconMaterial.mat";
        
        //Common
        public static readonly string ComponentTypeName = "type";
        public static readonly string ColorName = "color";
        public static readonly string NullValue = null;
        public static readonly string EmptyString = "";
        public static readonly string ComponentName = "name";
        public static readonly string ParentName = "parent";
        public static readonly string FadeInName = "fadeIn";
        public static readonly string FadeoutName = "fadeOut";
        public static float FadeoutValue;
        public static readonly UiColor ColorValue = "1 1 1 1";
        
        //Outline
        public static readonly string DistanceName = "distance";
        public static readonly string UseGraphicAlphaName = "useGraphicAlpha";
        public static readonly string UseGraphicAlphaValue = "True";
        public static readonly string DistanceValue = "1.0 -1.0";
        
        //Button
        public static readonly string CommandName = "command";
        public static readonly string CloseName = "close";
        
        //Needs Cursor
        public static readonly string NeedsCursorValue = "NeedsCursor";
        
        //Image
        public static readonly string PNGName = "png";
        public static readonly string URLName = "url";
        
        //Input
        public static readonly string CharacterLimitName = "characterLimit";
        public static int CharacterLimitValue;
        public static readonly string PasswordName = "password";
        public static readonly string PasswordValue = "true";
    }
    #endregion

    #region Positions\GridPosition.cs
    public class GridPosition : MovablePosition
    {
        public float NumCols { get; }
        public float NumRows { get; }
        private int _xSize = 1;
        private int _xOffset;
        private int _ySize = 1;
        private int _yOffset;
        private float _xPad;
        private float _yPad;
        
        public GridPosition(int size) : this(size, size)
        {
        }
        
        public GridPosition(int numCols, int numRows)
        {
            NumCols = numCols;
            NumRows = numRows;
        }
        
        public GridPosition SetRowLength(int size, int offset = 0)
        {
            _xSize = size;
            _xOffset = offset;
            return this;
        }
        
        public new GridPosition SetX(float xMin, float xMax)
        {
            XMin = xMin;
            XMax = xMax;
            return this;
        }
        
        public GridPosition SetColLength(int size, int offset = 0)
        {
            _ySize = size;
            _yOffset = offset;
            return this;
        }
        
        public new GridPosition SetY(float yMin, float yMax)
        {
            YMin = yMin;
            YMax = yMax;
            return this;
        }
        
        public GridPosition SetPadding(float padding)
        {
            _xPad = padding;
            _yPad = padding;
            return this;
        }
        
        public GridPosition SetPadding(float xPad, float yPad)
        {
            _xPad = xPad;
            _yPad = yPad;
            return this;
        }
        
        public GridPosition SetRowPadding(float padding)
        {
            _xPad = padding;
            return this;
        }
        
        public GridPosition SetColPadding(float padding)
        {
            _yPad = padding;
            return this;
        }
        
        public void MoveCols(int cols)
        {
            XMin += cols / NumCols;
            XMax += cols / NumCols;
            
            if (XMax > 1)
            {
                XMin -= 1;
                XMax -= 1;
// ... [Code preview truncated due to length. Full source in attached file] ...