/Poing2/frmBaseBlock.cs

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

/*
 * BASeCamp BASeBlock
Copyright (c) 2011, Michael Burgwin
All rights reserved.

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

    Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
    Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
    Neither the name of BASeCamp Corporation nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 * */


using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.IO;
using System.Linq;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
using System.Threading;
using System.Windows.Forms;
using System.Security;
//using System.Windows.Media;
using BASeCamp.BASeBlock.Blocks;
using BASeCamp.BASeBlock.Cheats;
using BASeCamp.BASeBlock.Events;
using BASeCamp.BASeBlock.GameObjects;
using BASeCamp.BASeBlock.GameObjects.Orbs;
using BASeCamp.BASeBlock.PaddleBehaviours;
using BASeCamp.BASeBlock.Particles;
using BASeCamp.Configuration;
using BASeCamp.BASeBlock.GameStates;
using BASeCamp.BASeBlock.HighScores;
using BASeCamp.Updating;
using BASeCamp.Licensing;


using Brush=System.Drawing.Brush;
using Color=System.Drawing.Color;
using Pen=System.Drawing.Pen;
using ThreadState=System.Threading.ThreadState;
using Timer = System.Threading.Timer;

namespace BASeCamp.BASeBlock
{
    public partial class frmBaseBlock : Form,iGameClient ,iManagerCallback 
    {
        [DllImport("user32.dll")]
        public static extern int SendMessage(IntPtr hWnd, Int32 wMsg, bool wParam, Int32 lParam);
        public IGameState ActiveState { get { return gamerunstate;} set { gamerunstate = value;}}
        private const int WM_SETREDRAW = 11;

        





        public int[][] GameOverMatrix = new int[][]
       {
           new int[]{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,},
           new int[]{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,},
           new int[]{0,1,1,1,1,1,1,0,0,0,1,1,0,0,0,1,1,1,0,0,1,1,1,0,1,1,1,1,1,1,},
           new int[]{0,1,1,1,1,1,1,0,0,1,1,1,1,0,0,1,1,1,0,0,1,1,1,0,1,1,1,1,1,1,},
           new int[]{0,1,1,0,0,0,0,0,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,0,1,1,0,0,0,0,},
           new int[]{0,1,1,0,1,1,1,0,1,1,0,0,1,1,0,1,1,0,1,1,0,1,1,0,1,1,1,1,0,0,},
           new int[]{0,1,1,0,1,1,1,0,1,1,1,1,1,1,0,1,1,0,0,0,0,1,1,0,1,1,1,1,0,0,},
           new int[]{0,1,1,0,0,1,1,0,1,1,0,0,1,1,0,1,1,0,0,0,0,1,1,0,1,1,0,0,0,0,},
           new int[]{0,1,1,1,1,1,1,0,1,1,0,0,1,1,0,1,1,0,0,0,0,1,1,0,1,1,1,1,1,1,},
           new int[]{0,1,1,1,1,1,1,0,1,1,0,0,1,1,0,1,1,0,0,0,0,1,1,0,1,1,1,1,1,1,},
           new int[]{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,},
           new int[]{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,},
           new int[]{0,1,1,1,1,1,1,0,1,1,0,0,1,1,0,0,1,1,1,1,1,1,0,0,1,1,1,1,0,0,},
           new int[]{0,1,1,1,1,1,1,0,1,1,0,0,1,1,0,0,1,1,1,1,1,1,0,0,1,1,1,1,1,0,},
           new int[]{0,1,1,0,0,1,1,0,1,1,0,0,1,1,0,0,1,1,0,0,0,0,0,0,1,1,0,0,1,1,},
           new int[]{0,1,1,0,0,1,1,0,1,1,0,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,0,0,1,1,},
           new int[]{0,1,1,0,0,1,1,0,1,1,0,0,1,1,0,0,1,1,1,1,0,0,0,0,1,1,1,1,1,0,},
           new int[]{0,1,1,0,0,1,1,0,1,1,0,0,1,1,0,0,1,1,0,0,0,0,0,0,1,1,1,1,1,1,},
           new int[]{0,1,1,1,1,1,1,0,0,1,1,1,1,0,0,0,1,1,1,1,1,1,0,0,1,1,0,0,1,1,},
           new int[]{0,1,1,1,1,1,1,0,0,0,1,1,0,0,0,0,1,1,1,1,1,1,0,0,1,1,0,0,1,1,},
           new int[]{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,},
           new int[]{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,},
           new int[]{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,},
           new int[]{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,},
           new int[]{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,},
       };


        private int MaxParticles = 800;

       

        public class MenuModeMenuItem
        {
            public class MenuItemStyleData
            {
                
                //private Color _BackColor = Color.White;
                //private Color _ForeColor = Color.Black;
                
                private Brush _Background = new SolidBrush(Color.White);
                private Brush _Foreground = new SolidBrush(Color.Black);
                private Pen _BoxBorder = new Pen(Color.Black);
                

                public Brush Background { get { return _Background; } set { _Background = value; } }
                public Brush Foreground { get { return _Foreground; } set { _Foreground = value; } }
                public Pen BoxBorder { get { return _BoxBorder; } set { _BoxBorder = value; } }
                    private Color _BackColor, _ForeColor;


                public Color BackColor
                {
                    get { return _BackColor; }
                    set
                    {
                        _BackColor = value;
                        _Background = new SolidBrush(_BackColor);
                    }
                }
                public Color ForeColor
                {
                    get { return _ForeColor; }
                    set
                    {
                        _ForeColor = value;
                        _Foreground = new SolidBrush(_ForeColor);
                    }
                }
                private Font _ItemFont = new Font("Arial", 14);

