五子棋

最新推荐文章于 2023-08-10 18:40:44 发布
最新推荐文章于 2023-08-10 18:40:44 发布
阅读量286 收藏 1
点赞数
分类专栏： c语言小游戏 文章标签： 五子棋 c语言小游戏 linux小游戏 ncurses
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixiaoyiri/article/details/50273617
版权

代码

/*
 * 玩法：wsad方向，空格落子
 */
#include <stdlib.h>
#include <string.h>
#include <curses.h>
#include <signal.h>
#include <sys/time.h>

#define COMPUTER_FIRST          1
#define HUMAN_FIRST             2
#define BLANK                   0
#define COMPUTER                1
#define HUMAN                   2
#define UP                      1
#define DOWN                    2
#define LEFT                    3
#define RIGHT                   4

#define ROW                     23
#define COL                     80

#define CHAR_COMPUTER           'O'
#define CHAR_HUMAN              '*'

struct point {
    int x, y;
};

void play();
int in_map(int y, int x);
int have_opposite(int y, int x, int flag, int dir, int idx);
int have_self(int y, int x, int flag, int dir, int idx, int num);
void cal_value(int y, int x, int flag);
void computer_go();
void find_max_value(int flag, int *max_value);
void undo();
int win(int y, int x, int flag);
void draw_chess(int y, int x, int flag);
void clear_cursor(struct point cursor);
void draw_cursor(struct point cursor);
int same_position();
void move_cursor(int dir);
void game_over();
void init_game();
void init();

struct point cmp, human, cmp_human, old, new;
int mode;
int map[ROW][COL];
int value_cmp[ROW][COL], value_human[ROW][COL];
int max_cmp, max_human;

struct point weiyi[4][11] = {
    {-5,0,      -4,0,       -3,0,       -2,0,       -1,0,       0,0, 
     1,0,       2,0,        3,0,        4,0,        5,0},

    {-5,-5,     -4,-4,      -3,-3,      -2,-2,      -1,-1,      0,0,
     1,1,       2,2,        3,3,        4,4,        5,5},

    {0,-5,      0,-4,       0,-3,       0,-2,       0,-1,       0,0,
     0,1,       0,2,        0,3,        0,4,        0,5},

    {5,-5,      4,-4,       3,-3,       2,-2,       1,-1,       0,0,
     -1,1,      -2,2,       -3,3,       -4,4,       -5,5}
};

int main()
{
    init();
    play();
    return 0;
}

void play()
{
    int ch;

    while (1) {
        ch = getch();
        switch (ch) {
            case 'W':
            case 'w':
                move_cursor(UP);
                break;
            case 'S':
            case 's':
                move_cursor(DOWN);
                break;
            case 'A':
            case 'a':
                move_cursor(LEFT);
                break;
            case 'D':
            case 'd':
                move_cursor(RIGHT);
                break;
            case 'U':
            case 'u':
                undo();
                break;
            case ' ':
                draw_chess(human.y, human.x, HUMAN);
                computer_go();
                break;
            case 'R':
            case 'r':
                init_game();
                break;
            case 'Q':
            case 'q':
                game_over();
                break;
            default:
                break;
        }
    }
}

int in_map(int y, int x)
{
    return ((y >= 0) && (y <= ROW) && 
            (x >= 0) && (x <= COL));
}

int have_opposite(int y, int x, int flag, int dir, int idx)
{
    int x0, y0, i;

    for (i = idx; i < idx+5; i ++) {
        y0 = y + weiyi[dir][i].y;
        x0 = x + weiyi[dir][i].x;

        if (!in_map(y0, x0))
            return 1;

        if ( (COMPUTER == flag) && (HUMAN == map[y0][x0]) )
            return 1;
        else if ( (HUMAN == flag) && (COMPUTER == map[y0][x0]) )
            return 1;
    }

    return 0;
}

int have_self(int y, int x, int flag, int dir, int idx, int num)
{
    int x0, y0, i, cnt = 0, have = 0;

    for (i = idx; i < idx+5; i ++) {
        y0 = y + weiyi[dir][i].y;
        x0 = x + weiyi[dir][i].x;

        if (!in_map(y0, x0))
            break;

        if ( (COMPUTER == flag) && (HUMAN != map[y0][x0]) ) {
            if (COMPUTER == map[y0][x0]) {
                if (have > num) 
                    break;
                have ++;
                cnt ++;
            }
            else if (BLANK == map[y0][x0]) {
                cnt ++;
            }
        }
        else if ((HUMAN == flag) && (COMPUTER != map[y0][x0])) {
            if (HUMAN == map[y0][x0]) {
                if (have > num) 
                    break;
                have ++;
                cnt ++;
            }
            else if (BLANK == map[y0][x0]) {
                cnt ++;
            }
        }
    }

    if ((5 == cnt) && (num == have))
        return 1;
    else
        return 0;
}

