五子连珠

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

代码

/*
 * 玩法：wsad方向，空格选择，q退出
 */

#include <stdlib.h>
#include <signal.h>
#include <sys/time.h>
#include <curses.h>

struct path_node {
    int row, col;
    int path;
    struct  path_node *next;
};

struct map_node {
    int y, x;
    char value;
    int path;
    int flag;
};

struct point {
    int row, col;
};

#define ROW         9
#define COL         9
#define MAX_PATH    ROW*COL
#define TICKER 150
#define CHAR_TYPE_NUM 5

#define VISITED     1
#define UNVISITED   0

#define CHAR_1      '1'
#define CHAR_2      '2'
#define CHAR_3      '3'
#define CHAR_4      '4'
#define CHAR_5      '5'
#define CHAR_NONE   ' '
#define CHAR_LINE_1     "-------------------"
#define CHAR_LINE_2     "| | | | | | | | | |"

#define bad_row(r)  ((r) < 0 || (r) > 8)
#define bad_col(c)  ((c) < 0 || (c) > 8)
#define arrive_end(r, c) ( ((r) == end_row) && ((c) == end_col) )
#define arrive_begin(r, c) ( ((r) == begin_row) && \
                            ((c) == begin_col) )

struct map_node map[ROW][COL];
char begin_char;
int no_path, blank_num;
int begin_row, begin_col, end_row, end_col, cursor_row, cursor_col;
struct path_node *head, *tail;
struct point blank_array[MAX_PATH];
char char_array[CHAR_TYPE_NUM] = {CHAR_1, CHAR_2, CHAR_3, CHAR_4, 
    CHAR_5};
struct point weiyi_around[4] = {{-1,0}, {0,1}, {1,0}, {0,-1}};
struct point weiyi_five[4][9] = {
    {{0, -4}, {0, -3}, {0, -2}, {0, -1}, {0, 0}, 
        {0, 1}, {0, 2}, {0, 3}, {0, 4}},
    {{-4, -4}, {-3, -3}, {-2, -2}, {-1, -1}, {0, 0}, 
        {1, 1}, {2, 2}, {3, 3}, {4, 4}},
    {{-4, 0}, {-3, 0}, {-2, 0}, {-1, 0}, {0, 0}, 
        {1, 0}, {2, 0}, {3, 0}, {4, 0}},
    {{-4, 4}, {-3, 3}, {-2, 2}, {-1, 1}, {0, 0}, 
        {1, -1}, {2, -2}, {3, -3}, {4, -4}}
};

void init();
int set_ticker(int n_msec);
void sig_timer(int sig);
void play();
void show_path();
void find_path();
void reset_map_path();
void destroy_list();
void cal_path();
void init_map();
void init_screen();
void game_over();
void generate_new();
void move_up();
void move_down();
void move_left();
void move_right();
void clear_cursor();
void draw_cursor();
void init_blank_array();
int remove_five(int row, int col);
int set_ticker(int n_msec);

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

void play()
{
    char ch;
    int first = 1;

    while(1) {
        ch = getch();
        switch (ch) {
            case 'w':
                move_up();
                break;
            case 's':
                move_down();
                break;
            case 'a':
                move_left();
                break;
            case 'd':
                move_right();
                break;
            case ' ':
                if (first) {
                    first = 0;
                    begin_row = cursor_row;
                    begin_col = cursor_col;
                    begin_char = map[begin_row][begin_col].value;
                    draw_cursor();
                }
                else {
                    if (CHAR_NONE != 
                            map[cursor_row][cursor_col].value)
                        break;
                    first = 1;
                    end_row = cursor_row;
                    end_col = cursor_col;
                    find_path();

                    cursor_row = begin_row;
                    cursor_col = begin_col;
                    clear_cursor();
                    cursor_row = end_row;
                    cursor_col = end_col;
                    draw_cursor();
                }
                break;
            case 'q':
                game_over();
                break;
        }
    }
}

void move_up()
{
    clear_cursor();
    if (cursor_row > 0)
        cursor_row --;
    draw_cursor();
}

void move_down()
{
    clear_cursor();
    if (cursor_row < 8)
        cursor_row ++;
    draw_cursor();
}

