/Poing2/GameEnemy.cs

Large files files are truncated, but you can click here to view the full file

using System;
using System.CodeDom.Compiler;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Design;
using System.Drawing.Imaging;
using System.Linq;
using System.Net.Sockets;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.Serialization;
using System.ComponentModel;
using BASeCamp.BASeBlock.Blocks;
using BASeCamp.BASeBlock.Events;
using BASeCamp.BASeBlock.Particles;
using BASeCamp.BASeBlock.Projectiles;

namespace BASeCamp.BASeBlock
{

    public class NoKillIncrementAttribute : System.Attribute
    {


    }
    /// <summary>
    /// Attribute that forces a class deriving from GameEnemy to Increment the Statistics kill counter when it dies.
    /// this cannot be overridden (to prevent kill incrementing)
    /// </summary>
    public class KillIncrementAttribute : System.Attribute
    {



    }
    /// <summary>
    /// GameEnemy: derives from GameObject, and provides the core logic for all Enemies that will be created.
    /// </summary>
    
    public abstract class GameEnemy : GameObject,iLocatable ,IExplodable
    {
        /*many enemies will be implemented using different "states"; that is, an enemy may have one set of animation frames
        for when it is "idle", and other animation frames for Attacking and so forth. We keep track of several things to help in this:
        
         * 1. A Dictionary that stores Arrays of Image KEYS (we don't want to duplicate image data across multiple instances) which can be indexed
         * based on the "EnemyState" string value, which, ideally, could be an enumeration, but different enemies may have any number of states and artificially limiting them seems
         * a bit premature- so we use a string.

        */
        protected int _HitPoints = 50;
        protected int _MaxHitPoints = 50;
        public int HitPoints { get { return _HitPoints; }
            set { _HitPoints = value; if (_HitPoints > _MaxHitPoints) _MaxHitPoints = value; }
        }
        public int MaxHitPoints { get { return _MaxHitPoints; } set { _MaxHitPoints = value; } }
        [Flags]
        public enum AutoSizeModeConstants
        {
            AutoSize_None, //default, no sizing will be done as frames change.
            AutoSize_ExpandTranslate, //expand to the left or up to preserve frame X scale.
            AutoSize_ExpandUp, //expand width or height to preserve frame Y scale.
            AutoSize_ExpandCenter //expansion will center the axis in the same location the center sits in the current frame.

        }

        public class FrameSizeMode
        {
            public AutoSizeModeConstants XSizeMode { get; set; }
            public AutoSizeModeConstants YSizeMode { get; set; }
            public FrameSizeMode(AutoSizeModeConstants pXSizeMode, AutoSizeModeConstants pYSizeMode)
            {
                XSizeMode = pXSizeMode;
                YSizeMode = pYSizeMode;

            }
            /// <summary>
            /// given our scalemode, location, and the current and new size, changes Location and currsize
            /// to scale appropriate to newsize.
            /// </summary>
            /// <param name="sizemode"></param>
            /// <param name="Location"></param>
            /// <param name="currsize"></param>
            /// <param name="newsize"></param>
            
            public void Rescale(ref PointF Location, ref SizeF currsize, SizeF newsize)
            {
                
                



            }
            private void RescaleAxis(AutoSizeModeConstants smode,ref float value, ref float Currsize, ref float newsize)
            {
                switch (smode)
                {

                    case AutoSizeModeConstants.AutoSize_None:
                        break; //nothing...
                    case AutoSizeModeConstants.AutoSize_ExpandTranslate:
                        //move value so that the the "end" of the size will be the same. (so the right or bottom remains unchanged)
                        value = (value + Currsize) - newsize;
                        Currsize = newsize;
                        break;
                    case AutoSizeModeConstants.AutoSize_ExpandUp:
                        //expand outwards...
                        Currsize = newsize;
                        break;
                    case AutoSizeModeConstants.AutoSize_ExpandCenter:
                        value = value + ((value + Currsize / 2) - (value + newsize / 2));
                        break;
                }
                    




            }


        }
        private FrameSizeMode _FramingSizeMode = new FrameSizeMode(AutoSizeModeConstants.AutoSize_None, AutoSizeModeConstants.AutoSize_None);

        public FrameSizeMode FramingSizeMode { get { return _FramingSizeMode; } set { _FramingSizeMode = value; } }


        private List<EnemyTrigger> _Triggers = new List<EnemyTrigger>();

        /// <summary>
        /// Trigger that get's invoked for certain circumstances
        /// </summary>
        public List<EnemyTrigger> Triggers {get { return _Triggers; }



            set { 
                _Triggers = value;
                if (_Triggers != null)
                {
                    foreach (var looptrigger in _Triggers)
                    {
                        looptrigger.OurEnemy=this;


                    }


                }




            }



        } //Trigger to invoke when this enemy dies.
        //public Trigger TriggerInvoke { get; set; }

        public ImageAttributes DrawAttributes=null; 
        //Enemy State:
        protected SizeF? _DrawSize=null; //if null, will use default. This is a float, and represents the % size we should use of the 

        public virtual SizeF DrawSize { 
            get
            {
                if (_DrawSize == null) return this.GetCurrentImage().Size;
                else return _DrawSize.Value;
            }
            set { _DrawSize = value; }}

        //current frame image.

        
        public event EventHandler<EnemyDeathEventArgs> OnDeath;
        
        private struct deathtriggerdata
        {
            public GameEnemy theenemy;
            public BCBlockGameState stateobj;
            public String SoundPlay;
            public List<EnemyTrigger> Triggers;

        }

