C언어] RPG게임만들기-4 (전투 설정)

[RPG게임만들기]

RPG게임만들기 전투 설정 플레이어 턴&턴 방식

플레이어 먼저 무조건 공격 그다음 몬스터 공격 방식

플레이어는 선택. 그다음 몬스터는 공격 2가지 형태중 1가지 설정

전투 로직 추가
1. 공격 2. 마법 3. 도망
1.공격 = 플레이어 물리 공격력 만큼 몬스터 HP감소.
2.마법 = 플레이어 마법 공격력 만큼 몬스터 HP감소. 
물리 공격 계산 공식 : 플레이어 물리공격력 - 몬스터(방어력/10)
마법 공격 계산 공식 : 플레이어 마법공격력- 몬스터(저항력/5)

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
//& 플레이어 구조체 정의
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;
 
//& 플레이어 속성 계산 함수
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);
}
 
//& 플레이어 정보 표시 함수
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 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);
}
 
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;
    do {
 
        printf("\n=== 메뉴 ===\n");
        printf("1. 플레이어 정보 표시\n");
        printf("2. 하급 사냥터(1~3) 등장\n");
        printf("3. 종료\n");
        printf("선택: ");
        scanf_s("%d", &choice);
 
        switch (choice) 
        {
        case 1:
            displayPlayerInfo(&player);
            break;
        case 2: {
            //& 몬스터 생성 및 초기화 (등급은 1~3 랜덤)
            Monster monster;
            monster.grade = rand() % 3 + 1;
            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);
 
            //& 몬스터 정보 표시 (임시
           // displayMonsterInfo(&monster);
            break;
        }
        case 3:
            printf("프로그램을 종료합니다.\n");
            break;
        default:
            printf("잘못된 선택입니다. 다시 선택하세요.\n");
        }
    } while (choice != 3);
 
    return 0;
}// main