C언어] RPG게임만들기-6 (아이템 생성)

[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;
 
//& 아이템 유형 문자열 배열
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);
}
 
//& 몬스터 속성 계산 함수
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);
}
 
//& 아이템 생성 함수
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;
}
 
//& 플레이어 정보 표시 함수
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 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));
 
    //& 플레이어 구조체 생성 및 초기화
    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;
 
    do {
        printf("\n=== 메뉴 ===\n");
        printf("1. 플레이어 정보 표시\n");
        printf("2. 사냥터 선택\n");
        printf("3. 종료\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");
            break;
        case 7:
            //& 아이템 생성 및 초기화
            Item weapon = createItem(WEAPON, "Test 무기", 35, 0, 0, 10, 0, 0, 0, 0, 50);
            Item helmet = createItem(HELMET, "Test 헷멧", 0, 5, 3, 0, 0, 0, 0, 0, 30);
 
            //& 아이템 정보 출력
            displayItemInfo(&weapon);
            displayItemInfo(&helmet);
        default:
            printf("잘못된 선택입니다. 다시 선택하세요.\n");
        }
    } while (choice != 3);
 
    return 0;
}// main

아이템 생성 함수 추가
아이템은 이름, 유형, 공격력, 방어력, 자항력, 힘, 민첩, 마력, 행운, 스피드, 판매 가격 등 옵션
추후 유형에 맞는 옵션만 표시

유형은 "무기", "투구", "갑옷", "장갑", "신발", "귀걸이", "반지", "팔찌" 추가