Development

Update SaveLoad system to correctly resolve cross references

A Playground/ExposablesTest/Game.cs

+using KludgeBox.SaveLoad;
+using KludgeBox.SaveLoad.SaveLoadTypes;
+using KludgeBox.Structs;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace A_Playground.ExposablesTest
+{
+    public class Game : IExposable
+    {
+        public Rect2 gameRegion = new Rect2(Vec2(), Vec2(100));
+        public List<Team> teams = new List<Team>();
+        public Dictionary<string, User> players = new Dictionary<string, User>();
+
+        public Game()
+        {
+            var team1 = new Team();
+            team1.name = "Reds";
+            team1.teamColor = Colors.Red;
+            team1.users.Add(new User { name = "Player1", position = Vec2(30,-0.1f), team = team1});
+            team1.users.Add(new User { name = "Player2", position = Vec2(19,3.1416f), team = team1});
+
+            var team2 = new Team();
+            team2.name = "Blues";
+            team2.teamColor = Colors.Blue;
+            team2.users.Add(new User { name = "Player3", position = Vec2(-30, 23.88005f), team = team2 });
+            team2.users.Add(new User { name = "Player4", position = Vec2(-403.5f, -33.7f), team = team2 });
+
+            teams.Add(team1);
+            teams.Add(team2);
+
+            foreach(var team in teams)
+                foreach (var user in team.users)
+                    players[user.name] = user;
+        }
+
+        public void ExposeData()
+        {
+            SaveLoad_Value.Link(ref gameRegion, "region");
+            SaveLoad_Array.Link(ref teams, "teams", LinkMode.Reference);
+            SaveLoad_Dictionary.Link(ref players, "players", LinkMode.Reference);
+        }
+    }
+}

A Playground/ExposablesTest/Team.cs

+using KludgeBox.SaveLoad;
+using KludgeBox.SaveLoad.SaveLoadTypes;
+using KludgeBox.Structs;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace A_Playground.ExposablesTest
+{
+    public class Team : IReferencable
+    {
+        private static int _teamsCount = 0;
+        public int Id => _id;
+
+        public List<User> users = new List<User>();
+        public string name = string.Empty;
+        public Color teamColor = Col(1);
+        private int _id = 0;
+        public Team()
+        {
+            _id = _teamsCount;
+            _teamsCount++;
+        }
+        public void ExposeData()
+        {
+            SaveLoad_Array.Link(ref users, "users", LinkMode.Reference);
+            SaveLoad_Value.Link(ref name, "name");
+            SaveLoad_Value.Link(ref teamColor, "color");
+        }
+
+        public string GetReferenceId()
+        {
+            return $"Team_{Id}";
+        }
+    }
+}

A Playground/ExposablesTest/User.cs

+using KludgeBox.SaveLoad;
+using KludgeBox.SaveLoad.SaveLoadTypes;
+using KludgeBox.Structs;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace A_Playground.ExposablesTest
+{
+    public class User : IReferencable
+    {
+        private static int _usersCount = 0;
+
+        public string name = String.Empty;
+        public Team team = null;
+        public Vector2 position = Vec2();
+        public int Id { get; private set; } = 0;
+
+        public User() 
+        {
+            Id = _usersCount;
+            _usersCount++;
+        }
+
+
+        public void ExposeData()
+        {
+            SaveLoad_Reference.Link(ref team, "team");
+            SaveLoad_Value.Link(ref name, "name");
+            SaveLoad_Value.Link(ref position, "position");
+        }
+
+        public string GetReferenceId()
+        {
+            return $"User_{Id}";
+        }
+    }
+}

A Playground/Program.cs

-using KludgeBox.SaveLoad;
+using A_Playground.ExposablesTest;
+using KludgeBox.SaveLoad;
 using KludgeBox.Structs;
 
 namespace A_Playground;
@@ -107,5 +108,16 @@ internal class Program
         Msg(cirStr);
         Msg(Parser.Parse<Circle>(cirStr));
         Empty();
+
+
+        Lines(linesSpacing);
+        Info("SaveLoad serialization");
+        var game = new Game();
+        var gameStr = SaveLoad.Save(game);
+        Msg(gameStr);
+        var newGame = SaveLoad.Load<Game>(gameStr);
+        Info("SaveLoad reserialization");
+        gameStr = SaveLoad.Save(newGame);
+        Msg(gameStr);
     }
 }
\ No newline at end of file

KludgeBox/SaveLoad/SaveLoadTypes/SaveLoad_Array.cs

 
+using KludgeBox.SaveLoad.SaveLoadTypes;
 using System;
 
 namespace KludgeBox.SaveLoad
 {
 	public static class SaveLoad_Array
 	{
-		public static void Link<TValue>(ref TValue[] array, string label) 
+		public static void Link<TValue>(ref List<TValue> array, string label, LinkMode defaultLinkMode = LinkMode.Undefined) 
 		{
-			// Saving process
-			if (SaveLoad.Mode is SaveLoadMode.Saving)
+
+            LinkMode linkMode;
+            Type elementType = typeof(TValue);
+            if (defaultLinkMode == LinkMode.Undefined)
+                linkMode = TypeResolver.ResolveLinkType(elementType);
+            else
+                linkMode = defaultLinkMode;
+
+			if(SaveLoad.Mode is SaveLoadMode.ScanRefs)
+			{
+				foreach (var item in array)
+					if (item is IReferencable rItem)
+						SaveLoad_Reference.Link(ref rItem, "ref");
+			}
+
+            // Saving process
+            if (SaveLoad.Mode is SaveLoadMode.Saving)
 			{
 				if (array is null)
 				{
@@ -23,17 +39,15 @@ namespace KludgeBox.SaveLoad
 				// Enter the object with the specified label for saving array data.
 				if (SaveLoad.EnterObject(label))
 				{
-					SaveLoad.Saver.WriteProperty("arrayLength", array.Length.ToString());
+					SaveLoad.Saver.WriteProperty("arrayLength", array.Count.ToString());
 
 					// Loop through the array elements and save them individually.
-					for (int i = 0; i < array.Length; i++)
+					for (int i = 0; i < array.Count; i++)
 					{
 						// Create a label for the array element based on the index.
 						string elementLabel = $"element{i}";
 
 						// Link the array element using the appropriate method based on its type.
-						Type elementType = typeof(TValue);
-						LinkMode linkMode = TypeResolver.ResolveLinkType(elementType);
 						TValue value = array[i];
 						switch (linkMode)
 						{
@@ -44,7 +58,11 @@ namespace KludgeBox.SaveLoad
 								var exposable = value as IExposable;
 								SaveLoad_Exposable.Link(ref exposable, elementLabel);
 								break;
-							default:
+                            case LinkMode.Reference:
+                                var referencable = value as IReferencable;
+                                SaveLoad_Reference.Link(ref referencable, elementLabel);
+                                break;
+                            default:
 								// Handle undefined LinkMode for the array element type.
 								break;
 						}
@@ -72,37 +90,43 @@ namespace KludgeBox.SaveLoad
 				int arrayLength = int.Parse((string)SaveLoad.Loader.CurrentObject[label]["arrayLength"]);
 
 				// Create a new array with the retrieved length.
-				array = new TValue[arrayLength];
+				array = new List<TValue>(arrayLength);
 
 				// Enter the object with the specified label for loading array data.
 				if (SaveLoad.EnterObject(label))
 				{
-					Type elementType = typeof(TValue);
 					// Loop through the array elements and load them individually.
 					for (int i = 0; i < arrayLength; i++)
 					{
-						// Create a label for the array element based on the index.
-						string elementLabel = $"element{i}";
-
-						// Link the array element using the appropriate method based on its type.
-						LinkMode linkMode = TypeResolver.ResolveLinkType(elementType);
-						TValue value = array[i];
-						switch (linkMode)
+						if(linkMode is not LinkMode.Reference)
 						{
-							case LinkMode.Value:
-								SaveLoad_Value.Link(ref value, elementLabel);
-								break;
-							case LinkMode.Exposable:
-								var exposable = value as IExposable;
-								SaveLoad_Exposable.Link(ref exposable, elementLabel);
-								value = (TValue)exposable;
-								break;
-							default:
-								// Handle undefined LinkMode for the array element type.
-								break;
+                            // Create a label for the array element based on the index.
+                            string elementLabel = $"element{i}";
+
+                            // Link the array element using the appropriate method based on its type.
+                            TValue value = default(TValue);
+                            switch (linkMode)
+                            {
+                                case LinkMode.Value:
+                                    SaveLoad_Value.Link(ref value, elementLabel);
+                                    break;
+                                case LinkMode.Exposable:
+                                    var exposable = value as IExposable;
+                                    SaveLoad_Exposable.Link(ref exposable, elementLabel);
+                                    value = (TValue)exposable;
+                                    break;
+                                case LinkMode.Reference:
+                                    var reference = value as IReferencable;
+                                    SaveLoad_Reference.Link(ref reference, elementLabel);
+                                    value = (TValue)reference;
+                                    break;
+                                default:
+                                    // Handle undefined LinkMode for the array element type.
+                                    break;
 
+                            }
+                            array[i] = value;
 						}
-						array[i] = value;
 					}
 
 					// Exit the object after loading the array data.
@@ -112,7 +136,26 @@ namespace KludgeBox.SaveLoad
 
 			if (SaveLoad.Mode is SaveLoadMode.PostLoading)
 			{
-				if (typeof(TValue).IsAssignableTo(typeof(IExposable)))
+                if (linkMode == LinkMode.Reference)
+                {
+                    if (SaveLoad.EnterObject(label))
+                    {
+                        foreach ((var key, var value) in SaveLoad.Loader.CurrentObject)
+                        {
+                            if (key == "arrayLength")
+                                continue;
+
+                            TValue val = default;
+                            var reference = value as IReferencable;
+                            SaveLoad_Reference.Link(ref reference, key);
+                            val = (TValue)reference;
+							array.Add(val);
+                        }
+                        SaveLoad.ExitObject();
+                    }
+                }
+
+                if (typeof(TValue).IsAssignableTo(typeof(IExposable)))
 				{
 					foreach (var value in array)
 					{