C++国际象棋程序

已于 2023-06-30 17:17:12 修改
阅读量518 收藏 1
点赞数 2
文章标签： 开发语言 c++
于 2023-06-30 14:31:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_50486524/article/details/131475857
版权 
#include  <iostream>
#include  <cstdlib>
#include  <cmath>
#include  <windows.h>
using namespace std;

int AXIS[8][8]=
{{338,334,322,337,331,322,334,338},
 {336,336,336,336,336,336,336,336},
 {0,0,0,0,0,0,0,0},{0,0,0,0,0,0,0,0},
 {0,0,0,0,0,0,0,0},{0,0,0,0,0,0,0,0},
 {80,80,80,80,80,80,80,80},
 {82,78,66,81,75,66,78,82}};
short Y_AXIS_1,Y_AXIS_2,LOOP_1,LOOP_2,LOOP_3;
char X_AXIS_1,X_AXIS_2;
bool LOOP_4;

void FUNCTION_SWHICH(void)
{
    AXIS[Y_AXIS_2][X_AXIS_2]=AXIS[Y_AXIS_1][X_AXIS_1];
    AXIS[Y_AXIS_1][X_AXIS_1]=0;
}

void FUNCTION_P_WHITE(void)
{
    if(Y_AXIS_1 == 1 && X_AXIS_1 == X_AXIS_2 && AXIS[Y_AXIS_2][X_AXIS_2] == 0)
    {
        if(Y_AXIS_2 == 2 || Y_AXIS_2 == 3)
        {
            FUNCTION_SWHICH();
        }
    }
    else if(X_AXIS_1 == X_AXIS_2 && AXIS[Y_AXIS_2][X_AXIS_2] == 0)
    {
        if(Y_AXIS_2 == Y_AXIS_1)
        {
            FUNCTION_SWHICH();
        }
    }
    else if(X_AXIS_2 == X_AXIS_1 || X_AXIS_2 == X_AXIS_1+1)
    {
        if(AXIS[Y_AXIS_2][X_AXIS_2] != 0)
        {
            if(Y_AXIS_2 == Y_AXIS_1)
            {
                FUNCTION_SWHICH();
            }
        }
    }
}

void FUNCTION_P_BLACK(void)
{
    if(Y_AXIS_1 == 6 && X_AXIS_1 == X_AXIS_2 && AXIS[Y_AXIS_2][X_AXIS_2] == 0)
    {
        if(Y_AXIS_2 == 4 || Y_AXIS_2 == 5)
        {
            FUNCTION_SWHICH();
        }
    }
    else if(X_AXIS_1 == X_AXIS_2 && AXIS[Y_AXIS_2][X_AXIS_2] == 0)
    {
        if(Y_AXIS_2+1 == Y_AXIS_1)
        {
            FUNCTION_SWHICH();
        }
    }
    else if(X_AXIS_2 == X_AXIS_1 || X_AXIS_2 == X_AXIS_1+1)
    {
        if(AXIS[Y_AXIS_2][X_AXIS_2] != 0)
        {
            if(Y_AXIS_2+1 == Y_AXIS_1)
            {
                FUNCTION_SWHICH();
            }
        }
    }
}

