Comments

• ChrisIceBox

  May 28

  With a custom iSaveFileHandler implementation, you can create an override of the GetDefaultSaveLabel function to return your custom label.
• jamesfootlight

  May 29

  Thanks, Chris.
  
  I’ve already implemented a custom iSaveFileHandler, and GetDefaultSaveLabel(int saveID) is overridden to return a custom label using scene name and timestamp. I also assign the label directly to saveFile.label during Save() and again in GatherSaveFiles() like so:
  
  string label = $"{scene} ({time})";
  saveFile.label = label;
  
  Despite this, the SavesList menu still displays the default “Save X” format instead of the custom label. This happens even though my handler is correctly registered and used (confirmed via debug logs). I’m using AC v1.79.3.
  
  Is there anything else that needs to happen for the label to show correctly in the UI? For example, is the SavesList menu supposed to reference GetDefaultSaveLabel(), or should it always rely on the label stored in SaveFile?
  
  Thanks again!
  James
• jamesfootlight

  May 29

  Got this sorted, thanks!
• jamesfootlight

  June 24

  Hi Chris,

  I'm currently integrating Adventure Creator v1.79.3 with a custom save system for Xbox using the Microsoft GDK. My goal is to ensure save slot labels (e.g. "Jungle\n24/06/2025 17:30") persist across sessions — not just in-memory, but stored and recalled correctly even after quitting and relaunching the game.

  I’ve implemented a custom iSaveFileHandler (called XboxSaveFileHandler) that writes and loads save blobs using Xbox GameSave. The saves themselves load and persist fine — however, I’m struggling to persist the save labels between sessions in a way that AC’s UI (i.e., SavesList menu elements) will continue to display them correctly.

  Here’s the problem:

  • AC calls GatherSaveFiles() or GatherSaveFilesAsync() to build the list of save slots.
  • I tried storing the labels in separate blobs (e.g., label_1.json), but this led to compatibility issues with the Xbox API (QueryContainerBlobs() overload errors).
  • I tried storing all labels in a manifest.json file (a dictionary of IDs → labels), but AC doesn't seem to populate the UI correctly from this when using a custom handler — unless we manually recreate SaveFile objects.

  Questions:

  • What is the correct way to persist labels in a custom iSaveFileHandler, so that AC's SavesList menu shows them after restarting the game?
  • Do I need to manually create and populate SaveFile objects with labels and timestamps inside GatherSaveFiles() for this to work?
  • Is there any special method or timing that AC expects for slot labels to be refreshed correctly in the UI?

  Thanks so much — any advice would be hugely appreciated, especially as we’re trying to get Xbox save/load certified and functional across all platforms.
• ChrisIceBox

  June 25

  I'm not clear on the underlying problem. What's the actual behaviour you're getting?

  The save labels are set by the iSaveFileHandler - but this data is stored within your game's Options Data, so that they can be retrieved without having to load the saves themselves.

  This should be handled automatically. If the wrong labels are showing, how are you saving options data? That can similarly be customised with an iOptionsFileHandler override.

  Are regular Options, e.g. SFX volume, saving/restoring correctly between sessions?
• jamesfootlight

  June 30

  Hi Chris,

  Thanks again for your help earlier — we’ve made progress, but I wanted to follow up on a couple of areas we’re still stuck on regarding save labels and options persistence using custom handlers in AC 1.79.3.

  Current Issues
  * Save Labels Not Persisting Across Sessions
  * We assign saveFile.label during Save() and again inside GatherSaveFiles(), and the label displays correctly in the SavesList menu during the same session. However, after restarting the game, AC’s SavesList reverts to showing “Save 0”, “Save 1”, etc.
  * Options Are Not Persisting Either
  * We’ve implemented a custom iOptionsFileHandler and confirmed that save/load callbacks are being hit — but changes to options like SFX volume don’t persist between sessions.
  **Our Handlers
  **Here’s a simplified version of our implementation:

  XboxSaveFileHandler.cs (excerpt)
  
  public void Save(SaveFile saveFile, string dataString, System.Action<bool> callback)
  {
      saveFile.label = $"{SceneManager.GetActiveScene().name} ({DateTime.Now:dd/MM/yyyy HH:mm})";
      // Save data to Xbox blob...
  }
  
  public void GatherSaveFiles(int slotCount, int profileID, Action<List<SaveFile>> callback)
  {
      // Load label from manifest and assign to saveFile.label
      var saveFiles = new List<SaveFile>();
      // ...build SaveFile list
      callback?.Invoke(saveFiles);
  }
  XboxOptionsFileHandler.cs (excerpt)
  
  public void SaveOptions(int profileID, string dataString, bool showLog)
  {
      // Save options.dat blob
  }
  
  public void LoadOptions(int profileID, Action<string> callback)
  {
      // Load options.dat blob and return string
  }
  

  Remaining Questions
  * Should save slot labels be written into Options data automatically by AC when saveFile.label is set, or do we need to manually handle that in iOptionsFileHandler?
  * Does AC’s SavesList element always rely on Options data for displaying labels, or does it fall back to saveFile.label or GetDefaultSaveLabel() if none is found?
  * Do we need to store save labels in a particular field/format inside the options string for AC to recognize them?
  * Any obvious issues with our approach that would explain why labels and options both reset on restart?
  Really appreciate any guidance — this is the final blocker before we wrap platform integration for certification.
