C语言实现三维五子棋（双人对战版）_立体五子棋代码-程序员宅基地

技术标签： C/C++ 二维数组三维 c语言三维五子棋的胜负判断五子棋

问题难点

棋盘如何显示？
胜负如何判断？

程序特点

运用结构体数组的知识，结构体内保存字符型二维数组。
结构体数组表示了棋盘厚度，字符型二维数组表示当前棋盘状态。
胜负评判系统分为当前平面棋盘检查与竖直方向检查。

程序不足

没有禁手限制，存在不公平
仅是双人对战版本，没有AI系统

C语言代码

#include<stdio.h>
#include<Windows.h>
#include<time.h>
#include<stdlib.h>
#include<string.h>
#include<conio.h> 
#define MAXIMUS 5 //定义棋盘大小(5*5个方框)
#define chess_number 30//定义棋盘高度
int count = 0, move_x = 0, move_y = 0, x = 0, y = 0, chess_num = chess_number / 2, chess_num_0;
struct MyStruct_0
{
    char ChessBoard[MAXIMUS][MAXIMUS];
}MyStruct_0[chess_number];

这里的棋盘高度是指：竖直方向棋盘个数
move_x：为棋子横坐标。x：为光标横坐标
实际初始状态为第15个棋盘，但用户显示为chess_num第零个棋盘，这样能够避免判断胜负不方便判断的情况

/*棋盘初始化*/
void Initialize()
{
    for (int i = 0; i < MAXIMUS; i++)
    {
        for (int j = 0; j < MAXIMUS; j++)
        {
            MyStruct_0[chess_num].ChessBoard[i][j] = ' ';
        }
    }
    MyStruct_0[chess_num].ChessBoard[x][y] = '+';
}

该函数目的：将棋盘棋子的地方用’ ‘代替。
显示初始光标位置

/*画棋盘*/
void DrawBoard()
{
    printf("\n当前棋盘位置(w,s调整)：%d\n", chess_num_0);
    printf("当前棋盘棋子情况：\n");
    printf("o:\n");
    for (int i = 0; i < MAXIMUS; i++)
    {
        for (int j = 0; j < MAXIMUS; j++)
        {
            if (MyStruct_0[chess_num].ChessBoard[i][j] == 'o')
                printf("(%d,%d) ", i, j);
        }
    }
    printf("\n*:\n");
    for (int i = 0; i < MAXIMUS; i++)
    {
        for (int j = 0; j < MAXIMUS; j++)
        {
            if (MyStruct_0[chess_num].ChessBoard[i][j] == '*')
                printf("(%d,%d) ", i, j);
        }
    }
    printf("\n---------------------------------------------\n\n");
    printf("┏");
    for (int i = 0; i < MAXIMUS - 1; i++)
        printf("─┳");
    printf("─┓\n");

    for (int i = 0; i< MAXIMUS - 1; i++)
    {
        for (int j = 0; j < MAXIMUS; j++)
        {
            printf("│%c ", MyStruct_0[chess_num].ChessBoard[i][j]);
        }
        printf("│\n");
        printf("┣");

        for (int i = 0; i < MAXIMUS - 1; i++)
        {
            printf("─╋"); 
        }
        printf("─┫\n");
    }

    for (int i = 0; i < MAXIMUS; i++)
    {
        printf("│%c ", MyStruct_0[chess_num].ChessBoard[MAXIMUS - 1][i]);
    }

    printf("│\n");
    printf("┗");
    for (int i = 0; i < MAXIMUS - 1; i++)
        printf("─┻");
    printf("─┛\n");
}

