라비린스6_개발 블로그

목차

추가 기능

• 엔딩 시 이미지 콘솔창에 출력
• 게임 시작 시 메뉴 변경
• 엔딩 목록 수집

엔딩 이미지

엔딩 이미지는 현재 2종만 있으며 나중에 마무리할때 전체 이미지 추가할 예정입니다.

이미지는 챗 gpt 를 통해 생성했습니다.

직접 그릴까 했는데 gpt가 이렇게까지 잘그려줄 줄 몰랐네요...

엔딩 목록(수집요소)

엔딩 목록은 [엔딩 목록] 창에서 확인 할 수 있다.

해당 엔딩을 얻으면 ??? 에서 엔딩 이름과 획득 방법이 표시된다.

새로운 엔딩을 얻을 시 txt 파일에 저장되며,

프로그램 실행 시 txt 파일을 읽어 엔딩별 획득 여부를 불러온다.

Endlist.txt 파일에 엔딩여부가 저장되며

엔딩별 획득여부를 Y, N 으로 표시한다.

소스코드

1. 콘솔창에 bmp 이미지 출력

// 이미지 출력
void ShowBitmap(const char* filename)
{
    HBITMAP hBitmap;
    BITMAP bitmap;
    HDC hdc, hdcMem;
    HWND hwnd = GetConsoleWindow(); // 콘솔 창 핸들 가져오기

    // 콘솔 DC 얻기
    hdc = GetDC(hwnd);
    hBitmap = (HBITMAP)LoadImageA(NULL, filename, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);
    if (!hBitmap) 
    {
        return;
    }

    hdcMem = CreateCompatibleDC(hdc);
    SelectObject(hdcMem, hBitmap);
    GetObject(hBitmap, sizeof(BITMAP), &bitmap);

    // 20, 50 위치에 200 x 200 사이즈로 출력
    StretchBlt(hdc, 20, 100, 250, 250, hdcMem, 0, 0, bitmap.bmWidth, bitmap.bmHeight, SRCCOPY);

    DeleteDC(hdcMem);
    ReleaseDC(hwnd, hdc);
    DeleteObject(hBitmap);
}

파일 경로를 기준으로 bmp 이미지를 출력한다.

    if (Ending_imgName[n]!="")
    {
        // 이미지 출력하기
        ShowBitmap(Ending_imgName[n].c_str());
    }

vector에 엔딩별 이미지 경로를 저장한 후 Showbitmap을 호출해서 이미지를 콘솔에 출력합니다.

2. txt 파일에 엔딩 수집여부 저장 및 불러오기

void SaveEndingList(int endNo)
{
    std::ifstream fileIn("Endlist.txt"); // 기존 파일 읽기
    std::vector<std::string> lines; // 파일 내용을 저장할 벡터
    std::string line;

    if (!fileIn.is_open()) {
        std::cout << "파일을 열 수 없습니다!" << std::endl;
        return;
    }
    // 파일 내용을 읽어서 벡터에 저장
    while (getline(fileIn, line)) 
    {
        std::stringstream ss(line);
        std::string number, isEnable;
        ss >> number >> isEnable;  // 번호, Y/N 읽기

        // 특정 번호를 찾으면 변경
        if (std::stoi(number) == endNo) 
        {
            if (isEnable == "N")
            {
                cout << "신규 엔딩이 목록에 추가되었습니다." << "\n";
            }
            isEnable = "Y"; // 특정 번호의 값을 Y로 변경
        }

        lines.push_back(number + " " + isEnable);
    }
    fileIn.close(); // 파일 닫기

    // 수정된 내용을 다시 파일에 저장
    std::ofstream fileOut("Endlist.txt"); // 덮어쓰기 모드

    if (!fileOut.is_open()) 
    {
        std::cout << "파일을 열 수 없습니다!" << std::endl;
        return;
    }

    for (const auto& l : lines) 
    {
        fileOut << l << "\n"; // 줄 단위로 다시 쓰기
    }
    fileOut.close();

    std::cout << "파일 저장 완료!" << std::endl;
}

엔딩 번호(0~9) 를 기준으로 찾아 엔딩여부(Y/N) 을 업데이트합니다.

void SetEndingInfo()
{
    Endinfo[0] = { 0,"중독", "독약을 마시고 사망", false};
    Endinfo[1] = { 1,"추락", "함정에 빠진 후 사망", false};
    // Endinfo[9]번까지 있지만 여기선 생략

    // 파일에서 획득여부 읽어와야됨

    string line;
    ifstream file("Endlist.txt"); 

    if (file.is_open()) 
    {
        while (getline(file, line)) 
        {
            std::stringstream ss(line); // stringstream으로 줄을 처리

            std::string number;
            std::string isEnable;

            ss >> number;  // 번호 읽기
            getline(ss >> std::ws, isEnable);  // 공백 무시하고 나머지 읽기
            if (isEnable == "Y")
            {
                Endinfo[stoi(number)].isCollected = true;
            }
        }
        file.close(); // 열었떤 파일을 닫는다. 
    }
    else 
    {
        cout << "Unable to open file";
    }
}

프로그램 실행시 Endlist.txt 파일을 읽어 엔딩 수집 여부를 Endinfo 구조체에 저장합니다.

전체코드(깃허브 링크)

https://github.com/Chaeyunbyun/GameProject_Test

백준 13022번 - 늑대와 올바른 단어(실버 2)

https://www.acmicpc.net/problem/13022

풀이

입력된 문자열이 규칙 1, 2를 충족시키는지 검사해야 한다.

규칙1: w, o, l, f 가 n 번 나온 단어는 올바른 단어(순서는 w, o, l, f 로 나와야함)

규칙2: 올바른 단어 2개를 이은 단어도 올바른 단어