• ChrisIceBox

  July 1

  Should save slot labels be written into Options data automatically by AC when saveFile.label is set, or do we need to manually handle that in iOptionsFileHandler?

  AC handles the serialization/deserialization of Options data - iOptionsFileHandler only needs to save/load all data as a single string value, dataString in SaveOptions.

  Does AC’s SavesList element always rely on Options data for displaying labels, or does it fall back to saveFile.label or GetDefaultSaveLabel() if none is found?

  If the Options data is not found, it'll revert back to the SaveFile list sent as a callback in the iSaveFileHandler's GatherSaveFiles function.

  The fact that the regular Options data (SFX volume etc) isn't persistent is the main issue, here. There may be an additional issue with labels, but the former needs to be addressed first.

  I can't comment on your implementaion of iOptionsFileHandler, but you've confirmed it's being used by AC with Debug.Logs?
• jamesfootlight

  July 2

  Hi Chris,
  
  Thanks for the clarification — very helpful.
  
  We’ve confirmed that our custom iOptionsFileHandler (XboxOptionsFileHandler) is being used to save both options data and save slot label metadata. Our logs confirm that the save process is working, for example:
  
  [XboxOptionsFileHandler] Options and labels saved for profile 0
  However, no options data is persisting between sessions — SFX volume and other preferences are reset on each launch. This suggests that while the data is being saved, it is not being loaded correctly at startup.
  
  We currently have no evidence that our LoadOptions() method is being called — it doesn’t appear in the Xbox logs, so we can’t confirm whether it’s ever executed without adding explicit in-game logging.
  
  Based on the log order and observed behavior, we suspect the handler is being assigned after AC has already called Options.LoadPrefs(), which would result in the default handler (likely PlayerPrefs) being used instead.
  
  Our setup begins in a non-Adventure Creator scene, where we initialize Xbox GDK systems (sign-in, achievements, save system, etc.). The first Adventure Creator scene is loaded afterwards. We attempted to assign the handler via a script called InitSaveHandlerWhenReady during the first (non-AC) scene, but this had no effect — likely because AC was not yet initialized and LoadPrefs() hadn’t yet been triggered.
  
  However, when InitSaveHandlerWhenReady runs in the first AC scene, it appears to run after AC has already initialized and loaded the default options — again, too late to have any effect.
  
  Regarding save slot labels:
  We are assigning saveFile.label manually and persisting it alongside the options data, for example:
  
  [XboxSaveFileHandler] Saving saveID 0 with label: AUTOSAVE - LABORATORY [02/07/2025 14:21]
  As you explained, Adventure Creator relies on the options data to store and retrieve custom labels across sessions — so if the iOptionsFileHandler isn’t active by the time Options.LoadPrefs() is called, both the options and labels will fail to load.
  
  That seems to be exactly what’s happening here: although the labels are saved correctly, they don’t persist between sessions because our handler isn’t active when AC initializes.
  
  We’re currently looking to identify a reliable way to ensure the handler is assigned before AC reaches LoadPrefs(), without modifying core AC scripts. Any guidance on this would be much appreciated.
  
  Cheers
• ChrisIceBox

  July 3

  Setting OptionsFileHandler before AC is present should be fine, I would have thought. It's a static variable and not one tied to a particular instance.

  Leaving AC's core scripts alone may be the ultimate goal, but you can test this by setting your own handler to be the AC default. In AC's Options script, see the OptionsFileHandler property at the bottom. Its getter returns OptionsFileHandler_PlayerPrefs unless an override is set - try replacing this with your own.
