用C#打造基础版中国象棋游戏

本文还有配套的精品资源，点击获取

简介：本文详细阐述了如何利用C#编程语言开发一个基础的中国象棋游戏。我们将重点介绍如何构建游戏的基础框架、用户界面和交互功能，而不包含电脑智能算法。文章从中国象棋的基本规则开始，讲解如何通过面向对象的编程方法实现棋盘和棋子的规则逻辑。然后，我们会探讨如何使用Windows Forms或WPF技术创建图形用户界面，并实现游戏状态管理和合法性检查，以及如何添加额外功能如悔棋、保存和加载游戏来提升用户体验。

1. 中国象棋规则的基础了解

中国象棋概述

中国象棋，又称为象棋，是一种两人对弈的策略棋类游戏，拥有悠久的历史和丰富的文化内涵。它的棋盘由9条直线和10条横线交错构成的90个交叉点组成，双方各有16个棋子，分别代表将、士、象、马、车、炮和兵。了解基础规则是掌握象棋的关键，它包括棋子的走法、吃子、将军、胜负判定等。

棋子走法和基本术语

每种棋子在棋盘上都有其特定的走法，例如：
- 将（帅）只能在九宫内移动。
- 士（仕）沿斜线移动。
- 象（相）不能越过河界，且“塞象眼”（中间两格不能通过）。
- 马走日（“日”字形）。
- 车走直线，无阻碍。
- 炮需要“隔子打子”。
- 兵（卒）过河前只能直走，过河后可横移。

掌握这些基本走法对于理解整个游戏至关重要。此外，还需了解“将军”、“将死”、“长将”、“长捉”等术语，它们是判断游戏状态的基础。

对弈策略初步

对弈策略是游戏的魅力所在，玩家需在遵守规则的同时，思考如何运用棋子进行有效进攻和防守。基本策略包括：
- 利用棋子的特殊走法进行布局。
- 控制棋盘中的关键点。
- 制定攻防计划，灵活运用战术。
- 观察对手的布局，预测对手意图。

了解和运用这些策略能帮助玩家在对弈中取得优势，甚至赢得比赛。象棋不仅是智力游戏，它还是一个能够提升逻辑思维能力、决策能力和战略规划能力的工具。

2. C#面向对象编程在象棋游戏中的应用

2.1 C#面向对象编程概述

2.1.1 类与对象的定义

在面向对象编程中，类是创建对象的蓝图。C#是一种面向对象的编程语言，它通过类来定义对象的属性和方法。一个类可以包含字段、属性、方法、事件和嵌套类等成员。对象是类的实例，可以拥有状态、行为和身份。

public class ChessPiece
{
    // 字段
    public string Name { get; set; }
    public string Color { get; set; }
    public int PositionX { get; private set; }
    public int PositionY { get; private set; }

    // 构造函数
    public ChessPiece(string name, string color, int x, int y)
    {
        Name = name;
        Color = color;
        PositionX = x;
        PositionY = y;
    }

    // 方法
    public void Move(int newX, int newY)
    {
        PositionX = newX;
        PositionY = newY;
    }
}

// 使用类创建对象
ChessPiece pawn = new ChessPiece("Pawn", "White", 4, 1);

在上面的代码示例中， ChessPiece 类定义了一个棋子，它有名称、颜色和位置。通过这个类，我们可以创建具体的棋子对象，如 pawn 。

2.1.2 继承、封装和多态性在C#中的体现

继承允许一个类继承另一个类的成员。封装是隐藏对象内部状态和实现细节的过程，对外只暴露操作接口。多态性允许使用基类类型引用派生类的实例。

// 继承
public class Bishop : ChessPiece
{
    public Bishop(string color, int x, int y) : base("Bishop", color, x, y) { }
    // Bishop特有的移动逻辑
}

// 封装
public class Rook : ChessPiece
{
    private bool hasMoved; // 私有字段，封装了移动状态

