C# 俄罗斯方块 游戏源码下载

【实例截图】

【核心代码】

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Threading;
using System.Timers;

namespace fangkuai_1
{
    class GamePalette
    {
        #region//常量区
        private readonly Color[] COLORS = new Color[] { Color.White, Color.Tomato, Color.Thistle, Color.Turquoise };//闪烁颜色
        private readonly int[] TIME_SPANS = new int[] { 700, 600, 550, 500, 450, 400, 350, 300, 250, 200 };//对应等级的速度
        private readonly int[] SCORE_SPANS = new int[] { 100, 300, 500, 1000, 1500 };//分值列表
        #endregion

        #region//属性区
        private BrickFactory m_BrickFactory;//砖块生产机
        private int m_Width = 15;//画板宽
        private int m_Heigh = 25;//画板高
        private Color[,] m_CoorArray;//固定砖块颜色数组
        private Color m_BgColor;//背景色
        private Color m_GridColor;//网格颜色
        private int m_Size;//单元格像素
        private int m_Level = 0;//等级
        private int m_Score = 0;//总分数
        private bool m_GameOver = false;//是否结束
        private bool m_ShowGrid = false;//显示网格
        private bool m_Pause = false;//暂停标志
        private bool m_Ready = false;//运行标志

        private Graphics m_MainPalette;//游戏主画布
        private Graphics m_NextPalette;//Next画布
        private Graphics m_Fen;
        private Graphics m_Ji;
        private Brick m_RunBrick;//活动的砖块
        private Brick m_NextBrick;//下一个砖块
        private System.Timers.Timer m_TimerBrick;//定时器，用来更新砖块
        #endregion

        #region 构造函数
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="width"></param>
        /// <param name="height"></param>
        /// <param name="info"></param>
        /// <param name="size"></param>
        /// <param name="bgColor"></param>
        /// <param name="gpPalette"></param>
        /// <param name="gpNext"></param>
        /// <param name="level"></param>
        /// <param name="gridColor"></param>
        /// <param name="showGrid"></param>
        public GamePalette(
            int width,
            int height,
            TemplateArray info,
            int size,
            Color bgColor,
            Graphics gpPalette,
            Graphics gpNext,
            Graphics gpFen,
            Graphics gpJi,
            int level,
            Color gridColor,
            bool showGrid)
        {
            m_Width = width;
            m_Heigh = height;
            m_CoorArray = new Color[width, height];
            m_BgColor = bgColor;
            m_MainPalette = gpPalette;
            m_NextPalette = gpNext;
            m_Fen = gpFen;
            m_Ji = gpJi;
            m_Size = size;
            m_Level = level;
            m_GridColor = gridColor;
            m_ShowGrid = showGrid;
            m_BrickFactory = new BrickFactory(info, bgColor, size);

            //InitRandowBrick();//生成level行随机砖块，以增加游戏可玩度
        }
        #endregion

        #region 属性访问器
        /// <summary>
        /// 游戏是否结束标志
        /// </summary>
        public bool IsGameOver
        {
            get { return m_GameOver; }
            set { m_GameOver = value; }
        }
        /// <summary>
        /// 获取当前游戏等级（0-9）
        /// </summary>
        public int Level
        {
            get { return m_Level; }
            set { m_Level = value; }
        }
        /// <summary>
        /// 获取当前积分
        /// </summary>
        public int Score
        {
            get { return m_Size; }
            set { m_Size = value; }
        }
        #endregion

        #region 公有函数
        /// <summary>
        /// 下移一个单位
        /// </summary>
        /// <returns></returns>
        public bool MoveDown()
        {
            if (m_RunBrick == null) return true;
            int xPos = m_RunBrick.X;//x坐标不变
            int yPos = m_RunBrick.Y   1;//y坐标加一
            for (int i = 0; i < m_RunBrick.Points.Length;i   )//循环检测各个砖点的下一个位置是否合法
            {
                //下一个位置超出画布不能移动
                if (yPos   m_RunBrick.Points[i].Y >= m_Heigh-2)
                    return false;

                //下一个位置已有砖块，不能移动
                if (!m_CoorArray[xPos   m_RunBrick.Points[i].X, yPos   m_RunBrick.Points[i].Y].IsEmpty)
                    return false;
            }

            m_RunBrick.Erase(m_MainPalette);//清除当前砖块在画布上的图形
            m_RunBrick.Y  ;//修正新的坐标偏移
            m_RunBrick.Paint(m_MainPalette);//从新绘制砖块图形到画布上
            return true;
        }

