Pixel Crushers Forum

Code: Select all

namespace PixelCrushers
{
    public class ShumaPickupSaver : Saver
    {
        [Serializable]
        public class Data
        {
            public PickupSpawner pickup;
            public Vector3 position;
            public InventoryItem item;
            public int number;
            public bool boolPickupPickedUp;
            public bool boolInstanciated;
        }

        public override string RecordData()
        {
            /// This method should return a string that represents the data you want to save.
            /// You can use SaveSystem.Serialize() to serialize a serializable object to a 
            /// string. This will use the serializer component on the Save System GameObject,
            /// which defaults to Unity's built-in JSON serialization. Remember that Unity
            /// cannot directly serialize lists or arrays, so you must put them inside a
            /// class.
            /// 
            /// If you use a class to hold the data, use SaveSystem.Serialize to return a 
            /// serialized version:
            ///

            Data data = new Data();
            data.pickup = GetComponent<PickupSpawner>();
            data.boolPickupPickedUp = GetComponent<PickupSpawner>().boolPickupPickedUp;
            data.item = GetComponent<PickupSpawner>().item;
            data.number = GetComponent<PickupSpawner>().number;
            data.boolInstanciated = GetComponent<PickupSpawner>().boolPickupInstanciated;
            return SaveSystem.Serialize(data);

            //return string.Empty;
        }

        public override void ApplyData(string s)
        {
            /// This method should process the string representation of saved data and apply
            /// it to the current state of the game. You can use SaveSystem.Deserialize()
            /// to deserialize the string to an object that specifies the state to apply to
            /// the game.
            /// 

            if (string.IsNullOrEmpty(s)) return; // No data to apply.
            Data data = SaveSystem.Deserialize<Data>(s);
            if (data == null) return; // Serialized string isn't valid.

            if (data.boolInstanciated)
            {
                GetComponent<PickupSpawner>().item = data.item;
                GetComponent<PickupSpawner>().number = data.number;
            }
            if (data.boolPickupPickedUp)
            {
                GetComponent<PickupSpawner>().boolPickupPickedUp = true;
                if (GetComponent<PickupSpawner>().boolPickupSpawned == false)
                {
                    GetComponent<PickupSpawner>().SpawnPickup();
                }
                GetComponent<PickupSpawner>().DestroyPickup();
            }
            else if (GetComponent<PickupSpawner>().boolPickupSpawned == false)
            {
                GetComponent<PickupSpawner>().SpawnPickup();
            }
        }

Code: Select all

{
            "key": "Pickup Spawner (03)ShumaPickupSaver",
            "sceneIndex": -1,
            "data": "{\n    \"pickup\": {\n        \"instanceID\": 221492\n    },\n    \"position\": {\n        \"x\": 0.0,\n        \"y\": 0.0,\n        \"z\": 0.0\n    },\n    \"item\": {\n        \"instanceID\": 30458\n    },\n    \"number\": 12,\n    \"boolPickupPickedUp\": false,\n    \"boolInstanciated\": false\n}"
        },

Code: Select all

using UnityEngine;
using GameDevTV.Saving;

namespace GameDevTV.Inventories
{
    /// <summary>
    /// Spawns pickups that should exist on first load in a level. This
    /// automatically spawns the correct prefab for a given inventory item.
    /// </summary>
    public class PickupSpawner : MonoBehaviour, ISaveable
    {
        // CONFIG DATA
        [SerializeField] public InventoryItem item = null;
        [SerializeField] public int number = 1;

        public bool boolPickupSpawned = false;
        public bool boolPickupPickedUp = false;
        public bool boolPickupInstanciated = false;

        // LIFECYCLE METHODS
        private void Awake()
        {
            // Spawn in Awake so can be destroyed by save system after.
            if (item != null)
            {
                if (boolPickupPickedUp == false)
                SpawnPickup();
            }
        }

        // PUBLIC

        /// <summary>
        /// Returns the pickup spawned by this class if it exists.
        /// </summary>
        /// <returns>Returns null if the pickup has been collected.</returns>
        public Pickup GetPickup() 
        { 
            return GetComponentInChildren<Pickup>();
        }