    public Rook(string color, int x, int y) : base("Rook", color, x, y) { }

    public bool HasMoved
    {
        get { return hasMoved; }
        set { hasMoved = value; }
    }
}

// 多态性
ChessPiece piece = new Rook("Black", 0, 0);
piece.Move(2, 2); // 通过基类类型引用派生类实例，并调用Move方法

在这里， Bishop 和 Rook 类继承自 ChessPiece ，体现了继承。 Rook 类中的 hasMoved 字段是私有的，外部不能直接访问，显示了封装性。 piece 变量是 ChessPiece 类型，但它引用了一个 Rook 实例，表明了多态性。

2.2 面向对象设计原则

2.2.1 SOLID原则的简介与应用

SOLID原则是面向对象设计的五项基本原则，旨在让软件设计更加灵活和可维护。SOLID代表单一职责、开闭原则、里氏替换、接口隔离和依赖倒置。

// 单一职责 - 一个类应该只有一个改变的理由
public class ChessMove
{
    public ChessPiece Piece { get; }
    public Position From { get; }
    public Position To { get; }

    public ChessMove(ChessPiece piece, Position from, Position to)
    {
        Piece = piece;
        From = from;
        To = to;
    }

    // 仅关注移动逻辑
    public void Execute()
    {
        // 移动棋子逻辑
    }
}

// 开闭原则 - 类应该对扩展开放，对修改关闭
public interface IChessRuleValidator
{
    bool IsValid(ChessMove move);
}

public class StandardChessRuleValidator : IChessRuleValidator
{
    public bool IsValid(ChessMove move)
    {
        // 标准规则验证
        return true;
    }
}

// 里氏替换 - 派生类应能替换基类
// 接口隔离 - 不应该强迫客户依赖于他们不使用的接口
// 依赖倒置 - 高层模块不应该依赖于低层模块，两者都应该依赖于抽象

ChessMove 类仅负责棋子移动的逻辑，它遵循了单一职责原则。 IChessRuleValidator 接口和 StandardChessRuleValidator 类是开闭原则的应用， StandardChessRuleValidator 可以随时被替换为其他实现，以符合不同规则集的需要。里氏替换、接口隔离和依赖倒置原则在上面代码中未直接体现，但它们都影响着代码的设计和结构。

2.2.2 设计模式在C#编程中的实践

设计模式是解决常见软件设计问题的模板或通用解决方案。它们被广泛应用于面向对象的软件设计中。以下是几个在C#中常用的模式示例：

// 工厂模式
public class ChessPieceFactory
{
    public ChessPiece CreatePiece(string type, string color, int x, int y)
    {
        switch (type)
        {
            case "Bishop": return new Bishop(color, x, y);
            case "Rook": return new Rook(color, x, y);
            // 其他棋子类型
            default: throw new ArgumentException("Invalid piece type.");
        }
    }
}

// 单例模式
public sealed class ChessGame
{
    private static readonly ChessGame instance = new ChessGame();

    // 私有构造函数
    private ChessGame() { }

    public static ChessGame Instance
    {
        get { return instance; }
    }
}

// 观察者模式
public interface IGameEventObserver
{
    void OnMoveMade(ChessMove move);
}

public class GameUI : IGameEventObserver
{
    public void OnMoveMade(ChessMove move)
    {
        // 更新UI
    }
}

工厂模式用于创建对象而不暴露创建逻辑到外部。单例模式保证一个类只有一个实例。观察者模式允许对象间存在一对多依赖关系，当一个对象改变状态时，所有依赖者都会收到通知。

2.3 面向对象在象棋游戏中的实现

2.3.1 对象的创建与初始化

对象的创建通常涉及到构造函数的调用，初始化则是设置对象的状态。在C#中，可以使用new操作符来创建对象。

// 创建一个棋盘
public ChessBoard Board { get; private set; }

public void InitializeGame()
{
    Board = new ChessBoard();
    // 初始化棋盘上的棋子
}

