GDI学习之俄罗斯方块续

当前方块对象

#region 定义砖块int[i,j,y,x] Tricks:i为那块砖,j为状态,y为列,x为行
        private int[, , ,] Tricks = {{
                                      {
                                          {,,,},
                                          {,,,},
                                          {,,,},
                                          {,,,}
                                      },
                                      {
                                          {,,,},
                                          {,,,},
                                          {,,,},
                                          {,,,}
                                      },
                                      {
                                          {,,,},
                                          {,,,},
                                          {,,,},
                                          {,,,}
                                      },
                                      {
                                          {,,,},
                                          {,,,},
                                          {,,,},
                                          {,,,}
                                      }
                                  },
                                  {
                                       {
                                           {,,,},
                                           {,,,},
                                           {,,,},
                                           {,,,}
                                       },
                                       {
                                           {,,,},
                                           {,,,},
                                           {,,,},
                                           {,,,}
                                       },
                                       {
                                           {,,,},
                                           {,,,},
                                           {,,,},
                                           {,,,}
                                       },
                                       {
                                           {,,,},
                                           {,,,},
                                           {,,,},
                                           {,,,}
                                       }
                                   },
                                   {
                                       {
                                           {,,,},
                                           {,,,},
                                           {,,,},
                                           {,,,}
                                       },
                                       {
                                           {,,,},
                                           {,,,},
                                           {,,,},
                                           {,,,}
                                       },
                                       {
                                           {,,,},
                                           {,,,},
                                           {,,,},
                                           {,,,}
                                       },
                                       {
                                           {,,,},
                                           {,,,},
                                           {,,,},
                                           {,,,}
                                       }
                                   },
                                   {
                                       {
                                           {,,,},
                                           {,,,},
                                           {,,,},
                                           {,,,}
                                       },
                                       {
                                           {,,,},
                                           {,,,},
                                           {,,,},
                                           {,,,}
                                       },
                                       {
                                           {,,,},
                                           {,,,},
                                           {,,,},
                                           {,,,}
                                       },
                                       {
                                           {,,,},
                                           {,,,},
                                           {,,,},
                                           {,,,}
                                       }
                                   },
                                   {
                                       {
                                           {,,,},
                                           {,,,},
                                           {,,,},
                                           {,,,}
                                       },
                                       {
                                           {,,,},
                                           {,,,},
                                           {,,,},
                                           {,,,}
                                       },
                                       {
                                           {,,,},
                                           {,,,},
                                           {,,,},
                                           {,,,}
                                       },
                                       {
                                           {,,,},
                                           {,,,},
                                           {,,,},
                                           {,,,}
                                       }
                                   },
                                   {
                                       {
                                           {,,,},
                                           {,,,},
                                           {,,,},
                                           {,,,}
                                       },
                                       {
                                           {,,,},
                                           {,,,},
                                           {,,,},
                                           {,,,}
                                       },
                                       {
                                           {,,,},
                                           {,,,},
                                           {,,,},
                                           {,,,}
                                       },
                                       {
                                           {,,,},
                                           {,,,},
                                           {,,,},
                                           {,,,}
                                       }
                                   },
                                   {
                                       {
                                           {,,,},
                                           {,,,},
                                           {,,,},
                                           {,,,}
                                       },
                                       {
                                           {,,,},
                                           {,,,},
                                           {,,,},
                                           {,,,}
                                       },
                                       {
                                           {,,,},
                                           {,,,},
                                           {,,,},
                                           {,,,}
                                       },
                                       {
                                           {,,,},
                                           {,,,},
                                           {,,,},
                                           {,,,}
                                       }
                                   }};

        #endregion

        //当前的砖块
        public int[,] CurrentTrick = new int[, ];

        //CurrentTrickNum当前砖块的数目, CurrentStatusNum当前状态,CurrentColor当前颜色， CurrentX当前x, CurrentY当前y
        public int CurrentTrickNum, CurrentStatusNum, CurrentColor, CurrentX, CurrentY;

        //方块种类
        private int TricksNum = ;

        //方块样式
        private int StatusNum = ;

        //颜色种类
        private int ColorNum = ;

        private Random rand = new Random();

        /// <summary>
        /// 随机生成方块和状态
        /// </summary>
        public void BeginTricks()
        {
            //随机生成砖码和状态码
            CurrentTrickNum = rand.Next(, TricksNum);
            CurrentStatusNum = rand.Next(, StatusNum);
            CurrentColor = rand.Next(, ColorNum);
            //分配数组
            for (int y = ; y < ; y++)
            {
                for (int x = ; x < ; x++)
                {
                    CurrentTrick[y, x] = Tricks[CurrentTrickNum, CurrentStatusNum, y, x];
                }
            }
            CurrentX = ;
            CurrentY = ;
        }

        /// <summary>
        /// 变化方块
        /// </summary>
        public void ChangeTricks()
        {
            if (CurrentStatusNum < )
            {
                CurrentStatusNum++;
            }
            else
            {
                CurrentStatusNum = ;
            }
            for (int y = ; y < ; y++)
            {
                for (int x = ; x < ; x++)
                {
                    CurrentTrick[y, x] = Tricks[CurrentTrickNum, CurrentStatusNum, y, x];
                }
            }
        }

        /// <summary>
        /// 下落方块
        /// </summary>
        public void DownTricks()
        {
            CurrentY++;
        }

        /// <summary>
        /// 左移方块
        /// </summary>
        public void LeftTricks()
        {
            CurrentX--;
        }

        /// <summary>
        /// 右移方块
        /// </summary>
        public void RightTricks()
        {
            CurrentX++;
        }