        /// <summary>
        /// True if the pickup was collected.
        /// </summary>
        public bool isCollected() 
        { 
            return GetPickup() == null;
        }

        //PRIVATE

        public void RestorePickup()
        {

        }

        public void SpawnPickup()
        {
            if (boolPickupSpawned == false)
            {
                var spawnedPickup = item.SpawnPickup(transform.position, number);
                spawnedPickup.transform.SetParent(transform);
                boolPickupSpawned = true;
            }
        }

        public void DestroyPickup()
        {
            var pickup = GetPickup();
            if (pickup)
            {
                pickup.transform.SetParent(null);
                Destroy(pickup.gameObject);
            }
        }

        object ISaveable.CaptureState()
        {
            return isCollected();
        }

        void ISaveable.RestoreState(object state)
        {
            bool shouldBeCollected = (bool)state;

            if (shouldBeCollected && !isCollected())
            {
                DestroyPickup();
            }

            if (!shouldBeCollected && isCollected())
            {
                SpawnPickup();
            }
        }
    }
}

Code: Select all

using System;
using System.Collections.Generic;
using UnityEngine;
using static GameDevTV.Inventories.Equipment;

namespace GameDevTV.Inventories
{
    /// <summary>
    /// A ScriptableObject that represents any item that can be put in an
    /// inventory.
    /// </summary>
    /// <remarks>
    /// In practice, you are likely to use a subclass such as `ActionItem` or
    /// `EquipableItem`.
    /// </remarks>
    public abstract class InventoryItem : ScriptableObject, ISerializationCallbackReceiver
    {
        // CONFIG DATA
        [Tooltip("Auto-generated UUID for saving/loading. Clear this field if you want to generate a new one.")]
        [SerializeField] string itemID = null;
        [Tooltip("Item name to be displayed in UI.")]
        [SerializeField] string displayName = null;
        [Tooltip("Item description to be displayed in UI.")]
        [SerializeField][TextArea] string description = null;
        [Tooltip("The UI icon to represent this item in the inventory.")]
        [SerializeField] Sprite icon = null;
        [Tooltip("The prefab that should be spawned when this item is dropped.")]
        [SerializeField] Pickup pickup = null;
        [Tooltip("If true, multiple items of this type can be stacked in the same inventory slot.")]
        [SerializeField] bool stackable = false;

        [Tooltip("WWise Audio Pickup Clip Name.")]
        [SerializeField] string WWisePickupClip = "";

        [SerializeField] ItemCategory category;

        // STATE
        static Dictionary<string, InventoryItem> itemLookupCache;

        // PUBLIC

        public ItemCategory GetCategory() => category;

        /// <summary>
        /// Get the inventory item instance from its UUID.
        /// </summary>
        /// <param name="itemID">
        /// String UUID that persists between game instances.
        /// </param>
        /// <returns>
        /// Inventory item instance corresponding to the ID.
        /// </returns>
        public static InventoryItem GetFromID(string itemID)
        {
            if (itemLookupCache == null)
            {
                itemLookupCache = new Dictionary<string, InventoryItem>();
                var itemList = Resources.LoadAll<InventoryItem>("");
                foreach (var item in itemList)
                {
                    if (itemLookupCache.ContainsKey(item.itemID))
                    {
                        Debug.LogError(string.Format("Looks like there's a duplicate GameDevTV.UI.InventorySystem ID for objects: {0} and {1}", itemLookupCache[item.itemID], item));
                        continue;
                    }

                    itemLookupCache[item.itemID] = item;
                }
            }

            if (itemID == null || !itemLookupCache.ContainsKey(itemID)) return null;
            return itemLookupCache[itemID];
        }

        /// <summary>
        /// Spawn the pickup gameobject into the world.
        /// </summary>
        /// <param name="position">Where to spawn the pickup.</param>
        /// <param name="number">How many instances of the item does the pickup represent.</param>
        /// <returns>Reference to the pickup object spawned.</returns>
        public Pickup SpawnPickup(Vector3 position, int number)
        {
            var pickup = Instantiate(this.pickup);
            pickup.transform.position = position;
            pickup.Setup(this, number);
            return pickup;
        }

        public Sprite GetIcon()
        {
            return icon;
        }