        /// <summary>
        /// 下移到底
        /// </summary>
        public void DropDown()
        {
            m_TimerBrick.Stop();//暂停定时器
            while (MoveDown()) ;//循环调用向下知道不能
            m_TimerBrick.Start();//从新启用计时器
        }

        /// <summary>
        /// 左移一个单位
        /// </summary>
        /// <returns></returns>
        public bool MoveLeft()
        {
            if (m_RunBrick == null) return true;
            int xPos = m_RunBrick.X-1;//x坐标减一
            int yPos = m_RunBrick.Y;//y坐标加一
            for (int i = 0; i < m_RunBrick.Points.Length; i  )//循环检测各个砖点的下一个位置是否合法
            {
                //左一个位置超出画布不能移动
                if (xPos   m_RunBrick.Points[i].X <0)
                    return false;

                //左移一个位置已有砖块，不能移动
                if (!m_CoorArray[xPos   m_RunBrick.Points[i].X, yPos   m_RunBrick.Points[i].Y].IsEmpty)
                    return false;
            }

            m_RunBrick.Erase(m_MainPalette);//清除当前砖块在画布上的图形
            m_RunBrick.X--;//修正新的坐标偏移
            m_RunBrick.Paint(m_MainPalette);//从新绘制砖块图形到画布上
            return true;
        }

        /// <summary>
        /// 右移一个单位
        /// </summary>
        /// <returns></returns>
        public bool MoveRight()
        {
            if (m_RunBrick == null) return true;
            int xPos = m_RunBrick.X   1;//x坐标减一
            int yPos = m_RunBrick.Y;//y坐标加一
            for (int i = 0; i < m_RunBrick.Points.Length; i  )//循环检测各个砖点的下一个位置是否合法
            {
                //左一个位置超出画布不能移动
                if (xPos   m_RunBrick.Points[i].X >= m_Width)
                    return false;

                //左移一个位置已有砖块，不能移动
                if (!m_CoorArray[xPos   m_RunBrick.Points[i].X, yPos   m_RunBrick.Points[i].Y].IsEmpty)
                    return false;
            }

            m_RunBrick.Erase(m_MainPalette);//清除当前砖块在画布上的图形
            m_RunBrick.X  ;//修正新的坐标偏移
            m_RunBrick.Paint(m_MainPalette);//从新绘制砖块图形到画布上
            return true;
        }

        /// <summary>
        /// 顺时针旋转
        /// </summary>
        /// <returns></returns>
        public bool DeasilRotate()
        {
            if (m_RunBrick == null) return true;
            for (int i = 0; i < m_RunBrick.Points.Length; i  )//循环检测各个砖点的下一个位置是否合法
            {
                //计算旋转后的坐标
                int x = m_RunBrick.X - m_RunBrick.Points[i].Y;
                int y = m_RunBrick.Y   m_RunBrick.Points[i].X;

                //左移一个位置已有砖块，不能移动
                if (x<0||x>=m_Width||y<0||y>=m_Heigh||!m_CoorArray[x,y].IsEmpty)
                    return false;
            }
            m_RunBrick.Erase(m_MainPalette);//清除当前砖块在画布上的图形
            m_RunBrick.DeasilRotate();//修正新的坐标偏移
            m_RunBrick.Paint(m_MainPalette);//从新绘制砖块图形到画布上
            return true;
        }

        //public bool ContraRotate()
        //{ }

        /// <summary>
        /// 画所有方块
        /// </summary>
        /// <param name="gp"></param>
        public void PaintPalette(Graphics gp)
        { 
            //以背景色清除画布
            lock (gp)
            {
                gp.Clear(m_BgColor);
            }
            //画网格
            if (m_ShowGrid)
                PaintGridLine(gp);
            //画已有砖块
            PaintBricks(gp);
            //画当前活动砖块
            if (m_RunBrick != null)         
                m_RunBrick.Paint(gp);
            
        }