void cal_value(int y, int x, int flag)
{
    int i, j, k, x0, y0, x1, y1, x2, y2, x3, y3;
    int one_five = 0, max = 0, sum = 0;

    for (i = 0; i < 4; i ++) {
        max = 0;

        for (j = 1; j < 6; j ++) {
            one_five = 0;

            if ( have_opposite(y, x, flag, i, j) )
                one_five = 0;
            if ( have_self(y, x, flag, i, j, 1) )
                one_five = 0;
            if ( have_self(y, x, flag, i, j, 2) )
                one_five = 1;
            if ( have_self(y, x, flag, i, j, 3) ) {
                y0 = y + weiyi[i][j].y;
                x0 = x + weiyi[i][j].x;
                y1 = y + weiyi[i][j+4].y;
                x1 = x + weiyi[i][j+4].x;
                y2 = y + weiyi[i][j+1].y;
                x2 = x + weiyi[i][j+1].x;
                y3 = y + weiyi[i][j+3].y;
                x3 = x + weiyi[i][j+3].x;
                if ((BLANK == map[y0][x0]) && 
                        (BLANK == map[y1][x1])) 
                    one_five = 20;
                else if ( ((BLANK == map[y0][x0]) && 
                            (BLANK == map[y2][x2])) || 
                        ((BLANK == map[y1][x1]) && 
                         (BLANK == map[y3][x3])))
                    one_five = 10;
                else
                    one_five = 5;
            }
            if ( have_self(y, x, flag, i, j, 4) ) {
                y0 = y + weiyi[i][j].y;
                x0 = x + weiyi[i][j].x;
                y1 = y + weiyi[i][j+5].y;
                x1 = x + weiyi[i][j+5].x;
                y2 = y + weiyi[i][j-1].y;
                x2 = x + weiyi[i][j-1].x;
                y3 = y + weiyi[i][j+4].y;
                x3 = x + weiyi[i][j+4].x;
                if ( ((in_map(y1, x1)) && 
                        (BLANK == map[y0][x0]) && 
                        (BLANK == map[y1][x1])) || 
                        (in_map(y2, x2) && 
                         (BLANK == map[y2][x2]) && 
                         (BLANK == map[y3][x3])) ) 
                    one_five = 400;
                else if ((BLANK == map[y0][x0]) || 
                        (BLANK == map[y3][x3]))
                    one_five = 200;
                else
                    one_five = 100;
            }
            if ( have_self(y, x, flag, i, j, 5) ) {
                one_five = 2000;
            }

            if (one_five > max)
                max = one_five;
        }

        sum += max;
    }

    if (COMPUTER == flag) 
        value_cmp[y][x] = sum;
    else if (HUMAN == flag)
        value_human[y][x] = sum;
}

void computer_go()
{
    int i, j;

    max_cmp = max_human = 0;
    memset(&cmp, 0, sizeof(struct point));
    memset(&cmp_human, 0, sizeof(struct point));
    memset(value_cmp, 0, sizeof(int)*ROW*COL);
    memset(value_human, 0, sizeof(int)*ROW*COL);

    for (i = 0; i < ROW; i ++) {
        for (j = 0; j < COL; j ++) {
            if (BLANK == map[i][j]) {
                map[i][j] = COMPUTER;
                cal_value(i, j, COMPUTER);
                map[i][j] = HUMAN;
                cal_value(i, j, HUMAN);
                map[i][j] = BLANK;
            }
        }
    }

    find_max_value(COMPUTER, &max_cmp);
    find_max_value(HUMAN, &max_human);

    if (max_cmp > max_human) {
        new = (struct point){cmp.x, cmp.y};
        draw_chess(cmp.y, cmp.x, COMPUTER);
        old = (struct point){new.x, new.y};
    }
    else if (max_cmp <= max_human) {
        new = (struct point){cmp_human.x, cmp_human.y};
        draw_chess(cmp_human.y, cmp_human.x, COMPUTER);
        old = (struct point){new.x, new.y};
    }
    else {
    }

#ifdef DEBUG
    attroff(A_STANDOUT);
    move(ROW, 0);
    printw("                             ");
    move(ROW, 0);
    printw("cmp:%d, human:%d", max_cmp, max_human);
    refresh();
#endif
}