규칙 1 을 만족시킬수 있는 단어는 wolf, wwoollff.. 등이 있다.

우선 문자가 반복된 횟수를 구한다. (wcnt 에 저장)

문자가 바뀐 지점 인덱스 +1 을 저장해서 구했다.

    for (int i = 0; i < str.size(); i++)
    {
        // 문자가 변한 구간
        if (i>=1 && str[i]!= str[i-1])
        {
            wcnt = i;
            break;
        }
    }

이제 각 문자별로 등장횟수를 카운트한다.

저는 'f' 를 기준으로 f다음에 f를 제외한 다른 문자가 나오면

각 문자별 등장 횟수가 wcnt 와 일치 하는지 검사했습니다.

여기서 1번 조건을 충족시키려면 현재까지 구간의 문자열은

w x (wcnt 횟수 반복) + o x (wcnt 횟수 반복)  +  l x (wcnt 횟수 반복)  + f x (wcnt 횟수 반복) 입니다.

만약 현재 구간까지 문자열이 1번 조건을 충족시킨다면, 다음 구간도 검사해야겠죠.

남은 구간만 다시 문자열을 동일하게 검사하면 됩니다.

저는 replace 로 현재검사한 구간을 제거하고

아직 문자가 남아있다면 재귀시켜서 다시 검사했습니다.

전체 코드

#include <iostream>
#include <vector>
#include <string>
#include <cmath>
#include <algorithm>
using namespace std;

bool isWolf(string str)
{
    int wcnt = 0;

    // 각각 문자열 카운트
    int w = 0;
    int o = 0;
    int l = 0;
    int f = 0;

    for (int i = 0; i < str.size(); i++)
    {
        // 문자가 변한 구간
        if (i>=1 && str[i]!= str[i-1])
        {
            wcnt = i;
            break;
        }
    }

    for (int i = 0; i < str.size(); i++)
    {
        if (str[i] == 'w')
        {
            w++;
        }
        if (str[i] == 'o')
        {
            o++;
        }
        if (str[i] == 'l')
        {
            l++;
        }
        if (str[i] == 'f')
        {
            f++;

            // f 연속 끝나면 발동
            // 문자열 인덱스에러 방지
            if (i == str.size() - 1 || (i < str.size() - 1 && str[i] != str[i + 1]))
            {
                // 모든 글자의 수가 같으면 
                if (wcnt == w && wcnt == o && wcnt == l && wcnt == f)
                {
                    string wolfstr = "wolf";
                    string findstr = "";

                    for (int j = 0; j < wolfstr.size(); j++)
                    {
                        for (int k = 0; k < wcnt; k++)
                        {
                            findstr += wolfstr[j];
                        }
                    }

                    // findstr 이 있는지 확인
                    int pos = str.find(findstr);
                    // 없으면 리턴시킴
                    if (pos== string::npos)
                    {
                        return false;
                    }
                    // 문자 제거
                    str = str.replace(str.find(findstr), findstr.length(), "");

                    if (str.size() == 0)
                    {
                        return true;
                    }
                    else
                    {
                        // 다시 문자 검사
                        return isWolf(str);
                    }
                }
                else
                {
                    return false;
                }
            }
        }
    }
    return false;
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int result = 0;

    string str;
    cin >> str;

    cout << isWolf(str);
    return 0;
}

목차

추가 기능

• 소지금 시스템 및 상점 시스템 추가
• NPC 추가
• NPC 별 이벤트 추가
• 헤더파일 추가, 기존 전역변수들 멤버변수로 옮김
• '훔치기' 관련 수치 추가(상점에서 훔치기 선택지에서 사용됨)

NPC 관련 처리는 클래스를 따로 분리했습니다.

[상점] 이벤트는 상인 npc 를 만나면 발생합니다

상점에 있는 아이템 3종은 랜덤으로 출현합니다

[훔치기]는 성공 확률이 표시 되는데, 처음에 도적을 선택했다면 성공확률이 높아집니다

[훔치기] 실패 시 일정 데미지를 입게 됩니다 

소스코드(NPC 관련 클래스)

#include "Npc_Game.h"
#include <iostream>
#include <vector>
#include <random>
#include <conio.h> // Windows에서 방향키 입력을 위해 사용
#include <random>
#include <algorithm> // 셔플 시 사용

#include "GameProject.h"
/// NPC 정보, 조우 이벤트

