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";

        }

    }

}