C#实现俄罗斯方块

namespace Tetris
{
 class Palette
 {
 private int _width = 15;//画板宽度
 private int _height = 25;//画板高度
 private Color[,] coorArr;//固定砖块数组
 private Color disapperColor;//背景色
 private Graphics gpPalette;//砖块活动画板
 private Graphics gpReady;//下一个砖块样式画板
 private BlockGroup bGroup;//砖块生产机制
 private Block runBlock;//正在活动的砖块
 private Block readyBlock;//下一个砖块
 private int rectPix;//单元格像
 public delegate void IniCountHandle(int _count,int state);//分数变量
 public event IniCountHandle CountEvent;
 public static int _Count = 0;


 static int mark = 100;//静态变量衡量过关的标准
 public static int state = 1;


 private System.Timers.Timer timerBlock;//定时器
 private static int timeSpan = 800;//定时器的时间间隔

 public Palette(int x, int y, int pix, Color dColor, Graphics gp, Graphics gr)//构造函数
 {
  _width = x;
  _height = y;
  coorArr = new Color[_width, _height];
  disapperColor = dColor;
  gpPalette = gp;
  gpReady = gr;
  rectPix = pix;
 }
 public void Start()//游戏开始
 {
  state = 1;
  _Count = 0;
  bGroup = new BlockGroup();
  runBlock = bGroup.GetABlock();
  runBlock.XPos = _width / 2;
  int y = 0;
  for (int i = 0; i < runBlock.Length ; i++)//垂直位置
  {
  if (runBlock[i].Y > y)
  {
   y = runBlock[i].Y;
  }
  }
  runBlock.YPos = y;
  gpPalette.Clear(disapperColor);//清空画板
  runBlock.Paint(gpPalette);//画运行砖块
  Thread.Sleep(20);
  readyBlock = bGroup.GetABlock();
  readyBlock.XPos = 2;
  readyBlock.YPos = 2;
  gpReady.Clear(disapperColor);//清空画板
  readyBlock.Paint(gpReady);
  //初始化并启动定时器
  timerBlock = new System.Timers.Timer(timeSpan);
  timerBlock.Elapsed += new System.Timers.ElapsedEventHandler(OnTimedEvent);
  timerBlock.AutoReset = true;
  timerBlock.Start();
 }
 public void nextstate()
 {
  
  PaintBackground(gpPalette);
  timerBlock = new System.Timers.Timer(timeSpan);
  timerBlock.Elapsed += new System.Timers.ElapsedEventHandler(OnTimedEvent);
  timerBlock.AutoReset = true;
  timerBlock.Start();
 }
 private void OnTimedEvent(object source, ElapsedEventArgs e)
 {
  CheckAndOverBlock();
  Down();
 }
 public bool Down()//砖块下移
 {
  int xPos = runBlock.XPos;
  int yPos = runBlock.YPos + 1;
  for (int i = 0; i < runBlock.Length; i++)
  {
  if (yPos - runBlock[i].Y > _height - 1)//如果超出下边界则失败
   return false;
  if (!coorArr[xPos + runBlock[i].X, yPos - runBlock[i].Y].IsEmpty)//如果下边有东西挡则失败
   return false;
  }
  runBlock.erase(gpPalette);//擦除原来位置砖块
  runBlock.YPos++;
  runBlock.Paint(gpPalette);
  return true;
 }
 public void Drop()//丢下砖块
 {
  timerBlock.Stop();
  while (Down()) ;
  timerBlock.Start();
 }
 public void MoveLeft()//向左移动
 {
  int xPos = runBlock.XPos - 1;
  int yPos = runBlock.YPos;
  for (int i = 0; i < runBlock.Length; i++)
  {
  if (xPos + runBlock[i].X < 0)
   return;
  if (!coorArr[xPos + runBlock[i].X, yPos - runBlock[i].Y].IsEmpty)//如果左边有东西挡则失败
   return;
  }
  runBlock.erase(gpPalette);
  runBlock.XPos--;
  runBlock.Paint(gpPalette);
 }
 public void MoveRight()//向右移动
 {
  int xPos = runBlock.XPos + 1;
  int yPos = runBlock.YPos;
  for (int i = 0; i < runBlock.Length; i++)
  {
  if (xPos + runBlock[i].X > _width -1)//如果超出右边界则失败
   return;
  if (!coorArr[xPos + runBlock[i].X, yPos - runBlock[i].Y].IsEmpty)//如果右边有东西挡则失败
   return;
  }
  runBlock.erase(gpPalette);
  runBlock.XPos++;
  runBlock.Paint(gpPalette);
 }
 public void DeasilRotate()//顺时针旋转
 {
  for (int i = 0; i < runBlock.Length; i++)
  {
  int x = runBlock.XPos + runBlock[i].Y;
  int y = runBlock.YPos + runBlock[i].X;
  if (x < 0 || x > _width - 1)
   return;
  if (y < 0 || y > _height - 1)
   return;
  if (!coorArr[x, y].IsEmpty)
   return;
  }
  runBlock.erase(gpPalette);
  runBlock.DeasilRotate();
  runBlock.Paint(gpPalette);
 }
 public void ContraRotate()//逆时针旋转
 {
  for (int i = 0; i < runBlock.Length; i++)
  {
  int x = runBlock.XPos - runBlock[i].Y;
  int y = runBlock.YPos - runBlock[i].X;
  if (x < 0 || x > _width - 1)
   return;
  if (y < 0 || y > _height - 1)
   return;
  if (!coorArr[x, y].IsEmpty)
   return;
  }
  runBlock.erase(gpPalette);
  runBlock.ContraRotate();
  runBlock.Paint(gpPalette);
 }
 private void PaintBackground(Graphics gp)//重画画板背景
 {
  gp.Clear(Color.Black);//清空画板
  for (int i = 0; i < _height; i++)
  {
  for (int j = 0; j < _width; j++)
  {
   if (!coorArr[j, i].IsEmpty)
   {
   SolidBrush sb = new SolidBrush(coorArr[j, i]);
   gp.FillRectangle(sb, j * rectPix + 1,
    i * rectPix + 1,
    rectPix - 2,
    rectPix - 2);
   }
  }
  }
 }
 public void PaintPalette(Graphics gp)//重画整个画板
 {
  PaintBackground(gp);//先画背景
  if (runBlock != null)//再画活动的砖块
  {
  runBlock.Paint(gp);
  }
 }
 public void PaintReady(Graphics gp)//重画下一个砖块
 {
  if (readyBlock != null)
  {
  readyBlock.Paint(gp);
  }
 }
  public void CheckAndOverBlock()//检查砖块是否到底
 {
  bool over = false;
  for (int i = 0; i < runBlock.Length; i++)
  {
  int x = runBlock.XPos + runBlock[i].X;
  int y = runBlock.YPos - runBlock[i].Y;
  if (y == _height - 1)
  {
   over = true;
   break;
  }
  if (!coorArr[x, y + 1].IsEmpty)//如果下面有砖块，则当前砖块结束
  {
   over = true;
   break;
  }
  }
  if (over)//如果当前砖块已经结束
  {
   for (int i = 0; i < runBlock.Length; i++)//把当前砖块归入coordinatearr
   {
   coorArr[runBlock.XPos + runBlock[i].X, runBlock.YPos - runBlock[i].Y] = runBlock.BlockColor;
   }
   //检查是否有满行现象，如果有，则删除
   CheckAndDelFullRow();
   //产生新的砖块
   runBlock = readyBlock;//新的砖块为准备好的砖块
   runBlock.XPos = _width / 2;
   int y = 0;
   for (int i = 0; i < runBlock.Length; i++)//垂直位置
   {
   if (runBlock[i].Y > y)
   {
    y = runBlock[i].Y;
   }
   }
   runBlock.YPos = y;
   //检查新产生的砖块所占用的地方是否已经有砖块，如果有，则游戏结束
   for (int i = 0; i < runBlock.Length; i++)
   {
   if (!coorArr[runBlock.XPos + runBlock[i].X, runBlock.YPos - runBlock[i].Y].IsEmpty)
   {
    //游戏结束
    StringFormat drawFormat = new StringFormat();
    drawFormat.Alignment = StringAlignment.Center;
    gpPalette.DrawString("GAME OVER"+"rn"+"得分：" + _Count.ToString()+"rn等级："+state .ToString (),
    new Font("Arial Black", 25f),
    new SolidBrush(Color.Yellow ),
    new RectangleF(0, _height * rectPix / 2 - 100, _width * rectPix, 150),
    drawFormat);
    timerBlock.Stop();
    return;
   }
   }
   runBlock.Paint(gpPalette);
   //获取新的准备砖块
   readyBlock = bGroup.GetABlock();
   readyBlock.XPos = 2;
   readyBlock.YPos = 2;
   gpReady.Clear(Color.Black);
   readyBlock.Paint(gpReady);
  }
 }
 private void CheckAndDelFullRow()//检查并删除满行
 {
  //找出当前砖块所在行范围
  int lowRow = runBlock.YPos - runBlock[0].Y;//lowRow代表当前砖块的Y轴的最小值
  int highRow = lowRow;//highRow代表当前砖块的y轴的最大值
  for (int i = 0; i < runBlock.Length;i++ )//找出当前砖块所占行的范围，放入low，high变量内
  {
  int y = runBlock.YPos - runBlock[i].Y;
  if (y < lowRow)
  {
   lowRow = y;
  }
  if (y > highRow)
  {
   highRow = y;
  }
  }
  int count=0;
  bool repaint = false;//判断是否重画
  for (int i = lowRow; i <= highRow; i++)//检查是否满行
  {
  bool rowFull = true;
  
  for (int j = 0; j < _width; j++)
  {
   if (coorArr[j, i].IsEmpty)//如果有一个单元格为空，说明这一行不可能为满行
   {
   rowFull = false;
   break;
   }
  }
  if (rowFull)//如果满行，则删除这一行
  {
   count ++;
   repaint = true;//如果删除，则需重画
   for (int k = i; k > 0; k--)
   {
   for (int j = 0; j < _width; j++)
   {
    coorArr[j, k] = coorArr[j, k - 1];
   }
   }
   for (int j = 0; j < _width; j++)//清空第0行
   {
   coorArr[j, 0] = Color.Empty;
   }
  }
  
  }
  //计算每满几行加的分值
  if (count == 1)
  {
  _Count += 10;
  CountEvent(_Count,state);
  }
  if (count == 2)
  {
  _Count += 30;
  CountEvent(_Count,state);
  }
  if (count == 3)
  {
  _Count += 60;
  CountEvent(_Count,state );
  }
  if (count >= 4)
  {
  _Count += 80;
  CountEvent(_Count,state);
  }
  if (repaint)//重画
  {
  PaintBackground(gpPalette);
  }
  if (_Count >= 1000)//如果通关初始化为原来的值
  {
  StringFormat drawFormat = new StringFormat();
  drawFormat.Alignment = StringAlignment.Center;
  gpPalette.DrawString("O(∩_∩)O"+"rn"+"***通关***"+"rn"+"按“开始”按钮rn王者归来",
   new Font("Arial Black", 20f),
   new SolidBrush(Color.Red),
   new RectangleF(0, _height * rectPix / 2 - 100, _width * rectPix, 120),
   drawFormat);
  timeSpan = 800;
  state = 1;
  _Count = 0;
  timerBlock.Close();
  }

  if (_Count >= mark)
  {
  mark += 100;
  timeSpan -= 70;
  state++;
  CountEvent(_Count ,state);
  StringFormat drawFormat = new StringFormat();
  drawFormat.Alignment = StringAlignment.Center;
  gpPalette.DrawString("tO(∩_∩)O~rn***恭喜过关***rn按“下一关”按钮rn开始新的远征",
   new Font("Arial Black", 20f),
   new SolidBrush(Color.DodgerBlue ),
   new RectangleF(0, _height * rectPix / 2 - 80, _width * rectPix, 120),
   drawFormat);
  timerBlock.Stop();//关闭计时器
  }
 }
 public void Pause()//暂停
 {
  if (timerBlock.Enabled == true)
  {
  timerBlock.Enabled = false;
  StringFormat drawFormat = new StringFormat();
  drawFormat.Alignment = StringAlignment.Center;
  gpPalette.DrawString("暂停" + "rn" + "得分：" + _Count.ToString(),
    new Font("Arial Black", 25f),
    new SolidBrush(Color.Aqua),
    new RectangleF(0, _height * rectPix / 2 - 100, _width * rectPix, 100),
    drawFormat);
  }
 }
 public void EndPause()//结束暂停
 {
  if (timerBlock.Enabled == false)
  {
  timerBlock.Enabled = true;
  PaintBackground(gpPalette);
  }
 }
 public void Close()//关闭
 {
  timerBlock.Close();
  gpPalette.Dispose();//释放画布
  gpReady.Dispose();
 }
 }
}

