Subversion Repositories AndroidProjects

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.ComponentModel;
using System.IO;
using System.Drawing;
using System.Drawing.Design;

using BauzoidNET.math;
using BauzoidNET.parser;
using BauzoidNET.graphics.sprite;

using BurutaruEditor.view;

namespace BurutaruEditor.file.enemies
{
    public abstract class EnemySpawner : LevelObject
    {

        public const float SPAWNER_SIZE = 32;

        public const int PART_SPAWN_TRIGGER = 0;
        public const int PART_SPAWN_POSITION = 32;

        public static readonly Vector4 ARROW_COLOR = new Vector4(1, 0, 0, 0.5f);

        //=================================================================================================================================

        public enum PowerUpType
        {
            NONE = -1,
            SPEED_UP = 0,
            MISSILE,
            BOMB,
            BEAM_SHOT,
            SPREAD_SHOT,
            NAPALM_SHOT,
            FORCE_FIELD
        }

        //=================================================================================================================================

        private Vector2 mSpawnTrigger = new Vector2();

        [Category("Basic Parameters")]
        [TypeConverter(typeof(ExpandableObjectConverter))]
        public Vector2 SpawnTrigger { get { return mSpawnTrigger; } }

        private Vector2 mSpawnPosition = new Vector2();

        [Category("Basic Parameters")]
        [TypeConverter(typeof(ExpandableObjectConverter))]
        public Vector2 SpawnPosition { get { return mSpawnPosition; } }

        private PowerUpType mPowerUpType = PowerUpType.NONE;
        [Category("Basic Parameters")]
        public PowerUpType LeavePowerUp
        {
            get
            {
                return mPowerUpType;
            }
            set
            {
                mPowerUpType = value;
            }
        }

        [Browsable(false)]
        public string DisplayName
        {
            get
            {
                return Name + " [" + GetPropertiesType() + "]";
            }
        }

        protected Vector4 mMultiplyColor = new Vector4(1, 1, 1, 1);
        protected Vector4 mLerpColor = new Vector4(0, 0, 0, 0);

        [Category("Basic Parameters")]
        [Editor(typeof(ColorEditor), typeof(UITypeEditor))] // specify editor for the property
        public Color MultiplyColor
        {
            get
            {
                return Color.FromArgb(255, (int)(mMultiplyColor.x * 255), (int)(mMultiplyColor.y * 255), (int)(mMultiplyColor.z * 255));
            }
            set
            {
                mMultiplyColor.set((float)value.R / 255.0f, (float)value.G / 255.0f, (float)value.B / 255.0f, 1.0f);
            }
        }

        protected float mMultiplyFactor = 1.0f;
        [Category("Basic Parameters")]
        public float MultiplyFactor
        {
            get { return mMultiplyFactor; }
            set { mMultiplyFactor = MathUtil.clamp(value, 0, 1); }
        }

        [Category("Basic Parameters")]
        [Editor(typeof(ColorEditor), typeof(UITypeEditor))] // specify editor for the property
        public Color LerpColor
        {
            get
            {
                return Color.FromArgb(255, (int)(mLerpColor.x * 255), (int)(mLerpColor.y * 255), (int)(mLerpColor.z * 255));
            }
            set
            {
                mLerpColor.set((float)value.R / 255.0f, (float)value.G / 255.0f, (float)value.B / 255.0f, 1.0f);
            }
        }

        protected float mLerpFactor = 0.0f;
        [Category("Basic Parameters")]
        public float LerpFactor
        {
            get { return mLerpFactor; }
            set { mLerpFactor = MathUtil.clamp(value, 0, 1); }
        }

        [Category("Basic Parameters")]
        public float Alpha { get; set; }

        //=================================================================================================================================

        public EnemySpawner(Document doc, string name)
            : base(doc, name)
        {
            Alpha = 1.0f;
        }

        public virtual void Render()
        {
            SpriteTransform t = DocumentView.Resources.Spawner.getSpriteTransform();
            t.x = SpawnTrigger.x + Doc.View.CurrentPosition.x;
            t.y = SpawnTrigger.y + Doc.View.CurrentPosition.y;
            t.w = SPAWNER_SIZE;
            t.h = SPAWNER_SIZE;
            t.centerPivot();
            DocumentView.Resources.Spawner.render();
        }

        public override void RenderSelected(int selectedPart, bool forHover = false)
        {
            float triggerX = SpawnTrigger.x + Doc.View.CurrentPosition.x;
            float triggerY = SpawnTrigger.y + Doc.View.CurrentPosition.y;

            float halfSize = (SPAWNER_SIZE / 2 + DocumentView.SELECTION_FRAME_OFFSET);

            if (forHover)
                Doc.View.RenderSelectionFrame(triggerX - halfSize, triggerY - halfSize, triggerX + halfSize, triggerY + halfSize, DocumentView.SELECTION_FRAME_HOVER_ALPHA);
            else
                Doc.View.RenderSelectionFrame(triggerX - halfSize, triggerY - halfSize, triggerX + halfSize, triggerY + halfSize);
        }

