C#俄罗斯方块

C#俄罗斯方块是一个基于C#编程语言的俄罗斯方块游戏。它的实现方式类似于其他语言的俄罗斯方块游戏。

首先，需要定义俄罗斯方块的方块类型和形状。可以使用数组来定义每种方块的形状，例如：

int[,] block1 = {{1, 1}, {1, 1}};
int[,] block2 = {{0, 2, 0}, {2, 2, 2}};
int[,] block3 = {{0, 3, 3}, {3, 3, 0}};
...

然后，需要定义游戏区域和游戏逻辑。游戏区域可以使用二维数组来表示，每个位置存储该位置是否有方块。

在游戏运行时，需要不断地生成新的方块，并让玩家控制方块的移动和旋转。当一个方块无法再下落时，需要将其固定在游戏区域中并检查是否有可以消除的行。

最后，还需要实现分数计算、游戏结束等逻辑。

这只是一个简单的实现方式，具体可以根据需求和个人喜好进行优化和改进。

相关问题

写一个C#俄罗斯方块游戏

很高兴回答您的问题！以下是一个简单的C#俄罗斯方块游戏的示例代码：

using System;
using System.Collections.Generic;

namespace Tetris
{
    class Program
    {
        static void Main(string[] args)
        {
            // 初始化游戏板和方块
            int[,] board = new int[20, 10];
            Block currentBlock = new Block();

            // 游戏循环
            while (true)
            {
                // 显示游戏板和当前方块
                DisplayBoard(board, currentBlock);

                // 获取用户输入
                ConsoleKeyInfo keyInfo = Console.ReadKey(true);

                // 移动方块或旋转方块
                if (keyInfo.Key == ConsoleKey.LeftArrow)
                {
                    currentBlock.MoveLeft(board);
                }
                else if (keyInfo.Key == ConsoleKey.RightArrow)
                {
                    currentBlock.MoveRight(board);
                }
                else if (keyInfo.Key == ConsoleKey.DownArrow)
                {
                    currentBlock.MoveDown(board);
                }
                else if (keyInfo.Key == ConsoleKey.UpArrow)
                {
                    currentBlock.Rotate(board);
                }

                // 下落方块
                if (!currentBlock.MoveDown(board))
                {
                    // 如果方块无法再下落，将方块固定到游戏板上
                    currentBlock.Lock(board);

                    // 判断是否有一行已经填满
                    int linesCleared = 0;
                    for (int i = board.GetLength(0) - 1; i >= 0; i--)
                    {
                        bool isFullLine = true;
                        for (int j = 0; j < board.GetLength(1); j++)
                        {
                            if (board[i, j] == 0)
                            {
                                isFullLine = false;
                                break;
                            }
                        }
                        if (isFullLine)
                        {
                            // 如果有一行已经填满，将该行删除并将上面的方块下移
                            for (int k = i; k > 0; k--)
                            {
                                for (int j = 0; j < board.GetLength(1); j++)
                                {
                                    board[k, j] = board[k - 1, j];
                                }
                            }
                            linesCleared++;
                            i++; // 由于上面的方块下移，需要重新检查该行
                        }
                    }

                    // 如果有行被删除，更新分数
                    if (linesCleared > 0)
                    {
                        UpdateScore(linesCleared);
                    }

                    // 创建一个新的方块
                    currentBlock = new Block();
                }
            }
        }

        static void DisplayBoard(int[,] board, Block currentBlock)
        {
            // 清空控制台
            Console.Clear();

            // 显示分数
            Console.WriteLine("Score: " + score);

            // 显示游戏板和当前方块
            for (int i = 0; i < board.GetLength(0); i++)
            {
                for (int j = 0; j < board.GetLength(1); j++)
                {
                    if (board[i, j] == 0)
                    {
                        Console.Write(".");
                    }
                    else
                    {
                        Console.Write("X");
                    }
                }
                Console.Write("    ");
                for (int j = 0; j < 4; j++)
                {
                    for (int k = 0; k < 4; k++)
                    {
                        if (currentBlock.Shape[j, k] == 0)
                        {
                            Console.Write(".");
                        }
                        else
                        {
                            Console.Write("X");
                        }
                    }
                    Console.WriteLine();
                }
            }
        }

        static int score = 0;

        static void UpdateScore(int linesCleared)
        {
            score += linesCleared * 100;
        }
    }

    class Block
    {
        public int[,] Shape { get; private set; }
        public int Row { get; private set; }
        public int Col { get; private set; }

