Fruitomation/Assets/Scripts/Game/UpgradeManager.cs

using System.Runtime.CompilerServices;
using System.Collections.Generic;
using UnityEngine.Scripting;
using UnityEngine;
using System.Linq;
using System.IO;
using System;

#if UNITY_EDITOR
using UnityEditor;
#endif // UNITY_EDITOR

namespace Fruitomation.Game
{
    [Serializable] public enum BasicUpgrade
    {
        Grapes,
        Bananas,
        Kiwi,
        Mangoes,
        Durian,
        BuddhasHand,
        Pitayas,
        
        AppleSlices,
        DriedAppleSlices,
        AppleJuice,
        GrapeJuice,
        Wine,
        Raisins,
        DriedFruitSelection,
        BananaSlices,
        DriedBananaSlices,
        BananaBacon,
        BananaPeeler,
        KiwiPresser,
        KiwiSeedOil,
        KiwiVinegar,
        AppleMangoJuice,
        SlicedKiwi,
        BananaIceCream,
        MangoJuice,
        MangoSlices,
        SpicedBananaIceCream,
        DurianPowder,
        DurianSlices,
        ExoticFruitSelection,
        BuddhasHandSlices,
        PitayaPeeler,
        PitayaFoodDye,
        PitayaIceCream,
        SpicedPitayaIceCream,
        
        Apple
    }

    [Serializable] public enum BuildingUnlock
    {
        None,
        
        //Wall, - Unlocked by default
        //Slope, - Unlocked by default
        [Preserve] Floor,
        
        //Spring, - Unlocked by default
        [Preserve] Fan,
        [Preserve] Alternator,
        
        //Slicer, - Unlocked by default
        //Presser, - Unlocked by default
        [Preserve] HeatExchanger,
        [Preserve] Grinder,
        [Preserve] Mixer,
        [Preserve] Fermenter,
        [Preserve] Peeler,
    }

    [Serializable] public enum AutomationBuildingType
    {
        [Preserve] None,
        [Preserve] Slicer,
        [Preserve] Presser,
        [Preserve] HeatExchanger,
        [Preserve] Grinder,
        [Preserve] Mixer,
        [Preserve] Fermenter,
        [Preserve] Peeler,
        [Preserve] Spawner
    }

    public class UnlockedUpgrades
    {
        [Serializable] public class Serialized
        {
            [SerializeField] private BuildingUnlock[] BuildingUnlocks;
            [SerializeField] private BasicUpgrade[] BasicUpgrades;

            private Serialized()
            {
                // All logic done in Serialize() function
            }

            public UnlockedUpgrades Unserialize()
            {
                UnlockedUpgrades upgrades = new();

                if (BuildingUnlocks is not null)
                {
                    foreach (BuildingUnlock unlock in BuildingUnlocks)
                        upgrades.Buildings.Add(unlock);
                }

                if (BasicUpgrades is not null)
                {
                    foreach (BasicUpgrade upgrade in BasicUpgrades)
                        upgrades.Unlocks.Add(upgrade);
                }

                return upgrades;
            }

            public static Serialized Serialize(UnlockedUpgrades upgrades)
            {
                Serialized serialized = new()
                {
                    BuildingUnlocks = upgrades.Buildings.ToArray(),
                    BasicUpgrades = upgrades.Unlocks.ToArray(),
                };

                return serialized;
            }
        }

        private readonly HashSet<BuildingUnlock> Buildings = new();
        private readonly HashSet<BasicUpgrade> Unlocks = new();
        
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void Unlock(BuildingUnlock unlock) => Buildings.Add(unlock);
        
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public void Unlock(BasicUpgrade upgrade) => Unlocks.Add(upgrade);

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public bool IsUnlocked(BuildingUnlock unlock) => Buildings.Contains(unlock);
        
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public bool IsUnlocked(BasicUpgrade upgrade) => Unlocks.Contains(upgrade);
    }

    public static class UpgradeManager
    {
        private static string Filepath => Path.Combine(Application.persistentDataPath, "upgrades.json");
        private static UnlockedUpgrades CurrentUpgrades;

        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
        private static void LoadSavedUpgrades()
        {
            if (File.Exists(Filepath))
            {
                string json = File.ReadAllText(Filepath);
                UnlockedUpgrades.Serialized serialized = JsonUtility.FromJson<UnlockedUpgrades.Serialized>(json);

                if (serialized is not null)
                {
                    CurrentUpgrades = JsonUtility.FromJson<UnlockedUpgrades.Serialized>(json).Unserialize();
                }
                
                CurrentUpgrades.Unlock(BasicUpgrade.Apple); // Unlocked by default
            }

            CurrentUpgrades ??= new UnlockedUpgrades();

            Application.quitting += SaveUpgradesToDisk;
        }

        private static void SaveUpgradesToDisk()
        {
            UnlockedUpgrades.Serialized serialized = UnlockedUpgrades.Serialized.Serialize(CurrentUpgrades);
            string json = JsonUtility.ToJson(serialized, true);
            File.WriteAllText(Filepath, json);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static void Unlock(BuildingUnlock unlock)
        {
            if (unlock == BuildingUnlock.None)
            {
                throw new ArgumentOutOfRangeException(nameof(unlock));
            }
            
            CurrentUpgrades.Unlock(unlock);
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static void Unlock(BasicUpgrade upgrade) => CurrentUpgrades.Unlock(upgrade);

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool Is(BuildingUnlock unlock) =>
            unlock == BuildingUnlock.None || CurrentUpgrades.IsUnlocked(unlock);

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static bool Is(BasicUpgrade upgrade) => CurrentUpgrades.IsUnlocked(upgrade);
        
#if UNITY_EDITOR
        [MenuItem("Fruitomation/Reset Upgrades")]
#endif // UNITY_EDITOR
        public static void ResetUpgrades()
        {
            CurrentUpgrades = new UnlockedUpgrades();
            CurrentUpgrades.Unlock(BasicUpgrade.Apple); // Always unlocked
        }

#if UNITY_EDITOR
        [MenuItem("Fruitomation/Unlock All Upgrades")]
        public static void UnlockAll()
        {
            BasicUpgrade[] upgrades = Enum.GetValues(typeof(BasicUpgrade)) as BasicUpgrade[];
            System.Diagnostics.Debug.Assert(upgrades != null, nameof(upgrades) + " != null");
            
            foreach (BasicUpgrade upgrade in upgrades)
            {
                Unlock(upgrade);
            }
            
            BuildingUnlock[] unlocks = Enum.GetValues(typeof(BuildingUnlock)) as BuildingUnlock[];
            System.Diagnostics.Debug.Assert(unlocks != null, nameof(unlocks) + " != null");

            foreach (BuildingUnlock unlock in unlocks)
            {
                if (unlock != BuildingUnlock.None)
                    Unlock(unlock);
            }
        }
#endif // UNITY_EDITOR
    }
}