void FUNCTION_R(void)
{
    if(X_AXIS_1 == X_AXIS_2)
    {
        if(Y_AXIS_1-Y_AXIS_2 < 0)
        {
            for(LOOP_1=1;LOOP_1 <= Y_AXIS_2-Y_AXIS_1;LOOP_1++)
            {
                if(AXIS[Y_AXIS_1+LOOP_1][X_AXIS_1] == 0)
                {
                    AXIS[Y_AXIS_1+LOOP_1-1][X_AXIS_1]=0;
                    AXIS[Y_AXIS_1+LOOP_1][X_AXIS_2]=338;
                }
                else
                {
                    AXIS[Y_AXIS_1+LOOP_1-1][X_AXIS_1]=0;
                    AXIS[Y_AXIS_1+LOOP_1][X_AXIS_2]=338;
                    break;
                }
            }
        }
        if(Y_AXIS_1-Y_AXIS_2 > 0)
        {
            for(LOOP_1=1;LOOP_1 <= Y_AXIS_1-Y_AXIS_2;LOOP_1++)
            {
                if(AXIS[Y_AXIS_1-LOOP_1][X_AXIS_1] == 0)
                {
                    AXIS[Y_AXIS_1-LOOP_1+1][X_AXIS_1]=0;
                    AXIS[Y_AXIS_1-LOOP_1][X_AXIS_2]=338;
                }
                else
                {
                    AXIS[Y_AXIS_1-LOOP_1+1][X_AXIS_1]=0;
                    AXIS[Y_AXIS_1-LOOP_1][X_AXIS_2]=338;
                    break;
                }
            }
        }
    }
    if(Y_AXIS_1 == Y_AXIS_2)
    {
        if(X_AXIS_1-X_AXIS_2 < 0)
        {
            for(LOOP_1=1;LOOP_1 <= X_AXIS_2-X_AXIS_1;LOOP_1++)
            {
                if(AXIS[Y_AXIS_1][X_AXIS_1+LOOP_1] == 0)
                {
                    AXIS[Y_AXIS_1][X_AXIS_1+LOOP_1-1]=0;
                    AXIS[Y_AXIS_2][X_AXIS_1+LOOP_1]=338;
                }
                else
                {
                    AXIS[Y_AXIS_1][X_AXIS_1+LOOP_1-1]=0;
                    AXIS[Y_AXIS_2][X_AXIS_1+LOOP_1]=338;
                    break;
                }
            }
        }
        if(X_AXIS_1-X_AXIS_2 > 0)
        {
            for(LOOP_1=1;LOOP_1 <= X_AXIS_1-X_AXIS_2;LOOP_1++)
            {
                if(AXIS[Y_AXIS_1][X_AXIS_1-LOOP_1] == 0)
                {
                    AXIS[Y_AXIS_1][X_AXIS_1-LOOP_1+1]=0;
                    AXIS[Y_AXIS_2][X_AXIS_1-LOOP_1]=338;
                }
                else
                {
                    AXIS[Y_AXIS_1][X_AXIS_1-LOOP_1+1]=0;
                    AXIS[Y_AXIS_2][X_AXIS_1-LOOP_1]=338;
                    break;
                }
            }
        }
    }
}

void FUNCTION_N(void)
{
    if(X_AXIS_2 == X_AXIS_1 && Y_AXIS_2 == Y_AXIS_1-2 || X_AXIS_2 == X_AXIS_1+1 && Y_AXIS_2 == Y_AXIS_1-2)
    {
        FUNCTION_SWHICH();
    }
    else if(X_AXIS_2 == X_AXIS_1 && Y_AXIS_2 == Y_AXIS_1+2 || X_AXIS_2 == X_AXIS_1+1 && Y_AXIS_2 == Y_AXIS_1+2)
    {
        FUNCTION_SWHICH();
    }
    else if(Y_AXIS_2 == Y_AXIS_1 && X_AXIS_2 == X_AXIS_1-2 || Y_AXIS_2 == Y_AXIS_1+1 && X_AXIS_2 == X_AXIS_1-2)
    {
        FUNCTION_SWHICH();
    }
    else if(Y_AXIS_2 == Y_AXIS_1 && X_AXIS_2 == X_AXIS_1+2 || Y_AXIS_2 == Y_AXIS_1+1 && X_AXIS_2 == X_AXIS_1+2)
    {
        FUNCTION_SWHICH();
    }
}