void move_left()
{
    clear_cursor();
    if (cursor_col > 0)
        cursor_col --;
    draw_cursor();
}

void move_right()
{
    clear_cursor();
    if (cursor_col < 8)
        cursor_col ++;
    draw_cursor();
}

void draw_cursor()
{
    char c;

    move(map[cursor_row][cursor_col].y, 
            map[cursor_row][cursor_col].x);
    c = (char)inch();
    attron(A_STANDOUT);
    addch(c);
    refresh();
}

void clear_cursor()
{
    char c;

    move(map[cursor_row][cursor_col].y, 
            map[cursor_row][cursor_col].x);
    c = (char)inch();
    attroff(A_STANDOUT);
    addch(c);
    refresh();
}

void show_path()
{
    int i;

    cursor_row = begin_row;
    cursor_col = begin_col;
    set_ticker(200);
    while (!arrive_end(cursor_row, cursor_col));
    set_ticker(0);
    for (i = 0; i < blank_num; i ++) {
        if ((blank_array[i].row == end_row) && 
                (blank_array[i].col == end_col)) {
            blank_array[i].row = begin_row;
            blank_array[i].col = begin_col;
            break;
        }
    }
}

int remove_five(int row, int col)
{
    int i, j, k, r, c;

    for (i = 0; i < 4; i ++) {
        for (j = 0; j < 5; j ++) {
            for (k = j; k < j+5; k ++) {
                r = row + weiyi_five[i][k].row;
                c = col + weiyi_five[i][k].col;
                if (begin_char != map[r][c].value) 
                    break;
            }
            if (k >= j+5) {
                for (k = j; k < j+5; k ++) {
                    r = row + weiyi_five[i][k].row;
                    c = col + weiyi_five[i][k].col;
                    move(map[r][c].y, map[r][c].x);
                    attroff(A_STANDOUT);
                    addch(CHAR_NONE);
                    refresh();
                    map[r][c].value = CHAR_NONE;
                }
                return 1;
            }
        }
    }
    return 0;
}

void find_path()
{
    reset_map_path();
    no_path = 0;
    map[end_row][end_col].path = 0;
    map[end_row][end_col].flag = VISITED;
    head = (struct path_node *)malloc(sizeof(struct path_node));
    *head = (struct path_node){end_row, end_col, 0, NULL};
    tail = head;

    cal_path();
    if (!no_path) {
        show_path();
        map[begin_row][begin_col].value = CHAR_NONE;
        map[end_row][end_col].value = begin_char;
        if (!remove_five(end_row, end_col))
            generate_new();
    }
}

void destroy_list()
{
    struct path_node *p;

    while (head) {
        p = head;
        head = head->next;
        free(p);
    }
}

void cal_path()
{
    int i, r, c;
    struct path_node *p, *tmp;

    while (head) {
        p = head;
        for (i = 0; i < 4; i ++) {
            r = p->row + weiyi_around[i].row;
            c = p->col + weiyi_around[i].col;
            if ((bad_row(r)) || (bad_col(c)))
                continue;
            if (arrive_begin(r, c)) {
                no_path = 0;
                destroy_list();
                return;
            }
            if ((CHAR_NONE == map[r][c].value) && 
                    (UNVISITED == map[r][c].flag)) {
                map[r][c].path = p->path + 1;
                map[r][c].flag = VISITED;

                tmp = (struct path_node *)malloc
                    (sizeof(struct path_node));
                *tmp = (struct path_node){r, c, p->path+1, NULL};
                tail = tail->next = tmp;
            }
        }
        head = head->next;
        free(p);
    }
    no_path = 1;
    destroy_list();
}

void generate_new()
{
    int i, j, k, m, r, c;

    for (i = 0; i < 3; i ++) {
        k = rand() % blank_num;
        j = rand() % CHAR_TYPE_NUM;
        r = blank_array[k].row;
        c = blank_array[k].col;
        map[r][c].value = char_array[j];
        move(map[r][c].y, map[r][c].x);
        attroff(A_STANDOUT);
        addch(char_array[j]);
        refresh();
        remove_five(r, c);

        for (m = k+1; m < blank_num; m ++) {
            blank_array[m-1].row = blank_array[m].row;
            blank_array[m-1].col = blank_array[m].col;
        }
        blank_num --;
    }
    if (blank_num <= 1) {
        getch();
        game_over();
    }
}

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