namespace Tetris
{
 class InfoArr
 {
 private ArrayList info = new ArrayList();//存放多个BlockInfo累得的数组
 private int _length = 0;//存放Arraylist的长度，以供访问
 public int Length
 {
  get
  {
  return _length;
  }
 }
 public BlockInfo this[int index]//索引器，根据下标，返回一个blockinfo的值
 {
  get
  {
  return (BlockInfo)info[index];
  }
 }
 public string this[string id]//索引器，根据一个字符串的id值下标，给相应id的颜色赋值
 {
  set
  {
  if (value == "")
  {
   return;
  }
  for (int i = 0; i < info.Count; i++)
  {
   if (((BlockInfo)info[i]).GetIdStr() == id)
   {
   try
   {
    ((BlockInfo)info[i]).BColor = Color.FromArgb(Convert.ToInt32(value));
   }
   catch (System.FormatException)
   {
    MessageBox.Show("颜色信息错误！请删除BlockSet.xml文件，并重新启动程序，很抱歉给您带来麻烦", "错误信息",
    MessageBoxButtons.OK,
    MessageBoxIcon.Error);
   }
   }
  }
  }
 }
 public BitArray StrToBit(string id)//把字符串转换为bitArray
 {
  if (id.Length != 25)
  {
  throw new System.FormatException("砖块样式信息不合法！请删除BlockSet.xml文件，并重新启动程序");
  }
  BitArray ba = new BitArray(25);
  for (int i = 0; i < 25; i++)
  {
  ba[i] = (id[i] == '0') ? false : true;
  }
  return ba;
 }
 public void Add(BitArray id, Color bColor)//添加一个砖块信息
 {
  if (id.Length != 25)
  {
  throw new System.FormatException("砖块样式信息不合法！请删除blockset.xml文件，并重新启动程序");
  }
  info.Add(new BlockInfo(id, bColor));//给动态数组info添加一个砖块信息
  _length++;//长度加一
 }
 public void Add(string id, string bColor)
 