        public override string ToString()
        {
            String buildit = "GameEnemy { \n" +
                "Location:" + this.Location.ToString() + "\n" +
                "Size:" + this.DrawSize.ToString() + "\n" +
                "State:" + this.EnemyState.ToString() + "\n" +
                "Hitpoints:" + this.HitPoints.ToString() + "\n" +
                "maxHP:" + this.MaxHitPoints.ToString() + "\n";
                
                buildit+="Triggers {\n";
                foreach(var iterate in Triggers)
                {
                    buildit+=iterate.ToString() + "\n";

                    buildit+="----\n";
                }
                buildit+="\n";

                return buildit;
        }

        public virtual void ExplosionInteract(object sender, PointF Origin, PointF Vector)
        {
            HitPoints -= (int)Vector.Magnitude();
        }

        //System.Threading.Timer usetimer;
        System.Threading.Thread deaththread;
        DateTime InitialDeath;
        private void CalledOnDeath(Object sender, EnemyDeathEventArgs e)
        {
            if (e.EnemyDied is ChomperEnemy)
            {
                Debug.Print("Chomper...");

            }
            if (Triggers != null)
            {
                Debug.Print("Enemy killed; invoking triggers.");
                foreach (EnemyTrigger looptrigger in Triggers)
                {
                    looptrigger.InvokeTriggerWithDelay(e.StateObject);


                }


            }


            /*if (Triggers != null)
                {
                    Debug.Print("OH NOES an enemy died, -invoking triggers");
                    foreach (EnemyTrigger looptrigger in Triggers)
                    {
                        looptrigger.InvokeTriggerWithDelay(stateobject);


                    }
                    /*
                    deathtriggerdata datatriggers = new deathtriggerdata();
                    datatriggers.theenemy = enemydied;
                    datatriggers.stateobj = stateobject;
                    datatriggers.SoundPlay = "puzzle";
                    //Debug.Print("assigning datatriggers TriggerID of " + Trigger);
                    datatriggers.Triggers= Triggers;
                    
                    //usetimer = new Timer(deathtriggertimeout,(object)datatriggers,0,500);
                    deaththread = new Thread(deathtriggertimeout);
                    InitialDeath = DateTime.Now;
                    deaththread.Start((object) datatriggers);*/
            //}
                
            //assuming that works, we would now destroy all blocks in the level that have the same TriggerID as us.

        }
        /*
            private void deathtriggertimeout(object parameter)
            {
                Debug.Print("deathtriggertimeout");
                while ((DateTime.Now - InitialDeath).Seconds < 2)
                {
                    Thread.Sleep(100);

                }
                Debug.Print("timeout expired...");
                deathtriggerdata dtd = (deathtriggerdata)parameter;
                //destroy all blocks with the same ID.
               // Debug.Print("TriggerID=" + dtd.TriggerID);
                List<Block> removethese = new List<Block>();
                if(!String.IsNullOrEmpty(dtd.SoundPlay))
                    BCBlockGameState.Soundman.PlaySound(dtd.SoundPlay,3.0f);
                lock (dtd.stateobj )
                {
                    if (dtd.TriggerObj != null)
                    {
                        //Debug.Print("Total number of blocks with triggerID of " + dtd.TriggerID + (from b in dtd.stateobj.Blocks where b.TriggerID == dtd.TriggerID select b).Count().ToString());



                        //foreach (
                        //    Block loopblock in
                        //        (from b in dtd.stateobj.Blocks where b.TriggerID == dtd.TriggerID select b))
                        /*
                        foreach (Block b in dtd.stateobj.Blocks)
                        {
                            if (b.TriggerID == TriggerID)
                            {
                                Debug.Print("kerploding a block...");
                                b.StandardSpray(dtd.stateobj);
                                removethese.Add(b);


                            }
                        }
                        foreach (Block removeblock in removethese)
                        {
                            dtd.stateobj.Blocks.Remove(removeblock);


                        }
                         * 

                        dtd.TriggerObj.InvokeTrigger(dtd.stateobj);

                        dtd.stateobj.Forcerefresh = true;
                    }
                }

                
            }
*/
        public virtual int GetScoreValue()
        {

            return 100;
        }
        private bool AllowKillIncrement()
        {

            return !(BCBlockGameState.HasAttribute(this.GetType(), typeof(NoKillIncrementAttribute))) ||
                BCBlockGameState.HasAttribute(this.GetType(),typeof(NoKillIncrementAttribute));


        }
        internal void InvokeOnDeath(BCBlockGameState stateobject,ref List<GameObject> AddObjects,ref List<GameObject> removeobjects)
        {
            var gotset = stateobject.ClientObject.GetPlayingSet();
            if (gotset !=null && AllowKillIncrement())
            {
                gotset.Statistics.EnemyKills++;
                
            }


            int gotvalue = GetScoreValue();
            if(gotvalue != 0)
                Block.AddScore(stateobject, GetScoreValue(), Location);
            
            var deathproc = OnDeath;
            if (deathproc != null)
            {
                deathproc(this, new EnemyDeathEventArgs(this, stateobject));
                

            }

        }

        public SizeF GetSize()
        {
            return DrawSize;

        }
        //public event Action<String, String> EnemyStateChanged;
        public event EventHandler<EnemyStateChangeEventArgs> EnemyStateChanged;
        private void RaiseEnemyStateChange(String oldstate, String newstate)
        {
            Debug.Print("Enemy State changed:" + oldstate + " to " + newstate);
            var invokethis = EnemyStateChanged;
            if (invokethis != null)
            {
                EnemyStateChangeEventArgs esc = new EnemyStateChangeEventArgs(oldstate, newstate);
                invokethis(this, esc);



            }

        }



