'C#'에 해당되는 글 38건

  1. 2023.11.03 Unity C# Socket 한글 깨짐
  2. 2021.10.19 int to Hex byte
  3. 2021.10.13 C# Socket Class
  4. 2021.08.10 Winform Socket Receive Textbox Value Assignment Not Work
  5. 2021.07.16 C# 콘솔 출력하는 방법 정리 - 윈폼프로젝트에 콘솔 보이게 하기
  6. 2019.07.12 partial class
  7. 2019.04.11 <바론과 애니비아 쌈박질>
  8. 2019.04.10 <Overload, Override>, .json없이 .dat으로

Unity C# Socket 한글 깨짐

C#/problemsC# 2023. 11. 3. 12:14


    private void ReceiveData()
    {
        byte[] buffer = new byte[1024];
        while (isRunning)
        {
            int bytesRead = this.socketClient.GetStream().Read(buffer, 0, buffer.Length);
            if (bytesRead > 0)
            {
                byte[] receivedData = new byte[bytesRead];
                Array.Copy(buffer, receivedData, bytesRead);
                Debug.Log("Received Binary Data: " + BitConverter.ToString(receivedData));

                // 바이너리 데이터를 문자열로 변환하여 확인 (주의: 한글 문자열이 깨져있을 수 있음)
                string decodedString = Encoding.GetEncoding(949).GetString(receivedData);

                print(decodedString);
                ProcessReceivedMessage(decodedString);
            }
        }
    }

바이너리 값으로 받아서 949 or UTF-8 방식으로 직접 변환

저작자표시
:

int to Hex byte

C# 2021. 10. 19. 17:28

using System;
using System.Threading;
using System.Collections.Generic;


namespace NetHappy
{
    class Program
    {
        static Dictionary<byte, int> dicCmdDatalength = new Dictionary<byte, int>();
        static void Main(string[] args)
        {
            dicCmdDatalength.Add(0xf4, 16);
            int[] wheelSpeed = { -1, -1, 1000, 1000 };
            byte[] value = InputData(wheelSpeed, 0xf4);

            string strValue = BitConverter.ToString(value);
            Console.WriteLine(strValue);
        }

        static byte[] InputData(int[] data, byte cmd)
        {
            int length = dicCmdDatalength[cmd];
            byte[] result = new byte[length + 5];//+ 5 = STX, STX, CMD, DataLength, ETX
            byte[] value= new byte[4];
            result[0] = 0x55;
            result[1] = 0x55;
            result[2] = cmd;
            result[3] = Convert.ToByte(length);

            int k = 4;
            for(int i = 0; i < 4; i++)
            {
                value = BitConverter.GetBytes(data[i]);
                for(int j = 0; j < 4; j++)
                {
                    result[k] = value[j];
                    k++;
                }
            }
            result[result.Length - 1] = 0xAA;

            return result;
        }
    }
}

저작자표시

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

C# 콘솔 출력하는 방법 정리 - 윈폼프로젝트에 콘솔 보이게 하기  (0) 2021.07.16
:

C# Socket Class

C#/Winform 2021. 10. 13. 10:58

Socket.cs
0.01MB
WinformSocketServer.7z
0.03MB

 

저작자표시

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

Winform Socket Receive Textbox Value Assignment Not Work  (0) 2021.08.10
:

Winform Socket Receive Textbox Value Assignment Not Work

C#/Winform 2021. 8. 10. 09:35

https://stackoverflow.com/questions/16424202/c-sharp-textbox-not-updating-when-used-with-socketio4net

 

C# Textbox Not Updating When Used With SocketIO4NET

I'm having a strange problem. I'm using SocketIO4Net Client for my program written in C#. The program communicates with server written in NodeJS & SocketIO. I'm able to send & receive data

stackoverflow.com

Winform 외부에서 textBox 값 변경할때
값 안 바뀌고 가만히 있으면

 

this.textBox.Text = msg;//이렇게 쓰지말고

this.textBox.Invoke(new Action(() => textBox.Text = msg));//이렇게써

 

https://bufferover.tistory.com/3

 

C# Invoke를 사용해 크로스 스레드 문제를 해결하는 방법

문제 원인 동시성이 있는 멀티 스레드 프로그램 환경에서 특정 스레드에서 생성된 Win Form 컨트롤 ( TextBox, ListView, Label, … )을 다른 스레드에서 접근할 때 발생한다. 스레드에서 안전한 방식으로

bufferover.tistory.com

 

저작자표시

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

C# Socket Class  (0) 2021.10.13
:

C# 콘솔 출력하는 방법 정리 - 윈폼프로젝트에 콘솔 보이게 하기

C# 2021. 7. 16. 09:47

https://manniz.tistory.com/entry/CC-%EC%BD%98%EC%86%94-%EC%B6%9C%EB%A0%A5%ED%95%98%EB%8A%94-%EB%B0%A9%EB%B2%95-%EC%A0%95%EB%A6%AC-%EC%9C%88%ED%8F%BC%ED%94%84%EB%A1%9C%EC%A0%9D%ED%8A%B8%EC%97%90-%EC%BD%98%EC%86%94-%EB%B3%B4%EC%9D%B4%EA%B2%8C-%ED%95%98%EA%B8%B0

저작자표시

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

int to Hex byte  (0) 2021.10.19
:

partial class

C#/모르는것 2019. 7. 12. 13:32