                public Font ItemFont { get { return _ItemFont; } set { _ItemFont = value; } }
                public MenuItemStyleData()
                {

                }

                public MenuItemStyleData(Color pBackColor, Color pForeColor,Font pItemFont)
                {
                    BackColor = pBackColor;
                    ForeColor = pForeColor;
                    ItemFont = pItemFont;


                }

            }

            public delegate void MenuItemEvent(MenuModeMenuItem sender);
            public delegate void MenuItemPrePaintEvent(MenuModeMenuItem sender, RectangleF drawarea);

            public event MenuItemEvent MenuItemSelect;
            public event MenuItemEvent MenuItemUnselect;
            public event MenuItemEvent MenuItemChosen;
            public event MenuItemPrePaintEvent MenuItemPrePaint;


            public void InvokeItemPrePaint(RectangleF drawarea)
            {
                var temp = MenuItemPrePaint;
                if (temp != null) temp.Invoke(this,drawarea);



            }

            public void InvokeItemSelect()
            {
                var temp = MenuItemSelect;
                if (temp != null) temp.Invoke(this);
                
            }
            public void InvokeItemUnselect()
            {
                var temp = MenuItemUnselect;
                if (temp != null) temp.Invoke(this);

            }
            public void InvokeItemChosen()
            {
                var temp = MenuItemChosen;
                if (temp != null) temp.Invoke(this);

            }

            private Object _Tag = null;
            public Object Tag { get { return _Tag; } set { _Tag = value; } }
            private String _Text;

            

            private MenuModeMenuItem.MenuItemStyleData Style = new MenuModeMenuItem.MenuItemStyleData(Color.White,Color.Black,new Font("Arial",14));
            private MenuModeMenuItem.MenuItemStyleData SelStyle = new MenuModeMenuItem.MenuItemStyleData(Color.Black,Color.Yellow,new Font("Arial",14,FontStyle.Bold))  ;
            private bool _Selected=false;

            

            public bool Selected { get { return _Selected; } set { _Selected = value; } }
            public MenuModeMenuItem.MenuItemStyleData OurStyle { get {
                return Selected?SelStyle:Style;
                



            } }
                public delegate void ItemActionProc(MenuModeMenuItem sender);
            private ItemActionProc _Action;
            public ItemActionProc Action { get { return _Action; } set { _Action = value; } }

            private static Graphics useg = null;
            private static bool ginitialized;
            public SizeF MeasureItem()
            {
                if (!ginitialized)
                {
                    Bitmap useb = new Bitmap(1, 1);
                    useg = Graphics.FromImage(useb);



                }

                SizeF gotsize = useg.MeasureString(_Text, OurStyle.ItemFont);


                return new SizeF(gotsize.Width*1.5f,gotsize.Height);

            }
         public MenuModeMenuItem(String Text,ItemActionProc MenuAction)
        {
            _Text=Text;
            _Action = MenuAction;
            SelStyle.BoxBorder = new Pen(Color.Red, 3);
            Style.BoxBorder = new Pen(Color.White, 1);
        }

        public String Text { get { return _Text; } set { _Text = value; } }


            public void Draw(Graphics g, RectangleF drawArea)
            {
                MenuModeMenuItem.MenuItemStyleData usestyle = OurStyle;
                InvokeItemPrePaint(drawArea);
                g.FillRectangle(usestyle.Background, drawArea);
                StringFormat useformat = new StringFormat();
                useformat.Alignment=StringAlignment.Center;
                g.DrawRectangle(usestyle.BoxBorder, drawArea.ToRectangle());
                g.DrawString(_Text, OurStyle.ItemFont, usestyle.Foreground , drawArea,useformat);
                

            }



        }
        public class MenuModeData
        {
            //list of menu items.
            private String _MenuMusic = "credit";
            private String _MenuTitle = "MENU";
            private Font _TitleFont = new Font("Arabia", 18);
            public String MenuTitle { get { return _MenuTitle; } set { _MenuTitle = value; } }
                public String MenuMusic { get { return _MenuMusic; } set { _MenuMusic = value; } }
                public LinkedList<MenuModeMenuItem> items = new LinkedList<MenuModeMenuItem>();

                private MenuModeMenuItem _SelectedItem = null;