        public override bool IsInside(float x, float y, out int selectedPart)
        {
            selectedPart = -1;
            float px = SpawnTrigger.x + Doc.View.CurrentPosition.x;
            float py = SpawnTrigger.y + Doc.View.CurrentPosition.y;

            if ((Math.Abs(px - x) <= (SPAWNER_SIZE / 2)) && (Math.Abs(py - y) < (SPAWNER_SIZE / 2)))
            {
                selectedPart = PART_SPAWN_TRIGGER;
                return true;
            }

            return false;
        }

        public override void WriteData(TextWriter tw)
        {
            tw.WriteLine("\tspawnTrigger " + mSpawnTrigger.x.ToString("F") + ", " + mSpawnTrigger.y.ToString("F") + ";");
            tw.WriteLine("\tspawnPosition " + mSpawnPosition.x.ToString("F") + ", " + mSpawnPosition.y.ToString("F") + ";");
            tw.WriteLine("\tleavePowerUp " + (int)mPowerUpType + ";");
            tw.WriteLine("\tmultiplyColor " + mMultiplyColor.x + ", " + mMultiplyColor.y + ", " + mMultiplyColor.z + ", " + mMultiplyFactor + ";");
            tw.WriteLine("\tlerpColor " + mLerpColor.x + ", " + mLerpColor.y + ", " + mLerpColor.z + ", " + mLerpFactor + ";");
            tw.WriteLine("\talpha " + Alpha + ";");
        }

        public override void WriteData(Serializer s)
        {
            s.Write("spawnTrigger"); s.Write(mSpawnTrigger);
            s.Write("spawnPosition"); s.Write(mSpawnPosition);
            s.Write("leavePowerUp"); s.Write((int)mPowerUpType);
            s.Write("multiplyColor"); s.Write(mMultiplyColor);
            s.Write("lerpColor"); s.Write(mLerpColor);
            s.Write("alpha"); s.Write(Alpha);
            /*s.Write("position"); s.Write(Position);
            s.Write("freeScroll"); s.Write(FreeScroll);
            s.Write("continueCondition"); s.Write(ContinueCondition);
            s.Write("scrollSpeed"); s.Write(ScrollSpeed);
            s.Write("starFieldStatus"); s.Write((int)StarFieldStatus);
            s.Write("starFieldStatusSwitchTime"); s.Write(StarFieldStatusSwitchTime);*/
        }

        public override bool ReadParameter(Tokenizer t, string id)
            {
                    if (id.Equals("spawnTrigger", StringComparison.OrdinalIgnoreCase))
                    {
                mSpawnTrigger = ParseUtil.readVector2(t);
                    }
            else if (id.Equals("spawnPosition", StringComparison.OrdinalIgnoreCase))
                    {
                mSpawnPosition = ParseUtil.readVector2(t);
                    }
            else if (id.Equals("leavePowerUp", StringComparison.OrdinalIgnoreCase))
            {
                mPowerUpType = (PowerUpType)((int)t.readNumber());
            }
            else if (id.Equals("multiplyColor", StringComparison.OrdinalIgnoreCase))
            {
                mMultiplyColor = ParseUtil.readVector4(t);
                mMultiplyFactor = mMultiplyColor.w;
                mMultiplyColor.w = 1.0f;
            }
            else if (id.Equals("lerpColor", StringComparison.OrdinalIgnoreCase))
            {
                mLerpColor = ParseUtil.readVector4(t);
                mLerpFactor = mLerpColor.w;
                mLerpColor.w = 1.0f;
            }
            else if (id.Equals("alpha", StringComparison.OrdinalIgnoreCase))
            {
                Alpha = t.readNumber();
            }
            else
            {
                return false;
            }
               
                    t.readToken(";");
                    return true;
            }

        public static EnemySpawner createSpawner(Document doc, string enemyType, string enemyName)
        {
            if (enemyType.Equals("BlobEnemy"))
            {
                return new BlobEnemySpawner(doc, enemyName);
            }
            else if (enemyType.Equals("CoreMechEnemy"))
            {
                return new CoreMechEnemySpawner(doc, enemyName);
            }
            else if (enemyType.Equals("CoreMechXlEnemy"))
            {
                return new CoreMechXlEnemySpawner(doc, enemyName);
            }
            else if (enemyType.Equals("CoreTurretEnemy"))
            {
                return new CoreTurretEnemySpawner(doc, enemyName);
            }
            else if (enemyType.Equals("SpaceMineEnemy"))
            {
                return new SpaceMineEnemySpawner(doc, enemyName);
            }
            else if (enemyType.Equals("GarbageCollectorBoss"))
            {
                return new GarbageCollectorBossSpawner(doc, enemyName);
            }

            return null;
        }

        public override string GetPropertiesType()
        {
            return "EnemySpawner";
        }
    }
}