무르르릉

Inventory.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Study04
{

    public class Inventory
    {
        private Item[] items;
        private int nextIndex;

        // 생성자
        public Inventory(int capacity)
        {
            this.items = new Item[capacity];
        }

        public void AddItem(Item item)
        {
            if (this.nextIndex > this.items.Length-1)
            {
                Console.WriteLine("공간이 부족합니다.");
            }
            else
            {
                this.items[this.nextIndex++] = item;
            }
        }

        public void Extend(int capacity)
        {

            int len = this.items.Length + capacity;
            Item[] temp = new Item[len];

            for (int i = 0; i < this.items.Length-1; i++) {
                temp[i] = this.items[i];
                
            }
            this.items = temp;
        }

        public void FindName()
        {
            for (int i = 0; i < this.items.Length; i++)
            {
                if (this.items[i] != null)
                {
                    Console.WriteLine(this.items[i].Name);
                }
            }
        }

        public Item GetItem(string itemName)
        {
            Item getItem = null;
            for (int i = 0; i < this.items.Length; i++)
            {
                if (this.items[i] != null)
                {
                    if (this.items[i].Name != itemName)
                    {
                        Console.WriteLine("{0} 아이템을 찾을 수 없습니다.", itemName);
                    }
                    else
                    {
                        getItem = this.items[i];
                        Console.WriteLine("{0}을 사용합니다.", getItem.Name);
                        break;
                    }
                }

            }
            return getItem;
        }
    }
}

Item.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Study04
{
    public class App
    {
        Inventory inven = null;
        Item items = null;
        // 생성자
        public App()
        {
            Console.Write("인벤토리의 최대 수량을 입력하세요.");
            string input = Console.ReadLine();
            int maxNum = Convert.ToInt32(input);

            inven = new Inventory(maxNum);
            Console.WriteLine(inven);

            while (true)
            {
                Console.WriteLine("숫자를 입력하세요.");
                Console.WriteLine("<1. 아이템 넣기, 2. 아이템 빼기, 3. 인벤토리 최대 수량 변경 4. 나가기>");
                string inputNum = Console.ReadLine();
                int num = Convert.ToInt32(inputNum);
                if (num == 1)
                {
                    Console.Write("아이템 이름을 입력하세요.: ");
                    string inputItem = Console.ReadLine();
                    this.items = new Item(inputItem);
                    inven.AddItem(this.items);
                }
                else if (num == 2)
                {
                    Console.Write("사용할 아이템 이름을 입력하세요.: ");
                    string inputItem = Console.ReadLine();
                    this.items = inven.GetItem(inputItem);
                }
                else if (num == 3)
                {
                    Console.WriteLine("추가할 수량을 입력하세요.: ");
                    string inputItem = Console.ReadLine();
                    int number = Convert.ToInt32(inputItem);
                    inven.Extend(number);
                    Console.WriteLine("인벤토리 총 수량: {0}", maxNum + number);
                }
                else if (num == 4)
                {
                    Console.WriteLine("인벤토리를 나갑니다.");
                    break;
                }
                else
                {
                    Console.WriteLine("잘못된 입력입니다.");
                }
            }
        } 
    }
}

App.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Study04
{
    public class App
    {
        Inventory inven = null;
        Item items = null;

        // 생성자
        public App()
        {
            Console.Write("인벤토리의 최대 수량을 입력하세요 -> ");
            string input = Console.ReadLine();
            int maxNum = Convert.ToInt32(input);

            inven = new Inventory(maxNum);

            while (true)
            {
                Console.WriteLine("\n");
                Console.WriteLine("숫자를 입력하세요");
                Console.WriteLine("<1. 아이템 넣기, 2. 아이템 빼기, 3. 인벤토리 최대 수량 변경 4. 나가기>");
                string inputNum = Console.ReadLine();
                int num = Convert.ToInt32(inputNum);
                if (num == 1)
                {
                    Console.Write("아이템 이름을 입력하세요 -> ");
                    string inputItem = Console.ReadLine();
                    this.items = new Item(inputItem);
                    inven.AddItem(this.items);
                    
                }
                else if (num == 2)
                {
                    Console.Write("사용할 아이템 이름을 입력하세요 -> ");
                    string inputItem = Console.ReadLine();
                    this.items = inven.GetItem(inputItem);
                }
                else if (num == 3)
                {
                    Console.WriteLine("추가할 수량을 입력하세요 -> ");
                    string inputItem = Console.ReadLine();
                    int number = Convert.ToInt32(inputItem);
                    inven.Extend(number);
                    Console.WriteLine("인벤토리 총 수량: {0}", maxNum + number);
                }
                else if (num == 4)
                {
                    Console.WriteLine("인벤토리를 나갑니다.");
                    break;
                }
                else
                {
                    Console.WriteLine("잘못된 입력입니다.");
                }
            }
        } 
    }
}