            //accessor which "unselects" (untoggles) the currently selected items selected state when a new one is assigned, and sets the new one.
                public MenuModeMenuItem SelectedItem
                {
                    get {return _SelectedItem; }
                    set {
                        if (_SelectedItem != null)
                        {
                            _SelectedItem.Selected=false;

                        }
                        _SelectedItem=value;
                        _SelectedItem.Selected = true;

                    }

                }
            public MenuModeData(IEnumerable<MenuModeMenuItem> pitems, MenuModeMenuItem.MenuItemEvent SelectEvent, MenuModeMenuItem.MenuItemEvent UnselectEvent, MenuModeMenuItem.MenuItemEvent ChosenEvent)
            {
                
                foreach (var loopit in pitems)
                {
                    var itemadd = loopit;
                    itemadd.MenuItemSelect += SelectEvent;
                    itemadd.MenuItemUnselect += UnselectEvent;
                    itemadd.MenuItemChosen += ChosenEvent;
                    
                    items.AddLast(itemadd);


                }


            }

           
            public void MenuAction(MenuModeMenuItem sender)
            {


            }
            public MenuModeMenuItem HitTest(BCBlockGameState gstate,PointF testpoint)
            {
                //like the draw routine, we need to acquire the calculated sizes. We just don't draw.
                //calculations. First, get a SizeF from each menu item...

                List<SizeF> allsizes = (from n in items select n.MeasureItem()).ToList();

                //get maximum width...
                float totalheight = 0;
                foreach (var loopsize in allsizes)
                {
                    totalheight += loopsize.Height;

                }
                float maxwidth = (from n in allsizes orderby n.Width descending select n).First().Width;

                //center the rectangle maxwidth,totalheight in the gamearea.

                RectangleF EntireSizeRect = BCBlockGameState.CenterRect(gstate.GameArea,
                                                                        new SizeF(maxwidth, totalheight));


                //title rect will be centered above the entiresize rect. First, we need to measure the title...
                SizeF titlesize = BCBlockGameState.MeasureString(_MenuTitle, _TitleFont);

                if (titlesize.Width < EntireSizeRect.Width)
                {
                    titlesize = new SizeF(EntireSizeRect.Width, titlesize.Height);


                }
                PointF TopCenter = new PointF(EntireSizeRect.Left + EntireSizeRect.Width / 2, EntireSizeRect.Top);
                RectangleF TitleRect = new RectangleF(TopCenter.X - titlesize.Width / 2, TopCenter.Y - titlesize.Height,
                                                      titlesize.Width, titlesize.Height);

               


                //EntireSizeRect = new RectangleF(EntireSizeRect.Left - 20, EntireSizeRect.Top - 20, EntireSizeRect.Width + 20, EntireSizeRect.Height + 20);
                float currx = EntireSizeRect.Left;
                float currY = EntireSizeRect.Top;


                //go through each one and calculate it's rectangle, then see if the given position is inside it.
                float selectedY = 0;
                MenuModeMenuItem selecteditemuse = null;
                foreach (var loopitem in items)
                {
                    var loopiheight = loopitem.MeasureItem();
                   
                    loopitem.Selected = loopitem == SelectedItem;
                    {
                   
                   
                        currY += loopiheight.Height;
                        RectangleF testrect = new RectangleF(new PointF(currx, currY),
                                                         new SizeF(maxwidth, loopiheight.Height));
                        if (testrect.Contains(testpoint))
                        {

                            return loopitem;
                        }
                    }


                }

            return null; //no hit...



            }

            public void Draw(Graphics g, BCBlockGameState gstate)
            {
                //calculations. First, get a SizeF from each menu item...

                List<SizeF> allsizes = (from n in items select n.MeasureItem()).ToList();

                //get maximum width...
                float totalheight = 0;
                foreach (var loopsize in allsizes)
                {
                    totalheight += loopsize.Height;

                }
                float maxwidth = (from n in allsizes orderby n.Width descending select n).First().Width;

                //center the rectangle maxwidth,totalheight in the gamearea.

                RectangleF EntireSizeRect = BCBlockGameState.CenterRect(gstate.GameArea,
                                                                        new SizeF(maxwidth, totalheight));


                //title rect will be centered above the entiresize rect. First, we need to measure the title...
                SizeF titlesize = BCBlockGameState.MeasureString(_MenuTitle, _TitleFont);

                if (titlesize.Width < EntireSizeRect.Width)
                {
                    titlesize = new SizeF(EntireSizeRect.Width, titlesize.Height);


                }
                PointF TopCenter = new PointF(EntireSizeRect.Left + EntireSizeRect.Width/2, EntireSizeRect.Top);
                RectangleF TitleRect = new RectangleF(TopCenter.X - titlesize.Width/2, TopCenter.Y - titlesize.Height,
                                                      titlesize.Width, titlesize.Height);

                //draw the title.
                g.FillRectangle(new SolidBrush(Color.Green), TitleRect);
                g.DrawRectangle(new Pen(Color.Yellow, 3), TitleRect.ToRectangle());
                g.DrawString(_MenuTitle, _TitleFont, new SolidBrush(Color.White), TitleRect);



                //EntireSizeRect = new RectangleF(EntireSizeRect.Left - 20, EntireSizeRect.Top - 20, EntireSizeRect.Width + 20, EntireSizeRect.Height + 20);
                float currx = EntireSizeRect.Left;
                float currY = EntireSizeRect.Top;


                //go through each one and draw it.
                float selectedY = 0;
                MenuModeMenuItem selecteditemuse = null;
                foreach (var loopitem in items)
                {
                    var loopiheight = loopitem.MeasureItem();
                    //defer drawing if selected item for last... save info when we encounter it, and then use that info after the loop.
                    loopitem.Selected = loopitem == SelectedItem;
                    {
                        if (loopitem.Selected)
                        {
                            selectedY = currY;
                            selecteditemuse = loopitem;
                        }
                        else
                        {
                            loopitem.Draw(g,
                                          new RectangleF(new PointF(currx, currY),
                                                         new SizeF(maxwidth, loopiheight.Height)));
                        }
                        currY += loopiheight.Height;

                    }


                }

                //draw the selected item...
                if (selecteditemuse != null)
                {

                    selecteditemuse.Draw(g,new RectangleF(new PointF(currx,selectedY),new SizeF(maxwidth,selecteditemuse.MeasureItem().Height)));
                }
            







        }

            public MenuModeData(String[] MenuItems,MenuModeMenuItem.MenuItemEvent SelectEvent,MenuModeMenuItem.MenuItemEvent UnselectEvent,MenuModeMenuItem.MenuItemEvent ChosenEvent,MenuModeMenuItem.MenuItemPrePaintEvent prepaint )
            {
                //constructor that accepts a bunch of strings, and the event assignments.
                
                foreach (String loopit in MenuItems)
                {
                    var itemadd = new MenuModeMenuItem(loopit, MenuAction);
                    itemadd.MenuItemSelect += SelectEvent;
                    itemadd.MenuItemUnselect += UnselectEvent;
                    itemadd.MenuItemChosen += ChosenEvent;
                    itemadd.MenuItemPrePaint += prepaint;
                    items.AddLast(itemadd);


                }

            }


        }


