SyncDataAsJson not working

[DrSalzstreuer]

Hey, the JSON based Sync-System for Bannerlords 1.3 (BETA) together with Bannerlord.ButterLib/2.10.0 is having issues.
Below an example how I use it and the serialized data always is a empty String and the deserialized one is null.

https://butterlib.butr.link/articles/SaveSystem/Overview.html

internal class RevoltCampaignBehavior(CampaignGameStarter CampaignGameStarterObject) : CampaignBehaviorBase
{
  private RevoltSaveData _revoltSaveData = new();

  internal Kingdom? RandomLuckyNation { get; private set; }
  internal Kingdom? ImperialLuckyNation { get; private set; }
  internal Kingdom? NonImperialLuckyNation { get; private set; }
  internal Dictionary<Settlement, IFaction> SettlementsPreviousFaction { get; } = new();

  public override void RegisterEvents()
  {
  	CampaignEvents.OnSessionLaunchedEvent.AddNonSerializedListener(this, OnSessionLaunched);
  	CampaignEvents.OnClanChangedKingdomEvent.AddNonSerializedListener(this, OnClanChangedKingdom);
  }

  public override void SyncData(IDataStore dataStore)
  {
  	if (dataStore.IsSaving)
  	{
  		_revoltSaveData.RandomLuckyNation = RandomLuckyNation;
  		_revoltSaveData.ImperialLuckyNation = ImperialLuckyNation;
  		_revoltSaveData.NonImperialLuckyNation = NonImperialLuckyNation;
  		_revoltSaveData.SettlementsPreviousFactionId = SettlementsPreviousFaction.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.StringId);

  		dataStore.SyncDataAsJson(nameof(RevoltCampaignBehavior), ref _revoltSaveData!);
  	}
  	else
  	{
  		dataStore.SyncDataAsJson(nameof(RevoltCampaignBehavior), ref _revoltSaveData!);

  		RandomLuckyNation = _revoltSaveData.RandomLuckyNation;
  		ImperialLuckyNation = _revoltSaveData.ImperialLuckyNation;
  		NonImperialLuckyNation = _revoltSaveData.NonImperialLuckyNation;

  		SettlementsPreviousFaction.Clear();

  		foreach (var settlementPreviousFactionId in _revoltSaveData.SettlementsPreviousFactionId)
  		{
  			var settlement = settlementPreviousFactionId.Key;
  			var factionStringId = settlementPreviousFactionId.Value;
  			
  			var faction = Campaign.Current.Factions.FirstOrDefault(faction => faction.StringId == factionStringId);
  			if (faction is not null)
  			{
  				SettlementsPreviousFaction[settlement] = faction;
  			}
  		}
  	}
  }
}

using TaleWorlds.CampaignSystem;
using TaleWorlds.CampaignSystem.Settlements;
using TaleWorlds.SaveSystem;

namespace Bannerlord.RevolutionsReloaded.Components.Revolts.SaveData;

[Serializable]
internal class RevoltSaveData
{
  [SaveableField(1)]
  public Kingdom? RandomLuckyNation;
  
  [SaveableField(2)]
  public Kingdom? ImperialLuckyNation;
  
  [SaveableField(3)]
  public Kingdom? NonImperialLuckyNation;
  
  [SaveableField(4)]
  public Dictionary<Settlement, string> SettlementsPreviousFactionId = new();
}

[DrSalzstreuer]

Okay, the issue is, that MBObjectManager in 1.3.1 BETA isn't storing Kingdoms, Clans, Heros and Factions anymore. Here is a workaround I wrote until you guys come up with something more reliable. I'm calling MBObjectLookupHelper.FindById instead of IMBObjectFinder.Find inside MBObjectBaseConverter.ReadJson

using System.Collections;
using System.Reflection;
using TaleWorlds.CampaignSystem;
using TaleWorlds.Library;
using TaleWorlds.ObjectSystem;

namespace Bannerlord.RevolutionsReloaded.Helpers;

