//---------------------------------------------------------------------------------------------------------------------------------------------------
// <copyright file="GameObject.cs" company="DarkWynter Studios">
//     Copyright (C)2007 DarkWynter Studios.  All rights reserved.
// </copyright>
//---------------------------------------------------------------------------------------------------------------------------------------------------
// {Contact : darkwynter.com for licensing information
//---------------------------------------------------------------------------------------------------------------------------------------------------

namespace DarkWynter.Engine.GameObjects
{
    #region Using Statements
    using System;
    using System.Collections.Generic;
    using Microsoft.Xna.Framework;
    using Microsoft.Xna.Framework.Graphics;
    using System.Xml;
    using Xclna.Xna.Animation.Content;
    using Xclna.Xna.Animation;

    using Physics;
    using Globals;
    using ObjectLib;
    using DarkWynter.Engine.Init;
    using DarkWynter.Stream;
    using DarkWynter.Engine.Audio;
    #endregion

    /// <summary>
    /// Methods of GameObject follow the GameFlow pattern to ensure quick and efficient loading and unloading procedures.
    /// Additional properties are included in GameObject and are used by Renderer and Update to manipulate the GameObject.
    /// Each object specifies its draw and update procedures internally and is passed to Physics for in game motion and rotation.
    /// </summary>
    public class GameObject
    {
        #region GameObject Interface Properties
        private Mass _mass;
        //private XmlNode _xml;
        private Load _load;

        private string _objectModelName;
        private bool _isCollectable;
        private bool _isKey;
        private Draw _draw;
        private Draw _drawBoundingVolume;
        private Draw _drawAIVision;



        /// <summary>
        /// Draw object
        /// </summary>
        public Draw draw { get { return _draw; } set { _draw = value; } }/// <summary>
        /// Draw object's bounding volume
        /// </summary>
        public Draw drawBoundingVolume { get { return _drawBoundingVolume; } set { _drawBoundingVolume = value; } }
        /// <summary>
        /// AI Vision Draw object
        /// </summary>
        public Draw drawAIVision { get { return _drawAIVision; } set { _drawAIVision = value; } }

        /// <summary>
        /// Mass object, handles physics of GameObject.
        /// </summary>
        public Mass mass { get { return _mass; } set { _mass = value; } }
        ///// <summary>
        ///// Xml data associated with this object.
        ///// </summary>
        //public XmlNode xml { get { return _xml; } set { _xml = value; } }
        /// <summary>
        /// Draw object
        /// </summary>
        public Load load { get { return _load; } set { _load = value; } }

        /// <summary>
        /// Text identifier for model name.
        /// </summary>
        public string objectModelName { get { return _objectModelName; } set { _objectModelName = value; } }
        /// <summary>
        /// Defines if this object is collectable by players.
        /// </summary>
        public bool isCollectable { get { return _isCollectable; } set { _isCollectable = value; } }
        /// <summary>
        /// Defines if this object is a Key object collected to pass the level.
        /// </summary>
        public bool isKey { get { return _isKey; } set { _isKey = value; } }


        /// <summary>
        /// Difference between object height and terrain at it's x/z location.
        /// HeightDifference is positive when object is below the terrain.
        /// </summary>
        public float heightDifference;
        /// <summary>
        /// Terrain height at object's x/z location.
        /// </summary>
        public float localTerrainHeight;

        /// <summary>
        /// Defines what kind of collision response this GameObject should have.
        /// </summary>
        public Enums_Engine.CollisionResponses collisionWithPlayerResponse = Enums_Engine.CollisionResponses.NONE;

        /// <summary>
        /// Defines the scale of damage or health an object bestows.
        /// </summary>
        public float collisionMultiplier = 0.001f;

        /// <summary>
        /// Game Object animated or not
        /// </summary>
        public bool modelAnimated;

        // Animation
        /// <summary>
        /// Model animator
        /// </summary>
        public ModelAnimator animator;
        /// <summary>
        /// Idle animation
        /// </summary>
        public AnimationController idle;
        /// <summary>
        /// Walk animation
        /// </summary>
        public AnimationController walk;
        /// <summary>
        /// Die animation
        /// </summary>
        public AnimationController die;
        /// <summary>
        /// Animation currently running
        /// </summary>
        public AnimationController currentAnimation;

