clean up infinite researchsystem shitcode (#13136)

* clean up infinite researchsystem shitcode

* fml some more shit

* make syncing work logically

* naming naming naming

Content.Server/Research/Systems/ResearchSystem.Client.cs

@@ -1,6 +1,8 @@
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
-using Content.Server.Research.Components;
+using Content.Server.Power.EntitySystems;
 using Content.Shared.Research.Components;
+using Robust.Server.Player;
 
 namespace Content.Server.Research.Systems;
 
@@ -11,80 +13,116 @@ public sealed partial class ResearchSystem
         SubscribeLocalEvent<ResearchClientComponent, ComponentStartup>(OnClientStartup);
         SubscribeLocalEvent<ResearchClientComponent, ComponentShutdown>(OnClientShutdown);
         SubscribeLocalEvent<ResearchClientComponent, BoundUIOpenedEvent>(OnClientUIOpen);
+        SubscribeLocalEvent<ResearchClientComponent, ConsoleServerSyncMessage>(OnConsoleSync);
+        SubscribeLocalEvent<ResearchClientComponent, ConsoleServerSelectionMessage>(OnConsoleSelect);
 
         SubscribeLocalEvent<ResearchClientComponent, ResearchClientSyncMessage>(OnClientSyncMessage);
         SubscribeLocalEvent<ResearchClientComponent, ResearchClientServerSelectedMessage>(OnClientSelected);
         SubscribeLocalEvent<ResearchClientComponent, ResearchClientServerDeselectedMessage>(OnClientDeselected);
+        SubscribeLocalEvent<ResearchClientComponent, ResearchRegistrationChangedEvent>(OnClientRegistrationChanged);
     }
 
     #region UI
 
-    private void OnClientDeselected(EntityUid uid, ResearchClientComponent component, ResearchClientServerDeselectedMessage args)
-    {
-        UnregisterClientServer(component);
-        UpdateClientInterface(component);
-
-        if (TryComp<ResearchConsoleComponent>(uid, out var console))
-        {
-            UpdateConsoleInterface(console, component);
-        }
-    }
-
     private void OnClientSelected(EntityUid uid, ResearchClientComponent component, ResearchClientServerSelectedMessage args)
     {
-        UnregisterClientServer(component);
-        RegisterClientServer(component, GetServerById(args.ServerId));
-        UpdateClientInterface(component);
+        var server = GetServerById(args.ServerId);
+        if (server == null)
+            return;
 
-        if (TryComp<ResearchConsoleComponent>(uid, out var console))
-        {
-            UpdateConsoleInterface(console, component);
-        }
+        UnregisterClient(uid, clientComponent: component);
+        RegisterClient(uid, server.Owner, component, server);
+    }
+
+    private void OnClientDeselected(EntityUid uid, ResearchClientComponent component, ResearchClientServerDeselectedMessage args)
+    {
+        UnregisterClient(uid, clientComponent: component);
     }
 
     private void OnClientSyncMessage(EntityUid uid, ResearchClientComponent component, ResearchClientSyncMessage args)
     {
-        UpdateClientInterface(component);
+        UpdateClientInterface(uid, component);
     }
 
+    private void OnConsoleSelect(EntityUid uid, ResearchClientComponent component, ConsoleServerSelectionMessage args)
+    {
+        if (!HasComp<TechnologyDatabaseComponent>(uid) || !this.IsPowered(uid, EntityManager))
+            return;
+
+        _uiSystem.TryToggleUi(uid, ResearchClientUiKey.Key, (IPlayerSession) args.Session);
+    }
+
+    private void OnConsoleSync(EntityUid uid, ResearchClientComponent component, ConsoleServerSyncMessage args)
+    {
+        if (!this.IsPowered(uid, EntityManager))
+            return;
+
+        SyncClientWithServer(uid);
+    }
     #endregion
 