void find_max_value(int flag, int *max_value)
{
    int i, j, x, y, max = 0;

    for (i = 0; i < ROW; i ++) {
        for (j = 0; j < COL; j ++) {
            if ((COMPUTER == flag) && (value_cmp[i][j] > max)) {
                max = value_cmp[i][j];
                x = j;
                y = i;
            }
            else if ((HUMAN == flag) && (value_human[i][j] > max)) {
                max = value_human[i][j];
                x = j;
                y = i;
            }
        }
    }

    *max_value = max;
    if (COMPUTER == flag) {
        cmp.x = x;
        cmp.y = y;
    }
    else if (HUMAN == flag) {
        cmp_human.x = x;
        cmp_human.y = y;
    }
}

void undo()
{
}

int win(int y, int x, int flag)
{
    int i, j, k, x0, y0, cnt = 0;

    for(i = 0; i < 4; i ++) {
        for (j = 1; j < 6; j ++) {
            cnt = 0;

            for (k = j; k < j+5; k ++) {
                y0 = y + weiyi[i][k].y;
                x0 = x + weiyi[i][k].x;

                if (!in_map(y0, x0))
                    break;

                if (COMPUTER == flag) {
                    if (COMPUTER == map[y0][x0]) {
                        cnt ++;
                        if (cnt >= 5)
                            return 1;
                    }
                    else {
                        break;
                    }
                }
                else if (HUMAN == flag) {
                    if (HUMAN == map[y0][x0]) {
                        cnt ++;
                        if (cnt >= 5)
                            return 1;
                    }
                    else {
                        break;
                    }
                }
            }
        }
    }

    return 0;
}

void draw_chess(int y, int x, int flag)
{
    if (BLANK == map[y][x]) {
        clear_cursor(old);
        move(y, x);

        if (COMPUTER == flag) {
            addch(CHAR_COMPUTER);
            map[y][x] = COMPUTER;
        }
        else if (HUMAN == flag) {
            addch(CHAR_HUMAN);
            map[y][x] = HUMAN;
        }

        refresh();
        draw_cursor(new);
    }

    if (win(y, x, flag)) {
        attroff(A_STANDOUT);
        move(ROW, 0);
        printw("                             ");
        move(ROW, 0);
        if (COMPUTER == flag)
            printw("Computer Win");
        else if (HUMAN == flag)
            printw("Human Win");
        refresh();
        getch();
        init_game();
    }
}

void clear_cursor(struct point cursor)
{
    char ch;
    move(cursor.y, cursor.x);
    attroff(A_STANDOUT);
    ch = (char)inch();
    addch(ch);
    refresh();
}

void draw_cursor(struct point cursor)
{
    char ch;
    move(cursor.y, cursor.x);
    ch = (char)inch();
    attron(A_STANDOUT);
    addch(ch);
    refresh();
}

int same_position()
{
    return ((cmp.x == human.x) && (cmp.y == human.y));
}

void move_cursor(int dir)
{
    if (!same_position())
        clear_cursor(human);
    switch (dir) {
        case UP:
            if (human.y > 0)
            human.y --;
            break;
        case DOWN:
            if (human.y < ROW-1)
                human.y ++;
            break;
        case LEFT:
            if (human.x > 0)
                human.x --;
            break;
        case RIGHT:
            if (human.x < COL-1)
                human.x ++;
            break;
        default:
            break;

    }
    if (!same_position())
            draw_cursor(human);
}

void game_over()
{
    endwin();
    exit(0);
}

void init_game()
{
    clear();
    memset(map, 0, sizeof(int)*ROW*COL);
    cmp = (struct point){40, 10};
    old = (struct point){40, 10};
    new = (struct point){40, 10};
    human = (struct point){40, 11};
    draw_chess(cmp.y, cmp.x, COMPUTER);
    draw_cursor(cmp);
    attroff(A_STANDOUT);
    move(ROW, 0);
    printw("                             ");
    refresh();
    max_cmp = max_human = 0;
    memset(&cmp, 0, sizeof(struct point));
    memset(&cmp_human, 0, sizeof(struct point));
    memset(value_cmp, 0, sizeof(int)*ROW*COL);
    memset(value_human, 0, sizeof(int)*ROW*COL);

}

void init()
{
    initscr();
    clear();
    cbreak();
    noecho();
    curs_set(0);
    srand(time(0));

    init_game();
}

结果

这里写图片描述

视频

c语言小游戏