        /// <summary>
        /// 3D Cue used with jump sound.
        /// </summary>
        public Cue3D jump;


        /// <summary>
        /// Index to the game controller associated with this object
        /// </summary>
        public int controllerIndex;
        #endregion

        #region Physics Properties
        /// <summary>
        /// Used to pass static instance data to shader (for static objects)
        /// </summary>
        public VertexFogBinormalTangentDepth staticObjectValues;

        /// <summary>
        /// Tangential component of force calculations.
        /// </summary>
        public Vector3 tangentialComponent = new Vector3();
        /// <summary>
        /// Normal component of force calculations.
        /// </summary>
        public Vector3 normalComponent = new Vector3();

        /// <summary>
        /// Used in collision; surface normal calculation.
        /// </summary>
        public Vector3 surfaceNormal;
        /// <summary>
        /// Used in collision; gravity normal calculation.
        /// </summary>
        public Vector3 gravityNormalComponent;
        /// <summary>
        /// Used in collision; tangential gravity-force calculation.
        /// </summary>
        public Vector3 gravityTangentialComponent;
        /// <summary>
        /// Used in collision; normal velocity-force calculation.
        /// </summary>
        public Vector3 velocityNormalComponent;
        /// <summary>
        /// Used in collision; tangential velocity-force calculation.
        /// </summary>
        public Vector3 velocityTangentialComponent;
        /// <summary>
        /// Used in collision; normal totalForce calculation.
        /// </summary>
        public Vector3 totalForceNormalComponent;
        /// <summary>
        /// Used in collision; tangential totalForce calculation.
        /// </summary>
        public Vector3 totalForceTangentialComponent;
        /// <summary>
        /// Used in collision; combined velocity and totalForce normal calculation.
        /// </summary>
        public Vector3 combinedNormalForce;
        /// <summary>
        /// Used in collision; combined velocity and totalForce tangential calculation.
        /// </summary>
        public Vector3 combinedTangentialForce;

        #endregion

        #region Xml Interface

        private string _type;
        public string type { get { return _type; } set { _type = value; } }

        private string _id;
        public string id { get { return _id; } set { _id = value; } }

        private string _typeID;
        public string typeID { get { return _typeID; } set { _typeID = value; } }

        private string _name;
        public string name { get { return _name; } set { _name = value; } }


        /// <summary>
        /// Defines the coordinate system the object is working in.
        /// </summary>
        public enum GridType { unit, coord, tile };
        private GridType _grid;
        public GridType grid
        {
            get
            {
                return _grid;
            }
            set
            {
                _grid = value;
            }
        }
        
        private string _x;
        private string _z;
        public string x 
        { 
            get 
            {
 
                return mass.currentPosition.X.ToString(); 
            } 
            set 
            {
                _x = value;
                float Y_height = 
                    DarkWynterEngine.objectLibrary.terrain.GetTerrainHeight(
                    float.Parse(value) / Statics_Engine.TerrainSettings.terrainScaleFactor,
                    mass.currentPosition.Z / Statics_Engine.TerrainSettings.terrainScaleFactor);


                mass.SetPosition(
                    new Vector3(float.Parse(value), Y_height, mass.currentPosition.Z),
                    new Vector3(float.Parse(value), Y_height, mass.currentPosition.Z - 1.0f));
            } 
        }
        public string z 
        { 
            get 
            { 
                return mass.currentPosition.Z.ToString(); 
            } 
            set 
            { 
                _z = value;
                float Y_height = 
                    DarkWynterEngine.objectLibrary.terrain.GetTerrainHeight(
                    mass.currentPosition.X / Statics_Engine.TerrainSettings.terrainScaleFactor,
                    float.Parse(value) / Statics_Engine.TerrainSettings.terrainScaleFactor);

                mass.SetPosition(
                    new Vector3(mass.currentPosition.X, Y_height, float.Parse(value)),
                    new Vector3(mass.currentPosition.X, Y_height, float.Parse(value) - 1.0f));
            } 
        }

        private string _maxScale;
        public string maxScale 
        { 
            get 
            { 
                return mass.scale.X.ToString(); 
            } 
            set 
            { 
                mass.scale = new Vector3(float.Parse(value)); 
            } 
        }