/*判断胜负*/
int Win_Or_Not()
{
    /*水平判断*/
    int W_ = 0, B_ = 0, i;
    for (i = 1; i < 5; i++){ if (move_x - i >= 0 && MyStruct_0[chess_num].ChessBoard[move_x - i][move_y] == 'o'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == 'o')W_++; else break; }
    for (i = 1; i < 5; i++){ if (move_x + i<MAXIMUS&&MyStruct_0[chess_num].ChessBoard[move_x + i][move_y] == 'o'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == 'o')W_++; else break; }
    if (W_ >= 4)
        return 1;
    for (i = 1; i < 5; i++){ if (move_x - i >= 0 && MyStruct_0[chess_num].ChessBoard[move_x - i][move_y] == '*'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == '*')B_++; else break; }
    for (i = 1; i < 5; i++){ if (move_x + i<MAXIMUS&&MyStruct_0[chess_num].ChessBoard[move_x + i][move_y] == '*'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == '*')B_++; else break; }
    if (B_ >= 4)
        return 2;

    W_ = 0, B_ = 0;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num].ChessBoard[move_x][move_y + i] == 'o'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == 'o')W_++; else { break; } }
    if (W_ == 4)
        return 1;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num].ChessBoard[move_x][move_y - i] == 'o'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == 'o')W_++; else { break; } }
    if (W_ == 4)
        return 1;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num].ChessBoard[move_x][move_y + i] == '*'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == '*')B_++; else { break; } }
    if (B_ == 4)
        return 2;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num].ChessBoard[move_x][move_y - i] == '*'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == '*')B_++; else { break; } }
    if (B_ == 4)
        return 2;

    W_ = 0, B_ = 0;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num].ChessBoard[move_x + i][move_y + i] == 'o'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == 'o')W_++; else { break; } }
    if (W_ == 4)
        return 1;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num].ChessBoard[move_x - i][move_y - i] == 'o'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == 'o')W_++; else { break; } }
    if (W_ == 4)
        return 1;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num].ChessBoard[move_x + i][move_y + i] == '*'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == '*')B_++; else { break; } }
    if (B_ == 4)
        return 2;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num].ChessBoard[move_x - i][move_y - i] == '*'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == '*')B_++; else { break; } }
    if (B_ == 4)
        return 2;

    W_ = 0, B_ = 0;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num].ChessBoard[move_x + i][move_y - i] == 'o'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == 'o')W_++; else { break; } }
    if (W_ == 4)
        return 1;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num].ChessBoard[move_x - i][move_y + i] == 'o'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == 'o')W_++; else { break; } }
    if (W_ == 4)
        return 1;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num].ChessBoard[move_x + i][move_y - i] == '*'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == '*')B_++; else { break; } }
    if (B_ == 4)
        return 2;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num].ChessBoard[move_x - i][move_y + i] == '*'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == '*')B_++; else { break; } }
    if (B_ == 4)
        return 2;


    /*立体判断*/

    /*0号方向*/
    W_ = 0, B_ = 0;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num + i].ChessBoard[move_x][move_y] == 'o'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == 'o') W_++; else {
   break;} }
    if (W_ == 4)
        return 1;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num - i].ChessBoard[move_x][move_y] == 'o'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == 'o') W_++; else { break; } }
    if (W_ == 4)
        return 1;

    W_ = 0, B_ = 0;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num + i].ChessBoard[move_x][move_y] == '*'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == '*') B_++; else { break; } }
    if (B_ == 4)
        return 2;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num - i].ChessBoard[move_x][move_y] == '*'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == '*') B_++; else { break; } }
    if (B_ == 4)
        return 2;

    /*1号方向*/
    W_ = 0, B_ = 0;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num + i].ChessBoard[move_x][move_y - i] == 'o'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == 'o') W_++; else { break; } }
    if (W_ == 4)
        return 1;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num - i].ChessBoard[move_x][move_y + i] == 'o'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == 'o') W_++; else { break; } }
    if (W_ == 4)
        return 1;

    W_ = 0, B_ = 0;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num + i].ChessBoard[move_x][move_y - i] == '*'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == '*') B_++; else { break; } }
    if (B_ == 4)
        return 2;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num - i].ChessBoard[move_x][move_y + i] == '*'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == '*') B_++; else { break; } }
    if (B_ == 4)
        return 2;

    /*2号方向*/
    W_ = 0, B_ = 0;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num + i].ChessBoard[move_x - i][move_y - i] == 'o'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == 'o') W_++; else { break; } }
    if (W_ == 4)
        return 1;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num - i].ChessBoard[move_x + i][move_y + i] == 'o'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == 'o') W_++; else { break; } }
    if (W_ == 4)
        return 1;

    W_ = 0, B_ = 0;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num + i].ChessBoard[move_x - i][move_y - i] == '*'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == '*') B_++; else { break; } }
    if (B_ == 4)
        return 2;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num - i].ChessBoard[move_x + i][move_y + i] == '*'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == '*') B_++; else { break; } }
    if (B_ == 4)
        return 2;

    /*3号方向*/
    W_ = 0, B_ = 0;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num + i].ChessBoard[move_x - i][move_y] == 'o'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == 'o') W_++; else { break; } }
    if (W_ == 4)
        return 1;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num - i].ChessBoard[move_x + i][move_y] == 'o'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == 'o') W_++; else { break; } }
    if (W_ == 4)
        return 1;

    W_ = 0, B_ = 0;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num + i].ChessBoard[move_x - i][move_y] == '*'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == '*') B_++; else { break; } }
    if (B_ == 4)
        return 2;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num - i].ChessBoard[move_x + i][move_y] == '*'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == '*') B_++; else { break; } }
    if (B_ == 4)
        return 2;

    /*4号方向*/
    W_ = 0, B_ = 0;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num + i].ChessBoard[move_x - i][move_y + i] == 'o'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == 'o') W_++; else { break; } }
    if (W_ == 4)
        return 1;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num - i].ChessBoard[move_x + i][move_y - i] == 'o'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == 'o') W_++; else { break; } }
    if (W_ == 4)
        return 1;

    W_ = 0, B_ = 0;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num + i].ChessBoard[move_x - i][move_y + i] == '*'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == '*') B_++; else { break; } }
    if (B_ == 4)
        return 2;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num - i].ChessBoard[move_x + i][move_y - i] == '*'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == '*') B_++; else { break; } }
    if (B_ == 4)
        return 2;

    /*5号方向*/
    W_ = 0, B_ = 0;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num + i].ChessBoard[move_x][move_y + i] == 'o'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == 'o') W_++; else { break; } }
    if (W_ == 4)
        return 1;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num - i].ChessBoard[move_x][move_y - i] == 'o'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == 'o') W_++; else { break; } }
    if (W_ == 4)
        return 1;

    W_ = 0, B_ = 0;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num + i].ChessBoard[move_x][move_y + i] == '*'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == '*') B_++; else { break; } }
    if (B_ == 4)
        return 2;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num - i].ChessBoard[move_x][move_y - i] == '*'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == '*') B_++; else { break; } }
    if (B_ == 4)
        return 2;

    /*6号方向*/
    W_ = 0, B_ = 0;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num + i].ChessBoard[move_x + i][move_y + i] == 'o'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == 'o') W_++; else { break; } }
    if (W_ == 4)
        return 1;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num - i].ChessBoard[move_x - i][move_y - i] == 'o'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == 'o') W_++; else { break; } }
    if (W_ == 4)
        return 1;

    W_ = 0, B_ = 0;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num + i].ChessBoard[move_x + i][move_y + i] == '*'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == '*') B_++; else { break; } }
    if (B_ == 4)
        return 2;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num - i].ChessBoard[move_x - i][move_y - i] == '*'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == '*') B_++; else { break; } }
    if (B_ == 4)
        return 2;

    /*7号方向*/
    W_ = 0, B_ = 0;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num + i].ChessBoard[move_x + i][move_y] == 'o'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == 'o') W_++; else { break; } }
    if (W_ == 4)
        return 1;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num - i].ChessBoard[move_x - i][move_y] == 'o'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == 'o') W_++; else { break; } }
    if (W_ == 4)
        return 1;

    W_ = 0, B_ = 0;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num + i].ChessBoard[move_x + i][move_y] == '*'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == '*') B_++; else { break; } }
    if (B_ == 4)
        return 2;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num - i].ChessBoard[move_x - i][move_y] == '*'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == '*') B_++; else { break; } }
    if (B_ == 4)
        return 2;

    /*8号方向*/
    W_ = 0, B_ = 0;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num + i].ChessBoard[move_x + i][move_y - i] == 'o'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == 'o') W_++; else { break; } }
    if (W_ == 4)
        return 1;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num - i].ChessBoard[move_x - i][move_y + i] == 'o'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == 'o') W_++; else { break; } }
    if (W_ == 4)
        return 1;

    W_ = 0, B_ = 0;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num + i].ChessBoard[move_x + i][move_y - i] == '*'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == '*') B_++; else { break; } }
    if (B_ == 4)
        return 2;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num - i].ChessBoard[move_x - i][move_y + i] == '*'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == '*') B_++; else { break; } }
    if (B_ == 4)
        return 2;

    int sum = 0;
    for (int i = 0; i < MAXIMUS; i++)
    {
        for (int j = 0; j < MAXIMUS; j++)
        {
            if (MyStruct_0[chess_num].ChessBoard[i][j] == 'o' || MyStruct_0[chess_num].ChessBoard[i][j] == '*')
                sum += 1;
        }
    }
    if (sum == MAXIMUS*MAXIMUS)
        return 3;

    return 0;
}