 {
  Color temp;
  if (!(bColor == ""))
  {
  temp = Color.FromArgb(Convert.ToInt32(bColor));//把字符串转换为颜色类
  }
  else
  {
  temp = Color.Empty;
  }
  info.Add(new BlockInfo(StrToBit(id), temp));//把字符串转换为bitarray类
  _length++;
 }

 }
}

namespace Tetris
{
 class BlockInfo
 {
 private BitArray _id;//存放砖块样式
 private Color _bColor;//存放颜色信息
 public BlockInfo(BitArray id, Color bColor)//构造函数，给似有函数变量赋值
 {
  _id = id;
  _bColor = bColor;
 }
 public BitArray ID
 {
  get
  {
  return _id;
  }
  set
  {
  _id = value;
  }

 }
 public Color BColor
 {
  get
  {
  return _bColor;
  }
  set
  {
  _bColor = value;
  }
 }
 public string GetIdStr()
 {
  StringBuilder s = new StringBuilder(25);
  foreach (bool b in _id)
  {
  s.Append(b ? "1" : "0");
  }
  return s.ToString();
 }
 public string GetColorStr()
 {
  return Convert.ToString(_bColor.ToArgb());
 }
 }
}

namespace Tetris
{
 class BlockGroup
 {
 private InfoArr info;//存放所有砖块样式信息
 private Color disapperColor;//背景色
 private int rectPix;//单元格像素
 public BlockGroup()//构造函数
 {
  Config config = new Config();
  config.LoadFromXmlFile();
  info = new InfoArr();
  info = config.Info;
  disapperColor = config.BackColor;
  rectPix = config.RectPix;
 }
 public Block GetABlock()//从砖块组中随机抽取一个砖块样式并返回
 {
  Random rd = new Random();//声明一个产生随机数的类
  int keyOrder = rd.Next(0, info.Length);//产生一个随机数
  BitArray ba = info[keyOrder].ID;//把抽取出的砖块样式赋给BitArray类对象ba
  int struNum = 0;//确定这个砖块样式中被填充方块的个数
  foreach (bool b in ba)//需要确定point数组的长度
  {
  if (b)
  {
   struNum++;
  }
  }
  Point[] structArr = new Point[struNum];//新建一个point数组，并确定其长度，以创建新的block
  int k = 0;
  for (int j = 0; j < ba.Length; j++)//用循环给point数组structarr赋坐标值
  {
  if (ba[j])
  {
   structArr[k].X = j / 5 - 2;
   structArr[k].Y = 2 - j % 5;
   k++;
  }
  }
  return new Block(structArr, info[keyOrder].BColor, disapperColor, rectPix);//创建一个新砖块并返回

 }
 }

namespace Tetris
{
 class Block
 {
 protected Point[] structArr;//存放砖块组成信息的坐标数组
 protected int _xPos;//砖块中心点所在的X坐标
 protected int _yPos;//砖块中心点所在的y坐标
 protected Color _blockColor;//砖块颜色
 protected Color disapperColor;//擦除颜色
 protected int rectPix;//每单元格像素
 public Block()//默认构造函数，声明此构造函数是为了子类能创建
 {
 
 }
 public Block(Point[] sa, Color bColor, Color dColor, int pix)
 {
  //重载构造函数，给成员变量赋值
  _blockColor = bColor;
  disapperColor = dColor;
  rectPix = pix;
  structArr = sa;
 }
 public Point this[int index]//索引器，根据索引访问砖块里的小方块坐标
 {
  get
  {
  return structArr[index];
  }
 }
 public int Length//属性，表示structArr的长度
 {
  get
  {
  return structArr.Length;
  }
 }
 #region 成员变量相应的属性
 public int XPos
 {
  get
  {
  return _xPos;
  }
  set
  {
  _xPos = value;
  }
 }
 public int YPos
 {
  get
  {
  return _yPos;
  }
  set
  {
  _yPos = value;
  }
 }
 public Color BlockColor
 {
  get
  {
  return _blockColor;
  }
 }
 #endregion
 public void DeasilRotate()//顺时针旋转
 {
  int temp;
  for (int i = 0; i < structArr.Length; i++)
  {
  temp = structArr[i].X;
  structArr[i].X = structArr[i].Y;
  structArr[i].Y = -temp;
  }
 }
 public void ContraRotate()//逆时针旋转
 {
  int temp;
  for (int i = 0; i < structArr.Length; i++)
  {
  temp = structArr[i].X;
  structArr[i].X = -structArr[i].Y;
  structArr[i].Y = temp;
  }
 }
 private Rectangle PointToRect(Point p)//把坐标点转化为画布的坐标值
 {
  return new Rectangle((_xPos + p.X) * rectPix + 1,
  (_yPos - p.Y) * rectPix + 1,
  rectPix - 2,
  rectPix - 2);
 }
 public virtual void Paint(Graphics gp)//在指定画板下绘制砖块
 {
  SolidBrush sb = new SolidBrush(_blockColor );
  foreach (Point p in structArr)
  {
  lock (gp)
  {
   gp.FillRectangle(sb, PointToRect(p));
  }
  }
 }
 public void erase(Graphics gp)//擦除矩形
 {
  SolidBrush sb = new SolidBrush(disapperColor);
  foreach (Point p in structArr)
  {
  lock (gp)
  {
   gp.FillRectangle(sb, PointToRect(p));
  }
  }
 }
 }
}

namespace Tetris
{
 public partial class FrmTetris : Form
 {
 public FrmTetris()
 {
  InitializeComponent();
  CheckForIllegalCrossThreadCalls = false;
 }

