무르르릉

1. App.cs

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

namespace Study05
{
    public class App
    {
        int[,] map;

        // 생성자
        public App()
        {
            this.CreateMap();
            Hero hero = new Hero(map);

            hero.MoveDown();
            this.DrawMap();
        }

        public void CreateMap()
        { 
            this.map = new int[,]
            {
                {0, 0, 0, 0},
                {0, 0, 0, 0},
                {-1, -1, 0, 0},
                {0, 0, 0, -1}
            };
        }


        public void DrawMap()
        {
            for (int i = 0; i < this.map.GetLength(0); i++)
            {
                for (int j = 0; j < this.map.GetLength(1); j++)
                {
                    Console.Write("{0} ", this.map[i, j]);
                }
                Console.WriteLine();
            }
            Console.WriteLine();
        }
    }
}

2. hero.cs

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

namespace Study05
{
    public class Hero
    {
        // id, 공격력
        public int heroId = 10;
        public int damage = 10;
        private int row = 0;
        private int col = 0;
        private int[,] map;

        // 생성자
        public Hero(int[,] map)
        {
            this.map = map;
            this.map[0, 0] = this.heroId;
        }

        public void Location(int row, int col)
        {
            this.row = row;
            this.col = col;
        }

        public void MoveRight()
        {
            int prevCol = this.col;
            int nextCol;

            if (prevCol >= 3)
            {
                Console.WriteLine("이동할 수 없습니다.");
            }
            else
            {
                prevCol = this.col;
                nextCol = this.col + 1;

                this.map[this.row, prevCol] = 0;
                this.map[this.row, nextCol] = this.heroId;

                this.col = nextCol;
            }
            
        }

        public void MoveLeft()
        {
            int prevCol = this.col;
            int nextCol;

            if (prevCol <= 0)
            {
                Console.WriteLine("이동할 수 없습니다.");
            }
            else
            {
                prevCol = this.col;
                nextCol = this.col - 1;

                this.map[this.row, prevCol] = 0;
                this.map[this.row, nextCol] = this.heroId;

                this.col = nextCol;
            }
        }

        public void MoveDown()
        {
            int prevRow = this.row;
            int nextRow;

            if (prevRow >= 3)
            {
                Console.WriteLine("이동할 수 없습니다.");
            }
            else
            {
                prevRow = this.row;
                nextRow = this.row + 1;

                this.map[prevRow, this.col] = 0;
                this.map[nextRow, this.col] = this.heroId;

                this.row = nextRow;
            }
        }

        public void MoveUp()
        {
            int prevRow = this.row;
            int nextRow;

            if (prevRow <= 0)
            {
                Console.WriteLine("이동할 수 없습니다.");
            }
            else
            {
                prevRow = this.row;
                nextRow = this.row - 1;

                this.map[prevRow, this.col] = 0;
                this.map[nextRow, this.col] = this.heroId;

                this.row = nextRow;
            }
        }

        // 실행 X
        public void Colide()
        {
            int row = this.row;
            int col = this.col;
            for (int i = 0; i < this.map.GetLength(0); i++)
            {
                for (int j = 0; j < this.map.GetLength(1); j++)
                {
                    if (this.map[i, j] == -1)
                    {
                        this.map[this.row, this.col] = this.heroId;
                        Console.WriteLine("이동할 수 없습니다.");
                    }
                }
            }
        }
    }
}

PlayGame.cs

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

namespace Study05
{
    public class PlayGame
    {
        private int[] board;
        private Random random = new Random();

        // 생성자
        public PlayGame()
        {
            this.board = new int[4];
        }

        public void CreateNewBlock()
        {
            int index = -1;
            while (true)
            {
                index = this.GetRandomIndex();
                if (this.board[index] == 0)
                {
                    this.board[index] = this.InitStartNumber();
                    break;
                }
            }
            this.PrintBlock();
        }

        public void StartMoveLeft()
        {
            int num = -1;
            int index = -1;
            for (int i = 0; i < this.board.Length; i++)
            {
                num = this.board[i];

                if (num != 0)
                {
                    index = i;
                }
            }
            for (int i = 0; i < this.board.Length; i++)
            {
                this.MoveLeft();
            }
        }

