【C语言】五子棋（c语言实现）

news2025/1/6 19:24:05

这里写目录标题

  • 最终效果
  • 菜单打印函数
  • 棋盘的初始化和打印
  • 人人对战
    • 落子判空函数
    • 悔棋函数
    • 判胜负函数
    • 人人对战
  • 人机对战
    • 一是将直接调用rand生成随机值，这就不可控
    • 二是根据棋子赢面来判断哪里落子最好
  • 如果选择退出程序直接exit就行
  • 主函数调用逻辑
  • 源代码

在这里插入图片描述

最终效果

五子棋c语言实现

菜单打印函数

使用这个函数来接收用户选择的模式，并通过返回值返回。
逻辑是使用一个死循环来打印，根据玩家输入的数来判断进入什么模式，输入错误数字就不出循环，正确就出循环。

int menu()
{
    int choice = -1;
    while (1)
    {
        printf("----------------欢迎使用五子棋------------------------\n");
        printf("-                 请选择模式                         -\n");
        printf("-                    1.人-人对战游戏                 -\n");
        printf("-                    2.人-机对战游戏                 -\n");
        printf("-                    0.退出游戏                      -\n");
        printf("------------------------------------------------------\n");
        printf("------------------------------------------------------\n");
        scanf("%d", &choice);
        if (choice > 4 || choice < 0)
            printf("错误输入");
        else
            break;
    }
    return choice;
}

棋盘的初始化和打印

在这个函数中将表示棋盘的二维数组初始化为空状态，并通过棋盘数组的只来打印棋盘。打印棋盘时用到的符号：┏ ┳ ┓┣ ╋ ┫┗ ┻ ┛。要注意有些地方添加━和空格来控制打印的棋盘是正确的。
里面每一次打印都调用draw_chessman这个函数，在这个函数中将根据数组值来判断如何打印。

//绘制棋子
void draw_chessman(int type, char* tableline) {
    if (type == WHITE)
        printf(" ●");
    if (type == BLACK)
        printf(" ○");
    if (type == NO)
        printf("%s", tableline);
}

打印棋盘的逻辑就是因为没能设置光标坐标那就只有一行一行打印然后根据边界行列值来判断。
如果要看如何打印改变光标可以参考这篇文章win32 API

void initMap(int map[N + 1][N + 1])
{
    //第一行和第一列显示数字
    for (int i = 0; i < N + 1; i++)
    {
        map[0][i] = i;
        map[i][0] = i;
        if (i >= 10)
        {
            map[0][i] = i - 10;
            map[i][0] = i - 10;
        }

    }

    for (int i = 0; i < N + 1; i++)
    {

        //打印第一行数字
        if (i == 0)
        {
            for (int j = 0; j < N + 1; j++)
            {
                printf("%-2d", map[0][j]);
            }
            printf("\n");
        }
        //打印第一行棋盘
        else if (i == 1)
        {
            for (int j = 0; j < N + 1; j++)
            {
                if (j == 0)
                    printf("%d", map[i][j]);
                else if (j == 1)
                    draw_chessman(map[i][j], " ┏");
                else if (j == N)
                    draw_chessman(map[i][j], "━┓");
                else
                    draw_chessman(map[i][j], "━┳");

            }
            printf("\n");

        }
        //打印最后一行
        else if (i == N)
        {
            for (int j = 0; j < N + 1; j++)
            {
                if (j == 0)
                    printf("%d", map[i][j]);
                else if (j == 1)
                    draw_chessman(map[i][j], " ┗");
                else if (j == N)
                    draw_chessman(map[i][j], "━┛");
                else
                    draw_chessman(map[i][j], "━┻");
            }
            printf("\n");
        }
        else
        {
            for (int j = 0; j < N + 1; j++)
            {

                if (j == 0)
                    printf("%d", map[i][j]);
                else if (j == 1)
                    draw_chessman(map[i][j], " ┣");
                else if (j == N)
                    draw_chessman(map[i][j], "━┫");
                else
                    draw_chessman(map[i][j], "━╋");
            }
            printf("\n");
        }
    }
}

人人对战

人人对战逻辑中就是先让黑方下棋，输入坐标，输入错误就再次输入（死循环实现），将该坐标的二维数组值变为黑，然后让其选择悔不悔棋，我实现的是只要1是悔棋其他数字就是不悔棋。执行完不悔棋后就判断是否胜利，如果胜就跳出选择是否重来一局，如果没胜就白棋下执行相同逻辑。

落子判空函数

在这个函数中判断坐标代表的二维数组值是不是空，不是就重新输入坐标。

void judgeEmpty(int map[][N + 1], int x, int y, int goal)
{
    while (1)
    {
        if (map[x][y] != NO)
        {
            printf("已有棋子，重新输入\n");
            scanf("%d%d", &x, &y);
        }
        else
        {
            map[x][y] = goal;
            initMap(map);
            break;
        }
    }
}

悔棋函数

该函数里面就是根据用户选择，如果悔棋然后将刚才的地方的数组值变回空。

int retract(int map[][N + 1], int x, int y)
{
    int choice = -1;
    printf("是否悔棋：是1\n");
    scanf("%d", &choice);
    if (choice == 1)
    {
        map[x][y] = NO;
        initMap(map);
    }
    return choice;
}

执行完不悔棋后就判断是否胜利

判胜负函数

这个函数就是将下的这个棋子的横竖斜方向判胜负。（没有判断和棋情况），如果要判断就是二维数组全不为空状态，使用遍历判断就行。