        public string GetItemID()
        {
            return itemID;
        }

        public bool IsStackable()
        {
            return stackable;
        }
        
        public string GetDisplayName()
        {
            return displayName;
        }

        public string GetDescription()
        {
            return description;
        }

        public string GetWWiseString()
        {
            return WWisePickupClip;
        }

        // PRIVATE
        
        void ISerializationCallbackReceiver.OnBeforeSerialize()
        {
            // Generate and save a new UUID if this is blank.
            if (string.IsNullOrWhiteSpace(itemID))
            {
                itemID = System.Guid.NewGuid().ToString();
            }
        }

        void ISerializationCallbackReceiver.OnAfterDeserialize()
        {
            // Require by the ISerializationCallbackReceiver but we don't need
            // to do anything with it.
        }
    }
}

Code: Select all

using UnityEngine;

namespace GameDevTV.Inventories
{
    /// <summary>
    /// To be placed at the root of a Pickup prefab. Contains the data about the
    /// pickup such as the type of item and the number.
    /// </summary>
    public class Pickup : MonoBehaviour
    {
        // STATE
        InventoryItem item;
        int number = 1;

        // CACHED REFERENCE
        Inventory inventory;

        // LIFECYCLE METHODS
        GameObject player;

        private void Start()
        {
            RefreshReferences();
        }

        void RefreshReferences()
        {
            if (player == null)
            {
                player = GameObject.FindWithTag("MainUniqueController");
            }
            if (inventory == null)
            {
                inventory = player.GetComponent<Inventory>();
            }
            if (item == null)
            {
                //TODO : find a way to get the number from the 
                Setup(this.item, 1);
            }
        }

        // PUBLIC

        /// <summary>
        /// Set the vital data after creating the prefab.
        /// </summary>
        /// <param name="item">The type of item this prefab represents.</param>
        /// <param name="number">The number of items represented.</param>
        public void Setup(InventoryItem item, int number)
        {
            this.item = item;
            if (!item.IsStackable())
            {
                number = 1;
            }
            this.number = number;
        }

        public InventoryItem GetItem()
        {
            RefreshReferences();
            return item;
        }

        public int GetNumber()
        {
            RefreshReferences();
            return number;
        }

        public void PickupItem()
        {
            bool foundSlot = inventory.AddToFirstEmptySlot(item, number);
            if (foundSlot)
            {
                WWiseAudioPlayer.WS.PlaySFXPickup(item.GetWWiseString());
                Destroy(gameObject);
                if (transform.parent.childCount > 1)
                {
                    GameObject particle = transform.parent.GetChild(1).gameObject;
                    Destroy(particle);
                }
            }
        }

        public bool CanBePickedUp()
        {
            RefreshReferences();
            return inventory.HasSpaceFor(item);
        }
    }
}

Code: Select all

[Serializable]
public class Data
{
    public Vector3 position;
    public string itemID;
    public int number;
    public bool boolPickupPickedUp;
    public bool boolInstanciated;
}

Code: Select all

Data data = new Data();
PickupSpawner pickup = GetComponent<PickupSpawner>(); // Call GetComponent once and cache value.
data.boolPickupPickedUp = pickup.boolPickupPickedUp;
data.itemID = (pickup.item != null) ? pickup.item.itemID : null;
data.number = pickup.number;
data.boolInstanciated = pickup.boolPickupInstanciated;
return SaveSystem.Serialize(data);

Code: Select all

if (string.IsNullOrEmpty(s)) return; // No data to apply.
Data data = SaveSystem.Deserialize<Data>(s);
if (data == null) return; // Serialized string isn't valid.

PickupSpawner pickup = GetComponent<PickupSpawner>(); // Call GetComponent once and cache value.

if (data.boolInstanciated)
{
    pickup.item = GetItemFromID(data.itemID);
    pickup.number = data.number;
}
if (data.boolPickupPickedUp)
{
    pickup.boolPickupPickedUp = true;
    if (pickup.boolPickupSpawned == false)
    {
        pickup.SpawnPickup();
    }
    pickup.DestroyPickup();
}
else if (pickup.boolPickupSpawned == false)
{
    pickup.SpawnPickup();
}