        private String GameOverHiScores = "";
        private DateTime lastscoreshow;
        private int Nextshowhiscore = 1; //next hi score to be shown by the "Game Over" screen...
        
        private Graphics pcgraph;
        //private Image GameAreaImage; //used during level complete tally...
        private Bitmap BackBufferBitmap;
        private Graphics backBufferCanvas;
        private List<String> RecentCheats = new List<string>();
        private int currentcheatsel = 0; //<<index into the list of the currently "selected" cheat; only really valid for a single
        private int currentcheatcharpos = 0; //position within cheat string, will be changable via arrow keys, home, end, etc.
                                        //"session" of the cheat "window".
        public bool DemoMode=false; //if true, refuses player interactions.

        
        public struct Tallyscreendata
        {
            public String TallyScreenString;
            public Image TallyImage;


        }
     
        private MenuModeData menudata;
        private Tallyscreendata tallydata;
        private IGameState statebeforepause;
        public Rectangle AvailableClientArea = new Rectangle(0, 0, 493, 427); //default client area. the HUD is drawn to the right this.
        
        private IGameState _gamerunstate = new StateNotRunning();
        public IGameState gamerunstate { get { 
           
            
            return _gamerunstate; } 
            set {
                _gamerunstate = value; Debug.Print("Game run state set to " + value.GetType().Name +" Stack:" + new StackTrace().ToString());
            }
        }
        public Thread GameThread=null;
        public Random mrandom = BCBlockGameState.rgen;
        public int mScoreatlevelstart = 0;
        public TimeSpan mLevelTime;
        public int LevelDeathCount = 0;
        public DateTime mLevelIntroStartTime;
        public TimeSpan mLevelParTime;
        public BCBlockGameState mGameState;
        public LevelSet mPlayingSet;
        public int mPlayingLevel;
        private Queue<PlayMessageData> LevelMessageQueue = null; 
        public bool ShowDebugInfo=false;
        public LevelSet GetPlayingSet()
        {
            return mPlayingSet;


        }

        public static void SuspendDrawing(Control parent)
        {
            parent.Invoke((MethodInvoker)(()=>SendMessage(parent.Handle, WM_SETREDRAW, false, 0)));
        }

        public static void ResumeDrawing(Control parent)
        {
            parent.Invoke((MethodInvoker)(() => SendMessage(parent.Handle, WM_SETREDRAW, true, 0)));
            //parent.Refresh();
        }

        public Level mPlayingLevelobj
        {
            get
            {
                
                    return mPlayingSet.Levels[mPlayingLevel - 1];
                
            
            
            
            }


        }
            //draws in several layers


        //the background layer...
        private Bitmap backgroundbitmap;
        private Graphics BackgroundBuffer;
        private Random mRandom = new Random();
        
        //and the "block" layer...
        private Bitmap BlockDrawBitmap;
        private Graphics BlockDrawBuffer;

        private bool sidebarbgdrawn=false;

        //decided that the moving blocks will be on a separate layer from the standard blocks.

        private Bitmap MovingBlockBitmap;
        private Graphics MovingBlockBuffer;

        private Bitmap SidebarBitmap;
        private Graphics sidebarGraphics;
        private Image SidebarImage;

        //private Bitmap backgroundpic = new Bitmap("D:\\banner2.png");
        private int drawbackgroundoffset = 0;
        /// <summary>
        /// set in GameProc and queried in the Paint() routine to determine wether nonanimated blocks need to be redrawn.
        /// </summary>
        private bool mredrawblocks=true;
        /// <summary>
        /// set in GameProc and queried in the Paint() routine to determine wether nonanimated blocks need to be redrawn.
        /// </summary>
        /// 
        
        ///<summary>
        ///also set in GameProc for consumption in the paint() routine; previously I was performing the LINQ to create this (the blocks that return true for "requiresPerformFrame" were in one, ones that returned false in another).
        ///although I don't know how LINQ is implemented internally I hazard a guess and say that repetition is not a good thing, so I graduated
        ///some collections to form-level locals.
        /// </summary>
        private List<Block> staticblocks;
        private List<Block> AnimatedBlocks;
        private bool mRedrawAnimated=true; 
        private bool gamethreadsuspended=false;
        private int gamepauseamount=0;
        //the ball and paddle are drawn to the Picturebox graphics object in the Paint routine.