这里是最重要的胜负判断函数。比较笨拙，能力有限。

这里以1号方向为例讲解。

/*1号方向*/
    W_ = 0, B_ = 0;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num + i].ChessBoard[move_x][move_y - i] == 'o'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == 'o') W_++; else { break; } }
    if (W_ == 4)
        return 1;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num - i].ChessBoard[move_x][move_y + i] == 'o'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == 'o') W_++; else { break; } }
    if (W_ == 4)
        return 1;

    W_ = 0, B_ = 0;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num + i].ChessBoard[move_x][move_y - i] == '*'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == '*') B_++; else { break; } }
    if (B_ == 4)
        return 2;
    for (i = 1; i < 5; i++){ if (MyStruct_0[chess_num - i].ChessBoard[move_x][move_y + i] == '*'&&MyStruct_0[chess_num].ChessBoard[move_x][move_y] == '*') B_++; else { break; } }
    if (B_ == 4)
        return 2;

W_ = 0, B_ = 0。记录双方当前连子数目。达到五个子后返回不同的数值来判断胜方。
MyStruct_0[chess_num + i].ChessBoard[move_x][move_y - i]表示当前第chess_num个棋盘的状态
每下一个子分为两部分。己方与对方。同时，将一条直线上的棋子数判断分为一半一半来判断。
一共九个方向。能想的来么？