+    private void OnClientRegistrationChanged(EntityUid uid, ResearchClientComponent component, ref ResearchRegistrationChangedEvent args)
+    {
+        UpdateClientInterface(uid, component);
+    }
+
     private void OnClientStartup(EntityUid uid, ResearchClientComponent component, ComponentStartup args)
     {
         var allServers = EntityQuery<ResearchServerComponent>(true).ToArray();
         if (allServers.Length > 0)
-            RegisterClientServer(component, allServers[0]);
+            RegisterClient(uid, allServers[0].Owner, component, allServers[0]);
     }
 
     private void OnClientShutdown(EntityUid uid, ResearchClientComponent component, ComponentShutdown args)
     {
-        UnregisterClientServer(component);
+        UnregisterClient(uid, component);
     }
 
     private void OnClientUIOpen(EntityUid uid, ResearchClientComponent component, BoundUIOpenedEvent args)
     {
-        UpdateClientInterface(component);
+        UpdateClientInterface(uid, component);
     }
 
-    private void UpdateClientInterface(ResearchClientComponent component)
+    private void UpdateClientInterface(EntityUid uid, ResearchClientComponent? component = null)
     {
+        if (!Resolve(uid, ref component, false))
+            return;
+
+        if (!TryGetClientServer(uid, out _, out var serverComponent, component))
+            return;
+
         var names = GetServerNames();
         var state = new ResearchClientBoundInterfaceState(names.Length, names,
-            GetServerIds(), component.ConnectedToServer ? component.Server!.Id : -1);
+            GetServerIds(), component.ConnectedToServer ? serverComponent.Id : -1);
 
         _uiSystem.TrySetUiState(component.Owner, ResearchClientUiKey.Key, state);
     }
 
-    private bool RegisterClientServer(ResearchClientComponent component, ResearchServerComponent? server = null)
+    /// <summary>
+    /// Tries to get the server belonging to a client
+    /// </summary>
+    /// <param name="uid">The client</param>
+    /// <param name="server">It's server. Null if false.</param>
+    /// <param name="serverComponent">The server's ResearchServerComponent. Null if false</param>
+    /// <param name="component">The client's Researchclient component</param>
+    /// <returns>If the server was successfully retrieved.</returns>
+    public bool TryGetClientServer(EntityUid uid, [NotNullWhen(returnValue: true)] out EntityUid? server,
+        [NotNullWhen(returnValue: true)] out ResearchServerComponent? serverComponent, ResearchClientComponent? component = null)
     {
-        return server != null && RegisterServerClient(server, component.Owner, component);
-    }
+        server = null;
+        serverComponent = null;
+
+        if (!Resolve(uid, ref component, false))
+            return false;
 
-    private void UnregisterClientServer(ResearchClientComponent component)
-    {
         if (component.Server == null)
-            return;
+            return false;
 
-        UnregisterServerClient(component.Server, component.Owner, component);
+        if (!TryComp<ResearchServerComponent>(component.Server, out var sc))
+            return false;
+
+        server = component.Server;
+        serverComponent = sc;
+        return true;
     }
 }

Content.Server/Research/Systems/ResearchSystem.Console.cs

@@ -1,8 +1,6 @@
 using Content.Server.Power.EntitySystems;
 using Content.Server.Research.Components;
 using Content.Shared.Research.Components;
-using Content.Shared.Research.Prototypes;
-using Robust.Server.Player;
 
 namespace Content.Server.Research.Systems;
 
