扫雷

人造人 · 发表于 2018-2-8 01:34:26

马上注册，结交更多好友，享用更多功能^_^

您需要登录才可以下载或查看，没有账号？立即注册

x

本帖最后由人造人于 2018-2-8 18:34 编辑

灵感来自 http://bbs.fishc.com/thread-104918-1-1.html

我目前不会写自动翻开的那部分
如果我点了一个，这个和这个周围没有雷，那就把这些翻开，这部分我目前不会写

源码

游客，如果您要查看本帖隐藏内容请回复

2018-02-08更新在13楼

人造人 · 发表于 2018-2-8 01:38:34

最后一张图是亮点

人造人 · 发表于 2018-2-8 01:39:06

@风过无痕丶

小甲鱼 · 发表于 2018-2-8 02:31:28

666

风过无痕丶 · 发表于 2018-2-8 11:03:43

人造人发表于 2018-2-8 01:39
@风过无痕丶

我觉得需要一个边框！

风过无痕丶 · 发表于 2018-2-8 11:20:01

我觉得自动翻开那部分可以写个类似数组的自动增长因子的东西~
翻开那部分由翻的次数来增长~
举例说：
翻第一次，检索周围两步的范围有没雷，如果有雷就只开当前范围，如果没雷就打开增长范围的未知区域。。。
翻第二次检索周围两步的次方
。。。。。
我大概的思维就是这样~

风过无痕丶 · 发表于 2018-2-8 11:52:10

还有~昨晚的那个随机数我好像找到解决方法了。。
如果不要种子，就只有一个值~
把种子放在主调函数就可以了。。。

风过无痕丶 · 发表于 2018-2-8 13:43:33

自动是自动开了~我怎么感觉我写成外挂了~ 把雷区就不开着给我剩在那了~

mintaka · 发表于 2018-2-8 14:38:56

人造人 · 发表于 2018-2-8 15:58:30

风过无痕丶发表于 2018-2-8 11:03
我觉得需要一个边框！

确实需要一个边框
^_^

人造人 · 发表于 2018-2-8 16:00:46

风过无痕丶发表于 2018-2-8 11:20
我觉得自动翻开那部分可以写个类似数组的自动增长因子的东西~
翻开那部分由翻的次数来增长~ ...

还是不明白，这部分我不会写
^_^

风过无痕丶 · 发表于 2018-2-8 16:29:16

                        // 检测附近有没雷，如果没雷，打开n的位置
                        //  如果有雷 打开当前位置
                        void Prompt_arr(void){
                                // 先取得当前位置！
                                int x,y;
                                gps_saolei(&x,&y);

                                // 来吧！开始数雷！
                                int count_A = 0;
                                int count_B = 0;
                                int count_C = 0;
                                int count_D = 0;
                                int n = count_saolei;   // count_saolei 为全局变量，按下开格子之后会自增~ 检测到有雷，值会缩减~
                                
                                // 总觉得还差点什么~
                                // 检测一下 是否在边界，如果是在边界的话，就不打开那么宽了
                                for (int i = 0; i < n--; i++){

                                        if (x > 15){
                                                ;
                                        }
                                        else {
                                                if (juzhen_tnt[x+i][y] == 8){ // 8为雷标识符
                                                        count_A++; // 有雷的话，就数一下有几个雷
                                                        }
                                                else {
                                                        juzhen[x+i][y] = 3; // 没雷的话，就打开格子
                                                }
                                        }
                                }


                                n = count_saolei;
                                for (int i = 0; i < n--; i++){
                                        if (x == 0){
                                                ;
                                        }
                                        else {
                                                if (juzhen_tnt[x-i][y] == 8){
                                                        count_B++; 
                                                }
                                                else {
                                                        juzhen[x-i][y] = 3; 
                                                }
                                        }
                                }


                                n = count_saolei;
                                for (int i = 0; i < n--; i++){
                                        if (y > 15){
                                                ;
                                        }
                                        else {
                                                if (juzhen_tnt[x][y+i] == 8){
                                                        count_C++; 
                                                }
                                                else {
                                                        juzhen[x][y+i] = 3; 
                                                }
                                        }
                                }


                                n = count_saolei;
                                for (int i = 0; i < n--; i++){
                                        if (y == 0){
                                                if (juzhen_tnt[x][y-i] == 8){
                                                        count_D++; 
                                                }
                                                else {
                                                        juzhen[x][y-i] = 3; 
                                                }
                                        }
                                }
                        }
};

功能是可以实现~但是有点毛病~遇到雷了它会绕开~就剩个光秃秃的雷区~可能还要修改一下算法和全局变量的衰减力度

人造人 · 发表于 2018-2-8 16:55:04