void sig_timer(int sig)
{
    int i, r, c;

    move(map[cursor_row][cursor_col].y, 
            map[cursor_row][cursor_col].x);
    addch(CHAR_NONE);
    refresh();
    clear_cursor();
    for (i = 0; i < 4; i ++) {
        r = cursor_row + weiyi_around[i].row;
        c = cursor_col + weiyi_around[i].col;
        if ((bad_row(r)) || (bad_col(c)))
            continue;
        if ((VISITED == map[r][c].flag) && 
                (map[r][c].path < map[cursor_row][cursor_col].path)) {
            cursor_row = r;
            cursor_col = c;
            break;
        }
    }
    move(map[cursor_row][cursor_col].y, 
            map[cursor_row][cursor_col].x);
    addch(begin_char);
    refresh();
    draw_cursor();
}

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

    clear();
    init_map();
    init_screen();
    init_blank_array();
    generate_new();
    cursor_row = cursor_col = 0;
    signal(SIGALRM, sig_timer);
}

void init_blank_array()
{
    int i, j;

    blank_num = 0;
    for (i = 0; i < ROW; i ++) {
        for (j = 0; j < COL; j ++) {
            blank_array[blank_num ++] = (struct point){i, j};
        }
    }
}

void reset_map_path()
{
    int i, j;

    for (i = 0; i < ROW; i ++) {
        for (j = 0; j < COL; j ++) {
            map[i][j].path = MAX_PATH;
            map[i][j].flag = UNVISITED;
        }
    }   
}

void init_map()
{
    int i, j;

    for (i = 0; i < ROW; i ++) {
        for (j = 0; j < COL; j ++) {
            map[i][j] = (struct map_node)
            {i*2+1, j*2+1, CHAR_NONE, MAX_PATH, UNVISITED};
        }
    }
}

void init_screen()
{
    int i, j;

    move(0, 0);
    printw(CHAR_LINE_1);
    for (i = 1; i < ROW*2; i ++) {
        move(i, 0);
        printw(CHAR_LINE_2);
        i ++;
        move(i, 0);
        printw(CHAR_LINE_1);
    }
    refresh();

    for (i = 0; i < ROW; i ++) {
        for (j = 0; j < COL; j ++) {
            if (CHAR_NONE != map[i][j].value) {
                move(map[i][j].y, map[i][j].x);
                addch(map[i][j].value);
            }
        }
    }
    refresh();
}

int set_ticker(int n_msec)
{
    struct itimerval timeset;
    long n_sec, n_usec;

    n_sec = n_msec / 1000;
    n_usec = (n_msec % 1000) * 1000L;

    timeset.it_interval.tv_sec = n_sec;
    timeset.it_interval.tv_usec = n_usec;

    timeset.it_value.tv_sec = n_sec;
    timeset.it_value.tv_usec = n_usec;

    return setitimer(ITIMER_REAL, &timeset, NULL);
}

结果

这里写图片描述

视频

c语言小游戏