 private Palette p;
 private Keys downKey;
 private Keys dropKey;
 private Keys moveLeftKey;
 private Keys moveRightKey;
 private Keys deasilRotateKey;
 private Keys contraRotateKey;
 private int paletteWidth;
 private int paletteHeight;
 private Color paletteColor;
 private int rectPix;

 private void btnStart_Click(object sender, EventArgs e)
 {
  lblState.Text = "等级：1";
  lblcount.Text = "得分：0";
  if (p != null)
  {
  p.Close();
  }
  p = new Palette(paletteWidth, paletteHeight, rectPix, paletteColor,
  Graphics.FromHwnd(pbRun.Handle),
  Graphics.FromHwnd(lblReady.Handle));
  p.CountEvent += new Palette.IniCountHandle(p_CountEvent);
  p.Start();
 }
 void p_CountEvent(int _count,int state)
 {
  lblcount.Text = "得分："+_count.ToString();
  lblState.Text = "等级：" + state.ToString();
 }
 private void pbRun_Paint(object sender, PaintEventArgs e)
 {
  if (p != null)
  {
  p.PaintPalette(e.Graphics);
  }
 }

 private void lblReady_Paint(object sender, PaintEventArgs e)
 {
  if (p != null)
  {
  p.PaintReady(e.Graphics);
  }
 }