// npc 별 이벤트 분기
// 리턴: 아이템번호: 아이템을 인벤에 추가
// 리턴: 100 - 처리 x
// 리턴: -100 - 사망
// 리턴: -50 - 체력감소
int Npc_Game::NpcEvent(int NpcNo, bool isLotto)
{
    // 상인
	if (NpcNo == 0)
	{
        cout << " -- [상인]을 만났습니다. -- " << "\n";
		int ret = ShopEvent();
        _getch();
        return ret;
	}
    // 도적단 두목
	if (NpcNo == 1)
	{
        cout << " -- [도적단 두목]을 만났습니다.. -- " << "\n";

        if (Myjob == "rogue")
        {
            cout << "도적단 두목: 어," << MyName + " 이잖아? 넌 그냥 보내줄게" << "\n";
            _getch();
            return 100;
        }
        cout << "도적단 두목: 돈 내놔. 30원 주면 보내줄게." << "\n";

        if (MyMoney>= 30)
        {
            cout << " -- 30원을 잃었습니다. -- " << "\n";
            MyMoney -= 30;
            _getch();
            return 100;
        }
        else
        {
            cout << "도적단 두목: 뭐야 돈 없어? 그럼 목숨이라도 내놔야지!" << "\n";
            MyMoney = 0;
            _getch();
            return -100;
        }
	}
    // 타노스
    if (NpcNo == 2)
    {
        cout << " -- [타노스]를 만났습니다.. -- " << "\n";
        cout << "타노스: 내가 핑거 스냅을 하면 50%의 인류가 소멸한다" << "\n";
        cout << "타노스: 넌 살아남을 수 있을까?" << "\n";
        cout << "\n";
        cout << "     -- 딱! --" << "\n";
        cout << "------------------" << "\n";
        cout << "\n";

        _getch();

        // 시드값을 얻기 위한 random_device 생성.
        std::random_device rdItem;

        // random_device 를 통해 난수 생성 엔진을 초기화 한다.
        std::mt19937 genItem(rdItem());

        // 0 부터 99 까지 균등하게 나타나는 난수열을 생성하기 위해 균등 분포 정의.
        std::uniform_int_distribution<int> disItem(0, 99);

        // 난수를 한 번 생성해서 변수에 저장
        int randItemValue = disItem(genItem);

        // 생존
        if (randItemValue < 50)
        {
            return 100;
        }
        else
        {
            return -100;
        }
    }
    if (NpcNo == 3)
    {
        cout << "복권방 사장: 안녕하세요" << "\n";
        cout << "복권방 사장: 복권을 가져와야 응모 가능합니다." << "\n";

        if (isLotto == false)
        {
            return -100;
        }
        else
        {
            _getch();

            // 시드값을 얻기 위한 random_device 생성.
            std::random_device rdItem;

            // random_device 를 통해 난수 생성 엔진을 초기화 한다.
            std::mt19937 genItem(rdItem());

            // 0 부터 99 까지 균등하게 나타나는 난수열을 생성하기 위해 균등 분포 정의.
            std::uniform_int_distribution<int> disItem(0, 99);

            // 난수를 한 번 생성해서 변수에 저장
            int randItemValue = disItem(genItem);

            // 당첨
            if (randItemValue < 20)
            {
                return 101;
            }
            else
            {
                cout << "복권방 사장: 아쉽네요, 다음 기회에..." << "\n";
                return 100;
            }
        }
    }
}

Npc_Game::Itemcost iteminfo[6];
Npc_Game::ItemDisc itemdisc[6];

// gameProject_test 의 itemcode 와 맞춰야함
//0,"빨간물약"
//1,"파란물약"
//2,"이상한사탕"
//3,"물"
//4,"독약"
//5,"복권"
//6,"데스노트"

void ItemCostInfo()
{
    // 0: 필드에서만 드랍됨
    // itemcode, itemname, itemcost
    iteminfo[0] = { 0,"빨간물약",50};
    iteminfo[1] = { 1,"파란물약",50};
    iteminfo[2] = { 2,"이상한사탕",0};
    iteminfo[3] = { 3,"물",10 };
    iteminfo[4] = { 4,"독약",20};
    iteminfo[5] = { 5,"복권",150 };
}

void ItemDiscInfo()
{
    itemdisc[0] = { 0,"Hp를 10 회복시킨다." };
    itemdisc[1] = { 1,"Mp를 10 회복시킨다." };
    itemdisc[2] = { 2,"레벨이 1 증가" };
    itemdisc[3] = { 3,"평범한 물. 효과는 없어보인다..." };
    itemdisc[4] = { 4,"불길한 느낌이 나는 물약이다" };
    itemdisc[5] = { 5,"[복권방]으로 가져가면 좋은일이 있을수도" };

}

void Npc_Game::LoadShopItemInfo()
{
    ItemCostInfo();
    ItemDiscInfo();

    // 전체 아이템 개수 만큼 추가
    for (int i = 0; i < 6; i++)
    {
        if (iteminfo[i].intCost != 0)
        {
            AllItem.push_back(iteminfo[i].strItemName);
            MapItem.insert(make_pair(iteminfo[i].strItemName, iteminfo[i].intItemNo));
        }
    }
}

// 아이템 설명 보기 / 구매 처리
// 구매 및 훔치기 성공: 1 구매 안함: 0 훔침 실패: 2
// 구매한 경우 상품목록에서 제외
int ShowItemDisc(int itemCode, vector<string> &RuleItem)
{
    cout << "설명: " << itemdisc[itemCode].strItemDisc << "\n";
    cout << "가격: " << iteminfo[itemCode].intCost << "\n";
    cout << "0: 구매하기\n1: 훔치기 (성공 확률:"<<MySnatch<<"%)" << endl;
    cout << " ( 돌아가기: 0~1를 제외한 아무 키를 누르면 돌아갑니다.)" << endl;

    char key = _getch(); // 키 입력 받기

    if (key == '0')
    {
        if (MyMoney < iteminfo[itemCode].intCost)
        {
            cout << "잔액이 부족합니다." << "\n";
            _getch();
            return 0;
        }
        cout << iteminfo[itemCode].strItemName <<" 구매하였습니다.\n";
        MyMoney -= iteminfo[itemCode].intCost;
        RuleItem.erase(RuleItem.begin() + itemCode);

        _getch();
        return 1;
    }
    // 훔치기
    else if (key == '1')
    {
        // 시드값을 얻기 위한 random_device 생성.
        std::random_device rd;

        // random_device 를 통해 난수 생성 엔진을 초기화 한다.
        std::mt19937 gen(rd());

        // 0 부터 99 까지 균등하게 나타나는 난수열을 생성하기 위해 균등 분포 정의.
        std::uniform_int_distribution<int> dis(0, 99);

        // 난수를 한 번 생성해서 변수에 저장
        int randValue = dis(gen);
        if (randValue < MySnatch)
        {
            // 성공
            cout << iteminfo[itemCode].strItemName << " 훔치기를 성공했습니다.\n";
            
            _getch();
            return 1;
        }
        else
        {
            // 실패
            cout << iteminfo[itemCode].strItemName << " 훔치기를 실패했습니다.\n";
            _getch();
            return 2;
        }
    }
}

