/*
 * Friendly.cs
 * Authors:     August Zinsser
 * 
 * Copyright Matthew Belmonte 2007
 */


using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Pina3D.Particles;
using tAC_Engine;


namespace Astropolis
{
    /// <summary>
    /// This represents the friendly units that pop out of wormholes in Meteor Madness.
    /// The opposite of space pirate.
    /// It has a basic AI that tells Meteor Madness when to throw a powerup to the player
    /// </summary>
    class Friendly : UFO
    {
        private double mArcPosition;     // Degrees of a circle corresponding to the player's ship's position
        private double mArcVelocity;     // Speed at which the ship can change its arcposition
        private float mPowerupCooldown;  // How long to wait before throwing the player a powerup
        private PowerUpType mPowerUp;    // The type of powerup to award
        private float mMoveAway = 0f;    // Holds the amount of "avoidance steering" from the main player
        private float mMoveAwayTimer = 0f;  // How long to wait before trying to steer away from the player


        public enum PowerUpType { Weapon, Resource };
        public double ArcPosition { set { mArcPosition = value; UpdatePosition(); } get { return mArcPosition; } }
        public double ArcVelocity { set { mArcVelocity = value; } get { return mArcVelocity; } }
        public PowerUpType PowerUp { get { return mPowerUp; } }


        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="texture">Image of the ship</param>
        /// <param name="width">In Space3D units</param>
        /// <param name="height">In Space3D units</param>
        /// <param name="depth">In Space3D units</param>
        /// <param name="hitPoints">How many hitpoints before the ship is destroyed</param>
        /// <param name="powerUp">The type of powerup to award the player</param>
        /// <param name="difficulty">Accelerates the time to turn and the rate of turn by this amount</param>
        public Friendly(Texture2D texture, float width, float height, float depth, int hitPoints, PowerUpType powerUp, float turnMultiplier)
            : base(texture, width, height, depth, hitPoints)
        {
            mArcVelocity = Math.PI / 720 * turnMultiplier * 2;
            mPowerUp = powerUp;
            mPowerupCooldown = 2.5f / turnMultiplier;
        }


        /// <summary>
        /// Deals the specified amount of damage to this ship, potentially killing it
        /// </summary>
        /// <param name="damage"></param>
        public override void GetHit(int damage)
        {
            mHitPoints -= damage;
            if (mHitPoints <= 0)
                Destroy();
            else
            {
                if (mPos.Z > -1)
                {
                    // Shield particle effect
                    mShieldEmitter.RegularEmissionType.LifeExpectancy = .1f;
                    mShieldEmitter = Sparx.LoadParticleEffect(@"Content\Particle Effects\Shield.spx");

                    // Redden the shields to indicate that they are low
                    float percentLeft = (float)(mHitPoints / 100f);
                    Color newColor = new Color((byte)((255 * (1 - percentLeft))),
                                               (byte)((150 * (percentLeft))),
                                               (byte)((255 * (percentLeft))));
                    mShieldEmitter.RegularEmissionType.Modifiers[0].InitialTint = newColor;
                    mShieldEmitter.RegularEmissionType.Modifiers[0].InitialOpacity = percentLeft;
                    Sparx.AddEmitter(mShieldEmitter);
                }
            }
        }


        /// <summary>
        /// Spawns the appropriate particle effects and/or entities
        /// </summary>
        public override void Destroy()
        {
            mAlive = false;

            Emitter splosion = Sparx.LoadParticleEffect(@"Content\Particle Effects\MediumExplosion.spx");
            Rectangle proj = Space3D.Project(this.X, this.Y, this.Z, this.Width, this.Height, -1f);
            float scaling = proj.Width * .01f;
            splosion.RenderScale = scaling;
            splosion.Transform = Matrix.CreateScale(scaling) * Matrix.CreateTranslation(proj.X, proj.Y, MathHelper.Clamp(this.Z / 5f, 0f, 1f));
            Sparx.AddEmitter(splosion);
            splosion = Sparx.LoadParticleEffect(@"Content\Particle Effects\MediumExplosion.spx");
            scaling *= .5f;
            splosion.RenderScale = scaling;
            splosion.Transform = Matrix.CreateScale(scaling) * Matrix.CreateTranslation(proj.X, proj.Y, MathHelper.Clamp(this.Z / 5f, 0f, 1f));
            Sparx.AddEmitter(splosion);
        }


        /// <summary>
        /// Awards the appropriate resources or damages player
        /// </summary>
        public override void CollideWithPlayer(Entity player)
        {
            ((MeteorMadness)AstroBaseApplication.MiniGame).ShooterShieldHit(50);
            Destroy();
        }


        /// <summary>
        /// Waits, throws a resource or power-up to the player, and then flies away
        /// </summary>
        /// <returns>True if the AI should throw a powerup, false if it should not</returns>
        public override bool React(CheetahFighter playerShip)
        {
            // Wait and then throw a power up or resource to the player
            if (mPowerupCooldown < 0)
            {
                ThrowPowerup();
                MoveAway();
                return true;
            }

            return false;
        }


        /// <summary>
        /// Steer away from the original position so the player does not have to move out of this ship's way
        /// </summary>
        private void MoveAway()
        {
            mMoveAwayTimer = 3f;
            Random rand = new Random();
            if (rand.NextDouble() < .5)
                mMoveAway = (float)-mArcVelocity;
            else
                mMoveAway = (float)mArcVelocity;
        }


        /// <summary>
        /// Moves the ship clockwise
        /// </summary>
        /// <param name="dt"></param>
        private void MoveLeft(float dt)
        {
            mArcPosition += mArcVelocity * dt;
            UpdatePosition();
        }


        /// <summary>
        /// Moves the ship counterclockwise
        /// </summary>
        /// <param name="dt"></param>
        private void MoveRight(float dt)
        {
            mArcPosition -= mArcVelocity * dt;
            UpdatePosition();
        }


        /// <summary>
        /// Resets the cooldown of the powerup to a very long time, ensuring that only one is thrown
        /// </summary>
        private void ThrowPowerup()
        {
            mPowerupCooldown = 1000f;
        }


        /// <summary>
        /// Updates the inherited Position properties based on the arcposition
        /// </summary>
        private void UpdatePosition()
        {
            // Get cartesian coordinates from angular position
            Vector2 PositionFromOrigin = new Vector2((float)Math.Cos(mArcPosition), (float)Math.Sin(mArcPosition));

            // Move the ship towards the center for aesthetics
            mPos.X = .8F * PositionFromOrigin.X;
            mPos.Y = .8F * PositionFromOrigin.Y;

            // Cleanup variables
            mArcPosition %= Math.PI * 2;
            mRot = mArcPosition - Math.PI / 2;
        }


        /// <summary>
        /// Updates logic and positional data for this ship
        /// </summary>
        public override void Update()
        {
            float dt = AstroBaseApplication.GameManager.ElapsedSeconds;
            mPowerupCooldown -= dt;

            mMoveAwayTimer -= dt;
            if (mMoveAwayTimer > 0)
            {
                // Start moving away from the original course
                mArcPosition += mMoveAway;
                UpdatePosition();
            }

            Rectangle proj = Space3D.Project(this.X, this.Y, this.Z, this.Width, this.Height, -1f);
            float scaling = proj.Width * .015f;
            mShieldEmitter.RenderScale = scaling;
            mShieldEmitter.Transform = Matrix.CreateScale(scaling) * Matrix.CreateTranslation(proj.X, proj.Y, MathHelper.Clamp(this.Z / 5f, 0f, 1f));

            base.Update();
        }
    }
}