int judgeWin(int map[][N + 1], int x, int y)
{
    for (int i = 1; i < N + 1; i++)
    {
        for (int j = 1; j < N + 1; j++)
        {
            if (j < N + 1 - 4 && (map[i][j] == BLACK || map[i][j] == WHITE))//横
            {
                if (map[i][j] == map[i][j + 1]
                    && map[i][j + 1] == map[i][j + 2]
                    && map[i][j + 2] == map[i][j + 3]
                    && map[i][j + 3] == map[i][j + 4])
                    return map[i][j];
            }
            if (i < N + 1 - 4 && (map[i][j] == BLACK || map[i][j] == WHITE))//竖
            {
                if (map[i][j] == map[i + 1][j]
                    && map[i + 1][j] == map[i + 2][j]
                    && map[i + 2][j] == map[i + 3][j]
                    && map[i + 3][j] == map[i + 4][j])
                    return map[i][j];
            }
            if (i < N + 1 - 4 && j < N + 1 - 4 && (map[i][j] == BLACK || map[i][j] == WHITE))//右下_
            {
                if (map[i][j] == map[i + 1][j + 1]
                    && map[i + 1][j + 1] == map[i + 2][j + 2]
                    && map[i + 2][j + 2] == map[i + 3][j + 3]
                    && map[i + 3][j + 3] == map[i + 4][j + 4])
                    return map[i][j];
            }
            if (i > 4 && j > 4 && (map[i][j] == BLACK || map[i][j] == WHITE))//右上
            {
                if (map[i][j] == map[i - 1][j - 1]
                    && map[i - 1][j - 1] == map[i - 2][j - 2]
                    && map[i - 2][j - 2] == map[i - 3][j - 3]
                    && map[i - 3][j - 3] == map[i - 4][j - 4])
                    return map[i][j];
            }
        }
    }
    return NO;
}

人人对战

void peopleFight(int map[][N + 1])
{
    printf("--------人-人对战---------------\n");
    initMap(map);
    while (1)
    {
        int x = -1;
        int y = -1;
    black:
        while (1)
        {
            printf("黑方落子\n");
            printf("请输入要落下的坐标现在棋盘为%d*%d\n", N, N);
            scanf("%d%d", &x, &y);
            if (x < 0 || x > N || y < 0 || y > N)
                printf("错误输入\n");
            else
                break;
        }
        judgeEmpty(map, x, y, BLACK);

        if (retract(map, x, y) == 1)
            goto black;
        //判断胜利
        int ret = judgeWin(map, x, y);
        if (ret == BLACK)
        {
            printf("黑方获胜\n");
            return;
        }
        else if (ret == WHITE)
        {
            printf("白方获胜\n");
            return;
        }
    white:
        while (1)
        {
            printf("白方落子\n");
            printf("请输入要落下的坐标现在棋盘为%d*%d\n", N, N);
            scanf("%d%d", &x, &y);
            if (x < 0 || x > N || y < 0 || y > N)
                printf("错误输入\n");
            else
                break;
        }
        judgeEmpty(map, x, y, WHITE);
        if (retract(map, x, y) == 1)
            goto white;
        //判断胜利
        ret = judgeWin(map, x, y);
        if (ret == BLACK)
        {
            printf("黑方获胜\n");
            return;
        }
        else if (ret == WHITE)
        {
            printf("白方获胜\n");
            return;
        }

    }
}

人机对战

在这个函数中用户选择落子方，然后执行逻辑与人人对战一样。
但是电脑生成棋子提供两种选择：

一是将直接调用rand生成随机值，这就不可控

方法一这样写对棋子的位置生成是很不可控的，会让机器随机乱落子。

void machine(int map[][N + 1])
{
    printf("--------人-机对战---------------\n");
    srand(time(NULL));
    int choice = -1;
    printf("请输入你执黑棋还是白棋，黑1，白2\n");
    scanf("%d", &choice);
    if (choice == 1)
    {
        while (1)
        {
            int x = -1;
            int y = -1;
        black:
            while (1)
            {
                printf("黑方落子\n");
                printf("请输入要落下的坐标现在棋盘为%d*%d\n", N, N);
                scanf("%d%d", &x, &y);
                if (x < 0 || x > N || y < 0 || y > N)
                    printf("错误输入\n");
                else
                    break;
            }
            judgeEmpty(map, x, y, BLACK);
            //判断胜利
            int ret = judgeWin(map, x, y);
            if (ret == BLACK)
            {
                printf("黑方获胜\n");
                return;
            }
            else if (ret == WHITE)
            {
                printf("白方获胜\n");
                return;
            }
            if (retract(map, x, y) == 1)
                goto black;
        next:
            x = rand() % 15 + 1;
            y = rand() % 15 + 1;
            if (map[x][y] != NO)
                goto next;
            judgeEmpty(map, x, y, WHITE);
            //判断胜利
            ret = judgeWin(map, x, y);
            if (ret == BLACK)
            {
                printf("黑方获胜\n");
                return;
            }
            else if (ret == WHITE)
            {
                printf("白方获胜\n");
                return;
            }
        }
    }
    else if (choice == 2)
    {
        while (1)
        {
            int x = -1;
            int y = -1;
        next2:
            x = rand() % 15 + 1;
            y = rand() % 15 + 1;
            if (map[x][y] != NO)
                goto next2;
            judgeEmpty(map, x, y, BLACK);
            //判断胜利
            int ret = judgeWin(map, x, y);
            if (ret == BLACK)
            {
                printf("黑方获胜\n");
                return;
            }
            else if (ret == WHITE)
            {
                printf("白方获胜\n");
                return;
            }
        white:
            while (1)
            {
                printf("白方落子\n");
                printf("请输入要落下的坐标现在棋盘为%d*%d\n", N, N);
                scanf("%d%d", &x, &y);
                if (x < 0 || x > N || y < 0 || y > N)
                    printf("错误输入\n");
                else
                    break;
            }
            judgeEmpty(map, x, y, WHITE);
            //判断胜利
            ret = judgeWin(map, x, y);
            if (ret == BLACK)
            {
                printf("黑方获胜\n");
                return;
            }
            else if (ret == WHITE)
            {
                printf("白方获胜\n");
                return;
            }
            if (retract(map, x, y) == 1)
                goto white;

        }
    }

}

二是根据棋子赢面来判断哪里落子最好

这样实现就会让机器落子一直是去围堵你的棋子，虽然还是很垃圾，但是比方法一好多了。