// 상점 이벤트
// 구매한 경우 수량 처리를 위해 itemNo를 리턴
// 구매 하지 않으면 100 리턴
int Npc_Game::ShopEvent()
{
    vector<string> RuleItem;
    int pntPosition = 0;

    // 랜덤 시드 설정
    random_device rd;
    mt19937 gen(rd());

    // 셔플
    shuffle(AllItem.begin(), AllItem.end(), gen);

    // 앞에서 3개만 선택
    RuleItem.assign(AllItem.begin(), AllItem.begin() + 3);

    RuleItem.push_back("돌아가기");

    while (true)
    {
        // 메뉴 출력
        system("cls"); // Windows에서는 "cls"로 변경
        cout << "상인: 구매하고 싶은 물건을 선택하세요." << "(현재 소지금: "<< MyMoney << ")" << endl;

        string pntItemName = "";

        for (int i = 0; i < RuleItem.size(); i++) {
            if (i == pntPosition) {
                cout << ">> " << RuleItem[i] << endl;
                pntItemName = RuleItem[i];
            }
            else {
                cout << "   " << RuleItem[i] << endl;
            }
        }

        // 키 입력 처리
        int key = _getch(); // 키 입력을 받음
        if (key == 72) { // 위쪽 방향키
            pntPosition = (pntPosition - 1 + RuleItem.size()) % RuleItem.size();
        }
        else if (key == 80) { // 아래쪽 방향키
            pntPosition = (pntPosition + 1) % RuleItem.size();
        }
        else if (key == 13)
        { // Enter 키
         // 선택된 메뉴에 따라 동작 실행
            // 1번
            if (pntPosition >= 0 && pntPosition <3)
            {
                int itemNo = MapItem[pntItemName];

                int result = ShowItemDisc(itemNo, RuleItem);

                // 구매, 훔침 성공 - 인벤토리 수량 조정을 위해 리턴
                if (result == 1)
                {
                    return itemNo;
                }
                // 흠침 실패
                if (result == 2)
                {
                    return -50;
                }
                if (result == 0)
                {
                    continue;
                }
            }
            if (pntPosition == 3)
            {
                cout << "상점을 나갑니다...\n";
                _getch(); 
                return 100;
            }
        }
    }
}

전체 소스코드(링크)

https://github.com/Chaeyunbyun/GameProject_Test

실행파일

목차

서론

C++ 구조체, 배열 활용 연습할 겸 텍스트 기반 RPG 게임을 만들어 봤습니다

사실 기능은 진짜없는데도 소스가 750줄이 넘네요

현재 기능은 간단한 탐색, 아이템 사용, 인벤토리 정도밖에 없습니다

몬스터와 턴제 전도 구현하고 싶긴 한데 가능할지는 잘 모르겠네요

사용자의 선택지에 따라서 게임이 진행되고, 특정 선택지는 체력이 깎이거나 배드 엔딩으로 갈 수 있습니다.

전체소스는 깃허브 링크에 공개되어 있습니다

소스가 긴 관계로 포스트에서는 핵심적인 내용만 정리하겠습니다

게임소개

게임 목적은 죽지않도록 주의하며 엔딩조건을 만족시키면 됩니다

처음 시작하면 캐릭터의 이름을 짓고 직업을 선택합니다.

직업별로 스탯은 다릅니다. 참고로 지금 공격력이나 마법 관련 스탯은 존재하긴 하는데 기능을 안합니다

메뉴는 인벤토리, 캐릭터, 탐색하기, 게임 종료의 4가지 입니다.

위 아래 방향키로 조작해서 엔터눌러서 선택하시면 됩니다

인벤토리에는 현재 보유한 아이템의 종류와 수량이 뜹니다.

설명과 같이 숫자 키를 눌러 아이템 번호를 입력하면 해당 아이템이 사용됩니다.

(예: 해당 이미지에서 0 을 누르면 [파란물약] 이 사용됨)

아이템 설명은 간단하게 써 드리겠습니다

얻을 확률이 낮은 아이템도 2종 있는데 이건 빼고 쓰겠습니다

아이템 사용시 다음과 같이 설명과 효과를 표시합니다

캐릭터 선택 시 현재 캐릭터 정보를 표시 합니다

참고로 Hp가 0이 되면 게임 오버됩니다

탐색하기는 아이템 획득, 함정, 특수이벤트의 이벤트가 일어납니다

함정 이벤트의 경우 체력이 하락하기 때문에 Hp관리에 주의하셔야겠습니다.

엔딩조건에 도달하면 게임이 종료됩니다.

엔딩 종류는 총 7개로, 이중 배드엔딩은 4개입니다

보물을 찾는 것 외에도 히든엔딩이 2개 있고, 배드엔딩중에서도 히든엔딩이 하나 있습니다

궁금하면 한번 해보시거나 깃허브 소스를 확인해보세요

소스코드(핵심 부분만)

먼저 인벤토리, 캐릭터, 아이템 정보는 구조체로 선언되어 있습니다.

인벤토리 - 아이템 정보는 아이템 번호가 키값이라고 생각하시면 됩니다.

struct MyCharacter
{
    int intLevel;
    string strName;
    int intHP;
    int intMp;
    int intAttack;
    int intMagic;
};

struct Inventorty
{
    int intItemNo;
    int intItemCount;
};

struct Iteminfo
{
    int intItemNo;
    string strItemName;
    int RestoreHp;
    int RestoreMp;
    int Levelup;
};

아이템의 정보를 등록해주는 함수, 및 초기 인벤토리를 설정해 주는 함수입니다.