        private Color getrandomcolor()
        {
            Func<int> randomint = new Func<int>(()=>((int)(mrandom.NextDouble()*255)));
            return Color.FromArgb(randomint(),randomint(),randomint(),randomint());




        }
        public void ReplaceBlocks(Func<Block, Block> replacefunc)
        {

            LinkedList<Block> newblocks = new LinkedList<Block>();
            Block createdblock;
            foreach (Block loopblock in mGameState.Blocks)
            {
                if (!loopblock.BlockRectangle.IsEmpty)
                {
                    createdblock = replacefunc(loopblock);
                    createdblock.BlockTriggers = loopblock.BlockTriggers;
                    createdblock.BlockEvents = loopblock.BlockEvents;
                    foreach (BlockTrigger bt in createdblock.BlockTriggers)
                    {
                        bt.OwnerBlock = createdblock;


                    }
                    foreach (BlockEvent be in createdblock.BlockEvents)
                    {
                        be.OwnerBlock = createdblock;

                    }
                    if (createdblock != null)
                        newblocks.AddLast(createdblock);

                }
            }
            mGameState.Blocks.Clear();
            mGameState.Blocks.AddRangeAfter(newblocks);
            staticblocks = (from bsel in mGameState.Blocks where !bsel.RequiresPerformFrame() select bsel).ToList();
            AnimatedBlocks = (from bsel in mGameState.Blocks where bsel.RequiresPerformFrame() select bsel).ToList();

            mredrawblocks = true;
            mRedrawAnimated = true;
            //invoke redraw
            PicGame.Invoke((MethodInvoker)(() => PicGame.Invalidate()));



        }
        public void UpdateBlocks()
        {
            staticblocks = (from bsel in mGameState.Blocks where !bsel.RequiresPerformFrame() select bsel).ToList();
            AnimatedBlocks = (from bsel in mGameState.Blocks where bsel.RequiresPerformFrame() select bsel).ToList();

            mredrawblocks = true;
            mRedrawAnimated = true;
            

        }
        public static int ScoreRevealDelayTime = 500;

        private Color RandomColor()
        {
            return Color.FromArgb((int)(mrandom.NextDouble() * 128 + 128), (int)(mrandom.NextDouble() * 255), (int)(mrandom.NextDouble() * 255), (int)(mrandom.NextDouble() * 255));



        }
        private LevelSet CreateDefaultLevelSet()
        {
            iLevelSetBuilder defaultbuilder = new DefaultLevelBuilder();
            LevelSet returnset =  defaultbuilder.BuildLevelSet(AvailableClientArea,this);

            //returnset.Save(@"D:\textoutxaml.xaml");


            return returnset;


        }

        private Level CreateDefaultLeveltestray(int levelnumber)
        {

            Level returnlevel = new Level();



            //returnlevel.levelballs.Add(new cBall(new PointF(PicGame.ClientSize.Width / 2, PicGame.ClientSize.Height - 50), new PointF(-2f, -2f)));
            returnlevel.LevelName = "Level " + levelnumber.ToString();
            returnlevel.MusicName = "ENDLESSCHALLENGE";
            returnlevel.levelballs.Add(new cBall(new PointF(30, 30), new PointF(2, 2)));
            
            /*
            for (int i = 0; i < PicGame.Width; i += 32)
            {
                returnlevel.levelblocks.Add(new RayBlock(new RectangleF(i, 50, 32, 16)));
            }
            */
            //returnlevel.levelblocks.Add(new RayBlock(new RectangleF(0,2,PicGame.Width,32)));
            for (int i = 0; i < PicGame.Width / 2; i += 32)
            {
                returnlevel.levelblocks.Add(new BoundedMovingBlock(new RayBlock(new RectangleF(PicGame.Width/2-(i/2), i, 32, 16)),
                                                            new PointF(2 + (float)(mRandom.NextDouble() * 3), 0)));
                returnlevel.levelblocks.Add(new BoundedMovingBlock(new RayBlock(new RectangleF(PicGame.Width / 2 + (i / 2), i, 32, 16)),
                                                            new PointF(2+ (float)(mRandom.NextDouble()*3), 0)));
            }
         
            returnlevel.levelblocks.Add(new NormalBlock(new RectangleF(PicGame.Width/2,5,32,16),new SolidBrush(Color.Red),new Pen(Color.Yellow)));



            return returnlevel;

        }
        

        private BCBlockGameState InitGameState(LevelSet useset, int startlevel)
        {
            BCBlockGameState newstate = new BCBlockGameState(this,PicGame,AvailableClientArea);
            BCBlockGameState.MainGameState = newstate;
            if(useset.Levels.Count < startlevel)
                throw new ArgumentException("Specified Level, " + startlevel.ToString() + " not found in given levelset, which contains " + useset.Levels.Count.ToString() + " Levels.");
            Level levelcopy = useset.Levels[startlevel-1];
            foreach(cBall levelball in levelcopy.levelballs)
            {
                newstate.Balls.AddLast(new cBall(levelball));


            }
            //newstate.Balls.Add(new cBall(newstate,new PointF(PicGame.ClientSize.Width/2,PicGame.ClientSize.Height-50),new PointF(-4f,-4f)));

            newstate.OnBallHitBottom += new BCBlockGameState.BallHitBottomProcedure(newstate_OnBallHitBottom);

            foreach(Block levelblock in levelcopy.levelblocks)
            {

                newstate.Blocks.AddLast((Block)levelblock.Clone());

                
            }

            /*
            for (int x = 0; x < PicGame.Width; x += 32)
            {


                for (int y = 0; y < PicGame.Height / 2; y += 16)
                {
                    if (mrandom.NextDouble() > 0.1)
                        newstate.Blocks.Add(new NormalBlock(newstate, new RectangleF(x, y, 32, 16), new SolidBrush(RandomColor()), new Pen(Color.Black, 1)));
                    else
                        newstate.Blocks.Add(new BombBlock(newstate, new RectangleF(x, y, 32, 16)));
                        
                    
                }
            }
             * */
            return newstate;


        }
        private PointF MidPoint(RectangleF ofrect)
        {

            return new PointF(ofrect.Left + (ofrect.Width / 2), ofrect.Top + (ofrect.Height / 2));


        }
       
       
        