        public String EnemyAction
        {
            set
            {
                if (_ActionIndex == null) InitActions();
                //map backwards...
                foreach (var iterate in _ActionIndex)
                {

                    if (iterate.Value.Equals(value, StringComparison.OrdinalIgnoreCase))
                        EnemyState = iterate.Key;
                }

            }
            get
            {
                if (_ActionIndex == null) InitActions();
                return GetAction(_EnemyState);
            }


        }
        protected void InitActions()
        {
            _ActionIndex = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
            foreach (var kvp in StateFrameImageKeys)
            {
                _ActionIndex.Add(kvp.Key, kvp.Key);

            }

        }
        protected String _EnemyState = "idle";
        public String EnemyState
        {
            get { return _EnemyState; }
            set
            {
                if (_EnemyState != value)
                {
                    RaiseEnemyStateChange(_EnemyState, value);
                    _EnemyState = value;

                }
            }


        }
        protected int mDefaultFrameDelay=50;
        protected PointF _Location;

        public virtual PointF Location { get { return _Location; } set { _Location = value; } }

        protected float DrawRotation; //rotation to draw...
        //dictionary of Image keys...
        protected Dictionary<String, String[]> _StateFrameImageKeys = new Dictionary<string, string[]>(StringComparer.OrdinalIgnoreCase);

        //a similar dictionary, which maps a state to an action. By default, each state is it's own action.
        //this is added to allow for different states for the images (such as jumping up and down) while having the
        //logic be able to deal with it in the same manner.
        protected Dictionary<String, String> _ActionIndex = null;

        public static GameEnemy CreateBoss<T>(PointF location, BCBlockGameState gstate) where T : GameEnemy
        {
            var resultvalue = CreateBoss<T>(location, gstate, (g) => g.OnDeath += bossdeath,new TimeSpan(0,0,0,3));
            return resultvalue;
        }
        public static void bossdeath(Object sender,EnemyDeathEventArgs e)
        {
            createenemy_OnDeath(sender, e);
        }
        public static GameEnemy CreateBoss<T>(PointF location, BCBlockGameState gstate,Action<T> onDeath,TimeSpan DeathDelay) where T:GameEnemy
        {
            
            GameEnemy createenemy = null;
            Type createtype = typeof(T);
            MethodInfo usemethod = null;
            foreach (var iterate in createtype.GetMethods())
            {
                if (iterate.Name.Equals("CreateBoss", StringComparison.OrdinalIgnoreCase) && iterate.IsStatic)
                {
                    usemethod = iterate;


                }

            }
            try
            {
                if (usemethod != null)
                {
                    createenemy= (GameEnemy)usemethod.Invoke(null,new object[] {location,gstate});

                }
            }
            catch(Exception exx)
            {
                Debug.Print(exx.ToString());

            }
            if (createenemy != null)
            {
                //int useChannel = Trigger.GetAvailableID(gstate);
                //createenemy.Triggers.Add(new EnemyTrigger(createenemy, useChannel, new TimeSpan(0, 0, 0, 0, 500)));
                gstate.Blocks.AddLast(new NormalBlock(new RectangleF(-500, -500, 32, 16)));
                BCBlockGameState.Soundman.PlayTemporaryMusic("smb2boss",1.0f,true);
                //gstate.PlayingLevel.LevelEvents.Add(new FinishLevelEvent(useChannel));
                gstate.PlayingLevel.TallyMusicName = "bossclear";
                gstate.PlayingLevel.ClearTitle = "   BOSS CLEAR     \n";
                gstate.BossCounter++; //add one to the boss counter.
                //show a message expressing the gravity of the situation.
                gstate.EnqueueMessage(createenemy.GetType().Name + "Boss Has awoken!");


                createenemy.OnDeath += createenemy_OnDeath;
                return createenemy;
            }
            return null;


        }

        static void createenemy_OnDeath(Object sender, EnemyDeathEventArgs e)
        {
            e.StateObject.EnqueueMessage(e.EnemyDied.GetType().Name + " Boss defeated! Well Done!");
            BCBlockGameState.Soundman.StopMusic();
            BCBlockGameState.Soundman.PlaySound("BOSSKILL");
            var currset = e.StateObject.ClientObject.GetPlayingSet();
            if (currset != null)
            {
                currset.Statistics.BossKills++;

            }
            e.StateObject.BossCounter--;
        }

       
        //protected int FrameDelay = 35; //delay between frame changes.

        protected Dictionary<String, int[]> FrameDelayTimes = new Dictionary<string, int[]>(StringComparer.OrdinalIgnoreCase);
        private T[] CreateArray<T>(T valueassign,int number)
        {
            T[] createarray = new T[number];
            for (int i = 0; i < createarray.Length;i++ )
            {
                createarray[i] = valueassign;
            }

            return createarray;
        }
        
        public Dictionary<String, String[]> StateFrameImageKeys
        {
            get {
                return _StateFrameImageKeys;
            
            }
            set {
                _StateFrameImageKeys=value;
                if (_StateFrameImageKeys == null) return;
                StateFrameIndex.Clear();
                FrameDelayTimes.Clear();
                foreach (KeyValuePair<String, String[]> kvp in _StateFrameImageKeys)
                {
                    StateFrameIndex.Add(kvp.Key, 0);

                    FrameDelayTimes.Add(kvp.Key, CreateArray<int>(50, kvp.Value.Length));

                }
            
            }


        }
        protected Dictionary<String, int> StateFrameIndex = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);

