'전체 글'에 해당되는 글 1801건

  1. 2019.03.28 컬렉션(C#)
  2. 2019.03.27 2019.03.26 과제 (와우 케릭터 만들기 C#콘솔)
  3. 2019.03.26 enum과 비트마스크
  4. 2019.03.22 2019.03.22 과제
  5. 2019.03.21 1. Introduction to Meshes
  6. 2019.03.20 How Unity Supports Cross Platform Feature

컬렉션(C#)

Unity3D/C# 2019. 3. 28. 23:14
반응형

컬렉션 (C#)
관련개체의 그룹을 만들고 관리 
개체를 그룹화 하는 방법에는 개체 배열을 만들거나 개체 컬렉션을 만드는 두가지 방법이 있음.

배열: 고정된 개수의 강력한 형식 개체를 만들고 작업 하는데 유용 
https://docs.microsoft.com/ko-kr/dotnet/csharp/programming-guide/arrays/index

컬렉션 : 개체그룹에 대해 작업하는 보다 유연한 방법을 제공
배열과달리 변경되는 작업에서 개체 그룹이 동적으로 확장되거나 축소될수 있음.
일부 컬렉션의 경우 키를 사용하여 개체를 신속하게 검색할 수 있도록 컬렉션에 추가 하는 모든 개체에 키를 할당할수 있음.
컬렉션은 클래스이므로 해당 컬렉션에 요소를 추가 하려면 먼저 클래스 인스턴스를 선언 해야 함.
컬렉션에 단일 데이터 형식의 요소만 포함된 경우 System.Collections.Generic 네임스페이스의 클래스중 하나를 사용할 수 있다.
제네릭 컬렉션은 다른 데이터 형식을 추가 할수 없도록 형식 안전성을 적용한다.
제네릭 컬렉션에서 요소를 검색 하는 경우 해당 데이터 형식을 결정하거나 변환할 필요가 없다.

제네릭 : https://docs.microsoft.com/ko-kr/dotnet/csharp/programming-guide/generics/

컬렉션의 종류 
- System.Collections.Generic 클래스 
- System.Collections.Concurrent 클래스 
- System.Collections 클래스 

키/값 쌍의 컬렉션 구현 
Linq를 사용하여 컬렉션에 엑세스 
컬렉션 정렬 
사용자 지정 컬렉션 정의
반복기 

 

 

 

Program.cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
using System;
 
namespace study03
{
    class MainClass
    {
        public static void Main(string[] args)
        {
            var app = new App();
            app.Run();
        }
    }
}
 
 
 



App.cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
using System;
using System.Collections.Generic;
 
namespace study03
{
    public class App
    {
        public App()
        { 
            //생성자 
        }
 
        public void Run()
        {
            //가방에 넣을 초기 아이템 
            Item[] items = new Item[3]
                {
                    new Item("가죽장갑", Item.eItemType.Armor, 1),
                    new Item("혈마도"Item.eItemType.Weapon, 1),
                    new Item("체력포션"Item.eItemType.Potion, 10)
                };
 
            Inventory inventory = new Inventory(items);
            foreach(Item item in inventory)
            {
                Console.WriteLine("{0} {1} {2}"item.Name, item.itemType, item.stack);
            }
 
            Console.WriteLine();
 
            var enumerator = inventory.GetEnumerator();
            while (enumerator.MoveNext())
            {
                var item = enumerator.Current;
                Console.WriteLine("{0} {1} {2}"item.Name, item.itemType, item.stack);
            }
 
        }
    }
}
 
 
 

 

 

 

Item.cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
using System;
 
namespace study03
{
    public class Item
    {
        public enum eItemType
        { 
            None = 0,
            Weapon = 1,
            Armor = 2,
            Accessory = 4,
            Potion = 8
        }
 
        public string Name { get; private set; } 
        public eItemType itemType { get; private set; }
        public int stack { get; private set; }
 
        public Item(string name, eItemType itemType, int stack)
        {
            this.Name = name;
            this.itemType = itemType;
            this.stack = stack;
        }
    }
}
 
 
 

 

 

Inventory.cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
using System;
using System.Collections;
 
namespace study03
{
    public class Inventory : IEnumerable
    {
        private Item[] items;
 
        public Inventory(Item[] items)
        {
            this.items = items;
        }
 
        IEnumerator IEnumerable.GetEnumerator()
        {
            return (IEnumerator)GetEnumerator();
        }
 
        public ItemEnumerator GetEnumerator()
        {
            return new ItemEnumerator(this.items);
        }
    }
}
 
 
 

 

 

ItemEnumerator.cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
using System;
using System.Collections;
 
namespace study03
{
    public class ItemEnumerator : IEnumerator
    {
        public Item[] items;
        private int position = -1;
 
        public ItemEnumerator(Item[] items)
        {
            this.items = items;
        }
 
        public bool MoveNext()
        {
            this.position++;
            return (this.position < this.items.Length);
        }
 
        public void Reset()
        {
            this.position = -1;
        }
 
        object IEnumerator.Current
        {
            get 
            {
                return Current;
            }
        }
 
        public Item Current
        {
            get
            {
                try 
                {
                    return this.items[this.position];
                }
                catch
                {
                    throw new InvalidOperationException();
                }
            }
        }
    }
}
 
 
 
반응형
:

2019.03.26 과제 (와우 케릭터 만들기 C#콘솔)

Unity3D/C# 2019. 3. 27. 00:44
반응형












1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace ConsoleApp6
{
    class Program
    {
        static void Main(string[] args)
        {
            new App();
            Console.ReadKey();
        }
    }
}
 
cs



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace ConsoleApp6
{
    class Mask
    {
 
        public static GameEnums.eTribe allianceMask = GameEnums.eTribe.Human | GameEnums.eTribe.Dwarf | GameEnums.eTribe.NightElf |
                                        GameEnums.eTribe.Gnome | GameEnums.eTribe.Draenei | GameEnums.eTribe.Worgen |
                                        GameEnums.eTribe.Pandaren;
 
        public static GameEnums.eTribe hordeMask = GameEnums.eTribe.Orc | GameEnums.eTribe.Undead | GameEnums.eTribe.Tauren |
                                     GameEnums.eTribe.Troll | GameEnums.eTribe.BloodElf | GameEnums.eTribe.Goblin |
                                     GameEnums.eTribe.Pandaren;
 
        //클래스 (얼라)
        public static GameEnums.eClass humanClassMask = GameEnums.eClass.DeathKnight | GameEnums.eClass.Hunter |
                                                      GameEnums.eClass.Rogue |
                                                      GameEnums.eClass.Monk | GameEnums.eClass.Mage |
                                                      GameEnums.eClass.Warlock |
                                                      GameEnums.eClass.Priest | GameEnums.eClass.Paladin | GameEnums.eClass.Warrior;
 
 
 
        public static GameEnums.eClass dwarfClassMask = GameEnums.eClass.DeathKnight | GameEnums.eClass.Rogue |
                                                        GameEnums.eClass.Hunter |
                                                        GameEnums.eClass.Monk | GameEnums.eClass.Mage |
                                                        GameEnums.eClass.Warlock |
                                                        GameEnums.eClass.Priest | GameEnums.eClass.Paladin | 
                                                        GameEnums.eClass.Shaman | GameEnums.eClass.Warrior;
 
        public static GameEnums.eClass nightElfClassMask = GameEnums.eClass.DemonHunter | GameEnums.eClass.DeathKnight |
                                                        GameEnums.eClass.Druid |
                                                        GameEnums.eClass.Rogue | GameEnums.eClass.Hunter |
                                                        GameEnums.eClass.Monk |
                                                        GameEnums.eClass.Mage | GameEnums.eClass.Priest | GameEnums.eClass.Warrior;
 
 
        //Gnome
        public static GameEnums.eClass gnomeClassMask =   GameEnums.eClass.DeathKnight |
                                                           GameEnums.eClass.Hunter |
                                                           GameEnums.eClass.Monk | GameEnums.eClass.Priest |
                                                           GameEnums.eClass.Warlock |
                                                           GameEnums.eClass.Warrior | GameEnums.eClass.Mage | GameEnums.eClass.Rogue;
 
        //Draenei
        public static GameEnums.eClass draeneiClassMask = GameEnums.eClass.DeathKnight |
                                                        GameEnums.eClass.Hunter |
                                                        GameEnums.eClass.Monk | GameEnums.eClass.Mage |
                                                        GameEnums.eClass.Priest |
                                                        GameEnums.eClass.Paladin | GameEnums.eClass.Shaman | GameEnums.eClass.Warrior;
 
        //Worgen
        public static GameEnums.eClass worgenClassMask = GameEnums.eClass.DeathKnight |
                                                          GameEnums.eClass.Druid |
                                                          GameEnums.eClass.Rogue | GameEnums.eClass.Hunter |
                                                          GameEnums.eClass.Mage |
                                                          GameEnums.eClass.Priest | GameEnums.eClass.Warlock | GameEnums.eClass.Warrior;
 
        //Pandaren
        public static GameEnums.eClass pandarenClassMask = GameEnums.eClass.Monk |
                                                           GameEnums.eClass.Rogue |
                                                           GameEnums.eClass.Hunter | GameEnums.eClass.Mage |
                                                           GameEnums.eClass.Priest |
                                                           GameEnums.eClass.Shaman | GameEnums.eClass.Warrior;
 
 
 
 
 
        //클래스 (오크)
 
        public static GameEnums.eClass orcClassMask = GameEnums.eClass.DeathKnight | GameEnums.eClass.Monk |
                                                GameEnums.eClass.Hunter |
                                                GameEnums.eClass.Mage | GameEnums.eClass.Rogue |
                                                GameEnums.eClass.Warlock |
                                                GameEnums.eClass.Shaman | GameEnums.eClass.Warrior;
 
        public static GameEnums.eClass undeadClassMask = GameEnums.eClass.DeathKnight | GameEnums.eClass.Hunter |
                                                   GameEnums.eClass.Mage |
                                                   GameEnums.eClass.Monk | GameEnums.eClass.Priest |
                                                   GameEnums.eClass.Rogue |
                                                   GameEnums.eClass.Warlock| GameEnums.eClass.Warrior;
 
        public static GameEnums.eClass taurenClassMask = GameEnums.eClass.DeathKnight | GameEnums.eClass.Hunter |
                                                         GameEnums.eClass.Druid |
                                                         GameEnums.eClass.Monk | GameEnums.eClass.Priest |
                                                         GameEnums.eClass.Paladin |
                                                         GameEnums.eClass.Shaman | GameEnums.eClass.Warrior;
 
        public static GameEnums.eClass trollClassMask = GameEnums.eClass.Monk | GameEnums.eClass.Hunter |
                                                         GameEnums.eClass.Druid |
                                                         GameEnums.eClass.Mage | GameEnums.eClass.Priest |
                                                         GameEnums.eClass.Rogue |
                                                         GameEnums.eClass.Warlock | GameEnums.eClass.Shaman |
                                                         GameEnums.eClass.Warrior;
 
        public static GameEnums.eClass bloodElfClassMask = GameEnums.eClass.DemonHunter | GameEnums.eClass.DeathKnight |
                                                        GameEnums.eClass.Hunter |
                                                        GameEnums.eClass.Mage | GameEnums.eClass.Monk |
                                                        GameEnums.eClass.Paladin |
                                                        GameEnums.eClass.Priest | GameEnums.eClass.Rogue |
                                                        GameEnums.eClass.Warlock | GameEnums.eClass.Warrior;
 
 
        public static GameEnums.eClass goblinClassMask = GameEnums.eClass.DeathKnight |
                                                            GameEnums.eClass.Hunter |
                                                            GameEnums.eClass.Mage | GameEnums.eClass.Priest |
                                                            GameEnums.eClass.Rogue |
                                                            GameEnums.eClass.Warlock | GameEnums.eClass.Shaman |
                                                            GameEnums.eClass.Warrior;
    }
}
 
cs



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace ConsoleApp6
{
    class GameEnums
    {
        public enum eStep
        {
            None = -1,
            SelectCamp,
            SelectTribe,
            SelectClass,
            SelectCharacterName,
            Done
        }
 
        //https://docs.microsoft.com/ko-kr/dotnet/csharp/programming-guide/enumeration-types
        [Flags]
        public enum eCamp
        {
            None = 0,
            Alliance = 1,
            Horde = 2
        }
 
        [Flags]
        public enum eTribe
        {
            //얼라진영
            None = 0,
            Human = 1,
            Dwarf = 2,
            NightElf = 4,
            Gnome = 8,
            Draenei = 16,
            Worgen = 32,
            
 
            //호드진영 
            Orc = 64,
            Undead = 128,
            Tauren = 256,
            Troll = 512,
            BloodElf = 1024,
            Goblin = 2048,
 
            Pandaren = 4096,
            //Pandaren,
        }
 
        [Flags]
        public enum eClass
        {
            None = 0,
            DeathKnight = 1,
            DemonHunter = 2,
            Druid = 4,
            Hunter = 8,
            Mage = 16,
            Monk = 32,
            Paladin = 64,
            Priest = 128,
            Rogue = 256,
            Shaman = 512,
            Warlock = 1024,
            Warrior = 2048,
 
        }
    }
}
 
cs



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace ConsoleApp6
{
    class App
    {
        private Dictionary<GameEnums.eTribe, GameEnums.eClass> dicClasses;
 
        private GameEnums.eCamp selectedCamp = GameEnums.eCamp.None;
        private GameEnums.eTribe selectedTribe = GameEnums.eTribe.None;
        private GameEnums.eClass selectedClass = GameEnums.eClass.None;
 
        private string selectedCharacterName;
 
        //생성자 
        public App()
        {
            //Orc = 64,
            //Undead = 128,
            //Tauren = 256,
            //Troll = 512,
            //BloodElf = 1024,
            //Goblin = 2048,
 
            //Pandaren = 4096,
            this.dicClasses = new Dictionary<GameEnums.eTribe, GameEnums.eClass>()
            {
                { GameEnums.eTribe.Human, Mask.humanClassMask },
                { GameEnums.eTribe.Dwarf, Mask.dwarfClassMask },
                { GameEnums.eTribe.NightElf, Mask.nightElfClassMask },
                { GameEnums.eTribe.Gnome, Mask.gnomeClassMask },
                { GameEnums.eTribe.Draenei, Mask.draeneiClassMask },
                { GameEnums.eTribe.Worgen, Mask.worgenClassMask },
                { GameEnums.eTribe.Pandaren, Mask.pandarenClassMask },
 
                { GameEnums.eTribe.Orc, Mask.orcClassMask },
                { GameEnums.eTribe.Undead, Mask.undeadClassMask },
                { GameEnums.eTribe.Tauren, Mask.taurenClassMask },
                { GameEnums.eTribe.Troll, Mask.trollClassMask },
                { GameEnums.eTribe.BloodElf, Mask.bloodElfClassMask },
                { GameEnums.eTribe.Goblin, Mask.goblinClassMask },
 
            };
 
            this.MoveStep(GameEnums.eStep.SelectCamp, GameEnums.eStep.None);
        }
 
        //진영 
        private void SelectCamp()
        {
            while (true)
            {
                Console.WriteLine("진영을 선택 해주세요(얼라이언스 / 호드)?");
                var input = Console.ReadLine();
                if (input == "얼라이언스")
                {
                    this.selectedCamp = GameEnums.eCamp.Alliance;
                    this.MoveStep(GameEnums.eStep.SelectTribe, GameEnums.eCamp.Alliance);
                    break;
                }
                else if (input == "호드")
                {
                    this.selectedCamp = GameEnums.eCamp.Horde;
                    this.MoveStep(GameEnums.eStep.SelectTribe, GameEnums.eCamp.Horde);
                    break;
                }
                else
                {
                    Console.WriteLine("잘못입력하셨습니다.");
                    continue;
                }
            }
 
 
        }
 
        private void SelectTribe(GameEnums.eCamp selectedCamp)
        {
            Console.WriteLine($"selectedCamp: {this.selectedCamp}");
 
            var strTribes = this.GetAvailableTribesString();
 
            Console.WriteLine($"종족을 선택해주세요 [{strTribes}] ");
 
            while (true)
            {
                var keyChar = Console.ReadKey().KeyChar;
                int inputNum;
                Int32.TryParse(keyChar.ToString(), out inputNum);
 
                if (inputNum == 0)
                {
                    //뒤로 돌아가기 
                    this.MoveStep(GameEnums.eStep.SelectCamp, GameEnums.eStep.None);
                    break;
                }
                else
                {
                    //선택한 종족
                    this.selectedTribe = this.GetSelectedTribe(selectedCamp, inputNum);
                    Console.WriteLine($"selectedTribe: {selectedTribe}");
 
                    //클래스 선택 하기 
                    this.MoveStep(GameEnums.eStep.SelectClass, this.selectedTribe);
                    break;
                }
            }
        }
 
        private GameEnums.eTribe GetSelectedTribe(GameEnums.eCamp selectedCamp, int inputNum)
        {
            string[] arrTribe = null;
            switch (selectedCamp)
            {
                case GameEnums.eCamp.Alliance:
                    {
                        arrTribe = Mask.allianceMask.ToString().Split(',');
                    }
                    break;
 
                case GameEnums.eCamp.Horde:
                    {
                        arrTribe = Mask.hordeMask.ToString().Split(',');
                    }
                    break;
            }
 
            return (GameEnums.eTribe)Enum.Parse(typeof(GameEnums.eTribe),
                arrTribe.GetValue(inputNum - 1).ToString().Trim());
        }
 
        private GameEnums.eClass GetAvailableClass(GameEnums.eTribe selectedTribe, int index)
        {
            var availableClasses = dicClasses[selectedTribe];
            string[] arrClasses = availableClasses.ToString().Split(',');
            return (GameEnums.eClass)Enum.Parse(typeof(GameEnums.eClass), arrClasses[index - 1].Trim());
        }
 
        private string GetAvailableClassesString(GameEnums.eTribe selectedTribe)
        {
            var availableClasses = dicClasses[selectedTribe];
 
            var sb = new StringBuilder();
            string[] arrClasses = availableClasses.ToString().Split(',');
 
            int i = 1;
            foreach (var availableClass in arrClasses)
            {
                sb.Append(string.Format("{0}:{1} ", i, availableClass.Trim()));
                i++;
            }
 
            sb.Append(string.Format("{0}:돌아가기 "0));
 
            return sb.ToString();
        }
 
        private string GetAvailableTribesString()
        {
            var sb = new StringBuilder();
            string[] arrTribe = null;
 
            switch (selectedCamp)
            {
                case GameEnums.eCamp.Alliance:
                    {
                        arrTribe = Mask.allianceMask.ToString().Split(',');
                    }
                    break;
 
                case GameEnums.eCamp.Horde:
                    {
                        arrTribe = Mask.hordeMask.ToString().Split(',');
                    }
                    break;
            }
 
            int i = 1;
            foreach (var tribe in arrTribe)
            {
                sb.Append(string.Format("{0}:{1} ", i, tribe.Trim()));
                i++;
            }
 
            sb.Append(string.Format("{0}:돌아가기 "0));
 
            return sb.ToString();
        }
 
        private void SelectClass(GameEnums.eTribe selectedTribe)
        {
            Console.WriteLine($"selectedTribe: {selectedTribe}");
 
            //선택한 종족에 따라 직업군 보여주기 
            while (true)
            {
                var strAvailableClasses = GetAvailableClassesString(selectedTribe);
                Console.WriteLine($"직업을 선택해주세요 [ {strAvailableClasses} ] ");
                var keyChar = Console.ReadKey().KeyChar;
                int selectedNum;
                Int32.TryParse(keyChar.ToString(), out selectedNum);
 
                if (selectedNum == 0)
                {
                    this.MoveStep(GameEnums.eStep.SelectTribe, this.selectedCamp);
                    break;
                }
                else
                {
                    this.selectedClass = this.GetAvailableClass(this.selectedTribe, selectedNum);
                    this.MoveStep(GameEnums.eStep.SelectCharacterName, null);
                    break;
                }
            }
 
 
        }
 
        private void MoveStep(GameEnums.eStep step, object selectedValue)
        {
            switch (step)
            {
                case GameEnums.eStep.SelectCamp:
                    {
                        this.SelectCamp();
                    }
                    break;
 
                case GameEnums.eStep.SelectTribe:
                    {
                        this.SelectTribe((GameEnums.eCamp)selectedValue);
                    }
                    break;
 
                case GameEnums.eStep.SelectClass:
                    {
                        this.SelectClass((GameEnums.eTribe)selectedValue);
                    }
                    break;
 
                case GameEnums.eStep.SelectCharacterName:
                    {
                        this.SelectCharacterName();
                    }
                    break;
 
                case GameEnums.eStep.Done:
                    {
                        this.Done();
                    }
                    break;
 
            }
        }
 
        private void Done()
        {
 
            Console.WriteLine("케릭터가 생성되었습니다.");
            Console.WriteLine($"이름: {this.selectedCharacterName}");
            Console.WriteLine($"진영: {this.selectedCamp}");
            Console.WriteLine($"종족: {this.selectedTribe}");
            Console.WriteLine($"직업: {this.selectedClass}");
 
            Console.WriteLine("프로그램을 종료합니다.");
        }
 
        private void SelectCharacterName()
        {
            while (true)
            {
                Console.WriteLine("케릭터 이름을 정해주세요 : ");
                var input = Console.ReadLine();
                if (string.IsNullOrEmpty(input))
                {
                    continue;
                }
                else
                {
                    this.selectedCharacterName = input;
                    this.MoveStep(GameEnums.eStep.Done, null);
 
                    break;
                }
            }
        }
    }
 
 
    //진영선택
    //얼라/호드 
 
    //종족선택
    //1.오크/2.언데드/3.타우렌/4.트롤/5.블러드엘프/6.고블린/7.판다렌/0.뒤로돌아가기
 
    //직업선택 (종족에따라)
    //1:죽음의기사 2: 사냥꾼, 3: 마법사, 4:수도사, 5:사제, 6:도적, 7:흑마법사, 8:전사
}
 
 
 
cs


반응형

'Unity3D > C#' 카테고리의 다른 글

C#. 쓰레드(Thread)  (0) 2019.04.01
컬렉션(C#)  (0) 2019.03.28
enum과 비트마스크  (0) 2019.03.26
C# Array Value Type or Reference  (0) 2019.03.12
CLR(Common Language Runtime)  (0) 2019.03.12
:

enum과 비트마스크

Unity3D/C# 2019. 3. 26. 18:47
반응형
enum과 비트마스크 



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace Study_03
{
    class App
    {
        public enum eNames
        {
            None = 0,
            Susan = 1,
            Bob = 2,
            Karen = 4,
            All = ~None
        }
 
        //생성자 
        public App()
        {
            var names = App.eNames.Bob | App.eNames.Karen;
            Console.WriteLine($"names: {names}");
            var includeSusan = (names & App.eNames.Susan) != App.eNames.None;
            Console.WriteLine($"{includeSusan}");
 
        }
    }
}
 
cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace Study_03
{
    class GameEnums
    {
        //진영 
        public enum eCamp
        {
            None = 0,
            Alliance = 100,
            Horde = 200
        }
 
        //종족
        [Flags]
        public enum eTribe
        {
            None = 0,
            Human = 1,
            Dwarf = 2
            NightElf = 4,
            All = ~None
        }
 
        //직업 
        [Flags]
        public enum eClasses
        {
            None = 0,
            DeathKnight = 1,
            Hunter = 2,
            Rogue = 4,
            Monk = 8,
            Mage = 16,
            Warlock = 32,
            Priest = 64
            Paladin = 128,
            Warrior = 512,
            Shaman = 1024,
            DemonHunter = 2048,
            Druid = 4096,
            All = ~None
        }
    }
}
 
cs



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace Study_03
{
    class Program
    {
        static void Main(string[] args)
        {
            GameEnums.eClasses humanAvailableClass = GameEnums.eClasses.DemonHunter |
                GameEnums.eClasses.DeathKnight |
                GameEnums.eClasses.Druid |
                GameEnums.eClasses.Rogue |
                GameEnums.eClasses.Hunter |
                GameEnums.eClasses.Monk |
                GameEnums.eClasses.Mage |
                GameEnums.eClasses.Priest |
                GameEnums.eClasses.Warrior;
 
            Console.WriteLine("종족을 선택해주세요. (1: 인간, 2:드워프, 3:나엘");
 
            var arrTribe = Enum.GetValues(typeof(GameEnums.eTribe));
            //foreach (var tribe in arrTribe)
            //{
            //    Console.WriteLine(tribe);
            //}
 
            var keyChar = Console.ReadKey().KeyChar;
            int selectedClassNum;
            Int32.TryParse(keyChar.ToString(), out selectedClassNum);
 
            var selectedClassEnum = (GameEnums.eTribe)arrTribe.GetValue(selectedClassNum);
 
            // 10진수를 2진수 문자열로
            string strBase2_2 = Convert.ToString((int)humanAvailableClass, 2);
            //Console.WriteLine(strBase2_2);
 
            var allClasses = Enum.GetValues(typeof(GameEnums.eClasses));
            //foreach (var availableClass in allClasses)
            //{
            //    var a = humanAvailableClass & (GameEnums.eClasses)availableClass;
            //    //var b = Convert.ToString((int)a, 2);
            //    var b = a & ~GameEnums.eClasses.None;
            //    Console.WriteLine("--->" + b);
            //}
 
            var a = humanAvailableClass & GameEnums.eClasses.All;
            //var b = Convert.ToString((int)a, 2);
            var b = a & ~GameEnums.eClasses.None;
 
            var c = b.ToString().Split(',');
            foreach (var d in c) {
                Console.WriteLine(d.ToString().Trim());
            }
 
            Console.ReadKey();
        }
    }
}
 
cs


반응형

'Unity3D > C#' 카테고리의 다른 글

컬렉션(C#)  (0) 2019.03.28
2019.03.26 과제 (와우 케릭터 만들기 C#콘솔)  (0) 2019.03.27
C# Array Value Type or Reference  (0) 2019.03.12
CLR(Common Language Runtime)  (0) 2019.03.12
C# Generic  (0) 2019.01.23
:

2019.03.22 과제

카테고리 없음 2019. 3. 22. 20:57
반응형

for문

https://docs.microsoft.com/ko-kr/dotnet/csharp/language-reference/keywords/for


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace Study_00
{
    class Test
    {
        public Test()
        {
            //생성자 
            for (int i = 0; i < 2; i++)
            {
                Console.WriteLine(i+5);
            }
 
            //int i의 값은 0이다.
            //i의 값은 0이다.
            //0은 2보다 작다 
            //비교 연산된 값은 True다.
            //비교 연산된 값이 True이므로 본문을 실행 한다.
            //i의 값은 0이다.
            //+ 연산된 값은 5이다.
            //5를 출력하고 줄바꿈한다.
            //iterator섹션을 실행 한다.
            //i의 값은 0이다.
            //++연산된 값은 1이다.
            //condition 섹션을 실행 한다.
            //i의 값은 1이다.
            //1은 2보다 작다.
            //비교연산된 값은 True다.
            //비교 연산된 값이 True이므로 본문을 실행 한다.
            //i의 값은 1이다.
            //+ 연산된 값은 6이다.
            //6을 출력하고 줄바꿈 한다.
            //iterator섹션을 실행 한다.
            //i의 값은 1이다.
            //++연산된 값은 2이다.
            //condition 섹션을 실행 한다.
            //i의 값은 2이다.
            //2은 2보다 작다.
            //비교연산된 값은 Flase다.
            //비교 연산된 값이 False이므로 루프를 종료 한다.
 
            Console.ReadKey();
        }
    }
}
 
cs



값형식https://docs.microsoft.com/ko-kr/dotnet/csharp/language-reference/keywords/value-types


값현식의 변수에 새 값을 할당하면 해당값이 복사 된다.

모든 값 형식은 System.ValueType 에서 암시적 파생된다.

값형식 변수는 기본적으로 null일수없다. 그러나 해당 nullable 형식의 변수는 null 일수 있다.

값형식에는 해당 형식의 기본값을 초기화 하는 암시적 기본 생성자가 있다.


기본값표 : https://docs.microsoft.com/ko-kr/dotnet/csharp/language-reference/keywords/default-values-table





1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace Study_00
{
    class Test
    {
        public Test()
        {
            //Test클래스의 생성자 
 
 
            //값형식의 초기화
 
            //지역변수는 사용하기 전에 초기화 해야 한다.
            //다음과 같이 초기화 하지 않고 지역변수를 선언할수 있다.
            int myInt;
 
            //초기화 전에 사용할수 없다.
            //초기화 하기 전에 사용하면 다음과 같은 에러를 만들어 낸다.
            //[ERROR] 할당되지 않은 'myInt'지역변수를 사용했습니다.
            //Console.WriteLine(myInt);
 
            //다음과 같이 초기화 할수 있다.
            myInt = new int();
            Console.WriteLine(myInt);
 
            //이것은 다음 문과 같다.
            myInt = 0;
            Console.WriteLine(myInt);
 
            //다음과 같이 선언과 초기화를 동일한 문에 포함 할수 있다.
            int myInt2 = new int();
            //또는 
            int myInt3 = 0;
 
            //new 연산자를 사용하면 특정 형식의 기본 생성자가 호출되고 
            //변수에 기본값이 할당 된다.
            //기본 생성자가 0값을 myInt에 할당 했다.
 
 
 
            Console.ReadKey();
        }
    }
}
 
cs




참조형식 : https://docs.microsoft.com/ko-kr/dotnet/csharp/language-reference/keywords/reference-types


C#형식은 참조형식과 값형식 두가지가 있다.

참조형식의 변수에 데이터(개체)에 대한 참조가 저장된다.

참조형식에는 두가지 변수가 같은 개체를 참조할수 있으므로 

한 변수에 대한 작업이 다른 변수에서 참조하는 개체에 영향을 미칠수 있다.


다음 키워드는 참조형식을 선언하는데 사용된다.


class, interface, delegate 


다음과 같은 기본 참조형식도 제공한다.


dynamic, object, string 




스택과 힙




값 형식 : int 

부호있는 32비트 정수 

https://docs.microsoft.com/ko-kr/dotnet/csharp/language-reference/keywords/int


범위 : -21억 ~ 21억 












리터럴?

컴퓨터 과학 분야에서 리터럴(literal)이란 소스 코드의 고정된 값을 대표하는 용어다.

https://ko.wikipedia.org/wiki/%EB%A6%AC%ED%84%B0%EB%9F%B4


리터럴은 데이터 그 자체를 뜻 한다. 

변수에 넣는 변하지 않는 데이터를 의미하는 것이다.

https://mommoo.tistory.com/14


변수및 상수에 저장되는 값 자체 

https://vitalholic.tistory.com/15



리터럴이란, 컴파일시 프로그램 내에 정의되어 있는 그대로 정확히 해석되어야 할 값을 의미한다.

리터럴은 숫자 뿐 아니라, 문자 또는 문자열일 수 있다.

http://www.terms.co.kr/literal.htm

예) x = 7


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace Study_00
{
    class Test
    {
        public Test()
        {
            //Test클래스의 생성자 
 
            //10진수 리터럴로 표현된 90,964와 같은 정수가 int 값에 할당된다.
            //10진수 리터럴에는 접두사가 없다.
            int intValue1 = 90946;
 
            //16진수 리터럴로 표현된 0x16342
            //0x 또는 0X 접두사를 사용하여 16진수 리터럴을 나타낸다.
            int intValue2 = 0x16342;
 
            //2진 리터럴 0b0001_0110_0011_0100_0010
            //0b 또는 0B 접두사를 사용하여 이진 리터럴을 나타낸다.
            //2진수 계산기 : https://ko.calcuworld.com/%EC%88%98%ED%95%99/2%EC%A7%84%EB%B2%95-%EA%B3%84%EC%82%B0%EA%B8%B0/
            int intValue3 = 0b0001_0110_0011_0100_0010;
 
            Console.WriteLine("10진수 리터럴 : " + intValue1);
            Console.WriteLine("16진수 리터럴 : " + intValue2);
            Console.WriteLine("2진 리터럴 : " + intValue3);
 
            Console.ReadKey();
        }
    }
}
 
cs




이어서 할것..



float: 32비트 부동소수점 값을 저장하는 단순 형식 

https://docs.microsoft.com/ko-kr/dotnet/csharp/language-reference/keywords/float


부동 소수점 형식 표 (float, double, decimal)

https://docs.microsoft.com/ko-kr/dotnet/csharp/language-reference/keywords/floating-point-types-table


기본적으로 대입연산자 오른쪽의 실수 리터럴은 double로 처리 됨.




변환

식에서 숫자 정수 형식과 부동 소수점 형식을 함께 사용할 수 있다.

이 경우 정수 형식이 부동 소수점 형식으로 변환됨.

식의 계산은 다음 규칙에 따라 수행됨.




변환
식에서 숫자 정수 형식과 부동 소수점 형식을 함께 사용할 수 있다.
이 경우 정수 형식이 부동 소수점 형식으로 변환됨.
식의 계산은 다음 규칙에 따라 수행됨.

부동 소수점 형식중 하나가 double이면 식은 같음에 대한 관계형 비교또는 비교에서 double 또는 bool로 계산됨.






실습 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
 
namespace Study_00
{
    class Test
    {
        public Test()
        {
            //int, short및 float가 수학식에 포함되어 float 결과를 제공 
            //float 은 System.Single형식의 별칭 이다.
 
            int x = 3;
            float y = 4.5f;
            short z = 5;
            var result = x * y / z;
            Console.WriteLine("The result is {0}", result);
            Type type = result.GetType();
            Console.WriteLine("result is of type : {0}", type.ToString());
 
 
            Console.ReadKey();
        }
    }
}
 
cs

결과 







var 타입 

Visual C# 3.0부터 메서드 범위에서 선언된 변수에 암시적 "형식" var을 사용할 수 있습니다. 암시적 형식 지역 변수는 형식을 직접 선언한 것처럼 강력한 형식이지만 컴파일러가 형식을 결정합니다. i의 다음 두 선언은 기능이 동일합니다.


Type


Console.WriteLine 



Console.WriteLine  실습 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
 
namespace Study_00
{
    class Test
    {
        public Test()
        {
            int monsterHp;
            int monsterMaxHp = 120;
 
            monsterHp = monsterMaxHp;
 
            Console.WriteLine("몬스터 체력 : ({0}/{1})", monsterHp, monsterMaxHp);
 
            Console.ReadKey();
        }
    }
}
 
cs








Floating Point Number의 진실 in C#

http://rapapa.net/?p=3414







long : 

https://docs.microsoft.com/ko-kr/dotnet/csharp/language-reference/keywords/long


long은 다음표에 나와있는 크기와 범위에 따라 값을 저장하는 정수형식을 나타냄 

범위 : –9,223,372,036,854,775,808 ~ 9,223,372,036,854,775,807

부호있는 64비트 정수 


리터럴 

10진수 리터럴, 16진수 리터럴 또는 이진 리터럴을 할당하여 long변수를 선언하고 초기화 할수 있다.

0x또는 0X접두사를 사용하여 16진수 리터럴을 나타내고 

0b또는 0B접두사를 사용하여 이진 리터럴을 나타낸다.

10진수 리터럴에는 접두사가 없다.

소문자 l 을 접미사로 사용할수있다.

구별을 위해 L을 사용하자.



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
 
namespace Study_00
{
    class Test
    {
        public Test()
        {
            long a = Int64.MaxValue;
            a += 1;
 
            //가장 작은 수가 되어 버렸다.
            //–9,223,372,036,854,775,808 ~ 9,223,372,036,854,775,807
            Console.WriteLine(a); //-9223372036854775808 
 
 
            //4294967296는 uint범위를 초과하기 때문에 long형식이다.
            var longVal1 = 4_294_967_296;
 
            //long에서 float, double또는 decimal은 미리 정의된 암시적 변환이 있으나
            //없는 경우 캐스트 해야 한다.
            int x = (int)8L;
        }
    }
}
cs








double : 


https://docs.microsoft.com/ko-kr/dotnet/csharp/language-reference/keywords/double


double 키워드는 64비트 부동 소수점 값을 저장하는 단순 형식이다.

근사범위를 가진다. : ±5.0 × 10−324 ~ ±1.7 × 10308

전체 자릿수 : ~15-17개 

.NET형식 : System.Double 


리터럴 


기본적으로 대입 연산자 오른쪽의 실수 리터럴은 double로 처리 된다.

그러나 정수가 double로 처리 되도록 하려면 접미사 d 또는 D를 사용하면 된다.






1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
 
namespace Study_00
{
    class Test
    {
        public Test()
        {
            int x = 3;
            float y = 4.5f;
            short z = 5;
            double w = 1.7E+3;
 
            Console.WriteLine($"x:{x} y:{y} z:{z} w:{w}");
        }
    }
}
cs













char https://docs.microsoft.com/ko-kr/dotnet/csharp/language-reference/keywords/char



char 키워드는 .NET Framework에서 유니코드 문자를 표현하는데 사용하는 Sytstem.Char 구조체의 인스턴스를 선언하는데 사용된다.


Char 개체의 값은 16비트 숫자(서수)값이다.


서수 : 순서를 나타내는 수의 쓰임방식이다.



리터럴 

char 형식의 상수는 문자 리터럴, 16진수 이스케이프 시퀀스 또는 유니코드 표현으로 기록 될수 있다.

정수 문자 코드를 캐스트 할수도 있다. 

ex ) char[] chars = new char[4];


char[0] = (char)88



실습 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
 
namespace Study_00
{
    class Test
    {
        public Test()
        {
            char[] chars = new char[4];
 
            chars[0] = 'X';
            chars[1] = '\x0058';
            chars[2] = (char) 88;
            chars[3] = '\u0058';
 
            foreach (char c in chars)
            {
                Console.WriteLine(c + " ");
            }
        }
    }
}
cs

결과 




https://www.utf8-chartable.de/unicode-utf8-table.pl




아스키코드 (ASCII)

미국 ANSI에서 표준화 한 정보교환용 7비트 부호체계 (128개)

문자와 기호가 해당 숫자 표현으로 변환되어야 하는 필요

데이터 저장과 교환가능 해짐 

아스키코드를 이용해 다른언어를 표현하기에 7비트로는 부족했기에 8비트로 확장한 아스키코드가 나옴

이를 ANSI코드라 부름 

2의 7승 : 128개 -> 2의 8승 : 256개로 128개나 더 쓸수 있게 됨 

위키 : https://ko.wikipedia.org/wiki/ASCII

참고 : https://minwan1.github.io/2018/06/09/2018-06-09-ASCII-Unicode/







유니코드 (Unicode)

위키 : https://en.wikipedia.org/wiki/Unicode

참고 : https://whatisthenext.tistory.com/103


전세계의 모든 문자를 컴퓨터에서 일관되게 표현하고 다룰수있도록 설계된 산업 표준.

한글은 자음+모음의 조합이 128개가 넘음 

중국어 한자의 개수가 만개가 넘음 아스키로는 불가능 

그래서 용량을 확장한 2byte (2의 16승 : 65536)의 유니코드가 등장 

유니코드는 총 110만개가 넘는 코드를 지정할수 있음 


문자 인코딩 

특정한 문자 집합 안의 문자들을 컴퓨터에서 사용하기 위해 일정한 범위 안의 정수(코드값)으로 변환하는 방법

유니코드 포인트를 8비트 숫자의 집합으로 나타내는 UTF-8이나 16비트의 숫자 집합으로 나타내는 UTF-16이 포함됨 














문자열 string : https://docs.microsoft.com/ko-kr/dotnet/csharp/programming-guide/strings/


문자열 값은 텍스트인 String 형식의 개체 

내부적으로 텍스트는 Char 개체의 순차적 읽기전용 컬렉션 (배열) 로 저장됨 

문자열 끝에 null 종료 문자가 없으므로 C# 문자열에는 포함된 null문자 ('\0')를 여러개 사용할수 있다.

문자열의 Length속성은 유니코드 문자 수가 아닌 포함된 char 개체수를 나타냄 

문자열에 개별 유니코드 코드 포인트에 엑세스 하려면 StringInfo개체를 사용 



문자열과 System.String

C#에서 string 키워드는 String의 별칭 

String 클래스는 문자열을 안전하게 작성, 조작및 비교 할수 있도록 다양한 메서드를 제공 



null : https://docs.microsoft.com/ko-kr/dotnet/csharp/language-reference/keywords/null

null 키워드는 개체를 참조 하지 않는 null참조를 나타내는 리터럴 

null은 참조형식 변수의 기본값 

일반적인 값형식은 null일수 없다.

그러나 nullable 값형식이 도입 됨. (c#2.0)



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
 
namespace Study_00
{
    class Test
    {
        public Test()
        {
            //초기화 없이 선언 
            string message1;
 
            //null값으로 초기화 
            string message2 = null;
 
            //비어 있는 문자열로 초기화 
            //"" 리터럴 대신 Empty상수를 이용함 
            string message3 = System.String.Empty;
 
            //보통의 문자열 리터럴 ""로 묶음 
            string oldPath = "c:\\Program Files\\Microsoft Visual Studio 8.0";
 
            //축어적 문자열 리터럴 @을 사용 
            string newPath = @"c:\Program Files\Microsoft Visual Studio 9.0";
 
            //명시적으로 네임스페이스 선언하여 사용할수도 있음 
            System.String greeting = "Hello World!";
 
            //지역변수 var 타입을 사용할수도 있음 (암시적으로 변환, 컴파일 타임에 )
            var temp = "반갑습니다.";
 
            //상수 값으로 사용도 가능 
            const string message4 = "문자열은 너무 공부할게 많다...";
 
            //new 키워드를 사용하여 String 클래스의 인스턴스를 생성할수있으며
            //생성자를 사용하여 문자 배열을 매개변수로 전달 할수도 있다.
 
            char[] letters = { 'A''B''C' };
            string alphabet = new string(letters);
 
            //문자 배열이 포함된 문자열을 초기화할 경우를 제외하고는 문자열 개체를 만들기 위해 new 연산자를 사용하지 않습니다.
        }
    }
}
cs









문자열표현식 (문자열보간)

$특수 문자는 문자열 리터럴을 보간된 문자열로 식별한다.

보간된 문자열은 보간된 식이 포함될 수 있는 문자열 리터럴이다.

보간된 문자열이 결과 문자열로 해석되면 보간된 식이 있는 항목이 식 결과의 문자열 표현으로 바뀐다.

C# 6 이상 버전에서 사용할 수 있음.


예제는 몬스터 잡기에서 사용했습니다.

https://docs.microsoft.com/ko-kr/dotnet/csharp/language-reference/tokens/interpolated











몬스터 잡기 (1~3차까지)



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
 
namespace Study_00
{
    class Test
    {
        string monsterName = "오우거";
        int maxMonsterHp = 123;
        int monsterHp;
        string monsterDesc = "몬스터는 사납고 무섭습니다.";
        string heroName = "홍길동";
        int maxHeroHp = 80;
        int heroHp;
        int heroAttackDamage = 4;
 
        public Test()
        {
            //Test클래스의 생성자 
            this.monsterHp = this.maxMonsterHp;
            this.heroHp = this.maxHeroHp;
 
            Log($"몬스터의 이름은 {monsterName} 입니다.");
            Log($"몬스터의 체력은 {monsterHp}/{maxMonsterHp}입니다.");
            Log(monsterDesc);
            Log($"용사의 이름은 {heroName} 입니다.");
            Log($"용사의 공격력은 {heroAttackDamage} 입니다.");
 
            AttackMonster();
 
            while (true)
            {
                if (monsterHp <= 0)
                    break;
                
                Log($"공격을 더 하시겠습니까? (Y/N)"false);
 
                var info = Console.ReadKey();
                Log("");
 
                if (info.Key == ConsoleKey.Y)
                {
                    
                    Log($"몇회 공격하시겠습니까?"false);
                    
                    int attackCnt;
 
                    Int32.TryParse(Console.ReadLine(), out attackCnt);
 
                    this.ClearCurrentConsoleLine();
 
                    if (attackCnt > 0)
                    {
                        Log($"{attackCnt}회 공격을 시도 합니다.");
                        for (int i = 0; i < attackCnt; i++)
                        {
                            this.AttackMonster();
 
                            if(this.monsterHp <= 0break;
 
                            Thread.Sleep(300);
                        }
                    }
                    else
                    {
                        Log($"잘못된 횟수입니다.");
                       continue;
                    }
                }
                else if (info.Key == ConsoleKey.N)
                {
                    
                    break;
                }
                else
                {
                    Log("잘못된 선택입니다.");
                }
 
            }
 
            Log("프로그램을 종료 합니다.");
            Console.ReadKey();
        }
 
        private void AttackMonster()
        {
            Log($"용사몬스터를 공격했습니다.");
            Log("몬스터는 "false);
            WriteLineWithColor("피해 (4)", ConsoleColor.Red);
            Log("를 받았습니다."true);
 
            this.monsterHp -= this.heroAttackDamage;
 
            if (this.monsterHp <= 0)
                this.monsterHp = 0;
 
            Log($"몬스터의 체력은({monsterHp}/{maxMonsterHp})입니다.");
 
            if (this.monsterHp <= 0)
            {
                Log($"몬스터가 죽었습니다.");
            }
 
        }
 
        private void Log(object value, bool isWriteLine = true)
        {
            if(isWriteLine)
                Console.WriteLine(value);
            else
                Console.Write(value);
        }
 
        private void WriteLineWithColor(string value, ConsoleColor color)
        {
            Console.BackgroundColor = ConsoleColor.Black;
            Console.ForegroundColor = color;
            Console.Write(value);
            Console.ResetColor();
        }
 
        private void ClearCurrentConsoleLine()
        {
            int currentLineCursor = Console.CursorTop;
            Console.SetCursorPosition(0Console.CursorTop);
            Console.Write(new string(' 'Console.WindowWidth));
            Console.SetCursorPosition(0, currentLineCursor);
        }
 
    }
}
 
cs


반응형
:

1. Introduction to Meshes

Udemy/Coding in Unity: Introduction to Shaders 2019. 3. 21. 03:05
반응형


Unity uses materials, shader and textures to display two and three dimensional model

Unity는 2 차원 및 3 차원 모델을 표시하기 위해 머티리얼, 셰이더 및 텍스처를 사용합니다.


The model has one or more materials and each material uses a shader

모델에는 하나 이상의 머티리얼이 있고 각 머티리얼에는 셰이더가 사용됩니다.


The shader used by the material is written in Unity's own language called ShaderLab. Within this, CG and HLSL code is also used.

머티리얼이 사용하는 셰이더는 Unity의 자체 언어 인 ShaderLab으로 작성되었습니다. 이 안에는 CG와 HLSL 코드도 사용됩니다.


The shader exposes certain properties that are set by the material.

셰이더는 재질에 의해 설정된 특정 속성을 노출합니다.


It contains code that calculates how an object should display on screen.

객체가 화면에 표시되는 방식을 계산하는 코드가 포함되어 있습니다.


To understand shaders you first need to understand what makes up two and three dimensional models.

셰이더를 이해하려면 먼저 2 차원 및 3 차원 모델을 구성하는 요소를 이해해야합니다.


Models are measures made up of triangles arranged in space.

모델은 공간에 배치 된 삼각형으로 구성된 측정 값입니다.


Each mesh requires several pieces of information in order to display correctly.

각 메시는 올바르게 표시하기 위해 여러 가지 정보가 필요합니다.


First these which give the triangle positions in 3-d space.

먼저 3 차원 공간에서 삼각형의 위치를 ​​지정합니다.


Triangles which join up the vertices to create the model.

버텍스를 결합하여 모델을 만드는 삼각형.


Normal's which allow lighting to shade the model uv's if you want to map a texture on  to the model.

텍스처를 모델에 매핑하려는 경우 라이팅이 모델 uv의 음영을 허용하는 Normal입니다.


If you want to add a normal map to the model.

모델에 노멀 맵을 추가하려는 경우.


Carlos if you wish to use vertex colors model always needs at least its first season triangle specified

Carlos는 버텍스 색상 모델을 사용하고자한다면 적어도 지정된 첫 번째 시즌 삼각형을 필요로합니다



Vertices of the corner positions of two and three dimensional models.

2 차원 및 3 차원 모델의 모서리 위치 정점.


If you see the vertices is stored in the vector 3 array with X Y and Z corresponding to the x y and z coordinates of the vertex. 

보시다시피 꼭지점은 벡터의 배열에 저장되고 X Y와 Z는 꼭지점의 x 및 z 좌표에 해당합니다.


Triangles are used to join up the vertices in a model in unity.

삼각형은 모델의 정점을 결합하는 데 사용됩니다.


The triangles are stored in an array with every three entries corresponding to a single triangle.

삼각형은 하나의 삼각형에 해당하는 세 개의 항목이있는 배열로 저장됩니다.





반응형
:

How Unity Supports Cross Platform Feature

Unity3D 2019. 3. 20. 13:08
반응형

https://medium.com/@nirajv21/how-unity-supports-cross-platform-feature-ae722321cfa




https://medium.com/@nirajv21/introduction-to-c-net-and-mono-76b7ddad1788




반응형

'Unity3D' 카테고리의 다른 글

(unity) find child recursively  (1) 2019.04.21
Orthographic size  (0) 2019.04.17
C# 컴파일 그리고 il2cpp  (0) 2019.03.07
JsonUtility  (0) 2019.03.07
Unity의 회전 및 오리엔테이션  (0) 2019.02.20
: