Composition over inheritance

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Composition
{
    class Program
    {
        static void Main(string[] args)
        {
            Particle test = new Particle();
            Console.WriteLine(test.hasInitialVelocity);

            test.AddParticlePropery(Particle.Properties.initialVelocity);
            Console.WriteLine(test.hasInitialVelocity);
            Console.WriteLine(test.initialVelocity);

            test.initialVelocity = 5;
            Console.WriteLine(test.hasInitialVelocity);
            Console.WriteLine(test.initialVelocity);

            Console.ReadLine();


        }
    }

    class SimulationController
    {
        private static float timeTillUpdate = 1.0f;


        public void Update()
        {
            UpdateParticleGraphValues();

            UpdateTimeLabel();
            UpdateVelocity();
            UpdatePosition();



        }

        private void UpdatePosition()
        {
            foreach (Particle particle in Particle.ParticleInstances)
            {
                particle.MyGameObject.transform.position = particle.MyGameObject.transform.position + particle.currentVelocity * deltaT;
            }
        }

        private void UpdateVelocity()
        {
            foreach (Particle particle in Particle.ParticleInstances)
            {
                Vector3 acceleration = GetAccelleration(particle);
                particle.currentVelocity = particle.currentVelocity + acceleration * deltaT;
            }
        }

        private Vector3 GetAccelleration(Particle particle)
        {
            Vector3 accelerationCounter = Vector3.zero;
            if (particle.hasGravity && particle.hasMass)
            {
                accelerationCounter = GetAccellerationGravity(particle);
            }
            if (particle.hasAcceleration)
            {
                accelerationCounter += particle.acceleration;
            }
            return accelerationCounter;
        }

        private void GetAccellerationGravity(Particle particle)
        {
            Vector3 sum = Vector3.zero;
            Vector3 positionDelta = Vector3.zero;
            foreach (Particle planet in Particle.ParticleInstances)
            {
                if (planet.hasGravity && planet.hasMass)
                {
                    positionDelta = planet.MyGameObject.transform.position - particle.MyGameObject.transform.position;
                    //Cannot divide by 0
                    if (positionDelta != Vector3.zero)
                    {
                        sum += planet.mass * positionDelta / Mathf.Pow(MyMaths.Vector_Magnitude(positionDelta), 3);
                    }
                }

            }
            return G * sum;
        }

        private void UpdateParticleGraphValues()
        {
            //Only updates every X seconds
            if (timeTillUpdate <= 0)
            {
                //Updates the points stored for every planet created
                UpdateGraphValues();
                //Index of particle user has selected for graphing
                int index = Gravity_InputController.Instance.DropBoxGraphTarget.value;
                //Updating graphs
                Gravity_InputController.Instance.GraphAcceleration.GetComponent<GraphMaker>().CreateGraph(GravityPlanets.PlanetInstances[index].graphPointsAcceleration);
                Gravity_InputController.Instance.GraphSpeed.GetComponent<GraphMaker>().CreateGraph(GravityPlanets.PlanetInstances[index].graphPointsSpeed);

                timeTillUpdate = timePerUpdate;
            }
            else
            {
                timeTillUpdate -= Time.deltaTime;
            }
        }

        //Updates the values of points to plot for every planet
        private void UpdateGraphValues()
        {
            foreach (Particle particle in Particle.ParticleInstances)
            {
                if (particle.hasGraphingValuesAcceleration)
                {
                    UpdateGraphValuesAcceleration(particle);
                }
                if (particle.hasGraphingValuesSpeed)
                {
                    UpdateGraphValuesSpeed(particle);
                }
                if (particle.hasGraphingValuesMomentumX)
                {
                    UpdateGraphValuesMomentumX(particle);
                }
                if (particle.hasGraphingValuesMomentumY)
                {
                    UpdateGraphValuesMomentumY(particle);
                }

            }
        }

        private void UpdateGraphValuesMomentumY(Particle particle)
        {
            particle.graphingValuesMomentumY.Add(new Vector2(
                simulationTime,
                particle.mass * particle.currentVelocity.y));
        }

        private void UpdateGraphValuesMomentumX(Particle particle)
        {
            particle.graphingValuesMomentumX.Add(new Vector2(
            simulationTime,
            particle.mass * particle.currentVelocity.x));
        }

        private void UpdateGraphValuesSpeed(Particle particle)
        {
            particle.graphingValuesSpeed.Add(new Vector2(simulationTime, particle.currentVelocity.magnitude));
        }

        private void UpdateGraphValuesAcceleration(Particle particle)
        {
            particle.graphingValuesAcceleration.Add(new Vector2(simulationTime, GetAccelleration(particle).magnitude));
        }
    }




    class Particle
    {
        public static List<Particle> ParticleInstances = new List<Particle>();

        public enum Properties
        {
            MyGameObject,
            ParticlePrefabs,
            ParticleSprites,
            displacement,
            initialVelocity,
            currentVelocity,
            acceleration,
            motionTime,
            initialPosition,
            key,
            numberOfInputs,
            invalidInput,
            diameter,
            restitution,
            mass,
            gravity,
            collisions,
            graphingValuesSpeed,
            graphingValuesAcceleration,
            graphingValuesMomentumX,
            graphingValuesMomentumY,
        }

        public void AddParticlePropery(Properties propertyType)
        {
            ObjectProperties[propertyType] = null;
        }


        public Dictionary<Properties, object> ObjectProperties = new Dictionary<Properties, object>();

        public bool hasMyGameObject => ObjectProperties.ContainsKey(Properties.MyGameObject);
        public bool hasParticlePrefabs => ObjectProperties.ContainsKey(Properties.ParticlePrefabs);
        public bool hasParticleSprites => ObjectProperties.ContainsKey(Properties.ParticleSprites);

        public bool hasDisplacement => ObjectProperties.ContainsKey(Properties.displacement);
        public bool hasInitialVelocity => ObjectProperties.ContainsKey(Properties.initialVelocity);
        public bool hasCurrentVelocity => ObjectProperties.ContainsKey(Properties.currentVelocity);
        public bool hasAcceleration => ObjectProperties.ContainsKey(Properties.acceleration);
        public bool hasMotionTime => ObjectProperties.ContainsKey(Properties.motionTime);

        public bool hasKey => ObjectProperties.ContainsKey(Properties.key);
        public bool hasNumberOfInputs => ObjectProperties.ContainsKey(Properties.numberOfInputs);
        public bool hasInvalidInput => ObjectProperties.ContainsKey(Properties.invalidInput);

        public bool hasDiameter => ObjectProperties.ContainsKey(Properties.diameter);
        public bool hasRestitution => ObjectProperties.ContainsKey(Properties.restitution);
        public bool hasMass => ObjectProperties.ContainsKey(Properties.mass);
        public bool hasInitialPosition => ObjectProperties.ContainsKey(Properties.initialPosition);

        public bool hasGraphingValuesSpeed => ObjectProperties.ContainsKey(Properties.graphingValuesSpeed);
        public bool hasGraphingValuesAcceleration => ObjectProperties.ContainsKey(Properties.graphingValuesAcceleration);
        public bool hasGraphingValuesMomentumX => ObjectProperties.ContainsKey(Properties.graphingValuesMomentumX);
        public bool hasGraphingValuesMomentumY => ObjectProperties.ContainsKey(Properties.graphingValuesMomentumY);

        public bool hasGravity => ObjectProperties.ContainsKey(Properties.gravity);
        public bool hasCollisions => ObjectProperties.ContainsKey(Properties.collisions);


        public float initialVelocity
        {
            get
            {
                if (hasInitialVelocity)
                {
                    return (float)ObjectProperties[Properties.initialVelocity];
                }
                else { throw new NotSupportedException("This particle has no initial Velocity"); }
            }
            set
            {
                if (hasInitialVelocity)
                {
                    ObjectProperties[Properties.initialVelocity] = value;
                }
                else { throw new NotSupportedException("This particle has no initial Velocity"); }
            }
        }

        public GameObject MyGameObject
        {
            get
            {
                if (hasMyGameObject)
                {
                    return ObjectProperties[Properties.MyGameObject];
                }
                else { throw new NotSupportedException("This particle has no Gameobject"); }
            }
            set
            {
                if (hasMyGameObject)
                {
                    ObjectProperties[Properties.MyGameObject] = value;
                }
                else { throw new NotSupportedException("This particle has no Gameobject"); }
            }
        }

        public List<GameObject> ParticlePrefabs
        {
            get
            {
                if (hasMyGameObject)
                {
                    return (float)ObjectProperties[Properties.MyGameObject];
                }
                else { throw new NotSupportedException("This particle has no Gameobject"); }
            }
            set
            {
                if (hasMyGameObject)
                {
                    ObjectProperties[Properties.MyGameObject] = value;
                }
                else { throw new NotSupportedException("This particle has no Gameobject"); }
            }
        }


    }
}