weixiaoyiri
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux下 五子棋代码（可人机对战 ）
08-18
电脑很聪明的五子棋，不过，界面有些不够完善，基本实现操作了，在终端直接编译运行。
表格对比工具
lcj435543665的博客
04-26 1624
对比表格的python小工具 import openpyxl as xls from openpyxl.styles import PatternFill, Color, NamedStyle from openpyxl.styles import colors import sys #MAX_CMP_ROW为行对比中，最后一列的列序号，根据表格自定义 MAX_CMP_ROW=10 #比对row...
acm模板
nqw1987的专栏
09-24 1055
<br />| 全排列函数next_permutation<br />STL 中专门用于排列的函数（可以处理存在重复数据集的排列问题）<br />头文件：#include <algorithm><br />using namespace std;<br />调用： next_permutation(start, end);<br />注意：函数要求输入的是一个升序排列的序列的头指针和尾指针.<br />用法：<br />// 数组<br />int a[N];<br />sort(a, a+N);<br /
递归从二维数组里面取几个位置------week6模拟
beautiful_pain的博客
04-01 97
问题描述 Input Output Sample Input-1 5 2 1 0 3 1 Sample Output-1 0 0 0 0 8 0 12 36 0 Sample Input-2 25 4 0 0 24 3 Sample Output-2 0 2 18 0 0 644 1656 36432 113344 解题思路以及关键代码 本题的关键就是如何从一个二维数组里面不重复的...
linux minigui实现简单五子棋代码（过程详细）
qq_51643989的博客
09-12 1211
minigui 实现简单五子棋
C++五子棋人机对战
程序员Rock的博客
06-10 3万+
使用C++，开发五子棋人机对战，快速提升C++项目开发能力。
Python五子棋
we123aaa4567的博客
05-01 1381
五月一了，今天，我们来做一个小游戏——五子棋。五子棋五子棋起源于中国，全国智力运动会竞技项目之一，是一种两人对弈的纯策略型棋类游戏。双方分别使用黑白两色的棋子，下在棋盘直线与横线的交叉点上，先形成五子连珠者获胜。五子棋容易上手，老少皆宜，而且趣味横生，引人入胜。它不仅能增强思维能力，提高智力，而且富含哲理，有助于修身养性。
前端技术搭建五子棋游戏（内含源码）
热门推荐
官方推荐
07-06 5万+
基于HTML、CSS、JS前端基础技术搭建人机五子棋游戏；
JavaScript应用：五子棋游戏实战开发
黑夜开发者的博客
08-10 2809
本篇文章介绍了如何使用JavaScript开发一个简单的五子棋游戏。通过绘制棋盘、实现开始按钮和游戏逻辑、处理用户交互、判断胜负和游戏结束等功能，我们完成了一个基本的五子棋游戏。当然，我们还可以对游戏进行优化和扩展，例如增加悔棋功能、提示下一步最佳落子位置等。JavaScript是一种非常强大和灵活的编程语言，可以用于开发各种类型的应用程序和游戏。希望通过这篇文章，你对使用JavaScript开发游戏有了更深入的了解。如果你对五子棋游戏开发还有任何问题或建议，欢迎在评论区留言讨论。
基于FPGA的五子棋算法
01-11
使用Matlab编写的五子棋游戏，使用串口将数据传送到FPGA，进行处理后获得黑白子像素信息，存储后换算为坐标，转换为棋盘信息矩阵。在FPGA中实现简化的五子棋算法，计算出在剩下所有格点中利益值最大的点，从而确定下...
python实现人机五子棋
12-20
本文实例为大家分享了python实现人机五子棋的具体代码，供大家参考，具体内容如下 图形界面引用PyQt5，还有socket通信。可以局域网对战，可以人机对战，应该存在一些小的bug，但是还没有找出来。希望读者可以找到 ...
五子棋AI python实现
04-30
使用python写的基于两层博弈树的五子棋AI。加入了阿尔法贝塔剪枝。 python版本：3+，应该可以在命令行里直接跑。 电脑执黑，玩家执白。无禁手。 因为只有两层博弈树，请大家不要嫌他菜哈哈哈，仅供大家学习参考。 ...
五子棋代码
04-19
五子棋代码，只用于学习交流，不适用于商业传播，
网络五子棋
06-23
VC++下网络五子棋程序
前18大旋转修整器企业占据全球87%的市场份额.docx
最新发布
05-06
前18大旋转修整器企业占据全球87%的市场份额
Planet-SkySat-Imagery-Product-Specification-Jan2020.pdf
05-06
SKYSAT IMAGERY PRODUCT SPECIFICATION PLANET.COM VIDEO Full motion videos are collected between 30 and 120 seconds by a single camera from any of the active SkySats. Videos are collected using only the Panchromatic half of the camera, hence all videos are PAN only. Videos are packaged and delivered with a video mpeg-4 file, plus all image frames with accompanying video metadata and a frame index file (reference Product Types below)
pisqpipe 五子棋
12-02
pisqpipe是一个五子棋的电脑游戏，它是根据五子棋规则开发的。玩家可以在电脑上与电脑或其他玩家对战，也可以选择不同的难度等级来挑战自己。 pisqpipe的游戏界面简单易懂，棋盘由15行15列组成。玩家可以选择黑子或...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值