https://docs.microsoft.com/ko-kr/dotnet/csharp/programming-guide/classes-and-structs/partial-classes-and-methods


partial class
대규모 프로젝트시, 여러 곳에서 한개의 클래스를 정의하는 방법

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 TestPartial
{
    class Program
    {
        static void Main(string[] args)
        {
            Go.Write1();
            Go.Write2();
        }
    }
}
 
cs



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
using System;
 
namespace TestPartial
{
    public class ClassA
    {
        
    }
    partial class Go
    {
        public static void Write1()
        {
            Console.WriteLine("이곳은 A");
        }
    }
}
cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
using System;
 
namespace TestPartial
{
    public class ClassB
    {
 
    }
    partial class Go
    {
        public static void Write2()
        {
            Console.WriteLine("이곳은 B");
        }
    }
}
cs








저작자표시

'C# > 모르는것' 카테고리의 다른 글

델리게이트  (0) 2019.03.28
<공부할 거 모아두기>하루에 하나라도 찾아보려고 노력하기  (0) 2019.03.26
:

<바론과 애니비아 쌈박질>

C#/과제 2019. 4. 11. 01:37



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
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace TestBattle
{
    public class Annivia : Champion, IMoveAble, IAttackable
    {
        public virtual void Move(Vector2 movePos)
        {
            var data = DataManager.GetInstance().dicCharacterData[this.characterInfo.id];
 
            float dis = this.characterInfo.pos.GetDistance(this.characterInfo.pos, movePos);
            while (true)
            {
                if (dis > 0)
                {
                    System.Threading.Thread.Sleep(500);
                    var dir = (movePos - this.characterInfo.pos).Normalize();
                    this.characterInfo.pos += dir * data.speed;
 
                    Console.WriteLine("{0}이(가) ({1:0.00},{2:0.00})로 이동합니다.", data.name, this.characterInfo.pos.x, this.characterInfo.pos.y);
                    dis -= data.speed;
                }
                else
                {
                    this.characterInfo.pos = movePos;
                    Console.WriteLine("{0}이(가) ({1:0.00},{2:0.00})에 도착했습니다.", data.name, this.characterInfo.pos.x, this.characterInfo.pos.y);
                    break;
                }
            }
        }
 
        //기능구현 사정거리 안에 있는 놈 때리기
        public void Attack(Character target)
        {
            var thisData = DataManager.GetInstance().dicCharacterData[this.characterInfo.id];
            var targetData = DataManager.GetInstance().dicCharacterData[target.characterInfo.id];
 
            //사거리 안에있으면 때림, 사거리 안에 없으면 이동함
            float dis = this.characterInfo.pos.GetDistance(this.characterInfo.pos, target.characterInfo.pos);
            while (true)
            {
                System.Threading.Thread.Sleep(500);
                if (dis > thisData.range)
                {
                    var dir = (target.characterInfo.pos - this.characterInfo.pos).Normalize();
                    this.characterInfo.pos += dir * thisData.speed;
 
                    //움직임
                    Console.WriteLine("{0}이(가) ({1:0.00},{2:0.00})로 이동합니다.", thisData.name, this.characterInfo.pos.x, this.characterInfo.pos.y);
 
                    dis -= thisData.speed;
                }
                else
                {
                    //멈춰서 때림
                    Console.WriteLine("{0}이(가) {1}을(를) 공격합니다.", thisData.name, targetData.name);
                    //때리면 데미지 들어감
                    target.TakeDamage(thisData.damage);
                    break;
                }
            }
        }
    }
}
 
cs



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace TestBattle
{
    public class App
    {
        public App()
        {
 
        }
 
        public void Start()
        {
            new GameLauncher();
        }
    }
}
 
cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace TestBattle
{
    public interface IAttackable
    {
        void Attack(Character target);
    }
}
 
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
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace TestBattle
{
    public class Baron : Monster, IAttackable
    {
        //기능구현 사정거리 안에 있는 놈 때리기
        public void Attack(Character target)
        {
            var thisData = DataManager.GetInstance().dicCharacterData[this.characterInfo.id];
            var targetData = DataManager.GetInstance().dicCharacterData[target.characterInfo.id];
 
            //사거리 안에있으면 때림, 사거리 안에 없으면 안때림, 바론은 이동모테
            float dis = this.characterInfo.pos.GetDistance(this.characterInfo.pos, target.characterInfo.pos);
 
            System.Threading.Thread.Sleep(500);
            if (dis > thisData.range)
            {
                Console.WriteLine("{0}이(가) 사정거리:{1} 밖에 있습니다.", targetData.name, thisData.range);
            }
            else
            {
                System.Threading.Thread.Sleep(500);
                //사거리안에 들어오면 때림
                Console.WriteLine("{0}이(가) {1}을(를) 공격합니다.", thisData.name, targetData.name);
                //때리면 데미지 들어감
                target.TakeDamage(thisData.damage);
            }
        }
    }
}
 
cs


1
2
3
4
5
6
7
8
9
10
11
12
13
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace TestBattle
{
    public class Champion : Character
    {
    }
}
 
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;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace TestBattle
{
    public class Character
    {
        public CharacterInfo characterInfo;
 
        //기본 생성자
        public Character()
        {
 
        }
 
        //인포받아 생성자
        public Character(CharacterInfo characterInfo)
        {
            this.characterInfo = characterInfo;
        }
 
        //기능구현 데미지 받기
        public virtual void TakeDamage(int damage)
        {
            var data = DataManager.GetInstance().dicCharacterData[this.characterInfo.id];
 
            if (this.characterInfo.hp > 0)
            {
                this.characterInfo.hp -= damage;
                if(this.characterInfo.hp <= 0)
                {
                    this.characterInfo.hp = 0;
                }
            }
            Console.WriteLine("{0}이(가) {1}의 피해를 입었습니다.\n남은체력:({2}/{3})", data.name, damage, this.characterInfo.hp, data.hp);
        }
    }
}
 
cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace TestBattle
{
    public class CharacterData
    {
        public int id;
        public int type;
        public string name;
        public int hp;
        public int damage;
        public float range;
        public float speed;
    }
}
 
cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace TestBattle
{
    public class CharacterInfo
    {
        public int id;
        public int hp;
        public Vector2 pos;
        public bool alive;
    }
}
 
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.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
using Newtonsoft.Json;
 
namespace TestBattle
{
    public class DataManager
    {
        private static DataManager Instance;
        public Dictionary<int, CharacterData> dicCharacterData;
 
        public DataManager()
        {
            this.dicCharacterData = new Dictionary<int, CharacterData>();
        }
 
        public static DataManager GetInstance()
        {
            if (DataManager.Instance == null)
            {
                DataManager.Instance = new DataManager();
            }
            return DataManager.Instance;
        }
 
        public void DataLoad(string path)
        {
            if (File.Exists(path))
            {
                //데이터 불러오기
                var json = File.ReadAllText(path);
                var CharacterDatas = JsonConvert.DeserializeObject<CharacterData[]>(json);
                foreach (var data in CharacterDatas)
                {
                    this.dicCharacterData.Add(data.id, data);
                }
                Console.WriteLine("데이터 로드 완료");
            }
            else
            {
                Console.WriteLine("데이터 파일이 없습니다.");
            }
        }
    }
}
 
cs


1
2
3
4
5
6
7
8
9
10
11
12
13
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace TestBattle
{
    public class Eggnnivia : Champion
    {
    }
}
 
cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace TestBattle
{
    public class GameInfo
    {
        public List<CharacterInfo> characterInfos;
 
        public GameInfo()
        {
            this.characterInfos = new List<CharacterInfo>();
        }
    }
}
 
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
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace TestBattle
{
    public class GameLauncher
    {
        //캐릭터들 전역변수
        private Baron baron = null;
        private Annivia annivia = null;
        private Eggnnivia eggnnivia = null;
 
        //스위치코드
        private int switchCode = 0;
 
        //유저인포
        private UserInfo userInfo;
        //캐릭터 리스트
        private List<Character> characters = new List<Character>();
 
        public GameLauncher()
        {
            //게임 시작 전 준비
            this.ReadyToStart();
 
            //게임시작
            this.GameStart();
 
            //유저인포 저장(싱크 맞추고 저장)
            this.SaveUserInfo();
            //런쳐 종료
        }
 
        private void ReadyToStart()
        {
            Console.WriteLine("게임 데이터 준비중입니다. 잠시만 기다려주세요.");
            //데이터 로드
            DataManager.GetInstance().DataLoad("./data/character_data.Json");
            //신구 유저 확인
            ExistsUserInfo("./info");
            //사전 준비완료
        }
 
        private void GameStart()
        {
            Console.WriteLine("게임이 시작되었습니다.");
 
            #region 캐릭터 생성
            if (this.userInfo.NewbieCheck == false)
            {
                //기존유저
                baron = (Baron)this.CreateCharacter<Baron>(this.userInfo.gameInfo.characterInfos[0]);
                annivia = (Annivia)this.CreateCharacter<Annivia>(this.userInfo.gameInfo.characterInfos[1]);
                eggnnivia = (Eggnnivia)this.CreateCharacter<Eggnnivia>(this.userInfo.gameInfo.characterInfos[2]);
            }
            else
            {
                //신규유저
                baron = this.CreateCharacter<Baron>(0);
                annivia = this.CreateCharacter<Annivia>(1);
                eggnnivia = this.CreateCharacter<Eggnnivia>(2);
            }
            baron.characterInfo.pos = new Vector2(10, 10);
            this.characters.Add(baron);
            this.characters.Add(annivia);
            this.characters.Add(eggnnivia);
            #endregion
 
            #region 게임진행
            if (annivia.characterInfo.alive == true)
            {
                switchCode = 0;
            }
            else
            {
                switchCode = 1;
            }
 
            while (true)
            {
                if (switchCode == 0)
                {
                    this.AnniviaGameStart();
                }
                else if (switchCode == 1)
                {
                    this.EggnniviaGameStart();
                }
                else if (switchCode==-1)
                {
                    break;
                }
            }
            #endregion
 
            //게임종료
        }
 
        //유저 정보 불러오기(신규 or 기존)
        private void ExistsUserInfo(string path)
        {
            if (Directory.Exists(path))
            {
                //기존 유저
                Console.WriteLine("기존 유저입니다.");
                //캐릭터 인포 불러오기
                this.userInfo = this.LoadUserInfo("./info/user_info.json");
                this.userInfo.NewbieCheck = false;
            }
            else
            {
                //신규 유저
                Console.WriteLine("신규 유저입니다.");
                //./info폴더 만들기
                Directory.CreateDirectory(path);
                //캐릭터 인포만들기
                this.CreateUserInfo();
                this.userInfo.NewbieCheck = true;
            }
        }
 
        //유저 정보 불러오기 - 1(기존 유저 인포 불러오기)
        private UserInfo LoadUserInfo(string path)
        {
            //./info/user_info.json불러오기
            var json = File.ReadAllText(path);
            return JsonConvert.DeserializeObject<UserInfo>(json);
        }
 
        //유저 정보 불러오기 - 2(신규 유저 인포 생성)
        private void CreateUserInfo(UserInfo userInfo = null)
        {
            if (this.userInfo == null)
            {
                if (userInfo == null)
                {
                    this.userInfo = new UserInfo();
                }
                else
                {
                    this.userInfo = userInfo;
                }
            }
        }
 
        //기존유저 캐릭터 인스턴스 생성(불러오기)
        private T CreateCharacter<T>(CharacterInfo characterInfo) where T : Character, new()
        {
            T character = new T();
            character.characterInfo = characterInfo;
            return character;
        }
 
        //신규유저 캐릭터 인스턴스 생성(새로만들기)
        private T CreateCharacter<T>(int id) where T : Character, new()
        {
            var data = DataManager.GetInstance().dicCharacterData[id];
            var info = new CharacterInfo();
            info.id = data.id;
            info.hp = data.hp;
            info.pos = new Vector2(0, 0);
            info.alive = true;
 
            T character = new T();
            character.characterInfo = info;
 
            return character;
        }
 
        private void SaveUserInfo()//json
        {
            //현재의 유저인포(게임인포(캐릭터인포List)))를 유저인포에 저장
            var characterInfos = new List<CharacterInfo>();
            foreach (var character in this.characters)
            {
                characterInfos.Add(character.characterInfo);
            }
            this.userInfo.gameInfo.characterInfos = characterInfos;
 
            //파일 쓰기
            var json = JsonConvert.SerializeObject(this.userInfo);
            File.WriteAllText("./info/user_info.json", json, Encoding.UTF8);
            Console.WriteLine("저장완료");
        }
 
        private void AnniviaGameStart()
        {
            while (true)//애니비아버전
            {
                Console.WriteLine();
                Console.WriteLine("=============================================================================================");
                Console.Write("[바론의 위치({0}, {1})]\n1.애니비아(이동)/2.애니비아(공격)/3.바론(공격)/4.정보 보기/0.종료 후 저장(숫자 입력):", baron.characterInfo.pos.x, baron.characterInfo.pos.y);
                var input = Console.ReadLine();
 
                if (input == "0")
                {
                    //게임 종료
                    Console.WriteLine("게임을 종료합니다.");
                    switchCode = -1;
                    break;
                }
                else if (input == "1")
                {
                    Console.Write("(x, y)좌표 입력\nx좌표 : ");
                    var x = Console.ReadLine();
                    Console.Write("y좌표 : ");
                    var y = Console.ReadLine();
 
                    float resultX, resultY;
                    if (float.TryParse(x, out resultX) && float.TryParse(y, out resultY))
                    {
                        var movePos = new Vector2(resultX, resultY);
                        annivia.Move(movePos);
                    }
                    else
                    {
                        Console.WriteLine("잘못된 입력입니다.");
                    }
                }
                else if (input == "2")
                {
                    annivia.Attack(baron);
                    if (baron.characterInfo.hp <= 0)
                    {
                        Console.WriteLine("바론이 죽었습니다.10초후에 부활합니다.");
                        for (int i = 10; i > 0; i--)
                        {
                            System.Threading.Thread.Sleep(1000);
                            Console.WriteLine(i);
                        }
                        baron.characterInfo.hp = DataManager.GetInstance().dicCharacterData[0].hp;
                        Console.WriteLine("{0}:크와아아아아아앙({0}이 부활했습니다.) Hp:{1}/{2}", DataManager.GetInstance().dicCharacterData[0].name, baron.characterInfo.hp, DataManager.GetInstance().dicCharacterData[0].hp);
                    }
                }
                else if (input == "3")
                {
                    baron.Attack(annivia);
                    if (annivia.characterInfo.hp <= 0)
                    {
                        Console.WriteLine("애니비아가 죽었습니다.");
                        annivia.characterInfo.alive = false;
                        eggnnivia.characterInfo.alive = true;
                        eggnnivia.characterInfo.pos = annivia.characterInfo.pos;
                        annivia.characterInfo.hp = DataManager.GetInstance().dicCharacterData[1].hp;
                        eggnnivia.characterInfo.hp = DataManager.GetInstance().dicCharacterData[2].hp;
 
                        Console.WriteLine("에그니비아 : 아 정글차이");
                        switchCode = 1;
                        break;
                    }
                }
                else if(input == "4")
                {
                    var data = DataManager.GetInstance().dicCharacterData[0];
                    Console.WriteLine("=============================================================================================");
                    Console.WriteLine("{0}의 정보", DataManager.GetInstance().dicCharacterData[0].name);
                    Console.WriteLine("위치 : ({0}, {1}), 체력 : ({2}/{3})\n공격력 : {4}, 사거리 : {5}, 이동속도 : {6}", baron.characterInfo.pos.x, baron.characterInfo.pos.y, baron.characterInfo.hp, data.hp, data.damage, data.range, data.speed);
                    data = DataManager.GetInstance().dicCharacterData[1];
                    Console.WriteLine("=============================================================================================");
                    Console.WriteLine("{0}의 정보", DataManager.GetInstance().dicCharacterData[1].name);
                    Console.WriteLine("위치 : ({0}, {1}), 체력 : ({2}/{3})\n공격력 : {4}, 사거리 : {5}, 이동속도 : {6}", annivia.characterInfo.pos.x, annivia.characterInfo.pos.y, annivia.characterInfo.hp, data.hp, data.damage, data.range, data.speed);
                }
                else
                {
                    Console.WriteLine("잘못된 입력입니다.");
                }
            }
        }
 
        private void EggnniviaGameStart()
        {
            while (true)//에그니비아버전
            {
                Console.WriteLine();
                Console.WriteLine("=============================================================================================");
                Console.Write("[바론의 위치({0}, {1})]\n1.애그니비아(이동)/2.애그니비아(공격)/3.바론(공격)/4.애니비아(즉시부활)/5.정보 보기/0.종료 후 저장(숫자 입력):", baron.characterInfo.pos.x, baron.characterInfo.pos.y);
                var input = Console.ReadLine();
 
                if (input == "0")
                {
                    //게임 종료
                    Console.WriteLine("게임을 종료합니다.");
                    switchCode = -1;
                    break;
                }
                else if (input == "1")
                {
                    Console.WriteLine("{0}은(는) 이동할 수 없습니다.", DataManager.GetInstance().dicCharacterData[2].name);
                }
                else if (input == "2")
                {
                    Console.WriteLine("{0}은(는) 공격할 수 없습니다.", DataManager.GetInstance().dicCharacterData[2].name);
                }
                else if (input == "3")
                {
                    baron.Attack(eggnnivia);
                    if (eggnnivia.characterInfo.hp <= 0)
                    {
                        Console.WriteLine("에그니비아가 죽었습니다.");
                        eggnnivia.characterInfo.alive = false;
                        annivia.characterInfo.alive = true;
                        annivia.characterInfo.pos = new Vector2(0, 0);
 
                        Console.WriteLine("10초후에 본진(0, 0)에서 부활합니다.");
                        for (int i = 10; i > 0; i--)
                        {
                            System.Threading.Thread.Sleep(1000);
                            Console.WriteLine(i);
                        }
                        Console.WriteLine("{0} : 자, 날아볼까요?", DataManager.GetInstance().dicCharacterData[1].name);
                        annivia.characterInfo.hp = DataManager.GetInstance().dicCharacterData[1].hp;
 
                        switchCode = 0;
                        break;
                    }
                }
                else if (input == "4")
                {
                    Console.WriteLine("애니비아가 즉시 부활합니다.");
                    eggnnivia.characterInfo.alive = false;
                    annivia.characterInfo.alive = true;
 
                    Console.WriteLine("{0} : 내 날개를 타고.", DataManager.GetInstance().dicCharacterData[1].name);
                    annivia.characterInfo.hp = eggnnivia.characterInfo.hp;
 
                    switchCode = 0;
                    break;
                }
                else if (input == "5")
                {
                    var data = DataManager.GetInstance().dicCharacterData[0];
                    Console.WriteLine("=============================================================================================");
                    Console.WriteLine("{0}의 정보", DataManager.GetInstance().dicCharacterData[0].name);
                    Console.WriteLine("위치 : ({0}, {1}), 체력 : ({2}/{3})\n공격력 : {4}, 사거리 : {5}, 이동속도 : {6}", baron.characterInfo.pos.x, baron.characterInfo.pos.y, baron.characterInfo.hp, data.hp, data.damage, data.range, data.speed);
                    data = DataManager.GetInstance().dicCharacterData[2];
                    Console.WriteLine("=============================================================================================");
                    Console.WriteLine("{0}의 정보", DataManager.GetInstance().dicCharacterData[2].name);
                    Console.WriteLine("위치 : ({0}, {1}), 체력 : ({2}/{3})\n공격력 : {4}, 사거리 : {5}, 이동속도 : {6}", eggnnivia.characterInfo.pos.x, eggnnivia.characterInfo.pos.y, eggnnivia.characterInfo.hp, data.hp, data.damage, data.range, data.speed);
                }
                else
                {
                    Console.WriteLine("잘못된 입력입니다.");
                }
            }
        }
    }
}
 