void AIjudge(int color, int map[N+1][N+1])
{
    int num = 1, left = 0, right = 0;
    int n, m, score = 0, max = 0;
    int dx, dy;
    for (int i = 1; i < N+1; i++)
    {
        for (int j = 1; j < N+1; j++)
        {
            score = 0;
            if (map[i][j] != 0)
                continue;
            else
            {
                dx = 1, dy = 0, n = i, m = j;
                while (1)//水平向右
                {
                    n += dx, m += dy;
                    if (map[n][m] == 0)
                    {
                        right = 0; break;
                    }
                    else if (map[n][m] != color || n > 15)
                    {
                        right++; break;
                    }
                    else if (num < 5) { num++; }
                }
                dx = -1, dy = 0;
                while (1) {//水平向左
                    n += dx; m += dy;
                    if (map[n][m] == 0) { left = 0; break; }
                    else if (map[n][m] != color || n < 1) { left++; break; }
                    else if (num < 5) { num++; }
                }
                score += Data(num, right + left);//用data来算分数，并用score来记录
                //  |方向
                num = 1; right = 0, left = 0;//每一次改变方向要重置这些变量
                dx = 0; dy = -1; n = i; m = j;
                //向上
                while (1) {
                    n += dx; m += dy;
                    if (map[n][m] == 0) { left = 0; break; }
                    else if (map[n][m] != color || m < 1) { left++; break; }
                    else if (num < 5) { num++; }
                }
                //向下
                dx = 0; dy = 1; n = i; m = j;
                while (1) {
                    n += dx; m += dy;
                    if (map[n][m] == 0) { right = 0; break; }
                    else if (map[n][m] != color || m > 15) { right++; break; }
                    else if (num < 5) { num++; }
                }
                score += Data(num, right + left);
                //  \方向
                num = 1; right = 0, left = 0;
                dx = 1; dy = 1; n = i; m = j;
                //向右下
                while (1) {
                    n += dx; m += dy;
                    if (map[n][m] == 0) { right = 0; break; }
                    else if (map[n][m] != color || m > 15 || n > 15) { right++; break; }
                    else if (num < 5) { num++; }
                }
                //向左上
                dx = -1; dy = -1; n = i; m = j;
                while (1) {
                    n += dx; m += dy;
                    if (n > 0 && m > 0 && map[n][m] == 0) { left = 0; break; }
                    else if ((n > 0 && m > 0 && map[n][m] != color) || m < 1 || n < 1) { left++; break; }
                    else if (num < 5) { num++; }
                }
                score += Data(num, right + left);
                //  /方向`
                num = 1; right = 0, left = 0;
                dx = 1; dy = -1; n = i; m = j;
                //向右上
                while (1) {
                    n += dx; m += dy;
                    if (map[n][m] == 0) { right = 0; break; }
                    else if (map[n][m] != color || n > 15 || m < 1) { right++; break; }
                    else if (num < 5) { num++; }
                }
                //向左下
                dx = -1; dy = 1; n = i; m = j;
                while (1) {
                    n += dx; m += dy;
                    if (n > 0 && m > 0 && map[n][m] == 0) { left = 0; break; }
                    else if ((n > 0 && m > 0 && map[n][m] != color) || n < 1 || m > 15) { left++; break; }
                    else if (num < 5) { num++; }
                }
                score += Data(num, right + left);
                if (score > max) {//每一次用max保存分数，下一次比较，最后找出最大值
                    max = score;
                    position[0] = i;//用来保存每一次的位置和分数
                    position[1] = j;
                    position[2] = score;
                }
            }
        }
    }
}
int Data(int num, int count)
{
    switch (num)
    {
    case 1:	if (count == 0)//活一:表示在该处落子，就只有这一个棋子，两边都没有阻挡（边界或对方的棋子）优势较大
        return 2;
          else if (count == 1)//冲一：表示在该处落子，就只有这一个棋子，两边有一种阻挡（边界或对方的棋子）优势较小
        return 1;
          else return 0;
        break;
    case 2:
        if (count == 0)//活二；接下来都同理活一和冲一
            return 20;
        else if (count == 1)//冲二
            return 10;
        else return 0;
        break;
    case 3:
        if (count == 0)//活三
            return 300;
        else if (count == 1)//冲三
            return 50;
        else return 0;
        break;
    case 4:
        if (count == 0)//活四
            return 4000;
        else if (count == 1)//冲四
            return 1000;
        else return 0;
        break;
    case 5://五
        return 5000;
        break;
    default:
        return 0;
        break;
    }
}
void machine(int map[][N + 1])
{
    printf("--------人-机对战---------------\n");
    int choice = -1;
    do {
        printf("请输入你执黑棋还是白棋，黑1，白2\n");
        scanf("%d", &choice);
    } while (choice != 1 && choice != 2);
    initMap(map);
    if (choice == 1)
    {
        while (1)
        {
            int x = -1;
            int y = -1;
        black:
            while (1)
            {
                printf("黑方落子\n");
                printf("现在棋盘为%d*%d请输入要落下的坐标x y\n", N, N);
                scanf("%d%d", &x, &y);
                if (x < 0 || x > N || y < 0 || y > N)
                    printf("错误输入\n");
                else
                    break;
            }
            judgeEmpty(map, x, y, BLACK);
            if (retract(map, x, y))
            {
                map[x][y] = 0;
                initMap(map);
                goto black;
            }
            int ret = judgeWin(map, x, y);
            if (ret == BLACK)       //判断胜利
                break;
           

                int old_max = 0, new_max = 0, n = 0, m = 0;
                int AIx = -1, AIy = -1;
                AIjudge(1, map);//判断黑子的优势位置
                old_max = position[2];//保存该位置分数
                AIx = position[0]; AIy = position[1];//保存该位置的坐标，注意行列和xy轴的对应关系
                position[0] = 0, position[1] = 0, position[2] = 0;
                AIjudge(-1, map);//判断白子的优势位置
                new_max = position[2];//保存分数
                if (new_max >= old_max) //判断哪个位置的分数大，从而判断是堵截还是进攻
                {
                    AIx = position[0]; AIy = position[1];
                }
            judgeEmpty(map, AIx, AIy, WHITE);
            ret = judgeWin(map, x, y);
            if (ret == WHITE)       //判断胜利
                break;
        }
    }
    else if (choice == 2)
    {
        while (1)
        {
            int x = -1, y = -1;
            int old_max = 0, new_max = 0, n = 0, m = 0;
            int AIx = -1, AIy = -1;
            AIjudge(1, map);//判断黑子的优势位置
            old_max = position[2];//保存该位置分数
            AIx = position[0]; AIy = position[1];//保存该位置的坐标，注意行列和xy轴的对应关系
            position[0] = 0, position[1] = 0, position[2] = 0;
            AIjudge(-1, map);//判断白子的优势位置
            new_max = position[2];//保存分数
            if (new_max >= old_max) //判断哪个位置的分数大，从而判断是堵截还是进攻
            {
                AIx = position[0]; AIy = position[1];
            }
            judgeEmpty(map, AIx, AIy, BLACK);
            int ret = judgeWin(map, x, y);
            if (ret == BLACK)       //判断胜利 
                break;
        white:
            while (1)
            {
                printf("白方落子\n");
                printf("现在棋盘为%d*%d请输入要落下的坐标x y\n", N, N);
                scanf("%d,%d", &x, &y);
                if (x < 0 || x > N || y < 0 || y > N)
                    printf("错误输入\n");
                else
                    break;
            }
            judgeEmpty(map, x, y, WHITE);
            if (retract(map, x, y))
            {
                map[x][y] = 0;
                initMap(map);
                goto white;
            }
            ret = judgeWin(map, x, y);
            if (ret == WHITE)       //判断胜利
                break;
            
        }
    }

}