void ItemMaster()
{
    // itemcode, itemname, hp , mp, level
    iteminfo[0] = { 0,"빨간물약",10,0,0 };
    iteminfo[1] = { 1,"파란물약",0,10,0 };
    iteminfo[2] = { 2,"이상한사탕",0,0,1 };
    iteminfo[3] = { 3,"물",0,0,0 };
    iteminfo[4] = { 4,"독약",-100,0,0 };
    iteminfo[5] = { 5,"복권",0,0,0 };
    iteminfo[6] = { 6,"데스노트",0,0,0 };
}

void InvenFirst()
{
    MyInven[0] = { 0,0 };
    MyInven[1] = { 0,0 };
    MyInven[2] = { 0,0 };
    MyInven[3] = { 0,0 };
    MyInven[4] = { 0,0 };
    MyInven[5] = { 0,0 };
    MyInven[6] = { 0,0 };

}

방향키로 조작하는 메뉴를 보여주는 코드입니다

메뉴 목록에 {종료하기, 돌아가기}를 넣은 후 

pointerPosition 값에 따라(사용자가 상 하로 이동하며 정할수있는 현재 위치)

엔터 시 선택한 메뉴별로 처리합니다.

  cout << "-- 종료하시겠습니까? --" << endl;
                    vector<string> menuItems = { "종료하기", "돌아가기" };
                    int pointerPosition = 0;
                    while (true)
                    {
                        system("cls");

                        for (int i = 0; i < menuItems.size(); i++)
                        {
                            if (i == pointerPosition)
                            {
                                cout << ">> " << menuItems[i] << endl;
                            }
                            else {
                                cout << "   " << menuItems[i] << endl;
                            }
                        }

                        // 키 입력 대기
                        int key = _getch();

                        // 위쪽 방향키
                        if (key == 72)
                        {
                            pointerPosition = (pointerPosition - 1 + menuItems.size()) % menuItems.size();
                        }
                        // 아래쪽 방향키
                        else if (key == 80)
                        {
                            pointerPosition = (pointerPosition + 1) % menuItems.size();
                        }
                        // Enter 키
                        else if (key == 13)
                        {
                            // 종료하기
                            if (pointerPosition == 0)
                            {
                                cout << "프로그램을 종료합니다." << endl;
                                return 0;
                            }
                            // 돌아가기
                            if (pointerPosition == 1)
                            {
                                break;
                            }
                        }
                    }

아이템을 얻었을 때 인벤토리에 추가하는 코드입니다.

지금 보니 인벤토리 개수 늘리고 코드를 안바꿔서 안맞는 부분이 있네요...

루프를 돌며 인벤토리에 IntItemno 를 기준으로 탐색하고 인벤토리에 추가하거나 수량을 +1 시킵니다

void AddInvent(int ItemNo, int ItemCount)
{
	// 특수 엔딩에 사용되는 변수
    if (ItemNo == 5)
    {
        isLotto = true;
    }

    // 먼저 인벤토리에 같은 아이템이 있는지 확인
    for (int i = 0; i < 5; i++)
    {
        if (MyInven[i].intItemNo == ItemNo) // 이미 존재하는 아이템 번호라면
        {
            MyInven[i].intItemCount += ItemCount; // 수량을 추가
            cout << iteminfo[ItemNo].strItemName + " " + to_string(ItemCount) + "개 추가." << endl;
            return; // 함수 종료
        }
    }

    // 인벤토리에 동일한 아이템이 없으면 빈 슬롯에 추가
    for (int i = 0; i < 5; i++)
    {
        if (MyInven[i].intItemCount == 0) // 빈 슬롯 찾기
        {
            MyInven[i].intItemNo = ItemNo;
            MyInven[i].intItemCount = ItemCount;

            // 아이템 정보 출력
            for (int j = 0; j < 10; j++)
            {
                if (iteminfo[j].intItemNo == ItemNo)
                {
                    cout << iteminfo[j].strItemName + " " + to_string(ItemCount) + "개 획득." << endl;
                    return;
                }
            }
        }
    }
}

인벤토리 확인 함수입니다.

현재 가지고 있는 아이템 종류/ 개수를 표시합니다.

아이템이 하나도 없다면 비어 있음 으로 표시 합니다.

void ShowMyInvent()
{
    int intCount = 0;

    cout << "**** 인벤토리 ****" << endl;
    cout << " ( ※ 아이템 번호를 입력하면 사용 가능합니다. (0~ 4))" << endl;
    cout << " ( 돌아가기: 0~4를 제외한 아무 키를 누르면 돌아갑니다.)" << endl;
    for (int i = 0; i < 5; i++)
    {
        if (MyInven[i].intItemCount>0)
        {
            for (int j = 0; j < 10; j++)
            {
                if (MyInven[i].intItemNo == iteminfo[j].intItemNo)
                {
                    cout << to_string(i)+":"+  iteminfo[j].strItemName + "/" + to_string(MyInven[i].intItemCount) + "개" << endl;
                    intCount++;
                    break;
                }
            }
        }
    }

    if (intCount == 0)
    {
        cout << "비어 있음." << endl;
    }
}

아이템 사용 함수 코드 중 일부입니다.

먼저 인벤토리 에 있는 아이템 수량을 차감합니다.

그리고 사용된 아이템 번호(useItemNo) 를 기준으로 해당되는 아이템의 아이템 정보를 가져옵니다

해당 아이템에 따라 Mp, Hp,레벨 값을 증감시킵니다

만약 Hp가 0 이 된다면 (if (MyCh.intHP <= 0) 부분)