 private void FrmTetris_Load(object sender, EventArgs e)
 {
  //读取xml文件中的参数配置信息，并依次赋给似有成员变量
  Config config = new Config();
  config.LoadFromXmlFile();
  downKey = config.DownKey;
  dropKey = config.DropKey;
  moveLeftKey = config.MoveLeftKey;
  moveRightKey = config.MoveRightKey;
  deasilRotateKey = config.DeasilRotateKey;
  contraRotateKey = config.ContraRotateKey;
  paletteWidth = config.CoorWidth;
  paletteHeight = config.CoorHeight;
  paletteColor = config.BackColor;
  rectPix = config.RectPix;
  //根据画板的长度和宽度信息动态改变窗体及画板的规格
  this.Width = paletteWidth * rectPix + 215;
  this.Height = paletteHeight * rectPix + 38;
  pbRun.Width = paletteWidth * rectPix;
  pbRun.Height = paletteHeight * rectPix;

 }

 private void FrmTetris_KeyDown(object sender, KeyEventArgs e)
 {
  if (e.KeyValue == 32)//屏蔽回车键
  {
  e.Handled = true;
  }
  if (e.KeyCode == downKey)//下降
  {
  p.Down();
  }
  else if (e.KeyCode == dropKey)
  {
  p.Drop();
  }
  else if (e.KeyCode == moveLeftKey)
  {
  p.MoveLeft();
  }
  else if (e.KeyCode == moveRightKey)
  {
  p.MoveRight();
  }
  else if (e.KeyCode == deasilRotateKey)
  {
  p.DeasilRotate();
  }
  else if (e.KeyCode == contraRotateKey)
  {
  p.ContraRotate();
  }
 }