如果选择退出程序直接exit就行

主函数调用逻辑

用死循环调用，然后根据menu返回值通过switch-case来调用相应模式函数，最后在让用户选择是否再来一局，如果再来一局就不出循环，不再来就出循环。

int main()
{
    while (1)
    {
        int map[N + 1][N + 1] = { 0 };
        int choice = menu();
        switch (choice)
        {
        case 1:
            //调用人人对打
            peopleFight(map);
            break;
        case 2:
            //调用人机对打
            machine(map);
            break;
        case 0:
            printf("退出成功\n");
            exit(0);
            break;
        }
        int a = 0;
        printf("是否再来一盘：是1，不是0\n");
        scanf("%d", &a);
        if (a == 0)
            break;
    }
    return 0;
}

源代码

源码呈上，为方便复制写在同一个文件之下，可以多文件进行。

# define _CRT_SECURE_NO_WARNINGS 1；
#include<stdio.h>
#include <stdlib.h>
#include<time.h>
#define N 15 //表示棋盘的行列
#define NO 0 //表示没下子的状态
#define BLACK 1
#define WHITE -1
//棋盘初始化函数
void initMap(int map[N + 1][N + 1]);
//落子函数
void judgeEmpty(int map[][N + 1], int x, int y, int goal);
//人人对打
void peopleFight(int map[][N + 1]);
//判断胜利
int judgeWin(int map[][N + 1], int x, int y);
//悔棋
int retract(int map[][N + 1], int x, int y);
//人机对打
void machine(int map[][N + 1]);
//打印菜单并返回选择的模式
int menu();
void AIjudge(int color, int map[N + 1][N + 1]);
int Data(int num, int count);
int position[3];

int main()
{
    while (1)
    {
        int map[N + 1][N + 1] = { 0 };
        int choice = menu();
        switch (choice)
        {
        case 1:
            //调用人人对打
            peopleFight(map);
            break;
        case 2:
            //调用人机对打
            machine(map);
            break;
        case 0:
            printf("退出成功\n");
            exit(0);
            break;
        }
        int a = 0;
        printf("是否再来一盘：是1，不是0\n");
        scanf("%d", &a);
        if (a == 0)
            break;
    }
    return 0;
}
int menu()
{
    int choice = -1;
    while (1)
    {
        printf("----------------欢迎使用五子棋------------------------\n");
        printf("-                 请选择模式                         -\n");
        printf("-                    1.人-人对战游戏                 -\n");
        printf("-                    2.人-机对战游戏                 -\n");
        printf("-                    0.退出游戏                      -\n");
        printf("------------------------------------------------------\n");
        printf("------------------------------------------------------\n");
        scanf("%d", &choice);
        if (choice > 4 || choice < 0)
            printf("错误输入");
        else
            break;
    }
    return choice;
}

void judgeEmpty(int map[][N + 1], int x, int y, int goal)
{
    while (1)
    {
        if (map[x][y] != NO)
        {
            printf("已有棋子，重新输入\n");
            scanf("%d%d", &x, &y);
        }
        else
        {
            map[x][y] = goal;
            initMap(map);
            break;
        }
    }
}

int judgeWin(int map[][N + 1], int x, int y)
{
    for (int i = 1; i < N + 1; i++)
    {
        for (int j = 1; j < N + 1; j++)
        {
            if (j < N + 1 - 4 && (map[i][j] == BLACK || map[i][j] == WHITE))//横
            {
                if (map[i][j] == map[i][j + 1]
                    && map[i][j + 1] == map[i][j + 2]
                    && map[i][j + 2] == map[i][j + 3]
                    && map[i][j + 3] == map[i][j + 4])
                    return map[i][j];
            }
            if (i < N + 1 - 4 && (map[i][j] == BLACK || map[i][j] == WHITE))//竖
            {
                if (map[i][j] == map[i + 1][j]
                    && map[i + 1][j] == map[i + 2][j]
                    && map[i + 2][j] == map[i + 3][j]
                    && map[i + 3][j] == map[i + 4][j])
                    return map[i][j];
            }
            if (i < N + 1 - 4 && j < N + 1 - 4 && (map[i][j] == BLACK || map[i][j] == WHITE))//右下_
            {
                if (map[i][j] == map[i + 1][j + 1]
                    && map[i + 1][j + 1] == map[i + 2][j + 2]
                    && map[i + 2][j + 2] == map[i + 3][j + 3]
                    && map[i + 3][j + 3] == map[i + 4][j + 4])
                    return map[i][j];
            }
            if (i > 4 && j > 4 && (map[i][j] == BLACK || map[i][j] == WHITE))//右上
            {
                if (map[i][j] == map[i - 1][j - 1]
                    && map[i - 1][j - 1] == map[i - 2][j - 2]
                    && map[i - 2][j - 2] == map[i - 3][j - 3]
                    && map[i - 3][j - 3] == map[i - 4][j - 4])
                    return map[i][j];
            }
        }
    }
    return NO;
}

