windows编程（Qt）实现中国象棋——人机对战，网络对战

末蓝、 2022-05-22 13:06 383阅读 0赞

1. 本程序包含AI思想，具有判断决策功能，但不具有学习功能

2. 本程序借鉴已有程序学习摸索，代码并非完全由我本人自己写出的

3. 本程序实现了：人机对战，网络对战功能

#ifndef STONE_H
    #define STONE_H
    
    /*
    **棋子头文件
    */
    
    #include <QRect>
    #include <QPainter>    //绘制头函数
    
    class Stone            //类声明
    {
    public:
        Stone();          //构造函数
        ~Stone();		  //析构函数
    
        enum TYPE{CHE, MA, PAO, BING, JIANG, SHI, XIANG};           //成员元素
    
        void init(int id);		//初始化函数
    
        int _row;        //
        int _col;
        TYPE _type;
        bool _dead;
        bool _red;
        int _id;
    
        QString name();
    
        void rotate();
    };
    
    #endif // STONE_H

#ifndef STEP_H
    #define STEP_H
    
    
    /*
    **棋子移动规则
    */
    
    #include <QObject>         //基类
    
    class Step : public QObject
    {
        Q_OBJECT
    public:
        explicit Step(QObject *parent = 0);     //声明构造函数是显式的
        ~Step();
    
        int _moveid;		//移动
        int _killid;		//吃子
        int _rowFrom;		//移动开始位置
        int _colFrom;		//移动列位置
        int _rowTo;			//移动到行位置
        int _colTo;			//移动到列位置
    
    signals:				//AI走子
    
    public slots:
    };
    
    #endif // STEP_H

#ifndef SINGLEGAME_H
    #define SINGLEGAME_H
    
    
    /*
    **电脑判断头文件
    */
    
    #include "Board.h"
    
    class SingleGame : public Board
    {
        Q_OBJECT
    public:
        SingleGame()
        {
            _level = 6;
        }
        virtual void click(int id, int row, int col);
    
        Step* getBestMove();
        void getAllPossibleMove(QVector<Step*>& steps);
    
        void fakeMove(Step* step);
        void unfakeMove(Step* step);
        int calcScore();
    
        int getMinScore(int level, int curMaxScore);
        int getMaxScore(int level, int curMinScore);
    
        int _level;
    
    public slots:
        void computerMove();
    };
    
    #endif // SINGLEGAME_H

#include "SingleGame.h"
    #include <QTimer>
    
    /*
    **电脑判断方法
    */
    
    void SingleGame::click(int id, int row, int col)
    {
        if(!this->_bRedTurn)
            return;
    
        Board::click(id, row, col);
    
        if(!this->_bRedTurn)
        {
            /* 启动0.1秒定时器，在0.1秒后电脑再思考 */
            QTimer::singleShot(100, this, SLOT(computerMove()));
    
        }
    }
    void SingleGame::computerMove()
    {
        Step* step = getBestMove();
        moveStone(step->_moveid, step->_killid,
                  step->_rowTo, step->_colTo);
        delete step;
        update();
    }
    
    void SingleGame::getAllPossibleMove(QVector<Step *> &steps)
    {
        int min=16, max=32;
        if(this->_bRedTurn)
        {
            min = 0, max = 16;
        }
        for(int i=min; i<max; ++i)
        {
            if(_s[i]._dead) continue;
    
            for(int row=0; row<=9; ++row)
            {
                for(int col=0; col<=8; ++col)
                {
                    int killid = this->getStoneId(row, col);
                    if(sameColor(killid, i)) continue;
    
                    if(canMove(i, killid, row, col))
                    {
                        saveStep(i, killid, row, col, steps);
                    }
                }
            }
        }
    }
    
    void SingleGame::fakeMove(Step* step)
    {
        killStone(step->_killid);
        moveStone(step->_moveid, step->_rowTo, step->_colTo);
    }
    
    void SingleGame::unfakeMove(Step* step)
    {
        reliveStone(step->_killid);
        moveStone(step->_moveid, step->_rowFrom, step->_colFrom);
    }
    
    /* 评价局面分 */
    int SingleGame::calcScore()
    {
        int redTotalScore = 0;
        int blackTotalScore = 0;
        //enum TYPE{CHE, MA, PAO, BING, JIANG, SHI, XIANG};
        static int chessScore[] = {100, 50, 50, 20, 1500, 10, 10};
    
        // 黑棋分的总数 - 红旗分的总数
        for(int i=0; i<16; ++i)
        {
            if(_s[i]._dead) continue;
            redTotalScore += chessScore[_s[i]._type];
        }
        for(int i=16; i<32; ++i)
        {
            if(_s[i]._dead) continue;
            blackTotalScore += chessScore[_s[i]._type];
        }
    
        return blackTotalScore - redTotalScore;
    }
    
    int SingleGame::getMaxScore(int level, int curMinScore)
    {
        if(level == 0) return calcScore();
    
        // 1.看看有那些步骤可以走
        QVector<Step*> steps;
        getAllPossibleMove(steps);   // 是红旗的possiblemove
    
        int maxScore = -100000;
        while(steps.count())
        {
            Step* step = steps.back();
            steps.removeLast();
    
            fakeMove(step);
            int score = getMinScore(level-1, maxScore);
            unfakeMove(step);
            delete step;
    
            if(score >= curMinScore)
            {
                while(steps.count())
                {
                    Step* step = steps.back();
                    steps.removeLast();
                    delete step;
                }
                return score;
            }
            if(score > maxScore)
            {
                maxScore = score;
            }
    
        }
        return maxScore;
    }
    
    int SingleGame::getMinScore(int level, int curMaxScore)
    {
    
    
        if(level == 0) return calcScore();
    
        // 1.看看有那些步骤可以走
        QVector<Step*> steps;
        getAllPossibleMove(steps);   // 是红棋的possiblemove
    
        int minScore = 100000;
        while(steps.count())
        {
            Step* step = steps.back();
            steps.removeLast();
    
            fakeMove(step);
            int score = getMaxScore(level-1, minScore);
            unfakeMove(step);
            delete step;
    
            if(score <= curMaxScore)
            {
                while(steps.count())
                {
                    Step* step = steps.back();
                    steps.removeLast();
                    delete step;
                }
                return score;
            }
    
            if(score < minScore)
            {
                minScore = score;
            }
    
        }
        return minScore;
    }
    
    Step* SingleGame::getBestMove()
    {
        /*
            2.试着走一下
            3.评估走的结果
            4.取最好的结果作为参考
        */
    
        // 1.看看有那些步骤可以走
        QVector<Step*> steps;
        getAllPossibleMove(steps);
    
        // 2.试着走一下
        // 3.评估走的结果
        int maxScore = -100000;
        Step* ret = NULL;
        while(steps.count())
        {
            Step* step = steps.back();
            steps.removeLast();
    
            fakeMove(step);
            int score = getMinScore(_level-1, maxScore);
            unfakeMove(step);
    
            if(score > maxScore)
            {
                maxScore = score;
                if(ret) delete ret;
                ret = step;
            }
            else
            {
                delete step;
            }
        }
    
        // 4.取最好的结果作为参考
        return ret;
    }