배드엔딩으로 보냅니다. GameEnding()은 엔딩을 처리하는 함수입니다

 MyInven[InventNo].intItemCount--;

    for (int i = 0; i < 10; i++)
    {
        if (useItemNo == iteminfo[i].intItemNo)
        {
            MyCh.intHP = MyCh.intHP + iteminfo[i].RestoreHp;
            MyCh.intMp = MyCh.intMp + iteminfo[i].RestoreMp;
            MyCh.intLevel = MyCh.intLevel + iteminfo[i].Levelup;

            if (iteminfo[i].RestoreHp != 0)
            {
                string strStatus;
                if (iteminfo[i].RestoreHp > 0)
                {
                    strStatus = "증가";
                }
                else
                {
                    strStatus = "감소";
                    // 독으로 인한 데미지
                    lastDamage = 0;
                }
                cout << "-- Hp: " << iteminfo[i].RestoreHp << " " << strStatus << " / Hp: " << MyCh.intHP << endl;
            }
            if (iteminfo[i].RestoreMp != 0)
            {
                string strStatus;
                if (iteminfo[i].RestoreMp > 0)
                {
                    strStatus = "증가";
                }
                else
                {
                    strStatus = "감소";
                }

                cout << "-- Mp: " + to_string(iteminfo[i].RestoreMp) + " " + strStatus + "/ Mp: " + to_string(MyCh.intMp) << endl;
            }
            if (iteminfo[i].Levelup != 0)
            {
                string strStatus;
                if (iteminfo[i].Levelup > 0)
                {
                    strStatus = "증가";
                }
                else
                {
                    strStatus = "감소";
                }
                cout << "-- 레벨: " + to_string(iteminfo[i].Levelup) + " " + strStatus + "/ 레벨: " + to_string(MyCh.intLevel) << endl;
            }

            if (MyCh.intHP <= 0)
            {
                GameEnding(lastDamage, false);
            }

            return;
        }
    }

전체코드(링크)

나머지 코드는 하단 깃허브 링크를 참조 부탁드립니다

텍스트rpg 게임 실행 파일은 첨부파일에 있습니다.

https://github.com/Chaeyunbyun/GameProject_Test/blob/master/GameProject_Test.cpp

골드 달성이긴 한데 정작 골드 문제는 못풀겠네요...

티어 자체보단 문제푸는 능력 키우는게 중요한것 같습니다.

단계별로 풀어보기로 순서대로 풀다가 심심하면 키워드 아무거나 검색하거나 solved.ac 클래스에 있는 문제중 난이도 낮은 걸로 풀어봤습니다

단계별로 풀어보기도 재귀 부터는 너무 어렵네요

그리디는 직관적이여서 이해하기 괜찮았고

dp는 저의 머리로는 정말로 이해가 안되었습니다. 브론즈문제도 참고 안하면 못풀겠더라고요

점화식 세우는것부터 어렵고 그리고 dp 테이블에 어떤식으로 값을 채우도록 설계할지 생각하는 것도 어렵습니다

아무튼 일단 쉬운것부터 풀면서 dp 테이블 설계하는데 익숙해져야 할 것 같습니다

사실 대학생때 재미로 hello world 나 사칙연산 풀어본거 외에는 작년~ 올해에 c++ 익숙해지려고 많이 풀었는데

실력 향상에 많이 도움이 된 것 같습니다

c# 은 요즘 안써서 까먹으려 하는데,  간단한 문제 위주로 몇개 풀어볼까 합니다

빠른 처리에 별로 용이하지 않아서 그런지 원래 우리나라에선 마이너라 그런지 백준에선 쓰는사람이 별로없네요...

일단 실버단계 dp 문제풀이에 익숙해지고  그 다음으로는 티어나 난이도 높은 문제보단 아직 풀어보지 않은 다양한 문제를 풀어보려 합니다

c#은 일단 브론즈 문제 몇개 풀어보고 괜찮으면 좀 더 해봐야겠습니다

1. 지원동기

저는 메일로 한빛 혼공학습단에 대한 안내를 보고 혼공학습단 - 컴퓨터구조, 운영체제에 지원했습니다.
예전에 전공책 살때 가입해놓고 그 이후로 한빛미디어에서 도서 안내 메일이 자주 왔는데
제대로 확인한 적이 별로 없습니다 근데 저때는 관심이 가서 읽어보고 
학습을 하면 마일리지까지 준다고 해서 지원하게 되었네요
쓰고보니 뭔가 지원동기가 아름답지 못하네요...

그리고 컴퓨터구조, 운영체제에 대해 복습하려고 생각하고 있었던 계기가 있습니다.
트러블슈팅을 하다 보면 메모리라던지 프로세스 등 운영체제와 관련된 부분들을 특히 많이 접하게 되는데
이해도가 좀 부족한것 같아서 이 부분을 잘 알면 조금 더 효율적으로 접근할 수 있지 않을까 라는 생각도 있었습니다

2. 학습방법

저는 전공자라 아는 내용도 어느 정도 있었습니다
특히 확인 문제는 보기 중에 고르거나 설명 파트에 있는걸 그대로 내는 등 의도적으로 쉽게 내진 것 같더라고요
일단 한 단원씩 쭈욱 읽은 다음에 확인 문제부터 풀어봤습니다
그리고 여유가 되면 더 알아보기나 예제 코드를 살펴 보았습니다

3. 회고

오랜만에 공부를 하니까 새로웠습니다
저는 사실 졸업하고 공부는커녕 책 자체를 잘 안 읽게 되었는데
그래도 커리큘럼 따라가면서 하니까 과제도 다 하고 완주 성공했네요
이 기세를 타서 다른 책도 사서 틈틈히 공부해보려고 합니다

감사합니다.

목차

오늘로 마지막 주차인 6주차네요

다들 고생 많으셨습니다.

한빛마일리지 받으면 뭐 살지 생각해보면서 도서들도 개인적으로 한번 훑어봤습니다

유익해보이는거 몇개만 따로 골라왔습니다

아 그리고 회고록도 따로 써야하네요 이건 정리해서 주말에 올릴게요