//绘制棋子
void draw_chessman(int type, char* tableline) {
    if (type == WHITE)
        printf(" ●");
    if (type == BLACK)
        printf(" ○");
    if (type == NO)
        printf("%s", tableline);
}

void initMap(int map[N + 1][N + 1])
{
    //第一行和第一列显示数字
    for (int i = 0; i < N + 1; i++)
    {
        map[0][i] = i;
        map[i][0] = i;
        if (i >= 10)
        {
            map[0][i] = i - 10;
            map[i][0] = i - 10;
        }

    }

    for (int i = 0; i < N + 1; i++)
    {

        //打印第一行数字
        if (i == 0)
        {
            for (int j = 0; j < N + 1; j++)
            {
                printf("%-2d", map[0][j]);
            }
            printf("\n");
        }
        //打印第一行棋盘
        else if (i == 1)
        {
            for (int j = 0; j < N + 1; j++)
            {
                if (j == 0)
                    printf("%d", map[i][j]);
                else if (j == 1)
                    draw_chessman(map[i][j], " ┏");
                else if (j == N)
                    draw_chessman(map[i][j], "━┓");
                else
                    draw_chessman(map[i][j], "━┳");

            }
            printf("\n");

        }
        //打印最后一行
        else if (i == N)
        {
            for (int j = 0; j < N + 1; j++)
            {
                if (j == 0)
                    printf("%d", map[i][j]);
                else if (j == 1)
                    draw_chessman(map[i][j], " ┗");
                else if (j == N)
                    draw_chessman(map[i][j], "━┛");
                else
                    draw_chessman(map[i][j], "━┻");
            }
            printf("\n");
        }
        else
        {
            for (int j = 0; j < N + 1; j++)
            {

                if (j == 0)
                    printf("%d", map[i][j]);
                else if (j == 1)
                    draw_chessman(map[i][j], " ┣");
                else if (j == N)
                    draw_chessman(map[i][j], "━┫");
                else
                    draw_chessman(map[i][j], "━╋");
            }
            printf("\n");
        }
    }
}

//void machine(int map[][N + 1])
//{
//    printf("--------人-机对战---------------\n");
//    srand(time(NULL));
//    int choice = -1;
//    printf("请输入你执黑棋还是白棋，黑1，白2\n");
//    scanf("%d", &choice);
//    if (choice == 1)
//    {
//        while (1)
//        {
//            int x = -1;
//            int y = -1;
//        black:
//            while (1)
//            {
//                printf("黑方落子\n");
//                printf("请输入要落下的坐标现在棋盘为%d*%d\n", N, N);
//                scanf("%d%d", &x, &y);
//                if (x < 0 || x > N || y < 0 || y > N)
//                    printf("错误输入\n");
//                else
//                    break;
//            }
//            judgeEmpty(map, x, y, BLACK);
//            //判断胜利
//            int ret = judgeWin(map, x, y);
//            if (ret == BLACK)
//            {
//                printf("黑方获胜\n");
//                return;
//            }
//            else if (ret == WHITE)
//            {
//                printf("白方获胜\n");
//                return;
//            }
//            if (retract(map, x, y) == 1)
//                goto black;
//        next:
//            x = rand() % 15 + 1;
//            y = rand() % 15 + 1;
//            if (map[x][y] != NO)
//                goto next;
//            judgeEmpty(map, x, y, WHITE);
//            //判断胜利
//            ret = judgeWin(map, x, y);
//            if (ret == BLACK)
//            {
//                printf("黑方获胜\n");
//                return;
//            }
//            else if (ret == WHITE)
//            {
//                printf("白方获胜\n");
//                return;
//            }
//        }
//    }
//    else if (choice == 2)
//    {
//        while (1)
//        {
//            int x = -1;
//            int y = -1;
//        next2:
//            x = rand() % 15 + 1;
//            y = rand() % 15 + 1;
//            if (map[x][y] != NO)
//                goto next2;
//            judgeEmpty(map, x, y, BLACK);
//            //判断胜利
//            int ret = judgeWin(map, x, y);
//            if (ret == BLACK)
//            {
//                printf("黑方获胜\n");
//                return;
//            }
//            else if (ret == WHITE)
//            {
//                printf("白方获胜\n");
//                return;
//            }
//        white:
//            while (1)
//            {
//                printf("白方落子\n");
//                printf("请输入要落下的坐标现在棋盘为%d*%d\n", N, N);
//                scanf("%d%d", &x, &y);
//                if (x < 0 || x > N || y < 0 || y > N)
//                    printf("错误输入\n");
//                else
//                    break;
//            }
//            judgeEmpty(map, x, y, WHITE);
//            //判断胜利
//            ret = judgeWin(map, x, y);
//            if (ret == BLACK)
//            {
//                printf("黑方获胜\n");
//                return;
//            }
//            else if (ret == WHITE)
//            {
//                printf("白方获胜\n");
//                return;
//            }
//            if (retract(map, x, y) == 1)
//                goto white;
//
//        }
//    }
//
//}