// 棋盘的初始化可能包括设置初始位置
public class ChessBoard
{
    public ChessPiece[,] Pieces { get; private set; }

    public ChessBoard()
    {
        Pieces = new ChessPiece[8, 8];
        // 设置初始棋子位置
    }
}

在初始化游戏时，我们创建了 ChessBoard 类的实例，并可能在构造函数中初始化棋盘上的棋子。

2.3.2 对象间的交互与通信

对象间的交互是通过方法调用实现的，通信则通过方法参数、返回值或事件来完成。

// 棋子移动请求的实现
public class ChessGame
{
    private ChessBoard board;

    public ChessGame(ChessBoard board)
    {
        this.board = board;
    }

    public bool MovePiece(ChessPiece piece, int newX, int newY)
    {
        // 检查移动是否合法
        if (board.IsMoveLegal(piece, newX, newY))
        {
            piece.Move(newX, newY);
            return true;
        }
        return false;
    }
}

// 棋盘状态检查
public class ChessBoard
{
    public bool IsMoveLegal(ChessPiece piece, int newX, int newY)
    {
        // 实现棋子移动规则
        return true;
    }
}

在上面的代码中， ChessGame 类中的 MovePiece 方法负责处理棋子的移动请求，而 ChessBoard 类中的 IsMoveLegal 方法负责检查移动是否合法。这是对象间通信的一个典型例子。

在对象的创建、初始化和交互中，我们通过C#语言的面向对象编程特性实现了象棋游戏的基本逻辑和结构。这样的编程范式有助于构建模块化、可维护的代码，同时简化了代码的复杂度，便于后续的开发和扩展。

3. 棋盘和棋子类的设计与实现

3.1 棋盘类的设计与实现

3.1.1 棋盘的数据结构定义

在设计中国象棋游戏时，棋盘是整个游戏的基石。在C#中，棋盘的数据结构可以通过二维数组来实现。这里我们定义一个8x9的二维数组，因为中国象棋棋盘是9列10行，我们需要对数组进行扩展以适应棋盘的特性。

private const int BoardWidth = 9;
private const int BoardHeight = 10;
private ChessPiece[,] boardArray = new ChessPiece[BoardWidth, BoardHeight];

每个数组元素 boardArray[i, j] 代表棋盘上的一个位置，其中 i 表示列， j 表示行。数组中存储的是 ChessPiece 对象，这个对象代表棋盘上的棋子，若位置为空，则该位置对应的是 null 。

3.1.2 棋盘的绘制与管理逻辑

棋盘绘制需要借助图形界面，这里我们以Windows Forms为例，介绍如何在窗体上绘制棋盘。首先，需要创建一个继承自 Form 的窗体类，在这个类中，我们可以添加控件和设置属性以绘制棋盘。

public class ChessBoardForm : Form
{
    private Bitmap chessBoardBitmap;
    private Label[,] chessLabels;
    public ChessBoardForm()
    {
        this.Size = new Size(600, 600); // 设置窗体大小
        chessBoardBitmap = new Bitmap(this.Width, this.Height);
        chessLabels = new Label[BoardWidth, BoardHeight];
        // 初始化棋盘位图和标签
        InitBoard();
        DrawBoard();
    }
    private void InitBoard()
    {
        // 初始化棋盘位图和标签的具体逻辑
    }
    private void DrawBoard()
    {
        // 绘制棋盘位图和标签的具体逻辑
    }
    protected override void OnPaint(PaintEventArgs e)
    {
        base.OnPaint(e);
        // 利用e.Graphics绘制棋盘和棋子
        e.Graphics.DrawImage(chessBoardBitmap, Point.Empty);
    }
    // 其他窗体方法和事件处理逻辑
}

棋盘的管理逻辑需要考虑棋子的放置、移动和游戏状态的更新。我们可以创建一个管理器类 ChessBoardManager 来处理这些问题。它可能包含如下的方法：