风过无痕丶发表于 2018-2-8 16:29
功能是可以实现~但是有点毛病~遇到雷了它会绕开~就剩个光秃秃的雷区~可能还要修改一下算法和全局变量 ...

谢谢，我研究一下
^_^

人造人 · 发表于 2018-2-8 18:31:17

本帖最后由人造人于 2018-2-8 18:36 编辑

2018-02-08 更新

就差自动翻开的部分了吧

#include <iostream>
#include <string>
#include <ctime>
#include <windows.h>
#include <conio.h>

struct MapElem
{
        bool status;
        bool is_mine;
        bool flag;
        int  count;
};

const int MAP_X = 16;
const int MAP_Y = 16;
MapElem map[MAP_X][MAP_Y];

void GlobalInit(void)
{
        for(int i = 0; i < MAP_X; ++i)
        {
                for(int j = 0; j < MAP_Y; ++j)
                {
                        map[i][j].is_mine = false;
                        map[i][j].status = false;
                        map[i][j].flag = false;
                        map[i][j].count = 0;
                }
        }
}

// 隐藏CMD窗口光标
void HideCursor(void)
{
        CONSOLE_CURSOR_INFO cci;
        cci.bVisible = FALSE;
        cci.dwSize = sizeof(cci);
        HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
        SetConsoleCursorInfo(handle, &cci);
}

static void GotoXY(int x, int y)
{
        COORD c;
        c.X = x * 2;
        c.Y = y;
        SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), c);
}

static void DrawString(const char *str, int color)
{
        static const WORD attr[] = {
                FOREGROUND_RED | FOREGROUND_INTENSITY, //红色
                FOREGROUND_GREEN | FOREGROUND_INTENSITY, //绿色
                FOREGROUND_BLUE | FOREGROUND_INTENSITY, //蓝色
                FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY //白色
        };
        CONSOLE_SCREEN_BUFFER_INFO csbi;
        DWORD NumberOfAttrsWritten;

        GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &csbi);
        printf(str);
        FillConsoleOutputAttribute(GetStdHandle(STD_OUTPUT_HANDLE), attr[color], strlen(str), csbi.dwCursorPosition, &NumberOfAttrsWritten);
}

void SetMine(int num)
{
        for(int i = 0; i < num; ++i)
        {
                int x, y;

                do
                {
                        x = rand() % MAP_X;
                        y = rand() % MAP_Y;
                }
                while(map[x][y].is_mine);

                map[x][y].is_mine = true;
        }
}

void ShowCount(int x, int y, int color)
{
        if(!map[x][y].count)
        {
                DrawString("∷", color);
                return;
        }

        char buf[3] = "①";
        buf[1] += map[x][y].count - 1;
        DrawString(buf, color);
}

const int MAP_OFFSET_X = 20;
const int MAP_OFFSET_Y = 10;
void DrawMap(void)
{
        int color;

        for(int i = 0; i < MAP_X; ++i)
        {
                for(int j = 0; j < MAP_Y; ++j)
                {
                        if(map[i][j].flag)
                                color = 1;
                        else
                                color = 3;

                        GotoXY(i + MAP_OFFSET_X, j + MAP_OFFSET_Y);

                        if(map[i][j].flag)
                        {
                                DrawString("◎", color);
                                continue;
                        }

                        if(map[i][j].status)
                        {
                                if(map[i][j].is_mine)
                                        DrawString("★", color);
                                else
                                        ShowCount(i, j, color);
                        }
                        else
                                DrawString("■", color);
                }
        }
}

void UpdateCursor(POINT po)
{
        DrawMap();

        GotoXY(po.x + MAP_OFFSET_X, po.y + MAP_OFFSET_Y);
        DrawString("□", 3);
}

bool SelectTarget(POINT cur)
{
        if(map[cur.x][cur.y].status)
                return false;

        map[cur.x][cur.y].status = true;
        DrawMap();

        if(map[cur.x][cur.y].is_mine)
        {
                GotoXY(cur.x + MAP_OFFSET_X, cur.y + MAP_OFFSET_Y);
                DrawString("★", 0);
                return true;
        }

        return false;
}

void ShowMap(void)
{
        int color;

        for(int i = 0; i < MAP_X; ++i)
        {
                for(int j = 0; j < MAP_Y; ++j)
                {
                        if(!map[i][j].status)
                        {
                                if(map[i][j].flag)
                                        color = 1;
                                else
                                        color = 3;

                                GotoXY(i + MAP_OFFSET_X, j + MAP_OFFSET_Y);
                                if(map[i][j].is_mine)
                                        DrawString("★", color);
                                else
                                        ShowCount(i, j, color);
                        }
                }
        }
}