        private string _animated;
        public string animated 
        { 
            get 
            {
                if (_animated == "Yes") {return "Yes";}
                else {return "No";}
            }     
            set 
            {
                if (_animated == "Yes"){modelAnimated = true;}
                else{modelAnimated = false;}

            } 
        }

        private string _model;
        public string model 
        { 
            get 
            { 
                return _model; 
            } 
            set 
            { 
                _model = value;
                draw.model = Statics_Engine.SystemSettings.content.Load<Model>(this.model);
                foreach (ModelMesh mesh in draw.model.Meshes)
                {
                    for (int i = 0; i < mesh.MeshParts.Count; i++)
                    {
                        ModelMeshPart part = mesh.MeshParts[i];

                        part.Effect = ShaderParameters.DrawFX.effect;//ShaderParameters.DrawFX.effect.Clone(Statics.SystemSettings.graphics.GraphicsDevice);
                    }
                }

            } 
        }

        private string _texture;
        public string texture 
        { 
            get 
            { 
                if(_texture != null)
                    return _texture; 
                else
                    return "Content\\_textures\\"; 
            } 
            set 
            { 
                _texture = value;
                if (draw.textureList.Count > 0)
                    draw.textureList[0] = Statics_Engine.SystemSettings.content.Load<Texture2D>(value);
                else
                    draw.textureList.Add(Statics_Engine.SystemSettings.content.Load<Texture2D>(value));
            } 
        }

        private string _bumpTexture;
        public string bumpTexture 
        {
            get 
            {
                if (_bumpTexture != null)
                    return _bumpTexture;
                else
                    return "Content\\_textures\\";
            } 
            set 
            { 
                _bumpTexture = value;
                if (draw.textureList.Count > 1)
                    draw.textureList[1] = Statics_Engine.SystemSettings.content.Load<Texture2D>(value);
                else
                    draw.textureList.Add(Statics_Engine.SystemSettings.content.Load<Texture2D>(value));
            } 
        }

        #endregion

        #region Methods

        public GameObject()
        {
            mass = new Mass();
            mass.gameObjectPointer = this;
        }

        /// <summary>
        /// Game object constructor.
        /// Gets a pre-initialized mass object from the Statics.LevelSettings.darkMatter list.
        /// </summary>
        public GameObject(Load gameObjectLoader)
        {
            load = gameObjectLoader;

            //mass = Statics_Engine.LevelSettings.darkMatter[Statics_Engine.LevelSettings.darkMatterIterator++];
            mass = new Mass();
            mass.gameObjectPointer = this;

            //drawAIVision = new Draw();
        }

