지뢰 찾기 / C++

너무 강의만 듣고 프로그래밍 연습을 위해서 지뢰찾기 게임을 만들었다.

이번에는 define 과 enum 을 사용했었는데 사용하는 이유를 깨달은거 같다.

이런식으로 반환값을재정의 하였다.

 

 

 

 

 

 

 

 

 

 Class 는 한개로 만들고 클래스 내부에서 

여러가지 멤버를 설정했다.

그리고 한칸 내부의 정보를 저장하기 위해서

Square 구조체도 한개 만들었다.

 

 

 

 

 

 

 

 

 

Class 내부의 함수 정보들이다 . 다시 봤을때 알아보기 쉽게하기 위해서

함수의 이름을 최대한 직관적으로 제작했다.

그리고 이번에는 빙고때와는 다르게 확장성을 생각해서  클래스를 설계했다

그결과로 쉬움, 중간, 어려움 난이도를 가지고있다.

 

 

 

 

 

 

 

 

게임 스타트 함수를 호출하면 순서대로 함수들이 진행 될 수 있도록 설계를 했다.

---

게임시작

 

게임을 시작하면 첫번째로 난이도를 선택할 수 있다. 방향키로 다른 선택이 가능하고 스페이스를 누르면

난이도는 선택된다.

하얀색 지점은 지금 가리키는 방향으로 A를 누르면 폭탄으로 의심되는 곳을 표시할 수 있다.

오픈한곳은 주변의 폭탄 숫자를 나태내고 0의 경우네는 자동으로 다른칸까지 열어주는  지뢰찾기와 유사하게

구현하였다.

지뢰를 발견하면 게임은 패배하고 모든 지뢰를 찾으면 게임은 승리한다.

 

 

 

검정색 코드는 cpp 파일 하얀색은 헤더입니다.

#include "minesweeper.h"
#include <stdlib.h>
#include <time.h>
 
void Textcolor(int foreground, int background)
{
    int color = foreground + background * 16;
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), color);
}
 
 
void Minesweeper::GameStart()
{
    SelectLevel();
    SetLevel();
    MakeMap();
    MineCount();
 
    pMap[Calculate()].Nowpoint = Yespoint;
    while (true)
    {
        ShowMap();
        MovePoint(KeyInput());
        VictoryCheck();
        if (1 == victory)
        {
            ShowMap();
            Sleep(1000);
            std::cout << "\n\n                             !!지뢰를 모두 찾았습니다 축하드려요!!!\n\n\n";
            Sleep(1000);
            break;
        }
        else if (2 == victory)
        {
            ShowMap();
            Sleep(1000);
            std::cout << "\n\n                             지뢰 지뢰 지뢰 지뢰 지뢰 지뢰 지뢰 지뢰";
            Sleep(1000);
            std::cout << "\n\n                                        게임 패배......             \n\n\n";
            Sleep(1000);
            break;
        }
    }
}
 
void Minesweeper::SelectLevel()
{
    int select = 0;
    while (select == 0)
    {
 
        system("cls");
        std::cout << "\n\n\n     -------난이도를 선택해주세요--------" << std::endl;
        std::cout << "     -                                  -" << std::endl;
        if (0 == Level) // 쉬움
        {
            std::cout << "     -      ";
            Textcolor(GREEN, 0);
            std::cout << "쉬움    ";
            Textcolor(WHITE, 0);
            std::cout << "중간    어려움      - " << std::endl;
 
        }
        else if (1 == Level)  // 중간
        {
            std::cout << "     -      쉬움    ";
            Textcolor(GREEN, 0);
            std::cout << "중간";
            Textcolor(WHITE, 0);
            std::cout << "    어려움      - " << std::endl;
 
        }
        else if (2 == Level)  // 어려움
        {
            std::cout << "     -      쉬움    중간    ";
            Textcolor(GREEN, 0);
            std::cout << "어려움";
            Textcolor(WHITE, 0);
            std::cout << "      - " << std::endl;
        }
        std::cout << "     -                                  -" << std::endl;
        std::cout << "     ------------------------------------" << std::endl;
        std::cout << "         결정하면 스페이스를 눌러주세요" <<   std::endl;
 
        while (true)
        {
 
            if (_kbhit()) {
 
                char c = _getch();
                   
                if (-32 == c)
                {
                    c = _getch();
 
                    switch (c)
                    {
                    case LEFT:
                        --Level;
                        break;
                    case RIGHT:
                        ++Level;
                        break;
                    }
 
                    if (Level == -1)
                    {
                        Level = 어려움;
                    }
                    else if (Level  == 3)
                    {
                        Level = 쉬움;
                    }
                    break;
                }
                else if(32 == c)
                {
                    select = 1;
                    break;
                }
            }
 
        }
    }
}
 