void RunGame()
{
    int input;
    system("cls");
    DrawBoard();//打印棋盘
    input = getch();//等待键盘按下一个字符
    if (input == 27)//如果是ESC则退出程序
    {
        exit(0);
    }
    else if (char(input) == 'c')
    {
        MyStruct_0[chess_num].ChessBoard[x][y] = ' ', move_x = x, move_y = y;
    }
    else if (char(input) == 'w')
    {
        chess_num_0++;
        chess_num++;
    }
    else if (char(input) == 's')
    {
        chess_num_0--;
        chess_num--;
    }
    else if (input == 0x20)//如果是空格则开始走子
    {
        if (count % 2 == 0)
            MyStruct_0[chess_num].ChessBoard[x][y] = 'o', move_x = x, move_y = y;
        else
            MyStruct_0[chess_num].ChessBoard[x][y] = '*', move_x = x, move_y = y;

        count += 1;
    }
    else if (input == 0xE0)//如果按下的是方向键，会填充两次输入，第一次为0xE0表示按下的是控制键
    {
        if (MyStruct_0[chess_num].ChessBoard[x][y] != '*'&&MyStruct_0[chess_num].ChessBoard[x][y] != 'o')
            MyStruct_0[chess_num].ChessBoard[x][y] = ' ';
        input = getch();//获得第二次输入信息

        switch (input)//判断方向键方向并移动光标位置
        {
        case 0x4B:
            y--;
            break;
        case 0x48:
            x--;
            break;
        case 0x4D:
            y++;
            break;
        case 0x50:
            x++;
            break;
        }

        if (x<0)x = MAXIMUS - 1;//如果光标位置越界则移动到对侧
        if (y<0)y = MAXIMUS - 1;
        if (x >= MAXIMUS)x = 0;
        if (y >= MAXIMUS)y = 0;

        if (MyStruct_0[chess_num].ChessBoard[x][y] != '*'&&MyStruct_0[chess_num].ChessBoard[x][y] != 'o')
            MyStruct_0[chess_num].ChessBoard[x][y] = '+';
    }

    system("cls");
    DrawBoard();//打印棋盘
    printf("当前对局数：%d\n", count);
    printf("稍等...\n");
    Sleep(100);
}