@@ -11,66 +9,39 @@ public sealed partial class ResearchSystem
     private void InitializeConsole()
     {
         SubscribeLocalEvent<ResearchConsoleComponent, ConsoleUnlockTechnologyMessage>(OnConsoleUnlock);
-        SubscribeLocalEvent<ResearchConsoleComponent, ConsoleServerSyncMessage>(OnConsoleSync);
-        SubscribeLocalEvent<ResearchConsoleComponent, ConsoleServerSelectionMessage>(OnConsoleSelect);
         SubscribeLocalEvent<ResearchConsoleComponent, ResearchServerPointsChangedEvent>(OnPointsChanged);
-    }
-
-    private void OnConsoleSelect(EntityUid uid, ResearchConsoleComponent component, ConsoleServerSelectionMessage args)
-    {
-        if (!HasComp<TechnologyDatabaseComponent>(uid) ||
-            !HasComp<ResearchClientComponent>(uid) ||
-            !this.IsPowered(uid, EntityManager))
-            return;
-
-        _uiSystem.TryOpen(uid, ResearchClientUiKey.Key, (IPlayerSession) args.Session);
-    }
-
-    private void OnConsoleSync(EntityUid uid, ResearchConsoleComponent component, ConsoleServerSyncMessage args)
-    {
-        if (!TryComp<TechnologyDatabaseComponent>(uid, out var database) ||
-            !HasComp<ResearchClientComponent>(uid) ||
-            !this.IsPowered(uid, EntityManager))
-            return;
-
-        SyncWithServer(database);
-        UpdateConsoleInterface(component);
+        SubscribeLocalEvent<ResearchConsoleComponent, ResearchRegistrationChangedEvent>(OnConsoleRegistrationChanged);
+        SubscribeLocalEvent<ResearchConsoleComponent, TechnologyDatabaseModifiedEvent>(OnConsoleDatabaseModified);
     }
 
     private void OnConsoleUnlock(EntityUid uid, ResearchConsoleComponent component, ConsoleUnlockTechnologyMessage args)
     {
-        if (!TryComp<TechnologyDatabaseComponent>(uid, out var database) ||
-            !TryComp<ResearchClientComponent>(uid, out var client) ||
-            !this.IsPowered(uid, EntityManager))
+        if (!this.IsPowered(uid, EntityManager))
             return;
 
-        if (!_prototypeManager.TryIndex(args.Id, out TechnologyPrototype? tech) ||
-            client.Server == null ||
-            !CanUnlockTechnology(client.Server, tech))
+        if (!UnlockTechnology(uid, args.Id))
             return;
 
-        if (!UnlockTechnology(client.Server, tech))
-            return;
-
-        SyncWithServer(database);
-        Dirty(database);
-        UpdateConsoleInterface(component);
+        SyncClientWithServer(uid);
+        UpdateConsoleInterface(uid, component);
     }
 
-    private void UpdateConsoleInterface(ResearchConsoleComponent component, ResearchClientComponent? clientComponent = null)
+    private void UpdateConsoleInterface(EntityUid uid, ResearchConsoleComponent? component = null, ResearchClientComponent? clientComponent = null)
     {
+        if (!Resolve(uid, ref component, ref clientComponent, false))
+            return;
+
         ResearchConsoleBoundInterfaceState state;
 
-        if (!Resolve(component.Owner, ref clientComponent, false) ||
-            clientComponent.Server == null)
+        if (TryGetClientServer(uid, out var server, out var serverComponent, clientComponent))
         {
-            state = new ResearchConsoleBoundInterfaceState(default, default);
+            var points = clientComponent.ConnectedToServer ? serverComponent.Points : 0;
+            var pointsPerSecond = clientComponent.ConnectedToServer ? PointsPerSecond(server.Value, serverComponent) : 0;
+            state = new ResearchConsoleBoundInterfaceState(points, pointsPerSecond);
         }
         else
         {
-            var points = clientComponent.ConnectedToServer ? clientComponent.Server.Points : 0;
-            var pointsPerSecond = clientComponent.ConnectedToServer ? PointsPerSecond(clientComponent.Server) : 0;
-            state = new ResearchConsoleBoundInterfaceState(points, pointsPerSecond);
+            state = new ResearchConsoleBoundInterfaceState(default, default);
         }
 
         _uiSystem.TrySetUiState(component.Owner, ResearchConsoleUiKey.Key, state);
@@ -80,7 +51,17 @@ public sealed partial class ResearchSystem
     {
         if (!_uiSystem.IsUiOpen(uid, ResearchConsoleUiKey.Key))
             return;
-        UpdateConsoleInterface(component);
+        UpdateConsoleInterface(uid, component);
     }
 
+    private void OnConsoleRegistrationChanged(EntityUid uid, ResearchConsoleComponent component, ref ResearchRegistrationChangedEvent args)
+    {
+        SyncClientWithServer(uid);
+        UpdateConsoleInterface(uid, component);
+    }
+
+    private void OnConsoleDatabaseModified(EntityUid uid, ResearchConsoleComponent component, ref TechnologyDatabaseModifiedEvent args)
+    {
+        UpdateConsoleInterface(uid, component);
+    }
 }

