[C#] 简单的俄罗斯方块实现

一个控制台俄罗斯方块游戏的简单实现. 已在 github.com/SlimeNull/Tetris 开源.

在这里插入图片描述

思路

很简单, 一个二维数组存储当前游戏的方块地图, 用 bool 即可, true 表示当前块被填充, false 表示没有.

然后, 抽一个 “形状” 类, 形状表示当前玩家正在操作的一个形状, 例如方块, 直线, T 形什么的. 一个形状又有不同的样式, 也就是玩家可以切换的样式. 每一个样式都是原来样式旋转之后的结果. 为了方便, 可以直接使用硬编码的方式存储所有样式中方块的相对坐标.

一个形状有一个自己的坐标, 并且它包含很多方块. 在绘制的时候, 获取它每一个方块的坐标, 转换为地图内的绝对坐标, 然后使用 StringBuilder 拼接字符串, 即可.

资料

俄罗斯方块中总共有这七种方块

在这里插入图片描述

类型定义

一个简单的二维坐标

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
/// <summary>
/// 表示一个坐标
/// </summary>
/// <param name="X"></param>
/// <param name="Y"></param>
record struct Coordinate(int X, int Y)
{
    /// <summary>
    /// 根据基坐标和相对坐标, 获取一个绝对坐标
    /// </summary>
    /// <param name="baseCoord"></param>
    /// <param name="relativeCoord"></param>
    /// <returns></returns>
    public static Coordinate GetAbstract(Coordinate baseCoord, Coordinate relativeCoord)
    {
        return new Coordinate(baseCoord.X + relativeCoord.X, baseCoord.Y + relativeCoord.Y);
    }
}

形状的一个样式, 单纯使用坐标数组存储即可.

1
record struct ShapeStyle(Coordinate[] Coordinates);

形状

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
/// <summary>
/// 形状基类
/// </summary>
abstract class Shape
{
    /// <summary>
    /// 名称
    /// </summary>
    public abstract string Name { get; }

    /// <summary>
    /// 形状的位置
    /// </summary>
    public Coordinate Position { get; set; }

    /// <summary>
    /// 形状所有的样式
    /// </summary>
    protected abstract ShapeStyle[] ShapeStyles { get; }

    /// <summary>
    /// 当前使用的样式索引
    /// </summary>
    private int _currentStyleIndex = 0;

    /// <summary>
    /// 从坐标构建一个新形状
    /// </summary>
    /// <param name="position"></param>
    public Shape(Coordinate position)
    {
        Position = position;
    }

    /// <summary>
    /// 获取当前形状的当前所有方块 (相对坐标)
    /// </summary>
    /// <returns></returns>
    public IEnumerable<Coordinate> GetBlocks()
    {
        return ShapeStyles[_currentStyleIndex].Coordinates;
    }

    /// <summary>
    /// 获取当前形状下一个样式的所有方块 (相对坐标)
    /// </summary>
    /// <returns></returns>
    public IEnumerable<Coordinate> GetNextStyleBlocks()
    {
        return ShapeStyles[(_currentStyleIndex + 1) % ShapeStyles.Length].Coordinates;
    }

    /// <summary>
    /// 改变样式
    /// </summary>
    public void ChangeStyle()
    {
        _currentStyleIndex = (_currentStyleIndex + 1) % ShapeStyles.Length;
    }
}

一个 T 形状的实现

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
class ShapeT : Shape
{
    public ShapeT(Coordinate position) : base(position)
    {
    }

    public override string Name => "T";

    protected override ShapeStyle[] ShapeStyles { get; } = new ShapeStyle[]
    {
        new ShapeStyle(
            new Coordinate[]
            {
                new Coordinate(-1, 0),
                new Coordinate(0, 0),
                new Coordinate(1, 0),
                new Coordinate(0, 1),
            }),
        new ShapeStyle(
            new Coordinate[]
            {
                new Coordinate(-1, 0),
                new Coordinate(0, -1),
                new Coordinate(0, 0),
                new Coordinate(0, 1),
            }),
        new ShapeStyle(
            new Coordinate[]
            {
                new Coordinate(-1, 0),
                new Coordinate(0, 0),
                new Coordinate(1, 0),
                new Coordinate(0, -1),
            }),
        new ShapeStyle(
            new Coordinate[]
            {
                new Coordinate(1, 0),
                new Coordinate(0, -1),
                new Coordinate(0, 0),
                new Coordinate(0, 1),
            }),
    };
}

主逻辑

上面的定义已经写好了, 接下来就是写游戏主逻辑.

主逻辑包含每一回合自动向下移动形状, 如果无法继续向下移动, 则把当前的形状存储到地图中. 并进行一次扫描, 将所有的整行全部消除.

抽一个 TetrisGame 的类用来表示俄罗斯方块游戏, 下面是这个类的基本定义.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class TetrisGame
{
    /// <summary>
    /// x, y
    /// </summary>
    private readonly bool[,] map;

    private readonly Random random = new Random();


    public TetrisGame(int width, int height)
    {
        map = new bool[width, height];

        Width = width;
        Height = height;
    }

    public Shape? CurrentShape { get; set; }

    public int Width { get; }
    public int Height { get; }
}

判断当前形状是否可以进行移动的方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
/// <summary>
/// 判断是否可以移动 (移动后是否会与已有方块重合, 或者超出边界)
/// </summary>
/// <param name="xOffset"></param>
/// <param name="yOffset"></param>
/// <returns></returns>
private bool CanMove(int xOffset, int yOffset)
{
    // 如果当前没形状, 返回 false
    if (CurrentShape == null)
        return false;

    foreach (var block in CurrentShape.GetBlocks())
    {
        Coordinate coord = Coordinate.GetAbstract(CurrentShape.Position, block);

        coord.X += xOffset;
        coord.Y += yOffset;

        // 如果移动后方块坐标超出界限, 不能移动
        if (coord.X < 0 || coord.X >= Width ||
            coord.Y < 0 || coord.Y >= Height)
            return false;

        // 如果移动后方块会与地图现有方块重合, 则不能移动
        if (map[coord.X, coord.Y])
            return false;
    }

    return true;
}

判断当前形状是否能够切换到下一个样式的方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
/// <summary>
/// 判断是否可以改变形状 (改变形状后是否会和已有方块重合, 或者超出边界)
/// </summary>
/// <returns></returns>
private bool CanChangeShape()
{
    // 如果当前没形状, 当然不能切换样式
    if (CurrentShape == null)
        return false;

    // 获取下一个样式的所有方块
    foreach (var block in CurrentShape.GetNextStyleBlocks())
    {
        Coordinate coord = Coordinate.GetAbstract(CurrentShape.Position, block);

        // 如果超出界限, 不能切换
        if (coord.X < 0 || coord.X >= Width ||
            coord.Y < 0 || coord.Y >= Height)
            return false;

        // 如果与现有方块重合, 不能切换
        if (map[coord.X, coord.Y])
            return false;
    }

    return true;
}

把当前形状存储到地图中

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
/// <summary>
/// 将当前形状存储到地图中
/// </summary>
private void StorageShapeToMap()
{
    // 没形状, 存寂寞
    if (CurrentShape == null)
        return;

    // 所有方块遍历一下
    foreach (var block in CurrentShape.GetBlocks())
    {
        // 转为绝对坐标
        Coordinate coord = Coordinate.GetAbstract(CurrentShape.Position, block);

        // 超出界限则跳过
        if (coord.X < 0 || coord.X >= Width ||
            coord.Y < 0 || coord.Y >= Height)
            continue;

        // 存地图里
        map[coord.X, coord.Y] = true;
    }

    // 当前形状设为 null
    CurrentShape = null;
}

生成一个新形状

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/// <summary>
/// 生成一个新形状
/// </summary>
/// <exception cref="InvalidOperationException"></exception>
private void GenerateShape()
{
    int shapeCount = 7;
    int randint = random.Next(shapeCount);

    Coordinate initCoord = new Coordinate(Width / 2, 0);

    Shape newShape = randint switch
    {
        0 => new ShapeI(initCoord),
        1 => new ShapeJ(initCoord),
        2 => new ShapeL(initCoord),
        3 => new ShapeO(initCoord),
        4 => new ShapeS(initCoord),
        5 => new ShapeT(initCoord),
        6 => new ShapeZ(initCoord),

        _ => throw new InvalidOperationException()
    };

    CurrentShape = newShape;
}

扫描地图, 消除所有整行

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
/// <summary>
/// 扫描, 消除掉可消除的行
/// </summary>
private void Scan()
{
    for (int y = 0;  y < Height; y++)
    {
        // 设置当前行是整行
        bool ok = true;

        // 循环当前行的所有方块, 如果方块为 false, ok 就会被设为 false
        for (int x = 0; x < Width; x++)
            ok &= map[x, y];

        // 如果当前行确实是整行
        if (ok)
        {
            // 所有行全部往下移动
            for (int _y = y; _y > 0; _y--)
                for (int x = 0; x < Width; x++)
                    map[x, _y] = map[x, _y - 1];
            
            // 最顶行全设为空
            for (int x = 0; x < Width; x++)
                map[x, 0] = false;
        }
    }
}

封装一些用户操作使用的方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
/// <summary>
/// 根据指定偏移, 进行移动
/// </summary>
/// <param name="xOffset"></param>
/// <param name="yOffset"></param>
public void Move(int xOffset, int yOffse
{
    lock (this)
    {
        if (CurrentShape == null)
            return;

        if (CanMove(xOffset, yOffset))
        {
            var newCoord = CurrentShape.
            newCoord.X += xOffset;
            newCoord.Y += yOffset;

            CurrentShape.Position = newC
        }
    }
}

/// <summary>
/// 向左移动
/// </summary>
public void MoveLeft()
{
    Move(-1, 0);
}

/// <summary>
/// 向右移动
/// </summary>
public void MoveRight()
{
    Move(1, 0);
}

/// <summary>
/// 向下移动
/// </summary>
public void MoveDown()
{
    Move(0, 1);
}

/// <summary>
/// 改变形状样式
/// </summary>
public void ChangeShapeStyle()
{
    lock (this)
    {
        if (CurrentShape == null)
            return;

        if (CanChangeShape())
            CurrentShape.ChangeStyle();
    }
}

/// <summary>
/// 降落到底部
/// </summary>
public void Fall()
{
    lock (this)
    {
        while (CanMove(0, 1))
        {
            Move(0, 1);
        }
    }
}

游戏每一轮的主逻辑

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
/// <summary>
/// 下一个回合
/// </summary>
public void NextTurn()
{
    lock (this)
    {
        // 如果当前没有存在的形状, 则生成一个新的, 并返回
        if (CurrentShape == null)
        {
            GenerateShape();
            return;
        }

        // 如果可以向下移动
        if (CanMove(0, 1))
        {
            // 直接改变当前形状的坐标
            var newCoord = CurrentShape.Position;
            newCoord.Y += 1;

            CurrentShape.Position = newCoord;
        }
        else
        {
            // 将当前的形状保存到地图中
            StorageShapeToMap();
        }

        // 扫描, 判断某些行可以被消除
        Scan();
    }
}

将地图渲染到控制台

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
public void Render()
{
    StringBuilder sb = new StringBuilder();

    bool[,] mapCpy = new bool[Width, Height];
    Array.Copy(map, mapCpy, mapCpy.Length);

    if (CurrentShape != null)
    {
        foreach (var block in CurrentShape.GetBlocks())
        {
            Coordinate coord = Coordinate.GetAbstract(CurrentShape.Position, block);
            if (coord.X < 0 || coord.X >= Width ||
                coord.Y < 0 || coord.Y >= Height)
                continue;

            mapCpy[coord.X, coord.Y] = true;
        }
    }

    sb.AppendLine("┌" + new string('─', Width * 2) + "┐");
    for (int y = 0; y < Height; y++)
    {
        sb.Append("|");

        for (int x = 0; x < Width; x++)
        {
            sb.Append(mapCpy[x, y] ? "##" : "  ");
        }

        sb.Append("|");

        sb.AppendLine();
    }

    sb.AppendLine("└" + new string('─', Width * 2) + "┘");

    lock (this)
    {
        Console.SetCursorPosition(0, 0);
        Console.Write(sb.ToString());
    }
}