void Minesweeper::SetLevel()
{
    if (쉬움 == Level)
    {
        Width = 9;
        Length = 9;
        Mine = 10;
 
    }
    else if (중간 == Level)
    {
        Width = 16;
        Length = 16;
        Mine = 40;
    }
    else if (어려움 == Level)
    {
        Width = 16;
        Length = 30;
        Mine = 99;
    }
}
 
void Minesweeper::MakeMap()
{
    pMap = new Square[Width * Length]; // 실수 2스택
    // 모든배열을 NoShow 값 대입
    for (int x = 0; x < (Width * Length); ++x)
    {
        pMap[x].Show = Noshow;
        pMap[x].RoundMine = 0;
        pMap[x].Nowpoint = Nopoint;
    }
 
    // 폭탄설치
    srand(time(NULL));
    int num = 0;
    for (int x = 0; x < Mine; ++x) // 폭탄 갯수만큼 반복
    {
        while (true)
        {
            num =rand() % (Width* Length);  // 실수 1스택 
             if (pMap[num].RoundMine != 9) // 폭탄이 없는곳만 폭탄 설치
            {
                pMap[num].RoundMine = 9;
                break;
            }
        }
 
    }
 
 }
 
 
int Minesweeper::KeyInput()
{
    while (true)
    {
 
        if (_kbhit()) {
 
            char c = _getch();
 
            if (-32 == c)
            {
                c = _getch();
 
                switch (c)
                {
                case LEFT:   // 왼쪽키 입력                    
                    return left;
                case RIGHT:  // 오른쪽키 입력
                    return right;
                case UP:     // 윗키 입력
                    return up;
                case DOWN:   // 아래키 입력
                    return down;
                }
            }
            else if (32 == c) // 스페이스 입력
            {
                return space;
            }
            else if (65 == c || 97 == c) // a 입력
            {
                return a;
            }
        }
    }
    
}
 
void Minesweeper::ShowMap()
{    
    system("cls");
    int a = 0;
    std::cout << "\n\n       ";
    for (int z = 1; z <= Width; ++z)
    {
        if (z < 10)
        {
            std::cout << " ";
        }
        std::cout << z;
    }
    std::cout << "\n";
    for (int x = 1; x <= Length; ++x)
    {
        if (x < 10)
        {
            std::cout << " ";
        }
        std::cout << "     " << x;
        for (int y = 1; y <= Width; ++y)
        {
            ShowSquare(&pMap[a++]);
        }
        std::cout << std::endl;
    }
 
    std::cout << "\n        Space : 오픈\n            A : 폭탄 표시\n         이동 : 방향키\n         폭탄  :" <<  Mine << "개";
 
}
 
 
 
void Minesweeper::ShowSquare(const Square* _sq)  // 한칸을 표현 
{
    if (Noshow == _sq->Show) 
    {
        if (Nopoint == _sq->Nowpoint)
        {
            Textcolor(WHITE, GREEN);
            std::cout << "  ";
            Textcolor(WHITE, BLACK);
        }
        else  if(Yespoint == _sq->Nowpoint)
        {
            Textcolor(WHITE, WHITE);
            std::cout << "  ";
            Textcolor(WHITE, BLACK);
        }
    }
    else if (깃발 == _sq->Show)
    {
        if (Nopoint == _sq->Nowpoint)
        {
            Textcolor(RED, GREEN);
            std::cout << " X";
            Textcolor(WHITE, BLACK);
        }
        else  if (Yespoint == _sq->Nowpoint)
        {
            Textcolor(RED, WHITE);
            std::cout << " X";
            Textcolor(WHITE, BLACK);
        }
    }
    else if (show == _sq->Show)
    {
 
        if (Nopoint == _sq->Nowpoint)
        {
            if (_sq->RoundMine <= 8)
            {
                Textcolor(BLACK, BLUE);
                std::cout << " ";
                std::cout << _sq->RoundMine;
                Textcolor(WHITE, BLACK);
            }
            else if (_sq->RoundMine == 9)
            {
                Textcolor(BLACK, BLUE);
                std::cout << " M";
                Textcolor(WHITE, BLACK);
            }
        }
        else  if (Yespoint == _sq->Nowpoint)
        {
            if (_sq->RoundMine <= 8)
            {
                Textcolor(BLACK, WHITE);
                std::cout << " ";
                std::cout << _sq->RoundMine;
                Textcolor(WHITE, BLACK);
            }
            else if (_sq->RoundMine == 9)
            {
                Textcolor(BLACK, WHITE);
                std::cout << " M";
                Textcolor(WHITE, BLACK);
            }
        }
 
    }
}
 