• jamesfootlight

  July 7

  Hi Chris,

  We’ve followed your advice and updated the Options.OptionsFileHandler fallback logic to return our custom Xbox handler by default on GDK builds. We also assign it manually via script at runtime just to be safe. Saving works (logs confirm blobs are written), and the blob options_profile_0 exists after reboot.

  But despite the blob being read, AC’s optionsData always resets to defaults on restart. We’ve confirmed:

  • LoadPrefsFromID() runs
  • LoadOptionsAsync() reads the blob (log shows it successfully deserializes)
  • Yet optionsData is still default, not what was saved

  We've tried:

  • Forcing SavePrefsToID() after sign-in
  • Explicitly assigning optionsData = ... inside the callback
  • Changing when/where the handler is assigned
  • Validating the JSON itself

  Still, the options UI shows default values every time. We suspect AC’s LoadPrefs() logic may be running before our data finishes loading, or that the optionsData assignment is overwritten somewhere internally.

  Can you confirm:

  When exactly Options.LoadPrefs() is called on startup relative to KickStarter.Initialise()?

  • Can we safely assign Options.optionsData = ... ourselves inside LoadOptionsAsync?
  • Should we explicitly delay KickStarter.Initialise() until after options have been read?

  Thanks again,
  James
• ChrisIceBox

  July 8

  LoadPrefs is called from the chain that begins in KickStarter.Initialise's SetPersistentEngine function call. Here's the stacktrace for the log that appears when starting up AC with OptionsFileHandler_PlayerPrefs:

  AC.OptionsFileHandler_PlayerPrefs:LoadOptions (int,bool) (at Assets/AdventureCreator/Scripts/Options/OptionsFileHandler_PlayerPrefs.cs:39)
  AC.Options:LoadPrefsFromID (int,bool,bool) (at Assets/AdventureCreator/Scripts/Options/Options.cs:185)
  AC.Options:LoadPrefs () (at Assets/AdventureCreator/Scripts/Options/Options.cs:118)
  AC.Options:OnInitPersistentEngine () (at Assets/AdventureCreator/Scripts/Options/Options.cs:39)
  AC.StateHandler:Initialise (bool) (at Assets/AdventureCreator/Scripts/Game engine/StateHandler.cs:140)
  AC.KickStarter:SetPersistentEngine () (at Assets/AdventureCreator/Scripts/Game engine/KickStarter.cs:180)
  AC.KickStarter:Initialise () (at Assets/AdventureCreator/Scripts/Game engine/KickStarter.cs:1130)
  AC.MultiSceneChecker:RegisterAsMain () (at Assets/AdventureCreator/Scripts/Game engine/MultiSceneChecker.cs:89)
  AC.MultiSceneChecker:Awake () (at Assets/AdventureCreator/Scripts/Game engine/MultiSceneChecker.cs:43)
  

  Can we safely assign Options.optionsData = ... ourselves inside LoadOptionsAsync?

  Where are you getting LoadOptionsAsync from? It's not an implementation of OptionsFileHandler.
• jamesfootlight

  July 8

  Thanks Chris — that’s super helpful.

  Just to clarify, the LoadOptionsAsync method I mentioned was part of our own custom implementation using Xbox Game Save. But I now realize that because Options.LoadPrefs() is triggered early via KickStarter.Initialise → SetPersistentEngine, our handler was being registered too late.

  Based on your explanation, we’re now assigning our XboxOptionsFileHandler and explicitly setting Options.optionsData = LoadOptions(...) inside a script that runs immediately after instantiating the PersistentEngine, but before any UI or save menus are used. This should ensure our options (volume, labels, etc.) persist correctly.

  Really appreciate the clarity on where LoadPrefs() is triggered — that’s exactly what we needed to move forward.
• jamesfootlight

  July 9

  Hi Chris,

  We’re running into an issue with options not persisting on Xbox using a custom iOptionsFileHandler implementation in Adventure Creator v1.79.3. We’re integrating with the Xbox GDK GameSave API, which loads options data asynchronously from a blob (e.g. options_profile_0).

  In the logs, we can confirm that:

  The options blob is successfully written and present in the save container.

  However, Adventure Creator appears to call Options.LoadPrefs() before our handler has a chance to load the data, resulting in the warning:

  [XboxOptionsFileHandler] AC called LoadOptions synchronously. Returning empty JSON.

  We’ve verified this happens during both CompleteSignInSetup() and again when AC initializes via OnInitPersistentEngine().

  Would you recommend delaying Adventure Creator’s Options.LoadPrefs() call until our async read has completed and Options.optionsData is initialized?

  Would modifying our InitSaveHandlerWhenReady script to wait for the GameSave system and options to fully load before allowing AC to proceed be the correct approach?

  Appreciate your advice on how best to handle this in AC’s initialization lifecycle.

  Thanks,
  James