cs


1
2
3
4
5
6
7
8
9
10
11
12
13
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace TestBattle
{
    public class Monster : Character
    {
    }
}
 
cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace TestBattle
{
    public interface IMoveAble
    {
        void Move(Vector2 movePos);
    }
}
 
cs


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


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace TestBattle
{
    public class UserInfo
    {
        public GameInfo gameInfo;
        public bool NewbieCheck;
 
        public UserInfo()
        {
            this.gameInfo = new GameInfo();
        }
    }
}
 
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
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace TestBattle
{
    public class Vector2
    {
        public float x, y;
 
        public Vector2(float x, float y)
        {
            this.x = x;
            this.y = y;
        }
 
        public static Vector2 operator +(Vector2 v1, Vector2 v2)
        {
            return new Vector2(v1.x + v2.x, v1.y + v2.y);
        }
 
        public static Vector2 operator -(Vector2 v1, Vector2 v2)
        {
            return new Vector2(v1.x - v2.x, v1.y - v2.y);
        }
 
        public static Vector2 operator *(Vector2 v1, float Value)
        {
            return new Vector2(v1.x * Value, v1.y * Value);
        }
 
        public static Vector2 operator /(Vector2 v1, float Value)
        {
            return new Vector2(v1.x / Value, v1.y / Value);
        }
 
        public float Dot(Vector2 v1, Vector2 v2)//스칼라 곱
        {
            return v1.x * v2.x + v1.y * v2.y;
        }
 
        public float GetDistance(Vector2 v1, Vector2 v2)
        {
            return (float)(Math.Sqrt(Math.Pow(v1.x - v2.x, 2) + Math.Pow(v1.y - v2.y, 2)));
        }
 
        public Vector2 Normalize()
        {
            var dis = (float)Math.Sqrt(Math.Pow(this.x, 2) + Math.Pow(this.y, 2));
 
            return new Vector2(this.x / dis, this.y / dis);
        }
    }
}
 
