C언어] RPG게임만들기-7 (상점)

[RPG게임만들기]

RPG게임만들기 상점 만들기

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>  // strcpy 함수를 사용하기 위한 헤더 추가
 
//& 플레이어 구조체 정의
typedef struct {
    //& 멤버 변수(플레이어 정보 설정)
    int HP;
    int MP;
    double physicalAttack;
    double magicalAttack;
    int strength;
    int agility;
    int luck;
    int magicPower;
    double defense;
    double resistance;
    double speed;
    double critical;
} Player;
 
//& 적(몬스터) 구조체 정의
typedef struct {
    //& 멤버 변수 (몬스터 정보 설정)
    int grade;
    int HP;
    int MP;
    double physicalAttack;
    double magicalAttack;
    int strength;
    int agility;
    int luck;
    int magicPower;
    double defense;
    double resistance;
    double speed;
    double critical;
} Monster;
 
//& 아이템 유형 열거형 정의
typedef enum {
    WEAPON,
    HELMET,
    ARMOR,
    GLOVES,
    SHOES,
    EARRING,
    RING,
    BRACELET
} ItemType;
 
//& 아이템 구조체 정의
typedef struct {
    ItemType type;
    char name[50];  // 아이템 이름 추가
    int attack;
    int defense;
    int resistance;
    int strength;
    int agility;
    int magicPower;
    int luck;
    int speed;
    int price;
} Item;
 
//& 인벤토리 구조체 정의
typedef struct {
    Item* items;
    int itemCount;
    int gold;
} Inventory;
 
//& 아이템 유형 문자열 배열
const char* itemTypeNames[] = { "무기", "투구", "갑옷", "장갑", "신발", "귀걸이", "반지", "팔찌" };
 
//& 플레이어 속성 계산 함수
void calculateAttributes(Player* player)
{
    //& 물리 공격력 = (기본 1)+(힘 * 3) / 10.0
    player->physicalAttack = (1) + (player->strength * 3) / 10.0;
 
    //& 마법 공격력 = (기본0.5)+(마력 * 2) / 8.0
    player->magicalAttack = (0.5) + (player->magicPower * 2) / 8.0;
 
    //& 방어력 = 5 + (힘 / 15)
    player->defense = 5 + (player->strength / 15.0);
 
    //& 저항력 = 3 + (마력 / 20)
    player->resistance = 3 + (player->magicPower / 20.0);
 
    //& 스피드 = 1 * (민첩 / 5)
    player->speed = 1 * (player->agility / 5.0);
 
    //& 크리티컬 = 0 * (행운 / 2)
    player->critical = 0 * (player->luck / 2.0);
}// calculateAttributes
 
//& 몬스터 속성 계산 함수
void calculateMonsterAttributes(Monster* monster)
{
    //& 물리 공격력 = (힘 * 1) / 10.0
    monster->physicalAttack = (monster->strength * 5) / 10.0;
 
    //& 마법 공격력 = (마력 * 0.2) / 8.0
    monster->magicalAttack = (monster->magicPower * 2) / 8.0;
 
    //& 방어력 = (등급 * 3) + (힘 / 15)
    monster->defense = (monster->grade * 3) + (monster->strength / 15.0);
 
    //& 저항력 = (등급 * 1) + (마력 / 20)
    monster->resistance = (monster->grade * 1) + (monster->magicPower / 20.0);
 
    //& 스피드 = 1 * (민첩 / 5)
    monster->speed = 1 * (monster->agility / 5.0);
 
    //& 크리티컬 = 0 * (행운 / 2)
    monster->critical = 0 * (monster->luck / 2.0);
}// calculateMonsterAttributes
 
//& 아이템 생성 함수
Item createItem(ItemType type, const char* name, int attack, int defense, int resistance,
    int strength, int agility, int magicPower, int luck,
    int speed, int price)
{
    Item newItem;
    newItem.type = type;
    strcpy_s(newItem.name, sizeof(newItem.name), name);  // 이름 설정
    newItem.attack = attack;
    newItem.defense = defense;
    newItem.resistance = resistance;
    newItem.strength = strength;
    newItem.agility = agility;
    newItem.magicPower = magicPower;
    newItem.luck = luck;
    newItem.speed = speed;
    newItem.price = price;
 
    return newItem;
}// createItem
 