        private static Random random = new Random();
        private static List<int[,]> shapes = new List<int[,]>()
        {
            new int[,] { { 1, 1 }, { 1, 1 } },
            new int[,] { { 0, 1, 0 }, { 1, 1, 1 } },
            new int[,] { { 1, 0, 0 }, { 1, 1, 1 } },
            new int[,] { { 0, 0, 1 }, { 1, 1, 1 } },
            new int[,] { { 1, 1, 0 }, { 0, 1, 1 } },
            new int[,] { { 0, 1, 1 }, { 1, 1, 0 } },
            new int[,] { { 1, 1, 1, 1 } }
        };

        public Block()
        {
            // 随机选择一个方块
            int index = random.Next(shapes.Count);
            Shape = shapes[index];

            // 将方块放到游戏板的顶部中央
            Row = 0;
            Col = (10 - Shape.GetLength(1)) / 2;
        }

        public bool MoveLeft(int[,] board)
        {
            if (Col > 0 && CanMove(board, Row, Col - 1))
            {
                Col--;
                return true;
            }
            return false;
        }

        public bool MoveRight(int[,] board)
        {
            if (Col < board.GetLength(1) - Shape.GetLength(1) && CanMove(board, Row, Col + 1))
            {
                Col++;
                return true;
            }
            return false;
        }

        public bool MoveDown(int[,] board)
        {
            if (Row < board.GetLength(0) - Shape.GetLength(0) && CanMove(board, Row + 1, Col))
            {
                Row++;
                return true;
            }
            return false;
        }

        public void Rotate(int[,] board)
        {
            int[,] rotatedShape = new int[Shape.GetLength(1), Shape.GetLength(0)];
            for (int i = 0; i < Shape.GetLength(0); i++)
            {
                for (int j = 0; j < Shape.GetLength(1); j++)
                {
                    rotatedShape[j, Shape.GetLength(0) - 1 - i] = Shape[i, j];
                }
            }
            if (CanMove(board, Row, Col, rotatedShape))
            {
                Shape = rotatedShape;
            }
        }

        public void Lock(int[,] board)
        {
            for (int i = 0; i < Shape.GetLength(0); i++)
            {
                for (int j = 0; j < Shape.GetLength(1); j++)
                {
                    if (Shape[i, j] != 0)
                    {
                        board[Row + i, Col + j] = 1;
                    }
                }
            }
        }

        private bool CanMove(int[,] board, int newRow, int newCol)
        {
            return CanMove(board, newRow, newCol, Shape);
        }

        private bool CanMove(int[,] board, int newRow, int newCol, int[,] newShape)
        {
            for (int i = 0; i < newShape.GetLength(0); i++)
            {
                for (int j = 0; j < newShape.GetLength(1); j++)
                {
                    if (newShape[i, j] != 0)
                    {
                        int row = newRow + i;
                        int col = newCol + j;
                        if (row < 0 || row >= board.GetLength(0) || col < 0 || col >= board.GetLength(1) || board[row, col] != 0)
                        {
                            return false;
                        }
                    }
                }
            }
            return true;
        }
    }
}

此代码创建了一个简单的俄罗斯方块游戏，其中方块可以左右移动、向下落、旋转，并且可以与游戏板上的方块进行碰撞检测。该代码可以运行在控制台中。

C# 写个 俄罗斯方块

好的，下面是一个简单的 C# 俄罗斯方块游戏代码：

using System;
using System.Threading;

namespace Tetris
{
    class Program
    {
        // 游戏区域大小
        const int Width = 10;
        const int Height = 20;

        // 方块图形数组
        static readonly int[][][] Tetrominoes = new int[][][]
        {
            new int[][] // I
            {
                new int[] { 1, 1, 1, 1 }
            },
            new int[][] // J
            {
                new int[] { 1, 1, 1 },
                new int[] { 0, 0, 1 }
            },
            new int[][] // L
            {
                new int[] { 1, 1, 1 },
                new int[] { 1, 0, 0 }
            },
            new int[][] // O
            {
                new int[] { 1, 1 },
                new int[] { 1, 1 }
            },
            new int[][] // S
            {
                new int[] { 0, 1, 1 },
                new int[] { 1, 1, 0 }
            },
            new int[][] // T
            {
                new int[] { 1, 1, 1 },
                new int[] { 0, 1, 0 }
            },
            new int[][] // Z
            {
                new int[] { 1, 1, 0 },
                new int[] { 0, 1, 1 }
            }
        };

        // 随机数生成器
        static readonly Random Random = new Random();

        // 当前方块
        static int[][] CurrentTetromino;
        static int CurrentX;
        static int CurrentY;

        // 游戏区域
        static readonly int[][] Board = new int[Height][];
        static int Score;

        // 控制台输出锁
        static readonly object ConsoleLock = new object();