/// <summary>
/// MBGUID lookup helper that searches objects across both managers in the most efficient order.
/// Also supports IFaction (which has a MBGUID) even though IFaction does not derive from MBObjectBase.
/// </summary>
/// <remarks>
/// - First checks MBObjectManager by GUID (fast O(1) path that uses engine's internal map).
/// - Then checks MBObjectManager type list for the requested runtime type (O(n) only for that type).
/// - Finally scans CampaignObjectManager's partitioned collections (O(n) only for relevant types).
/// </remarks>
/// <seealso cref="MBObjectManager"/>
/// <seealso cref="CampaignObjectManager"/>
/// <seealso cref="MBGUID"/>
public static class MBObjectLookupHelper
{
	/// <summary>
	/// Generic API. Returns object of type <typeparamref name="T"/> or null if not found.
	/// </summary>
	/// <typeparam name="T">MBObjectBase-derived type to find.</typeparam>
	/// <param name="id">Target MBGUID.</param>
	/// <returns>The found instance or null.</returns>
	public static T? FindById<T>(MBGUID id) where T : MBObjectBase 
		=> (T?)FindById(id, typeof(T));

	/// <summary>
	/// Runtime-type API. Returns object of the requested <paramref name="objectType"/> (or a compatible instance) or null if not found.
	/// </summary>
	/// <param name="id">Target MBGUID.</param>
	/// <param name="objectType">Runtime type to search for. Must be MBObjectBase or IFaction.</param>
	/// <returns>Found instance or null.</returns>
	/// <remarks>
	/// Special-case: IFaction is supported (it has MBGUID) even though it does not inherit MBObjectBase.
	/// </remarks>
	public static object? FindById(MBGUID id, Type objectType)
	{
		// IFaction (interface) is not MBObjectBase but has MBGUID; handle explicitly.
		if (objectType == typeof(IFaction))
		{
			return FindFactionById(id);
		}

		if (!typeof(MBObjectBase).IsAssignableFrom(objectType))
		{
			return null;
		}

		// 1) Fast path: MBObjectManager direct GUID lookup (internally uses ObjectTypeRecords map).
		var mbObject = MBObjectManager.Instance.GetObject(id);
		if (mbObject is not null && objectType.IsInstanceOfType(mbObject))
		{
			return mbObject;
		}

		// 2) MBObjectManager type list scan (only for the requested type).
		var fromMbList = FindInMBObjectManagerList(id, objectType);
		if (fromMbList is not null)
		{
			return fromMbList;
		}

		// 3) CampaignObjectManager partitions scan (only relevant lists and partitions).
		return FindInCampaignCollections(id, objectType);
	}

	/// <summary>
	/// Finds IFaction by MBGUID.
	/// <remarks>
	/// Tries MBObjectManager first (which might already return a Kingdom/Clan),
	/// then falls back to Factions (interface list).</remarks>
	/// </summary>
	/// <param name="id">Faction MBGUID.</param>
	/// <returns>The IFaction instance or null.</returns>
	/// <seealso cref="IFaction"/>
	private static IFaction? FindFactionById(MBGUID id)
	{
		// MBObjectManager can return concrete faction types (e.g., Kingdom or Clan) directly.
		var mbObject = MBObjectManager.Instance.GetObject(id);
		if (mbObject is IFaction factionObject)
		{
			return factionObject;
		}

		var com = Campaign.Current?.CampaignObjectManager;
		if (com is null)
		{
			return null;
		}

		for (int i = 0, n = com.Factions?.Count ?? 0; i < n; i++)
		{
			var faction = com.Factions![i];
			if (faction.Id == id)
			{
				return faction;
			}
		}

		return null;
	}

	/// <summary>
	/// MBObjectManager type list lookup for the given runtime type, matching by MBGUID.
	/// </summary>
	/// <param name="id">Target MBGUID.</param>
	/// <param name="objectType">Runtime type (MBObjectBase-derived).</param>
	/// <returns>The found MBObjectBase instance or null.</returns>
	/// <seealso cref="MBObjectManager.GetObjectTypeList{T}()"/>
	private static MBObjectBase? FindInMBObjectManagerList(MBGUID id, Type objectType)
	{
		var method = typeof(MBObjectManager).GetMethod(nameof(MBObjectManager.GetObjectTypeList), BindingFlags.Public | BindingFlags.Instance);
		if (method is null)
		{
			return null;
		}

		try
		{
			var generic = method.MakeGenericMethod(objectType);
			if (generic.Invoke(MBObjectManager.Instance, []) is not IEnumerable list)
			{
				return null;
			}

			var enumerator = list.GetEnumerator();
			try
			{
				while (enumerator.MoveNext())
				{
					if (enumerator.Current is MBObjectBase mbObject && mbObject.Id == id)
					{
						return mbObject;
					}
				}
			}
			finally
			{
				(enumerator as IDisposable)?.Dispose();
			}
		}
		catch
		{
			// ignored
		}

		return null;
	}

