수업 016 (04.27 2020) Maple Story

* Difficulties in coding design

(For ex App.cs  line.48)

* Frequent mistakes about the subject

(For ex Attack and Hit, this => solved with // (need to address))

** About 'Index'

* Spend too much time....... 생각하는 시간 많음

** virtual, override, : // 상속

where to order for attack in Charater.cs? Hero.cs?

---

1. Problem: Require Level List - solved (list 1 copy and paste)

Require Level이 10이 나오는 것을 확인했지만 선택 가능한 직업목록에서 검사만 출력되는 것을 확인 => List 목록에서 가져올때 list # 를 바꾸지 않음..

 

2. Coding

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace Study._017
{
    class App
    {
        // 생성자
        public App()
        {
            // DataManager dm1 = new DataManager();
            // dm.GetInstance();       // 자신의 instance 반환
 
            // 나오는 instance가 항상 같길 원함(Data Manager는 하나면 되니까)
            // "DataManager 싱글톤으로 만들어주세요" 43/4)
            DataManager dm = DataManager.GetInstance();
            dm.LoadDatas();        // LoadDatas 인스턴스 메서드
 
            // 데이터 로드
            BudgetData budgetData = dm.GetBudgetDataById(100);
 
            HeroData Data = dm.GetCharacterDataById(1000);
 
            ClassData classData = dm.GetClassDataById(100);
 
            ItemData itemData = dm.GetItemDataById(100);
 
            LevelUp levelUp = dm.GetLevelUpById(100000);
 
            MonsterData monsterData = dm.GetMonsterDataById(1000);
 
            // >> 영웅생성
 
            Hero hero = this.CreateDefaultHero();
 
            // 몬스터 생성
            Monster monster = this.CreateMonster(1000);
 
            // 몬스터 공격
            hero.Attack(monster);
 
 
            //  >>>>>>>>>>>>>>>>>>>>>>>>> Need more practice >>>>>>>>>>>>>>>>>>>>>>>>>
 
            // 몬스터 처치/ 몬스터 Die 이면
            if (monster.IsDie())
            {
                // 몬스터 죽음 => 경험치를 줌
                int exp = monster.exp;
 
                // 아이템 드랍
                Item item = this.DropItem(monster.dropItemId);
 
                // 영웅이 경험치를 얻고 레벨업 => 전직
                hero.GetExp(exp);
 
                // 전직 가능한 요구 레벨
                // Console.WriteLine(hero.info.classGrade); // output: -1
                if (hero.info.classGrade < 0)   // 아직 직업이 없을때 classGrade: -1
                {
                    List<ClassData> classDatas = DataManager.GetInstance().GetAvailableClassDatas(hero.info.classType);
 
                    Console.WriteLine("{0}", classDatas[0].require_level);
                    Console.WriteLine(">> Eroor: Require Level이 10은 나오지만 검사만 출력됨 \n");
 
                    // UI상에 선택 가능한 직업 보여주기
                    if (hero.info.level >= classDatas[0].require_level)      // lv.10보다 크면 직업얻음
                    {
                        Console.WriteLine("===== 선택가능한 직업 목록 ====");
                        foreach (var data in classDatas)
                        {
                            Console.WriteLine("{0}", data.class_name);
                        }
 
                        // 선택한 클래스
                        var selectedClassData = classDatas[0];
                        Console.WriteLine("\n{0}를 선택했습니다.", selectedClassData.class_name);
 
                        // 전직
                        hero.Upgrade(null, selectedClassData);
                    }
 
                    // 레벨업 testing
                    Console.WriteLine("\n<Level Up testing>\n");
                    hero.Levelup(30);
                    classDatas = DataManager.GetInstance().GetAvailableClassDatas(hero.info.classType);
                    var beforeData = classDatas[hero.info.classGrade - 1];
                    var nextData = classDatas[hero.info.classGrade];
                    hero.Upgrade(beforeData, nextData); // 전직
                }
 
 
                // hero.GetItem(item);
            }
 
            // 경험치, 아이템 획득
            // 레벨업
            // 전직
        }
 
        public Hero CreateDefaultHero()
        {
            // 영웅 생성 :: 영웅 데이터, 영웅 인포
            // 영웅 인포 객체 생성 :: 레벨, 직업 타입, 등급(직업), hp, mp 
            // 레벨, 직업 타입, 등급(직업), hp, mp
            var characterData = DataManager.GetInstance().GetCharacterDataById(1000);
            var heroInfo = new HeroInfo("홍길동", characterData.hp, characterData.mp, characterData.damage);
            var hero = new Hero();          // 생성
            hero.Init(heroInfo);            // 초기화
            Console.WriteLine(hero.info.name + "님이 입장하셨습니다. \n");
            return hero;
        }
 
        public Monster CreateMonster(int id)
        {
            var data = DataManager.GetInstance().GetMonsterDataById(id);
            return new Monster(data);
        }
 
        public Item DropItem(int id)
        {
            ItemData data = DataManager.GetInstance().GetItemDataById(id);
            return new Item(data.id, data.name);
        }
    }
}

 

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;
 
namespace Study._017
{
    // 데이터 관리자
    class DataManager
    {
        // "DataManager 싱글톤으로 만들어주세요 (1/4)"
        private static DataManager instance;
 
        Dictionary<int, BudgetData> dicBudgetDatas;
        Dictionary<int, HeroData> dicCharacterDatas;
        Dictionary<int, ClassData> dicClassDatas;
        Dictionary<int, ItemData> dicItemDatas;
        Dictionary<int, LevelUp> dicLevelUps;
        Dictionary<int, MonsterData> dicMonsterDatas;
 
 
        // 생성자
        // "DataManager 싱글톤으로 만들어주세요 (2/4)"
        private DataManager()
        {
            this.dicBudgetDatas = new Dictionary<int, BudgetData>();
            this.dicCharacterDatas = new Dictionary<int, HeroData>();
            this.dicClassDatas = new Dictionary<int, ClassData>();
            this.dicItemDatas = new Dictionary<int, ItemData>();
            this.dicLevelUps = new Dictionary<int, LevelUp>();
            this.dicMonsterDatas = new Dictionary<int, MonsterData>();
        }
 
        // "DataManager 싱글톤으로 만들어주세요 (3/4)"
        public static DataManager GetInstance()
        // static : 형식에서 반환 (class) [정적] / DataManager를 App 에서 쓰고싶어!
        {
            // [static 때문에 정적이어야함]
            // 인스턴스가 없다면 새로운 인스턴스를 반환
            if (DataManager.instance == null)
            {
                DataManager.instance = new DataManager();
                return DataManager.instance;
            }
 
            // 있다면 있는 인스턴스를 반환
            else
            {
                return DataManager.instance;
            }
        }
 
        public void LoadDatas()
        {
            string jsonBudget = File.ReadAllText("./budget_data.json");
            this.dicBudgetDatas = JsonConvert.DeserializeObject<BudgetData[]>(jsonBudget).ToDictionary(x => x.id, x => x);
 
            string jsonCharacter = File.ReadAllText("./character_data.json");
            this.dicCharacterDatas = JsonConvert.DeserializeObject<HeroData[]>(jsonCharacter).ToDictionary(x => x.character_id, x => x);
 
            string jsonClass = File.ReadAllText("./class_data.json");
            this.dicClassDatas = JsonConvert.DeserializeObject<ClassData[]>(jsonClass).ToDictionary(x => x.class_id, x => x);
 
            string jsonItem = File.ReadAllText("./item_data.json");
            this.dicItemDatas = JsonConvert.DeserializeObject<ItemData[]>(jsonItem).ToDictionary(x => x.id, x => x);
 
            string jsonLevelUp = File.ReadAllText("levelup_data.json");
            this.dicLevelUps = JsonConvert.DeserializeObject<LevelUp[]>(jsonLevelUp).ToDictionary(x => x.exp_id, x => x);
 
            string jsonMonster = File.ReadAllText("monster_data.json");
            this.dicMonsterDatas = JsonConvert.DeserializeObject<MonsterData[]>(jsonMonster).ToDictionary(x => x.id, x => x);
        }
 
        public BudgetData GetBudgetDataById(int id)
        {
            BudgetData data = this.dicBudgetDatas[id];
            return data;
        }
 
        public HeroData GetCharacterDataById(int id)
        {
            HeroData data = this.dicCharacterDatas[id];
            return data;
        }
 
        public ClassData GetClassDataById(int id)
        {
            ClassData data = this.dicClassDatas[id];
            return data;
        }
 
        public ItemData GetItemDataById(int id)
        {
            ItemData data = this.dicItemDatas[id];
            return data;
        }
 
        public LevelUp GetLevelUpById(int id)
        {
            LevelUp data = this.dicLevelUps[id];
            return data;
        }
 
        // ***
        public LevelUp GetLevelUpByIndex(int index)
        {
            List<LevelUp> list = new List<LevelUp>();
            foreach (var pair in this.dicLevelUps)
            {
                list.Add(pair.Value);
            }
            return list[index];
        }
 
        public MonsterData GetMonsterDataById(int id)
        {
            MonsterData data = this.dicMonsterDatas[id];
            return data;
        }
 
        // *** 새로운 list에 class type
        public List<ClassData> GetAvailableClassDatas(int classType)
        {
            List<ClassData> list3 = new List<ClassData>();
 
            if (classType <= 0) // 직업이 없을때
            {
                List<ClassData> list1 = new List<ClassData>();  // class_type = 1 인 list
                List<ClassData> list2 = new List<ClassData>();  // class_type = 2 인 list
 
                foreach (var pair in this.dicClassDatas) // list value 넣기
                {
                    if (pair.Value.class_type == 1)
                    {
                        list1.Add(pair.Value);
                    }
                    else if (pair.Value.class_type == 2)
                    {
                        list2.Add(pair.Value);
                    }
                }
 
                list3.Add(list1[0]);
                list3.Add(list2[0]);
            }
            else                // 직업이 있을떄
            {
                foreach (var pair in this.dicClassDatas)
                {
                    if(pair.Value.class_type == classType)
                    {
                        list3.Add(pair.Value);
                    }
                }
            }
            return list3;           // 반환해주는거 잊지말기
        }
    }
}

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace Study._017
{
    class Hero : Character
    {
        public HeroInfo info;
 
        public Hero()
        {
            Console.WriteLine("영웅이 생성되었습니다.");
        }
 
        public void Init(HeroInfo info)
        {
            this.info = info;
        }
 
        // monster or hero 둘다 공격 가능 (모든 캐릭터가 다 때릴수 있다.)
        public override void Attack(Character target)
        {
            Console.WriteLine("영웅이 몬스터를 공격했습니다.");
            target.Hit(this.info.damage);
        }
 
        public override void Hit(float damage)
        {
            this.info.hp -= damage;
            if (this.info.hp <= 0)
            {
                this.Die();
            }
        }
 
        public override void Die()
        {
            Console.WriteLine("영웅이 죽었습니다.");
        }
 
 
 
        //  >>>>>>>>>>>>>>>>>>>>>>>>> Need more practice >>>>>>>>>>>>>>>>>>>>>>>>>
        public void GetExp(int exp)
        {
            this.info.exp += exp;
 
            int nextLevel = this.info.level + 1;
            int nextLevelUpIndex = nextLevel - 1;   // 0부터 시작이니까
 
            // 레벨업 체크
            var levelUpData = DataManager.GetInstance().GetLevelUpByIndex(nextLevelUpIndex);
 
            // 필요 경험치
            Console.WriteLine("Lv. {0} 에서 Lv. {1}로 레벨업 하려면 {2}만큼의 경험치가 필요합니다. \n", info.level, nextLevel, levelUpData.require_exp);
 
            if (this.info.exp >= levelUpData.require_exp)       // 필요한 경험치보다 경험치가 많으면 레벨업
            {
                this.info.exp = levelUpData.require_exp;
                this.Levelup();
            }
 
            // test for level up
            this.info.level = 10;
        }
 
        public void Levelup(int count = 1)
        {
            this.info.level += count;
            Console.WriteLine("레벨업! Lv. {0}이 되었습니다.", this.info.level);
        }
 
        // 전직
        public void Upgrade(ClassData beforeData, ClassData nextData)
        {
            ClassData beforeClassData = null;
 
            if (beforeData == null)     // 뉴비
            {
                beforeClassData = DataManager.GetInstance().GetClassDataById(100);
            }
            else
            {
                beforeClassData = beforeData;
            }
 
            string beforeClassName = beforeClassData.class_name;
            string nextClassName = nextData.class_name;
 
            Console.WriteLine("\n=================================");
            Console.WriteLine("{0}에서 {1}로 전직 했습니다.", beforeClassName, nextClassName);
            Console.WriteLine("================================= \n");
 
            // 직업 결정
            this.info.classType = nextData.class_type;
            // 직업 그레이드 초기화
            this.info.classGrade = 1;       // 나중에 인덱스로 접근하려면 -1
        }
    }
}
 

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace Study._017
{
    class Monster : Character
    {
        public int id;
        public string name;
        public int damage;
        public float hp;
        public float maxHp;
        public int exp;
        public int dropItemId;
 
        public Monster(MonsterData data)
        {
            this.id = data.id;
            this.name = data.name;
            this.damage = data.damage;
            this.maxHp = data.hp;
            this.hp = this.maxHp;
            this.exp = data.exp;
            this.dropItemId = data.drop_item_id;
            Console.WriteLine("'{0}'이/(가) 생성되었습니다. \n", this.name, this.id);
        }
 
        public void Init()
        {
        }
 
        public override void Attack(Character target)
        {
            target.Hit(this.damage);
        }
 
        public override void Hit(float damage)
        {
            this.hp -= damage;
            Console.WriteLine("{0}/{1} \n", this.hp, this.maxHp);
 
            if (this.hp <= 0)
            {
                this.Die();
            }
        }
 
        public override void Die()
        {
            Console.WriteLine("몬스터가 죽었습니다.");
        }
 
        public bool IsDie()
        {
            // 몬스터 체력이 0 되었을때
            this.hp = 0;
            if (this.hp <= 0)
            {
                return true;
            }
            return false;
        }
    }
}

 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace Study._017
{
    class Character
    {
        public Character()
        {
        }
 
        public virtual void Attack(Character target)
        {
        }
 
        public virtual void Hit(float damage)
        {
        }
 
        public virtual void Die()
        {
        }
    }
}

 

>> BudgetData.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace Study._017
{
    class BudgetData
    {
        public int id;
        public string name;
    }
}

 

 

3. Result

• NewB

 

 

• Lv. 10

 

• Lv. 30