void FUNCTION_B(void)
{
    if(Y_AXIS_2-Y_AXIS_1 < 0)
    {
        if(X_AXIS_2-X_AXIS_1 < 0)
        {
            for(LOOP_1=1;LOOP_1 <= sqrt((X_AXIS_1-X_AXIS_2)*(Y_AXIS_1-Y_AXIS_2));LOOP_1++)
            {
                if(AXIS[Y_AXIS_1-LOOP_1][X_AXIS_1-LOOP_1] == 0)
                {
                    AXIS[Y_AXIS_1-LOOP_1+1][X_AXIS_1-LOOP_1+1]=0;
                    AXIS[Y_AXIS_1-LOOP_1][X_AXIS_1-LOOP_1]=322;
                }
                else
                {
                    AXIS[Y_AXIS_1-LOOP_1+1][X_AXIS_1-LOOP_1+1]=0;
                    AXIS[Y_AXIS_1-LOOP_1][X_AXIS_1-LOOP_1]=322;
                    break;
                }
            }
        }
        if(X_AXIS_2-X_AXIS_1 > 0)
        {
            for(LOOP_1=1;LOOP_1 <= sqrt((X_AXIS_2-X_AXIS_1)*(Y_AXIS_1-Y_AXIS_2));LOOP_1++)
            {
                if(AXIS[Y_AXIS_1-LOOP_1][X_AXIS_1+LOOP_1] == 0)
                {
                    AXIS[Y_AXIS_1-LOOP_1+1][X_AXIS_1+LOOP_1-1]=0;
                    AXIS[Y_AXIS_1-LOOP_1][X_AXIS_1+LOOP_1]=322;
                }
                else
                {
                    AXIS[Y_AXIS_1-LOOP_1+1][X_AXIS_1+LOOP_1-1]=0;
                    AXIS[Y_AXIS_1-LOOP_1][X_AXIS_1+LOOP_1]=322;
                    break;
                }
            }
        }
    }
    if(Y_AXIS_2-Y_AXIS_1 > 0)
    {
        if(X_AXIS_2-X_AXIS_1 < 0)
        {
            for(LOOP_1=1;LOOP_1 <= sqrt((X_AXIS_1-X_AXIS_2)*(Y_AXIS_2-Y_AXIS_1));LOOP_1++)
            {
                if(AXIS[Y_AXIS_1+LOOP_1][X_AXIS_1-LOOP_1] == 0)
                {
                    AXIS[Y_AXIS_1+LOOP_1-1][X_AXIS_1-LOOP_1+1]=0;
                    AXIS[Y_AXIS_1+LOOP_1][X_AXIS_1-LOOP_1]=322;
                }
                else
                {
                    AXIS[Y_AXIS_1+LOOP_1-1][X_AXIS_1-LOOP_1+1]=0;
                    AXIS[Y_AXIS_1+LOOP_1][X_AXIS_1-LOOP_1]=322;
                    break;
                }
            }
        }
        if(X_AXIS_2-X_AXIS_1 > 0)
        {
            for(LOOP_1=1;LOOP_1 <= sqrt((X_AXIS_2-X_AXIS_1)*(Y_AXIS_2-Y_AXIS_1));LOOP_1++)
            {
                if(AXIS[Y_AXIS_1+LOOP_1][X_AXIS_1+LOOP_1] == 0)
                {
                    AXIS[Y_AXIS_1+LOOP_1-1][X_AXIS_1+LOOP_1-1]=0;
                    AXIS[Y_AXIS_1+LOOP_1][X_AXIS_1+LOOP_1]=322;
                }
                else
                {
                    AXIS[Y_AXIS_1+LOOP_1-1][X_AXIS_1+LOOP_1-1]=0;
                    AXIS[Y_AXIS_1+LOOP_1][X_AXIS_1+LOOP_1]=322;
                    break;
                }
            }
        }
    }
}