public class ChessBoardManager
{
    private ChessBoardForm form;
    public ChessBoardManager(ChessBoardForm form)
    {
        this.form = form;
    }
    public void PlacePiece(ChessPiece piece, int column, int row)
    {
        // 将棋子放置到棋盘的指定位置
    }
    public void MovePiece(int fromColumn, int fromRow, int toColumn, int toRow)
    {
        // 移动棋子到新的位置
    }
    // 其他管理棋盘和游戏状态的方法
}

3.2 棋子类的设计与实现

3.2.1 棋子的基本属性和行为

棋子类 ChessPiece 是游戏中的核心类之一。它需要至少包含以下基本属性：

• 种类（例如“车”，“马”，“炮”等）
• 持有者（红方或黑方）
• 当前位置（行和列的索引）
• 是否已经被“吃掉”（移除）

public enum ChessPieceKind
{
    General, // 将帅
    Advisor, // 士
    Elephant, // 象
    Horse, // 马
    Chariot, // 车
    Cannon, // 炮
    Soldier // 兵
}

public class ChessPiece
{
    public ChessPieceKind Kind { get; set; }
    public Team Holder { get; set; }
    public int PositionX { get; set; }
    public int PositionY { get; set; }
    public bool IsCaptured { get; set; }
    // 其他与棋子相关的行为和属性
}

3.2.2 棋子的移动规则与逻辑封装

棋子的移动规则依赖于其种类和游戏规则。我们可以为棋子类添加一个方法来实现这个功能：

public bool MovePiece(int toX, int toY, ChessBoardManager manager)
{
    // 检查目标位置是否在合法范围内
    // 检查移动是否符合规则（例如“马”需要走“日”字）
    // 更新棋子位置
    // 绘制棋子到新位置
    // 返回移动是否成功
}

这个方法根据棋子种类，会调用不同的规则来判断移动是否合法。例如，车可以直线移动，而马则需要按照“日”字型规则移动。此外，还要检查目标位置是否已有其它棋子，如果有，则需要判断是否可以“吃掉”该棋子。

3.3 棋盘与棋子的交互

3.3.1 棋子在棋盘上的表示方法

在棋盘上表示棋子，我们可以使用图形控件，如 Label 来显示棋子的图标。在Windows Forms中，可以通过 Label 控件的 BackgroundImage 属性来设置棋子图标。

// 在棋盘绘制方法中，设置label的BackgroundImage为棋子图标
chessLabels[positionX, positionY].BackgroundImage = ChessPieceImage;

ChessPieceImage 是预先准备好的图片资源，根据棋子的种类和持有者来选择。

3.3.2 棋盘状态更新与管理

棋盘状态的更新通常发生在棋子移动后。每移动一个棋子，都需要更新棋盘数组以及界面来反映最新的游戏状态。

public class ChessBoardManager
{
    public void UpdateBoardAfterMove(ChessPiece piece, int fromX, int fromY, int toX, int toY)
    {
        // 更新棋盘数组状态
        boardArray[fromX, fromY] = null;
        boardArray[toX, toY] = piece;
        // 更新界面
        form.chessLabels[fromX, fromY].Text = string.Empty;
        form.chessLabels[toX, toY].BackgroundImage = ChessPieceImage;
        // 刷新窗体以显示更新
        form.Invalidate();
    }
}

每次移动棋子后，都应该调用 UpdateBoardAfterMove 方法来同步更新棋盘数组和界面。这里的 Invalidate 方法是 Form 类提供的，用于重绘窗体的无效区域。

4. 使用Windows Forms或WPF创建游戏用户界面

4.1 Windows Forms基础与界面设计

4.1.1 Windows Forms的基本控件和布局

Windows Forms是.NET Framework提供的一个用于创建Windows桌面应用程序的GUI库。使用Windows Forms，开发者可以快速搭建起一个界面丰富的桌面应用程序。在我们的象棋游戏中，将需要使用各种控件来构建游戏界面，包括面板（Panel）、标签（Label）、按钮（Button）等。