weixiaoyiri
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
五子棋程序C++实现代码
03-23
内含阅读文档，方便易懂。VS2010编写，五子棋程序包含双活四，活三四，双活三，活四禁手。
用C++完成五子连珠游戏
weixin_51252109的博客
09-14 1310
一：项目背景 本游戏的棋盘大小是9 × 9，一共会出现6种颜色的珠子。初始状态棋盘上7个随机位置分布着7个随机颜色的珠子。通过移动珠子将同色的珠子连在一起来消除后得分。当无珠子可以移动时程序结束。让同色的棋子5颗连在一起排成横向、纵向或者斜向，五颗以上即可消除得分。 游戏规则： 1.一次只允许移动一个珠子。（从实现难度上分成3等。原游戏规则是要求必须存在可移动路径时方可移动珠子，即在移动路径上存在珠子阻挡就无法移动。这需要完成一项有效路径判断功能。更为优秀者可设计所采用的移动路径是所有可行移动路径中
C++小游戏开发——五子连珠，大作业项目
08-29
五子连珠游戏大一项目开发 设计思路：输入目标坐标并移动，检索是否连接五个棋子选择消除并积分，棋盘铺满游戏结束
VC++课程设计 五子连珠源代码
11-24
该程序是TICTACTOE游戏，棋盘为5*5，5个棋子连起来即为赢。输入参数时，若输入的数字超出边界或在已有棋子的地方再输入，则提示出错，要求重新输入
五子连珠国王版 老版五子连珠 七彩连珠
02-05
https://www.bilibili.com/video/BV1hh411p7c3/
Android 五子连珠 .rar
01-02
Android项目 五子连珠 Android项目 五子连珠 Android项目 五子连珠 Android项目 五子连珠 Android项目 五子连珠 Android项目 五子连珠 Android项目 五子连珠 Android项目 五子连珠 Android项目 五子连珠
Cocos Creator 小游戏五子连珠
08-18
Cocos Creator 小游戏五子连珠，代码是TS写的，方便阅读和二次开发修改。以下是试玩链接，wzlz.ywbdemo.cn
五子连珠游戏
03-16
游戏的规则很易学，每移动一次彩球，就会有三个球加入棋盘，如果移动一个球，能组成五个以上同色球，就可消去一路，同时没有三个球加入，移动球到达的位置要有通道可过，根据消去的球记分。这个项目有非常详细的源码...
五子连珠小游戏android源码
03-16
1、游戏功能：在9×9方格中，鼠标点击小球移动，每当5个或5个以上同颜色的小球连成1行，则消去并得分，如果移动时没有得分，将随机产生三个小球，当游戏不能放3个球时游戏结束。 ... ... 4、保存功能：游戏过程中，退出...
c++课程设计 五子连珠棋
05-30
用于大二c++课程设计，五子棋，打开直接能用，代码简单 界面较少
c++五连珠游戏代码
08-17
c++五连珠游戏代码，里面有详细的程序代码，精美的界面，可以游戏。
C语言课设五子连珠C语言游戏
05-24
大一的课设，五子连珠，需要Easyx 大概1000行 游戏内容 就是 五子连成一条线即可消除 其实游戏性并不大 只是为了巩固C语言知识才做的。 用到了很多知识点
五子连珠（c#版的）
05-25
看到苏T玩色球玩得挺爽的，写一个c#版的比较比较。 支持无限悔棋、支持录像重放（单放，不能暂停的）
VC实现的五子连珠程序
05-22
自己写的，编译通过，不用改任何东西，直接通过
五连珠c语言,【C语言】五子连珠代码
weixin_34563472的博客
05-20 541
////////////////////////////////////////////////////////////////////////////程序名称：五子连珠//编译环境：Visual C++ 2010/6.0,EasyX_2011惊蛰版//程序编写：Amanda_澜 [email protected]//最后更新：2011-12////////////////////////////...
五子连珠（vc2005实现）
月影孤帆
02-22 1354
前些时间照网上一个小游戏做了一个五子连珠  游戏的界面：    下面是我做这个程序的计划，从这个程序开始，我要努力的习惯去写写有关编程的一些计划性的文档，不管多少，都应该坚持写下去。。。///////////////////////////////////////////////////////////////////////////////////
c++打造五子棋（友元类）
pycharm_u的博客
03-20 912
实现五子棋游戏，要如下步骤： 1.建立棋盘类，棋盘类中有对棋盘的限制以及初始化 2.建立玩家类，为棋盘类的友元，对棋盘修改（下棋），以及判断输赢的算法 3.main函数实现界面   代码如下： #include &lt;iostream&gt; #include &lt;conio.h&gt; #define Chesssize 14 using namespace std; /*五子...
浅学C++(3)学习C语言(五子棋)
weixin_45700807的博客
07-14 620
坐标与方向键各实现五子棋
jether五子连珠
最新发布
02-05
Jether五子连珠是一种围棋术语，用来形容一连串连续放置在棋盘上的五个棋子。围棋是一种古老而深奥的策略棋类游戏，，需要玩家运用智慧和战略进行对局。jether五子连珠是围棋中的一种杀法，在游戏的一方将五个相同...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值