        public void MoveLeft()
        {
            for (int i = 0; i < this.board.Length; i++)
            {
                int num = this.board[i];
                if (num != 0)
                {
                    if (i == 0) return;
                    this.board[i - 1] = num;
                    this.board[i] = 0;
                }
            }
            this.PrintBlock();
        }

        public void StartGame()
        {
            this.CreateInitBlock();
            this.PrintBlock();
        }

        public void CreateInitBlock()
        {
            int index = this.GetRandomIndex();
            int num = this.InitStartNumber();
            this.board[index] = num;
        }

        public int InitStartNumber()
        {
            int initNum = this.random.Next(1, 3) * 2;
            return initNum;
        }

        public int GetRandomIndex()
        {
            int index = this.random.Next(0, 4);
            return index;
        }

        public void PrintBlock()
        {
            for (int i = 0; i < this.board.Length; i++)
            {
                Console.Write("{0} ", this.board[i]);
            }
            Console.WriteLine();
        }
    }
}

2. App.cs

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

namespace Study05
{
    public class App
    {

        // 생성자
        public App()
        {
            PlayGame game = new PlayGame();
            game.StartGame();
            game.StartMoveLeft();
            game.CreateNewBlock();
        }
    }
}

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)
        {
            // 몬스터 정보
            int MonsterHp;
            int MonsterMaxHp = 10;
            MonsterHp = MonsterMaxHp;

            // 영웅 공격력
            int heroDamage = 2;

            Console.WriteLine("몬스터의 체력: {0}", MonsterHp);
            Console.WriteLine("영웅의 공격력: {0}", heroDamage);
            Console.Write("몇 회 공격하시겠습니까?: ");
            string inputHit = Console.ReadLine();
            int hit = Convert.ToInt32(inputHit);

            for (int i=0; i < hit; i++)
            {
                MonsterHp -= heroDamage;
                Console.WriteLine("몬스터가 피해(-{0})를 받았습니다. {1}/{2}", heroDamage, MonsterHp, MonsterMaxHp);

                if (MonsterHp <= 0)
                {
                    Console.WriteLine("몬스터가 죽었습니다.");
                    break;
                }
            }
        }
    }
}

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)
        {
            for (int i = 0; i < 10; i++)
            {
                if (i%2 == 1)
                {
                    Console.WriteLine(i+1);
                }
            }
        }
    }
}

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)
        {
            for (int i = 0; i < 4; i++)
            {
                Console.WriteLine(1000+ (i + 1));
            }
        }
    }
}

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)
        {
            for (int i = 0; i < 10; i++)
            {
                if (i%2 == 0)
                {
                    Console.WriteLine(i + 1);
                }
            }
        }
    }
}

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)
        {
            int startTime = 9;
            for (int i = 0; i < 8; i++)
            {
                Console.Write("{0}교시 ", i + 1);
                Console.WriteLine("{0}:30 ~", startTime);
                startTime++;
                if (startTime == 13)
                {
                    startTime++;
                    continue;
                }
            }
        }
    }
}

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("숫자를 입력하세요 (1~10): ");
            string inputNum = Console.ReadLine();
            int num = Convert.ToInt32(inputNum);
            int cnt = 0;

            if (num > 10)
            {
                Console.WriteLine("10보다 큰 수를 입력했습니다.");
            }
            else if (num == 1)
            {
                Console.WriteLine("1보다 작은 숫자는 없습니다.");
            }
            else
            {
                for (int i = 0; i < 10; i++)
                {
                    if (num > i + 1)
                    {
                        cnt++;
                    }
                }
                Console.WriteLine("{0}보다 작은 숫자는 {1}개입니다.", num, cnt);
            }
        }
    }
}

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)
        {
            for (int i = 0; i < 5; i++)
            {
                Console.WriteLine(5 - i);
            }
        }
    }
}

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("1과 10 사이의 숫자를 고르시오: ");
            int num = Convert.ToInt32(Console.ReadLine());
            int sum = 0;

            if (num < 1 || num > 10)
            {
                Console.WriteLine("입력값을 확인하세요.");
            }
            else
            {
                for (int i = 0; i < num; i++)
                {
                    sum += i + 1;
                }
                Console.WriteLine("1부터 {0}까지의 합은 {1}입니다.", num, sum);
            }
            
        }
    }
}

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)
        {
            for (int i = 0; i < 5; i++)
            {
                if (i % 2 == 1)
                {
                    Console.WriteLine("줄넘기를 {0}회 했습니다. 야호~", i + 1);
                }
                else
                {
                    Console.WriteLine("줄넘기를 {0}회 했습니다.", i + 1);
                }
            }
        }
    }
}

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)
        {
            string menuName1 = "짜장면";
            string menuName2 = "잡탕밥";
            string menuName3 = "양장피";
            int menuPrice1 = 6000;
            int menuPrice2 = 8000;
            int menuPrice3 = 12000;
            int menuOrderCount1 = 0;     // 짜장면 주문 횟수
            int menuOrderCount2 = 0;     // 잡탕밥 주문 횟수
            int menuOrderCount3 = 0;     // 양장피 주문 횟수
            int totalMoney = 0;     // 주문 금액

            Console.WriteLine("홍콩반점에 오신 것을 환영합니다!");
            Console.Write("소지금액: ");
            int money = Convert.ToInt32(Console.ReadLine());
            Console.Write("인원: ");
            int count = Convert.ToInt32(Console.ReadLine());
            Console.Write("\n");
            Console.WriteLine("* {0}명, 소지금액: {1}", count, money);
            Console.Write("\n");
            Console.WriteLine(" --------------------- ");
            Console.WriteLine("|        메뉴판       |");
            Console.WriteLine("|                     |");
            Console.WriteLine("| ------------------- | ");
            Console.WriteLine("|   1. 짜장면  6000   |");
            Console.WriteLine("| ------------------- | ");
            Console.WriteLine("|   2. 잡탕밥  8000   |");
            Console.WriteLine("| ------------------- | ");
            Console.WriteLine("|   3. 양장피  12000  |");
            Console.WriteLine(" --------------------- ");
            Console.WriteLine("메뉴를 주문해주세요. (1인 1메뉴)");

            for (int i = 0; i < count; i++)
            {
                Console.Write("{0}번째 손님의 주문: ", i + 1);
                int select = Convert.ToInt32(Console.ReadLine());
                if (select == 1)
                {
                    menuOrderCount1++;
                    totalMoney += menuPrice1;
                }
                if (select == 2)
                {
                    menuOrderCount2++;
                    totalMoney += menuPrice2;
                }
                if (select == 3)
                {
                    menuOrderCount3++;
                    totalMoney += menuPrice3;
                }
            }

            Console.WriteLine(" --------------------- ");
            Console.WriteLine("|      주문 내역      |");
            Console.WriteLine(" --------------------- ");
            Console.WriteLine("{0} {1}개     {2}원", menuName1, menuOrderCount1, menuPrice1 * menuOrderCount1);
            Console.WriteLine("{0} {1}개     {2}원", menuName2, menuOrderCount2, menuPrice2 * menuOrderCount2);
            Console.WriteLine("{0} {1}개     {2}원", menuName3, menuOrderCount3, menuPrice3 * menuOrderCount3);
            Console.WriteLine(" --------------------- ");
            Console.WriteLine(" 합계   {0}원", totalMoney);

            if (totalMoney > money)
            {
                Console.WriteLine("\n{0}원이 부족합니다.\n다음에 다시 오세요~", totalMoney - money);
                
            }
            else
            {
                Console.WriteLine("\n감사합니다.");
                Console.WriteLine("현재 남은 소지 금액은 {0}원 입니다.", money - totalMoney);
                Console.WriteLine("안녕히 가세요~");
            }
        }
    }
}

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("잘못된 입력입니다.");
                }
            }
        }
    }
}