        private IEnumerable<RectangleF> BlocksFromMatrix(int[][] Matrixuse)
        {

           
            //15/26, also zero.
            

            float usewidth = AvailableClientArea.Width / Matrixuse[0].Length;
            float useheight = AvailableClientArea.Height / Matrixuse.Length;

            for (int x = 0; x < Matrixuse.Length; x++)
            {
                for (int y = 0; y < Matrixuse[x].Length; y++)
                {
                    //if it is a black pixel..
                    if (Matrixuse[x][y]==1)
                    {
                        //add a new rectangle...
                        yield return new RectangleF(y*usewidth,x*useheight,usewidth,useheight);



                    }

                }




            }

            




        }

        private LevelSet CreateGameOverSet()
        {
            LevelSet returnset = new LevelSet();


            for (int i = 0; i < mPlayingSet.Levels.Count; i++)
            {
                Level golevel = new Level();

                golevel.levelballs.Add(new cBall(new PointF(15, 15), new PointF(2, 2)));
                golevel.SidebarTextColor = Color.Black;

                //now, we add the blocks.
                //a square of blocks, 10 blocks wide and 15 blocks high, centered around the middle.
                SizeF middleblocksize = new SizeF(32*10, 16*15);
                RectangleF middlecentered = GetCenteredRect(middleblocksize, AvailableClientArea);
                GraphicsPath usepath = new GraphicsPath();
              
                IEnumerable<RectangleF> userects = BlocksFromMatrix(GameOverMatrix); //known to work
                foreach (RectangleF createblockrect in userects)
                {
                    Block addthisblock;
                    if (BCBlockGameState.rgen.NextDouble() > 0.1f)
                        addthisblock = new InvincibleBlock(createblockrect);
                    else
                    {
                        addthisblock = new NormalBlock(createblockrect);
                    }
                    golevel.levelblocks.Add(addthisblock);



                }
                golevel.levelblocks.Add(new NormalBlock(new RectangleF(-300, -300, 32, 16)));
                //add the top line...
                /* for (int x = 0; x < middleblocksize.Width; x += 32)
                 {
                     Block newblock = new InvincibleBlock(new RectangleF(middlecentered.Left + x, middlecentered.Top, 32, 16));
                     golevel.levelblocks.Add(newblock);



                 }
                 //add the line on the left...
                 for (int y = 16; y < middleblocksize.Height; y += 16)
                 {

                     Block newblock = new InvincibleBlock(new RectangleF(middlecentered.Left, middlecentered.Top + y, 32, 16));
                     golevel.levelblocks.Add(newblock);


                 }
                 */


                returnset.Levels.Add(golevel);

            }


            return returnset;







        }
        bool HiscoreCheck()
        {


            String PlayerName = BCBlockGameState.Settings.PlayerName;

            int position = 0;
            // gamethread should be aborted. If it isn't- we do it.

            if ((GameThread!=null) && (GameThread.IsAlive) && GameThread != Thread.CurrentThread)
            {
                //abort it.
                GameThread.Abort();
                GameThread=null;

            }


            if ((position = mPlayingSet.HighScores.Eligible(PlayerName,(int)mGameState.GameScore)) > 0)
            {
                //score made! woop!

                HighScoreEntryMode(position,PlayerName);
                
                return true;

            }
            return false;

        }

        void GameOver()
        {
            if (GameThread != null && GameThread!=Thread.CurrentThread)
                GameThread.Abort();



            bool gotscore=false;
            BCBlockGameState.Soundman.StopMusic();
            //TODO: here is where we would "submit" the score to the HighScore management system... but ONLY if demo mode is off!
            //create the game over level.
            if (DemoMode == false)
            {
                gotscore=HiscoreCheck();


            }
            //if they didn't get a hi score, forcegameover().... otherwise, game over will be called after they enter their name.
            if(!gotscore) forcegameover();
        }
        private int HighScoreNamesMaxLength = 0;
        private int HighScoreScoresMaxLength = 0;
        private int HighScoresMaxSeparators = 0;
        private LevelSet restartset = null;
        private void forcegameover()
        {
            gamerunstate = new StateLevelOutroGameOver();

            LevelSet mGoverSet = CreateGameOverSet();
            DemoMode = true;
           
            ActualPlaySet = mPlayingSet;
            Nextshowhiscore = 0;
            GameOverHiScores = "Top - " + ActualPlaySet.SetName;

            //calculate maximum length of names and scores.
            HighScoreNamesMaxLength = Math.Min(ActualPlaySet.HighScores.GetScores().Max((w) => w.Name.Length),20);
            HighScoreScoresMaxLength = ActualPlaySet.HighScores.GetScores().Max((w) => w.Score.ToString().Length);
            HighScoresMaxSeparators= Math.Max(HighScoreNamesMaxLength+1,9);

            //cache the current set...
            restartset = mPlayingSet;
            tallydata.TallyImage = BCBlockGameState.Imageman.getImageRandom(mPlayingLevelobj.GameOverPicKey);
            PlayLevel(mGameState, mGoverSet.Levels[0]);
            
            gamerunstate = new StateLevelOutroGameOver();
        }


        protected iActiveSoundObject ds;
        
