游戏人生Silverlight(1) - 七彩俄罗斯方块[Silverlight 2.0(c#)]

[源码下载]

游戏人生Silverlight(1) - 七彩俄罗斯方块[Silverlight 2.0(c#)]

作者：webabcd


介绍
使用 Silverlight 2.0(c#) 开发一个七彩俄罗斯方块


玩法
↑ - 变形；← - 向左移动；→ - 向右移动；↓ - 向下移动


在线DEMO



思路
1、每个形状都是由4个“块”组成的，也就是“块”是俄罗斯方块的最小单位，首先要有一个“块”的用户控件。要求可以设置“块”的位置和颜色
2、经典俄罗斯方块一共7种形状，把每种形状所需要的功能抽象出来写一个抽象类，7个具体形状分别继承这个抽象类，并重写其抽象属性和抽象方法
3、核心控制部分：在容器内铺满隐藏的“块”，上/下/左/右/控制形状的变形和移动，通过控制容器内“块”的颜色来响应变化，当形状下一步移动或变形的位置处已经有颜色时则禁止移动或变形，当形状下一步移动或变形的位置在底边有颜色或处于容器的底部则判断消行并生成新的形状


关键代码
1、形状抽象类
PieceBase.cs

using System;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;

namespace YYTetris.Piece
{
         public abstract class PieceBase
        {
                 public PieceBase()
                {
                        InitPiece();
                }

                 // 形状的矩阵
                 public int[,] Matrix { get; set; }

                 // 形状的索引
                 private int _index = 0;

                 // 形状的最大索引
                 public int MaxIndex { get; set; }

                 /// <summary>
                 /// 初始化形状，需要设置 Matrix 和 MaxIndex
                 /// </summary>
                 public abstract void InitPiece();

                 /// <summary>
                 /// 变形
                 /// </summary>
                 /// <returns>变形后的矩阵</returns>
                 public abstract int[,] GetRotate();

                 /// <summary>
                 /// 形状的颜色
                 /// </summary>
                 public abstract Color Color { get; }

                 /// <summary>
                 /// 获取下一个形状的索引。如果超过最大索引则返回最初索引
                 /// </summary>
                 /// <returns></returns>
                 public int GetNextIndex()
                {
                         int nextIndex = _index >= MaxIndex ? 0 : _index + 1;

                         return nextIndex;
                }

                 /// <summary>
                 /// 变形。设置 Matrix 为变形后的矩阵
                 /// </summary>
                 public void Rotate()
                {
                        Matrix = GetRotate();

                        _index = GetNextIndex();
                }
        }
}

 

2、继承PieceBase类，以“L”为例。每种形状均为一个4×4矩阵，1代表有“块”，0代表空
L.cs

using System;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;

namespace YYTetris.Piece
{
         public class L : PieceBase
        {
                 public override void InitPiece()
                {
                        Matrix = new int[,]
                        {
                                {0,1,0,0},
                                {0,1,0,0},
                                {0,1,1,0},
                                {0,0,0,0}
                        };

                        MaxIndex = 3;
                }

                 public override int[,] GetRotate()
                {
                         switch (GetNextIndex())
                        {
                                 case 0:
                                         return new int[,]
                                        {
                                                {0,1,0,0},
                                                {0,1,0,0},
                                                {0,1,1,0},
                                                {0,0,0,0}
                                        };
                                 case 1:
                                         return new int[,]
                                        {
                                                {0,0,0,0},
                                                {1,1,1,0},
                                                {1,0,0,0},
                                                {0,0,0,0}
                                        };
                                 case 2:
                                         return new int[,]
                                        {
                                                {1,1,0,0},
                                                {0,1,0,0},
                                                {0,1,0,0},
                                                {0,0,0,0}
                                        };
                                 case 3:
                                         return new int[,]
                                        {
                                                {0,0,1,0},
                                                {1,1,1,0},
                                                {0,0,0,0},
                                                {0,0,0,0}
                                        };
                                 default:
                                         return Matrix;
                        }
                }

                 public override Color Color
                {
                        get { return Helper.GetColor( "#339933"); }
                }
        }
}

 

3、核心控制类
UIControl.cs

using System;
using System.Net;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Documents;
using System.Windows.Ink;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;

using YYTetris.Piece;
using System.Windows.Threading;
using System.Collections.Generic;
using System.ComponentModel;

namespace YYTetris
{
         public class UIControl : INotifyPropertyChanged
        {
                 /// <summary>
                 /// 俄罗斯方块容器
                 /// </summary>
                 public Block[,] Container { get; set; }

                 /// <summary>
                 /// 下一个形状的容器（4×4）
                 /// </summary>
                 public Block[,] NextContainer { get; set; }

                 /// <summary>
                 /// 游戏状态（Ready, Play, Pause, Over）
                 /// </summary>
                 public GameStatus GameStatus { get; set; }

                 private int _rows = 20; // 行数（Y 方向）
                 private int _columns = 10; // 列数（X 方向）
                 private int _positionX = 3; // 形状所属的 4×4 容器的 X 坐标
                 private int _positionY = 0; // 形状所属的 4×4 容器的 Y 坐标

                 private List<PieceBase> _pieces; // 形状集合

                 private PieceBase _currentPiece; // 当前形状
                 private PieceBase _nextPiece; // 下一个形状

                 private int _initSpeed = 400; // 初始速率（毫秒）
                 private int _levelSpeed = 50; // 每增加一个级别所需增加的速率（毫秒）

                 private DispatcherTimer _timer;

                 /// <summary>
                 /// 构造函数
                 /// </summary>
                 public UIControl()
                {
                         // 初始化形状集合，共七种形状
                        _pieces = new List<PieceBase>() { new I(), new L(), new L2(), new N(), new N2(), new O(), new T() };

                         // 初始化方块容器（用 Block 对象填满整个容器）
                        Container = new Block[_rows, _columns];
                         for ( int i = 0; i < _rows; i++)
                        {
                                 for ( int j = 0; j < _columns; j++)
                                {
                                        var block = new Block();
                                        block.Top = i * block.rectangle.ActualHeight;
                                        block.Left = j * block.rectangle.ActualWidth;
                                        block.Color = null;

                                        Container[i, j] = block;
                                }
                        }

                         // 初始化下一个形状的容器（用 Block 对象将其填满）
                        NextContainer = new Block[4, 4];
                         for ( int i = 0; i < 4; i++)
                        {
                                 for ( int j = 0; j < 4; j++)
                                {
                                        var block = new Block();
                                        block.Top = i * block.rectangle.ActualHeight;
                                        block.Left = j * block.rectangle.ActualWidth;
                                        block.Color = null;

                                        NextContainer[i, j] = block;
                                }
                        }

                         // 创建一个新的形状
                        CreatePiece();
                         // 呈现当前创建出的形状
                        AddPiece(0, 0);

                         // Timer 用于定时向下移动形状
                        _timer = new DispatcherTimer();
                        _timer.Interval = TimeSpan.FromMilliseconds(_initSpeed);
                        _timer.Tick += new EventHandler(_timer_Tick);

                        GameStatus = GameStatus.Ready;
                }

                 /// <summary>
                 /// 开始游戏（启动计时器）
                 /// </summary>
                 public void Play()
                {
                        GameStatus = GameStatus.Play;
                        _timer.Start();
                }

                 /// <summary>
                 /// 暂停游戏（停止计时器）
                 /// </summary>
                 public void Pause()
                {
                        GameStatus = GameStatus.Pause;
                        _timer.Stop();
                }

                 /// <summary>
                 /// 创建一个新的形状
                 /// </summary>
                 private void CreatePiece()
                {
                         // 逻辑移到 下坠后 的逻辑内
                         for ( int x = 0; x < _columns; x++)
                        {
                                 if (Container[0, x].Color != null)
                                {
                                        OnGameOver( null);
                                         break;
                                }
                        }

                         // 计算 当前形状 和 下一个形状
                        Random random = new Random();
                        _currentPiece = _nextPiece == null ? _pieces[random.Next(0, 7)] : _nextPiece;
                        _nextPiece = _pieces[random.Next(0, 7)];

                         // 形状所属的 4×4 容器的 X 坐标和 Y 坐标
                        _positionX = 3;
                        _positionY = 0;

                         // 设置“下一个形状的容器”的 UI
                        SetNextContainerUI();
                }

                 private void _timer_Tick( object sender, EventArgs e)
                {
                        MoveToDown();
                }

                 /// <summary>
                 /// 向左移动
                 /// </summary>
                 public void MoveToLeft()
                {
                         if (GameStatus != GameStatus.Play) return;

                         if (!IsBoundary(_currentPiece.Matrix, -1, 0))
                        {
                                RemovePiece();
                                AddPiece(-1, 0);
                        }
                }

                 /// <summary>
                 /// 向右移动
                 /// </summary>
                 public void MoveToRight()
                {
                         if (GameStatus != GameStatus.Play) return;

                         if (!IsBoundary(_currentPiece.Matrix, 1, 0))
                        {
                                RemovePiece();
                                AddPiece(1, 0);
                        }
                }

                 /// <summary>
                 /// 向下移动
                 /// </summary>
                 public void MoveToDown()
                {
                         if (GameStatus != GameStatus.Play) return;

                         if (!IsBoundary(_currentPiece.Matrix, 0, 1))
                        {
                                RemovePiece();
                                AddPiece(0, 1);
                        }
                         else
                        {
                                 // 如果触及底边了，则消除可消的行并且创建新的形状
                                RemoveRow();
                                CreatePiece();

                                 // 每落下一个形状加 1 分
                                Score++;
                        }
                }

未完待续>>