//& 아이템 구매 함수
void buyItem(Inventory* inventory, Item* item)
{
    if (inventory->gold >= item->price)
    {
        // 충분한 금액이 있을 경우 아이템을 인벤토리에 추가하고 금액 차감
        inventory->items = (Item*)realloc(inventory->items, (inventory->itemCount + 1) * sizeof(Item));
        inventory->items[inventory->itemCount] = *item;
        inventory->itemCount++;
        inventory->gold -= item->price;
 
        printf("%s 아이템을 구매했습니다.\n", item->name);
    }
    else
    {
        printf("보유한 금액이 부족하여 %s 아이템을 구매할 수 없습니다.\n", item->name);
    }
}// buyItem
 
//& 아이템 판매 함수
void sellItem(Inventory* inventory, int itemIndex)
{
    if (itemIndex >= 0 && itemIndex < inventory->itemCount)
    {
        //& 판매할 아이템의 가격을 획득하고 인벤토리에서 해당 아이템 제거
        inventory->gold += inventory->items[itemIndex].price;
        printf("%s 아이템을 판매하여 %d 골드를 획득했습니다.\n", inventory->items[itemIndex].name, inventory->items[itemIndex].price);
 
        for (int i = itemIndex; i < inventory->itemCount - 1; i++)
        {
            inventory->items[i] = inventory->items[i + 1];
        }
 
        inventory->itemCount--;
        inventory->items = (Item*)realloc(inventory->items, inventory->itemCount * sizeof(Item));
    }
    else
    {
        printf("잘못된 인덱스입니다. 판매할 아이템을 선택하세요.\n");
    }
}// sellItem
 
//& 플레이어 정보 표시 함수
void displayPlayerInfo(Player* player)
{
    printf("\n=== 플레이어 정보 ===\n");
    printf("HP: %d\n", player->HP);
    printf("MP: %d\n", player->MP);
    printf("물리 공격력: %lf\n", player->physicalAttack);
    printf("마법 공격력: %lf\n", player->magicalAttack);
    printf("방어력: %lf\n", player->defense);
    printf("저항력: %lf\n", player->resistance);
    printf("스피드: %lf\n", player->speed);
    printf("크리티컬: %lf\n", player->critical);
}// displayPlayerInfo
 
//& 몬스터 정보 표시 함수
void displayMonsterInfo(Monster* monster)
{
    printf("\n=== 몬스터 정보 ===\n");
    printf("몬스터 등급 : %d\n", monster->grade);
    printf("HP: %d\n", monster->HP);
    printf("MP: %d\n", monster->MP);
    printf("물리 공격력: %lf\n", monster->physicalAttack);
    printf("마법 공격력: %lf\n", monster->magicalAttack);
    printf("방어력: %lf\n", monster->defense);
    printf("저항력: %lf\n", monster->resistance);
    printf("스피드: %lf\n", monster->speed);
    printf("크리티컬: %lf\n", monster->critical);
}//displayMonsterInfo
 
//& 아이템 정보 표시 함수
void displayItemInfo(Item* item)
{
    printf("\n=== 아이템 정보 ===\n");
    printf("이름: %s\n", item->name);
    printf("유형: %s\n", itemTypeNames[item->type]);
    printf("공격력: %d\n", item->attack);
    printf("방어력: %d\n", item->defense);
    printf("저항력: %d\n", item->resistance);
    printf("힘: %d\n", item->strength);
    printf("민첩: %d\n", item->agility);
    printf("마력: %d\n", item->magicPower);
    printf("행운: %d\n", item->luck);
    printf("스피드: %d\n", item->speed);
    printf("가격: %d\n", item->price);
}// displayItemInfo
 
//& 상점 아이템 목록 표시 함수
void displayShop(Inventory* shopInventory)
{
    printf("\n=== 상점 아이템 목록 ===\n");
 
    if (shopInventory->itemCount == 0)
    {
        printf("상점에 아이템 없음\n");
    }
    else
    {
        for (int i = 0; i < shopInventory->itemCount; i++)
        {
            displayItemInfo(&(shopInventory->items[i]));
        }
    }
}// displayShop
 
//& 인벤토리 정보 출력 함수 
void displayInventory(Inventory* inventory)
{
    printf("\n=== 인벤토리 ===\n");
    printf("보유 금액: %d\n", inventory->gold);
 
    if (inventory->itemCount == 0)
    {
        printf("보유 아이템 없음\n");
    }
    else
    {
        for (int i = 0; i < inventory->itemCount; i++)
        {
            displayItemInfo(&(inventory->items[i]));
        }
    }
}// displayInventory
 