• ChrisIceBox

  July 9

  • Unity version: [add your Unity version here]
  • Menu type: Unity UI-based or Adventure Creator? [whichever you use]

  Am I talking to an AI, James?
• jamesfootlight

  July 9

  AC Menu Type
  Unity Version: 2022.3.51f1

  I am asking ai to help me write more concise responses, rather than my haphazard replys. We had this working months back, then I had to switch to PS5 to fix a bug and do an update. Then I switched back and have lost the options working. Saves work fine. Ironically, options were working first before on xbox and saves was the issue. I am sure it is to do with when we initialise the handlers, but I seem to have tried everyything. I feed the watson logs in to chat gpt to understand what they are telling me. And they are telling me this:

  • Xbox GDK runtime and GameSave system initialize correctly
  • Save provider and container are created (0x0 HRESULT = success)
  • Sign-in, SCID, sandbox, and TitleId are all set properly
  • InitSaveHandlerWhenReady script runs — but only logs:
  • [InitSaveHandlerWhenReady] Handlers already assigned.
  • This suggests it thinks it already finished setup, even though options were not loaded yet

  • Adventure Creator tries to load options too early:

  • [XboxOptionsFileHandler] AC called LoadOptions synchronously. Returning empty JSON.

  • This means AC is using default options (like default volume/settings) instead of your saved data
  • Your options blob exists (options_profile_0)
  • But it’s not being read before AC uses it, so options don't persist between runs

  Root Problem
  InitSaveHandlerWhenReady is logging "Handlers already assigned" before options are loaded, causing AC to use defaults.

  Solution?
  Delay setting handlersSet = true until options are loaded and Options.optionsData is assigned, then call Options.SavePrefs().

  Let me know if you'd like a version of this explanation to post to a forum or share with your team.

  This is our InitSaveHandlerWhenReady script:

  #if UNITY_GDK && !UNITY_PS4 && !UNITY_PS5
  using System.Collections;
  using UnityEngine;
  using AC;
  
  namespace WoolleyMountain
  {
      public class InitSaveHandlerWhenReady : MonoBehaviour
      {
          private bool handlersSet = false;
          private GameObject persistentEngineInstance;
          private bool triedSpawn = false;
  
          private void Awake()
          {
              Debug.Log("[InitSaveHandlerWhenReady] Awake called.");
              DontDestroyOnLoad(gameObject);
          }
  
          private void Update()
          {
              if (handlersSet)
                  return;
  
              if (KickStarter.stateHandler == null)
              {
                  Debug.Log("[InitSaveHandlerWhenReady] KickStarter.stateHandler is null.");
                  if (!triedSpawn)
                  {
                      Debug.Log("[InitSaveHandlerWhenReady] Attempting to spawn PersistentEngine...");
  
                      GameObject prefab = Resources.Load<GameObject>("PersistentEngine");
                      if (prefab == null)
                      {
                          Debug.LogError("[InitSaveHandlerWhenReady] Resources.Load('PersistentEngine') returned null!");
                          triedSpawn = true;
                          return;
                      }
  
                      persistentEngineInstance = Instantiate(prefab);
                      persistentEngineInstance.name = "PersistentEngine";
                      DontDestroyOnLoad(persistentEngineInstance);
                      Debug.Log("[InitSaveHandlerWhenReady] PersistentEngine instantiated.");
                      triedSpawn = true;
                      StartCoroutine(WaitForPersistentEngine());
                  }
  
                  return;
              }
  
              if (KickStarter.options == null || KickStarter.saveSystem == null)
              {
                  Debug.Log("[InitSaveHandlerWhenReady] Waiting: KickStarter not fully initialized.");
                  return;
              }
  
              if (handlersSet || SaveSystem.SaveFileHandler != null)
              {
                  Debug.Log("[InitSaveHandlerWhenReady] Handlers already assigned.");
                  return;
              }
  
              if (GdkXboxManager.Instance?.SaveManager != null)
              {
                  Debug.Log("[InitSaveHandlerWhenReady] Running delayed Xbox handler init...");
                  StartCoroutine(InitializeXboxHandlers());
              }
          }
  
          private IEnumerator WaitForPersistentEngine()
          {
              yield return new WaitUntil(() =>
                  KickStarter.stateHandler != null &&
                  KickStarter.saveSystem != null &&
                  KickStarter.options != null);
  
              Debug.Log("[InitSaveHandlerWhenReady] PersistentEngine initialized. Continuing...");
          }
  
          private IEnumerator InitializeXboxHandlers()
          {
              yield return null;
  
              var saveManager = GdkXboxManager.Instance?.SaveManager;
              if (saveManager == null)
              {
                  Debug.LogError("[InitSaveHandlerWhenReady] SaveManager is null! Cannot assign file handlers.");
                  yield break;
              }
  
              SaveSystem.SaveFileHandler = new XboxSaveFileHandler(saveManager);
              Debug.Log("[InitSaveHandlerWhenReady] XboxSaveFileHandler assigned.");
  
              // Set OptionsFileHandler via reflection (for AC 1.79.3 compatibility)
              var field = typeof(Options).GetField("optionsFileHandler", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.NonPublic);
              if (field != null)
              {
                  var optionsHandler = new XboxOptionsFileHandler(saveManager);
                  field.SetValue(null, optionsHandler);
                  Debug.Log("[InitSaveHandlerWhenReady] XboxOptionsFileHandler set via reflection.");
  
                  bool optionsLoaded = false;
                  optionsHandler.LoadOptionsAsync(Options.GetActiveProfileID(), true, (loadedOptions) =>
                  {
                      Options.optionsData = loadedOptions;
                      Options.SavePrefs(); // Ensure AC picks up loaded options
                      Debug.Log($"[InitSaveHandlerWhenReady] Options loaded and saved. Music volume: {Options.GetMusicVolume()}");
                      optionsLoaded = true;
                  });
  
                  yield return new WaitUntil(() => optionsLoaded);
              }
              else
              {
                  Debug.LogError("[InitSaveHandlerWhenReady] Could not find 'optionsFileHandler' field in Options class.");
                  yield break;
              }
  
              handlersSet = true;
          }
      }
  }
  #endif
  

  I'd really appreciate any help, it is getting me down!!1
