Removed modded handshake unpatch

Stopped objects appearing when opening language selection menu

Removed unused code

Improved custom button class

.idea/.idea.Unify/.idea/indexLayout.xml

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
-  <component name="ContentModelUserStore">
+  <component name="UserContentModel">
     <attachedFolders />
     <explicitIncludes />
     <explicitExcludes />

README.md

@@ -1,8 +1,9 @@
-# Unify
+# Unify
 
-An Among Us mod to add extra regions to the regions menu.
+An Among Us mod to add extra regions to the region menu.
 
-![Regions menu](images/RegionsMenu.jpg)
+![Region menu](images/RegionsMenu.png)
+![Region menu editor](images/RegionsMenuEditor.png)
 
 # Table of Contents
 - [Features](#features)
@@ -14,16 +15,33 @@ An Among Us mod to add extra regions to the regions menu.
 The following regions have been added:
 - [skeld.net](https://skeld.net/)
 - localhost *(for playing on a server running on your computer)*
+- matux.fr
+- Przebot (may be unreliable or outdated)
+
+Regions can be connected to directly using an IP address.
+
+Custom regions can be added as detailed below in the
+[configuration](#configuration) section.
+
+Other mods can add regions via the
+`AddRegion(string name, string ip, ushort port)` API method.
 
 ## Installation
 
 > **⚠ WARNING**
 >
-> This mod requires you to have BepInEx and Reactor installed. You can install BepInEx and Reactor by following [this guide](INSTALLATION.md) or by following the steps on the
-> following two pages: https://docs.reactor.gg/docs/basic/install_bepinex and https://docs.reactor.gg/docs/basic/install_reactor.
+> This mod only has compiled releases for the steam release of the game.
 
-1. Ensure that BepInEx and Reactor are installed (more information above).
-2. Download the latest mod on the [releases](https://github.com/DaemonBeast/Unify/releases) page.
+> If you are still using 2020.12.9s and Reactor fails to load, try using the Reactor version located
+> here: https://github.com/NuclearPowered/Reactor/actions/runs/593649307.
+
+> If you are still using 2021.3.5s and Reactor fails to load, try using the Reactor version located
+> here: https://github.com/NuclearPowered/Reactor/actions/runs/636023321.
+
+1. Ensure that BepInEx and Reactor (Reactor is not required for pre releases) are installed
+   ([installation guide](INSTALLATION.md)).
+2. Download the latest mod on the [releases](https://github.com/DaemonBeast/Unify/releases) page
+   for the version of Among Us you are using.
 3. Move the mod to the `(Among Us game files)/BepInEx/plugins` folder.
 4. Launch the game.
 
@@ -37,13 +55,13 @@ The following regions have been added:
 > file creates itself.
 
 The configuration file is located at
-`(Among Us game files)/BepInEx/config/daemon.unify.reactor.cfg`.
+`(Among Us game files)/BepInEx/config/daemon.unify.cfg`.
 
 ### Custom regions
 
 Custom regions can be added by modifying the `[Region 1]`,
-`[Region 2]` ... `[Region 5]` sections of the configuration file.
-The sections allow you to modify the display name of the region,
-the IP address of the region, and the port of the region.
+`[Region 2]` ... `[Region 9]` sections of the configuration file.
+You can modify the display name of the region,
+the IP address of the region and the port of the region.
 
 If the IP field is left empty, the region will not show up in game.

Unify/Controls/Button.cs

@@ -0,0 +1,125 @@
+using System;
+using System.Threading.Tasks;
+using Reactor.Extensions;
+using TMPro;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+using Object = UnityEngine.Object;
+
+namespace Unify.Controls
+{
+    public class Button
+    {
+        private static readonly TaskCompletionSource<bool> Initialized = new TaskCompletionSource<bool>();
+        private static GameObject _instance;
+        
+        private readonly SpriteRenderer _spriteRenderer;
+        private readonly BoxCollider2D _boxCollider2D;
+
+        public GameObject GameObject { get; }
+        public TextMeshPro Text { get; }
+        public Vector2 Size
+        {
+            get => _spriteRenderer.size;
+            set
+            {
+                Text.rectTransform.sizeDelta = value;
+                _spriteRenderer.size = value;
+                _boxCollider2D.size = value;
+            }
+        }
+        public AspectPosition Position { get; }
+        public UnityEngine.UI.Button.ButtonClickedEvent OnClick { get; }
+
+        private Button(string text)
+        {
+            GameObject = Object.Instantiate(_instance).DontDestroy();
+
+            Text = GameObject.GetComponentInChildren<TextMeshPro>();
+            Position = GameObject.GetComponent<AspectPosition>();
+            OnClick = GameObject.GetComponent<PassiveButton>().OnClick;
+            _spriteRenderer = GameObject.GetComponent<SpriteRenderer>();
+            _boxCollider2D = GameObject.GetComponent<BoxCollider2D>();
+            
+            var size = new Vector2(Text.preferredWidth, Text.preferredHeight);
+
+            Text.text = text;
+            Text.rectTransform.sizeDelta = size;
+            Position.DistanceFromEdge =
+                new Vector3(Text.preferredWidth / 2f + 0.1f, Text.preferredHeight / 2f + 0.1f, -100f);
+            _spriteRenderer.size = size;
+            _boxCollider2D.size = size;
+        }
+
+        public static async Task<Button> Create(string text)
+        {
+            await Initialized.Task;
+
+            return new Button(text);
+        }
+
+        public Button SetText(string newText)
+        {
+            Text.text = newText;
+            return this;
+        }
+
+        public Button SetSize(Vector2 newSize)
+        {
+            Size = newSize;
+            return this;
+        }
+
+        public Button SetDistanceFromEdge(Vector2 newPosition)
+        {
+            Position.DistanceFromEdge = new Vector3(newPosition.x, newPosition.y, -100f);
+            return this;
+        }
+
+        public Button SetAlignment(AspectPosition.EdgeAlignments newAlignment)
+        {
+            Position.Alignment = newAlignment;
+            return this;
+        }
+
+        public static void InitializeBaseButton()
+        {
+            BaseButton.Initialize();
+        }
+
+        private static class BaseButton
+        {
+            public static void Initialize()
+            {
+                SceneManager.add_sceneLoaded((Action<Scene, LoadSceneMode>) OnSceneLoaded);
+            }
+
+            private static void OnSceneLoaded(Scene scene, LoadSceneMode loadSceneMode)
+            {
+                Instantiate();
+                
+                SceneManager.remove_sceneLoaded((Action<Scene, LoadSceneMode>) OnSceneLoaded);
+            }
+
+            private static void Instantiate()
+            {
+                if (Initialized.Task.IsCompleted) return;
+                
+                var exitButton = GameObject.Find("ExitGameButton");
+                if (!exitButton) return;
+
+                _instance = Object.Instantiate(exitButton).DontDestroy();
+                _instance.SetActive(false);
+                _instance.name = "Button";
+
+                _instance.GetComponent<PassiveButton>().OnClick = new UnityEngine.UI.Button.ButtonClickedEvent();
+                _instance.GetComponent<SceneChanger>().Destroy();
+                _instance.GetComponent<ConditionalHide>().Destroy();
+                _instance.GetComponentInChildren<TextTranslatorTMP>().Destroy();
+                _instance.GetComponentInChildren<TextMeshPro>().text = "Button";
+
+                Initialized.SetResult(true);
+            }
+        }
+    }
+}

Unify/Patches/Regions.cs

@@ -1,65 +1,329 @@
 using System;
 using System.Collections.Generic;
+using System.Threading.Tasks;
 using BepInEx.Configuration;
 using HarmonyLib;
+using Reactor.Extensions;
+using UnityEngine;
+using Button = UnityEngine.UI.Button;
+using Object = UnityEngine.Object;
+using String = System.String;
 
 namespace Unify.Patches
 {
-    [HarmonyPatch]
     public static class RegionsPatch
     {
+        internal static IRegionInfo[] OldRegions { get; } = ServerManager.DefaultRegions;
+
+        internal static IRegionInfo[] NewRegions { get; } = new IRegionInfo[]
+        {
+            new DnsRegionInfo("192.241.154.115", "skeld.net", StringNames.NoTranslation, "192.241.154.115", 22023)
+                .Cast<IRegionInfo>(),
+            new DnsRegionInfo("localhost", "localhost", StringNames.NoTranslation, "127.0.0.1", 22023)
+                .Cast<IRegionInfo>(),
+            new DnsRegionInfo("152.228.160.91", "matux.fr", StringNames.NoTranslation, "152.228.160.91", 22023)
+                .Cast<IRegionInfo>(),
+            new DnsRegionInfo("77.55.217.159", "Przebot", StringNames.NoTranslation, "77.55.217.159", 22023)
+                .Cast<IRegionInfo>()
+        };
+
+        internal static List<IRegionInfo> ModRegions { get; } = new List<IRegionInfo>();
+
+        public static IRegionInfo DirectRegion { get; set; }
+
+        internal static TextBoxTMP DirectConnect { get; set; }
+
         public static void Patch()
         {
-            RegionInfo[] newRegions = new RegionInfo[]
-            {
-                new RegionInfo("skeld.net", "192.241.154.115", new ServerInfo[]
-                {
-                    new ServerInfo("skeld.net-Master-1", "192.241.154.115", 22023)
-                }),
-                new RegionInfo("localhost", "127.0.0.1", new ServerInfo[]
-                {
-                    new ServerInfo("localhost-Master-1", "127.0.0.1", 22023)
-                })
-            };
-            
-            RegionInfo[] customRegions = LoadCustomRegions();
-            
-            RegionInfo[] patchedRegions = MergeRegions(ServerManager.DefaultRegions, newRegions);
-            patchedRegions = MergeRegions(patchedRegions, customRegions);
+            ServerManager serverManager = ServerManager.Instance;
+
+            IRegionInfo[] patchedRegions = OldRegions
+                .AddRangeToArray(NewRegions)
+                .AddRangeToArray(ModRegions.ToArray())
+                .AddRangeToArray(LoadCustomUserRegions());
+            if (DirectRegion != null) patchedRegions = patchedRegions.AddToArray(DirectRegion);
 
             ServerManager.DefaultRegions = patchedRegions;
+            serverManager.AvailableRegions = patchedRegions;
         }
 
-        private static RegionInfo[] MergeRegions(RegionInfo[] oldRegions, RegionInfo[] newRegions)
+        private static IRegionInfo[] LoadCustomUserRegions()
         {
-            RegionInfo[] patchedRegions = new RegionInfo[oldRegions.Length + newRegions.Length];
-            Array.Copy(oldRegions, patchedRegions, oldRegions.Length);
-            Array.Copy(newRegions, 0, patchedRegions, oldRegions.Length, newRegions.Length);
+            List<IRegionInfo> customRegions = new List<IRegionInfo>();
 
-            return patchedRegions;
-        }
-        
-        private static RegionInfo[] LoadCustomRegions()
-        {
-            List<RegionInfo> customRegions = new List<RegionInfo>();
-            
-            for (int x = 0; x < 5; x++)
+            for (int x = 0; x < 9; x++)
             {
-                ConfigEntry<string> regionName = UnifyPlugin.ConfigFile.Bind($"Region {x + 1}", $"Name", "custom region");
-                ConfigEntry<string> regionIp = UnifyPlugin.ConfigFile.Bind($"Region {x + 1}", "IP", "");
-                ConfigEntry<ushort> regionPort = UnifyPlugin.ConfigFile.Bind($"Region {x + 1}", "Port", (ushort) 22023);
-                
+                ConfigEntry<string> regionName = UnifyPlugin.ConfigFile.Bind(
+                    $"Region {x + 1}", $"Name", "custom region");
+                ConfigEntry<string> regionIp = UnifyPlugin.ConfigFile.Bind(
+                    $"Region {x + 1}", "IP", "");
+                ConfigEntry<ushort> regionPort = UnifyPlugin.ConfigFile.Bind(
+                    $"Region {x + 1}", "Port", (ushort) 22023);
+
                 if (String.IsNullOrWhiteSpace(regionIp.Value)) continue;
 
-                RegionInfo regionInfo = new RegionInfo(regionName.Value, regionIp.Value, new ServerInfo[]
-                {
-                    new ServerInfo($"{regionName.Value}-Master-1", regionIp.Value, regionPort.Value)
-                });
-                
+                IRegionInfo regionInfo = new DnsRegionInfo(
+                        regionIp.Value, regionName.Value,
+                        StringNames.NoTranslation, regionIp.Value, regionPort.Value)
+                    .Cast<IRegionInfo>();
+
                 customRegions.Add(regionInfo);
             }
 
             return customRegions.ToArray();
         }
+
+        private static void UpdateRegion()
+        {
+            RegionMenu regionMenu = DestroyableSingleton<RegionMenu>.Instance;
+
+            bool success = UnifyPlugin.SetDirectRegion(DirectConnect.text, out IRegionInfo newRegion);
+
+            if (!success)
+            {
+                DirectConnect.StartCoroutine(Effects.SwayX(DirectConnect.transform, 0.75f, 0.25f));
+                return;
+            }
+
+            regionMenu.ChooseOption(newRegion);
+            regionMenu.Close();
+        }
+
+        [HarmonyPatch(typeof(ServerManager), nameof(ServerManager.LoadServers))]
+        public static class LoadNewRegionsPatch
+        {
+            public static void Postfix()
+            {
+                Patch();
+            }
+        }
+
+        [HarmonyPatch(typeof(JoinGameButton), nameof(JoinGameButton.OnClick))]
+        public static class DirectConnectEnterButtonPatch {
+            public static bool Prefix(JoinGameButton __instance)
+            {
+                GameObject regionMenuGameObject = GameObject.Find("RegionMenu");
+                if (!regionMenuGameObject) return true;
+
+                UpdateRegion();
+
+                return false;
+            }
+        }
+
+        [HarmonyPatch(typeof(RegionMenu))]
+        public static class RegionMenuPatches
+        {
+            [HarmonyPatch(nameof(RegionMenu.Open))]
+            [HarmonyPostfix]
+            public static void DirectConnectButtonPatch()
+            {
+                RefreshDirectConnectButton();
+            }
+
+            [HarmonyPatch(nameof(RegionMenu.Open))]
+            [HarmonyPostfix]
+            public static void RegionMenuLayoutPatch()
+            {
+                RefreshRegionMenu();
+            }
+
+            internal static void RefreshRegionMenu()
+            {
+                if (!GameObject.Find("RegionMenu")) return;
+                
+                var regionButtons = DestroyableSingleton<RegionMenu>.Instance.ButtonPool.activeChildren.ToArray();
+                var defaultRegions = ServerManager.DefaultRegions;
+                var showOfficials = UnifyPlugin.ShowOfficialRegions.Value;
+                var showExtras = UnifyPlugin.ShowExtraRegions.Value;
+
+                for (int i = 0; i < regionButtons.Length; i++)
+                {
+                    ServerListButton regionButton = regionButtons[i].Cast<ServerListButton>();
+                    IRegionInfo region = defaultRegions[i];
+
+                    var textTranslatorTemp = regionButton.GetComponentInChildren<TextTranslatorTMP>();
+                    if (textTranslatorTemp) textTranslatorTemp.Destroy();
+
+                    int extraRegionCount = OldRegions.Length + NewRegions.Length + ModRegions.Count;
+                    bool isCustomRegion = i >= OldRegions.Length;
+                    bool isCustomUserRegion = i >= extraRegionCount;
+                    float x = (!isCustomRegion && !showExtras ? 3f : 0) + (isCustomRegion ? 3f : 0) +
+                        (isCustomUserRegion ? 3f : 0) - 4.25f - (!showOfficials || OldRegions.Length == 0 ? 1.5f : 0) -
+                        (!showExtras || extraRegionCount == 0 ? 1.5f : 0);
+                    float y = i - (isCustomRegion ? OldRegions.Length : 0) - 
+                              (isCustomUserRegion ? NewRegions.Length + ModRegions.Count : 0);
+
+                    var regionButtonPosition = new Vector3(1.25f + x, 2f - 0.5f * y, 0);
+                    regionButton.transform.localPosition = regionButtonPosition;
+
+                    regionButton.gameObject.SetActive(
+                        (showOfficials || i >= OldRegions.Length) &&
+                        (showExtras || !isCustomRegion || isCustomUserRegion));
+                    
+                    var buttonRolloverHandler = regionButton.GetComponent<ButtonRolloverHandler>();
+
+                    if (RegionsEditor.IsActive)
+                    {
+                        buttonRolloverHandler.OverColor =
+                            ServerManager.Instance.CurrentRegion.Name == region.Name ? Color.white : Color.black;
+                        regionButton.Text.color = Color.gray;
+                    }
+                    else
+                    {
+                        buttonRolloverHandler.OverColor = Color.green;
+                        regionButton.Text.color = Color.white;
+                    }
+
+                    if (isCustomUserRegion)
+                    {
+                        regionButton.Text.text = 
+                            RegionsEditor.IsActive ? $"{region.Name}\n{region.PingServer}   {region.Servers[0].Port}" :
+                                region.Name;
+                    }
+                }
+            }
+
+            internal static void RefreshDirectConnectButton()
+            {
+                if (!GameObject.Find("RegionMenu")) return;
+                
+                if (DirectConnect) DirectConnect.gameObject.Destroy();
+
+                RegionMenu regionMenu = DestroyableSingleton<RegionMenu>.Instance;
+                JoinGameButton joinGameButton = DestroyableSingleton<JoinGameButton>.Instance;
+
+                DirectConnect = Object.Instantiate(joinGameButton.GameIdText, regionMenu.transform);
+                DirectConnect.GetComponentInChildren<TextTranslatorTMP>().Destroy();
+                DirectConnect.GetComponent<JoinGameButton>().Destroy();
+                DirectConnect.outputText.text = "Enter IP";
+                DirectConnect.IpMode = true;
+                DirectConnect.characterLimit = 15;
+                DirectConnect.ClearOnFocus = false;
+
+                DirectConnect.OnEnter = new Button.ButtonClickedEvent();
+                DirectConnect.OnEnter.AddListener((Action) UpdateRegion);
+
+                int offset = NewRegions.Length + ModRegions.Count;
+                DirectConnect.transform.localPosition = new Vector3(0, 1f - (offset / 2f), -100f);
+            }
+        }
     }
-}
+    
+    internal static class RegionsEditor
+    {
+        private static Controls.Button _switchButton;
+        
+        private static Controls.Button _toggleOfficialsButton;
+        private static Controls.Button _toggleExtrasButton;
+
+        internal static bool IsActive;
+
+        internal static async void SetUp()
+        {
+            await SetUpSwitchButton();
+            await SetUpToggleOfficialsButton();
+            await SetUpToggleExtrasButton();
+        }
+
+        private static void SetRegionsEditorVisibility(bool visible)
+        {
+            IsActive = visible;
+            _toggleOfficialsButton.GameObject.SetActive(visible);
+            _toggleExtrasButton.GameObject.SetActive(visible);
+            
+            RegionsPatch.RegionMenuPatches.RefreshRegionMenu();
+
+            if (visible)
+            {
+                _switchButton.Text.text = "Back";
+                RegionsPatch.DirectConnect.gameObject.SetActive(false);
+            }
+            else
+            {
+                _switchButton.Text.text = "Edit";
+                RegionsPatch.RegionMenuPatches.RefreshDirectConnectButton();
+            }
+        }
+
+        private static async Task SetUpSwitchButton()
+        {
+            _switchButton = await Controls.Button.Create("Edit");
+            _switchButton.SetSize(new Vector2(0.8f, 0.4f)).SetDistanceFromEdge(new Vector2(0.5f, 0.3f));
+                
+            _switchButton.OnClick.AddListener((Action) (() =>
+            {
+                SetRegionsEditorVisibility(!IsActive);
+            }));
+        }
+
+        private static async Task SetUpToggleOfficialsButton()
+        {
+            _toggleOfficialsButton = await Controls.Button.Create("Toggle Official Regions");
+            _toggleOfficialsButton.SetSize(new Vector2(2f, 0.4f)).SetDistanceFromEdge(new Vector2(1.1f, 1.3f));
+                
+            _toggleOfficialsButton.OnClick.AddListener((Action) (() =>
+            {
+                UnifyPlugin.ShowOfficialRegions.Value = !UnifyPlugin.ShowOfficialRegions.Value;
+                RegionsPatch.RegionMenuPatches.RefreshRegionMenu();
+            }));
+        }
+
+        private static async Task SetUpToggleExtrasButton()
+        {
+            _toggleExtrasButton = await Controls.Button.Create("Toggle Extra Regions");
+            _toggleExtrasButton.SetSize(new Vector2(2f, 0.4f)).SetDistanceFromEdge(new Vector2(1.1f, 1.8f));
+                
+            _toggleExtrasButton.OnClick.AddListener((Action) (() =>
+            {
+                UnifyPlugin.ShowExtraRegions.Value = !UnifyPlugin.ShowExtraRegions.Value;
+                RegionsPatch.RegionMenuPatches.RefreshRegionMenu();
+            }));
+        }
+
+        [HarmonyPatch(typeof(RegionMenu), nameof(RegionMenu.Open))]
+        public static class OpenRegionsEditorPatch
+        {
+            public static void Postfix()
+            {
+                if (!GameObject.Find("RegionMenu")) return;
+                
+                _switchButton.GameObject.SetActive(true);
+            }
+        }
+        
+        [HarmonyPatch(typeof(RegionMenu))]
+        public static class HideRegionsEditorPatch
+        {
+            [HarmonyPatch(nameof(RegionMenu.Close))]
+            [HarmonyPostfix]
+            public static void HideOnClosePatch()
+            {
+                Hide();
+            }
+            
+            [HarmonyPatch(nameof(RegionMenu.ChooseOption))]
+            [HarmonyPrefix]
+            public static bool DisableRegionButtonsPatch()
+            {
+                if (IsActive) return false;
+                
+                Hide();
+                return true;
+            }
+
+            private static void Hide()
+            {
+                if (!RegionsPatch.DirectConnect) return;
+                
+                SetRegionsEditorVisibility(false);
+                
+                _switchButton.GameObject.SetActive(false);
+                RegionsPatch.DirectConnect.gameObject.SetActive(false);
+            }
+        }
+    }
+}
+
+// TODO:
+//  Store custom servers in a JSON file

Unify/Unify.cs

@@ -1,9 +1,14 @@
-using System.IO;
+using System;
+using System.IO;
+using System.Linq;
+using System.Text.RegularExpressions;
 using BepInEx;
 using BepInEx.Configuration;
 using BepInEx.IL2CPP;
 using HarmonyLib;
+using Hazel.Udp;
 using Reactor;
+using Unify.Controls;
 using Unify.Patches;
 
 namespace Unify
@@ -11,22 +16,79 @@ namespace Unify
     [BepInPlugin(Id, Name, Version)]
     [BepInProcess("Among Us.exe")]
     [BepInDependency(ReactorPlugin.Id)]
+    [ReactorPluginSide(PluginSide.ClientOnly)]
     public class UnifyPlugin : BasePlugin
     {
-        public const string Id = "daemon.unify.reactor";
+        public const string Id = "daemon.unify";
         private const string Name = "Unify";
-        private const string Version = "0.1.1";
-        
-        public static readonly ConfigFile ConfigFile =
-            new ConfigFile(Path.Combine(Paths.ConfigPath, $"{UnifyPlugin.Id}.cfg"), true);
+        private const string Version = "5.0.0";
+
+        public static ConfigFile ConfigFile { get; private set; }
+
+        internal static ConfigEntry<bool> ShowOfficialRegions;
+        internal static ConfigEntry<bool> ShowExtraRegions;
 
         public Harmony Harmony { get; } = new Harmony(Id);
 
         public override void Load()
         {
-            RegionsPatch.Patch();
+            FixCompatibility();
             
+            ShowOfficialRegions = ConfigFile.Bind("Preferences", "Show Official Regions", true, 
+                "If the official regions should be shown when displaying the regions menu");
+            ShowExtraRegions = ConfigFile.Bind("Preferences", "Show Extra Regions", true,
+                "If the extra regions added by default in Unify should be shown when displaying the regions menu");
+
             Harmony.PatchAll();
+            
+            Button.InitializeBaseButton();
+            RegionsEditor.SetUp();
+        }
+
+        public static IRegionInfo AddRegion(string name, string ip, ushort port)
+        {
+            if (Uri.CheckHostName(ip) != UriHostNameType.IPv4) return ServerManager.Instance.CurrentRegion;
+
+            IRegionInfo existingRegion =
+                ServerManager.DefaultRegions.ToArray().FirstOrDefault(region => region.PingServer == ip);
+            if (existingRegion != null) return existingRegion;
+            
+            IRegionInfo newRegion = new DnsRegionInfo(ip, name, StringNames.NoTranslation, ip, port)
+                .Cast<IRegionInfo>();
+            
+            RegionsPatch.ModRegions.Add(newRegion);
+            RegionsPatch.Patch();
+
+            return newRegion;
+        }
+
+        public static bool SetDirectRegion(string ip, out IRegionInfo newRegion)
+        {
+            newRegion = null;
+            
+            if (!Regex.IsMatch(ip, @"^(\d{1,3}\.){3}\d{1,3}$")) return false;
+            
+            newRegion = new DnsRegionInfo(ip, ip, StringNames.NoTranslation, ip, 22023)
+                .Cast<IRegionInfo>();
+
+            RegionsPatch.DirectRegion = newRegion;
+            RegionsPatch.Patch();
+
+            return true;
+        }
+
+        private static void FixCompatibility()
+        {
+            string oldConfigPath = Path.Combine(Paths.ConfigPath, "daemon.unify.reactor.cfg");
+            string newConfigPath = Path.Combine(Paths.ConfigPath, $"{UnifyPlugin.Id}.cfg");
+            bool oldConfigExists = File.Exists(oldConfigPath);
+            if (oldConfigExists)
+            {
+                File.Copy(oldConfigPath, newConfigPath, true);
+                File.Delete(oldConfigPath);
+            }
+
+            ConfigFile = new ConfigFile(Path.Combine(Paths.ConfigPath, $"{UnifyPlugin.Id}.cfg"), true);
         }
     }
 }

Unify/Unify.csproj

@@ -1,29 +1,34 @@
 <Project Sdk="Microsoft.NET.Sdk">
     <PropertyGroup>
         <TargetFramework>netstandard2.1</TargetFramework>
-        <Version>0.1.1</Version>
-        <Mappings>NuclearPowered/Mappings:0.1.2</Mappings>
+        <Version>5.0.1</Version>
+        <Mappings>DaemonBeast/Mappings:0.6.0</Mappings>
 
-        <Description>Region mod for Reactor</Description>
+        <Description>Region mod</Description>
         <Authors>Daemon</Authors>
     </PropertyGroup>
 
     <PropertyGroup Condition="'$(GamePlatform)' == 'Steam'">
-        <GameVersion>2020.12.9s</GameVersion>
+        <GameVersion>2021.5.25s</GameVersion>
         <DefineConstants>$(DefineConstants);STEAM</DefineConstants>
     </PropertyGroup>
-
+  
     <PropertyGroup Condition="'$(GamePlatform)' == 'Itch'">
-        <GameVersion>2020.11.17i</GameVersion>
+        <GameVersion>2021.5.25i</GameVersion>
         <DefineConstants>$(DefineConstants);ITCH</DefineConstants>
     </PropertyGroup>
-
+  
     <ItemGroup>
         <Deobfuscate Include="$(AmongUs)\BepInEx\plugins\Reactor-$(GameVersion).dll" />
-
-        <PackageReference Include="Reactor.OxygenFilter.MSBuild" Version="0.2.5" />
     </ItemGroup>
-
+  
+    <ItemGroup>
+        <PackageReference Include="Reactor.OxygenFilter.MSBuild" Version="0.3.0">
+            <PrivateAssets>all</PrivateAssets>
+            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+        </PackageReference>
+    </ItemGroup>
+  
     <Target Name="Copy" AfterTargets="Reobfuscate">
         <Copy SourceFiles="$(OutputPath)reobfuscated/$(AssemblyName)-$(GameVersion).dll" DestinationFolder="$(AmongUs)/BepInEx/plugins/" />
         <Copy SourceFiles="$(OutputPath)reobfuscated/$(AssemblyName)-$(GameVersion).dll" DestinationFolder="../build/" />