Movement/Config/MovementDefinitionFactory.cs

using System.Collections.Generic;
using UnityEngine;

namespace Syntriax.Modules.Movement.Config
{
    /// <summary>
    /// The Singleton factory responsible for loading and applying <see cref="MovementDefinition"/>s,
    /// </summary>
    /// <remarks>
    /// <para> Looks for the path specified in the variable <see cref="ResourceDirectoryToDefinitions"/></para>
    /// <para> The default path is "Resources/Modules/Syntriax/Movement/Definitions/"</para>
    /// </remarks>
    public class MovementDefinitionFactory : MonoBehaviour
    {
        private const string Name = "Movement Definition Factory";
        private const int InitialCapacity = 64;
        private const string ResourceDirectoryToDefinitions = "Modules/Syntriax/Movement/Definitions/";

        private static MovementDefinitionFactory _instance = null;
        public static MovementDefinitionFactory Instance
        {
            get
            {
                if (_instance == null)
                    _instance = new GameObject(Name).AddComponent<MovementDefinitionFactory>();

                return _instance;
            }
        }

        private Dictionary<string, MovementDefinition> _definitions = null;
        public Dictionary<string, MovementDefinition> Definitions
        {
            get
            {
                if (_definitions == null)
                    Initialize();

                return _definitions;
            }
        }

        private void Start()
        {
            if (_instance == this)
                return;

            Destroy(this);
        }

        /// <summary>
        /// Initializes the factory, if already initialized reinitializes
        /// </summary>
        /// <remarks>
        /// <para> Automatically loads the definition files specificed path <see cref="ResourceDirectoryToDefinitions"/></para>
        /// <para> The default is "Resources/Modules/Syntriax/Movement/Definitions/"</para>
        /// </remarks>
        public void Initialize()
        {
            if (_definitions == null)
                _definitions = new Dictionary<string, MovementDefinition>(InitialCapacity);

            Reset();

            foreach (TextAsset definitionTextAsset in UnityEngine.Resources.LoadAll<TextAsset>(ResourceDirectoryToDefinitions))
                AddToFactoryWithJSON(definitionTextAsset.text);
        }

        /// <summary>
        /// Manually registers a <see cref="MovementDefinition"/> to the factory with a JSON <see cref="string"/>
        /// </summary>
        /// <param name="definitionJSONText">A <see cref="string"/> of a <see cref="MovementDefinition"/> in JSON</param>
        public void AddToFactoryWithJSON(string definitionJSONText)
        {
            MovementDefinition movementDefinition = JsonUtility.FromJson<MovementDefinition>(definitionJSONText);
            AddDefinitionToFactory(movementDefinition);
        }

        /// <summary>
        /// Clears all the definitions in the factory
        /// </summary>
        /// <remarks>
        /// Does not reinitialize, please call <see cref="Initialize"/> to initialize it back
        /// </remarks>
        public void Reset() => _definitions?.Clear();

        /// <summary>
        /// Registers a list of <see cref="MovementDefinition"/>s to the factory
        /// </summary>
        public void AddDefinitionsToFactory(List<MovementDefinition> movementDefinitions)
        {
            foreach (MovementDefinition movementDefinition in movementDefinitions)
                AddDefinitionToFactory(movementDefinition);
        }

        /// <summary>
        /// Registers a single <see cref="MovementDefinition"/> to the factory
        /// </summary>
        public void AddDefinitionToFactory(MovementDefinition movementDefinition)
        {
            if (Definitions.ContainsKey(movementDefinition.Name))
                throw new System.ArgumentException($"{movementDefinition.Name} is already in the Movement Definition Factory");

            Definitions.Add(movementDefinition.Name, movementDefinition);
        }

        /// <summary>
        /// Searches for the <see cref="MovementDefinition"/> in the factory and applies it to the <see cref="GameObject"/>
        /// </summary>
        /// <param name="gameObject"><see cref="GameObject"/> that the <see cref="MovementDefinition"/> will be applied to</param>
        /// <param name="definitionName">The registered <see cref="MovementDefinition"/>'s name that will be applied to the provided <see cref="GameObject"/></param>
        /// <exception cref="System.ArgumentException">When the provided <see cref="MovementDefinition"/> name is not registered in the factory</exception>
        public void ApplyDefinitionToGameObject(GameObject gameObject, string definitionName)
        {
            if (!Definitions.ContainsKey(definitionName))
                throw new System.ArgumentException($"The definition with name \"{definitionName}\" does not exists in the current {Name}");

            ApplyDefinitionToGameObject(gameObject, Definitions[definitionName]);
        }

        /// <summary>
        /// Applies the provided <see cref="MovementDefinition"/> to the <see cref="GameObject"/>
        /// </summary>
        /// <param name="gameObject"><see cref="GameObject"/> that the <see cref="MovementDefinition"/> will be applied to</param>
        /// <param name="definition">The <see cref="MovementDefinition"/> that will be applied to the provided <see cref="GameObject"/></param>
        public void ApplyDefinitionToGameObject(GameObject gameObject, MovementDefinition definition)
        {
            foreach (MovementConfig movementConfig in definition.MovementConfigs)
            {
                IMovement movement = (IMovement)MovementFactory.Instance.AddToGameObject(gameObject, movementConfig.TypeName);
                movement.BaseSpeed = movementConfig.BaseSpeed;
            }

            if (definition.MonoBehaviours != null)
                foreach (string monoBehaviours in definition.MonoBehaviours)
                    MovementFactory.Instance.AddToGameObject(gameObject, monoBehaviours);
        }

#if UNITY_EDITOR
        public void SaveMovementDefinition(MovementDefinition definition)
        {
            string jsonText = JsonUtility.ToJson(definition, true);
            string path = $"Assets/Resources/{ResourceDirectoryToDefinitions}{definition.Name}.json";
            System.IO.File.WriteAllText(path, jsonText);
        }
#endif
    }
}