void peopleFight(int map[][N + 1])
{
    printf("--------人-人对战---------------\n");
    initMap(map);
    while (1)
    {
        int x = -1;
        int y = -1;
    black:
        while (1)
        {
            printf("黑方落子\n");
            printf("请输入要落下的坐标现在棋盘为%d*%d\n", N, N);
            scanf("%d%d", &x, &y);
            if (x < 0 || x > N || y < 0 || y > N)
                printf("错误输入\n");
            else
                break;
        }
        judgeEmpty(map, x, y, BLACK);

        if (retract(map, x, y) == 1)
            goto black;
        //判断胜利
        int ret = judgeWin(map, x, y);
        if (ret == BLACK)
        {
            printf("黑方获胜\n");
            return;
        }
        else if (ret == WHITE)
        {
            printf("白方获胜\n");
            return;
        }
    white:
        while (1)
        {
            printf("白方落子\n");
            printf("请输入要落下的坐标现在棋盘为%d*%d\n", N, N);
            scanf("%d%d", &x, &y);
            if (x < 0 || x > N || y < 0 || y > N)
                printf("错误输入\n");
            else
                break;
        }
        judgeEmpty(map, x, y, WHITE);
        if (retract(map, x, y) == 1)
            goto white;
        //判断胜利
        ret = judgeWin(map, x, y);
        if (ret == BLACK)
        {
            printf("黑方获胜\n");
            return;
        }
        else if (ret == WHITE)
        {
            printf("白方获胜\n");
            return;
        }

    }
}

int retract(int map[][N + 1], int x, int y)
{
    int choice = -1;
    printf("是否悔棋：是1\n");
    scanf("%d", &choice);
    if (choice == 1)
    {
        map[x][y] = NO;
        initMap(map);
    }
    return choice;
}
void AIjudge(int color, int map[N+1][N+1])
{
    int num = 1, left = 0, right = 0;
    int n, m, score = 0, max = 0;
    int dx, dy;
    for (int i = 1; i < N+1; i++)
    {
        for (int j = 1; j < N+1; j++)
        {
            score = 0;
            if (map[i][j] != 0)
                continue;
            else
            {
                dx = 1, dy = 0, n = i, m = j;
                while (1)//水平向右
                {
                    n += dx, m += dy;
                    if (map[n][m] == 0)
                    {
                        right = 0; break;
                    }
                    else if (map[n][m] != color || n > 15)
                    {
                        right++; break;
                    }
                    else if (num < 5) { num++; }
                }
                dx = -1, dy = 0;
                while (1) {//水平向左
                    n += dx; m += dy;
                    if (map[n][m] == 0) { left = 0; break; }
                    else if (map[n][m] != color || n < 1) { left++; break; }
                    else if (num < 5) { num++; }
                }
                score += Data(num, right + left);//用data来算分数，并用score来记录
                //  |方向
                num = 1; right = 0, left = 0;//每一次改变方向要重置这些变量
                dx = 0; dy = -1; n = i; m = j;
                //向上
                while (1) {
                    n += dx; m += dy;
                    if (map[n][m] == 0) { left = 0; break; }
                    else if (map[n][m] != color || m < 1) { left++; break; }
                    else if (num < 5) { num++; }
                }
                //向下
                dx = 0; dy = 1; n = i; m = j;
                while (1) {
                    n += dx; m += dy;
                    if (map[n][m] == 0) { right = 0; break; }
                    else if (map[n][m] != color || m > 15) { right++; break; }
                    else if (num < 5) { num++; }
                }
                score += Data(num, right + left);
                //  \方向
                num = 1; right = 0, left = 0;
                dx = 1; dy = 1; n = i; m = j;
                //向右下
                while (1) {
                    n += dx; m += dy;
                    if (map[n][m] == 0) { right = 0; break; }
                    else if (map[n][m] != color || m > 15 || n > 15) { right++; break; }
                    else if (num < 5) { num++; }
                }
                //向左上
                dx = -1; dy = -1; n = i; m = j;
                while (1) {
                    n += dx; m += dy;
                    if (n > 0 && m > 0 && map[n][m] == 0) { left = 0; break; }
                    else if ((n > 0 && m > 0 && map[n][m] != color) || m < 1 || n < 1) { left++; break; }
                    else if (num < 5) { num++; }
                }
                score += Data(num, right + left);
                //  /方向`
                num = 1; right = 0, left = 0;
                dx = 1; dy = -1; n = i; m = j;
                //向右上
                while (1) {
                    n += dx; m += dy;
                    if (map[n][m] == 0) { right = 0; break; }
                    else if (map[n][m] != color || n > 15 || m < 1) { right++; break; }
                    else if (num < 5) { num++; }
                }
                //向左下
                dx = -1; dy = 1; n = i; m = j;
                while (1) {
                    n += dx; m += dy;
                    if (n > 0 && m > 0 && map[n][m] == 0) { left = 0; break; }
                    else if ((n > 0 && m > 0 && map[n][m] != color) || n < 1 || m > 15) { left++; break; }
                    else if (num < 5) { num++; }
                }
                score += Data(num, right + left);
                if (score > max) {//每一次用max保存分数，下一次比较，最后找出最大值
                    max = score;
                    position[0] = i;//用来保存每一次的位置和分数
                    position[1] = j;
                    position[2] = score;
                }
            }
        }
    }
}
int Data(int num, int count)
{
    switch (num)
    {
    case 1:	if (count == 0)//活一:表示在该处落子，就只有这一个棋子，两边都没有阻挡（边界或对方的棋子）优势较大
        return 2;
          else if (count == 1)//冲一：表示在该处落子，就只有这一个棋子，两边有一种阻挡（边界或对方的棋子）优势较小
        return 1;
          else return 0;
        break;
    case 2:
        if (count == 0)//活二；接下来都同理活一和冲一
            return 20;
        else if (count == 1)//冲二
            return 10;
        else return 0;
        break;
    case 3:
        if (count == 0)//活三
            return 300;
        else if (count == 1)//冲三
            return 50;
        else return 0;
        break;
    case 4:
        if (count == 0)//活四
            return 4000;
        else if (count == 1)//冲四
            return 1000;
        else return 0;
        break;
    case 5://五
        return 5000;
        break;
    default:
        return 0;
        break;
    }
}
void machine(int map[][N + 1])
{
    printf("--------人-机对战---------------\n");
    int choice = -1;
    do {
        printf("请输入你执黑棋还是白棋，黑1，白2\n");
        scanf("%d", &choice);
    } while (choice != 1 && choice != 2);
    initMap(map);
    if (choice == 1)
    {
        while (1)
        {
            int x = -1;
            int y = -1;
        black:
            while (1)
            {
                printf("黑方落子\n");
                printf("现在棋盘为%d*%d请输入要落下的坐标x y\n", N, N);
                scanf("%d%d", &x, &y);
                if (x < 0 || x > N || y < 0 || y > N)
                    printf("错误输入\n");
                else
                    break;
            }
            judgeEmpty(map, x, y, BLACK);
            if (retract(map, x, y))
            {
                map[x][y] = 0;
                initMap(map);
                goto black;
            }
            int ret = judgeWin(map, x, y);
            if (ret == BLACK)       //判断胜利
                break;
           

                int old_max = 0, new_max = 0, n = 0, m = 0;
                int AIx = -1, AIy = -1;
                AIjudge(1, map);//判断黑子的优势位置
                old_max = position[2];//保存该位置分数
                AIx = position[0]; AIy = position[1];//保存该位置的坐标，注意行列和xy轴的对应关系
                position[0] = 0, position[1] = 0, position[2] = 0;
                AIjudge(-1, map);//判断白子的优势位置
                new_max = position[2];//保存分数
                if (new_max >= old_max) //判断哪个位置的分数大，从而判断是堵截还是进攻
                {
                    AIx = position[0]; AIy = position[1];
                }
            judgeEmpty(map, AIx, AIy, WHITE);
            ret = judgeWin(map, x, y);
            if (ret == WHITE)       //判断胜利
                break;
        }
    }
    else if (choice == 2)
    {
        while (1)
        {
            int x = -1, y = -1;
            int old_max = 0, new_max = 0, n = 0, m = 0;
            int AIx = -1, AIy = -1;
            AIjudge(1, map);//判断黑子的优势位置
            old_max = position[2];//保存该位置分数
            AIx = position[0]; AIy = position[1];//保存该位置的坐标，注意行列和xy轴的对应关系
            position[0] = 0, position[1] = 0, position[2] = 0;
            AIjudge(-1, map);//判断白子的优势位置
            new_max = position[2];//保存分数
            if (new_max >= old_max) //判断哪个位置的分数大，从而判断是堵截还是进攻
            {
                AIx = position[0]; AIy = position[1];
            }
            judgeEmpty(map, AIx, AIy, BLACK);
            int ret = judgeWin(map, x, y);
            if (ret == BLACK)       //判断胜利 
                break;
        white:
            while (1)
            {
                printf("白方落子\n");
                printf("现在棋盘为%d*%d请输入要落下的坐标x y\n", N, N);
                scanf("%d,%d", &x, &y);
                if (x < 0 || x > N || y < 0 || y > N)
                    printf("错误输入\n");
                else
                    break;
            }
            judgeEmpty(map, x, y, WHITE);
            if (retract(map, x, y))
            {
                map[x][y] = 0;
                initMap(map);
                goto white;
            }
            ret = judgeWin(map, x, y);
            if (ret == WHITE)       //判断胜利
                break;
            
        }
    }

}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1908358.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