 private void btnPause_Click(object sender, EventArgs e)
 {
  if (p == null)
  {
  return;
  }
  if (btnPause.Text == "暂停")
  {
  p.Pause();
  btnPause.Text = "继续";
  }
  else
  {
  p.EndPause();
  btnPause.Text = "暂停";
  }

 }

 private void btnConfig_Click(object sender, EventArgs e)
 {
  if (btnPause.Text == "暂停")
  {
  btnPause.PerformClick();
  }
  using (Frmconfig frmconfig= new Frmconfig())
  {
  frmconfig.ShowDialog();
  }
 }

 private void FrmTetris_FormClosing(object sender, FormClosingEventArgs e)
 {
  if (p !=null )
  {
  p.Close ();
  }
 }

 private void button5_Click(object sender, EventArgs e)
 {
  p.Down();
 }

 private void button1_Click(object sender, EventArgs e)
 {
  p.MoveLeft();
 }

 private void button2_Click(object sender, EventArgs e)
 {
  p.MoveRight();
 }

 private void button3_Click(object sender, EventArgs e)
 {
  p.DeasilRotate();
 }

 private void button4_Click(object sender, EventArgs e)
 {
  p.ContraRotate();
 }

 private void button6_Click(object sender, EventArgs e)
 {
  p.Drop();
 }