这里是主要的操作函数。
input = getch();//等待键盘按下一个字符 if (input == 27)//如果是ESC则退出程序 { exit(0); }
这个代码实现了对于键盘输入的类型转换，inpu为int型
else if (char(input) == 'c') { MyStruct_0[chess_num].ChessBoard[x][y] = ' ', move_x = x, move_y = y; }
这里提供了悔一步棋的操作，很简单，就只是将棋子变成’ ‘即可。
else if (char(input) == 'w') { chess_num_0++; chess_num++; }
chess_num_0：界面显示当前棋盘数
chess_num：实际棋盘数组的数值大小
`else if (input == 0x20)//如果是空格则开始走子
{
if (count % 2 == 0)
MyStruct_0[chess_num].ChessBoard[x][y] = ‘o’, move_x = x, move_y = y;
else
MyStruct_0[chess_num].ChessBoard[x][y] = ‘*’, move_x = x, move_y = y;
```
count += 1;
```
}`
如果输入空格则会将当前的光标坐标（x，y）依照当前局数奇偶来觉得是’o’还是’*’
执行完赋值操作后，局数加一

`else if (input == 0xE0)//如果按下的是方向键，会填充两次输入，第一次为0xE0表示按下的是控制键
{
if (MyStruct_0[chess_num].ChessBoard[x][y] != ‘*’&&MyStruct_0[chess_num].ChessBoard[x][y] != ‘o’)
MyStruct_0[chess_num].ChessBoard[x][y] = ’ ‘;
input = getch();//获得第二次输入信息

switch (input)//判断方向键方向并移动光标位置
{
case 0x4B:
    y--;
    break;
case 0x48:
    x--;
    break;
case 0x4D:
    y++;
    break;
case 0x50:
    x++;
    break;
}

if (x<0)x = MAXIMUS - 1;//如果光标位置越界则移动到对侧
if (y<0)y = MAXIMUS - 1;
if (x >= MAXIMUS)x = 0;
if (y >= MAXIMUS)y = 0;

if (MyStruct_0[chess_num].ChessBoard[x][y] != '*'&&MyStruct_0[chess_num].ChessBoard[x][y] != 'o')
    MyStruct_0[chess_num].ChessBoard[x][y] = '+';

当是方向键的时候，需要将’+’光标赋值给当前棋盘，并且将原来的位置的字符赋值为’ ‘
没进行一次方向键操作，便需要对于x和y值进行变动
当然还有超越棋盘边界的情况

if (x<0)x = MAXIMUS - 1;//如果光标位置越界则移动到对侧
        if (y<0)y = MAXIMUS - 1;
        if (x >= MAXIMUS)x = 0;
        if (y >= MAXIMUS)y = 0;

这段代码便解决了这个问题

int main()
{
    system("title 五子棋(方框版) — J.m制作");//设置标题
    system("mode con cols=60 lines=40");//设置窗口大小
    system("color F0");//设置颜色
    Initialize();

    while (true)
    {
        if (Win_Or_Not() == 1)
        {
            system("cls");
            DrawBoard();
            printf("游戏结果： o Win\n");
            system("pause");
        }
        if (Win_Or_Not() == 2)
        {
            system("cls");
            DrawBoard();
            printf("游戏结果: * Win\n");
            system("pause");
        }
        if (Win_Or_Not() == 3)
        {
            system("cls");
            DrawBoard();
            printf("游戏结果: 平局\n");
            system("pause");
        }
        RunGame();
    }

    return 0;
}

这里是主函数，需要注意的是这个程序永远不会退出，即使胜负已定。因为考虑到需要玩家查看当前棋盘状态，所以便没有设置结束。

本文链接：https://blog.csdn.net/weixin_39541632/article/details/77781882

原作者删帖不实内容删帖广告或垃圾文章投诉

智能推荐

js-选项卡原理_选项卡js原理-程序员宅基地

文章浏览阅读90次。【代码】js-选项卡原理。_选项卡js原理

设计模式-原型模式（Prototype）-程序员宅基地

文章浏览阅读67次。原型模式是一种对象创建型模式，它采用复制原型对象的方法来创建对象的实例。它创建的实例，具有与原型一样的数据结构和值分为深度克隆和浅度克隆。浅度克隆：克隆对象的值类型（基本数据类型），克隆引用类型的地址；深度克隆：克隆对象的值类型，引用类型的对象也复制一份副本。UML图：具体代码：浅度复制：import java.util.List;/*..._prototype 设计模式

个性化政府云的探索-程序员宅基地

文章浏览阅读59次。入选国内首批云计算服务创新发展试点城市的北京、上海、深圳、杭州和无锡起到了很好的示范作用，不仅促进了当地产业的升级换代，而且为国内其他城市发展云计算产业提供了很好的借鉴。据了解，目前国内至少有20个城市确定将云计算作为重点发展的产业。这势必会形成新一轮的云计算基础设施建设的**。由于云计算基础设施建设具有投资规模大，运维成本高，投资回收周期长，地域辐射性强等诸多特点，各地在建...

STM32问题集之BOOT0和BOOT1的作用_stm32boot0和boot1作用-程序员宅基地

文章浏览阅读9.4k次，点赞2次，收藏20次。一、功能及目的在每个STM32的芯片上都有两个管脚BOOT0和BOOT1，这两个管脚在芯片复位时的电平状态决定了芯片复位后从哪个区域开始执行程序。BOOT1=x BOOT0=0 // 从用户闪存启动，这是正常的工作模式。BOOT1=0 BOOT0=1 // 从系统存储器启动，这种模式启动的程序_stm32boot0和boot1作用

C语言函数递归调用-程序员宅基地

文章浏览阅读3.4k次，点赞2次，收藏22次。C语言函数递归调用_c语言函数递归调用

明日方舟抽卡模拟器wiki_明日方舟bilibili服-明日方舟bilibili服下载-程序员宅基地

文章浏览阅读410次。明日方舟bilibili服是一款天灾驾到战斗热血的创新二次元废土风塔防手游，精妙的二次元纸片人设计，为宅友们源源不断更新超多的纸片人老婆老公们，玩家将扮演废土正义一方“罗德岛”中的指挥官，与你身边的感染者们并肩作战。与同类塔防手游与众不同的几点，首先你可以在这抽卡轻松获得稀有，同时也可以在战斗体系和敌军走位机制看到不同。明日方舟bilibili服设定：1、起因不明并四处肆虐的天灾，席卷过的土地上出..._明日方舟抽卡模拟器

随便推点

Maven上传Jar到私服报错：ReasonPhrase: Repository version policy: SNAPSHOT does not allow version: xxx_repository version policy snapshot does not all-程序员宅基地

文章浏览阅读437次。Maven上传Jar到私服报错：ReasonPhrase: Repository version policy: SNAPSHOT does not allow version: xxx_repository version policy snapshot does not all

斐波那契数列、素数、质数和猴子吃桃问题_斐波那契日-程序员宅基地

文章浏览阅读1.2k次。斐波那契数列（Fibonacci Sequence）是由如下形式的一系列数字组成的：0, 1, 1, 2, 3, 5, 8, 13, 21, 34, …上述数字序列中反映出来的规律，就是下一个数字是该数字前面两个紧邻数字的和，具体如下所示：示例：比如上述斐波那契数列中的最后两个数，可以推导出34后面的数为21+34=55下面是一个更长一些的斐波那契数列：0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584,_斐波那契日

PHP必会面试题_//该层循环用来控制每轮冒出一个数需要比较的次数-程序员宅基地

文章浏览阅读363次。PHP必会面试题1. 基础篇1. 用 PHP 打印出前一天的时间格式是 2017-12-28 22:21:21？ //>>1.当前时间减去一天的时间，然后再格式化echo date('Y-m-d H:i:s',time()-3600*24);//>>2.使用strtotime，可以将任何字符串时间转换成时间戳，仅针对英文echo date('Y-m-d H:i:s',str..._//该层循环用来控制每轮冒出一个数需要比较的次数

windows用mingw(g++)编译opencv，opencv_contrib，并install安装_opencv mingw contrib-程序员宅基地

文章浏览阅读1.3k次，点赞26次，收藏26次。windows下用mingw编译opencv貌似不支持cuda，选cuda会报错，我无法解决，所以没选cuda，下面两种编译方式支持。打开cmake gui程序，在下面两个框中分别输入opencv的源文件和编译目录，build-mingw为你创建的目录，可自定义命名。1、如果已经安装Qt，则Qt自带mingw编译器，从Qt安装目录找到编译器所在目录即可。1、如果已经安装Qt，则Qt自带cmake，从Qt安装目录找到cmake所在目录即可。2、若未安装Qt，则安装Mingw即可，参考我的另外一篇文章。_opencv mingw contrib

5个高质量简历模板网站，免费、免费、免费_hoso模板官网-程序员宅基地

文章浏览阅读10w+次，点赞42次，收藏309次。今天给大家推荐5个好用且免费的简历模板网站，简洁美观，非常值得收藏！1、菜鸟图库https://www.sucai999.com/search/word/0_242_0.html?v=NTYxMjky网站主要以设计类素材为主，办公类素材也很多，简历模板大部个偏简约风，各种版式都有，而且经常会更新。最重要的是全部都能免费下载。2、个人简历网https://www.gerenjianli.com/moban/这是一个专门提供简历模板的网站，里面有超多模板个类，找起来非常方便，风格也很多样，无须注册就能免费下载，_hoso模板官网

通过 TikTok 联盟提高销售额的 6 个步骤_tiktok联盟-程序员宅基地

文章浏览阅读142次。你听说过吗？该计划可让您以推广您的产品并在成功销售时支付佣金。它提供了新的营销渠道，使您的产品呈现在更广泛的受众面前并提高品牌知名度。此外，TikTok Shop联盟可以是一种经济高效的产品或服务营销方式。您只需在有人购买时付费，因此不存在在无效广告上浪费金钱的风险。这些诱人的好处是否足以让您想要开始您的TikTok Shop联盟活动？如果是这样，本指南适合您。_tiktok联盟