电脑显示x3daudio1_7.dll丢失如何修复，总结5种靠谱的修复方法

电脑显示x3daudio1_7.dll丢失如何修复，总结5种靠谱的修复方法

在使用电脑时&#xff0c;若系统提示x3daudio1_7.dll文件丢失&#xff0c;需及时进行修复操作&#xff0c;当此文件丢失或损坏时&#xff0c;人们可能会遇到一些音频功能方面的问题&#xff0c;如软件游戏无法正常启动运行。以下提供一种快速有效的修复方法。 一、了解x3daudio…
阅读更多...
Flutter 是如何实现的 ？

Flutter 是如何实现的 ？

Flutter 是由 Google 开发的一个开源 UI 软件开发工具包&#xff0c;用于构建跨平台的应用程序。Flutter 的核心理念是提供一个高度可定制、快速和现代的 UI 框架&#xff0c;它允许开发者使用一套代码库构建 Android、iOS、Web 和桌面应用程序。以下是 Flutter 的一些关键实现…
阅读更多...
四川赤橙宏海商务信息咨询有限公司专业电商服务团队

四川赤橙宏海商务信息咨询有限公司专业电商服务团队

在数字经济迅猛发展的今天&#xff0c;抖音电商以其独特的魅力和强大的市场潜力&#xff0c;成为了众多企业竞相追逐的蓝海。作为深耕抖音电商领域的专业服务商&#xff0c;四川赤橙宏海商务信息咨询有限公司凭借其丰富的经验和专业的团队&#xff0c;为众多商家提供了全方位、…
阅读更多...
大模型应用元年，到底有哪些场景可以实际落地场景？

大模型应用元年，到底有哪些场景可以实际落地场景？

很多企业和个人都号称自己打造了AI大模型实际落地场景&#xff0c;其中有噱头、蹭热点&#xff0c;也有真实落地应用的。下面我将聊聊有哪些应用是真实落地可执行的。 大模型写作 生成式大语言大模型的看家本领非写作莫属。大模型输出logits的基础上加上top_p、top_k、temper…
阅读更多...
spring boot集成easypoi导出word换行处理

spring boot集成easypoi导出word换行处理

项目场景&#xff1a; spring boot集成easypoi导出word <dependency><groupId>cn.afterturn</groupId><artifactId>easypoi-spring-boot-starter</artifactId><version>4.4.0</version> </dependency> 问题描述 spring boo…
阅读更多...
java中Request和Response的详细介绍

java中Request和Response的详细介绍

1.Request和Response的概述 # 重点 1. service方法的两个参数request和response是由tomcat创建的void service(ServletRequest var1, ServletResponse var2) 2. request 表示请求数据, tomcat将浏览器发送过来的请求数据解析并封装到request对象中servlet开发者可以通过reques…
阅读更多...
Studying-代码随想录训练营day31| 56.合并区间、738.单调递增的数字、968.监控二叉树、贪心算法总结