        static void Main(string[] args)
        {
            // 初始化游戏区域
            for (int i = 0; i < Height; i++)
            {
                Board[i] = new int[Width];
            }

            // 开始游戏循环
            while (true)
            {
                // 产生新的方块
                CurrentTetromino = Tetrominoes[Random.Next(Tetrominoes.Length)];
                CurrentX = Width / 2 - CurrentTetromino[0].Length / 2;
                CurrentY = 0;

                // 游戏循环
                while (true)
                {
                    // 处理用户输入
                    if (Console.KeyAvailable)
                    {
                        var key = Console.ReadKey(true);
                        switch (key.Key)
                        {
                            case ConsoleKey.LeftArrow:
                                if (IsLegalMove(CurrentTetromino, CurrentX - 1, CurrentY))
                                {
                                    CurrentX--;
                                }
                                break;
                            case ConsoleKey.RightArrow:
                                if (IsLegalMove(CurrentTetromino, CurrentX + 1, CurrentY))
                                {
                                    CurrentX++;
                                }
                                break;
                            case ConsoleKey.DownArrow:
                                if (IsLegalMove(CurrentTetromino, CurrentX, CurrentY + 1))
                                {
                                    CurrentY++;
                                }
                                break;
                            case ConsoleKey.Spacebar:
                                // 下落到底部
                                while (IsLegalMove(CurrentTetromino, CurrentX, CurrentY + 1))
                                {
                                    CurrentY++;
                                }
                                break;
                        }
                    }

                    // 计算下一帧
                    var nextTetrominoY = CurrentY + 1;
                    if (IsLegalMove(CurrentTetromino, CurrentX, nextTetrominoY))
                    {
                        CurrentY = nextTetrominoY;
                    }
                    else
                    {
                        // 将当前方块放入游戏区域
                        for (int i = 0; i < CurrentTetromino.Length; i++)
                        {
                            for (int j = 0; j < CurrentTetromino[i].Length; j++)
                            {
                                if (CurrentTetromino[i][j] == 1)
                                {
                                    Board[CurrentY + i][CurrentX + j] = 1;
                                }
                            }
                        }

                        // 消除满行
                        int linesCleared = 0;
                        for (int i = 0; i < Height; i++)
                        {
                            if (IsRowFull(i))
                            {
                                ClearRow(i);
                                linesCleared++;
                            }
                        }

                        // 更新分数
                        Score += linesCleared * linesCleared;

                        // 判断游戏是否结束
                        if (IsGameOver())
                        {
                            lock (ConsoleLock)
                            {
                                Console.SetCursorPosition(0, Height + 1);
                                Console.WriteLine("Game over! Your score is {0}.", Score);
                            }
                            return;
                        }

                        // 跳出当前方块的下落循环
                        break;
                    }

                    // 渲染游戏区域
                    lock (ConsoleLock)
                    {
                        Console.Clear();
                        for (int i = 0; i < Height; i++)
                        {
                            for (int j = 0; j < Width; j++)
                            {
                                Console.Write(Board[i][j] == 1 ? "#" : ".");
                            }
                            Console.WriteLine();
                        }
                        Console.WriteLine("Score: {0}", Score);
                    }

                    // 暂停一段时间
                    Thread.Sleep(100);
                }
            }
        }

        // 判断当前方块是否可以移动到指定位置
        static bool IsLegalMove(int[][] tetromino, int x, int y)
        {
            for (int i = 0; i < tetromino.Length; i++)
            {
                for (int j = 0; j < tetromino[i].Length; j++)
                {
                    if (tetromino[i][j] == 1)
                    {
                        int boardX = x + j;
                        int boardY = y + i;
                        if (boardX < 0 || boardX >= Width || boardY < 0 || boardY >= Height || Board[boardY][boardX] == 1)
                        {
                            return false;
                        }
                    }
                }
            }
            return true;
        }

        // 判断指定行是否已满
        static bool IsRowFull(int row)
        {
            for (int j = 0; j < Width; j++)
            {
                if (Board[row][j] == 0)
                {
                    return false;
                }
            }
            return true;
        }

        // 清除指定行
        static void ClearRow(int row)
        {
            for (int i = row; i > 0; i--)
            {
                for (int j = 0; j < Width; j++)
                {
                    Board[i][j] = Board[i - 1][j];
                }
            }
        }

        // 判断游戏是否结束
        static bool IsGameOver()
        {
            for (int j = 0; j < Width; j++)
            {
                if (Board[0][j] == 1)
                {
                    return true;
                }
            }
            return false;
        }
    }
}

这个代码实现了一个简单的俄罗斯方块游戏，使用控制台进行输出。玩家可以使用方向键来移动方块，使用空格键加速方块下落。游戏结束时会显示分数。