int GetCount(int x, int y)
{
        int count = 0;

        // 左上角 -> 右上角
        for(int i = 0; i < 3; ++i)
                if((x - 1 + i >= 0) && (y - 1 >= 0))
                        if(map[x - 1 + i][y - 1].is_mine)
                                ++count;

        // 左下角 -> 右下角
        for(int i = 0; i < 3; ++i)
                if((x - 1 + i >= 0) && (y + 1 < MAP_Y))
                        if(map[x - 1 + i][y + 1].is_mine)
                                ++count;

        // 左边
        if(x - 1 >= 0)                // 有左边吗?
                if(map[x - 1][y].is_mine)
                        ++count;

        // 右边
        if(x + 1 < MAP_X)        // 有右边吗?
                if(map[x + 1][y].is_mine)
                        ++count;

        return count;
}

void GenerateCount(void)
{
        for(int i = 0; i < MAP_X; ++i)
        {
                for(int j = 0; j < MAP_Y; ++j)
                {
                        if(!map[i][j].is_mine)
                                map[i][j].count = GetCount(i, j);
                }
        }
}

int main(void)
{
        srand((unsigned int)time(nullptr));
        HideCursor();
        GlobalInit();

        SetMine(30);
        GenerateCount();
        DrawMap();

        POINT cur = {MAP_X / 2, MAP_Y / 2};
        UpdateCursor(cur);

        char command;
        while(1)
        {
                command = _getch();
                switch(command)
                {
                case 'q':
                case 'Q':
                        goto EXIT;
                case 'w':
                case 'W':
                        if(cur.y > 0)
                        {
                                --cur.y;
                                UpdateCursor(cur);
                        }
                        break;
                case 's':
                case 'S':
                        if(cur.y < MAP_Y - 1)
                        {
                                ++cur.y;
                                UpdateCursor(cur);
                        }
                        break;
                case 'a':
                case 'A':
                        if(cur.x > 0)
                        {
                                --cur.x;
                                UpdateCursor(cur);
                        }
                        break;
                case 'd':
                case 'D':
                        if(cur.x < MAP_X - 1)
                        {
                                ++cur.x;
                                UpdateCursor(cur);
                        }
                        break;
                case 'f':
                case 'F':
                        if(!map[cur.x][cur.y].status)
                        {
                                map[cur.x][cur.y].flag = !map[cur.x][cur.y].flag;
                                DrawMap();
                        }
                        break;
                case ' ':
                        if(!map[cur.x][cur.y].flag)
                                if(SelectTarget(cur))
                                        goto EXIT;
                        break;

                }

        }

EXIT:
        ShowMap();

        GotoXY(0, 34);
        return 0;
}

asdf123as · 发表于 2018-2-26 14:43:08

mintaka · 发表于 2018-3-26 22:47:19

楼主，还有在写吗，我写了一下自动打开的，好像有些bug

#include<bits/stdc++.h>
#include<windows.h>
#include <conio.h>
using namespace std;

const int map_x = 16;
const int map_y = 16;
struct Mapelem{
    bool status = false;
    bool is_mine = false;
    int course = 0;
}Map[map_x][map_y];

void Hidecursor()
{
    CONSOLE_CURSOR_INFO cci;
    cci.bVisible = FALSE;
    cci.dwSize = sizeof(cci);
    HANDLE handle = GetStdHandle(STD_OUTPUT_HANDLE);
    SetConsoleCursorInfo(handle, &cci);
}

void gotoxy(int x,int y){
    COORD cod;
    cod.X = x * 2;
    cod.Y = y;
    SetConsoleCursorPosition( GetStdHandle( STD_OUTPUT_HANDLE ), cod );
}

void print_course(int x,int y){
    if(!Map[x][y].course){
        printf(" ");
        return;
    }
    printf("%d",Map[x][y].course);
}

void drawmap(){
    for(int i=0; i<map_x; i++){
        for(int j=0; j<map_y; j++){
            gotoxy(i,j);
            if(Map[i][j].status){
                if(Map[i][j].is_mine)
                    printf("║О");
                else
                    print_course(i,j);
            }
            else
                printf("║Ж");
        }
    }
}

void UpdateCursor(POINT po)
{
        drawmap();

        gotoxy(po.x, po.y);
        printf("║У");
}

void setmine(int num){
    int x,y;
    for(int i=0; i<num; i++){
        do{
            x = rand()%map_x;
            y = rand()%map_y;
        }while(Map[x][y].is_mine);
        Map[x][y].is_mine = true;
    }
}