Chapter 14: 가상 메모리
Chapter 15: 파일 시스템

학습 내용 정리

Chapter 14: 가상 메모리

연속 메모리 할당: 프로세스는 프로세스의 메모리 주소를 할당 받아 연속적으로 배치 됨

스와핑: 사용하지 않는 프로세스를 보조 기억 장치의 스왑 영역으로 이동시키고 실행할 프로시스를 메모리로 옮김

스왑 영역: 스와핑 발생 시 프로세스가 들어가는 보조 기억 장치의 영역

스왑 아웃: 실행 되지 않는 프로세스를 메모리에서 스왑 영역으로 옯기는 것

(메모리 - > 스왑 영역)

스왑 인: 프로세스를 스왑 영역에서 프로세스로 옮기는 것

(스왑영역 -> 메모리)

스와핑을 활용하면 프로세스에서 요구하는 메모리 주소 공간 크기가 실제 메모리 크기보다 커도 실행이 가능하다.

메모리 할당

• 최초 적합:  최초로 발견한 빈 공간에 프로세스를 적재
• 최적 접합: 적재될 수 있는 가장 작은 공간에 프로세스를 적재
• 최악 적합: 적재될 수 있는 가장 큰 공간에 프로세스 적재

외부 단편화: 프로세스를 할당하기 힘든 작은 메모리 공간으로 인한 메모리 낭비 현상

외부 단편화 해결 방법

1. 압축: 흩어진 메모리 공간을 하나로 압축하는 기법

2. 페이징 기법

페이징: 메모리의 물리 주소 공간을 프레임 단위로 나눔, 논리 공간을 페이지 단위로 자름. 

 이후 페이지를 프레임에 할당 하는 가상 메모리 관리 기법

페이지 아웃: 페이지 단위로 스왑 아웃
페이지 인: 페이지 단위로 스왑 인

페이지 테이블 베이스 레지스터: 각 프로세스 페이지테이블이 적재된 순서
TLB: 페이지 테이블의 캐시메모리 역할 수행
TLB 히트: CPU가 발생한 논리 주소에 대한 페이지번호가 TLB테이블에 존재(없는 경우 TLB미스)

페이지 폴트: 프로세스가 참조하려는 페이지가 현재 메모리에 로드되어 있지 않을 때 발생

페이지 참조열: CPU가 참조하는 페이지 중 연속된 페이지를 생략한 페이지열
- 페이지 참조열을 알면 페이지 폴트 횟수를 알 수 있다

페이지 교체 알고리즘
1. FIFO 페이지 교체 알고리즘:

- 가장 먼저 메모리에 들어온 페이지부터 내보내는 알고리즘

-  페이지의 향후 참조 가능성을 고려 하지 않음

2. LRU

- 사용 가능성이 낮은 페이지를 우선적으로 내보내는 알고리즘 (가장 오래전에 참조 된  페이지를 내보낸다.)

3. LFU

- 참조 횟수가 가장 적은 페이지를 교체 대상으로 선정하는 알고리즘

4. 최적 페이지 교체 알고리즘

- CPU에 의해 참조되는 횟수를 고려하는 페이지 교체 알고리즘

- 가장 낮은 페이지 폴트율을 보장하는 알고리즘이다

- 실제로 구현하기는 힘드며 이론상 성능을 평가하기 위한 목적으로 사용

스레싱: 지나치게 빈번한 페이지 교체로 CPU이용률이 낮아 지는 문제

Chapter 15: 파일 시스템

트리 구조 디렉터리: 최상위 디렉터리 및에 여러 서브 디렉터리가 있는 구조
루트 디렉터리: 최상위 디렉터리

절대 경로: 루트 디렉터리에서 자기자신에 이르는 구조
상대 경로: 현재디렉터리에서 시작하는 구조

파티셔닝: 저장장치의 논리적인 영역을 구획
포매팅: 파일 시스템을 설정하여 새로운 데이터를 쓸 작업 준비 (저수준 포매팅, 논리적 포매팅)

파일 할당 방법: 연속 할당 불연속 할당
불연속 할당은 연결 할당과 색인 할당으로 나뉨

FAT파일시스템(FAT: 파일 할당 테이블) 을 이용하는 연결 할당 기반 파일 시스템
유닉스 파일 시스템: i-node 를 이용하는 색인할당 기반 파일 시스템

과제

p.400 1번

메모리 할당 방식에 대해 옳은 것을 보기에서 고르시오
보기) 최초 적합, 최적 적합, 최악 적합

---

1. 최초로 발견한 빈 공간에 프로세스를 적재
2. 적재될 수 있는 가장 큰 공간에 프로세스 적재
3. 적재될 수 있는 가장 작은 공간에 프로세스를 적재

답:

1 - 최초 적합

2 - 최악 적합

3 - 최적 적합

14 -3 LRU 교체 알고리즘 사용 시 페이지 폴트 발생 횟수

풀이:

우선 프레임은 세개 있습니다

최초 상태는 아래와 같다고 합시다

맞는 표현법인지 모르겠지만 간단하게 배열로 표현하겠습나다

아래의 페이지 참조열에 있는 페이지를 참조 하게 되면 (빨간색으로 표시한 부분이 페이지 폴트 발생한 구간입니다)

프레임에 없는 페이지에 접근 한 경우 가장 오래전에 들어온 페이지부터 내보내면서 수행하면 다음과 같이 진행 됩니다.

2 3 1 3 5 2 3 4 2 3

페이지 폴트는 총 3번 발생했습니다. 

답: 3

완주 기념 한빛 책 둘러보기

교보문고 랭킹기준으로 둘러보거나 검색해서 유용해 보이는 걸로 골랐습니다

실제 책 내용을 본게 아닌 목차를 보고 설명을 쓴거라 정확하진 않습니다. 