cs


저작자표시

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

<Overload, Override>, .json없이 .dat으로  (0) 2019.04.10
<lol바론과 애니비아의 사투>미완성(에러에러에러)  (0) 2019.04.09
<인벤토리> 저장, 불러오기 기능  (0) 2019.04.08
<IEnumerable과 IEnumerator> 내일 다시 확인하여 예제 준비할 것  (0) 2019.04.01
<인벤토리 1차>중첩방식 목록보기  (0) 2019.03.31
:

<Overload, Override>, .json없이 .dat으로

C#/과제 2019. 4. 10. 01:41
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace _20190409
{
    public class Annivia : Champion
    {
        public Annivia()
        {
            this.speed = 3;
        }
    }
}
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
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace _20190409
{
    public class App
    {
        GameLauncher gameLauncher;
 
        public App()
        {
            this.gameLauncher = new GameLauncher();
        }
 
        public void Start()
        {
            Console.WriteLine("앱 실행");
            this.gameLauncher.Start();
        }
    }
}
cs

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.Text;
using System.Threading.Tasks;
 
namespace _20190409
{
    public class BaronNashor : Monster
    {
        public BaronNashor()
        {
            this.speed = 0;
        }
 
        public override void Move(Vector2 movePos)
        {
            Console.WriteLine("바론은 움직일 수 없습니다.");
        }
    }
}
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.IO;
using System.Linq;
using System.Runtime.Serialization.Formatters.Binary;
using System.Text;
using System.Threading.Tasks;
 
namespace _20190409
{
    public class BinaryManager
    {
        public BinaryManager()
        {
 
        }
 
        public void SerializeObject<T>(T obj, string path)
        {
            object saveInfo = obj;
 
            BinaryFormatter formatter = new BinaryFormatter();
            Stream str = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.None);
            formatter.Serialize(str, saveInfo);
            str.Close();
        }
 
        public T DeSerializeObject<T>(string path)
        {
            var info = File.ReadAllText(path);
            BinaryFormatter formatter = new BinaryFormatter();
            Stream str = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read);
            T obj = (T)formatter.Deserialize(str);
            str.Close();
            return obj;
        }
 
        public T DeSerializeDatas<T>(string path)
        {
            var info = File.ReadAllText(path);
            BinaryFormatter formatter = new BinaryFormatter();
            Stream str = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read);
            var obj = formatter.Deserialize(str);
            str.Close();
            var temp = (T)obj;
            return temp;
        }
 
        //제이슨 파일만 있고, dat파일 없을때 Json으로 dat파일 만들기(Json필요함)
        #region
        /*public void JsonToDat<T>(Dictionary<int, T> data, string path) where T : CharacterData
        {
            object saveData = data;
            BinaryFormatter formatter = new BinaryFormatter();
            Stream str = new FileStream(path, FileMode.Create, FileAccess.Write, FileShare.None);
            formatter.Serialize(str, saveData);
            str.Close();
        }*/
        #endregion
    }
}
 
cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace _20190409
{
    public class Champion : Character
    {
    }
}
 
 
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
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace _20190409
{
    public class Character
    {
        public CharacterInfo characterInfo;
        public int speed;
 
        public Character()
        {
 
        }
 
        public Character(CharacterInfo characterInfo)
        {
            this.characterInfo = characterInfo;
        }
 
        public virtual void Move(Vector2 movePos)
        {
            var data = DataManager.GetInstance().dicCharacterData[this.characterInfo.id];
 
            float dis = this.characterInfo.pos.GetDistance(this.characterInfo.pos, movePos);
            while (true)
            {
                if (dis > 0)
                {
                    System.Threading.Thread.Sleep(500);
                    var dir = (movePos - this.characterInfo.pos).Normalize();
                    this.characterInfo.pos += dir * speed;
 
                    Console.WriteLine("{0}이(가) ({1:0.00},{2:0.00})로 이동합니다.", data.name, this.characterInfo.pos.x, this.characterInfo.pos.y);
                    dis -= speed;
                }
                else
                {
                    this.characterInfo.pos = movePos;
                    Console.WriteLine("{0}이(가) ({1:0.00},{2:0.00})에 도착했습니다.", data.name, this.characterInfo.pos.x, this.characterInfo.pos.y);
                    break;
                }
            }
        }
 
        public virtual void Attack(Character target)
        {
            var data = DataManager.GetInstance().dicCharacterData[this.characterInfo.id];
            var targetData = DataManager.GetInstance().dicCharacterData[target.characterInfo.id];
 
            //사거리 안에있으면 때림, 사거리 안에 없으면 이동함
            float dis = this.characterInfo.pos.GetDistance(this.characterInfo.pos, target.characterInfo.pos);
            while (true)
            {
                System.Threading.Thread.Sleep(500);
                if (dis > data.range)
                {
                    var dir = (target.characterInfo.pos - this.characterInfo.pos).Normalize();
                    this.characterInfo.pos += dir * speed;
                    //움직임
                    Console.WriteLine("{0}이(가) ({1:0.00},{2:0.00})로 이동합니다.", data.name, this.characterInfo.pos.x, this.characterInfo.pos.y);
 
                    dis -= this.speed;
                }
                else
                {
                    //멈춰서 때림
                    Console.WriteLine("{0}이(가) {1}을(를) 공격합니다.", data.name, targetData.name);
                    //때리면 데미지 들어감
                    target.TakeDamage(data.damage);
                    break;
                }
            }
        }
 
        public virtual void TakeDamage(int damage)
        {
            var data = DataManager.GetInstance().dicCharacterData[this.characterInfo.id];
            this.characterInfo.hp -= damage;
            Console.WriteLine("{0}이(가) {1}의 피해를 입었습니다.\n남은체력:({2}/{3})", data.name, damage, this.characterInfo.hp, data.hp);
        }
    }
}
cs


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace _20190409
{
    [Serializable]
    public class CharacterData
    {
        public int id;
        public int type;
        public string name;
        public int hp;
        public int damage;
        public float range;
    }
}
cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace _20190409
{
    [Serializable]
    public class CharacterInfo
    {
        public int id;
        public int hp;
        public Vector2 pos;
    }
}
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
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;
 