        /// <summary>
        /// 小地图上画方块
        /// </summary>
        /// <param name="gp"></param>
        public void PaintNext(Graphics gp)
        {
            lock (gp)
            {
                gp.Clear(m_BgColor);
            }
            if (m_NextBrick != null)
                m_NextBrick.Paint(gp);
        }

        public void PaintFen(Graphics gp)
        {
            lock (gp)
            {
                gp.Clear(Color.White);
                Font drawFont = new Font("Arial", 16);
                SolidBrush drawBrush = new SolidBrush(Color.Black);
                PointF drawPoint = new PointF(0.0F, 0.0F);

                gp.DrawString(Convert.ToString(m_Score), drawFont, drawBrush, drawPoint);
            }
            

        }
        public void PaintJi(Graphics gp)
        {
            lock (gp)
            {
                gp.Clear(Color.White);
                Font drawFont = new Font("Arial", 16);
                SolidBrush drawBrush = new SolidBrush(Color.Black);
                PointF drawPoint = new PointF(0.0F, 0.0F);


                gp.DrawString(Convert.ToString(m_Level), drawFont, drawBrush, drawPoint);
            }
            
        }

        /// <summary>
        /// 开始游戏
        /// </summary>
        public void Start()
        {
            m_RunBrick = m_BrickFactory.CreateBrick();//产生一个砖块
            m_RunBrick.X = m_Width / 2;//水平位置在画布中心
            m_Ready = true;
            int y = 0;
            for (int i = 0; i < m_RunBrick.Points.Length; i  )
            {
                if (m_RunBrick.Points[i].Y < y)
                    y = m_RunBrick.Points[i].Y;
            }

            m_RunBrick.Y = -y;//垂直位置保证能完全显示


            PaintPalette(m_MainPalette);

            Thread.Sleep(20);//延时产生下一个砖块
            m_NextBrick = m_BrickFactory.CreateBrick();
            PaintNext(m_NextPalette);

            //设定并启动定时器
            m_TimerBrick = new System.Timers.Timer(TIME_SPANS[m_Level]);
            m_TimerBrick.Elapsed  = new System.Timers.ElapsedEventHandler(OnBrickTimeEvent);
            m_TimerBrick.AutoReset = true;
            //kaishidingshi
        }

        /// <summary>
        /// 暂停游戏
        /// </summary>
        public void Pause()
        { }

        /// <summary>
        /// 继续游戏
        /// </summary>
        public void Resume()
        { }

        /// <summary>
        /// 关闭游戏
        /// </summary>
        public void Close()
        {
            if (m_TimerBrick != null)
            {
                m_TimerBrick.Close();
                m_TimerBrick.Dispose();
            }
            m_NextPalette.Dispose();
            m_MainPalette.Dispose();

        }
        #endregion

        #region 私有函数
        //时时更新砖块信息
        private void OnBrickTimeEvent(object source, ElapsedEventArgs e)
        {
            if (m_Pause || m_GameOver)
            {
                if (m_GameOver) PaintGameOver();
                return;
            }
            if (m_Ready)
            {
                if (!MoveDown())
                    CheckAndOverBrick();
            }
            PaintFen(m_Fen);
            PaintJi(m_Ji);
        }

        private void PaintGridLine(Graphics gp)
        {
            try
            {
                lock (gp)
                {
                    using (Pen p = new Pen(m_GridColor, 1))
                    {
                        for (int column = 1; column < m_Width; column  )
                            gp.DrawLine(p, column * m_Size - 1, 0, column * m_Size - 1, m_Heigh * m_Size);
                        for (int row = 1; row < m_Heigh; row  )
                            gp.DrawLine(p, 0, row * m_Size, m_Width * m_Size, row * m_Size);
                    }
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex);
            }
        }

        private void PaintBricks(Graphics gp)
        {
            lock (gp)
            {
                for (int row = 0; row < m_Heigh; row  )
                {
                    for (int column = 0; column < m_Width; column  )
                    {
                        try
                        {
                            Color c = m_CoorArray[column, row];
                            if (c.IsEmpty) c = m_BgColor;
                            using (SolidBrush sb = new SolidBrush(c))
                            {
                                gp.FillRectangle(sb, column * m_Size   1, row * m_Size   1, m_Size - 2, m_Size - 2);
                            }
                            
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine(ex);
                        }
                    }
                }
            }
        }