//& 몬스터 공격 함수
void monsterAttack(Player* player, Monster* monster)
{
    printf("몬스터가 플레이어를 공격합니다!\n");
 
    int isPhysicalAttack = rand() % 2; // 0 또는 1 중 랜덤 선택
 
    if (isPhysicalAttack)
    {
        //& 몬스터가 물리 공격을 선택한 경우
        int monsterPhysicalDamage = monster->physicalAttack - player->defense;
        if (monsterPhysicalDamage < 0)
        {
            monsterPhysicalDamage = 0;
        }
        player->HP -= monsterPhysicalDamage;
        printf("플레이어에게 %d만큼의 물리 피해를 입혔습니다.\n", monsterPhysicalDamage);
    }
    else
    {
        //& 몬스터가 마법 공격을 선택한 경우
        int monsterMagicalDamage = monster->magicalAttack - player->resistance;
        if (monsterMagicalDamage < 0)
        {
            monsterMagicalDamage = 0;
        }
        player->HP -= monsterMagicalDamage;
        printf("플레이어에게 %d만큼의 마법 피해를 입혔습니다.\n", monsterMagicalDamage);
    }
}//monsterAttack
 
//& 전투 함수
void battle(Player* player, Monster* monster)
{
    int choice;
    int physicalDamage, magicalDamage; // 변수 초기화 추가
 
    do {
        printf("\n=== 전투 메뉴 ===\n");
        printf("1. 공격\n");
        printf("2. 마법\n");
        printf("3. 도망\n");
        printf("선택: ");
        scanf_s("%d", &choice);
 
        system("cls"); // 화면 지우기
 
        printf("[%d] 등급 몬스터 등장\n", monster->grade);
 
        switch (choice)
        {
        case 1: // 공격
            printf("플레이어가 몬스터를 공격합니다!\n");
            physicalDamage = player->physicalAttack - monster->defense / 10;
            if (physicalDamage < 0)
            {
                physicalDamage = 0;
            }
            monster->HP -= physicalDamage;
            printf("몬스터에게 %d만큼의 물리 피해를 입혔습니다.\n", physicalDamage);
            break;
        case 2: // 마법
            printf("플레이어가 몬스터에게 마법을 사용합니다!\n");
            magicalDamage = player->magicalAttack - monster->resistance / 5;
            if (magicalDamage < 0)
            {
                magicalDamage = 0;
            }
            monster->HP -= magicalDamage;
            printf("몬스터에게 %d만큼의 마법 피해를 입혔습니다.\n", magicalDamage);
            break;
        case 3: // 도망
            printf("도망쳤습니다. 전투를 종료합니다.\n");
            return;
        default:
            printf("잘못된 선택입니다. 다시 선택하세요.\n");
        }
 
        //& 몬스터 공격 함수 
        monsterAttack(player, monster);
 
        //& 플레이어와 몬스터의 HP 출력
        printf("플레이어 HP: %d, 몬스터 HP: %d\n", player->HP, monster->HP);
 
        //& 전투 종료 조건 확인
        if (player->HP <= 0)
        {
            printf("플레이어가 전투에서 패배했습니다.\n");
            return;
        }
        else if (monster->HP <= 0)
        {
            printf("몬스터를 처치했습니다. 전투에서 승리했습니다!\n");
            return;
        }
    } while (1);
}//battle
 
//& 사냥터 함수
void hunt(Player* player, int minGrade, int maxGrade)
{
    printf("=== 사냥터에 입장했습니다. ===\n");
 
    //& 몬스터 등급은 minGrade부터 maxGrade 사이의 랜덤 값
    int monsterGrade = rand() % (maxGrade - minGrade + 1) + minGrade;
 
    //& 몬스터 생성 및 초기화
    Monster monster;
    monster.grade = monsterGrade;
    monster.HP = 80 + monster.grade * 20;
    monster.MP = 40 + monster.grade * 10;
    monster.strength = monster.grade * 5;
    monster.agility = monster.grade * 5;
    monster.luck = monster.grade * 5;
    monster.magicPower = monster.grade * 2;
    calculateMonsterAttributes(&monster);
 
    //& 전투 실행
    battle(player, &monster);
}//hunt
 