Content.Server/Research/Systems/ResearchSystem.PointSource.cs

@@ -1,5 +1,6 @@
 using Content.Server.Power.EntitySystems;
 using Content.Server.Research.Components;
+using Content.Shared.Research.Components;
 
 namespace Content.Server.Research.Systems;
 

Content.Server/Research/Systems/ResearchSystem.Server.cs

@@ -1,97 +1,164 @@
+using System.Linq;
 using Content.Server.Power.EntitySystems;
-using Content.Server.Research.Components;
 using Content.Shared.Research.Components;
-using Content.Shared.Research.Prototypes;
 
 namespace Content.Server.Research.Systems;
 
 public sealed partial class ResearchSystem
 {
-    private bool CanRun(ResearchServerComponent component)
+    private void InitializeServer()
     {
-        return this.IsPowered(component.Owner, EntityManager);
+        SubscribeLocalEvent<ResearchServerComponent, ComponentStartup>(OnServerStartup);
+        SubscribeLocalEvent<ResearchServerComponent, ComponentShutdown>(OnServerShutdown);
+        SubscribeLocalEvent<ResearchServerComponent, TechnologyDatabaseModifiedEvent>(OnServerDatabaseModified);
     }
 
-    private void UpdateServer(ResearchServerComponent component, int time)
+    private void OnServerStartup(EntityUid uid, ResearchServerComponent component, ComponentStartup args)
     {
-        if (!CanRun(component))
+        var unusedId = EntityQuery<ResearchServerComponent>(true)
+            .Max(s => s.Id) + 1;
+        component.Id = unusedId;
+        Dirty(component);
+    }
+
+    private void OnServerShutdown(EntityUid uid, ResearchServerComponent component, ComponentShutdown args)
+    {
+        foreach (var client in new List<EntityUid>(component.Clients))
+        {
+            UnregisterClient(client, uid, serverComponent: component, dirtyServer: false);
+        }
+    }
+
+    private void OnServerDatabaseModified(EntityUid uid, ResearchServerComponent component, ref TechnologyDatabaseModifiedEvent args)
+    {
+        foreach (var client in component.Clients)
+        {
+            RaiseLocalEvent(client, ref args);
+        }
+    }
+
+    private bool CanRun(EntityUid uid)
+    {
+        return this.IsPowered(uid, EntityManager);
+    }
+
+    private void UpdateServer(EntityUid uid, int time, ResearchServerComponent? component = null)
+    {
+        if (!Resolve(uid, ref component))
             return;
-        ChangePointsOnServer(component.Owner, PointsPerSecond(component) * time, component);
+
+        if (!CanRun(uid))
+            return;
+        AddPointsToServer(uid, PointsPerSecond(uid, component) * time, component);
     }
 
-    public bool RegisterServerClient(ResearchServerComponent component, EntityUid client, ResearchClientComponent? clientComponent = null)
+    /// <summary>
+    /// Registers a client to the specified server.
+    /// </summary>
+    /// <param name="client">The client being registered</param>
+    /// <param name="server">The server the client is being registered to</param>
+    /// <param name="clientComponent"></param>
+    /// <param name="serverComponent"></param>
+    /// <param name="dirtyServer">Whether or not to dirty the server component after registration</param>
+    /// <returns>Whether or not the client was successfully registered to the server</returns>
+    public bool RegisterClient(EntityUid client, EntityUid server, ResearchClientComponent? clientComponent = null,
+        ResearchServerComponent? serverComponent = null,  bool dirtyServer = true)
     {
-        if (!Resolve(client, ref clientComponent))
+        if (!Resolve(client, ref clientComponent) || !Resolve(server, ref serverComponent))
             return false;
 
-        if (component.Clients.Contains(client))
+        if (serverComponent.Clients.Contains(client))
             return false;
-        component.Clients.Add(client);
-        clientComponent.Server = component;
+
+        serverComponent.Clients.Add(client);
+        clientComponent.Server = server;
+
+        if (dirtyServer)
+            Dirty(serverComponent);
+
+        var ev = new ResearchRegistrationChangedEvent(server);
+        RaiseLocalEvent(client, ref ev);
         return true;
     }
 
-    public void UnregisterServerClient(ResearchServerComponent component, EntityUid client, ResearchClientComponent? clientComponent = null)
+    /// <summary>
+    /// Unregisterse a client from its server
+    /// </summary>
+    /// <param name="client"></param>
+    /// <param name="clientComponent"></param>
+    /// <param name="dirtyServer"></param>
+    public void UnregisterClient(EntityUid client, ResearchClientComponent? clientComponent = null, bool dirtyServer = true)
     {
         if (!Resolve(client, ref clientComponent))
             return;
 
-        component.Clients.Remove(client);
+        if (clientComponent.Server is not { } server)
+            return;
+
+        UnregisterClient(client, server, clientComponent, dirtyServer: dirtyServer);
+    }
+
+    /// <summary>
+    /// Unregisters a client from its server
+    /// </summary>
+    /// <param name="client"></param>
+    /// <param name="server"></param>
+    /// <param name="clientComponent"></param>
+    /// <param name="serverComponent"></param>
+    /// <param name="dirtyServer"></param>
+    public void UnregisterClient(EntityUid client, EntityUid server, ResearchClientComponent? clientComponent = null,
+        ResearchServerComponent? serverComponent = null, bool dirtyServer = true)
+    {
+        if (!Resolve(client, ref clientComponent) || !Resolve(server, ref serverComponent))
+            return;
+
+        serverComponent.Clients.Remove(client);
         clientComponent.Server = null;
+
+        if (dirtyServer)
+        {
+            Dirty(serverComponent);
+        }
+
+        var ev = new ResearchRegistrationChangedEvent(null);
+        RaiseLocalEvent(client, ref ev);
     }
 
-    public bool IsTechnologyUnlocked(ResearchServerComponent component, TechnologyPrototype prototype,
-        TechnologyDatabaseComponent? databaseComponent = null)
-    {
-        if (!Resolve(component.Owner, ref databaseComponent, false))
-            return false;
-        return IsTechnologyUnlocked(databaseComponent.Owner, prototype.ID, databaseComponent);
-    }
-
-    public bool CanUnlockTechnology(ResearchServerComponent component, TechnologyPrototype technology, TechnologyDatabaseComponent? databaseComponent = null)
-    {
-        if (!Resolve(component.Owner, ref databaseComponent, false))
-            return false;
-
-        if (!CanUnlockTechnology(databaseComponent.Owner, technology, databaseComponent) ||
-            component.Points < technology.RequiredPoints ||
-            IsTechnologyUnlocked(component, technology, databaseComponent))
-            return false;
-
-        return true;
-    }
-
-    public bool UnlockTechnology(ResearchServerComponent component, TechnologyPrototype prototype,
-        TechnologyDatabaseComponent? databaseComponent = null)
-    {
-        if (!Resolve(component.Owner, ref databaseComponent, false))
-            return false;
-
-        if (!CanUnlockTechnology(component, prototype, databaseComponent))
-            return false;
-        var result = UnlockTechnology(databaseComponent, prototype);
-        if (result)
-            ChangePointsOnServer(component.Owner, -prototype.RequiredPoints, component);
-        return result;
-    }
-
-    public int PointsPerSecond(ResearchServerComponent component)
+    /// <summary>
+    /// Gets the amount of points generated by all the server's sources in a second.
+    /// </summary>
+    /// <param name="uid"></param>
+    /// <param name="component"></param>
+    /// <returns></returns>
+    public int PointsPerSecond(EntityUid uid, ResearchServerComponent? component = null)
     {
         var points = 0;
 
-        if (!CanRun(component))
+        if (!Resolve(uid, ref component))
             return points;
+
+        if (!CanRun(uid))
+            return points;
+
         var ev = new ResearchServerGetPointsPerSecondEvent(component.Owner, points);
         foreach (var client in component.Clients)
         {
             RaiseLocalEvent(client, ref ev);
         }
-
         return ev.Points;
     }
 
-    public void ChangePointsOnServer(EntityUid uid, int points, ResearchServerComponent? component = null)
+    /// <summary>
+    /// Adds a specified number of points to a server.
+    /// </summary>
+    /// <param name="uid">The server</param>
+    /// <param name="points">The amount of points being added</param>
+    /// <param name="component"></param>
+    public void AddPointsToServer(EntityUid uid, int points, ResearchServerComponent? component = null)
     {
+        if (points == 0)
+            return;
+
         if (!Resolve(uid, ref component))
             return;
         component.Points += points;
@@ -100,5 +167,6 @@ public sealed partial class ResearchSystem
         {
             RaiseLocalEvent(client, ref ev);
         }
+        Dirty(component);
     }
 }

