Rmimport

Resources/Locale/en-US/commands.ftl

@@ -175,6 +175,20 @@ cmd-hint-loadmap-y-position = [y-position]
 cmd-hint-loadmap-rotation = [rotation]
 cmd-hint-loadmap-uids = [float]
 
+cmd-savegame-desc = Serializes all game entities to disk. Will save all entities, paused an unpaused.
+cmd-savegame-help = savegame <Path>
+cmd-savegame-attempt = Attempting to save full game state to {$path}.
+cmd-savegame-success = Game state successfully saved.
+cmd-savegame-error = Could not save the game state! See server log for details.
+cmd-savegame-disabled = Game saves are disabled on this server.
+
+cmd-loadgame-desc = Loads a full game state from disk into the game. Flushes all existing entities
+cmd-loadgame-help = loadgame <Path>
+cmd-loadgame-attempt = Attempting to load full game state from {$path}.
+cmd-loadgame-success = Game state successfully loaded.
+cmd-loadgame-error = Could not load the game state! See server log for details.
+cmd-loadgame-disabled = Game saves are disabled on this server.
+
 cmd-hint-savebp-id = <Grid EntityID>
 
 ## 'flushcookies' command

Robust.Client/GameObjects/EntitySystems/ContainerSystem.cs

@@ -116,7 +116,7 @@ private void HandleComponentState(EntityUid uid, ContainerManagerComponent compo
                 if (!component.Containers.TryGetValue(id, out var container))
                 {
                     var type = _serializer.FindSerializedType(typeof(BaseContainer), data.ContainerType);
-                    container = _dynFactory.CreateInstanceUnchecked<BaseContainer>(type!, inject:false);
+                    container = _dynFactory.CreateInstanceUnchecked<BaseContainer>(type!, inject: false);
                     container.Init(this, id, (uid, component));
                     component.Containers.Add(id, container);
                 }
@@ -169,15 +169,15 @@ private void HandleComponentState(EntityUid uid, ContainerManagerComponent compo
                 {
                     var entity = stateEnts[i];
                     var netEnt = stateNetEnts[i];
+
                     if (!entity.IsValid())
                     {
-                        DebugTools.Assert(netEnt.IsValid());
-                        AddExpectedEntity(netEnt, container);
+                        if (netEnt.IsValid())
+                            AddExpectedEntity(netEnt, container);
                         continue;
                     }
 
                     var meta = MetaData(entity);
-                    DebugTools.Assert(meta.NetEntity == netEnt);
 
                     // If an entity is currently in the shadow realm, it means we probably left PVS and are now getting
                     // back into range. We do not want to directly insert this entity, as IF the container and entity

Robust.Server/Console/Commands/MapCommands.cs

@@ -1,10 +1,13 @@
 using System.Linq;
 using System.Numerics;
+using Robust.Shared;
+using Robust.Shared.Configuration;
 using Robust.Shared.Console;
 using Robust.Shared.ContentPack;
 using Robust.Shared.EntitySerialization;
 using Robust.Shared.EntitySerialization.Systems;
 using Robust.Shared.GameObjects;
+using Robust.Shared.GameSaves;
 using Robust.Shared.IoC;
 using Robust.Shared.Localization;
 using Robust.Shared.Map;
@@ -334,4 +337,112 @@ public override void Execute(IConsoleShell shell, string argStr, string[] args)
                 shell.WriteLine(Loc.GetString("cmd-loadmap-error", ("path", args[1])));
         }
     }
+
+    public sealed class SaveGame : LocalizedCommands
+    {
+        [Dependency] private readonly IEntitySystemManager _system = default!;
+        [Dependency] private readonly IResourceManager _resource = default!;
+        [Dependency] private readonly IConfigurationManager _config = default!;
+
+        public override string Command => "savegame";
+
+        public override CompletionResult GetCompletion(IConsoleShell shell, string[] args)
+        {
+            switch (args.Length)
+            {
+                case 1:
+                    var opts = CompletionHelper.UserFilePath(args[0], _resource.UserData);
+                    return CompletionResult.FromHintOptions(opts, Loc.GetString("cmd-hint-savemap-path"));
+                case 2:
+                    return CompletionResult.FromHint(Loc.GetString("cmd-hint-savemap-force"));
+            }
+            return CompletionResult.Empty;
+        }
+
+        public override void Execute(IConsoleShell shell, string argStr, string[] args)
+        {
+            if (!_config.GetCVar(CVars.GameSavesEnabled))
+            {
+                shell.WriteLine(Loc.GetString("cmd-savegame-disabled"));
+                return;
+            }
+
+            if (args.Length < 1)
+            {
+                shell.WriteLine(Help);
+                return;
+            }
+
+            shell.WriteLine(Loc.GetString("cmd-savegame-attempt", ("path", args[0])));
+            bool saveSuccess = _system.GetEntitySystem<GameSavesSystem>().TrySaveGame(new ResPath(args[0]));
+            if(saveSuccess)
+            {
+                shell.WriteLine(Loc.GetString("cmd-savegame-success"));
+            }
+            else
+            {
+                shell.WriteError(Loc.GetString("cmd-savegame-error"));
+            }
+        }
+    }
+
+    public sealed class LoadGame : LocalizedCommands
+    {
+        [Dependency] private readonly IEntityManager _entMan = default!;
+        [Dependency] private readonly IEntitySystemManager _system = default!;
+        [Dependency] private readonly IResourceManager _resource = default!;
+        [Dependency] private readonly IConfigurationManager _config = default!;
+
+        public override string Command => "loadgame";
+
+        public override CompletionResult GetCompletion(IConsoleShell shell, string[] args)
+        {
+            switch (args.Length)
+            {
+                case 1:
+                    var opts = CompletionHelper.UserFilePath(args[0], _resource.UserData);
+                    return CompletionResult.FromHintOptions(opts, Loc.GetString("cmd-hint-savemap-path"));
+                case 2:
+                    return CompletionResult.FromHint(Loc.GetString("cmd-hint-savemap-force"));
+            }
+            return CompletionResult.Empty;
+        }
+
+        public override void Execute(IConsoleShell shell, string argStr, string[] args)
+        {
+            if (!_config.GetCVar(CVars.GameSavesEnabled))
+            {
+                shell.WriteLine(Loc.GetString("cmd-savegame-disabled"));
+                return;
+            }
+
+            if (args.Length < 1)
+            {
+                shell.WriteLine(Help);
+                return;
+            }
+
+            var flush = false;
+            if (args.Length == 2 && !bool.TryParse(args[1], out flush))
+            {
+                shell.WriteError(Loc.GetString("cmd-parse-failure-bool", ("arg", args[1])));
+                return;
+            }
+
+            shell.WriteLine(Loc.GetString("cmd-loadgame-attempt", ("path", args[0])));
+
+            if (flush)
+                _entMan.FlushEntities();
+
+            bool loadSuccess = _system.GetEntitySystem<GameSavesSystem>().TryLoadGame(new ResPath(args[0]));
+            if(loadSuccess)
+            {
+                shell.WriteLine(Loc.GetString("cmd-loadgame-success"));
+            }
+            else
+            {
+                shell.WriteError(Loc.GetString("cmd-loadgame-error"));
+            }
+        }
+    }
 }