        /// <summary>
        /// Load object data from Xml.
        /// </summary>
        /// <param name="objectLibrary">ObjectLibrary that this object belongs to.</param>
        public virtual bool Load(ObjectLibrary objectLibrary)
        {
            return load.Load_Default(objectLibrary, this, false);

            #region Old Code
            //// Set up Model Manager
            //if (!LoadModel(load.node))
            //{
            //    return false;
            //}

            //// Get the Location Map
            //Texture2D locationMap = Statics_Engine.SystemSettings.content.Load<Texture2D>(node.Attributes["locationMap"].Value);
            //int length = locationMap.Width * locationMap.Width;
            //Color[] locationColorValues = new Color[length];
            //locationMap.GetData<Color>(locationColorValues);
            //Random rand = new Random();

            //// Precalculate the vertexmap/locationmap ratio for use in the for loop below
            //float vertexmapToObjectmapRelationship = Statics_Engine.TerrainSettings.vertexMapSize / locationMap.Width;

            //// Create a ruler 1 terrain mod long (distance between verticies
            //float terrainModWidth = Statics_Engine.TerrainSettings.terrainScaleFactor * vertexmapToObjectmapRelationship;

            //// Get the color value of the node
            //int mapColorR = int.Parse(node.Attributes["red"].Value);
            //int mapColorG = int.Parse(node.Attributes["green"].Value);
            //int mapColorB = int.Parse(node.Attributes["blue"].Value);

            //Vector3 scale = new Vector3((int)(float.Parse(node.Attributes["maxScale"].Value)));
            //float massValue = float.Parse(node.Attributes["mass"].Value);
            //isCollectable = bool.Parse(node.Attributes["isCollectable"].Value);
            //isKey = bool.Parse(node.Attributes["isKey"].Value);

            //// For each pixel of the treeMap
            //for (int l = 0; l < length; l++)
            //{
            //    // If the color matches create a prop
            //    if (locationColorValues[l].R == mapColorR && locationColorValues[l].G == mapColorG && locationColorValues[l].B == mapColorB)
            //    {
            //        // Get the 2D location from 1D array
            //        int h = l % locationMap.Width;
            //        int w = (int)l / locationMap.Width;

            //        // Start Type properties
            //        //gameObject.mass.objectType = objectType;
            //        mass.gameObjectPointer = this;
            //        objectModelName = node.Attributes["name"].Value;

            //        // Get terrain height at position
            //        float yPosition = objectLibrary.terrain.GetTerrainHeight(w * vertexmapToObjectmapRelationship,
            //                                                                 h * vertexmapToObjectmapRelationship);

            //        // Set the object world properties
            //        Vector3 locpos = new Vector3(w * terrainModWidth, yPosition, h * terrainModWidth);
            //        Vector3 refpos = new Vector3(w * terrainModWidth, yPosition, h * terrainModWidth - 1);
            //        mass.SetPosition(locpos, refpos);

            //        mass.Rotate(0.0f, 0.0f);
            //        mass.scale = scale;
            //        mass.mass = massValue;
            //        mass.isMoving = false;

            //        if (isKey)
            //        {
            //            collisionWithPlayerResponse = Enums_Engine.CollisionResponses.HEALTHBONUS;
            //        }
            //    }
            //}
            //return true;
            #endregion
        }


        /// <summary>
        /// Load object data from Xml.
        /// </summary>
        /// <param name="objectLibrary">ObjectLibrary that this object belongs to.</param>
        public bool Load_Instanced(ObjectLibrary objectLibrary)
        {
            return load.Load_Default(objectLibrary, this, false);
        }

        /// <summary>
        /// Load model data from XML
        /// </summary>
        /// <param name="node">The model xml node corresponding to this object</param>
        /// <returns></returns>
        public bool LoadModel(XmlNode node)
        {
            try
            {
                this.name = node.Attributes["name"].Value;
                this.maxScale = node.Attributes["maxScale"].Value;
                this.animated = node.Attributes["animated"].Value;

                
                if (node.Attributes["grid"] != null)
                {
                    switch (node.Attributes["grid"].Value)
                    {
                        case "unit":
                            grid = GridType.unit;
                            break;
                        case "tile":
                            grid = GridType.tile;
                            break;
                        case "coord":
                            grid = GridType.coord;
                            break;
                        default:
                            grid = GridType.unit;
                            break;
                    }
                }


                // Load Textures and Model
                draw = new Draw();
                draw.textureList.Clear();

                this.texture = node.Attributes["texture"].Value;
                this.bumpTexture = node.Attributes["bumpTexture"].Value;
                this.model = node.Attributes["model"].Value;


                // Create Animation Transforms
                if (this.name == "ss3" || this.name == "dojogirl")
                {
                    draw.initialTransform = Matrix.CreateRotationY((float)(-Math.PI / 2.0f)) *
                                       Matrix.CreateTranslation(new Vector3(0, -Statics_Engine.PlayerSettings.DEFAULT_PLAYER_HEIGHT / 2.0f, 0));
                }
                else if (this.name == "bunny")
                {
                    draw.initialTransform = Matrix.CreateTranslation(new Vector3(0, Statics_Engine.PlayerSettings.DEFAULT_PLAYER_HEIGHT, 0));
                }
                else if (this.name == "fish")
                {
                    draw.initialTransform = Matrix.CreateRotationY((float)(-Math.PI)) *
                                       Matrix.CreateTranslation(new Vector3(0, -Statics_Engine.PlayerSettings.DEFAULT_PLAYER_HEIGHT / 2.0f + 5, 0));
                }
                else
                {
                    draw.initialTransform = Matrix.Identity;
                }

                return true;
            }
            catch
            {
                return false;
            }
        }