int GetCount(int x, int y)
{
        int count = 0;

        // вСио╫г -> срио╫г
        for(int i = 0; i < 3; ++i)
                if((x - 1 + i >= 0) && (y - 1 >= 0))
                        if(Map[x - 1 + i][y - 1].is_mine)
                                ++count;

        // вСоб╫г -> сроб╫г
        for(int i = 0; i < 3; ++i)
                if((x - 1 + i >= 0) && (y + 1 < map_y))
                        if(Map[x - 1 + i][y + 1].is_mine)
                                ++count;

        // вС╠ъ
        if(x - 1 >= 0)                // спвС╠ъбП?
                if(Map[x - 1][y].is_mine)
                        ++count;

        // ср╠ъ
        if(x + 1 < map_x)        // спср╠ъбП?
                if(Map[x + 1][y].is_mine)
                        ++count;

        return count;
}

void GenerateCount(void)
{
        for(int i = 0; i < map_x; ++i)
        {
                for(int j = 0; j < map_y; ++j)
                {
                        if(!Map[i][j].is_mine)
                                Map[i][j].course = GetCount(i, j);
                }
        }
}

void show_mine(POINT p ){


    if (Map[p.x][p.y].status)
        return;
    else if (Map[p.x][p.y].course>0){
        Map[p.x][p.y].status = true;
        return;
    }
    else{
        Map[p.x][p.y].status = true;
        POINT k;
        int i;
        for(i = 0; i < 3; ++i)
                if((p.x - 1 + i >= 0) && (p.y - 1 >= 0))
                       {
                            k.x = p.x - 1 +i;
                            k.y = p.y - 1;
                            show_mine(k);
                        }
        // вСоб╫г -> сроб╫г
        for(i = 0; i < 3; ++i)
                if((p.x - 1 + i >= 0) && (p.y + 1 < map_y))
                        {
                            k.x = p.x - 1 + i;
                            k.y = p.y + 1;
                            show_mine(k);
                        }
        // вС╠ъ
        if(p.x - 1 >= 0)                // спвС╠ъбП?
                {
                    k.x = p.x - 1;
                    k.y = k.y;
                    show_mine(k);
                }

        // ср╠ъ
        if(p.x + 1 < map_x)        // спср╠ъбП?
                {
                    k.x = p.x + 1;
                    k.y = p.y;
                    show_mine(k);
                }
    }
}

bool SelectTarget(POINT p){
    if(Map[p.x][p.y].status)
        return false;
    if(Map[p.x][p.y].is_mine)
        return true;
    //print_course(p.x,p.y);
    show_mine(p);
    drawmap();
    return false;
}

void showmap(){
    for(int i=0; i<map_x; i++){
        for(int j=0; j<map_y; j++){
            if(!Map[i][j].status){
                gotoxy(i,j);
                if(Map[i][j].is_mine)
                    printf("║О");
                else
                    print_course(i,j);
            }
        }
    }
}

int main(){
    srand((unsigned int)time(0));
    Hidecursor();
    drawmap();
    setmine(30);
    GenerateCount();

    POINT p = {0,0};
    UpdateCursor(p);

    while(1){
        char c = _getch();
        switch(c){
        case 'q':
        case 'Q':
            goto EXIT;
            break;
        case 'a':
        case 'A':
            if(p.x>0){
                p.x--;
                UpdateCursor(p);
            }break;
        case 's':
        case 'S':
            if(p.y<15){
                p.y++;
                UpdateCursor(p);
            }break;
        case 'W':
        case 'w':
            if(p.y>0){
                p.y--;
                UpdateCursor(p);
            }break;
        case 'd':
        case 'D':
            if(p.x<15){
                p.x++;
                UpdateCursor(p);
            }break;
        case ' ':
            if(SelectTarget(p))
                goto EXIT;
            break;
        }
    }
    EXIT:
        showmap();

    return 0;
}

mintaka · 发表于 2018-3-26 22:48:59

我觉得应该再加一个游戏通过的函数
ps：编码问题中文和一些字符无法显示。。。。

人造人 · 发表于 2018-3-26 23:15:05

mintaka 发表于 2018-3-26 22:48
我觉得应该再加一个游戏通过的函数
ps：编码问题中文和一些字符无法显示。。。。

这是编码问题吗？

叫我ace · 发表于 2018-3-27 16:37:07

谢谢楼主

mintaka · 发表于 2018-3-27 18:30:40

人造人发表于 2018-3-26 23:15
这是编码问题吗？

是我电脑的编译器设置问题，原本的星号，方块会变成你这样子，虽然我运行时还是正常，你应该要改一下

账号		自动登录	找回密码
密码			立即注册

[技术交流] 扫雷

马上注册，结交更多好友，享用更多功能^_^

评分