Content.Server/Research/Systems/ResearchSystem.Technology.cs

@@ -1,30 +1,25 @@
-using System.Linq;
-using Content.Server.Research.Components;
 using Content.Shared.Research.Components;
 using Content.Shared.Research.Prototypes;
-using Robust.Shared.GameStates;
 
 namespace Content.Server.Research.Systems;
 
 public sealed partial class ResearchSystem
 {
     /// <summary>
-    ///     Synchronizes this database against other,
-    ///     adding all technologies from the other that
-    ///     this one doesn't have.
+    /// Syncs the primary entity's database to that of the secondary entity's database.
     /// </summary>
-    /// <param name="component"></param>
-    /// <param name="otherDatabase">The other database</param>
-    /// <param name="twoway">Whether the other database should be synced against this one too or not.</param>
-    public void Sync(TechnologyDatabaseComponent component, TechnologyDatabaseComponent otherDatabase, bool twoway = true)
+    public void Sync(EntityUid primaryUid, EntityUid otherUid, TechnologyDatabaseComponent? primaryDb = null, TechnologyDatabaseComponent? otherDb = null)
     {
-        otherDatabase.TechnologyIds = otherDatabase.TechnologyIds.Union(component.TechnologyIds).ToList();
-        otherDatabase.RecipeIds = otherDatabase.RecipeIds.Union(component.RecipeIds).ToList();
+        if (!Resolve(primaryUid, ref primaryDb) || !Resolve(otherUid, ref otherDb))
+            return;
 
-        if (twoway)
-            Sync(otherDatabase, component, false);
+        primaryDb.TechnologyIds = otherDb.TechnologyIds;
+        primaryDb.RecipeIds = otherDb.RecipeIds;
 
-        Dirty(component);
+        Dirty(primaryDb);
+
+        var ev = new TechnologyDatabaseModifiedEvent();
+        RaiseLocalEvent(primaryDb.Owner, ref ev);
     }
 
     /// <summary>
@@ -33,46 +28,74 @@ public sealed partial class ResearchSystem
     ///     syncs against the research server, and the server against the local database.
     /// </summary>
     /// <returns>Whether it could sync or not</returns>
-    public bool SyncWithServer(TechnologyDatabaseComponent component, ResearchClientComponent? clientComponent = null)
+    public bool SyncClientWithServer(EntityUid uid, TechnologyDatabaseComponent? databaseComponent = null, ResearchClientComponent? clientComponent = null)
     {
-        if (!Resolve(component.Owner, ref clientComponent, false))
-            return false;
-        if (!TryComp<TechnologyDatabaseComponent>(clientComponent.Server?.Owner, out var clientDatabase))
+        if (!Resolve(uid, ref databaseComponent, ref clientComponent, false))
             return false;
 
-        Sync(component, clientDatabase);
+        if (!TryComp<TechnologyDatabaseComponent>(clientComponent.Server, out var serverDatabase))
+            return false;
 
+        Sync(uid, clientComponent.Server.Value, databaseComponent, serverDatabase);
         return true;
     }
 
     /// <summary>
-    ///     If possible, unlocks a technology on this database.
+    /// Tries to add a technology to a database, checking if it is able to
     /// </summary>
-    /// <param name="component"></param>
-    /// <param name="technology"></param>
-    /// <returns></returns>
-    public bool UnlockTechnology(TechnologyDatabaseComponent component, TechnologyPrototype technology)
+    /// <returns>If the technology was successfully added</returns>
+    public bool UnlockTechnology(EntityUid client, string prototypeid, ResearchClientComponent? component = null,
+        TechnologyDatabaseComponent? databaseComponent = null)
     {
-        if (!CanUnlockTechnology(component.Owner, technology, component)) return false;
+        if (!_prototypeManager.TryIndex<TechnologyPrototype>(prototypeid, out var prototype))
+        {
+            Logger.Error("invalid technology prototype");
+            return false;
+        }
+        return UnlockTechnology(client, prototype, component, databaseComponent);
+    }
 
-        AddTechnology(component, technology.ID);
+    /// <summary>
+    /// Tries to add a technology to a database, checking if it is able to
+    /// </summary>
+    /// <returns>If the technology was successfully added</returns>
+    public bool UnlockTechnology(EntityUid client, TechnologyPrototype prototype, ResearchClientComponent? component = null,
+        TechnologyDatabaseComponent? databaseComponent = null)
+    {
+        if (!Resolve(client, ref component, ref databaseComponent, false))
+            return false;
+
+        if (!CanUnlockTechnology(client, prototype, databaseComponent))
+            return false;
+
+        if (component.Server is not { } server)
+            return false;
+        AddTechnology(server, prototype.ID);
+        AddPointsToServer(server, -prototype.RequiredPoints);
         return true;
     }
 
     /// <summary>
     ///     Adds a technology to the database without checking if it could be unlocked.
     /// </summary>
-    /// <param name="component"></param>
-    /// <param name="technology"></param>
-    public void AddTechnology(TechnologyDatabaseComponent component, string technology)
+    public void AddTechnology(EntityUid uid, string technology, TechnologyDatabaseComponent? component = null)
     {
+        if (!Resolve(uid, ref component))
+            return;
+
         if (!_prototypeManager.TryIndex<TechnologyPrototype>(technology, out var prototype))
             return;
-        AddTechnology(component, prototype);
+        AddTechnology(uid, prototype, component);
     }
 
-    public void AddTechnology(TechnologyDatabaseComponent component, TechnologyPrototype technology)
+    /// <summary>
+    ///     Adds a technology to the database without checking if it could be unlocked.
+    /// </summary>
+    public void AddTechnology(EntityUid uid, TechnologyPrototype technology, TechnologyDatabaseComponent? component = null)
     {
+        if (!Resolve(uid, ref component))
+            return;
+
         component.TechnologyIds.Add(technology.ID);
         foreach (var unlock in technology.UnlockedRecipes)
         {
@@ -82,23 +105,63 @@ public sealed partial class ResearchSystem
         }
         Dirty(component);
 
-        if (!TryComp<ResearchServerComponent>(component.Owner, out var server))
-            return;
-        foreach (var client in server.Clients)
-        {
-            if (!TryComp<ResearchConsoleComponent>(client, out var console))
-                continue;
-            UpdateConsoleInterface(console);
-        }
+        var ev = new TechnologyDatabaseModifiedEvent();
+        RaiseLocalEvent(uid, ref ev);
     }
 
-    public void AddLatheRecipe(TechnologyDatabaseComponent component, string recipe, bool dirty = true)
+    /// <summary>
+    /// Adds a lathe recipe to the specified technology database
+    /// without checking if it can be unlocked.
+    /// </summary>
+    public void AddLatheRecipe(EntityUid uid, string recipe, TechnologyDatabaseComponent? component = null, bool dirty = true)
     {
+        if (!Resolve(uid, ref component))
+            return;
+
         if (component.RecipeIds.Contains(recipe))
             return;
 
         component.RecipeIds.Add(recipe);
         if (dirty)
             Dirty(component);
+
+        var ev = new TechnologyDatabaseModifiedEvent();
+        RaiseLocalEvent(uid, ref ev);
+    }
+
+    /// <summary>
+    ///     Returns whether a technology can be unlocked on this database,
+    ///     taking parent technologies into account.
+    /// </summary>
+    /// <returns>Whether it could be unlocked or not</returns>
+    public bool CanUnlockTechnology(EntityUid uid, string technology, TechnologyDatabaseComponent? database = null, ResearchClientComponent? client = null)
+    {
+        if (!_prototypeManager.TryIndex<TechnologyPrototype>(technology, out var prototype))
+            return false;
+        return CanUnlockTechnology(uid, prototype, database, client);
+    }
+
+    /// <summary>
+    ///     Returns whether a technology can be unlocked on this database,
+    ///     taking parent technologies into account.
+    /// </summary>
+    /// <returns>Whether it could be unlocked or not</returns>
+    public bool CanUnlockTechnology(EntityUid uid, TechnologyPrototype technology, TechnologyDatabaseComponent? database = null, ResearchClientComponent? client = null)
+    {
+        if (!Resolve(uid, ref database, ref client))
+            return false;
+
+        if (!TryGetClientServer(uid, out _, out var serverComponent, client))
+            return false;
+
+        if (serverComponent.Points < technology.RequiredPoints)
+            return false;
+
+        if (IsTechnologyUnlocked(uid, technology, database))
+            return false;
+
+        if (!ArePrerequesitesUnlocked(uid, technology, database))
+            return false;
+        return true;
     }
 }