Brick

操作类

#region 定义背景
        private int[,] bgGraoud ={
                                     {,,,,,,,,,,,,,},
                                     {,,,,,,,,,,,,,},
                                     {,,,,,,,,,,,,,},
                                     {,,,,,,,,,,,,,},
                                     {,,,,,,,,,,,,,},
                                     {,,,,,,,,,,,,,},
                                     {,,,,,,,,,,,,,},
                                     {,,,,,,,,,,,,,},
                                     {,,,,,,,,,,,,,},
                                     {,,,,,,,,,,,,,},
                                     {,,,,,,,,,,,,,},
                                     {,,,,,,,,,,,,,},
                                     {,,,,,,,,,,,,,},
                                     {,,,,,,,,,,,,,},
                                     {,,,,,,,,,,,,,},
                                     {,,,,,,,,,,,,,},
                                     {,,,,,,,,,,,,,},
                                     {,,,,,,,,,,,,,},
                                     {,,,,,,,,,,,,,},
                                     {,,,,,,,,,,,,,}
                                 };
        #endregion

        //定义颜色
        private Color[] TrickColor = { Color.Transparent, Color.Red, Color.Blue, Color.Orange, Color.Green };

        //Sorce分数
        public int Sorce;

        private Image myImage;

        private Color backColor;

        private Brick brick = new Brick();

        public TetrisHelper(Image myImage, Color backColor)
        {
            this.myImage = myImage;
            this.backColor = backColor;
        }

        /// <summary>
        /// 重新开始
        /// </summary>
        public void Renew()
        {
            Sorce = ;
            for (int y = ; y < ; y++)
            {
                for (int x = ; x < ; x++)
                {
                    bgGraoud[y, x] = ;
                }
            }
        }

        /// <summary>
        /// 随机生成方块和状态
        /// </summary>
        public void BeginTricks()
        {
            brick.BeginTricks();
        }

        /// <summary>
        /// 变化方块
        /// </summary>
        public void ChangeTricks()
        {
            brick.ChangeTricks();
        }

        /// <summary>
        /// 检测是否可以向下了
        /// </summary>
        /// <returns></returns>
        private bool CheckIsDown()
        {
            for (int y = ; y < ; y++)
            {
                for (int x = ; x < ; x++)
                {
                    if (brick.CurrentTrick[y, x] == )
                    {
                        //超过了背景
                        if (y + brick.CurrentY +  >= )
                        {
                            return false;
                        }
                        if (x + brick.CurrentX >= )
                        {
                            brick.CurrentX =  - x;
                        }
                        if (bgGraoud[y + brick.CurrentY + , x + brick.CurrentX] >= )
                        {
                            return false;
                        }
                    }
                }
            }
            return true;
        } 

        /// <summary>
        /// 下落方块
        /// </summary>
        public bool DownTricks()
        {
            if (CheckIsDown())
            {
                brick.DownTricks();
            }
            else
            {
                if (brick.CurrentY == )
                {
                    return false;
                }
                //下落完成，修改背景
                for (int y = ; y < ; y++)
                {
                    for (int x = ; x < ; x++)
                    {
                        if (brick.CurrentTrick[y, x] == )
                        {
                            bgGraoud[brick.CurrentY + y, brick.CurrentX + x] = brick.CurrentColor;
                        }
                    }
                }
                CheckSore();
                BeginTricks();

            }
            return true;
        }

        /// <summary>
        /// 检测是否可以左移
        /// </summary>
        /// <returns></returns>
        private bool CheckIsLeft()
        {
            for (int y = ; y < ; y++)
            {
                for (int x = ; x < ; x++)
                {
                    if (brick.CurrentTrick[y, x] == )
                    {
                        if (x + brick.CurrentX -  < )
                        {
                            return false;
                        }
                        if (bgGraoud[y + brick.CurrentY, x + brick.CurrentX - ] >= )
                        {
                            return false;
                        }
                    }
                }
            }
            return true;
        }  

        /// <summary>
        /// 左移方块
        /// </summary>
        public void LeftTricks()
        {
            if (CheckIsLeft())
            {
                brick.LeftTricks();
            }
        }

        /// <summary>
        /// 检测是否可以右移
        /// </summary>
        /// <returns></returns>
        private bool CheckIsRight()
        {
            for (int y = ; y < ; y++)
            {
                for (int x = ; x < ; x++)
                {
                    if (brick.CurrentTrick[y, x] == )
                    {
                        if (x + brick.CurrentX +  >= )
                        {
                            return false;
                        }
                        if (bgGraoud[y + brick.CurrentY, x + brick.CurrentX + ] >= )
                        {
                            return false;
                        }
                    }
                }
            }
            return true;
        }  

        /// <summary>
        /// 右移方块
        /// </summary>
        public void RightTricks()
        {
            if (CheckIsRight())
            {
                brick.RightTricks();
            }
        }

        public Image Draw()
        {
            Graphics g = Graphics.FromImage(myImage);
            g.Clear(backColor);
            for (int bgy = ; bgy < ; bgy++)
            {
                for (int bgx = ; bgx < ; bgx++)
                {
                    if (bgGraoud[bgy, bgx] > )
                    {
                        g.FillRectangle(new SolidBrush(TrickColor[bgGraoud[bgy, bgx]]), bgx * , bgy * , , );
                        g.DrawRectangle(Pens.White, bgx * , bgy * , , );
                    }
                }
            }
            //绘制当前的图片
            for (int y = ; y < ; y++)
            {
                for (int x = ; x < ; x++)
                {
                    if (brick.CurrentTrick[y, x] == )
                    {
                        g.FillRectangle(new SolidBrush(TrickColor[brick.CurrentColor]), (x + brick.CurrentX) * , (y + brick.CurrentY) * , , );
                        g.DrawRectangle(Pens.White, (x + brick.CurrentX) * , (y + brick.CurrentY) * , , );
                    }
                }
            }

            return myImage;
        }

        private void CheckSore()
        {
            for (int y = ; y > -; y--)
            {
                bool isFull = true;
                for (int x = ; x > -; x--)
                {
                    if (bgGraoud[y, x] == )
                    {
                        isFull = false;
                        break;
                    }
                }
                if (isFull)
                {
                    //增加积分
                    Sorce = Sorce + ;
                    for (int yy = y; yy > ; yy--)
                    {
                        for (int xx = ; xx < ; xx++)
                        {
                            int temp = bgGraoud[yy - , xx];
                            bgGraoud[yy, xx] = temp;
                        }
                    }
                    y++;
                }
            }
        }

