Qt象棋游戏开发:如何用QPainter绘制专业级棋盘(附完整代码)
很多Qt开发者在掌握了基础控件和布局后,都想挑战一些更具表现力的项目,比如游戏开发。象棋,作为一款经典的策略游戏,其棋盘绘制看似简单,实则是对Qt绘图系统理解深度的一次绝佳检验。它不像俄罗斯方块那样依赖动态刷新,也不像3D游戏那样复杂,但它要求精确的几何计算、美观的视觉呈现和良好的代码组织。如果你已经熟悉了Qt的信号槽和基本窗口部件,那么通过亲手绘制一个象棋棋盘,你将能深刻体会到QPainter这个二维绘图引擎的强大与灵活。这不仅仅是画几条线,更是学习如何将数学逻辑、美术审美与代码架构融合的过程。接下来,我将以一个完整的、可复用的项目视角,带你从零开始,用QPainter打造一个不仅功能正确,而且视觉效果专业的象棋棋盘。
1. 项目架构与核心类设计
在动手写第一行绘制代码之前,花点时间思考整体架构是值得的。一个混乱的paintEvent里塞满所有绘制逻辑,虽然能跑,但后期维护和功能扩展会成为噩梦。我们的目标是构建一个清晰、可扩展的棋盘组件。
首先,我们创建一个名为ChessBoardWidget的自定义QWidget类。这个类将专门负责棋盘的视觉呈现。与简单地在主窗口上直接绘制不同,将其独立为组件,有利于实现模块化。例如,未来你可以轻松地将这个棋盘组件嵌入到任何界面中,或者为其添加不同的主题皮肤。
在头文件chessboardwidget.h中,我们需要进行一些关键声明:
#ifndef CHESSBOARDWIDGET_H
#define CHESSBOARDWIDGET_H
#include <QWidget>
#include <QPen>
#include <QBrush>
#include <QColor>
#include <QLinearGradient>
class ChessBoardWidget : public QWidget
{
Q_OBJECT
public:
explicit ChessBoardWidget(QWidget *parent = nullptr);
// 可公开设置的属性
void setBoardSize(int size); // 设置棋盘格数(默认9x10)
void setCellSize(int size); // 设置每个格子的像素尺寸
void setTheme(const QString &themeName); // 设置主题(如“古典”、“木质”)
protected:
void paintEvent(QPaintEvent *event) override;
void resizeEvent(QResizeEvent *event) override; // 用于自适应调整
private:
// 核心绘制方法分解
void drawBoardBackground(QPainter &painter);
void drawGridLines(QPainter &painter);
void drawSpecialMarkings(QPainter &painter); // “楚河汉界”、九宫、兵炮位
void drawDecoration(QPainter &painter); // 装饰性元素,如角落花纹
// 计算辅助函数
QPointF cellCenter(int row, int col) const; // 计算格子中心坐标
QRectF cellRect(int row, int col) const; // 计算格子矩形区域
// 成员变量
int m_boardRows; // 行数(10)
int m_boardCols; // 列数(9)
int m_cellSize; // 格子边长(像素)
int m_boardMargin; // 棋盘边距
QColor m_lineColor;
QColor m_bgColor1; // 背景色1(如浅色)
QColor m_bgColor2; // 背景色2(如深色,用于渐变或交替)
QLinearGradient m_bgGradient; // 背景渐变
// 预计算的几何点,避免在paintEvent中重复计算
QVector<QLineF> m_gridLines;
QVector<QPointF> m_starPoints; // “米”字格星位点
void calculateGeometry(); // 当尺寸变化时,重新计算所有几何信息
};
#endif // CHESSBOARDWIDGET_H
这种设计将庞大的paintEvent分解为多个语义清晰的私有方法,每个方法负责一个独立的视觉层。calculateGeometry函数是关键,它会在棋盘尺寸变化时,预先计算好所有线条的起点终点、特殊标记的位置,并将它们存储起来。在paintEvent中,我们只需要遍历这些预计算好的几何元素进行绘制,这比每次都实时计算要高效得多,尤其是在需要频繁重绘或棋盘尺寸较大时。
注意:将绘制逻辑分解并预计算几何数据,是提升复杂自定义部件绘制性能的常用技巧。它遵循了“计算与渲染分离”的原则。
2. 绘制基础网格与视觉优化
棋盘的核心是横十竖九的网格线。绘制直线本身很简单,但要让线条看起来专业、清晰且美观,就需要在细节上下功夫。我们首先在构造函数中初始化一些默认参数。
ChessBoardWidget::ChessBoardWidget(QWidget *parent)
: QWidget(parent)
, m_boardRows(10)
, m_boardCols(9)
, m_cellSize(60)
, m_boardMargin(40)
{
// 初始化默认颜色主题
m_lineColor = QColor(0x2C, 0x2C, 0x2C); // 深灰色线条,比纯黑更柔和
m_bgColor1 = QColor(0xF0, 0xE5, 0xD6); // 米黄色背景
m_bgColor2 = QColor(0xE8, 0xD0, 0xB5); // 稍深的米黄,用于渐变
// 设置背景渐变
m_bgGradient.setStart(0, 0);
m_bgGradient.setFinalStop(width(), height());
m_bgGradient.setColorAt(0.0, m_bgColor1);
m_bgGradient.setColorAt(1.0, m_bgColor2);
// 设置组件最小尺寸,并启用反锯齿
setMinimumSize(m_boardCols * m_cellSize + 2 * m_boardMargin,
m_boardRows * m_cellSize + 2 * m_boardMargin);
setAttribute(Qt::WA_OpaquePaintEvent); // 告知系统此部件完全不透明,可优化绘制
calculateGeometry(); // 初始计算几何数据
}
接下来是calculateGeometry函数,它负责将所有静态的线条数据计算并存储起来:
void ChessBoardWidget::calculateGeometry()
{
m_gridLines.clear();
m_starPoints.clear();
int boardWidth = m_boardCols * m_cellSize;
int boardHeight = m_boardRows * m_cellSize;
int startX = m_boardMargin;
int startY = m_boardMargin;
// 1. 计算所有垂直线(共10条,但中间“楚河”断开)
for (int col = 0; col <= m_boardCols; ++col) {
int x = startX + col * m_cellSize;
// 上半部分垂直线(第1-5行)
m_gridLines.append(QLineF(x, startY, x, startY + 5 * m_cellSize));
// 下半部分垂直线(第6-10行)
m_gridLines.append(QLineF(x, startY + 6 * m_cellSize, x, startY + 10 * m_cellSize));
}
// 2. 计算所有水平线(共11条)
for (int row = 0; row <= m_boardRows; ++row) {
int y = startY + row * m_cellSize;
m_gridLines.append(QLineF(startX, y, startX + boardWidth, y));
}
// 3. 预计算“米”字格星位点(将、士、象的走位点)
// 示例:将/帅的星位 (row 1, col 5) 和 (row 8, col 5) 以0-based索引
QList<QPair<int, int>> starPositions = {
{0, 3}, {0, 5}, {0, 7}, // 上方九宫星位
{2, 4}, // 上方中路星位
{7, 4}, // 下方中路星位
{9, 3}, {9, 5}, {9, 7} // 下方九宫星位
};
for (auto &pos : starPositions) {
m_starPoints.append(cellCenter(pos.first, pos.second));
}
}
现在,我们实现核心的paintEvent和基础的绘制方法。注意,我们开启了QPainter::Antialiasing(反锯齿),这是让线条边缘平滑不出现锯齿的关键。
void ChessBoardWidget::paintEvent(QPaintEvent *event)
{
Q_UNUSED(event);
QPainter painter(this);
// 关键设置:开启反锯齿,让线条和图形边缘平滑
painter.setRenderHint(QPainter::Antialiasing, true);
// 可选:开启文本反锯齿
painter.setRenderHint(QPainter::TextAntialiasing, true);
// 按层次绘制
drawBoardBackground(painter);
drawGridLines(painter);
drawSpecialMarkings(painter);
drawDecoration(painter);
}
void ChessBoardWidget::drawBoardBackground(QPainter &painter)
{
// 绘制一个带圆角的棋盘外框,增加立体感
QRectF boardRect(m_boardMargin - 5, m_boardMargin - 5,
m_boardCols * m_cellSize + 10,
m_boardRows * m_cellSize + 10);
QPen borderPen(QColor(0x8B, 0x45, 0x13), 6); // 深棕色粗边框
painter.setPen(borderPen);
painter.setBrush(m_bgGradient); // 使用渐变画刷填充
painter.drawRoundedRect(boardRect, 10, 10); // 绘制圆角矩形
}
void ChessBoardWidget::drawGridLines(QPainter &painter)
{
QPen gridPen(m_lineColor);
gridPen.setWidth(2); // 网格线稍细
gridPen.setStyle(Qt::SolidLine);
painter.setPen(gridPen);
// 绘制所有预计算好的网格线
painter.drawLines(m_gridLines);
// 绘制“楚河汉界”两端的短竖线,线条稍粗
QPen riverPen(m_lineColor);
riverPen.setWidth(3);
painter.setPen(riverPen);
int startX = m_boardMargin;
int startY = m_boardMargin;
int riverYTop = startY + 5 * m_cellSize;
int riverYBottom = startY + 6 * m_cellSize;
// 左端短竖线
painter.drawLine(startX, riverYTop, startX, riverYBottom);
// 右端短竖线
painter.drawLine(startX + m_boardCols * m_cellSize, riverYTop,
startX + m_boardCols * m_cellSize, riverYBottom);
}
仅仅绘制线条还不够。一个专业的棋盘,其线条交叉点(特别是“米”字格的星位)通常会有一个小圆点或装饰。我们可以通过遍历预计算的m_starPoints来绘制它们。
void ChessBoardWidget::drawSpecialMarkings(QPainter &painter)
{
// 1. 绘制“米”字格星位点
painter.setBrush(QBrush(m_lineColor)); // 填充色为线条色
painter.setPen(Qt::NoPen); // 描边设为无,绘制实心圆点
for (const QPointF &point : m_starPoints) {
painter.drawEllipse(point, 4, 4); // 绘制半径为4像素的圆
}
// 2. 绘制“士”的斜线(九宫格对角线)
QPen diagonalPen(m_lineColor);
diagonalPen.setWidth(2);
painter.setPen(diagonalPen);
int startX = m_boardMargin;
int startY = m_boardMargin;
int cell = m_cellSize;
// 上方九宫斜线
painter.drawLine(startX + 3 * cell, startY + 0 * cell,
startX + 5 * cell, startY + 2 * cell);
painter.drawLine(startX + 5 * cell, startY + 0 * cell,
startX + 3 * cell, startY + 2 * cell);
// 下方九宫斜线
painter.drawLine(startX + 3 * cell, startY + 7 * cell,
startX + 5 * cell, startY + 9 * cell);
painter.drawLine(startX + 5 * cell, startY + 7 * cell,
startX + 3 * cell, startY + 9 * cell);
// 3. 绘制“兵”和“炮”位置的直角标记(井字格)
QPen cornerPen(m_lineColor);
cornerPen.setWidth(3);
painter.setPen(cornerPen);
// 定义兵和炮的位置(行,列),以0-based索引
QList<QPair<int, int>> soldierPos = {{3,1}, {3,7}, {2,0}, {2,2}, {2,4}, {2,6}, {2,8}};
QList<QPair<int, int>> cannonPos = {{2,1}, {2,7}};
auto drawCornerMark = [&](int row, int col, int offset) {
QPointF center = cellCenter(row, col);
float halfCell = m_cellSize * 0.5;
float markLen = m_cellSize * 0.15; // 标记长度占格子的15%
// 绘制左上、右上、左下、右下四个方向的直角标记
QPainterPath path;
// 左上角标记
path.moveTo(center.x() - halfCell + offset, center.y() - halfCell);
path.lineTo(center.x() - halfCell + offset + markLen, center.y() - halfCell);
path.moveTo(center.x() - halfCell, center.y() - halfCell + offset);
path.lineTo(center.x() - halfCell, center.y() - halfCell + offset + markLen);
// ... 类似地绘制其他三个角
painter.drawPath(path);
};
for (auto &pos : soldierPos) {
drawCornerMark(pos.first, pos.second, 2);
}
for (auto &pos : cannonPos) {
drawCornerMark(pos.first, pos.second, 4); // 炮的标记可以稍长一些
}
}
通过以上步骤,一个基础但已相当规整的棋盘就呈现出来了。线条清晰,星位明确,并且有了初步的立体感。
3. 高级渲染技巧:渐变、纹理与文字
要让棋盘从“能用”跃升到“好看”,我们需要运用QPainter更高级的特性。背景使用简单的单色填充显得呆板,我们可以采用线性渐变来模拟光照效果,让棋盘中心更亮,边缘稍暗。此外,“楚河汉界”的文字渲染也需要精心处理。
首先,我们优化drawBoardBackground中的渐变设置,使其能动态适应部件尺寸。
void ChessBoardWidget::drawBoardBackground(QPainter &painter)
{
// 创建一个更精致的径向渐变,模拟中心光源效果
QRadialGradient radialGrad(width()/2, height()/2, qMax(width(), height())/2);
radialGrad.setColorAt(0, QColor(0xFA, 0xF0, 0xE6)); // 中心更亮的米白
radialGrad.setColorAt(0.7, m_bgColor1); // 过渡到主背景色
radialGrad.setColorAt(1, QColor(0xDE, 0xC9, 0xB5)); // 边缘稍暗
// 绘制带纹理感的棋盘底框
QRectF boardRect(m_boardMargin - 8, m_boardMargin - 8,
m_boardCols * m_cellSize + 16,
m_boardRows * m_cellSize + 16);
// 先画一个深色阴影,制造微微的悬浮感
painter.setPen(Qt::NoPen);
painter.setBrush(QColor(0, 0, 0, 30)); // 半透明黑色
painter.drawRoundedRect(boardRect.translated(2, 2), 12, 12);
// 再画主体背景
painter.setBrush(radialGrad);
painter.setPen(QPen(QColor(0x8B, 0x45, 0x13), 4));
painter.drawRoundedRect(boardRect, 12, 12);
}
接下来,我们实现drawDecoration方法,其中最重要的就是绘制“楚河汉界”这四个字。在Qt中绘制文字,字体选择、大小、颜色和位置都至关重要。
void ChessBoardWidget::drawDecoration(QPainter &painter)
{
// 绘制“楚河汉界”文字
int startX = m_boardMargin;
int startY = m_boardMargin;
int riverCenterY = startY + 5.5 * m_cellSize; // 楚河汉界中间位置
// 设置字体 - 使用一种有书法感的字体,如果系统没有,则回退到黑体
QFont font;
QStringList preferredFonts = {"LiSu", "SimLi", "FangSong", "STKaiti", "Microsoft YaHei"};
for (const QString &fontName : preferredFonts) {
if (QFontDatabase::hasFamily(fontName)) {
font.setFamily(fontName);
break;
}
}
font.setPointSize(m_cellSize / 3); // 字体大小随格子尺寸自适应
font.setBold(true);
painter.setFont(font);
// 设置文字颜色和效果
QColor textColor(0x8B, 0x00, 0x00); // 深红色
painter.setPen(textColor);
// 计算文字绘制区域
QString riverText = "楚河 汉界";
QFontMetrics metrics(font);
int textWidth = metrics.horizontalAdvance(riverText);
int textHeight = metrics.height();
// 文字绘制位置(水平居中,垂直位于河界中间)
QRectF textRect(startX + (m_boardCols * m_cellSize - textWidth) / 2,
riverCenterY - textHeight / 2,
textWidth,
textHeight);
// 可以为文字添加一个微弱的阴影或描边来增强立体感和可读性
painter.setPen(QPen(QColor(255, 255, 255, 150), 1));
painter.drawText(textRect.translated(1, 1), Qt::AlignCenter, riverText);
painter.setPen(textColor);
painter.drawText(textRect, Qt::AlignCenter, riverText);
// 可选:在棋盘四个角绘制装饰性图案或文字(如“棋”字篆刻)
// 这里以简单的圆形装饰为例
painter.setBrush(Qt::NoBrush);
QPen decorPen(QColor(0x8B, 0x45, 0x13, 100)); // 半透明的深棕色
decorPen.setWidth(1);
painter.setPen(decorPen);
int cornerRadius = 15;
QPointF corners[] = {
QPointF(m_boardMargin - 5, m_boardMargin - 5),
QPointF(m_boardMargin + m_boardCols * m_cellSize + 5, m_boardMargin - 5),
QPointF(m_boardMargin - 5, m_boardMargin + m_boardRows * m_cellSize + 5),
QPointF(m_boardMargin + m_boardCols * m_cellSize + 5, m_boardMargin + m_boardRows * m_cellSize + 5)
};
for (const QPointF &corner : corners) {
painter.drawEllipse(corner, cornerRadius, cornerRadius);
}
}
文字渲染时,我们考虑了字体回退机制,确保在不同操作系统上都能找到一个合适的字体。为文字添加轻微白色阴影的技巧,能有效提升在复杂背景上的辨识度,这是UI设计中的常用手法。
4. 性能优化与交互增强
一个专业的自定义部件不仅要好看,还要反应灵敏、性能高效。当棋盘需要频繁重绘(例如,在窗口缩放时),优化就显得尤为重要。我们已经通过预计算几何数据(calculateGeometry)减少了paintEvent中的计算量。此外,我们还可以利用resizeEvent来智能调整棋盘大小,并设置适当的绘制区域裁剪,避免不必要的重绘。
void ChessBoardWidget::resizeEvent(QResizeEvent *event)
{
QWidget::resizeEvent(event);
// 根据新的窗口尺寸,动态调整格子大小,保持棋盘居中且比例协调
int availableWidth = width() - 2 * m_boardMargin;
int availableHeight = height() - 2 * m_boardMargin;
// 保持格子为正方形,取宽高中较小者除以格数
int newCellSizeByWidth = availableWidth / m_boardCols;
int newCellSizeByHeight = availableHeight / m_boardRows;
int newCellSize = qMin(newCellSizeByWidth, newCellSizeByHeight);
// 限制格子大小的最小值和最大值,避免过小或过大
newCellSize = qMax(30, qMin(newCellSize, 100));
if (newCellSize != m_cellSize) {
m_cellSize = newCellSize;
calculateGeometry(); // 格子尺寸变了,重新计算所有绘制数据
update(); // 请求重绘
}
}
为了进一步提升交互体验,我们可以让棋盘响应鼠标事件,例如高亮鼠标悬停的格子,或者为选中的格子添加视觉效果。这需要在类中添加相关的事件处理器和状态变量。
首先,在头文件中添加:
// chessboardwidget.h
protected:
void mouseMoveEvent(QMouseEvent *event) override;
void leaveEvent(QEvent *event) override;
void mousePressEvent(QMouseEvent *event) override;
signals:
void cellHovered(int row, int col);
void cellClicked(int row, int col);
private:
// 交互状态
int m_hoveredRow;
int m_hoveredCol;
int m_selectedRow;
int m_selectedCol;
然后在实现文件中:
// chessboardwidget.cpp
ChessBoardWidget::ChessBoardWidget(QWidget *parent)
: QWidget(parent)
, m_hoveredRow(-1)
, m_hoveredCol(-1)
, m_selectedRow(-1)
, m_selectedCol(-1)
{
// ... 其他初始化 ...
setMouseTracking(true); // 启用鼠标跟踪,即使不按下鼠标也能接收move事件
}
void ChessBoardWidget::mouseMoveEvent(QMouseEvent *event)
{
QPoint pos = event->pos();
// 将鼠标坐标转换为棋盘格子索引
int col = (pos.x() - m_boardMargin) / m_cellSize;
int row = (pos.y() - m_boardMargin) / m_cellSize;
// 检查是否在有效棋盘区域内
bool insideBoard = (col >= 0 && col < m_boardCols &&
row >= 0 && row < m_boardRows &&
pos.x() >= m_boardMargin && pos.x() < m_boardMargin + m_boardCols * m_cellSize &&
pos.y() >= m_boardMargin && pos.y() < m_boardMargin + m_boardRows * m_cellSize);
int oldHoveredRow = m_hoveredRow;
int oldHoveredCol = m_hoveredCol;
if (insideBoard) {
m_hoveredRow = row;
m_hoveredCol = col;
} else {
m_hoveredRow = -1;
m_hoveredCol = -1;
}
// 如果悬停的格子发生了变化,则更新该区域(局部重绘)
if (m_hoveredRow != oldHoveredRow || m_hoveredCol != oldHoveredCol) {
// 请求重绘新旧两个格子所在的区域
if (oldHoveredRow != -1) {
update(cellRect(oldHoveredRow, oldHoveredCol).toRect().adjusted(-2, -2, 2, 2));
}
if (m_hoveredRow != -1) {
update(cellRect(m_hoveredRow, m_hoveredCol).toRect().adjusted(-2, -2, 2, 2));
}
emit cellHovered(m_hoveredRow, m_hoveredCol);
}
}
void ChessBoardWidget::leaveEvent(QEvent *event)
{
Q_UNUSED(event);
if (m_hoveredRow != -1 || m_hoveredCol != -1) {
int oldRow = m_hoveredRow;
int oldCol = m_hoveredCol;
m_hoveredRow = -1;
m_hoveredCol = -1;
update(cellRect(oldRow, oldCol).toRect().adjusted(-2, -2, 2, 2));
}
}
void ChessBoardWidget::mousePressEvent(QMouseEvent *event)
{
if (event->button() == Qt::LeftButton && m_hoveredRow != -1) {
int oldSelectedRow = m_selectedRow;
int oldSelectedCol = m_selectedCol;
m_selectedRow = m_hoveredRow;
m_selectedCol = m_hoveredCol;
// 重绘新旧选中格子
if (oldSelectedRow != -1) {
update(cellRect(oldSelectedRow, oldSelectedCol).toRect().adjusted(-2, -2, 2, 2));
}
update(cellRect(m_selectedRow, m_selectedCol).toRect().adjusted(-2, -2, 2, 2));
emit cellClicked(m_selectedRow, m_selectedCol);
}
}
最后,我们需要修改paintEvent中的drawSpecialMarkings或新增一个drawInteraction方法,来绘制悬停和选中效果。
void ChessBoardWidget::drawSpecialMarkings(QPainter &painter)
{
// ... 之前绘制星位、斜线、直角标记的代码 ...
// 绘制悬停效果
if (m_hoveredRow != -1 && m_hoveredCol != -1) {
QRectF hoverRect = cellRect(m_hoveredRow, m_hoveredCol);
painter.setPen(QPen(QColor(100, 150, 255, 120), 3)); // 半透明蓝色边框
painter.setBrush(Qt::NoBrush);
painter.drawRoundedRect(hoverRect.adjusted(2, 2, -2, -2), 5, 5);
}
// 绘制选中效果
if (m_selectedRow != -1 && m_selectedCol != -1) {
QRectF selectedRect = cellRect(m_selectedRow, m_selectedCol);
painter.setPen(QPen(QColor(255, 100, 100, 180), 4)); // 半透明红色边框,更粗
painter.setBrush(Qt::NoBrush);
painter.drawRoundedRect(selectedRect.adjusted(1, 1, -1, -1), 6, 6);
// 可以在选中格子中心加一个更明显的标记
painter.setBrush(QBrush(QColor(255, 100, 100, 100)));
painter.setPen(Qt::NoPen);
painter.drawEllipse(cellCenter(m_selectedRow, m_selectedCol), 6, 6);
}
}
通过以上优化,我们的棋盘组件不仅外观精美,而且具备了流畅的交互反馈。鼠标移动时格子高亮,点击时选中,这为后续实现棋子拖放、走棋逻辑打下了坚实的基础。整个过程中,我们严格遵循了Qt的绘图最佳实践:预计算、局部更新、利用硬件加速(反锯齿),确保了即使在低配置设备上也能流畅运行。
752



被折叠的 条评论
为什么被折叠?