 private void button7_Click(object sender, EventArgs e)
 {
  OpenFileDialog ofDialog = new OpenFileDialog();
  ofDialog.AddExtension = true;
  ofDialog.CheckFileExists = true;
  ofDialog.CheckPathExists = true;

  //the next sentence must be in single line
  ofDialog.Filter = "MP3文件(*.mp3)|*.mp3|Audio文件(*.avi)|*.avi|VCD文件(*.dat)|*.dat|WAV文件(*.wav)|*.wav|所有文件 (*.*)|*.*";
  ofDialog.DefaultExt = "*.mp3";
  if (ofDialog.ShowDialog() == DialogResult.OK)
  {
  this.axWindowsMediaPlayer1.URL = ofDialog.FileName;
  }
 }

 private void timer1_Tick(object sender, EventArgs e)
 {
  DateTime dt = DateTime.Now; //当前时间的实例; 
  lbltime.Text = dt.ToString(); //转为string类型 把值交给lbltime的Text属性; 
 }

 private void button8_Click(object sender, EventArgs e)
 {
  
  p.CountEvent += new Palette.IniCountHandle(p_CountEvent);
  p.nextstate();
 }

 }
}

namespace Tetris
{
 public partial class Frmconfig : Form
 {
 public Frmconfig()
 {
  InitializeComponent();
 }
 private bool[,] struArr = new bool[5, 5];
 private Color blockColor = Color.Red;
 private void lblMode_Paint(object sender, PaintEventArgs e)
 {
  Graphics gp = e.Graphics;
  gp.Clear(Color.Black);
  Pen p = new Pen(Color.White);
  for (int i = 31; i < 155; i = i + 31)
  gp.DrawLine(p, 1, i, 155, i);
  for (int i = 31; i < 155; i = i + 31)
  gp.DrawLine(p, i, 1, i, 155);
  //填充颜色
  SolidBrush s = new SolidBrush(blockColor);
  for (int x = 0; x < 5; x++)
  {
  for (int y = 0; y < 5; y++)
  {
   if (struArr[x, y])
   {
   gp.FillRectangle(s, 31 * x + 1, 31 * y + 1, 30, 30);
   }
  }
  }

 }

 private void lblMode_MouseClick(object sender, MouseEventArgs e)
 {
  if (e.Button != MouseButtons.Left)
  return;
  int xPos, yPos;
  xPos = e.X / 31;
  yPos = e.Y / 31;
  struArr[xPos, yPos] = !struArr[xPos, yPos];
  bool b = struArr[xPos, yPos];
  Graphics gp = lblMode.CreateGraphics();
  SolidBrush s = new SolidBrush(b ? blockColor : Color.Black);
  gp.FillRectangle(s, 31 * xPos + 1, 31 * yPos + 1, 30, 30);
  gp.Dispose();
 }
 }
}