        private void ExplodePaddle()
        {
            if(mGameState.PlayerPaddle==null) return;
            Random rg = BCBlockGameState.rgen;
            Rectangle paddlerect = mGameState.PlayerPaddle.Getrect();
            for (int i = 0; i < 120; i++)
            {
                //todo: fix so this isn't called repeatedly because there is a ball outside...
                //(add another ball somewhere else, invisible, maybe?)

                int minvalue = Math.Min(paddlerect.Left, paddlerect.Right);
                int maxvalue = Math.Max(paddlerect.Left, paddlerect.Right);


                Point randomspot = new Point(rg.Next(minvalue, maxvalue), rg.Next(paddlerect.Top, paddlerect.Bottom));
                PointF rspot = randomspot.ToPointF();
                Particle dp = null;


                //Type[] particletypes = new Type[] { typeof(DustParticle),typeof(FireParticle),typeof(PolyDebris)};


                int rnum = rg.Next(1, 3);
                if (rnum == 1)
                    dp = new DustParticle(rspot);
                else
                {
                    PolyDebris pd = new PolyDebris(rspot, (rg.NextDouble()*4)-2, Color.YellowGreen);
                    pd.PenColor=Color.YellowGreen;
                    pd.BrushColor=Color.YellowGreen;
                    dp = pd;


                }
                mGameState.Particles.Add(dp);




            }
            //use Level death sound...

            //BCBlockGameState.Soundman.SetMusicVolume(0.0f);
            
            
            BCBlockGameState.Soundman.PauseMusic(true);
            BCBlockGameState.Soundman.Driver.OnSoundStop += new OnSoundStopDelegate(DeathMusicStop);
            
           
            ds = BCBlockGameState.Soundman.PlaySound(mPlayingLevelobj.DeathSound);
            mGameState.PlayerPaddle.InvokeOnDeath();
            mGameState.PlayerPaddle = null;
        }
        
        void DeathMusicStop(iActiveSoundObject objstop)
        {

            if (objstop == ds)
            {
                //remove this method...
                BCBlockGameState.Soundman.Driver.OnSoundStop -= DeathMusicStop;
                //reset the volume, too.
                try
                {
                    BCBlockGameState.Soundman.PauseMusic(false); //unpause...
                    //BCBlockGameState.Soundman.GetPlayingMusic_Active().setVolume(1.0f);
                }
                catch
                {
                    //ignored...
                }

            }

        }

        private DateTime DeathStart;
        void LifeLost()
        {
            //we cant lose a life if we are already "dying"
            Dorefreshstats = true;
            if(gamerunstate is StateDeath) return;

            //change  state to be death, and put a bunch of explodey particles all over.
            if (mGameState.PlayerPaddle != null)
            {
                Rectangle paddlerect = mGameState.PlayerPaddle.Getrect();
                
            /*    foreach (cBall createball in mGameState.Balls)
                {
                    createball.Velocity = new PointF(0, 0);
                    createball.Location = new PointF(-50, paddlerect.Bottom);
                    createball.Radius = 05f;
                    createball.DrawColor = Color.Blue;
                }
                */
                


                LevelDeathCount++;
                //cut macguffins in half and explode from the paddle.
                mGameState.MacGuffins /= 2;
                PointF SpawnGuffLocation = new PointF((float)mGameState.PlayerPaddle.Getrect().CenterPoint().X, mGameState.PlayerPaddle.Getrect().Top - 16);

                for (int i = 0; i < mGameState.MacGuffins; i++)
                {
                    //choose a random velocity. between PI and PI*2; this will be upwards-only.
                    double useangle = Math.PI + (BCBlockGameState.rgen.NextDouble()*Math.PI);
                    PointF RandomSpeed = BCBlockGameState.GetRandomVelocity(3, 5, useangle);
                    MacGuffinOrb mgo = new MacGuffinOrb(SpawnGuffLocation);
                    mgo.MacGuffinValue = BCBlockGameState.rgen.Next(0, 6);
                    mgo.Velocity = RandomSpeed;
                    mGameState.GameObjects.AddLast(mgo);


                }



                ExplodePaddle();
            }
            //remove all gamecharacter objects.
            List<GameCharacter> removethese = new List<GameCharacter>(from m in mGameState.GameObjects where m is GameCharacter select (GameCharacter)m);
            foreach (GameCharacter gchar in removethese)
            {
                
                mGameState.GameObjects.Remove(gchar);


            }
            gamerunstate = new StateDeath();
            DeathStart=DateTime.Now;
            

        }
        void PostLifeLost()
        {
            Dorefreshstats = true;

            if (mPlayingSet != null)
            {
                mPlayingSet.Statistics.Deaths++;

            }

            mGameState.playerLives--;
            //lblLives.Invoke(((MethodInvoker)(() => lblLives.Text = mGameState.playerLives.ToString())));

            gamethreadsuspended = true;
            //Thread.Sleep(500);
            gamethreadsuspended = false;
            gamerunstate = new StateRunning();
            if (mGameState.playerLives <= 0)
            {

                GameOver();



            }
            else
            {
                //reinitialize the balls from the "stored" levelset...
                
                if (mGameState.PlayerPaddle != null)
                {
                    lock (mGameState.PlayerPaddle) //lock it to prevent race condition.
                    {
                        //added June 24th 2011- Destroy() routine needs to be called when reinstantiating the paddle, otherwise
                        //the "old" paddle, and it's behaviours, will still have active hooks to any events they hooked.
                        foreach (var loopbeh in mGameState.PlayerPaddle.Behaviours)
                        {
                            loopbeh.UnHook();


                        }
                        mGameState.PlayerPaddle.Behaviours.Clear();
                    }
                }
                 
                mGameState.PlayerPaddle = new Paddle(mGameState, new Size(48, 15), new PointF(mGameState.GameArea.Width / 2, mGameState.TargetObject.Height - 35), BCBlockGameState.Imageman.getLoadedImage("paddle"));
                mGameState.PlayerPaddle.OnHPChange+=PlayerPaddle_OnHPChange;
                mGameState.PlayerPaddle.OnEnergyChange +=PlayerPaddle_OnEnergyChange;
                foreach (cBall loopball in mPlayingSet.Levels[mPlayingLevel - 1].levelballs)
                {
                    mGameState.Balls.AddLast((cBall)loopball.Clone());



                }

                //iterate through the levels blocks as well and see which ones we need to respawn...
                foreach (Block iterateblock in mPlayingSet.Levels[mPlayingLevel - 1].levelblocks)
                {
                    if (iterateblock.AutoRespawn)
                    {
                        mGameState.Blocks.AddLast((Block)iterateblock.Clone());

                    }
                }


            }




        }
        public void ForceDeath()
        {

            LifeLost();

        }
        void newstate_OnBallHitBottom(cBall ball)
        {
         
        }
        private Bitmap IntroSequenceBitmap;
        private Graphics IntroSequenceGraphic;
        public float CurrentFPS { get; set; }
        