        protected GameEnemy(PointF Position, Dictionary<String, String[]> StateFrameData, int FrameDelay)
            : this(Position, StateFrameData, FrameDelay, null)
        {

            OnDeath = CalledOnDeath;

        }
        protected String GetAction(String state)
        {

            return _ActionIndex[state];

        }
        protected GameEnemy(PointF Position, Dictionary<String, String[]> StateFrameData,int FrameDelay,ImageAttributes useattributes)
        {
            OnDeath = CalledOnDeath;
            DrawAttributes=useattributes;
            Location=Position;
            mDefaultFrameDelay=FrameDelay;
            StateFrameImageKeys = StateFrameData;
            


            if(StateFrameData!=null)
            {
                _ActionIndex = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
                foreach (KeyValuePair<String, String[]> kvp in StateFrameData)
                {
                    if (StateFrameIndex.ContainsKey(kvp.Key))
                    {
                        StateFrameIndex[kvp.Key] = 0;
                        FrameDelayTimes[kvp.Key] = CreateArray(FrameDelay, kvp.Value.Length);
                    }
                    else
                    {
                        StateFrameIndex.Add(kvp.Key, 0);
                        FrameDelayTimes.Add(kvp.Key, CreateArray(FrameDelay, kvp.Value.Length));
                    }
                    _ActionIndex.Add(kvp.Key, kvp.Key);
                }
            }
            
        }



        public virtual Image GetCurrentImage()
        {
            if (StateFrameImageKeys == null) return null;
            try
            {
                return BCBlockGameState.Imageman.getLoadedImage(StateFrameImageKeys[_EnemyState][StateFrameIndex[_EnemyState]]);
            }
            catch
            {
                //do nothin
                return null;
            }

        }
        public RectangleF GetRectangleF()
        {
            if (DrawSize != null)
                return new RectangleF(Location.X, Location.Y, DrawSize.Width, DrawSize.Height);
            else
            {
                Image grabimage = GetCurrentImage();
                return new RectangleF(Location.X,Location.Y,grabimage.Width,grabimage.Height);



            }



        }
        public void setRectangleF(RectangleF newrect)
        {
            Location = new PointF(newrect.Left, newrect.Top);
            DrawSize = new SizeF(newrect.Width, newrect.Height);


        }
        public void setRectangle(Rectangle newrect)
        {
            RectangleF convrect = newrect.ToRectangleF();
            setRectangleF(convrect);


        }
        public Rectangle GetRectangle()
        {
            RectangleF convrect = GetRectangleF();
            return new Rectangle((int)convrect.Left,(int)convrect.Top,(int)convrect.Width,(int)convrect.Height);


        }
        /// <summary>
        /// called when a set of frames is about to loop around.
        /// </summary>

        public virtual void OnFramesetComplete(BCBlockGameState gamestate)
        {




        } //called when a set of frames loops back to 0.
        
        

       

        /// <summary>
        /// increments the frame number of the currently selected list of state images.
        /// </summary>
        /// 

        private int GetFrameDelayTime()
        {
            //if the FrameDelayTimes Dictionary is null- or if it doesn't extend far enough to cover the current frame...
            
            /*if (FrameDelayTimes == null || FrameDelayTimes.Count < StateFrameIndex[_EnemyState])
            {
                //return a default value.
                return mDefaultFrameDelay;
            }*/
            //otherwise, retrieve the appropriate delay time based on this character/enemies current state and current frame.
            try
            {
                return FrameDelayTimes[_EnemyState][StateFrameIndex[_EnemyState]];
            }
            catch
            {

                return mDefaultFrameDelay;
            }

        }

        int FrameDelayCounter = 0;
        private void IncrementImageFrame(BCBlockGameState gamestate)
        {
            FrameDelayCounter++;
            if (FrameDelayCounter > GetFrameDelayTime())
            {
                Trace.WriteLine("FrameSet:" + _EnemyState);
                OnFramesetComplete(gamestate);
                FrameDelayCounter = 0;
                int currframe = StateFrameIndex[_EnemyState];
                int numframes = StateFrameImageKeys[_EnemyState].Length - 1;
                if (currframe >= numframes)
                    currframe = 0;
                else
                    currframe++;

                StateFrameIndex[_EnemyState] = currframe;
            }
        }
        