Robust.Shared/CVars.cs

@@ -1962,5 +1962,26 @@ internal static readonly CVarDef<string>
         /// </summary>
         public static readonly CVarDef<bool> LoadingShowDebug =
             CVarDef.Create("loading.show_debug", DefaultShowDebug, CVar.CLIENTONLY);
+
+        /*
+         * GAME SAVES
+         */
+
+        /// <summary>
+        /// Whether to allow saving and loading all entities.
+        /// Should be enabled only after the repository is tested, and it's confirmed that
+        /// saving and loading in stable scenarios doesn't throw any errors.
+        /// </summary>
+        public static readonly CVarDef<bool> GameSavesEnabled =
+            CVarDef.Create("gamesaves.enabled", true, CVar.SERVER | CVar.REPLICATED);
+
+        /// <summary>
+        /// ZSTD compression level to use when compressing game saves.
+        /// </summary>
+        public static readonly CVarDef<int> GameSavesCompressLevel =
+            CVarDef.Create("gamesaves.compress_level", 3, CVar.ARCHIVE);
+
+        public static readonly CVarDef<string> GameSavesAutoloadName =
+            CVarDef.Create("gamesaves.autoload_name", "save", CVar.SERVERONLY);
     }
 }

Robust.Shared/EntitySerialization/Systems/MapLoaderSystem.Load.cs

@@ -80,7 +80,7 @@ public bool TryLoadGeneric(ResPath file, [NotNullWhen(true)] out LoadResult? res
         return TryLoadGeneric(data, file.ToString(), out result, options);
     }
 
-    private bool TryLoadGeneric(
+    public bool TryLoadGeneric(
         MappingDataNode data,
         string fileName,
         [NotNullWhen(true)] out LoadResult? result,

Robust.Shared/EntitySerialization/Systems/MapLoaderSystem.cs

@@ -135,6 +135,10 @@ public void Delete(LoadResult result)
         {
             Del(uid);
         }
-    }
 
+        foreach (var uid in result.NullspaceEntities)
+        {
+            Del(uid);
+        }
+    }
 }

Robust.Shared/GameObjects/EntityManager.Network.cs

@@ -183,7 +183,7 @@ public NetEntity GetNetEntity(EntityUid uid, MetaDataComponent? metadata = null)
         if (uid == EntityUid.Invalid)
             return NetEntity.Invalid;
 
-        if (!MetaQuery.Resolve(uid, ref metadata))
+        if (!MetaQuery.Resolve(uid, ref metadata, logMissing: false))
             return NetEntity.Invalid;
 
         return metadata.NetEntity;

Robust.Shared/GameSaves/GameSaveEvent.cs

@@ -0,0 +1,16 @@
+using Robust.Shared.GameObjects;
+using Robust.Shared.Utility;
+
+namespace Robust.Shared.GameSaves;
+
+/// <summary>
+/// Event that is raised before all entities from the current state are saved to file.
+/// </summary>
+[ByRefEvent]
+public readonly record struct BeforeGameSaveEvent(ResPath SavePath);
+
+/// <summary>
+/// Event that is raised  before loading all saved entities from the file.
+/// </summary>
+[ByRefEvent]
+public readonly record struct BeforeGameLoadEvent(ResPath SavePath);