        private void CheckAndOverBrick()
        {
            //设定当前砖块到画布上
            for (int i = 0; i < m_RunBrick.Points.Length; i  )
                m_CoorArray[m_RunBrick.X   m_RunBrick.Points[i].X, m_RunBrick.Y   m_RunBrick.Points[i].Y] = m_RunBrick.Color;
            //检测并消除满行
            CheckAndDelFullRow();
            //设定活动砖块
            m_RunBrick = m_NextBrick;
            m_RunBrick.X = m_Width / 2;
            int y = 0;
            for(int i=0;i<m_RunBrick.Points.Length;i  )
            {
                if(m_RunBrick.Points[i].Y<y)
                    y=m_RunBrick.Points[i].Y;
            }
            m_RunBrick.Y = -y;
            //检查游戏结束
            for (int i = 0; i < m_RunBrick.Points.Length; i  )
            {
                //如果砖块所在位置有砖块，则到达顶部，游戏结束
                if (!m_CoorArray[m_RunBrick.X   m_RunBrick.Points[i].X, m_RunBrick.Y   m_RunBrick.Points[i].Y].IsEmpty)
                {
                    m_RunBrick = null;
                    //闪烁效果
                    m_TimerBrick.Stop();
                    for (int row = m_Heigh - 1; row > 0; row--)
                    {
                        for (int column = 0; column < m_Width; column  )
                        {
                            m_CoorArray[column, row] = m_BgColor;
                        }
                        PaintBricks(m_MainPalette);
                        System.Threading.Thread.Sleep(50);
                    }
                    //游戏结束
                    m_GameOver = true;
                    m_Ready = false;
                    m_TimerBrick.Start();
                    return;
                }  
            }
            m_RunBrick.Paint(m_MainPalette);

            //获取新的下一个砖块
            m_NextBrick = m_BrickFactory.CreateBrick();
            PaintNext(m_NextPalette);
        }
        //检查并删除满行砖块
        private void CheckAndDelFullRow()
        {
            int fullRowCount = 0;//满行数
            int upRow = m_RunBrick.Y - 2;//当前砖块的上行标志
            int downRow = m_RunBrick.Y   2;//当前砖块的下行标志
            if (upRow < 0) upRow = 0;//越界处理
            if (downRow > m_Heigh) downRow = m_Heigh - 1;//越界处理

            //检查此范围的行
            for (int row = upRow; row <= downRow; row  )
            {
                bool isFull = true;
                for (int column = 0; column < m_Width; column  )
                {
                    if (m_CoorArray[column, row].IsEmpty)//如果该行颜色都不为空（都有砖块）
                    {
                        isFull = false;
                        break;
                    }
                }
                if (isFull)//清除满行
                {
                    fullRowCount  ;
                    m_TimerBrick.Stop();//暂停游戏

                    //闪烁效果
                    for (int n = 0; n < COLORS.Length; n  )
                    {
                        for (int column = 0; column < m_Width; column  )
                            m_CoorArray[column, row] = COLORS[n];
                        PaintBricks(m_MainPalette);
                        m_TimerBrick.Start();//继续游戏
                    }
                    for (int rowIndex = row; rowIndex > 0; rowIndex--)
                        for (int column = 0; column < m_Width; column  )
                            m_CoorArray[column, rowIndex] = m_CoorArray[column, rowIndex - 1];
                    PaintBricks(m_MainPalette);
                    m_TimerBrick.Start();//继续游戏
                }
                
            }
            //有满行
            if (fullRowCount > 0)
            {
                int currentScore = SCORE_SPANS[fullRowCount - 1];//当前计分
                int tempScore = m_Score;//游戏得分
                m_Score  = currentScore;//追加得分
                if (m_Score >= 1000 && m_Score.ToString()[0] != tempScore.ToString()[0])//判断升级
                {
                    m_Level = (m_Level   1) % TIME_SPANS.Length;//当前级别
                    m_TimerBrick.Interval = TIME_SPANS[m_Level];//游戏速度
                }

            }
        }
        private void PaintGameOver()
        { }
        #endregion

    }
}