• jamesfootlight

  July 9

  this is my xboxoptionshandler:

      #if UNITY_GDK
      using System;
      using System.Collections.Generic;
      using System.Text;
      using UnityEngine;
      using AC;
      using HR = Unity.XGamingRuntime.HR;
  
      namespace WoolleyMountain
      {
          public class XboxOptionsFileHandler : iOptionsFileHandler
          {
              private int activeProfile = 0;
              private readonly Dictionary<int, string> profileCache = new Dictionary<int, string>();
              private const string ContainerName = "MainSaves";
  
              public void SaveOptions(int profileID, string dataString, bool showLog)
              {
                  string blobName = GetBlobName(profileID);
                  byte[] data = Encoding.UTF8.GetBytes(dataString);
  
                  if (GdkXboxManager.Instance?.SaveManager == null)
                  {
                      if (showLog) Debug.LogWarning("[XboxOptionsFileHandler] SaveManager is null");
                      return;
                  }
  
                  GdkXboxManager.Instance.SaveManager.SaveGame(ContainerName, blobName, data, (hr) =>
                  {
                      if (HR.SUCCEEDED(hr))
                      {
                          profileCache[profileID] = dataString;
                          if (showLog) Debug.Log($"[XboxOptionsFileHandler] Options saved for profile {profileID}");
                      }
                      else if (showLog)
                      {
                          Debug.LogWarning($"[XboxOptionsFileHandler] Failed to save options for profile {profileID}: 0x{hr:X}");
                      }
                  });
              }
  
              public string LoadOptions(int profileID, bool showLog)
              {
                  if (profileCache.TryGetValue(profileID, out string cached))
                  {
                      if (showLog) Debug.Log($"[XboxOptionsFileHandler] Loaded options from cache for profile {profileID}");
                      return cached;
                  }
  
                  if (showLog) Debug.LogWarning($"[XboxOptionsFileHandler] No cached options found for profile {profileID}, returning empty string");
                  return string.Empty;
              }
  
              public void LoadOptionsAsync(int profileID, bool showLog, System.Action<string> onComplete)
              {
                  if (profileCache.TryGetValue(profileID, out string cached))
                  {
                      if (showLog) Debug.Log($"[XboxOptionsFileHandler] Loaded options from cache for profile {profileID}");
                      onComplete?.Invoke(cached);
                      return;
                  }
  
                  string blobName = GetBlobName(profileID);
  
                  if (GdkXboxManager.Instance?.SaveManager == null)
                  {
                      if (showLog) Debug.LogWarning("[XboxOptionsFileHandler] SaveManager is null");
                      onComplete?.Invoke(string.Empty);
                      return;
                  }
  
                  GdkXboxManager.Instance.SaveManager.LoadGame(ContainerName, blobName, (hr, data) =>
                  {
                      if (HR.SUCCEEDED(hr) && data != null && data.Length > 0)
                      {
                          string loadedData = Encoding.UTF8.GetString(data);
                          profileCache[profileID] = loadedData;
                          if (showLog) Debug.Log($"[XboxOptionsFileHandler] Loaded options for profile {profileID}");
                          onComplete?.Invoke(loadedData);
                      }
                      else
                      {
                          if (showLog) Debug.LogWarning($"[XboxOptionsFileHandler] No options found for profile {profileID}, hr: 0x{hr:X}");
                          onComplete?.Invoke(string.Empty);
                      }
                  });
              }
  
              public void DeleteOptions(int profileID)
              {
                  string blobName = GetBlobName(profileID);
  
                  if (GdkXboxManager.Instance?.SaveManager == null)
                  {
                      Debug.LogWarning("[XboxOptionsFileHandler] SaveManager is null");
                      return;
                  }
  
                  GdkXboxManager.Instance.SaveManager.DeleteBlob(ContainerName, blobName, (hr) =>
                  {
                      if (HR.SUCCEEDED(hr))
                          Debug.Log($"[XboxOptionsFileHandler] Deleted options for profile {profileID}");
                      else
                          Debug.LogWarning($"[XboxOptionsFileHandler] Failed to delete options blob '{blobName}': 0x{hr:X}");
                  });
  
                  profileCache.Remove(profileID);
              }
  
              public int GetActiveProfile() => activeProfile;
  
              public void SetActiveProfile(int profileID)
              {
                  activeProfile = profileID;
                  Debug.Log($"[XboxOptionsFileHandler] Active profile set to {profileID}");
              }
  
              public bool DoesProfileExist(int profileID) => profileCache.ContainsKey(profileID);
  
              public void Initialize(System.Action onComplete)
              {
                  int profileID = 0; // Default profile
                  LoadOptionsAsync(profileID, true, (loadedData) =>
                  {
                      profileCache[profileID] = loadedData;
                      activeProfile = profileID;
                      Debug.Log("[XboxOptionsFileHandler] Initialized and loaded default profile.");
                      onComplete?.Invoke();
                  });
              }
  
              private string GetBlobName(int profileID) => $"options_{profileID}";
          }
      }
      #endif
  