        public override bool PerformFrame(BCBlockGameState gamestate)
        {
            IncrementImageFrame(gamestate);
            //throw new NotImplementedException();
            //return _HitPoints <= 0;
            return false;
        }
        public virtual Image getIcon()
        {
            Bitmap buildbit = new Bitmap((int)DrawSize.Width, (int)DrawSize.Height);
            
                
                Graphics g = Graphics.FromImage(buildbit);
                //translate to 0,0.
                g.TranslateTransform(-(Location.X), -(Location.Y));
                Draw(g);
            return buildbit;    
            
        }
        public override void Draw(Graphics g)
        {
            Image currimage = GetCurrentImage();
            if (currimage == null)
            {
                Debug.Print("BREAK");

            }
            var copyt = g.Transform.Clone();
            PointF DrawLocation = Location;
            if (Math.Abs(DrawRotation) > 0.1f)
            {
                 

                g.TranslateTransform(DrawSize.Width / 2 + DrawLocation.X, DrawSize.Height / 2 + DrawLocation.Y);
                g.RotateTransform(DrawRotation);
                g.TranslateTransform(-DrawSize.Width / 2, -DrawSize.Height / 2);
                DrawLocation = new PointF(0, 0);
            }
            

            if (DrawSize != null)
            {
                if (DrawAttributes == null)
                {
                    //g.DrawImage(GetCurrentImage(), Location.X, Location.Y, DrawSize.Value.Width, DrawSize.Value.Height);
                    g.DrawImage(GetCurrentImage(), DrawLocation.X, DrawLocation.Y, DrawSize.Width, DrawSize.Height);
                }
                else
                {
                 
                    //g.DrawImage(BlockImage, new Rectangle((int)BlockRectangle.Left, (int)BlockRectangle.Top, (int)BlockRectangle.Width, (int)BlockRectangle.Height), 0f, 0f, BlockImage.Width, BlockImage.Height, GraphicsUnit.Pixel, DrawAttributes);
                    g.DrawImage(currimage, new Rectangle((int)DrawLocation.X, (int)DrawLocation.Y, (int)DrawSize.Width, (int)DrawSize.Height), 0f, 0f, currimage.Width, currimage.Height, GraphicsUnit.Pixel, DrawAttributes);
                    //g.DrawImage(GetCurrentImage(), Location.X, DrawSize.Value.Width, DrawSize.Value.Height, DrawAttributes);
                }
            }
            else
            {

                if(DrawAttributes==null)
                    g.DrawImage(GetCurrentImage(), DrawLocation);
                else
                    g.DrawImage(currimage, new Rectangle((int)DrawLocation.X, (int)DrawLocation.Y, (int)currimage.Width, (int)currimage.Height), 0f, 0f, currimage.Width, currimage.Height, GraphicsUnit.Pixel, DrawAttributes);
                
            }
            g.Transform=copyt;
            if (this is iImagable)
            {
                //some Enemies implement interfaces that provide location, size, and speed information.
                //we will use this to draw a HP bar above those enemies.
                //this is just a testing feature...
                

                //first, decide where to draw it.
                iImagable refprojectile = this as iImagable;
                var ourrect = refprojectile.getRectangle();
                //3 pixels high.
                Rectangle HPBar = new Rectangle(ourrect.Left - 2, ourrect.Top - 3, ourrect.Width + 4, 2);
                if (!g.ClipBounds.Contains(HPBar))
                    HPBar.Offset(0, ourrect.Height + 3);
                
                float healthpercent = (float)HitPoints / (float)MaxHitPoints;
                Rectangle fullbar = new Rectangle(HPBar.Left, HPBar.Top, (int)(Math.Ceiling((float)HPBar.Width * healthpercent)), HPBar.Height);
                g.FillRectangle(Brushes.White, HPBar);
                using (SolidBrush usebrush = new SolidBrush(BCBlockGameState.MixColor(Color.Red, Color.Lime, (float)HitPoints / (float)MaxHitPoints)))
                {
                    g.FillRectangle(usebrush, fullbar);
                }
                g.DrawRectangle(Pens.Black, HPBar);




            }
           

            //throw new NotImplementedException();
        }
    }
    [Bossable]
    public class SnakeEnemy : GameEnemy, IDeserializationCallback
    {
        public enum SnakeMoveDirection
        {
            SnakeMove_Left,
            SnakeMove_Up,
            SnakeMove_Right,
            SnakeMove_Down





        }
        private SizeF createblockSize = new SizeF(8, 8);
        private DateTime lastcall = DateTime.Now;
        private int FrameDelay = 500;
        private bool killed = false;
        public PointF BlockSpeed = new PointF(0, 1);
        public Type BlockTypeCreate = typeof(DemonBlock);
        public int MaxLength = 25;
        private Block SnakeHead = null;
        private const int gridsize = 15;
        private Queue<Block> snakecomponents = new Queue<Block>();
        public SnakeEnemy(Block[] usesegments, int Milliframedelay)
            : base(usesegments[usesegments.Length - 1].BlockLocation, null, Milliframedelay)
        {
            snakecomponents = new Queue<Block>();
            //element 0 is the tail; the last element is our new "head". as such ,to make our queue, we need to enqueue from the "last" item (the head) to the first item.
            for (int i = 0; i < usesegments.Length; i++)
            {
                snakecomponents.Enqueue(usesegments[i]);
                if (i == usesegments.Length)
                    usesegments[i].OnBlockHit += SnakeHead_OnBlockHit;
                else
                    usesegments[i].OnBlockDestroy += SnakeBody_OnBlockDestroy;








            }
            SnakeHead = usesegments[usesegments.Length - 1];
            BlockTypeCreate = SnakeHead.GetType();



        }
        public SnakeEnemy(PointF pPosition)
            : this(pPosition, 150)
        {
        }

        public SnakeEnemy(PointF pPosition, int MilliFrameDelay)
            : this(pPosition, MilliFrameDelay, typeof(NormalBlock))
        {

        }
        public override int GetScoreValue()
        {
            return 4000;
        }
        public SnakeEnemy(PointF pPosition, int MilliFrameDelay, Type pBlockTypeCreate)
            : base(pPosition, null, MilliFrameDelay)
        {
            if (!pBlockTypeCreate.IsSubclassOf(typeof(Block)))
            {

                throw new ArgumentException("Snakes can only be made of blocks", "pBlockTypeCreate");

            }
            BlockTypeCreate = pBlockTypeCreate;
            FrameDelay = MilliFrameDelay;
            Location = pPosition;


        }
        private PointF[] prospectivedirections = new PointF[] { new PointF(0, 1), new PointF(1, 0), new PointF(0, -1), new PointF(-1, 0) };

        private SnakeMoveDirection GetCurrentDirection()
        {
            if (BlockSpeed.X == 0 && BlockSpeed.Y == 1)
            {
                return SnakeMoveDirection.SnakeMove_Down;


            }
            else if (BlockSpeed.X == 0 && BlockSpeed.Y == -1)
            {
                return SnakeMoveDirection.SnakeMove_Up;
            }
            else if (BlockSpeed.X == -1 && BlockSpeed.Y == 0)
            {
                return SnakeMoveDirection.SnakeMove_Left;
            }
            else if (BlockSpeed.X == 1 && BlockSpeed.Y == 0)
            {
                return SnakeMoveDirection.SnakeMove_Right;
            }
            return SnakeMoveDirection.SnakeMove_Right;

        }
        private int GetWeightForDirection(int[,] gridweights, SnakeMoveDirection direction)
        {
            int midspot = (gridsize / 2);
            int startx = 0, starty = 0, endx = 0, endy = 0;

            switch (direction)
            {
                case SnakeMoveDirection.SnakeMove_Up:
                    startx = 0;
                    endx = gridsize;
                    starty = 0;
                    endy = midspot;
                    break;
                case SnakeMoveDirection.SnakeMove_Left:
                    startx = 0;
                    endx = midspot;
                    starty = 0;
                    endy = gridsize;
                    break;
                case SnakeMoveDirection.SnakeMove_Down:
                    startx = 0;
                    endx = gridsize;
                    starty = gridsize - midspot;
                    endy = gridsize;

                    break;
                case SnakeMoveDirection.SnakeMove_Right:
                    startx = gridsize - midspot;
                    endx = gridsize;
                    starty = 0;
                    endy = gridsize;
                    break;



            }
            int accumtotal = 0;

            for (int loopx = startx; loopx < endx; loopx++)
            {
                for (int loopy = starty; loopy < endy; loopy++)
                {
                    accumtotal += gridweights[loopx, loopy];


                }



            }


            return accumtotal;

        }
        private PointF directionToSpeed(SnakeMoveDirection convertdirection)
        {
            switch (convertdirection)
            {
                case SnakeMoveDirection.SnakeMove_Up:
                    return new PointF(0, -1);

                case SnakeMoveDirection.SnakeMove_Left:
                    return new PointF(-1, 0);
                case SnakeMoveDirection.SnakeMove_Down:
                    return new PointF(0, 1);
                    break;
                case SnakeMoveDirection.SnakeMove_Right:
                    return new PointF(1, 0);
                    break;



            }
            return new PointF(0, 1);



        }

        private SnakeMoveDirection[] GetProspectiveDirections(SnakeMoveDirection currentdirection)
        {
            switch (currentdirection)
            {
                case SnakeMoveDirection.SnakeMove_Up:
                    return new SnakeMoveDirection[] { SnakeMoveDirection.SnakeMove_Left, SnakeMoveDirection.SnakeMove_Up, SnakeMoveDirection.SnakeMove_Right };
                    break;
                case SnakeMoveDirection.SnakeMove_Down:
                    return new SnakeMoveDirection[] { SnakeMoveDirection.SnakeMove_Right, SnakeMoveDirection.SnakeMove_Down, SnakeMoveDirection.SnakeMove_Left };
                    break;
                case SnakeMoveDirection.SnakeMove_Left:
                    return new SnakeMoveDirection[] { SnakeMoveDirection.SnakeMove_Down, SnakeMoveDirection.SnakeMove_Left, SnakeMoveDirection.SnakeMove_Up };
                    break;
                case SnakeMoveDirection.SnakeMove_Right:
                    return new SnakeMoveDirection[] { SnakeMoveDirection.SnakeMove_Up, SnakeMoveDirection.SnakeMove_Right, SnakeMoveDirection.SnakeMove_Down };
                    break;
            }

            return null;
        }





        private int IsBlockAtPos(BCBlockGameState statein, PointF poscheck)
        {
            return (from n in statein.Blocks where n.BlockRectangle.Contains(poscheck) select n).Count();



        }
        private int getPosWeight(BCBlockGameState statein, PointF poscheck)
        {
            //the way the simple AI works is that it basically interprets the world in units of it's size.
            //the AI itself basically has to choose to either turn left, go straight, or turn right.
            //too simplify this I currently use a small 9x9 grid; if a block occupies a given location or that location is outside the bounds of the level,
            //the grid value will be false. Otherwise, it will be true. the decision of which direction to turn is based on the values in the grid. (whichever prospective direction has the most true values).
            //*changed right now to ints, whichever direction has the lowest sum).

            if (!statein.GameArea.Contains((int)poscheck.X, (int)poscheck.Y))
            {
                return 3;


            }
            else 
                return 2 * IsBlockAtPos(statein,poscheck);
         





        }
        private int[,] getAIGridData(BCBlockGameState gamestate)
        {
            if (SnakeHead == null) return null;

            int middlespot = (int)Math.Ceiling((float)gridsize / 2); //should be five for gridsize of 9.
            SizeF totalgridsize = new SizeF(gridsize * createblockSize.Width, gridsize * createblockSize.Height);
            SizeF halfgridsize = new SizeF(totalgridsize.Width / 2, totalgridsize.Height / 2);
            int[,] returngrid = new int[gridsize, gridsize];

            PointF centralPoint = SnakeHead.CenterPoint();

            for (int x = 0; x < gridsize; x++)
            {
                float Xuse = ((centralPoint.X - halfgridsize.Width) + (createblockSize.Width * x));
                for (int y = 0; y < gridsize; y++)
                {
                    float Yuse = ((centralPoint.Y - halfgridsize.Height) + (createblockSize.Height * y));
                    //at 0, we want to be at centerpoint-(blockwidth*middlespot)
                    returngrid[x, y] = getPosWeight(gamestate, new PointF(Xuse, Yuse));






                }


            }



            return returngrid;




        }

        //private PointF[] getprospectiveDirections(BCBlockGameState gamestate, PointF currentdirection)
        //{
        //    float xpart = currentdirection.X;
        //    float ypart = currentdirection.Y;




        //}

        private void CalcAI(BCBlockGameState gamestate)
        {
            Random rg = BCBlockGameState.rgen;
            //currently changes the snake direction randomly.
            //if (rg.NextDouble() < 0.1)
            //{
            //BlockSpeed = prospectivedirections[rg.Next(0,prospectivedirections.Length)];

            //}
            sincelastchange++;
            if (sincelastchange > 2)
            {

                SnakeMoveDirection[] snakedirections = GetProspectiveDirections(GetCurrentDirection());
                //get the list of possible directions to go.

                //calculate the grid weights around the snakes head.
                int[,] gridweight = getAIGridData(gamestate);
                if (gridweight != null)
                {
                    //corrdirections: corresponds to SnakeMoveDirection Array, containing the accumulated value of that direction from the grid.
                    int[] corrdirections = new int[snakedirections.Length];
                    int currmin = int.MaxValue, minindex = -1;

                    for (int i = 0; i < snakedirections.Length; i++)
                    {
                        corrdirections[i] = GetWeightForDirection(gridweight, snakedirections[i]);
                        if (corrdirections[i] < currmin)
                        {
                            currmin = corrdirections[i];
                            minindex = i;


                        }

                    }

                    Debug.Print("Current Direction is " + Enum.GetName(typeof(SnakeMoveDirection), GetCurrentDirection()) +
                        " Chosen direction is " + Enum.GetName(typeof(SnakeMoveDirection), snakedirections[minindex]));

                    //we have our direction now; the snakedirection corresponding to the minimum.
                    if (snakedirections[minindex] != GetCurrentDirection()) sincelastchange = 0;
                    BlockSpeed = directionToSpeed(snakedirections[minindex]);


                }
            }




        }

        private Block CreateNewBlock(BCBlockGameState gamestate, PointF poscreate)
        {

            //Block createdblock = new NormalBlock(new RectangleF(poscreate, createblockSize), new SolidBrush(Color.Red), new Pen(Color.Black));
            Block createdblock = (Block)Activator.CreateInstance(BlockTypeCreate, new object[] { new RectangleF(poscreate, createblockSize) });
            if (createdblock is NormalBlock)
            {
                NormalBlock nb = createdblock as NormalBlock;
                nb.BlockColor = Color.Red;
                nb.PenColor = Color.Black;


            }
            lock (gamestate.Blocks)
                gamestate.Blocks.AddLast(createdblock);
            gamestate.Forcerefresh = true;
            return createdblock;
        }
        private int sincelastchange = 0; //number of frames since the last direction change.
        public override bool PerformFrame(BCBlockGameState gamestate)
        {
            //return base.PerformFrame(gamestate, ref AddObjects, ref removeobjects);
            //DON'T call the base; the snake isn't implemented like some other enemies, in that most of it's "matter" is really just a line of blocks.
            //Debug.Print("Snake performframe");
            //Debug.Print("Millis:" + (DateTime.Now - lastcall).TotalMilliseconds.ToString());
            if ((DateTime.Now - lastcall).TotalMilliseconds > FrameDelay)
            {
                if (!killed)
                {
                    //perform a Frame. duh
                    //calculated AI.
                    CalcAI(gamestate);

                    //AI has been calculated, so now we want to add a new block, and if our queue is longer then our maximum length, remove the tail.

                    //for the sake of brevity, the "Position" value will indicate the upper left corner of the "head" piece.
                    PointF useoffset = new PointF(createblockSize.Width * BlockSpeed.X,
                                                  createblockSize.Height * BlockSpeed.Y);
                    //retrieve the new coordinates to add the newest entry...
                    PointF newheadposition = new PointF(Location.X + useoffset.X, Location.Y + useoffset.Y);

                    //create the new block.
                    Block createdblock = CreateNewBlock(gamestate, newheadposition);
                    //stop hooking events from the previous snake head.
                    if (SnakeHead != null)
                    {
                        SnakeHead.OnBlockHit -= SnakeHead_OnBlockHit;
                        SnakeHead.OnBlockDestroy += SnakeBody_OnBlockDestroy;
                    }

                    SnakeHead = createdblock;
                    snakecomponents.Enqueue(SnakeHead);
                    SnakeHead.OnBlockHit += SnakeHead_OnBlockHit;
                    Location = SnakeHead.BlockLocation;
                    while (snakecomponents.Count > MaxLength)
                    {
                        //remove tail bits until our length is appropriate.
                        Block deq = snakecomponents.Dequeue();
                        //remove this block from the game.
                        gamestate.Blocks.Remove(deq);

                    }

                }
                else
                {
                    //killed is true; so animate the snakes GRISLY DEMISE.
                    //dequeue the block...
                    if (snakecomponents.Count == 0) return true;
                    Block deq = snakecomponents.Dequeue();
                    while (!gamestate.Blocks.Contains(deq) && deq != null && snakecomponents.Count > 0)
                    {
                        deq = snakecomponents.Dequeue();
                    }
                    //skip blocks that aren't part of the snake anymore for whatever reason (or that are part of the snake but were destroyed in the meantime)


                    //remove it from the game as well.
                    if (snakecomponents.Count > 0)
                    {
                        if (deq != SnakeHead)
                        {
                            gamestate.Blocks.Remove(deq);
                            BCBlockGameState.Soundman.PlaySound("gren");
                            //   PointF eo = deq.CenterPoint();
                            deq.StandardSpray(gamestate);
                            deq.AddScore(gamestate, 5);
                        }
                        else
                        {
                            gamestate.Blocks.Remove(deq);
                            BCBlockGameState.Soundman.PlaySound("bomb");
                            deq.StandardSpray(gamestate);
                            deq.AddScore(gamestate, 25);
                            gamestate.GameObjects.AddLast(new ExplosionEffect(deq.CenterPoint(), 48));


                        }
                    }


                    /*for (int i = 0; i < 50; i++)
                    {
                        Random rg = BCBlockGameState.rgen;
                        PointF genpoint = new PointF((float)(eo.X + (rg.NextDouble() * createblockSize.Width)), (float)(eo.Y + (rg.NextDouble() * createblockSize.Height)));
                        DustParticle dp = new DustParticle(genpoint, 5f);
                        gamestate.Particles.Add(dp);


                    }*/



                }


                lastcall = DateTime.Now;
                gamestate.Forcerefresh = true;
            }




            return snakecomponents.Count ==0;
        }
        void SnakeBody_OnBlockDestroy(Object Sender,BlockHitEventArgs<bool> e )
        {
            if (e.TheBlock == SnakeHead || killed)
            {
                e.Result = true;
                //return;  //when already dying, ignore.
            }
            Debug.Print("Snake's body was Destroyed...");
            //first, convert our queue into an LinkedList, to make this work a little easier.

            Queue<Block> newsnake = new Queue<Block>();
            //Queue<Block> refreshus = new Queue<Block>();
            //Block[] usearray = snakecomponents.ToArray();
            //the "tail" will be the first element, the last element will be the "head" block.
            
            //PSUEDOCODE:
            //use dequeue on OUR snake segments, adding each one to another queue, and unhooking out event handlers.
            Block removeit = null;
            while (removeit != e.TheBlock)
            {
                removeit = snakecomponents.Dequeue();
                removeit.OnBlockDestroy -= SnakeBody_OnBlockDestroy;
                //remove from game as well.
                removeit.AddScore(e.GameState, 5);
                removeit.StandardSpray(e.GameState);
                BCBlockGameState.Soundman.PlaySound("gren");
                e.GameState.Blocks.Remove(removeit);
                //newsnake.Enqueue(removeit);

            }
            //newsnake is the proper size.
            //commented out: was adding snakes instead :P but found it to be a huge pain in the rear.
            //Block[] snakesegments = newsnake.ToArray();
            //SnakeEnemy se = new SnakeEnemy(snakesegments, FrameDelay);
            //gamestate.GameObjects.AddLast(se);






            e.Result = true;
//            return true; //extra work should be done here to "split" the snake in half at the block.

        }

        void SnakeHead_OnBlockHit(Object sender,BlockHitEventArgs<bool> e )
        {
            //Note: this is Onblock <HIT> because we want the snake to be "defeatable" regardless of the behaviour of the block; so if the head block
            //is hit at all the snake dies.
            if (!killed)
            {
                Debug.Print("The snake has been killed. The horror!");
                FrameDelay *= 3;
                killed = true;

            }
            e.Result = true;
        }
        public override void Draw(Graphics g)
        {
            //amazingly- Do nothing! All the drawing will be managed by the Levelset and blocks and whatnot.

        }


        #region IDeserializationCallback Members

        public void OnDeserialization(object sender)
        {
            //throw new NotImplementedException();
            foreach (EnemyTrigger looptrigger in base.Triggers)
            {

                looptrigger.OurEnemy = this;

            }
        }

        #endregion

        #region iLocatable Members

        /*
        public new PointF Location
        {
            get
            {
                if(SnakeHead!=null)
                    return SnakeHead.CenterPoint();

                return new PointF(0, 0);
            }
            set
            {
                //not truly supported...
                //throw new NotImplementedException();

            }
        }
        */
        #endregion
    }
   


    public class ShootSpinner : SpinnerGuy
    {

       

        [Editor(typeof(ItemTypeEditor<iProjectile>),typeof(UITypeEditor))]
        private Type _ShootType = typeof(LaserShot);

        public Type ShootType { get { return _ShootType; } set { _ShootType = value; } }
        

        public ShootSpinner(PointF pPosition)
            : this(pPosition, new SizeF(16, 16))
        {

        }
        public ShootSpinner(PointF pPosition, SizeF usesize)
            : base(pPosition,usesize)
        {


        }
        public override int GetScoreValue()
        {
            return 400;
        }
        protected override void Shoot(BCBlockGameState gamestate)
        {
            float UseVelocity = 4;
            float useangle = (float)((DrawRotation / 360) * (2 * Math.PI));
            //calculate the velocity....
            PointF projectilespeed = new PointF((float)(Math.Cos(useangle) * UseVelocity), (float)(Math.Sin(useangle) * UseVelocity));
            projectilespeed = new PointF(projectilespeed.X + base.VelocityUse.X, projectilespeed.Y + base.VelocityUse.Y);
            //type has to have a constructor that accepts a Location and Speed.
            if (_ShootType == typeof(LaserShot))
            {
                LaserShot shootbullet = new LaserShot(GetRectangle().CenterPoint(), projectilespeed);
                shootbullet.DamagesPaddle = true;
                shootbullet.Weak = true;
                gamestate.Defer(() =>
                {
                    gamestate.GameObjects.AddLast(shootbullet);
                    BCBlockGameState.Soundman.PlaySound("FIRELASER", 1.0f);
                });
            }
            else
 …

Large files files are truncated, but you can click here to view the full file