책을 고르는데 과제보다 더 오래 걸린거같네요ㅠㅠ

<개발/ 프로그래밍>
1, Thinking About C++11 STL
 - C++ 표준라이브러리 STL 의 활용을 중점으로 다루고 있다
STL은 범용성이나 편리성 성능면에서 굉장히 뛰어나지만, 기능이 정말 많아서 다 알기는 힘든 면도 있다.
실무면에서도 많이 활용되므로 읽으면 도움될 것 같다

2. 이것이 취업을 위한 컴퓨터 과학이다 with CS 기술 면접
- CS(컴퓨터과학)에 관련된 다양한 내용을 정리 해 놓았다
혼자공부하는 컴퓨터구조+운영체제에서도 나온 컴퓨터 구조 운영체제 관련 내용 및
네트워크, DB등에 대한 내용도 전체적으로 다 들어가 있다
제목은 기술 면접이라 되어 있지만 실무에서도 많이 도움이 된다고 생각한다

3. 실무로 통하는 클린코드
- 다양한 언어의 에제를 통해 클린코드 작성법을 소개한다.
주석 활용이나 변수명 정의 등 간단한 부분부터 리팩토링 같은 심화된 부분까지 고려 할수 있도록 정리되어있다

---
전 참고로 저런걸 몰라서 신입사원일떄 학교에서 전공실습할때처럼

int a, b, c;

string s;

이런 변수 쓰다 쿠사리 먹었습니다... 

<기타>
게임 전쟁
 - 게임 산업의 역사와 2000년대 콘솔 황금기 시대적 양상 등에 대해 자세히 정리되어있다
게임은 항상 많은 관심을 받아왔고 인기도 높았으며 이에 따라 다양한 게임들이 개발되어왔다
과거에 게임은 단순 아이들용 놀이나 부정적으로는 게임중독같은 질병을 일으키는 것으로 여겨지기도 했다
지금은 작품성을 인정받는 게임들도 많고 하나의 문화 사업으로 받아들여진다

일단 Thinking About C++11 STL 부터 살 것 같습니다. 다른 책들도 유용할것 같고 게임 전쟁도 재밌어보이네요

나머지 구매 순서는 천천히 생각해봐야겠네요

목차

4주차 과제 우수혼공족으로 선정되었네요 하하 커피 맛있게 먹겠습니다

벌써 다음주면 끝이네요. 전 한빛마일리지가 목적이기 때문에 다음주까지 완주하겠습니다

Chapter 12: 프로세스 동기화
Chapter 13: 교착 상태

학습 내용 정리

Chapter 12: 프로세스 동기화

프로세스 동기화: 일반적으로 실행 순서 제어와 상호 배제를 말한다

• 실행 순서 제어: 프로세스를 올바른 순서 대로 제어
• 상호 배제: 동시에 접근하면 안되는 자원에 하나의 프로세스만 접근 하도록 함

생산자와 소비자 문제:

여러개의 프로세스를 어떻게 동기화 할 것인가에 대한 문제.
동시에 접근하면 안되는 자원에 생산자와 소비자가 동시에 접근 하게 되어 발생

공유 자원: 공동으로 사용하는 자원(전역 변수, 보조기억장치, I/O 장치 등)
임계 구역 : 공유 자원에 접근하는 코드 중 동시에 실행하면 문제가 되는 코드 영역
레이스 컨디션: 여러개의 프로세스(또는 스레드)가 공유 자원에 접근하기 위해 경쟁 하는 상태

임계 구역 문제를 해결 하기 위한 3가지 원칙

Chapter 13: 교착 상태

교착 상태(데드락): 일어나지 않을 사건을 기다리며 무한 대기
자원 할당 그래프: 교착상태 표현에 사용되는 그래프

기아 상태: 프로세스가 원하는 자원을 계속 할당 받지 못하는 상태 

식사하는 철학자 문제: 여러 프로세스가 동시에 돌아갈 때 교착 상태가 나타나는 원인을 보여주는 문제

https://ko.wikipedia.org/wiki/%EC%8B%9D%EC%82%AC%ED%95%98%EB%8A%94_%EC%B2%A0%ED%95%99%EC%9E%90%EB%93%A4_%EB%AC%B8%EC%A0%9C

교착 상태 발생 조건

• 상호배제
• 점유와대기
• 비선점
• 원형 대기

교착 상태 예방: 교착상태 발생조건중 하나를 충족시키지못하게함
교착 상태 회피: 안전상태를 유지할수있는 경우만 자원할당
교착 상태 검출 후 회복:교착 상태 발생여부를 검사하고 발생 시 회복시킴

과제

p.363 1번 문제

다음 중 옳지 않은 것을 고르시오

1. 뮤텍스 락은 임계구역을 잠근 후 임계 구역에 진입함으로써 상호 배제를 위한 동기화를 이룸
2. 세마포는 공유 자원이 여러 개 있는 상태에서도 사용 가능
3. 세마포를 이용해 프로세스 실행 순서 제어를 위한 동기화를 이룰 수 있음
4. 세마포를 이용하면 반드시 바쁜 대기를 해야 함

해설: 4. -> 사용 할 수 있는 자원이 없는 경우 세마포에서는 프로세스를 대기 상태로 만들고 해당 프로세스 PCB를 대기큐에 집어넣는다. 따라서 반드시 바쁜대기를 하지는 않음

답: 4

12 -1 임계 구역, 상호 배제 정리

임계 구역: 공유 자원에 접근하는 코드 중 동시에 실행하면 문제가 되는 코드 영역

상호 배제: 한 프로세스가 임계 구역에서 작업중인 경우 다른 프로세스가 임계구역에 들어가지 못하게 제어

임계 구역 문제를 해결 하기 위한 3가지 원칙