void Minesweeper::MovePoint(int where)
{
    
    if (left == where) 
    {    
        pMap[Calculate()].Nowpoint = Nopoint;
        --PointX;
        pMap[Calculate()].Nowpoint = Yespoint;
    }
 
    else if (right == where)
    {
        pMap[Calculate()].Nowpoint = Nopoint;
        ++PointX;
        pMap[Calculate()].Nowpoint = Yespoint;
    }
    else if (up == where)
    {
        pMap[Calculate()].Nowpoint = Nopoint;
        --PointY;
        pMap[Calculate()].Nowpoint = Yespoint;
    }
    else if (down == where)
    {
        pMap[Calculate()].Nowpoint = Nopoint;
        ++PointY;
        pMap[Calculate()].Nowpoint = Yespoint;
    }
    else if (space == where)
    {
        if (pMap[Calculate()].Show != show)
        {
            Open(PointX, PointY);
        }
    }
    else if (a == where)
    {
        if (깃발 == pMap[Calculate()].Show)
        {
            pMap[Calculate()].Show = Noshow;
        }
        else if (Noshow == pMap[Calculate()].Show)
        {
            pMap[Calculate()].Show = 깃발;
        }
    }
}
 
int Minesweeper::Calculate()
{
    while (true)
    {
        if (PointX > Width)
        {
            PointX = PointX - Width;
            ++PointY;
        }
        else if (PointX < 1)
        {
            PointX = PointX + Width;
            --PointY;
        }
        else if (PointY < 1)
        {
            ++PointY;
        }
        else if (PointY > Length)
            --PointY;
        else
            break;
    
    }
 
    return (PointX + (PointY - 1) * Width - 1);     
}
 
int cal(int x, int y, int wide)
{
    return (x + (y - 1) * wide - 1);
}
 
void Minesweeper::MineCount()
{
    for (int x = 1; x <= Width; ++x)
    {
        for (int y = 1; y <= Length; ++y)
        {
            int count = 0;
            // 1번자리
            if (1 == x || 1 == y)
            {
 
            }
            else
            {
                if (pMap[cal(x - 1, y - 1, Width)].RoundMine == 9)
                    ++count;
            }
            // 2번자리
 
            if (1 != y)
            {
                if (pMap[cal(x, y - 1, Width)].RoundMine == 9)
                    ++count;
            }
            // 3번자리
            if (x == Width || y == 1)
            {}
            else
            {
                if (pMap[cal(x + 1, y - 1, Width)].RoundMine == 9)
                    ++count;
            }
            // 4번자리
            if (1 != x)
            {
                if (pMap[cal(x - 1, y, Width)].RoundMine == 9)
                    ++count;
            }
            // 6번자리
            if (Width != x)
            {
                if (pMap[cal(x + 1, y, Width)].RoundMine == 9)
                    ++count;
            }
            // 7번자리
            if (Length == y || 1 == x)
            {
            }
            else
            {
                if (pMap[cal(x - 1, y + 1, Width)].RoundMine == 9)
                    ++count;
            }
            // 8번자리 
            if (Length != y)
            {
                if (pMap[cal(x, y + 1, Width)].RoundMine == 9)
                    ++count;
            }
 
            // 9번자리
 
            if (Length == y || Width == x) {}
            else
            {
                if (pMap[cal(x+1 , y + 1, Width)].RoundMine == 9)
                    ++count;
            }
 
            if (pMap[cal(x, y, Width)].RoundMine != 9)
            {
                pMap[cal(x, y, Width)].RoundMine = count;    
            }
        }
 
 
 
 
    }
}
 