        public void PlayLevel(BCBlockGameState stateobject, Level playthislevel)
        {
            
            Debug.Print("PlayLevel Entered...");
            //first, terminate the game thread, if it is running...
            bool ongamethread = (GameThread == Thread.CurrentThread);
            if (GameThread != null && GameThread != Thread.CurrentThread)
            {
                Debug.Print("GameThread is running; Aborting...");
                GameThread.Abort();



            }
            Debug.Print("Stopping playing music...");
            BCBlockGameState.Soundman.StopMusic();
            //next, we copy the balls and blocks from playthislevel...
            //clear any existing balls or blocks...
            //stateobject.Balls.Clear();
            //stateobject.Blocks.Clear();
            Debug.Print("Clearing current game state variables...");
            stateobject.GameObjects.Clear();
            stateobject.Particles.Clear();
            stateobject.Balls = new LinkedList<cBall>();
            stateobject.Blocks = new LinkedList<Block>();
            
            stateobject.RemoveBalls.Clear();
            Debug.Print("Cloning level data to current state...");
            foreach (cBall copyball in playthislevel.levelballs)
            {
                stateobject.Balls.AddLast((cBall) copyball.Clone());


            }


            foreach (Block copyblock in playthislevel.levelblocks)
            {

                stateobject.Blocks.AddLast((Block) copyblock.Clone());


            }
            if (stateobject.PlayerPaddle != null)
            {
              
                    lock (stateobject.PlayerPaddle) //lock it to prevent race condition.
                    {
                        //added June 24th 2011- Destroy() routine needs to be called when reinstantiating the paddle, otherwise
                        //the "old" paddle, and it's behaviours, will still have active hooks to any events they hooked.
                        foreach (var loopbeh in stateobject.PlayerPaddle.Behaviours)
                        {
                            loopbeh.UnHook();


                        }
                        stateobject.PlayerPaddle.Behaviours.Clear();
                    }
                

                
                stateobject.PlayerPaddle.OnHPChange += PlayerPaddle_OnHPChange;
                stateobject.PlayerPaddle.OnEnergyChange += PlayerPaddle_OnEnergyChange;
            }
            //LevelMessageQueue = new Queue<PlayMessageData>(playthislevel.MessageQueue.Clone());
            LevelMessageQueue = playthislevel.CreateMessageQueue();
            Debug.Print("Level contains " + stateobject.Balls.Count.ToString() + " balls and " +
                        stateobject.Blocks.Count.ToString() + " blocks.");
            Debug.Print("Playing level music...");
            PlayLevelMusic(playthislevel, true);


            //change sidebarimage if the Level has one to use.
            //the sidebarimage in the Level will be a key. if it's not null or empty, load the Image from the Image manager.
            SideBarImageCanvas = null; //nullify so PaintSideBarStats will redraw it.


            if (!String.IsNullOrEmpty(playthislevel.SidebarImageKey))
            {
                SidebarImage = BCBlockGameState.Imageman.getLoadedImage(playthislevel.SidebarImageKey);


            }
            else
            {
                SidebarImage = BCBlockGameState.Imageman.getLoadedImage("sidebarbg");

            }
            //create the bitmap of the introduction text.
            
            #region create introduction bitmap
            Debug.Print("Creating Intro sequence bitmap...");
            //mGameState.BackgroundDraw = new BackgroundColourImageDrawer(playthislevel);

            mGameState.PlayingLevel = playthislevel;
            mGameState.BackgroundDraw=playthislevel.Background;
            //CreateIntroBitmap(playthislevel, out IntroSequenceBitmap, out IntroSequenceGraphic);
            playthislevel.CreateIntroBitmap(out IntroSequenceBitmap, out IntroSequenceGraphic);
            #endregion
            
            //initialize textanimator.
            //IntroAnimator = new TextAnimationManager(playthislevel.LevelName, getLinearCharAnimator,new PointF(AvailableClientArea.Width/2,AvailableClientArea.Height/2 ));


            if (playthislevel.NoPaddle)
            {
                mGameState.PlayerPaddle=null;

            }
            Dorefreshstats = true;
            gamerunstate = new StateLevelIntro();
            mScoreatlevelstart = (int)mGameState.GameScore;
            mLevelParTime = playthislevel.CalculateParTime();
            mLevelIntroStartTime = DateTime.Now;
            mLevelTime = new TimeSpan(0);
            LevelDeathCount = 0;
            mRedrawAnimated=true;
            mredrawblocks=true;
            //initialize the AnimatedBlocks and StaticBlocks collections, otherwise we still won't
            //get them to draw.
            staticblocks = (from n in mGameState.Blocks where !n.RequiresPerformFrame() select n).ToList();
            AnimatedBlocks = (from n in mGameState.Blocks where n.RequiresPerformFrame() select n).ToList();
            if (!ongamethread)
            {
                Debug.Print("Not on game thread, creating new gamethread...");   
                GameThread = new Thread(gameproc);
                GameThread.Start();
                
            }
  …