        public virtual string ToXml()
        {


            string xml =

                "\n" +
                "<" + this.type+ " " +
                " typeID=\"" + this.typeID + "\"" +
                " id=\"" + this.id + "\"" +

                " name=\"" + this.name  + "\"" +

                " x=\"" + this.x + "\"" +
                " z=\"" + this.z + "\"" +
                " grid=\"" + this.grid.ToString() + "\"" +

                " model=\"" + this.model + "\"" +
                " texture=\"" + this.texture + "\"" +
                " bumpTexture=\"" + this.bumpTexture + "\"" +

                " maxScale=\"" + this.maxScale  + "\"" +
                " animated=\"" + this.animated  + "\"" +
                "/>" +
                "\n";

            return xml;

            

            //switch (_grid)
            //{
            //    case GridType.unit:
            //        return "unit";
            //        break;
            //    case GridType.tile:
            //        return "tile";
            //        break;
            //    case GridType.coord:
            //        return "coord";
            //        break;
            //    default:
            //        return "unit";
            //        break;
            //}
        }

        /// <summary>
        /// Runs the appropriate animation on the model
        /// </summary>
        /// <param name="controller">The animation to run</param>
        public void RunController(AnimationController controller)
        {
            foreach (BonePose p in animator.BonePoses)
            {
                p.CurrentController = (IAnimationController)controller;
                p.CurrentBlendController = null;
            }
            currentAnimation = controller;
        }

        /// <summary>
        /// Update this object
        /// </summary>
        /// <param name="objectLibrary">ObjectLibrary</param>
        public virtual void Update(ref ObjectLibrary objectLibrary)
        {
            mass.Update();
            mass.boundingVolume.UpdateSphere(mass.currentPosition);
        }
        /// <summary>
        /// Method called when the motion buttons have been pressed
        /// </summary>
        /// <param name="value">Vector 2 amount of translation to induce</param>
        public virtual void Translate(Vector2 value)
        {
            mass.MoveObject(value.Y, value.X);
        }
        /// <summary>
        /// Method called when the rotation buttons have been pressed
        /// </summary>
        /// <param name="value">Vector 2 amount of rotation</param>
        public virtual void Rotate(Vector2 value)
        {
            mass.Rotate(value.Y, value.X);
        }

