Hi, I’m noticing my ActionStore is not loading correctly, I tried reverting the changes from this lecture and I don’t think that has anything to do with it but I’m pretty stumped right now. I don’t think it is a resources folder issue as the same ability will save/load fine in my inventory just not in the action bar. My ability is currently in Resources/Fire Explosion, but I also tried moving it back to directly being in resources with no change. I also double checked that my player was using the correct “player” uid and ActionStore is on my player. I did some breakpoints and it looks like inside of ActionStore.cs, the correct information gets passed from CaptureState, but it gets called twice, the first time the correct state is returned and the second time it just passes an empty state so not sure there. Then in the return, two states get loaded as well but both of them are empty states so the foreach never runs. I don’t have any other save/load issues so I assume my SavingSystem.cs is fine, and I haven’t changed ActionStore.cs so not sure what would be causing this.
SavingSystem.cs
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using UnityEngine;
using UnityEngine.SceneManagement;
namespace RPG.Saving
{
public class SavingSystem : MonoBehaviour
{
public IEnumerator LoadLastScene(string saveFile)
{
// Load save file
Dictionary<string, object> state = LoadFile(saveFile);
// Default build index is the active scene
int buildIndex = SceneManager.GetActiveScene().buildIndex;
if (state.ContainsKey("lastSceneBuildIndex"))
{
// If we have access to the last scene then use that instead
buildIndex = (int)state["lastSceneBuildIndex"];
}
// Load the scene
yield return SceneManager.LoadSceneAsync(buildIndex);
RestoreState(state);
}
public void Save(string saveFile)
{
// Get existing or new state, then capture current game state, and save the state to the file
Dictionary<string, object> state = LoadFile(saveFile);
CaptureState(state);
SaveFile(saveFile, state);
}
public void Load(string saveFile)
{
RestoreState(LoadFile(saveFile));
}
private void SaveFile(string saveFile, object state)
{
string path = GetPathFromSaveFile(saveFile);
using (FileStream stream = File.Open(path, FileMode.Create))
{
BinaryFormatter formatter = new BinaryFormatter();
formatter.Serialize(stream, state);
}
}
private Dictionary<string, object> LoadFile(string saveFile)
{
string path = GetPathFromSaveFile(saveFile);
if (!File.Exists(path))
{
return new Dictionary<string, object>();
}
using (FileStream stream = File.Open(path, FileMode.Open))
{
BinaryFormatter formatter = new BinaryFormatter();
return (Dictionary<string, object>)formatter.Deserialize(stream);
}
}
private void CaptureState(Dictionary<string, object> state)
{
foreach (SaveableEntity saveable in FindObjectsOfType<SaveableEntity>())
{
state[saveable.GetUniqueIdentifier()] = saveable.CaptureState();
}
state["lastSceneBuildIndex"] = SceneManager.GetActiveScene().buildIndex;
}
private void RestoreState(Dictionary<string, object> state)
{
foreach (SaveableEntity saveable in FindObjectsOfType<SaveableEntity>())
{
string id = saveable.GetUniqueIdentifier();
if (state.ContainsKey(id))
saveable.RestoreState(state[saveable.GetUniqueIdentifier()]);
}
}
private string GetPathFromSaveFile(string saveFile)
{
return Application.persistentDataPath + "/" + saveFile + ".sav";
}
}
}
ActionStore.cs
using System;
using System.Collections.Generic;
using UnityEngine;
using RPG.Saving;
namespace RPG.Inventories
{
/// <summary>
/// Provides the storage for an action bar. The bar has a finite number of
/// slots that can be filled and actions in the slots can be "used".
///
/// This component should be placed on the GameObject tagged "Player".
/// </summary>
public class ActionStore : MonoBehaviour, ISaveable
{
// STATE
Dictionary<int, DockedItemSlot> dockedItems = new Dictionary<int, DockedItemSlot>();
private class DockedItemSlot
{
public ActionItem item;
public int number;
}
// PUBLIC
/// <summary>
/// Broadcasts when the items in the slots are added/removed.
/// </summary>
public event Action storeUpdated;
/// <summary>
/// Get the action at the given index.
/// </summary>
public ActionItem GetAction(int index)
{
if (dockedItems.ContainsKey(index))
{
return dockedItems[index].item;
}
return null;
}
/// <summary>
/// Get the number of items left at the given index.
/// </summary>
/// <returns>
/// Will return 0 if no item is in the index or the item has
/// been fully consumed.
/// </returns>
public int GetNumber(int index)
{
if (dockedItems.ContainsKey(index))
{
return dockedItems[index].number;
}
return 0;
}
/// <summary>
/// Add an item to the given index.
/// </summary>
/// <param name="item">What item should be added.</param>
/// <param name="index">Where should the item be added.</param>
/// <param name="number">How many items to add.</param>
public void AddAction(InventoryItem item, int index, int number)
{
if (dockedItems.ContainsKey(index))
{
if (object.ReferenceEquals(item, dockedItems[index].item))
{
dockedItems[index].number += number;
}
}
else
{
var slot = new DockedItemSlot();
slot.item = item as ActionItem;
slot.number = number;
dockedItems[index] = slot;
}
if (storeUpdated != null)
{
storeUpdated();
}
}
/// <summary>
/// Use the item at the given slot. If the item is consumable one
/// instance will be destroyed until the item is removed completely.
/// </summary>
/// <param name="user">The character that wants to use this action.</param>
/// <returns>False if the action could not be executed.</returns>
public bool Use(int index, GameObject user)
{
if (dockedItems.ContainsKey(index))
{
dockedItems[index].item.Use(user);
if (dockedItems[index].item.isConsumable())
{
RemoveItems(index, 1);
}
return true;
}
return false;
}
/// <summary>
/// Remove a given number of items from the given slot.
/// </summary>
public void RemoveItems(int index, int number)
{
if (dockedItems.ContainsKey(index))
{
dockedItems[index].number -= number;
if (dockedItems[index].number <= 0)
{
dockedItems.Remove(index);
}
if (storeUpdated != null)
{
storeUpdated();
}
}
}
/// <summary>
/// What is the maximum number of items allowed in this slot.
///
/// This takes into account whether the slot already contains an item
/// and whether it is the same type. Will only accept multiple if the
/// item is consumable.
/// </summary>
/// <returns>Will return int.MaxValue when there is not effective bound.</returns>
public int MaxAcceptable(InventoryItem item, int index)
{
var actionItem = item as ActionItem;
if (!actionItem) return 0;
if (dockedItems.ContainsKey(index) && !object.ReferenceEquals(item, dockedItems[index].item))
{
return 0;
}
if (actionItem.isConsumable())
{
return int.MaxValue;
}
if (dockedItems.ContainsKey(index))
{
return 0;
}
return 1;
}
/// PRIVATE
[System.Serializable]
private struct DockedItemRecord
{
public string itemID;
public int number;
}
object ISaveable.CaptureState()
{
var state = new Dictionary<int, DockedItemRecord>();
foreach (var pair in dockedItems)
{
var record = new DockedItemRecord();
record.itemID = pair.Value.item.GetItemID();
record.number = pair.Value.number;
state[pair.Key] = record;
}
return state;
}
void ISaveable.RestoreState(object state)
{
var stateDict = (Dictionary<int, DockedItemRecord>)state;
foreach (var pair in stateDict)
{
AddAction(InventoryItem.GetFromID(pair.Value.itemID), pair.Key, pair.Value.number);
}
}
}
}