TetrisHelper

窗体代码

public Form1()
        {
            InitializeComponent();
        }

        TetrisHelper tetrisHelper;

        private void Form1_Load(object sender, EventArgs e)
        {
            //初始化
            Image myImage = new Bitmap(panel1.Width, panel1.Height);
            tetrisHelper = new TetrisHelper(myImage, panel1.BackColor);
            loadGame();
        }

        protected override void OnPaint(PaintEventArgs e)
        {
            Draw();
            base.OnPaint(e);
        }

        private void loadGame()
        {
            timer1.Interval = ;
            tetrisHelper.Renew();
            label1.Text = "分数：" + tetrisHelper.Sorce;
            tetrisHelper.BeginTricks();
            button2.Text = "开始游戏";
            this.Focus();
        }

        private void timer1_Tick(object sender, EventArgs e)
        {
            if (tetrisHelper.DownTricks())
            {
                Draw();
            }
            else
            {
                timer1.Stop();
                if (MessageBox.Show("哈哈，你玩玩了", "确认", MessageBoxButtons.OK, MessageBoxIcon.Information) == DialogResult.OK)
                {
                    loadGame();
                }
            }
        }

        private void Form1_KeyDown(object sender, KeyEventArgs e)
        {
            if (timer1.Enabled == false)
            {
                return;
            }
            if (e.KeyCode == Keys.W)
            {
                tetrisHelper.ChangeTricks();
                Draw();
            }
            else if (e.KeyCode == Keys.A)
            {
                tetrisHelper.LeftTricks();
                Draw();
            }
            else if (e.KeyCode == Keys.D)
            {
                tetrisHelper.RightTricks();
                Draw();
            }
            else if (e.KeyCode == Keys.S)
            {
                timer1.Stop();
                timer1.Interval = ;
                timer1.Start();
            }
        }

        private void Form1_KeyUp(object sender, KeyEventArgs e)
        {
            if (timer1.Enabled == false)
            {
                return;
            }
            if (e.KeyCode == Keys.S)
            {
                timer1.Stop();
                timer1.Interval = ;
                timer1.Start();
            }
        }

        private void Draw()
        {
            Image img = tetrisHelper.Draw();

            Graphics gg = panel1.CreateGraphics();

            gg.DrawImage(img, , );
        }  

        private void button2_Click(object sender, EventArgs e)
        {
            if (button2.Text == "暂停游戏")
            {
                button2.Text = "开始游戏";
                timer1.Stop();
            }
            else
            {
                button2.Text = "暂停游戏";
                timer1.Start();
            }
        }

Form1

页面展现