• jamesfootlight

  July 9

  and my xboxsavehandler:

  #if UNITY_GDK
  using System;
  using System.Collections;
  using System.Collections.Generic;
  using System.Text;
  using UnityEngine;
  using Unity.XGamingRuntime;
  using AC;
  
  namespace WoolleyMountain
  {
      public class XboxSaveFileHandler : iSaveFileHandler
      {
          private const string ContainerName = "MainSaves";
  
          public void Save(SaveFile saveFile, string dataString, Action<bool> callback)
          {
              if (GdkXboxManager.Instance?.SaveManager == null)
              {
                  Debug.LogWarning("[XboxSaveFileHandler] SaveManager is null");
                  callback?.Invoke(false);
                  return;
              }
  
              byte[] data = Encoding.UTF8.GetBytes(dataString);
              string blobName = saveFile.saveID.ToString();
  
              GdkXboxManager.Instance.SaveManager.SaveGame(ContainerName, blobName, data, hr =>
              {
                  bool success = HR.SUCCEEDED(hr);
                  Debug.Log("[XboxSaveFileHandler] Save " + (success ? "successful" : "failed") + " for blob " + blobName);
                  callback?.Invoke(success);
              });
          }
  
          public void Load(SaveFile saveFile, bool showLog, Action<SaveFile, string> callback)
          {
              if (GdkXboxManager.Instance?.SaveManager == null)
              {
                  Debug.LogWarning("[XboxSaveFileHandler] SaveManager is null");
                  callback?.Invoke(saveFile, string.Empty);
                  return;
              }
  
              string blobName = saveFile.saveID.ToString();
  
              GdkXboxManager.Instance.SaveManager.LoadGame(ContainerName, blobName, (hr, data) =>
              {
                  if (HR.SUCCEEDED(hr) && data != null)
                  {
                      string dataString = Encoding.UTF8.GetString(data);
                      callback?.Invoke(saveFile, dataString);
                  }
                  else
                  {
                      if (showLog)
                          Debug.LogWarning("[XboxSaveFileHandler] Failed to load save for blob: " + blobName);
                      callback?.Invoke(saveFile, string.Empty);
                  }
              });
          }
  
          public void Delete(SaveFile saveFile, Action<bool> callback)
          {
              if (GdkXboxManager.Instance?.SaveManager == null)
              {
                  Debug.LogWarning("[XboxSaveFileHandler] SaveManager is null");
                  callback?.Invoke(false);
                  return;
              }
  
              string blobName = saveFile.saveID.ToString();
  
              GdkXboxManager.Instance.SaveManager.DeleteBlob(ContainerName, blobName, hr =>
              {
                  bool success = HR.SUCCEEDED(hr);
                  Debug.Log("[XboxSaveFileHandler] Delete " + (success ? "successful" : "failed") + " for blob " + blobName);
                  callback?.Invoke(success);
              });
          }
  
          public List<SaveFile> GatherSaveFiles(int profileID)
          {
              List<SaveFile> saves = new List<SaveFile>();
              var blobs = GdkXboxManager.Instance?.SaveManager?.QueryContainerBlobs();
  
              if (blobs != null)
              {
                  foreach (var blob in blobs)
                  {
                      if (int.TryParse(blob.Name, out int saveID))
                      {
                          var save = new SaveFile(saveID, saveID, blob.Name, GetDefaultSaveLabel(saveID), null, string.Empty, 0);
                          saves.Add(save);
                      }
                  }
              }
  
              return saves;
          }
  
          public SaveFile GetSaveFile(int profileID, int saveID)
          {
              return new SaveFile(saveID, saveID, saveID.ToString(), GetDefaultSaveLabel(saveID), null, string.Empty, 0);
          }
  
          public List<SaveFile> GatherImportFiles(int profileID, int maxFiles, string extension, string label)
          {
              return new List<SaveFile>();
          }
  
          public string GetDefaultSaveLabel(int saveID)
          {
              string sceneName = UnityEngine.SceneManagement.SceneManager.GetActiveScene().name;
              string friendlyName = GetFriendlySceneName(sceneName);
              string dateTime = System.DateTime.Now.ToString("dd/MM/yyyy HH:mm");
  
              if (saveID == 0)
              {
                  return $"AUTOSAVE - {friendlyName.ToUpper()} [{dateTime}]";
              }
  
              return $"{friendlyName.ToUpper()} [{dateTime}]";
          }
  
          private string GetFriendlySceneName(string sceneName)
          {
              if (sceneName == "Title Screen 1") return "Main Menu";
              if (sceneName == "Start Screen") return "Woolley Mountain";
              if (sceneName == "Start Screen Part 3") return "Woolley Mountain Part 3";
              if (sceneName == "Control Room Land Ahoy") return "Control Room Part 2";
              if (sceneName.StartsWith("Bertie's Lair")) return "Bertie's Lair";
              return sceneName;
          }
  
          public void DeleteAll(int profileID)
          {
              var blobs = GdkXboxManager.Instance?.SaveManager?.QueryContainerBlobs();
              if (blobs != null)
              {
                  foreach (var blob in blobs)
                  {
                      GdkXboxManager.Instance.SaveManager.DeleteBlob(ContainerName, blob.Name, hr =>
                      {
                          Debug.Log("[XboxSaveFileHandler] Delete result: 0x" + hr.ToString("X") + " for blob " + blob.Name);
                      });
                  }
              }
          }
  
          public bool SupportsSaveThreading() => false;
  
          public void SaveScreenshot(SaveFile saveFile) { /* Disabled */ }
      }
  }
  #endif
  
• jamesfootlight

  July 9

  I’ve given up on chat GPT - it just gets lost and muddled: right now saves persist, but options do not.
• jamesfootlight

  July 11

  Any thoughts on this one Chris ?