Content.Server/Research/Systems/ResearchSystem.cs

@@ -1,5 +1,5 @@
 using System.Linq;
-using Content.Server.Research.Components;
+using Content.Shared.Research.Components;
 using Content.Shared.Research.Systems;
 using JetBrains.Annotations;
 using Robust.Server.GameObjects;
@@ -18,20 +18,17 @@ namespace Content.Server.Research.Systems
         public override void Initialize()
         {
             base.Initialize();
-            SubscribeLocalEvent<ResearchServerComponent, ComponentStartup>(OnStartup);
-
             InitializeClient();
             InitializeConsole();
             InitializeSource();
+            InitializeServer();
         }
 
-        private void OnStartup(EntityUid uid, ResearchServerComponent component, ComponentStartup args)
-        {
-            var unusedId = EntityQuery<ResearchServerComponent>(true)
-                .Max(s => s.Id) + 1;
-            component.Id = unusedId;
-        }
-
+        /// <summary>
+        /// Gets a server based on it's unique numeric id.
+        /// </summary>
+        /// <param name="id"></param>
+        /// <returns></returns>
         public ResearchServerComponent? GetServerById(int id)
         {
             foreach (var server in EntityQuery<ResearchServerComponent>())
@@ -43,6 +40,10 @@ namespace Content.Server.Research.Systems
             return null;
         }
 
+        /// <summary>
+        /// Gets the names of all the servers.
+        /// </summary>
+        /// <returns></returns>
         public string[] GetServerNames()
         {
             var allServers = EntityQuery<ResearchServerComponent>(true).ToArray();
@@ -56,6 +57,10 @@ namespace Content.Server.Research.Systems
             return list;
         }
 
+        /// <summary>
+        /// Gets the ids of all the servers
+        /// </summary>
+        /// <returns></returns>
         public int[] GetServerIds()
         {
             var allServers = EntityQuery<ResearchServerComponent>(true).ToArray();
@@ -77,7 +82,7 @@ namespace Content.Server.Research.Systems
                     continue;
                 server.NextUpdateTime = _timing.CurTime + server.ResearchConsoleUpdateTime;
 
-                UpdateServer(server, (int) server.ResearchConsoleUpdateTime.TotalSeconds);
+                UpdateServer(server.Owner, (int) server.ResearchConsoleUpdateTime.TotalSeconds, server);
             }
         }
     }