void Minesweeper::Open(int x, int y)
{
    if (pMap[cal(x, y, Width)].Show != show)
    {
 
        if (pMap[cal(x, y, Width)].RoundMine == 0) // 0이면 주변을 열어야함
        {
            // 1번
            if( 1 ==x || 1== y)
            { }
            else
            {
                Open(x - 1, y - 1);
            }
            // 2번
            if (y != 1)
            {
                Open(x, y - 1);
            }
            // 3번
            if ( 1 == y || Width == x)
            { }
            else
            {
                Open(x + 1, y - 1);
            }
            // 4번
            if (1 != x)
            {
                Open(x - 1, y);
            }
            // 5번
            pMap[cal(x, y, Width)].Show = show;
            // 6번
            if (Width != x)
            {
                Open(x + 1, y);
            }
            // 7번
            if ( 1 ==x || Length == y)
            {}
            else
            {
                Open(x - 1, y + 1);
            }
            // 8번
            if (Length != y)
            {
                Open(x, y + 1);
            }
            // 9번
            if (Width == x || Length == y)
            {}
            else
            {
                Open(x + 1, y + 1);
            }
        }
        else if (pMap[cal(x, y, Width)].RoundMine == 9) // 패배
        {
            pMap[cal(x, y, Width)].Show = show;
            victory = 2;
        }
        else // 숫자 표시
        {
            pMap[cal(x, y, Width)].Show = show;
        }
    }
}
 
void Minesweeper::VictoryCheck()
{
    int CountOpen = 0;
    for (int x = 0; x < (Width*Length); ++x)
    {
        if (pMap[x].Show == show)
            ++CountOpen;
    }
    
    if (CountOpen == (Width * Length) - Mine)
        victory = 1;
 
}
 
 
 
 
Minesweeper::Minesweeper()
    :Level(1)
    ,Width(0)
    ,Length(0)
    ,Mine(0)
    ,pMap(nullptr)
    ,PointX(1)
    ,PointY(1)
    ,victory(0)
{
 
}
 
Minesweeper::~Minesweeper()
{
}

#pragma once
#include <iostream>
#include <windows.h>
#include <conio.h>
#include <vector>
 
#define UP 72
#define DOWN 80
#define LEFT 75
#define RIGHT 77
 
void Textcolor(int foreground, int background);
 
enum show
{
    Noshow,
    show,
    깃발,
};
enum point
{
    Nopoint,
    Yespoint,
};
enum 난이도
{
    쉬움,
    중간,
    어려움,
};
enum Color
{
    BLACK,
    BLUE,
    GREEN,
    CYAN,
    RED,
    MAGENTA,
    BROWN,
    LIGHTGRAY,
    DARKGRAY,
    LIGHTBLUE,
    LIGHTGREEN,
    LIGHTCYAN,
    LIGHTRED,
    LIGHTMAGENTA,
    YELLOW,
    WHITE
};
enum KeyInput
{
    left,
    right,
    up,
    down,
    space,
    a,
};
 
struct Square
{
public:
    int Show;      // 0 : 안보여줌  1: 보여줌  2: 깃발
    int RoundMine; // 주변의 마인 갯수 0~8 가능 9: 폭탄 표시 
    bool Nowpoint; // 0 이면 x 1 이면 가리키고있는중
};
 
class Minesweeper
{
private:
    int Level;  // 난이도
    int Width;  // 가로 길이
    int Length; // 세로 길이
    int Mine;   // 지뢰 갯수
    Square* pMap;// 생성된 맵 포인터
    int PointX;
    int PointY;
    int victory; // 0: 계속진행 1: 승리 2: 패배
 
public:
    void GameStart();
 
private:
    void SelectLevel();
    void SetLevel();
    void MakeMap();
    int KeyInput();
    void ShowMap();
    void ShowSquare(const Square* _sq);
    void MovePoint(int where);
    int Calculate();
    void MineCount();
    void Open(int x, int y);
    void VictoryCheck();
 
public:
 
    Minesweeper();
    ~Minesweeper();
 
};
 
 
int cal(int x, int y, int wide);