1. property, get-set메서드

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Study04
{
    public class Hero
    {
        private string name;
        private int damage;
        private int maxHp;
        private int hp;
        
        public string Name
        {
            get
            {
                return this.name;
            }
            set
            {
                this.name = value;
            }
        }

        public int Damage
        {
            get
            {
                return this.damage;
            }
            set
            {
                this.damage = value;
            }
        }

        public int Hp
        {
            get
            {
                return this.hp;
            }
        }

        public int MaxHp
        {
            get
            {
                return this.maxHp;
            }
            set
            {
                this.maxHp = value;
                this.hp = this.maxHp;
                
            }
        }

        // 생성자
        public Hero()
        {

        }
        
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Study04
{
    public class App
    {
        // 생성자
        public App()
        {
            Hero hero = new Hero();
            hero.Name = "홍길동";
            hero.Damage = 1;
            hero.MaxHp = 10;
            Console.WriteLine(hero.Name);
            Console.WriteLine(hero.Damage);
            Console.WriteLine("{0}/{1}", hero.Hp, hero.MaxHp);
        } 
    }
}

2. interface 상속

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Study04
{
    interface IBurrow
    {
        void Burrow();
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Study04
{
    interface IRecovery
    {
        void RecoverHp();   // 체력 회복
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Study04
{
    public class Drone : IBurrow, IRecovery
    {
        // 생성자
        public Drone()
        {

        }

        // 자동 생성
        public void Burrow()
        {
            Console.WriteLine("Brrow!");
        }

        public void RecoverHp()
        {
            Console.WriteLine("체력 회복");
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Study04
{
    public class Zergling : IBurrow, IRecovery
    {
        // 생성자
        public Zergling()
        {

        }

        public void Burrow()
        {
            Console.WriteLine("Burrow");
        }

        public void RecoverHp()
        {
            Console.WriteLine("체력 회복");
        }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Study04
{
    public class App
    {
        // 생성자
        public App()
        {
            Drone drone = new Drone();
            drone.Burrow();
            drone.RecoverHp();

            Zergling zergling = new Zergling();
            zergling.Burrow();

            // 타입으로 사용
            IBurrow drone2 = new Drone();
            drone2.Burrow();
            // drone2.RecoverHp();  -> 캐스팅 오류
            // 해결방법
            IRecovery drone3 = (IRecovery)drone2;
            drone3.RecoverHp();
            ((IRecovery)drone2).RecoverHp();

            IBurrow zergling2 = new Zergling();
            zergling2.Burrow();
        } 
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Study04
{
    interface IAttack
    {
        void Attack();
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Study04
{
    interface ICloak
    {
        void CloakOn();
        void CloakOff();
        bool IsCloak();
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Study04
{
    public class Marine : IAttack
    {
        // 생성자
        public Marine()
        {

        }

        public void Attack()
        {
            Console.WriteLine("총을 쏩니다.");
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Study04
{
    public class Firebat : IAttack
    {
        //생성자
        public Firebat()
        {

        }

        public void Attack()
        {
            Console.WriteLine("화염방사기를 쏩니다.");
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Study04
{
    public class Wraith : ICloak
    {
        private bool isCloak;
        // 생성자
        public Wraith()
        {

        }

        public void CloakOff()
        {
            this.isCloak = false;
        }

        public void CloakOn()
        {
            this.isCloak = false;
        }

        public bool IsCloak()
        {
            return this.isCloak;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Study04
{
    public class App
    {
        // 생성자
        public App()
        {
            // 인터페이스 IAttack

            Marine marine = new Marine();
            Firebat firebat = new Firebat();

            marine.Attack();    //총을 쏩니다
            firebat.Attack();   // 화염방사기를 쏩니다

            // 인터페이스 ICloak
            ICloak wraith = new Wraith();
            wraith.CloakOn();
            wraith.CloakOff();  // false
            bool isCloak = wraith.IsCloak();
            if (isCloak)
            {
                Console.WriteLine("은신중입니다.");
            }
            else
            {
                Console.WriteLine("은신중이지 않습니다.");   // 출력
            }

        } 
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Study04
{
    public class App
    {
        // 정수 배열 타입 변수 정의
        int[] arr1;
        // 문자열 배열 타입 변수 정의
        string[] arr2;
        // Hero배열 형식의 변수 정의
        Hero[] arr3;

        // 생성자
        public App()
        {
            // 정수 인스턴스 생성하고 arr3에 할당, 해당 요소는 기본값 0
            this.arr1 = new int[2];
            this.arr1[0] = 1;

            // 문자열 인스턴스 생성하고 arr3에 할당 
            this.arr2 = new string[3];

            // Hero 인스턴스 생성하고 arr3에 할당
            this.arr3 = new Hero[3];

            // 두개 같음
            int[] array2 = new int[] { 1, 2, 3, 4, 5 };
            int[] array3 = { 1, 2, 3, 4, 5 };

            int[] score = new int[5];
            //score[-1] = 0;  // 인덱스 배열 범위 오류
            score[0] = 80;
            score[1] = 74;
            score[2] = 81;
            score[3] = 90;
            score[4] = 34;
            //score[5] = 79;  // 인덱스 배열 범위 오류
            //Console.WriteLine(score.Length);    // 5

            //// 반복문 이용하여 출력
            //for (int i = 0; i < score.Length; i++)
            //{
            //    Console.WriteLine(score[i]);
            //}

            foreach (int num in score)
            {
                Console.WriteLine(num);
            }

            string[] fruitsNames = new string[3];
            fruitsNames[0] = "바나나";
            //fruitsNames[1] = "딸기";
            fruitsNames[2] = "수박";

            for (int i = 0; i < fruitsNames.Length; i++)
            {
                if (i == 1)
                {
                    fruitsNames[i] = "복숭아";
                }
            }

            foreach(string name in fruitsNames)
            {
                Console.WriteLine(name);
            }
        } 
    }
}

1. const: 상수

* 변수 타입 앞에 선언. 고정된 값으로 이후 새로운 값으로 변경할 수 없음

const float pi = 3.141592f;

// 상수는 값 변경 X
// pi = 3.1411f;    -> 오류
Console.WriteLine(pi);

2. enum: 열거형식

* 값을 따로 지정해주지 않으면 0부터 차례대로 값이 부여됨

enum eItemGrade
{
    Normal, // 0
    Magic,  // 1
    Legendary   // 2
}

// 열거형식 eItemGrade 변수 정의 및 초기화
eItemGrade itemGradeType = eItemGrade.Magic;
Console.WriteLine(itemGradeType);	// Magic

3. 형식 변환

3-1. 공통

* 변환하려는 변수 앞에 '(타입)' 입력

//// 열거형식 -> 정수
//Console.WriteLine((int)itemType);    // 0

//// 정수 -> 열거형식
//eItemType myItemType = (eItemType)1;
//Console.WriteLine(myItemType);  // Armor

3-2. ToString(): 문자열 변환

// 정수 -> 문자열
int hp = 100;
string strHp = hp.ToString();
Console.WriteLine(strHp);

// 실수 -> 문자열
float damage = 1.34f;
string strDamage = damage.ToString();
Console.WriteLine(strDamage);

//bool 타입 -> 문자열
bool isDie = false;
string strIsDie = isDie.ToString();
Console.WriteLine(strIsDie);

3-3. Convert.ToInt32(): 정수 변환

//문자열->정수
// 숫자에 지정된 문자열 ex) "10", "1100", "1.23"
int damage = Convert.ToInt32("100");
Console.WriteLine("damage: {0}", damage);

3-4. Convert.ToSingle(): 실수 변환

//문자열 -> 실수
float pi = Convert.ToSingle("3.14");    //3.14f ->오류
Console.WriteLine("pi = {0}", pi);

4. var: 암시적 형식

* 입력한 값의 타입으로 지정됨

var name = "홍길동";	// string
var level = 12;		  // int

5. 값 형식/참조 형식

- 값 형식은 스택에  값이 직접적으로 저장됨

• 종류: int, float, char, bool, enum

- 참조 형식은 힙에 값이 저장되어 스택에서 참조

* 값을 지정해주지 않고 변수 정의만 할 시 기본값은 'null'

• 종류: object, string

// 참조 형식 변수 정의 -> 스택에 변수 주소 저장
string name = null;
Console.WriteLine("name: {0}", name);   // null: 출력은 되나 아무것도 없음

// 값 할당 -> 힙에 저장
name = "홍길동";
Console.WriteLine("name: {0}", name);

6. if-else 조건문

- if문에 입력한 bool식이 true일 경우 해당 본문 실행

- else if(): 처음 사용한 if문 외의 다른 조건식을 사용할 때 이용

- else: 조건식이 false일 경우 해당 본문 실행

enum eRace
{
    Terran = 1,
    Zerg = 2,
    Protoss= 3
}

// 비교한 값에 따라 선택한 종족 출력
eRace select;

Console.WriteLine("종족을 선택해주세요. (1.Terran, 2.Zerg, 3. Protoss): ");
string inputNum = Console.ReadLine();
select = (eRace)Convert.ToInt32(inputNum);

if (eRace.Terran == select)
{
    Console.WriteLine("테란을 선택했습니다.");
}
else if (eRace.Zerg == select)
{
    Console.WriteLine("저그를 선택했습니다.");
}
else if (eRace.Protoss == select)
{
    Console.WriteLine("프로토스를 선택했습니다.");
}
else
{
    Console.WriteLine("잘못 선택했습니다.");
}

7. 논리 연산자

• &&: AND 연산, 모든 조건이 참일 경우 true
• ||: OR 연산, 모든 조건 중 하나라도 참일 경우 true
• !: NOT 연산, 두 값이 같지 않을 경우 true

string mat1 = "장검";
string mat2 = "장검";
string newItem = null;
int gold = 1000;    // 소지 골드
int requireGold = 10;   // 합성에 필요한 골드

if ((mat1 != null && mat2 != null) && gold >= requireGold)
{
    mat1 = null;
    mat2 = null;
    newItem = "강인한 장검";
    gold -= requireGold;
    Console.WriteLine("합성 성공");
    Console.WriteLine("{0}이 만들어졌습니다.", newItem);
    Console.WriteLine("남은 골드: {0}", gold);
}

8. for문

- for문에 지정된 bool 식이 true일 경우 본문 반복 실행

// for문 기본형
for (int i = 0; i < 5; i++)
{
    Console.Write(i);
}

// int i = 0: initializer section - 변수 선언&초기화
// i < 5: Condition section - 반복 실행 구간
// i++: iterator section - 본문 실행 후 수행

9. 응용 실습

Console.Write("첫번째 수를 입력해주세요: ");
string input1 = Console.ReadLine();
Console.Write("두번째 수를 입력해주세요: ");
string input2 = Console.ReadLine();

Console.WriteLine("당신이 입력한 두 수는 다음과 같습니다.");
Console.WriteLine("첫 번째 수: {0}", input1);
Console.WriteLine("두 번째 수: {0}", input2);

// 입력 받은 두 수 더하기
Console.WriteLine("두 수의 합을 입력하세요: ");
string input3 = Console.ReadLine();

// 형변환
int num1 = Convert.ToInt32(input1);
int num2 = Convert.ToInt32(input2);
int sum = num1 + num2;
int num3 = Convert.ToInt32(input3);

if (sum == num3)
{
    Console.WriteLine("정답입니다.");
}
else
{
    Console.WriteLine("틀렸습니다. 정답은 {0}입니다.", sum);
}

for (int i = 0; i < 5; i++)
{
    if (i % 2 == 0)
    {
        Console.WriteLine("{0}는 홀수입니다.", i + 1);
    }
    if (i % 2 == 1)
    {
        Console.WriteLine("{0}는 짝수입니다.", i + 1);
    }
}

Console.Write("원하는 단수를 입력하세요: ");
string input = Console.ReadLine();
int number = Convert.ToInt32(input);

for (int i = 0; i < 9; i++)
{
    Console.WriteLine("{0} x {1} = {2}", number, i + 1, (i + 1) * number);
}

Console.Write("줄넘기를 몇 회 하시겠습니까? (1~9): ");
int input = Convert.ToInt32(Console.ReadLine());
int cnt = Convert.ToInt32(input);
if (cnt < 1 || cnt > 9)
{
    Console.WriteLine("범위를 벗어났습니다.");
}
else
{
    for (int i = 0; i < cnt; i++)
    {
        Console.WriteLine("줄넘기를 {0}회 했습니다.", i + 1);
    }
    Console.WriteLine("------------------------------------");
    Console.WriteLine("줄넘기를 총 {0}개 했습니다. ", cnt);

}

1. int: 정수

// 현재 체력 변수를 정수 형식으로 정의
int currentHp;

// 현제 체력 변수에 672 할당
currentHp = 672;

// 현재 체력 변수에 0 할당
currentHp = 0;

// 현재 체력 변수 값 출력
Console.WriteLine(currentHp);

// 현재 체력 변수에 -675 할당 후 출력
currentHp = -675;
Console.WriteLine(currentHp);

// 현재 체력 변수에 -1 할당
// =: 오른쪽 값을 왼쪽 변수에 할당하는 연산자
currentHp = -1;
Console.WriteLine(currentHp);

2. float: 실수

* 값에 반드시 접미사 'f'를 붙여야함

// 공격력 변수를 실수 형식으로 정의하고 1.1로 초기화
float damage = 1.1f;

// 공격력 변수에 22.33 할당
damage = 23.33f;

// 공격력 변수 값 출력
Console.WriteLine(damage);  // 23.33

3. string: 문자열

* 큰따옴표를 사용하여 값 정의

// 맵 이름 변수 정의
string mapName;

// 값 할당
mapName = "북부 평원";
mapName = "123";

// 출력: 123
Console.WriteLine(mapName);

4. bool: 논리 자료

* 큰따옴표를 사용하여 값 정의

bool isHit = true;
Console.WriteLine("{0}", isHit);

// char : 문자 타입 '<값>'
char a = 'a';
// string : 문자열 "<값>"
string b = "b";

Console.WriteLine("{0}, {1}", a, b);

5. object: 모든 형식

// 모든 라인에서 에러가 발생하지 않음
object obj = 123;
obj = true;
obj = "홍길동";
obj = 123.32f;
obj = 'a';

응용 실습

float expPercent = 23.13f;
string percentSign = "%";

// 값 출력
//Console.Write(expPercent);
//// 값 출력 후 줄바꿈
//Console.WriteLine(percentSign);

string strPer = expPercent + percentSign;
Console.WriteLine(strPer);  // 23.13%

// 아이템 이름 변수 정의
string itemName;
// 아이템 이름에 "장검" 값 할당
itemName = "장검";
// 아이템 수량 변수 정의
int itemAmount;
// 아이템 수량 변수에 2 값 할당
itemAmount = 2;

// 다음과 같이 출력해보자
// ---------------------------
// 장검x2
Console.WriteLine(itemName + "x" + itemAmount);

Console.WriteLine("{0}x{1} {2}", itemName, itemAmount, 100);

// 현재 체력 변수 정의
int currHp;
// 최대 체력 변수 정의
int maxHp;
// 최대 체력 변수에 100 할당
maxHp = 100;
// 현재 체력 변수에 최대 체력 변수 값 할당
currHp = maxHp;
// 문자열 표현식을 사용하여 다음과 같이 출력하세요
// ----------------------------------------------------
// (100/100)
Console.WriteLine("({0}/{1})", currHp, maxHp);

// 몬스터에게 2 공격을 받았습니다
currHp = currHp - 2;    // 98
Console.WriteLine("({0}/{1})", currHp, maxHp);

// 체력 물약 먹음 (체력 +2)
currHp = currHp + 2;
Console.WriteLine("({0}/{1})", currHp, maxHp);

// 영웅 이름 변수 정의
string playerName;
// 영웅 체력 변수 정의
int playerHp;
// 영웅 최대 체력 변수 정의
int playerMaxHp;
// 몬스터 이름 변수 정의
string monsterName;
// 몬스터 공격력 변수 정의
int monsterDamage;

playerName = "홍길동";
monsterName = "악어";
playerMaxHp = 100;
playerHp = playerMaxHp;
monsterDamage = 24;

Console.WriteLine("{0}이(가) {1}을(를) 공격합니다.", monsterName, playerName);
Console.WriteLine("{0}이(가) {1}만큼 피해를 받았습니다.", playerName, monsterDamage);
playerHp = playerHp - monsterDamage;
Console.WriteLine("영웅의 체력: ({0}/{1})", playerHp, playerMaxHp);

// 물약 이름 변수 정의
string potionName = "빨간 물약 (소)";
// 물약 회복량 변수 정의
int potionRecovery = 3;
// 영웅 체력 변수 정의
int heroHp;
// 영웅 최대 체력 변수 정의
int heroMaxHp = 123;
heroHp = heroMaxHp;
// 몬스터 공격력 변수 정의
int damage = 5;
// 몬스터에게 공격을 받고 영웅의 체력을 출력
heroHp = heroHp - damage;
Console.WriteLine("{0}/{1}", heroHp, heroMaxHp);
// 영웅의 죽었는가? (bool 타입 변수 정의, 사용 X)
bool isHeroDie = false;
// 물약 사용
heroHp = heroHp + potionRecovery;
// 값 할당 및 출력
Console.WriteLine("{0}을 먹고 체력 {1} 만큼 회복했습니다. 영웅의 체력 ({2}/{3})", potionName, potionRecovery, heroHp, heroMaxHp);

// 다음과 같이 출력
//(8/10) 80% <- 현재 체력/최대 체력
Console.WriteLine("({0}/{1})", heroHp, heroMaxHp);
//Console.WriteLine(heroHp / heroMaxHp);

// 하트 변수 정의하고 1로 초기화
int heart = 1;
// 증가 연산자를 사용해 1 증가시키기
heart++;
Console.WriteLine(heart);

// 영웅 체력
float hp;
// 영웅 최대 체력
int maxHp = 100;
hp = maxHp;
//몬스터 공격력
int monDamage = 10;
// 복합할당식으로 영웅 체력 감소(몬스터 공격력만큼)
hp -= monDamage;

// 출력
Console.WriteLine("{0}/{1}", hp, maxHp);

// 영웅의 최대 체력을 x2하고 출력
maxHp *= 2;
Console.WriteLine("{0}/{1}", hp, maxHp);

// 영웅의 체력을 %로 출력
float per = hp / maxHp;
Console.WriteLine("{0}/{1} {2}%", hp, maxHp, per);

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Exam02
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Console.Write("당신의 이름은?: ");
            string name = Console.ReadLine();
            Console.Write("당신의 공격력은? (1~5): ");
            string damage = Console.ReadLine();
            int damageNum = Convert.ToInt32(damage);

            int wolfHp = 5;
            int wolfMaxHp = wolfHp;

            /// 데미지 입력값 조건문 추가
            if (damageNum > 5)
            {
                Console.WriteLine("숫자를 확인하세요.");
            }
            else if (damageNum < 1)
            {
                Console.WriteLine("숫자를 확인하세요.");
            }
            else
            {
                Console.Write("이름: {0} ", name);
                Console.WriteLine("공격력: {0} ", damage);

                Console.WriteLine("늑대가 출현했습니다. ({0}/{1})", wolfHp, wolfMaxHp);
                Console.Write("공격하시려면 \"공격\"을 입력하세요.: ");
                string input = Console.ReadLine();

                if (input == "공격")
                {
                    if (damageNum < 5)
                    {
                        wolfHp -= damageNum;
                        Console.WriteLine("늑대가 피해를 {0}만큼 받았습니다.", damageNum);
                        Console.WriteLine("늑대({0}/{1})가 황급히 도망갑니다.", wolfHp, wolfMaxHp);
                    }
                    else if (damageNum >= 5)
                    {
                        Console.WriteLine("늑대가 죽었습니다..");
                    }
                    else
                    {
                        Console.WriteLine("잘못된 입력입니다.");
                    }
                }
                else
                {
                    Console.WriteLine("잘못된 입력입니다.");
                }
            }
        }
    }
}