在构建界面时，首先需要考虑的是布局。Windows Forms提供了各种布局控件，如FlowLayoutPanel、TableLayoutPanel、SplitContainer等，来帮助开发者以不同的方式组织子控件。例如，棋盘可以通过一个TableLayoutPanel来构建，每个格子作为一个单元格，棋子对象可以在这些单元格中动态显示。

4.1.2 设计象棋游戏界面的思路与实现

设计一个象棋游戏界面，首先需要确保界面的清晰性和用户的交互便捷性。考虑到中国象棋的棋盘为9x10格，我们需要为每格创建一个控件，通常可以选择Button控件来代表每一个可点击的格子。

界面设计可以分成几个部分：

• 棋盘：使用一个81个Button控件组成的二维数组来表示，每个Button代表一个棋盘格。
• 棋子：可以使用自定义绘制（如继承自PictureBox的类）或使用Image控件来表示，需要根据棋子类型和当前游戏状态动态显示。
• 状态栏：显示当前轮到哪一方、游戏状态（如计时器、剩余步数等）。
• 操作按钮：如悔棋、暂停等辅助操作按钮。

在实现上，可以使用Visual Studio的设计器快速搭建界面框架，然后通过代码对每个控件进行事件绑定和逻辑处理。

4.2 WPF基础与界面设计

4.2.1 WPF的核心概念与优势

WPF（Windows Presentation Foundation）是.NET Framework中的一个用户界面框架，它具有高度的可扩展性和灵活性。WPF的核心概念包括XAML语言、依赖属性、路由事件、数据绑定、样式和模板等。

WPF相较于Windows Forms的优势在于：

• 分离的UI代码和逻辑代码：使用XAML来描述用户界面，逻辑代码用C#编写。
• 高度的可定制性：WPF的控件样式和模板可以被自定义，易于设计出美观的界面。
• 强大的数据绑定能力：可以轻松实现数据和视图的同步。
• 内置的3D图形和动画支持。

4.2.2 设计象棋游戏界面的思路与实现

使用WPF来设计象棋游戏界面，首先需要定义XAML文件，其中会包含用于显示棋盘和棋子的控件。WPF提供了一个Canvas控件，非常适合用来绘制棋盘，因为它可以精确控制每个子控件的位置。

游戏界面设计的关键点包括：

• 棋盘绘制：可以使用Canvas的子元素来绘制棋盘的线条和方格。自定义绘制的棋子将被放置在Canvas上。
• 棋子表示：通过为棋子创建自定义控件（可能是Image控件或形状控件）。
• 用户操作集成：绑定按钮或快捷键的事件到相应的操作上。

实现过程可以分为几个步骤：

1. 使用Visual Studio或Blend工具创建一个新的WPF项目。
2. 设计XAML布局，确保棋盘控件可以响应用户操作。
3. 用C#编写逻辑代码，处理游戏逻辑，如移动棋子、检查游戏状态等。

4.3 用户交互的集成

4.3.1 按钮和键盘事件的处理

无论是Windows Forms还是WPF，用户交互的集成都是必不可少的一部分。按钮点击和键盘事件是两种主要的用户交互方式。在象棋游戏中，按钮可以用来执行各种游戏动作，如开始游戏、悔棋等，而键盘事件则可以用来控制特定棋子的移动。

在Windows Forms中，可以为每个按钮的Click事件编写处理函数。例如，为”悔棋”按钮注册一个事件处理函数，实现游戏的悔棋逻辑。对于键盘事件，可以重写窗体的KeyDown事件方法，捕获特定按键并执行相应的动作。

在WPF中，按钮事件的处理类似，但是更加灵活。可以使用命令绑定（Command Binding）来将按钮和逻辑代码关联起来。键盘事件也可以通过路由事件机制来捕捉和处理。

4.3.2 用户操作反馈与游戏状态同步