namespace _20190409
{
    public class DataManager
    {
        private static DataManager Instance;
        public Dictionary<int, CharacterData> dicCharacterData= new Dictionary<int, CharacterData>();
 
        private DataManager()
        {
            this.dicCharacterData = new Dictionary<int, CharacterData>();
        }
 
        public static DataManager GetInstance()
        {
            if (DataManager.Instance == null)
            {
                DataManager.Instance = new DataManager();
            }
            return DataManager.Instance;
        }
 
        public void LoadData(string path)
        {
            if (File.Exists(path))
            {
                var temp = new BinaryManager();
                var characterDatas = temp.DeSerializeDatas<Dictionary<int, CharacterData>>(path);
                this.dicCharacterData = characterDatas;
            }
            else
            {
                Console.WriteLine("파일 불러오기 실패, dat파일과 json파일이 없습니다.");
            }
 
            //제이슨 파일만 있고, dat파일 없을때 Json으로 dat파일 만들기(Json필요함)
            #region
            /*if (File.Exists("./data/character_data.json"))
            {
                Console.WriteLine("dat파일이 없습니다. json파일이 있으면 변환합니다.");
                var json = File.ReadAllText("./data/character_data.json");
                var characterDatas = JsonConvert.DeserializeObject<CharacterData[]>(json);
                foreach (var data in characterDatas)
                {
                    this.dicCharacterData.Add(data.id, data);
                }
                new BinaryManager().JsonToDat<CharacterData>(this.dicCharacterData, path);
            }*/
            #endregion
        }
    }
}
cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace _20190409
{
    [Serializable]
    public class GameInfo
    {
        //캐릭터 인포(List)
        public List<CharacterInfo> characterInfos;
 
        public GameInfo()
        {
            this.characterInfos = new List<CharacterInfo>();
        }
    }
}
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
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.IO;
 
using System.Runtime.Serialization.Formatters.Binary;
using System.Collections;
 
namespace _20190409
{
    public class GameLauncher
    {
        private UserInfo userInfo;
        private Dictionary<int, CharacterData> dicCharacterData = DataManager.GetInstance().dicCharacterData;
        private List<Character> characters;
 
        public GameLauncher()
        {
            this.characters = new List<Character>();
        }
 
        public void Start()
        {
            Console.WriteLine("게임 런쳐 실행");
            this.ReadyToStart();
        }
 
        private void ReadyToStart()
        {
            //게임 시작 준비
            Console.WriteLine("게임 시작을 준비중입니다.");
            //데이터 로드(data)
            DataManager.GetInstance().LoadData("./data/character_data.dat");
            //신구 유저 확인(info)
            this.ExistUserInfo("./info");
            //게임 시작
            this.StartGame();
        }
 
        private void StartGame()
        {
            Console.WriteLine("게임이 시작됐습니다.");
            //캐릭터 생성(신규 유저, 기존 유저 구분)
            BaronNashor baron = null;
            Annivia annivia = null;
 
            if (this.userInfo.NewbieCheck == false)
            {
                //기존 유저
                baron = (BaronNashor)this.CreateCharacter<BaronNashor>(this.userInfo.gameInfo.characterInfos[0]);
                annivia = (Annivia)this.CreateCharacter<Annivia>(this.userInfo.gameInfo.characterInfos[1]);
            }
            else
            {
                //신규유저
                baron = this.CreateCharacter<BaronNashor>(0);
                annivia = this.CreateCharacter<Annivia>(1);
 
                baron.characterInfo.pos = new Vector2(10, 10);
                annivia.characterInfo.pos = new Vector2(1, 1);
            }
            this.characters.Add(baron);
            baron.characterInfo.pos = new Vector2(20, 20);
            this.characters.Add(annivia);
 
            //게임 진행
            //움직이고
            annivia.Move(new Vector2(10, 10));
            //움직여서 때리고
            annivia.Attack(baron);
            //원래 자리로 도망
            annivia.Move(new Vector2(1, 1));
            //세이브//종료
            this.SaveUserInfo();
        }
 