        /// <summary>
        /// Default behavior applies force based physics for rebound.
        /// Override to supplement behavior.
        /// Return true if collidedObject is absorbed or destroyed, else false.
        /// </summary>
        /// <param name="collidedObject">GameObject that collided with this GameObject.</param>
        /// <param name="resultantForce">The force applied by the colliding GameObject to this GameObject</param>
        /// <param name="objectLibrary">ObjectLibrary that this object belongs to.</param>
        /// <returns>True = this object has to be recycled</returns>
        public virtual bool ObjectCollisionResponse(GameObject collidedObject, Vector3 resultantForce, ObjectLibrary objectLibrary)
        {
            mass.numberOfCollision++;
            mass.isMoving = true;

            return false;
        }
        /// <summary>
        /// Default behavior applies force based physics for rebound.
        /// Override to supplement or replace behavior.
        /// </summary>
        /// <param name="terrain">A copy of the terrain, provided for overrides</param>
        public virtual void TerrainCollisionResponse(Terrain terrain)
        {
            CalculateVectorComponents(surfaceNormal, Statics_Engine.GameSettings.accelDueToGravity);
            gravityNormalComponent = normalComponent + Vector3.Zero;
            gravityTangentialComponent = tangentialComponent + Vector3.Zero;

            // Calculate the components of velocity with reference to the surface normal
            CalculateVectorComponents(surfaceNormal, mass.velocity);
            velocityNormalComponent = normalComponent + Vector3.Zero;
            velocityTangentialComponent = tangentialComponent + Vector3.Zero;

            // Calculate the components of totalForce with reference to the surface normal
            CalculateVectorComponents(surfaceNormal, mass.totalForce);
            totalForceNormalComponent = normalComponent + Vector3.Zero;
            totalForceTangentialComponent = tangentialComponent + Vector3.Zero;

            // Calculate normal and tangential forces with reference to the their components
            combinedNormalForce = (mass.mass * velocityNormalComponent / Statics_Engine.SystemSettings.dt) + totalForceNormalComponent;
            combinedTangentialForce = (mass.mass * velocityTangentialComponent / Statics_Engine.SystemSettings.dt) +
                                       totalForceTangentialComponent +
                                       (mass.mass * gravityTangentialComponent);

            mass.numberOfCollision++;
        }
        /// <summary>
        /// Calculate components of collision.
        /// </summary>
        /// <param name="surfaceNormal">Normal of surface that is being collided against.</param>
        /// <param name="objectVelocity">Velocity of this GameObject.</param>
        private void CalculateVectorComponents(Vector3 surfaceNormal, Vector3 objectVelocity)
        {
            if (objectVelocity.Length() >= 0.01f || !float.IsInfinity(objectVelocity.Length()))
            {
                normalComponent = Vector3.Dot(objectVelocity, surfaceNormal) * surfaceNormal;

                tangentialComponent = objectVelocity - normalComponent;
            }
            else
            {
                // Object velocity is equal to zero so set both components to zero
                normalComponent = Vector3.Zero;
                tangentialComponent = Vector3.Zero;
            }
        }
        /// <summary>
        /// Sets the heightDifference parameter for this GameObject.
        /// HeightDifference is positive when object is below the terrain.
        /// </summary>
        /// <param name="terrain">Terrain object to determine height difference with.</param>
        public void GetObjectHeight(Terrain terrain)
        {
            // Used to calculate the average terrain height around the player
            localTerrainHeight = 0;

            // Error check
            mass.EnforceLevelBoundary();

            // Get X and Z positions
            int posX = (int)mass.currentPosition.X;
            int posZ = (int)mass.currentPosition.Z;

            // Add up all neighboring terrain points
            localTerrainHeight = terrain.GetTerrainHeight(posX / Statics_Engine.TerrainSettings.terrainScaleFactor, 
                                                          posZ / Statics_Engine.TerrainSettings.terrainScaleFactor);
            surfaceNormal = terrain.GetTerrainNormal(posX / Statics_Engine.TerrainSettings.terrainScaleFactor, 
                                                     posZ / Statics_Engine.TerrainSettings.terrainScaleFactor, mass.velocity);

            // Average all the neighboring terrain points
            float newHeight = localTerrainHeight + (mass.objectHeight / 2);

            // Get difference between average and player
            heightDifference = newHeight - mass.currentPosition.Y;
        }

        /// <summary>
        /// Draws a stand alone model with no instancing or triangle stripping.
        /// </summary>
        public virtual Draw Draw()
        {
            return null;
        }
        /// <summary>
        /// Draws the model for ai vision
        /// </summary>
        public virtual void DrawAIVision()
        {
        }
        /// <summary>
        /// Called after Draw method.
        /// Allows GameObjects to add Billboards to be drawn.
        /// List is cleared each pass, or frame.
        /// </summary>
        /// <param name="objectLibrary">ObjectLibrary that this object belongs to.</param>
        /// <param name="gameObjectBillboards">Dynamic Billboard list.</param>
        public virtual void Draw_Billboards(ObjectLibrary objectLibrary, BillboardList gameObjectBillboards)
        {
            
        }
        #endregion
    }
}