为了给用户提供良好的游戏体验，对用户的操作做出及时反馈是必须的。此外，游戏的当前状态需要即时反映在界面上。例如，当用户选择一个棋子时，需要高亮显示该棋子以及它能合法移动到的所有位置。当用户移动棋子后，游戏状态更新，界面上的棋子和标记也必须同步更新。

Windows Forms和WPF都提供了丰富的控件和机制来实现这样的用户交互反馈。在Windows Forms中，可以通过改变控件的背景色、前景色、边框样式等属性来提供视觉反馈。在WPF中，除了可以使用样式和模板来改变视觉表现外，还可以利用动画来提升用户体验。

实现用户操作反馈与游戏状态同步的关键在于：

• 将用户界面的表示逻辑和游戏状态的管理分离，以保持代码的清晰和维护性。
• 使用数据绑定将控件的状态与后端逻辑紧密同步。
• 合理运用事件和命令模式来响应用户的操作。

在本章节，我们深入探讨了如何使用Windows Forms和WPF来创建中国象棋游戏的用户界面。我们从基础控件和布局的介绍开始，到设计界面的思路和实现，再到用户交互的集成，逐步深入到每个细节。接下来的章节将介绍棋盘状态的合法性检查和游戏状态管理，这两者是确保游戏正常运行的关键。

5. 棋盘状态合法性检查的实现与游戏状态管理

在开发中国象棋游戏的过程中，棋盘状态合法性检查是确保游戏逻辑正确性的重要环节。它涉及到棋子移动规则的编码实现、棋盘状态的合法性检测方法，以及游戏状态的管理。此外，人机交互功能的完善也是提高用户体验的关键。

5.1 棋盘状态合法性检查机制

5.1.1 棋子移动规则的编码实现

在实现棋子移动规则时，首先要定义每种棋子的移动特性。以“马”为例，它走的是“日”字路线，即先直线再斜线或先斜线再直线，且在移动过程中必须跳过一个棋子。在C#代码中，可以这样实现：

public class Horse : ChessPiece
{
    public override bool CanMove(int startX, int startY, int endX, int endY, ChessPiece[,] board)
    {
        int deltaX = Math.Abs(endX - startX);
        int deltaY = Math.Abs(endY - startY);
        // 检查是否走“日”字路线
        if (deltaX == 2 && deltaY == 1 || deltaX == 1 && deltaY == 2)
        {
            // 检查路径上是否有棋子阻挡
            if (IsPathBlocked(startX, startY, endX, endY, board))
                return false;
            return true;
        }
        return false;
    }
    private bool IsPathBlocked(int startX, int startY, int endX, int endY, ChessPiece[,] board)
    {
        // 跳过一个棋子的坐标
        int midX = (startX + endX) / 2;
        int midY = (startY + endY) / 2;
        // 检查中间是否有棋子
        return board[midX, midY] != null && board[midX, midY].Team != Team;
    }
}

5.1.2 棋盘状态的合法性检测方法

棋盘状态的合法性检测方法通常在游戏的关键时刻被调用，如每次移动棋子后。此方法要检查当前棋盘状态是否符合游戏规则，例如，确保没有出现“将军”和“将死”的局面。以下是检测“将军”的伪代码示例：

public bool IsCheckMate(ChessPiece[,] board)
{
    // 检查红方是否被将军
    if (CheckForCheck(Team.Red))
    {
        // 红方无法逃脱将军，游戏结束
        return true;
    }
    return false;
}

public bool CheckForCheck(Team currentTeam)
{
    // 获取当前玩家的将/帅的位置
    var currentKingPosition = GetKingPosition(currentTeam);
    // 遍历对方棋子，检查是否有棋子可以攻击到将/帅
    foreach (var piece in GetAllPiecesOfTheOpponentTeam(currentTeam))
    {
        if (piece.CanMove(piece.X, piece.Y, currentKingPosition.X, currentKingPosition.Y, board))
        {
            // 如果可以攻击到将/帅，则当前玩家被将军
            return true;
        }
    }
    return false;
}