void FUNCTION_K(void)
{
    if(X_AXIS_2 == X_AXIS_1+1 && Y_AXIS_2 == Y_AXIS_1+1 || X_AXIS_2 == X_AXIS_1 && Y_AXIS_2 == Y_AXIS_1+1 || X_AXIS_2 == X_AXIS_1 && Y_AXIS_2 == Y_AXIS_1+1)
    {
        FUNCTION_SWHICH();
    }
    if(X_AXIS_2 == X_AXIS_1+1 && Y_AXIS_2 == Y_AXIS_1 || X_AXIS_2 == X_AXIS_1 && Y_AXIS_2 == Y_AXIS_1 || X_AXIS_2 == X_AXIS_1 && Y_AXIS_2 == Y_AXIS_1)
    {
        FUNCTION_SWHICH();
    }
    if(X_AXIS_2 == X_AXIS_1+1 && Y_AXIS_2 == Y_AXIS_1 || X_AXIS_2 == X_AXIS_1 && Y_AXIS_2 == Y_AXIS_1 || X_AXIS_2 == X_AXIS_1 && Y_AXIS_2 == Y_AXIS_1)
    {
        FUNCTION_SWHICH();
    }
}

int main(void)
{
    for(LOOP_3=1;LOOP_3 == 1;LOOP_3+=0)
    {
        system("cls");
        for(LOOP_1=0;LOOP_1 <= 7;LOOP_1++)
        {
            for(LOOP_2=0;LOOP_2 <= 7;LOOP_2++)
            {
                if(AXIS[LOOP_1][LOOP_2] > 300 && AXIS[LOOP_1][LOOP_2] < 400)
                {
                    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                        FOREGROUND_INTENSITY |
                        FOREGROUND_RED |
                        FOREGROUND_GREEN |
                        FOREGROUND_BLUE);
                    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                        BACKGROUND_INTENSITY |
                        FOREGROUND_INTENSITY |
                        BACKGROUND_RED |
                        BACKGROUND_GREEN |
                        BACKGROUND_BLUE);
                }
                else
                {
                    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                        FOREGROUND_INTENSITY);
                    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),
                        FOREGROUND_INTENSITY |
                        FOREGROUND_RED |
                        FOREGROUND_GREEN |
                        FOREGROUND_BLUE);
                }
                cout << (char)(AXIS[LOOP_1][LOOP_2]);
            }
            cout << endl;
        }
        cout << LOOP_4 << ":";
        cin >> X_AXIS_1 >> Y_AXIS_1 >> X_AXIS_2 >> Y_AXIS_2;
        X_AXIS_1-='a';
        X_AXIS_2-='a';
        Y_AXIS_1-=1;
        Y_AXIS_2-=1;
        if(X_AXIS_1 >= 0 && X_AXIS_1 <= 7 && Y_AXIS_1 >= 0 && Y_AXIS_1 <= 7)
        {
            if(X_AXIS_2 >= 0 && X_AXIS_2 <= 7 && Y_AXIS_2 >= 0 && Y_AXIS_2 <= 7)
            {
                if(AXIS[Y_AXIS_1][X_AXIS_1] == 336 || AXIS[Y_AXIS_1][X_AXIS_1] == 80)
                {
                    if(LOOP_4 == 0)
                    {
                        FUNCTION_P_WHITE();
                    }
                    else if(LOOP_4 == 1)
                    {
                        FUNCTION_P_BLACK();
                    }
                }
                else if(AXIS[Y_AXIS_1][X_AXIS_1] == 338 || AXIS[Y_AXIS_1][X_AXIS_1] == 82)
                {
                    FUNCTION_R();
                }
                else if(AXIS[Y_AXIS_1][X_AXIS_1] == 334 || AXIS[Y_AXIS_1][X_AXIS_1] == 78)
                {
                    FUNCTION_N();
                }
                else if(AXIS[Y_AXIS_1][X_AXIS_1] == 322 || AXIS[Y_AXIS_1][X_AXIS_1] == 66)
                {
                    FUNCTION_B();
                }
                else if(AXIS[Y_AXIS_1][X_AXIS_1] == 331 || AXIS[Y_AXIS_1][X_AXIS_1] == 75)
                {
                    FUNCTION_K();
                }
                else if(AXIS[Y_AXIS_1][X_AXIS_1] == 337 || AXIS[Y_AXIS_1][X_AXIS_1] == 81)
                {
                    FUNCTION_N();
                    FUNCTION_B();
                }
            }
        }
        if(LOOP_4 == 0)
        {
            LOOP_4=1;
        }
        else LOOP_4=0;
    }
    return 0;
}