#region Legacy Code - Heat dissipation and State Change
/* Legacy Code
        // Test Function to update energy distribution
        public void UpdateHeatDissipation(ObjectLibrary objectLibrary, float dt)
        {
            List<Particle> newParticlesToAddToList = new List<Particle>();

            foreach (Particle particle in particles)
            {
                particle.mass.UpdatePosition(dt);
            }

            // Iterate through dynamic particles
            for (int i = 0; i < particles.Count; i++)
            {
                Particle particle = particles[i];

                // List to store the pointers to neighboring particles
                List<Particle> neighboringParticleList = new List<Particle>();

                // Used to calculate the average value of all neighboring particles
                float averageEnergy = particle.mass.energy;

                // Get the list of neighboring particle pointers
                neighboringParticleList = GetSurroundingParticles(particle.mass.currentPosition, objectLibrary);

                // Calculate their total energy
                foreach (Particle neigborParticle in neighboringParticleList)
                {
                    averageEnergy += neigborParticle.mass.energy;
                }

                // Find the average
                averageEnergy /= neighboringParticleList.Count + 1;

                // If the average value is not equal to zero then we have some heat dissipation to do
                if (averageEnergy != particle.mass.energy && neighboringParticleList.Count != 0)
                {
                    // Iterate through neighboring particles
                    foreach (Particle neigborParticle in neighboringParticleList)
                    {
                        // If their value is not equal to the average set it and set the flag
                        if (neigborParticle.mass.energy != averageEnergy)
                        {
                            neigborParticle.mass.SetEnergy(averageEnergy);

                            if (!neigborParticle.mass.isChanging)
                            {
                                neigborParticle.mass.isChanging = true;
                                newParticlesToAddToList.Add(neigborParticle);
                            }
                        }
                    }

                    // Set the starting particle's energy to average value as well
                    particle.mass.SetEnergy(averageEnergy);
                }
                else if (particle.mass.energy != 0.0f)
                {
                    DissipateHeat(particle);
                }
                else
                {
                    // The particle and it's neighbors are in equilibrium so remove it from the list
                    particle.mass.isChanging = false;
                    if (!particle.mass.isMoving)
                    {
                        // Particle needs to be put back into the static list
                        MoveParticle(particles, particles, particle);
                    }
                    else
                    {
                        particles.Remove(particle);
                    }

                    i--;
                }
            }

            foreach (Particle newParticle in newParticlesToAddToList)
            {
                if (particles.Contains(newParticle))
                {
                    continue;
                }

                if (newParticle.mass.isMoving)
                {
                    CopyParticle(particles, particles, newParticle);
                }
                else
                {
                    MoveParticle(particles, particles, newParticle);
                }
            }
        }
        
        public void StateChange(ObjectLibrary objectLibrary, float elementUse, GameObject gameObject)
        {
            Particle particle = (Particle)gameObject;

            gameObject.mass.ChangeEnergy(elementUse / 2.0f);

            if (gameObject.mass.isChanging)
            {
                return;
            }
            else if (gameObject.mass.isMoving)
            {
                // Particle is in the dynamic list so we need to copy it to the Thermal list
                switch (particle.particleType)
                {
                    case Particle.ParticleType.Air:
                        {
                            objectLibrary.particleManager.air.CopyParticle(objectLibrary.particleManager.air.dynamicParticles,
                                                                             objectLibrary.particleManager.air.thermalParticles,
                                                                             particle);
                            break;
                        }
                    case Particle.ParticleType.Water:
                        {
                            objectLibrary.particleManager.water.CopyParticle(objectLibrary.particleManager.water.dynamicParticles,
                                                                                objectLibrary.particleManager.water.thermalParticles,
                                                                                particle);
                            break;
                        }
                    case Particle.ParticleType.Earth:
                        {
                            objectLibrary.particleManager.earth.CopyParticle(objectLibrary.particleManager.earth.dynamicParticles,
                                                                               objectLibrary.particleManager.earth.thermalParticles,
                                                                               particle);
                            break;
                        }
                }
                gameObject.mass.isChanging = true;
            }
            else
            {
                // It's in the static list, so move the particle to the dynamic list
                switch (particle.particleType)
                {
                    case Particle.ParticleType.Air:
                        {
                            objectLibrary.particleManager.air.MoveParticle(objectLibrary.particleManager.air.staticParticles,
                                                                             objectLibrary.particleManager.air.thermalParticles,
                                                                             particle);
                            break;
                        }
                    case Particle.ParticleType.Water:
                        {
                            objectLibrary.particleManager.water.MoveParticle(objectLibrary.particleManager.water.staticParticles,
                                                                                objectLibrary.particleManager.water.thermalParticles,
                                                                                particle);
                            break;
                        }
                    case Particle.ParticleType.Earth:
                        {
                            objectLibrary.particleManager.earth.MoveParticle(objectLibrary.particleManager.earth.staticParticles,
                                                                               objectLibrary.particleManager.earth.thermalParticles,
                                                                               particle);
                            break;
                        }
                }
                gameObject.mass.isChanging = true;
            }
        }
*/
#endregion