5.2 游戏状态管理

5.2.1 轮换机制的实现与管理

轮换机制保证了游戏的进行交替在两个玩家之间进行。可以通过一个简单的轮换标记来管理当前操作的玩家，例如，使用一个布尔值来表示当前轮到哪一方：

private bool isRedTurn = true;

public void SwitchTurn()
{
    isRedTurn = !isRedTurn;
}

5.2.2 棋子移动记录与撤销机制

记录移动历史对于游戏撤销功能至关重要。可以使用一个列表来存储每次移动的详细信息，包括起始位置、结束位置和相关棋子：

public class MoveRecord
{
    public int startX, startY, endX, endY;
    public ChessPiece movedPiece;
}

private List<MoveRecord> moveHistory = new List<MoveRecord>();

public void RecordMove(ChessPiece piece, int startX, int startY, int endX, int endY)
{
    moveHistory.Add(new MoveRecord
    {
        startX = startX,
        startY = startY,
        endX = endX,
        endY = endY,
        movedPiece = piece
    });
}

5.2.3 游戏结束条件的判断与处理

游戏结束条件包括将/帅被将死、和棋等情形。以下是和棋的示例代码：

public bool IsStalemate()
{
    // 检查双方是否均无法进行有效移动
    foreach (var piece in GetAllPieces(Team.Red))
    {
        if (piece.CanMoveAnywhere(board))
            return false;
    }
    foreach (var piece in GetAllPieces(Team.Black))
    {
        if (piece.CanMoveAnywhere(board))
            return false;
    }
    return true;
}

5.3 用户交互功能的完善

5.3.1 棋子选择与移动的人机交互

用户交互功能的完善是提高玩家游戏体验的关键。以下是实现棋子选择和移动的简单伪代码：

public void OnChessPieceSelected(ChessPiece piece)
{
    // 检查是否是本方回合，并且没有选中棋子
    if (isRedTurn && selectedPiece == null)
    {
        selectedPiece = piece;
        // 显示可移动位置
        DisplayValidMoveLocations(piece);
    }
}

public void OnChessPieceMoved(int startX, int startY, int endX, int endY)
{
    if (selectedPiece != null && selectedPiece.CanMove(startX, startY, endX, endY, board))
    {
        // 移动棋子并记录操作
        MovePiece(selectedPiece, startX, startY, endX, endY);
        RecordMove(selectedPiece, startX, startY, endX, endY);
        selectedPiece = null; // 取消选中状态
        // 检查游戏状态
        CheckGameState();
    }
}

5.3.2 特殊操作的实现与反馈

特殊操作如“长将”、“长捉”等，需要特殊处理。例如，根据规则不允许长将：

public bool IsIllegalMoveBecauseOfStalemate(ChessPiece piece, int startX, int startY, int endX, int endY)
{
    // 检查移动后的状态是否导致双方无法进行有效移动（长将）
    if (IsStalemateAfterMove(piece, startX, startY, endX, endY))
    {
        // 这种移动是不允许的
        return true;
    }
    return false;
}

至此，我们已经深入探讨了棋盘状态合法性检查和游戏状态管理的实现细节。在实际开发过程中，你还需要考虑到用户界面的友好性，以及提供足够的反馈信息，以确保玩家能够获得流畅且富有挑战性的游戏体验。

本文还有配套的精品资源，点击获取

简介：本文详细阐述了如何利用C#编程语言开发一个基础的中国象棋游戏。我们将重点介绍如何构建游戏的基础框架、用户界面和交互功能，而不包含电脑智能算法。文章从中国象棋的基本规则开始，讲解如何通过面向对象的编程方法实现棋盘和棋子的规则逻辑。然后，我们会探讨如何使用Windows Forms或WPF技术创建图形用户界面，并实现游戏状态管理和合法性检查，以及如何添加额外功能如悔棋、保存和加载游戏来提升用户体验。

本文还有配套的精品资源，点击获取