	/// <summary>
	/// Scans CampaignObjectManager's partitioned collections in a targeted order.
	/// Only iterates lists that could logically contain the requested target type.
	/// </summary>
	/// <param name="id">Target MBGUID.</param>
	/// <param name="targetType">Runtime type (MBObjectBase-derived).</param>
	/// <returns>The found MBObjectBase instance or null.</returns>
	/// <seealso cref="CampaignObjectManager"/>
	private static MBObjectBase? FindInCampaignCollections(MBGUID id, Type targetType)
	{
		var com = Campaign.Current?.CampaignObjectManager;
		if (com is null)
		{
			return null;
		}

		// Heroes.
		var mbObject = ScanList(com.AliveHeroes, id, targetType);
		if (mbObject is not null)
		{
			return mbObject;
		}

		mbObject = ScanList(com.DeadOrDisabledHeroes, id, targetType);
		if (mbObject is not null)
		{
			return mbObject;
		}

		// Clans and Kingdoms.
		mbObject = ScanList(com.Clans, id, targetType);
		if (mbObject is not null)
		{
			return mbObject;
		}

		mbObject = ScanList(com.Kingdoms, id, targetType);
		if (mbObject is not null)
		{
			return mbObject;
		}

		// Settlements.
		mbObject = ScanList(com.Settlements, id, targetType);
		if (mbObject is not null)
		{
			return mbObject;
		}

		// MobileParty partitions.
		mbObject = ScanList(com.MobileParties, id, targetType);
		if (mbObject is not null)
		{
			return mbObject;
		}

		mbObject = ScanList(com.LordParties, id, targetType);
		if (mbObject is not null)
		{
			return mbObject;
		}

		mbObject = ScanList(com.CaravanParties, id, targetType);
		if (mbObject is not null)
		{
			return mbObject;
		}

		mbObject = ScanList(com.PatrolParties, id, targetType);
		if (mbObject is not null)
		{
			return mbObject;
		}

		mbObject = ScanList(com.MilitiaParties, id, targetType);
		if (mbObject is not null)
		{
			return mbObject;
		}

		mbObject = ScanList(com.GarrisonParties, id, targetType);
		if (mbObject is not null)
		{
			return mbObject;
		}

		mbObject = ScanList(com.BanditParties, id, targetType);
		if (mbObject is not null)
		{
			return mbObject;
		}

		mbObject = ScanList(com.VillagerParties, id, targetType);
		if (mbObject is not null)
		{
			return mbObject;
		}

		mbObject = ScanList(com.CustomParties, id, targetType);
		if (mbObject is not null)
		{
			return mbObject;
		}

		mbObject = ScanList(com.PartiesWithoutPartyComponent, id, targetType);
		if (mbObject is not null) 
		{
			return mbObject;
		}

		return null;
	}

	/// <summary>
	/// Scans a single MBReadOnlyList for a matching MBGUID with minimal overhead.
	/// Avoids per-item reflection when the list item type is assignable to the requested target type.
	/// </summary>
	/// <typeparam name="TList">List element type (MBObjectBase-derived).</typeparam>
	/// <param name="mbObjectList">The list to scan.</param>
	/// <param name="id">Target MBGUID.</param>
	/// <param name="targetType">Runtime type we look for.</param>
	/// <returns>Found item or null.</returns>
	private static MBObjectBase? ScanList<TList>(MBReadOnlyList<TList> mbObjectList, MBGUID id, Type targetType) where TList : MBObjectBase
	{
		if (!targetType.IsAssignableFrom(typeof(TList)))
		{
			return null;
		}

		for (int i = 0, n = mbObjectList.Count; i < n; i++)
		{
			var mbObject = mbObjectList[i];
			if (mbObject.Id == id)
			{
				return mbObject;
			}
		}

		return null;
	}
}