int main()
{
    //& 난수 발생을 위한 시드 설정
    srand((unsigned int)time(NULL));
 
    //& 플레이어 및 상점 인벤토리 생성 및 초기화
    Inventory playerInventory;
    playerInventory.items = NULL;
    playerInventory.itemCount = 0;
    playerInventory.gold = 1000;
    Inventory shopInventory;
    shopInventory.items = NULL;
    shopInventory.itemCount = 0;
    shopInventory.gold = 0;
    //& 상점에 아이템 추가
    Item weapon = createItem(WEAPON, "강력한 검", 35, 0, 0, 5, 0, 0, 0, 2, 100);
    Item armor = createItem(ARMOR, "튼튼한 갑옷", 0, 15, 5, 0, 0, 0, 0, 0, 150);
    Item potion = createItem(HELMET, "낡은 투구", 0, 5, 3, 0, 0, 0, 0, 0, 50);
    shopInventory.items = (Item*)realloc(shopInventory.items, 3 * sizeof(Item));
    shopInventory.items[0] = weapon;
    shopInventory.items[1] = armor;
    shopInventory.items[2] = potion;
    shopInventory.itemCount = 3;
 
    //& 플레이어 구조체 생성 및 초기화
    Player player;
    player.HP = 100;
    player.MP = 50;
    player.strength = 10;
    player.agility = 10;
    player.luck = 10;
    player.magicPower = 5;
    calculateAttributes(&player);
 
    //& 선택 변수 선언
    int choice;
    int minGrade, maxGrade;
    int itemIndex;
 
    do {
        printf("\n=== 메뉴 ===\n");
        printf("1. 플레이어 정보 표시\n");
        printf("2. 사냥터 선택\n");
        printf("3. 상점\n");
        printf("4. 종료\n");
        printf("선택: ");
        scanf_s("%d", &choice);
 
        switch (choice)
        {
        case 1:
            displayPlayerInfo(&player);
            break;
        case 2:
            printf("=== 사냥터 선택 ===\n");
            printf("1. 하급 사냥터 (1~3 등급)\n");
            printf("2. 중급 사냥터 (4~9 등급)\n");
            printf("3. 고급 사냥터 (10~19 등급)\n");
            printf("4. 종료\n");
            printf("선택: ");
            scanf_s("%d", &choice);
 
            switch (choice)
            {
            case 1:
                minGrade = 1;
                maxGrade = 3;
                hunt(&player, minGrade, maxGrade);
                break;
            case 2:
                minGrade = 4;
                maxGrade = 9;
                hunt(&player, minGrade, maxGrade);
                break;
            case 3:
                minGrade = 10;
                maxGrade = 19;
                hunt(&player, minGrade, maxGrade);
                break;
            case 4:
                printf("프로그램을 종료합니다.\n");
                break;
            default:
                printf("잘못된 선택입니다. 다시 선택하세요.\n");
            }
            break;
        case 3:
            printf("=== 상점 ===\n");
            printf("1. 아이템 구매\n");
            printf("2. 아이템 판매\n");
            printf("3. 종료\n");
            printf("선택: ");
            scanf_s("%d", &choice);
 
            switch (choice)
            {
            case 1:
                //& 아이템 목록 
                displayShop(&shopInventory);
                printf("구매할 아이템 인덱스를 입력하세요: ");
                scanf_s("%d", &itemIndex);
                if (itemIndex >= 0 && itemIndex < shopInventory.itemCount)
                {
                    buyItem(&playerInventory, &(shopInventory.items[itemIndex]));
                }
                else
                {
                    printf("잘못된 인덱스입니다. 다시 선택하세요.\n");
                }
                break;
            case 2:
                printf("판매할 아이템 인덱스를 입력하세요: ");
                scanf_s("%d", &itemIndex);
                sellItem(&playerInventory, itemIndex);
                break;
            case 3:
                printf("프로그램을 종료합니다.\n");
                break;
            default:
                printf("잘못된 선택입니다. 다시 선택하세요.\n");
            }
            break;
        case 4:
            printf("프로그램을 종료합니다.\n");
            break;
        default:
            printf("잘못된 선택입니다. 다시 선택하세요.\n");
        }
    } while (choice != 3);
 
    return 0;
}// main