        private void ExistUserInfo(string path)
        {
            if (Directory.Exists(path))
            {
                //기존 유저
                Console.WriteLine("기존 유저입니다.");
                //캐릭터 인포 불러오기
                //this.userInfo = this.LoadUserInfo("./info/user_info.json");
                this.userInfo = this.LoadUserInfo("./info/user_info.dat");
                this.userInfo.NewbieCheck = false;
            }
            else
            {
                //신규 유저
                Console.WriteLine("신규 유저입니다.");
                //./info폴더 만들기
                Directory.CreateDirectory(path);
                //캐릭터 인포만들기
                this.CreateUserInfo();
                this.userInfo.NewbieCheck = true;
            }
        }
 
        private UserInfo LoadUserInfo(string path)
        {
            //./info/user_info.dat불러오기
            return new BinaryManager().DeSerializeObject<UserInfo>("./info/user_info.dat");
        }
 
        //신규 유저, 유저인포 만들기
        private void CreateUserInfo(UserInfo userInfo = null)
        {
            if (this.userInfo == null)
            {
                if (userInfo == null)
                {
                    this.userInfo = new UserInfo();
                }
                else
                {
                    this.userInfo = userInfo;
                }
            }
        }
 
        //기존 유저, 인포 불러와서, 캐릭터 생성하기
        private T CreateCharacter<T>(CharacterInfo characterInfo) where T : Character, new()
        {
            T character = new T();
            character.characterInfo = characterInfo;
            return character;
        }
 
        //신규유저, 인포 생성해서, 캐릭터 생성하기
        private T CreateCharacter<T>(int id) where T : Character, new()
        {
            var data = DataManager.GetInstance().dicCharacterData[id];
            var info = new CharacterInfo();
 
            info.id = data.id;
            info.hp = data.hp;
            info.pos = new Vector2(1, 1);
 
            T character = new T();
            character.characterInfo = info;
            return character;
        }
 
        private void SaveUserInfo()//dat
        {
            //현재의 유저인포(게임인포(캐릭터인포List)))를 유저인포에 저장
            this.SyncUserInfo();
 
            var info = this.userInfo;
            new BinaryManager().SerializeObject<UserInfo>(info,"./info/user_info.dat");
 
            Console.WriteLine("저장완료");
        }
 
        private void SyncUserInfo()
        {
            var characterInfos = new List<CharacterInfo>();
            foreach (var character in this.characters)
            {
                characterInfos.Add(character.characterInfo);
            }
            this.userInfo.gameInfo.characterInfos = characterInfos;
        }
    }
}
cs



1
2
3
4
5
6
7
8
9
10
11
12
13
14
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace _20190409
{
    public class Monster : Character
    {
    }
}
 
 
cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace _20190409
{
    class Program
    {
        static void Main(string[] args)
        {
            App app = new App();
 
            app.Start();
 
            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
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace _20190409
{
    [Serializable]
    public class UserInfo
    {
        //게임인포, 뉴비체크
        public GameInfo gameInfo;
        public bool NewbieCheck;//기존유저일때 false, 신규유저일때 true
 
        public UserInfo()
        {
            this.gameInfo = new GameInfo();
        }
    }
}
 
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
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
 
namespace _20190409
{
    [Serializable]
    public class Vector2
    {
        public float x, y;
 
        public Vector2(float x, float y)
        {
            this.x = x;
            this.y = y;
        }
 
        public static Vector2 operator +(Vector2 v1, Vector2 v2)
        {
            return new Vector2(v1.x + v2.x, v1.y + v2.y);
        }
 
        public static Vector2 operator -(Vector2 v1, Vector2 v2)
        {
            return new Vector2(v1.x - v2.x, v1.y - v2.y);
        }
 
        public static Vector2 operator *(Vector2 v1, float Value)
        {
            return new Vector2(v1.x * Value, v1.y * Value);
        }
 
        public static Vector2 operator /(Vector2 v1, float Value)
        {
            return new Vector2(v1.x / Value, v1.y / Value);
        }
 
        public float Dot(Vector2 v1, Vector2 v2)//스칼라 곱
        {
            return v1.x * v2.x + v1.y * v2.y;
        }
 
        public float GetDistance(Vector2 v1, Vector2 v2)
        {
            return (float)(Math.Sqrt(Math.Pow(v1.x - v2.x, 2) + Math.Pow(v1.y - v2.y, 2)));
        }
 
        public Vector2 Normalize()
        {
            var dis = (float)Math.Sqrt(Math.Pow(this.x, 2) + Math.Pow(this.y, 2));
 
            return new Vector2(this.x / dis, this.y / dis);
        }
    }
}
cs


찾아보기
.txt -> .dat컨버터 사이트 찾아보기


BinaryFormatter 
[Serializable]

저작자표시

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

<바론과 애니비아 쌈박질>  (0) 2019.04.11
<lol바론과 애니비아의 사투>미완성(에러에러에러)  (0) 2019.04.09
<인벤토리> 저장, 불러오기 기능  (0) 2019.04.08
<IEnumerable과 IEnumerator> 내일 다시 확인하여 예제 준비할 것  (0) 2019.04.01
<인벤토리 1차>중첩방식 목록보기  (0) 2019.03.31
:
◀ PREV : [1] : [2] : [3] : [4] : [5] : NEXT ▶

티스토리툴바