“一个可以运行 的C++语言国际象棋程序，几年前编的答辩程序，莫得注释，我也忘了写的是嘛，王车易位没写，烂尾坟立个碑。”

爱读书的Avonise
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
C语言项目实战：《国际象棋》零基础项目，200 行源代码示例
致力于C语言C++知识分享！
11-19 4954
这篇文章主要为大家详细介绍了C语言实现——《国际象棋项目》，它和中国象棋可不一样哟！文中示例代码介绍的非常详细，具有一定的参考价值,感兴趣的小伙伴们可以参考一下！ 游戏介绍： 国际象棋（Chess），又称西洋棋，是一种二人对弈的棋类游戏。 棋盘为正方形，由64个黑白（深色与浅色）相间的格子组成；棋子分黑白（深色与浅色）两方共32枚，每方各16枚。虽然汉语称之为西洋棋或国际象棋，但是实际上它起源于亚洲，后由阿拉伯人传入欧洲，成为国际通行棋种。 行棋规则 国际象棋是双方对下的，一方用白棋，一方用黑
C++制作汉字版国际象棋第一篇
程序员小知的博客
01-12 511
今天我新开了一个专栏，在这里我将会一步步带大家写出一个国际象棋小游戏
国际象棋 C++实现
04-13
国际象棋 C++实现
C++国际象棋 （有王车易位）
sleven_bird的博客
08-17 404
有些小bug若有人可以找出并修改请发出评论区，我会非常感谢他
基于C++的简易的国际象棋双人对战程序设计
毕业作品网站
09-12 2546
国际象棋是世界上一个古老的棋种。据现有史料记载，国际象棋的发展历史已将近2000年。关于它的起源，有多种不同的说法，诸如起源于古印度、中国、阿拉伯国家等。国际象棋分为黑白两方共32枚，每方各16枚；棋盘为正方形，由64个黑白（深色与浅色）相间的格子组成。每方有王、后、象、车、马、兵六种棋子，不同棋子走子和吃子的方法不同，不再赘述。
C++制作汉字版国际象棋（2）
程序员小知的博客
01-13 217
上次我写出了棋类型的定义与赋值，今天我们来写地图与马
C++制作汉字版国际象棋（3）
程序员小知的博客
01-20 515
今天我们会写所有的输出操作
基于C++的递归和回溯国际象棋女王安全算法
毕业作品网站
06-21 896
熟悉递归的基本思想 能够设计自己的递归函数。关键是设计基本案例和感应步骤 了解回溯算法。可以使用递归和回溯来解决特定问题。Windows 7（或更高版本）+ Visual Studio 2010（或更高版本）制定并验证一个程序，将八个女王放在棋盘上，这样就不会有女王受到任何其他女王的攻击。定义一个名为 eightqueen 的类。我把所有的方法都放进去了，包括递归方法。 通过构造函数创建默认棋盘。然后定义方法 printchess（） 和 goBack（） 它们是更简单的。最重要的方法是 isValid（）
Chess:用C ++编写的国际象棋引擎
03-21
Chess:用C ++编写的国际象棋引擎
国际象棋代码实现
11-29
c语言实现国际象棋模拟，适用于初级学员的课程设计
国际象棋程序-chess.rar
08-13
国际象棋程序-chess.rar 完全功能，有历史记录，反应很快，可悔棋。 附件： 巨多：解压后运行主文件，chess.m即可。 里边还有作者写的一个pdf的象棋教程，功能未曾试完。 附件： chess.rar
中国象棋AI算法 C/C++
10-21
中国象棋的AI算法，一步一步教你学习AI设计，六个版本，难度逐次增加。非常好的学习资料。
C++程序代码（打印国际象棋的棋盘）
10-19
该工程文件能够编译、组建和执行，主要是练习打印国际象棋的棋盘，有很好的C++训练功能，仅供参考！
Chess-AI：具有许多玩家AI的C ++国际象棋实现，包括神经网络驱动的AI，与Deepmind的AlphaZero国际象棋引擎相同...
02-15
DNN国际象棋AI 设计原理 该项目围绕着由神经网络驱动的国际象棋AI，其设计受到的国际象棋引擎的严重影响。 AlphaZero使用了类似的方法以及和来创建强大的国际象棋AI。 尽管这些项目共享许多设计原则，但我的项目在实现上与AlphaZero在很多方面都有很大不同。 首先，我的实现使用的是，，而不是Deepmind使用的深度卷积神经网络。 实施更基本的网络的原因是由于这样的事实，即更复杂，更主流的网络结构（例如和只是经过修改的前馈网络，具有更多的连接或预处理元素（例如卷积核）。 结果，该项目将研究更基本的网络结构，然后可以将其理解和设计扩展到更复杂的网络。 待办事项：目前正在计划其他网络实现（特别是CNN）和训练算法（例如和 ）。 我也希望探索一些我在找到的有趣的想法，该想法探讨了如何强化学习问题，例如训练这种国际象棋AI，以利用监督学习中更可靠的训练方法。 此外，不是使用这样的
国际象棋小游戏C语言源代码
03-25
国际象棋程序为小游戏开发程序，运用C语言编写，展现与现实相似的棋盘，实现人与人对弈，程序对于行进步伐是否符合国际象棋下棋规则进行判断，并对最后的输赢进行判断。
18-打印国际象棋Dev C++
高调做事，低调做人！
01-11 1718
#include "stdio.h" #include "conio.h" main() { int i,j; for(i=0;i<8;i++) { for(j=0;j<8;j++) if((i+j)%2==0) printf("%c%c",219,219); else printf(" "); printf("
数据结构：国际象棋 C++ 大数显示
程序员伤不起
01-20 2717
思考题1:国际象棋是很久以前由一个印度人Shashi发明的，当他吧该发明献给国王时，国王很高兴，就许诺可以给这个发明人任何他想要的奖赏，Shashi要求以这种方式给他一些粮食：棋盘的第1个方格内只放1粒麦粒，第2格2粒，第3格4粒，第4格8粒，以此类推，直到64个方格全部放满。这个奖赏的最终结果会是什么样呢？ 思路：题目主要围绕的数大数展开的，应该单个2的63次方已经很大了 int的范围：
C/C++：实现象棋游戏
linglingnana的博客
05-30 6492
采用面相过程的设计方式实现，类似于我们平时做的课程设计，实现这样的小游戏无非就是多了图形处理库。这里使用的是acllib图形库。 设计这种小游戏，首先要从宏观上去认识：象棋，要有棋盘，要有棋子，棋子要移动。 对于棋盘，十行九列画出即可。 对于棋子，分黑红两方，按照指定位置画出。 如何移动棋子，我们有mouseEvent函数。 初始化棋盘棋子：initmap，initpaint 利用鼠标实现棋子移动分两步： 第一次点击，记录点击棋子的信息 第二次点击，将第一次点击记录的棋子信息移动到第二次点击的位置。 最后在
c++古印度象棋格麦粒
最新发布
11-16
根据古老的传说，舍罕王打算奖赏国际象棋的发明人——宰相：西萨·班·达依尔。国王问他想要什么，他对国王说：“陛下，请您在这张棋盘的第1个小格里，赏给我1粒麦子，在第2个小格里给2粒，第3小格给4粒，以后每一小格都比前一小格加一倍。请您把这样摆满棋盘上所有的64格的麦粒，都赏给您的仆人吧！”根据这个问题，我们可以使用C++编写程序来计算宰相最终获得的麦粒数量。 以下是C++代码示例： ```c++ #include <iostream> #include <cmath> using namespace std; int main() { int n = 64; long long grains = pow(2, n) - 1; cout << "宰相最终获得的麦粒数量为：" << grains << endl; return 0; } ``` 输出结果为： ``` 宰相最终获得的麦粒数量为：18446744073709551615 ```
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值