Studying-代码随想录训练营day31| 56.合并区间、738.单调递增的数字、968.监控二叉树、贪心算法总结

第31天&#xff0c;贪心最后一节(ง •_•)ง&#x1f4aa;&#xff0c;编程语言&#xff1a;C 目录 56.合并区间 738.单调递增的数字 968.监控二叉树 贪心算法总结 56.合并区间 文档讲解&#xff1a;代码随想录合并区间 视频讲解&#xff1a;手撕合并区间 题目&#xf…
阅读更多...
美妆网页设计（前端）

美妆网页设计（前端）

目录 一、 网站背景&#xff1a; 1、 背景介绍 2、 项目意义 二、 系统设计&#xff1a; 1.系统目标 2.系统功能结构 3.开发环境 三、 开发实现 1、导航栏 2、轮播效果效果 3、下拉菜单效果 4、模态框 遇到的问题及解决办法 五、 总结&#xff1a; 网站背景&…
阅读更多...
【LabVIEW学习篇 - 5】：数据类型——数值、字符串

【LabVIEW学习篇 - 5】：数据类型——数值、字符串

文章目录 数值枚举下拉列表控件 字符串字符串与十六进制截取字符串连接字符串 字符串与数值间的转换字符串转为数值数值转为字符串 数值 如下图所示&#xff0c;各种数值型数据的不同之处在于存储和表示数据时所使用的位置不同。 浮点型 整型 在LabVIEW中&#xff0c;想要改…
阅读更多...
Android计算器界面的设计——表格布局TableLayout实操

Android计算器界面的设计——表格布局TableLayout实操

目录 任务目标任务分析任务实施 任务目标 使用TextView、Button等实现一个计算器界面&#xff0c;界面如图1所示。 图1 计算器界面效果图 任务分析 界面整体使用表格布局&#xff0c;第一行使用一个TextView控件&#xff0c;横跨4列&#xff0c;中间4行4列&#xff0c;最后一…
阅读更多...
Mysql笔记-v2

Mysql笔记-v2

零、 help、\h、? 调出帮助 mysql> \hFor information about MySQL products and services, visit:http://www.mysql.com/ For developer information, including the MySQL Reference Manual, visit:http://dev.mysql.com/ To buy MySQL Enterprise support, training, …
阅读更多...
EAI四个层次服务-系统架构师（二十六）

EAI四个层次服务-系统架构师（二十六）

1、&#xff08;重点&#xff09;系统应用集成提供了4个不同层次服务&#xff0c;最上层服务是&#xff08;&#xff09;服务。 解析: EAI&#xff08;Enterprise Application Integration&#xff09;系统应用集成&#xff0c;相关概念。 实施EAI必须保证&#xff1a;应用程…
阅读更多...
OS Copilot测评-CSDN

OS Copilot测评-CSDN

登录控制台 安装插件 sudo yum install -y os-copilot效果如下 配置 AccessKey ID 与 AccessKey Secret 注意安全&#xff0c;使用完成后&#xff0c;别忘了去控制台删除&#xff0c;一般情况使用子Key就可以 检测是否可用 co hi实际操作(当前为官方案例请求) 实操1&…
阅读更多...
分区Partition

分区Partition

理解Partition 向量检索服务DashVector的Collection具有分区&#xff08;Partition&#xff09;的能力&#xff0c;同一个Collection下的Doc可通过不同的Partition进行物理和逻辑上的分区。各种Doc操作&#xff08;如插入Doc、检索Doc等&#xff09;若指定Partition&#xff0…
阅读更多...
超好用的傲软录屏下载和解锁版安装教程 (专业好用的桌面录屏软件)

超好用的傲软录屏下载和解锁版安装教程 (专业好用的桌面录屏软件)

录屏系列软件安装目录 一、ZD屏幕录像机解锁版下载及安装教程 (一款小巧的轻量级屏幕录像工具) 二、班迪录屏Bandicam v7解锁版安装教程&#xff08;高清录屏软件&#xff09; 三、Mirillis Action v4 解锁版安装教程(专业高清屏幕录像软件) 四、Aiseesoft Screen Recorder…
阅读更多...
react-类组件1

react-类组件1

类组件&#xff1a; import { Component } from "react";class App extends Component {constructor() {super();this.state {message: "xxxxx",};}render() {return (<div><div>{this.state.message}</div></div>);} }export d…
阅读更多...
如 何 避 开 职 场 雷 区

如 何 避 开 职 场 雷 区

01 管理好自己的情绪 在职场中切忌过于情绪化&#xff0c;学会管理好自己的情绪是一个职场人必备的技能之一。坏情绪并不会帮助你解决任何问题&#xff0c;过多的抱怨&#xff0c;只会使你成为负能量的传播者。 在职场中&#xff0c;需要做的是管理好自己的情绪&#xff0c;积…
阅读更多...
Python--并发编程--协程

Python--并发编程--协程

概念 协程是轻量级的线程&#xff0c;它是程序员管理的并发机制&#xff0c;使得在一个线程中程序可以在多个函数之间交替运行。 Python中主要通过asyncio模块实现协程。 协程函数 用async修饰的函数 import asyncio# func为协程函数 async def func():await asyncio.slee…
阅读更多...
【C语言】extern 关键字详解

【C语言】extern 关键字详解

在C语言中&#xff0c;extern关键字用于声明一个变量或函数是定义在另一个文件中的。它使得在多个文件之间共享变量或函数成为可能。extern关键字常见于大型项目中&#xff0c;通常用于声明全局变量或函数&#xff0c;这些变量或函数的定义位于其他文件中。 基本用法 变量声明…
阅读更多...
[极客大挑战 2019]RCE ME

[极客大挑战 2019]RCE ME

[极客大挑战 2019]RCE ME <?php error_reporting(0); if(isset($_GET[code])){$code$_GET[code];if(strlen($code)>40){die("This is too Long.");}if(preg_match("/[A-Za-z0-9]/",$code)){die("NO.");}eval($code); } else{highlight_f…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023