FREE UiFramework : 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;

//UiFramework created with PluginMerge v(1.0.0.0) by MJSU
namespace Oxide.Plugins
{
    //[Info("Rust UI Framework", "MJSU", "1.1.0")]
    //[Description("UI Framework for Rust")]
    public partial class UiFramework : 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";
            publi
// ... [Code preview truncated due to length. Full source in attached file] ...