'분류 전체보기' 카테고리의 글 목록 (3 Page)

분류 전체보기 +66

Loading..[프로토타입] 일정시간 지나면 적 생성 기지로 자동으로 공격해오기
2019.06.17

뷰어로 보기
Loading..프로토타입 건물생성 하면 주변 캐릭터가 찾아오기
2019.06.14

뷰어로 보기
Loading..TestGPGS 개인정보 처리방침
2019.06.13

뷰어로 보기
Loading..[프로토타입] 건물생성 시 주변가까운 캐릭터 데려오기
2019.06.12

뷰어로 보기
Loading..[프로토타입]캐릭터 이동 및 빌딩생성
2019.06.09

뷰어로 보기

[프로토타입] 일정시간 지나면 적 생성 기지로 자동으로 공격해오기

카테고리 없음2019. 6. 17. 04:25

뷰어
댓글로
이전글
다음글

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
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using UnityEngine.UI;
 
public class TestMonster : MonoBehaviour
{
    public int colCount, rowCount;
    public int fenceX, fenceY;
 
    public Vector2[] blockPos;
    public Vector2[] characterPos;
 
    public Vector2[] villagesPos;
 
    public Vector2[] fencesPos;
 
    public Button testBtn;
    public Button testBtn2;
 
    public GameObject testBuildingBtn;
 
 
    public Text txtTimer;
    private float timer = 5f;
 
    private int tileWidth = 64;
    private int tileHeight = 32;
    private int col = 0; //행
    private int row = 0; //열
 
    private GameObject village;
    private GameObject monster;
    private GameObject fence;
 
    private GameObject mapTile;
    private GameObject motherNode;
    private Coroutine routine;
 
    private Dictionary<Vector2, GameObject> dicFIndTile = new Dictionary<Vector2, GameObject>();
 
    private List<GameObject> openList = new List<GameObject>();
    private List<GameObject> characterList = new List<GameObject>();
    private List<GameObject> closeList = new List<GameObject>();
    private List<GameObject> fenceList = new List<GameObject>();
 
    private GameObject targetNode;
    private GameObject selectedTile;
 
    private void Start()
    {
        this.CreateCharacter();
        this.CreateMap();
        
        InvokeRepeating("Timer", 0, 1);
 
        this.testBtn.onClick.AddListener(() =>
        {
            //this.FindNode();
 
            //Debug.Log(this.motherNode.GetComponent<TestTile>().vec2);
 
            if (this.FindeTargetNode())
            {
                this.monster.GetComponent<Animator>().Play("run");
                this.FIndNextPos();
            }
        });
 
        this.testBtn2.onClick.AddListener(() => {
            this.FindNode();
        });
    }
 
    void Timer()
    {
        this.txtTimer.text = string.Format("{0}", this.timer);
        this.timer--;
 
        if (this.timer < 0)
        {
            //this.timer = 5;
            this.timer = 10;
            this.CreateMonster();
            
            if (this.FindeTargetNode())
            {
                this.monster.GetComponent<Animator>().Play("run");
                this.FIndNextPos();
            }
            //this.FindNode();
            //this.FindeTargetNode();
        }
    }
 
    private bool FindeTargetNode()
    {
        if (targetNode != null)
        {
            while (true)
            {
                if (targetNode.GetComponent<TestTile>().vec2 == motherNode.GetComponent<TestTile>().vec2)
                {
                    Debug.Log("찾음");
                    return true;
                }
                this.FindNode();
            }
        }
        else
        {
            Debug.Log("어디로 가");
            return false;
        }
    }
 
    //TODO 수정해야 할 부분
    private void CreateMonster()
    {
        this.monster = Instantiate(Resources.Load<GameObject>("Prefabs/monster"));
 
        var data = new Vector2(10, 10);
 
        var data2 = this.dicFIndTile[data];
 
        this.monster.AddComponent<TestCharacter>();
        this.monster.GetComponent<TestCharacter>().vec2 = data2.GetComponent<TestTile>().vec2;
 
        monster.transform.position = data2.transform.position;
 
        this.motherNode = data2;
 
        this.targetNode = this.village;
    }
 
    private void FIndNextPos()
    {
        if (this.routine != null)
        {
            StopCoroutine(this.routine);
        }
        this.routine = StartCoroutine(this.FindNextPosImpl());
    }
 
    private IEnumerator FindNextPosImpl()
    {
        this.monster.GetComponent<Animator>().Play("run");
 
        for (int i = 0; i < this.closeList.Count; i++)
        {
            this.monster.GetComponent<TestCharacter>().vec2 = this.closeList[i].GetComponent<TestTile>().vec2;
 
            //this.CharacterMovePoint(this.closeList[i]);
 
            while (true)
            {
                var dir = (this.closeList[i].transform.position - this.monster.transform.position).normalized;
 
                var nextNode = Vector2.Distance(this.monster.transform.position, this.closeList[i].transform.position);
 
                this.monster.transform.position += dir * 2f * Time.deltaTime;
 
                if (nextNode <= 0.03f)
                {
                    //Debug.Log("다음");
                    break;
                }
 
                yield return null;
            }
 
            if (i + 1 < this.closeList.Count)
            {
                if (this.closeList[i + 1].GetComponent<TestTile>().isFence == true || this.closeList[i + 1].GetComponent<TestTile>().isBuilding == true)
                {
                    this.closeList[i + 1].GetComponent<TestTile>().isFence = false;
                    
                    foreach(var data in this.fenceList)
                    {
                        if (this.closeList[i + 1].GetComponent<TestTile>().vec2 == data.GetComponent<TestTile>().vec2)
                        {
                            data.gameObject.SetActive(false);
                        }
                    }
                    
                    Debug.Log("방어막");
                    this.monster.GetComponent<Animator>().Play("attack");
 
                    break;
                }
            }
 
            var distance = Vector2.Distance(this.monster.transform.position, this.targetNode.transform.position);
 
            //Debug.Log(distance);
            if (distance <= 0.04f)
            {
                this.monster.GetComponent<TestCharacter>().vec2 = this.targetNode.GetComponent<TestTile>().vec2;
 
                Debug.Log("도착");
                this.monster.gameObject.SetActive(false);
                this.ClearMap();
 
                this.monster = null;
                break;
            }
        }
 
        yield return new WaitForSeconds(0.6f);
 
        this.monster.GetComponent<Animator>().Play("idle");
 
        this.ClearMap();
        
        if (this.FindeTargetNode())
        {
            this.monster.GetComponent<Animator>().Play("run");
            this.FIndNextPos();
        }
    }
 
    #region 타일초기화
    private void ClearMap()
    {
        Debug.Log("타일초기화");
 
        this.openList.Clear();
        this.closeList.Clear();
        //this.targetNode = null;
        this.selectedTile = null;
        //this.motherNode = null;
 
        var data2 = this.dicFIndTile[this.monster.GetComponent<TestCharacter>().vec2];
 
        this.motherNode = data2;
 
        for (int i = 0; i < colCount; i++)
        {
            for (int j = 0; j < rowCount; j++)
            {
                var tiles = new Vector2(j, i);
 
                var tile = dicFIndTile[tiles];
 
                if (!tile.GetComponent<TestTile>().isBlock || !tile.GetComponent<TestTile>().isBuilding || !tile.GetComponent<TestTile>().isFence)
                {
                    tile.GetComponent<TestTile>().isBlock = false;
 
                    this.SetActiveFGH(tile);
 
                    //tile.GetComponent<SpriteRenderer>().color = Color.white;
                }
 
 
                //Debug.LogFormat("{0}{1}", tile.GetComponent<TestTile>().isBlock, tile.GetComponent<TestTile>().vec2);
            }
        }
    }
    #endregion
 
    //길찾기
    #region 길찾기
    private void FindNode()
    {
        var mother = this.motherNode.GetComponent<TestTile>().vec2;
        var motherX = mother.x - 1;
        var motherY = mother.y - 1;
        var maxX = mother.x + 1;
        var maxY = mother.y + 1;
 
        if (motherX < 0)
        {
            motherX = 0;
        }
        if (motherY < 0)
        {
            motherY = 0;
        }
 
        for (int x = (int)motherX; x <= maxX; x++)
        {
            for (int y = (int)motherY; y <= maxY; y++)
            {
                if (x < this.colCount && y < this.rowCount)
                {
                    var data = new Vector2(x, y);
 
                    var tile = this.dicFIndTile[data];
                    if (tile.GetComponent<TestTile>().isBlock != true && !this.closeList.Contains(tile))
                    {
                        if (data.x == motherX && data.y == mother.y || data.y == mother.y)
                        {
                            this.openList.Add(tile);
                            this.SetFGH(tile);
                        }
                        if (data.y == motherY && data.x == mother.x || data.x == mother.x)
                        {
                            this.openList.Add(tile);
                            this.SetFGH(tile);
                        }
 
                        this.openList.Remove(motherNode);
                        this.closeList.Add(motherNode);
 
                        if (!this.closeList.Contains(tile))
                        {
                            //tile.GetComponent<SpriteRenderer>().color = Color.grey;
                            this.SetActiveFGH(tile);
 
                        }
                    }
                }
            }
        }
 
        //foreach (var datas in openList)
        //{
        //    datas.GetComponent<SpriteRenderer>().color = Color.grey;
        //}
 
        this.NextNode();
    }
 
    private void NextNode()
    {
        //this.motherNode.GetComponent<SpriteRenderer>().color = Color.blue;
 
        if (this.targetNode.GetComponent<TestTile>().vec2 != this.motherNode.GetComponent<TestTile>().vec2)
        {
            IEnumerable<GameObject> sortNode = this.openList.OrderBy(x => x.GetComponent<TestTile>().f);
 
            this.selectedTile = sortNode.FirstOrDefault<GameObject>();
            this.motherNode = this.selectedTile;
        }
        else
        {
            Debug.Log("찾았다");
        }
    }
    #endregion
 
    private void SetFGH(GameObject tile)
    {
        var tileScript = tile.GetComponent<TestTile>();
 
        var getG = tile.GetComponent<TestTile>().g;
        var getH = tile.GetComponent<TestTile>().h;
        getG = Mathf.Round(Vector2.Distance(tile.GetComponent<TestTile>().vec2, this.monster.GetComponent<TestCharacter>().vec2) * 10);
        var dx = Mathf.Abs(tile.GetComponent<TestTile>().vec2.x - this.targetNode.GetComponent<TestTile>().vec2.x);
        var dy = Mathf.Abs(tile.GetComponent<TestTile>().vec2.y - this.targetNode.GetComponent<TestTile>().vec2.y);
 
        getH = (dx + dy) * 10;
 
        tile.GetComponent<TestTile>().f = getG + getH;
 
        tileScript.G.text = getG.ToString();
        tileScript.H.text = getH.ToString();
        tileScript.F.text = tile.GetComponent<TestTile>().f.ToString();
    }
 
    #region FGH 활성화 비활성화
    private void SetActiveFGH(GameObject tile)
    {
        if (!this.openList.Contains(tile))
        {
            tile.GetComponent<TestTile>().G.gameObject.SetActive(false);
            tile.GetComponent<TestTile>().F.gameObject.SetActive(false);
            tile.GetComponent<TestTile>().H.gameObject.SetActive(false);
        }
        else
        {
            tile.GetComponent<TestTile>().G.gameObject.SetActive(true);
            tile.GetComponent<TestTile>().F.gameObject.SetActive(true);
            tile.GetComponent<TestTile>().H.gameObject.SetActive(true);
        }
    }
    #endregion
 
    #region 맵, 타일, 캐릭터 생성
    //캐릭터 생성입력
    private void CreateCharacter()
    {
        var character = Instantiate(Resources.Load<GameObject>("Prefabs/hero"));
        var character1 = Instantiate(Resources.Load<GameObject>("Prefabs/hero"));
        var character2 = Instantiate(Resources.Load<GameObject>("Prefabs/hero"));
 
        this.CreatedCharacter(character, this.characterPos[0].x, this.characterPos[0].y);
        this.CreatedCharacter(character1, this.characterPos[1].x, this.characterPos[1].y);
        this.CreatedCharacter(character2, this.characterPos[2].x, this.characterPos[2].y);
    }
 
    //캐릭터생성
    private void CreatedCharacter(GameObject character, float x, float y)
    {
        var vec2 = new Vector2(x, y);
 
        character.AddComponent<TestCharacter>();
        character.GetComponent<TestCharacter>().vec2 = vec2;
 
        this.characterList.Add(character);
 
        var screen = this.MapToScreen(vec2);
 
        var screenPos = Camera.main.ScreenToWorldPoint(new Vector2(screen.x, screen.y));
 
        character.transform.position = new Vector3(screenPos.x, screenPos.y, 0);
    }
 
    //맵생성입력
    private void CreateMap()
    {
        this.village = Instantiate(Resources.Load<GameObject>("Prefabs/128x128building"));
        this.CreatedMap(village, this.colCount / 2, this.rowCount / 2);
        village.GetComponent<TestTile>().isBuilding = true;
 
        while (true)
        {
            this.mapTile = Instantiate(Resources.Load<GameObject>("Prefabs/tile"));
 
            this.mapTile.tag = "Tile";
 
            this.mapTile.transform.SetParent(this.transform);
 
            this.CreatedMap(this.mapTile, this.col, this.row);
 
            this.dicFIndTile.Add(new Vector2(col, row), mapTile);
            this.col++;
 
            for (int i = 0; i < this.fencesPos.Length; i++)
            {
                this.fence = Instantiate(Resources.Load<GameObject>("Prefabs/fence"));
                this.fenceList.Add(fence);
                this.CreatedMap(fence, this.fencesPos[i].x, this.fencesPos[i].y);
            }
 
            if (this.col >= this.colCount)
            {
                this.col = 0;
                this.row++;
            }
 
            if (this.row >= this.rowCount)
            {
                row = 0;
                this.WorldToCenterCamera();
                break;
            }
        }
    }
 
    //맵생성
    private void CreatedMap(GameObject tileMap, float x, float y)
    {
        var vec2 = new Vector2(x, y);
 
        tileMap.AddComponent<TestTile>();
        tileMap.GetComponent<TestTile>().vec2 = vec2;
 
        if (tileMap.GetComponentInChildren<TextMesh>())
        {
            tileMap.GetComponentInChildren<TextMesh>().text = string.Format("({0},{1})", x, y);
            this.SetActiveFGH(tileMap);
        }
 
        for (int a = 0; a < this.blockPos.Length; a++)
        {
            if (vec2 == this.blockPos[a])
            {
                tileMap.name = "block";
                tileMap.GetComponent<SpriteRenderer>().color = Color.red;
                tileMap.GetComponent<TestTile>().isBlock = true;
            }
        }
 
        for (int b = 0; b < this.fencesPos.Length; b++)
        {
            if (vec2 == this.fencesPos[b])
            {
                tileMap.name = "fence";
                tileMap.GetComponent<SpriteRenderer>().color = Color.yellow;
                tileMap.GetComponent<TestTile>().isFence = true;
            }
        }
 
        var screen = this.MapToScreen(vec2);
 
        var screenPos = Camera.main.ScreenToWorldPoint(new Vector2(screen.x, screen.y));
 
        tileMap.transform.position = new Vector3(screenPos.x, screenPos.y, 0);
    }
 
    //맵포지를 스크린포지로
    public Vector2 MapToScreen(Vector2 mapPos)
    {
        var screenX = mapPos.x * this.tileWidth - (mapPos.y * this.tileWidth);
        var screenY = mapPos.y * -tileHeight - (mapPos.x * tileHeight);
 
        return new Vector2(screenX, screenY);
    }
 
    //카메라를 타일의 센터로
    private void WorldToCenterCamera()
    {
        var pos = new Vector2(this.colCount / 2 - 1, this.rowCount / 2 - 1);
 
        var posX = this.dicFIndTile[pos].transform.position.x;
        var posY = this.dicFIndTile[pos].transform.position.y;
 
        Camera.main.transform.localPosition = new Vector3(posX, posY, -100);
        Camera.main.orthographicSize = this.rowCount / 2;
    }
    #endregion
}
 
Colored by Color Scripter
cs

저작자표시

프로토타입 건물생성 하면 주변 캐릭터가 찾아오기

Project/TODO2019. 6. 14. 01:23

뷰어
댓글로
이전글
다음글

프로토타입..언제 마무리하지...unitypackage

오늘 한 작업

길찾기 보완 (타겟과 가장 가까운 캐릭터 vec2값 넣어주기)

건물 짓는 곳 제한

캐릭터 이동모션 ( idle을 안하는거 보완...해야함)

앞으로 해야 할 작업

1. 캐릭터 랜덤타일 찾아서 움직이기

2. 길찾기 조금더 보완하기

3. 건물 클릭하면 UI창 뜨기

코드 정리랑.. 아직 구현 못한것들 해야하는데...

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
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using UnityEngine.UI;
 
public class TestProtoType : MonoBehaviour
{
    public int colCount, rowCount;
    public Vector2[] blockPos;
    public Vector2[] characterPos;
 
    public GameObject uiPopup;
 
    public Button buildingBtn;
    public Button chracterMoveBtn;
    public Button testBtn;
 
    private int tileWidth = 64;
    private int tileHeight = 32;
    private int col = 0; //행
    private int row = 0; //열
 
    private Coroutine routine;
    private GameObject mapTile;
    private GameObject motherNode;
    private GameObject targetNode;
    private GameObject selectedTile;
    private GameObject selectedBuilding;
    private GameObject nearCharacter;
 
    //private TestUIPopup uiPopup;
 
    private Dictionary<Vector2, GameObject> dicFIndTile = new Dictionary<Vector2, GameObject>();
 
    private List<GameObject> openList = new List<GameObject>();
    private List<GameObject> closeList = new List<GameObject>();
    private List<GameObject> characterList = new List<GameObject>();
    private List<GameObject> randomMoveList = new List<GameObject>();
 
    private void Start()
    {
        this.CreateCharacter();
        this.CreateMap();
        this.TileCheck();
        this.buildingBtn.onClick.AddListener(() =>
        {
            this.uiPopup.GetComponent<TestUIPopup>().CreateUI();
        });
 
        this.chracterMoveBtn.onClick.AddListener(() =>
        {
            //this.FindNode();
            this.FindeTargetNode();
        });
 
        this.testBtn.onClick.AddListener(() =>
        {
            this.FIndNextPos();
        });
    }
 
 
    private void FindeTargetNode()
    {
        if (targetNode != null)
        {
            while (true)
            {
                if (targetNode == motherNode)
                {
                    Debug.Log("찾음");
                    break;
                }
 
                this.FindNode();
            }
        }
        else
        {
            Debug.Log("어디로 가");
        }
    }
 
    private void FIndNextPos()
    {
        if (this.routine != null)
        {
            StopCoroutine(this.routine);
        }
        this.routine = StartCoroutine(this.FindNextPosImpl());
    }
 
    private IEnumerator FindNextPosImpl()
    {
        for (int i = 1; i < this.closeList.Count; i++)
        {
            this.nearCharacter.GetComponent<TestCharacter>().vec2 = this.closeList[i - 1].GetComponent<TestTile>().vec2;
 
            this.CharacterMovePoint(this.closeList[i]);
 
            while (true)
            {
                var dir = (this.closeList[i].transform.position - this.nearCharacter.transform.position).normalized;
 
                var nextNode = Vector2.Distance(this.nearCharacter.transform.position, this.closeList[i].transform.position);
 
                this.nearCharacter.transform.position += dir * 2f * Time.deltaTime;
 
                //Debug.Log(nextNode);
 
 
                if (nextNode <= 0.03f)
                {
                    //Debug.Log("다음");
                    break;
                }
                yield return null;
            }
 
            var distance = Vector2.Distance(this.nearCharacter.transform.position, this.targetNode.transform.position);
 
            //Debug.Log(distance);
            if (distance <= 0.04f)
            {
                this.nearCharacter.GetComponent<TestCharacter>().vec2 = this.targetNode.GetComponent<TestTile>().vec2;
 
                Debug.Log("도착");
                this.nearCharacter.gameObject.SetActive(false);
                this.ClearMap();
                yield return new WaitForSeconds(4);
 
                this.nearCharacter.gameObject.SetActive(true);
                this.nearCharacter.GetComponent<Animator>().Play("hero_idle2");
 
                this.nearCharacter = null;
                break;
            }
        }
    }
 
    private void CharacterMovePoint(GameObject tile)
    {
        var mother = tile.GetComponent<TestTile>().vec2;
        var data = this.nearCharacter.GetComponent<TestCharacter>().vec2;
        var motherX = mother.x - 1;
        var motherY = mother.y - 1;
        var maxX = mother.x + 1;
        var maxY = mother.y + 1;
 
        if (data.x == motherX && data.y == mother.y)
        {
            //Debug.Log("오아");
            this.nearCharacter.GetComponent<Animator>().Play("hero_rightdown");
        }
        if (data.x == mother.x && data.y == maxY)
        {
            //Debug.Log("오위");
            this.nearCharacter.GetComponent<Animator>().Play("hero_rightup");
        }
        if (data.x == maxX && data.y == mother.y)
        {
            //Debug.Log("왼위");
            this.nearCharacter.GetComponent<Animator>().Play("hero_leftup");
        }
        if (data.x == mother.x && data.y == motherY)
        {
            //Debug.Log("왼아");
            this.nearCharacter.GetComponent<Animator>().Play("hero_leftdown");
        }
    }
 
    private void FindNode()
    {
        var mother = this.motherNode.GetComponent<TestTile>().vec2;
        var motherX = mother.x - 1;
        var motherY = mother.y - 1;
        var maxX = mother.x + 1;
        var maxY = mother.y + 1;
 
        if (motherX < 0)
        {
            motherX = 0;
        }
        if (motherY < 0)
        {
            motherY = 0;
        }
 
        for (int x = (int)motherX; x <= maxX; x++)
        {
            for (int y = (int)motherY; y <= maxY; y++)
            {
                if (x < this.colCount && y < this.rowCount)
                {
                    var data = new Vector2(x, y);
 
                    var tile = this.dicFIndTile[data];
                    if (tile.GetComponent<TestTile>().isBlock != true && !this.closeList.Contains(tile))
                    {
                        if (data.x == motherX && data.y == mother.y || data.y == mother.y)
                        {
                            this.openList.Add(tile);
                            this.SetFGH(tile);
                        }
                        if (data.y == motherY && data.x == mother.x || data.x == mother.x)
                        {
                            this.openList.Add(tile);
                            this.SetFGH(tile);
                        }
 
                        this.openList.Remove(motherNode);
                        this.closeList.Add(motherNode);
 
                        if (!this.closeList.Contains(tile))
                        {
                            tile.GetComponent<SpriteRenderer>().color = Color.grey;
                            this.SetActiveFGH(tile);
 
                        }
                    }
                }
            }
        }
 
        foreach (var datas in openList)
        {
            datas.GetComponent<SpriteRenderer>().color = Color.grey;
        }
 
        this.NextNode();
        this.closeList.Add(motherNode);
    }
 
    private void SetFGH(GameObject tile)
    {
        var tileScript = tile.GetComponent<TestTile>();
 
        var getG = tile.GetComponent<TestTile>().g;
        var getH = tile.GetComponent<TestTile>().h;
        getG = Mathf.Round(Vector2.Distance(tile.GetComponent<TestTile>().vec2, this.motherNode.GetComponent<TestTile>().vec2) * 10);
        var dx = Mathf.Abs(tile.GetComponent<TestTile>().vec2.x - this.targetNode.GetComponent<TestTile>().vec2.x);
        var dy = Mathf.Abs(tile.GetComponent<TestTile>().vec2.y - this.targetNode.GetComponent<TestTile>().vec2.y);
 
        getH = (dx + dy) * 10;
 
        tile.GetComponent<TestTile>().f = getG + getH;
 
        tileScript.G.text = getG.ToString();
        tileScript.H.text = getH.ToString();
        tileScript.F.text = tile.GetComponent<TestTile>().f.ToString();
    }
 
    private void NextNode()
    {
        this.motherNode.GetComponent<SpriteRenderer>().color = Color.blue;
 
        if (this.targetNode != this.motherNode)
        {
            IEnumerable<GameObject> sortNode = this.openList.OrderBy(x => x.GetComponent<TestTile>().f);
 
            this.selectedTile = sortNode.FirstOrDefault<GameObject>();
 
            this.motherNode = this.selectedTile;
        }
        else
        {
            Debug.Log("찾았다");
        }
    }
 
    #region 타일초기화
    private void ClearMap()
    {
        Debug.Log("타일초기화");
 
        this.openList.Clear();
        this.closeList.Clear();
        this.targetNode = null;
        this.selectedTile = null;
        //this.nearCharacter = null;
        this.motherNode = null;
 
        for (int i = 0; i < colCount; i++)
        {
            for (int j = 0; j < rowCount; j++)
            {
                var tiles = new Vector2(j, i);
 
                var tile = dicFIndTile[tiles];
 
                if (!tile.GetComponent<TestTile>().isBlock)
                {
                    tile.GetComponent<TestTile>().isBlock = false;
 
                    this.SetActiveFGH(tile);
 
                    tile.GetComponent<SpriteRenderer>().color = Color.white;
                }
                //Debug.LogFormat("{0}{1}", tile.GetComponent<TestTile>().isBlock, tile.GetComponent<TestTile>().vec2);
            }
        }
    }
    #endregion
 
    void TileCheck()
    {
        if (this.routine != null)
        {
            StopCoroutine(this.routine);
        }
        this.routine = StartCoroutine(this.TileCheckImpl());
    }
 
    IEnumerator TileCheckImpl()
    {
        while (true)
        {
            if (Input.GetMouseButtonDown(0))
            {
                Vector2 worldPos = Camera.main.ScreenToWorldPoint(Input.mousePosition);
 
                RaycastHit2D hit = Physics2D.Raycast(worldPos, Vector2.zero);
 
                if (hit.collider != null && hit.collider.GetComponent<TestTile>().isBuilding)
                {
                    Debug.Log("??");
 
                    //hit.collider.gameObject.GetComponentInChildren<Button>().onClick.AddListener(() =>
                    //{
                    //    //var buildingPopupMenu = Instantiate(Resources.Load("Prefabs/BuildingPopup") as GameObject);
                    //});
                }
            }
            yield return null;
        }
    }
    
    #region 마우스 클릭 시 빌딩생성
    public void CreateBuilding()
    {
        if (routine != null)
        {
            StopCoroutine(this.routine);
        }
        this.routine = StartCoroutine(this.CreatebuildingImpl());
    }
 
    private IEnumerator CreatebuildingImpl()
    {
        var building = Instantiate(Resources.Load<GameObject>("Prefabs/isoTile"));
 
        while (true)
        {
            Vector2 ray = Camera.main.ScreenToWorldPoint(Input.mousePosition);
            RaycastHit2D hit = Physics2D.Raycast(ray, Vector2.zero);
            building.transform.position = ray;
 
            if (Input.GetMouseButtonDown(0))
            {
                if (hit.collider == null || hit.collider.GetComponent<TestTile>().isBlock || hit.collider.GetComponent<TestTile>().isBuilding == true)
                {
                    Debug.Log("응 안돼~");
                }
                else
                {
                    this.selectedBuilding = hit.collider.gameObject;
                    this.targetNode = hit.collider.gameObject;
 
                    hit.collider.gameObject.GetComponent<TestTile>().isBuilding = true;
 
                    this.FindNearCharacterNode();
 
                    building.transform.position = hit.collider.gameObject.transform.position;
 
                    break;
                }
            }
            yield return null;
        }
    }
    #endregion
 
    #region 주변캐릭터 탐색
    private void FindNearCharacterNode()
    {
        foreach (var characters in this.characterList)
        {
            var character = characters.GetComponent<TestCharacter>().vec2;
 
            //Debug.Log(character);
 
            var characterX = character.x - 1;
            var characterY = character.y - 1;
            var maxX = character.x + 1;
            var maxY = character.y + 1;
 
            if (characterX < 0)
            {
                characterX = 0;
            }
            if (characterY < 0)
            {
                characterY = 0;
            }
 
            for (int x = (int)characterX; x <= maxX; x++)
            {
                for (int y = (int)characterY; y <= maxY; y++)
                {
                    if (x < this.colCount && y < this.rowCount)
                    {
                        var data = new Vector2(x, y);
 
                        var nearNode = this.dicFIndTile[data];
 
                        var getG = characters.GetComponent<TestCharacter>().g;
                        var getH = characters.GetComponent<TestCharacter>().h;
 
                        //다음 타일까지의 이동비용
                        getG = Mathf.Round(Vector2.Distance(characters.GetComponent<TestCharacter>().vec2, nearNode.GetComponent<TestTile>().vec2) * 10);
 
                        //최종목적지점까지의 예상이동비용
                        var dx = Mathf.Abs(characters.GetComponent<TestCharacter>().vec2.x - this.selectedBuilding.GetComponent<TestTile>().vec2.x);
                        var dy = Mathf.Abs(characters.GetComponent<TestCharacter>().vec2.y - this.selectedBuilding.GetComponent<TestTile>().vec2.y);
                        getH = (dx + dy) * 10;
 
                        characters.GetComponent<TestCharacter>().f = getG + getH;
                    }
                }
            }
        }
 
        //F값이 제일 적은 캐릭터
        var sortCharacterF = this.characterList.OrderBy(x => x.GetComponent<TestCharacter>().f);
        this.nearCharacter = sortCharacterF.FirstOrDefault<GameObject>();
 
        //캐릭터의 키값으로 타일 찾고 마더로
        this.motherNode = this.dicFIndTile[nearCharacter.GetComponent<TestCharacter>().vec2];
    }
    #endregion
 
    #region FGH 활성화 비활성화
    private void SetActiveFGH(GameObject tile)
    {
        if (!this.openList.Contains(tile))
        {
            tile.GetComponent<TestTile>().G.gameObject.SetActive(false);
            tile.GetComponent<TestTile>().F.gameObject.SetActive(false);
            tile.GetComponent<TestTile>().H.gameObject.SetActive(false);
        }
        else
        {
            tile.GetComponent<TestTile>().G.gameObject.SetActive(true);
            tile.GetComponent<TestTile>().F.gameObject.SetActive(true);
            tile.GetComponent<TestTile>().H.gameObject.SetActive(true);
        }
    }
    #endregion
 
    #region 맵, 타일, 캐릭터 생성
    //캐릭터 생성입력
    private void CreateCharacter()
    {
        var character = Instantiate(Resources.Load<GameObject>("Prefabs/hero"));
        var character1 = Instantiate(Resources.Load<GameObject>("Prefabs/hero"));
        var character2 = Instantiate(Resources.Load<GameObject>("Prefabs/hero"));
 
        this.CreatedCharacter(character, this.characterPos[0].x, this.characterPos[0].y);
        this.CreatedCharacter(character1, this.characterPos[1].x, this.characterPos[1].y);
        this.CreatedCharacter(character2, this.characterPos[2].x, this.characterPos[2].y);
    }
 
    //맵생성입력
    private void CreateMap()
    {
        while (true)
        {
            this.mapTile = Instantiate(Resources.Load<GameObject>("Prefabs/tile"));
 
            this.mapTile.tag = "Tile";
 
            this.mapTile.transform.SetParent(this.transform);
 
            this.CreatedMap(this.mapTile, this.col, row);
            this.dicFIndTile.Add(new Vector2(col, row), mapTile);
            this.col++;
 
            if (this.col >= this.colCount)
            {
                this.col = 0;
                this.row++;
            }
 
            if (this.row >= this.rowCount)
            {
                row = 0;
                this.WorldToCenterCamera();
                break;
            }
        }
    }
 
    //캐릭터생성
    private void CreatedCharacter(GameObject character, float x, float y)
    {
        var vec2 = new Vector2(x, y);
 
        character.AddComponent<TestCharacter>();
        character.GetComponent<TestCharacter>().vec2 = vec2;
 
        this.characterList.Add(character);
 
        var screen = this.MapToScreen(vec2);
 
        var screenPos = Camera.main.ScreenToWorldPoint(new Vector2(screen.x, screen.y));
 
        character.transform.position = new Vector3(screenPos.x, screenPos.y, 0);
    }
 
    //맵생성
    private void CreatedMap(GameObject tileMap, float x, float y)
    {
        var vec2 = new Vector2(x, y);
 
        tileMap.AddComponent<TestTile>();
        tileMap.GetComponent<TestTile>().vec2 = vec2;
 
        if (tileMap.GetComponentInChildren<TextMesh>())
        {
            tileMap.GetComponentInChildren<TextMesh>().text = string.Format("({0},{1})", x, y);
            this.SetActiveFGH(tileMap);
        }
 
        foreach (var chracter in this.characterList)
        {
            if (chracter.GetComponent<TestCharacter>().vec2 == tileMap.GetComponent<TestTile>().vec2)
            {
                this.motherNode = tileMap;
            }
        }
 
        for (int a = 0; a < this.blockPos.Length; a++)
        {
            if (vec2 == this.blockPos[a])
            {
                tileMap.name = "block";
                tileMap.GetComponent<SpriteRenderer>().color = Color.red;
                tileMap.GetComponent<TestTile>().isBlock = true;
            }
        }
 
        var screen = this.MapToScreen(vec2);
 
        var screenPos = Camera.main.ScreenToWorldPoint(new Vector2(screen.x, screen.y));
 
        tileMap.transform.position = new Vector3(screenPos.x, screenPos.y, 0);
    }
 
    //맵포지를 스크린포지로
    public Vector2 MapToScreen(Vector2 mapPos)
    {
        var screenX = mapPos.x * this.tileWidth - (mapPos.y * this.tileWidth);
        var screenY = mapPos.y * -tileHeight - (mapPos.x * tileHeight);
 
        return new Vector2(screenX, screenY);
    }
 
    //카메라를 타일의 센터로
    private void WorldToCenterCamera()
    {
        var pos = new Vector2(this.colCount / 2 - 1, this.rowCount / 2 - 1);
 
        var posX = this.dicFIndTile[pos].transform.position.x;
        var posY = this.dicFIndTile[pos].transform.position.y;
 
        Camera.main.transform.localPosition = new Vector3(posX, posY, -100);
        Camera.main.orthographicSize = this.rowCount / 2;
    }
 
    #endregion
}
Colored by Color Scripter
cs

저작자표시

'Project > TODO' 카테고리의 다른 글

[프로토타입]0626타일클릭 후 몬스터그룹 이동시키기,건물파괴 (0)	2019.06.26
[프로토타입] 건물생성 시 주변가까운 캐릭터 데려오기 (0)	2019.06.12
[프로토타입]캐릭터 이동 및 빌딩생성 (0)	2019.06.09
[프로토타입3단계] 캐릭터로 이동시키기 (0)	2019.06.08
[프로토타입]딕셔너리 키 오류 해결 (0)	2019.06.07

TestGPGS 개인정보 처리방침

Unity/수업내용2019. 6. 13. 12:08

뷰어
댓글로
이전글
다음글

C:\Users\user\Downloads\TestGPGS+개인정보+처리.html

TestGPGS+개인정보+처리.html

<시나브로>('https://yangjae.tistory.com/'이하 '시나브로')은(는) 개인정보보호법에 따라 이용자의 개인정보 보호 및 권익을 보호하고 개인정보와 관련한 이용자의 고충을 원활하게 처리할 수 있도록 다음과 같은 처리방침을 두고 있습니다.

<시나브로>('시나브로') 은(는) 회사는 개인정보처리방침을 개정하는 경우 웹사이트 공지사항(또는 개별공지)을 통하여 공지할 것입니다.

○ 본 방침은부터 2019년 6월 13일부터 시행됩니다.

1. 개인정보의 처리 목적 <시나브로>('https://yangjae.tistory.com/'이하 '시나브로')은(는) 개인정보를 다음의 목적을 위해 처리합니다. 처리한 개인정보는 다음의 목적이외의 용도로는 사용되지 않으며 이용 목적이 변경될 시에는 사전동의를 구할 예정입니다.

가. 홈페이지 회원가입 및 관리

만14세 미만 아동 개인정보 수집 시 법정대리인 동의 여부 확인 등을 목적으로 개인정보를 처리합니다.

나. 재화 또는 서비스 제공

콘텐츠 제공, 본인인증 등을 목적으로 개인정보를 처리합니다.

2. 개인정보 파일 현황
('https://yangjae.tistory.com/'이하 '시나브로')가 개인정보 보호법 제32조에 따라 등록․공개하는 개인정보파일의 처리목적은 다음과 같습니다.

1. 개인정보 파일명 : TestGPGS 개인정보 처리방침
- 개인정보 항목 : 로그인ID, 성별, 생년월일
- 수집방법 : Google Api
- 보유근거 : 게임내에 유저정보 표시
- 보유기간 : 10년
- 관련법령 : 신용정보의 수집/처리 및 이용 등에 관한 기록 : 3년, 계약 또는 청약철회 등에 관한 기록 : 5년

※ 기타('https://yangjae.tistory.com/'이하 '시나브로')의 개인정보파일 등록사항 공개는 행정안전부 개인정보보호 종합지원 포털(www.privacy.go.kr) → 개인정보민원 → 개인정보열람등 요구 → 개인정보파일 목록검색 메뉴를 활용해주시기 바랍니다.

3. 개인정보의 처리 및 보유 기간

① <시나브로>('시나브로')은(는) 법령에 따른 개인정보 보유·이용기간 또는 정보주체로부터 개인정보를 수집시에 동의 받은 개인정보 보유,이용기간 내에서 개인정보를 처리,보유합니다.

② 각각의 개인정보 처리 및 보유 기간은 다음과 같습니다.

1.<제화 또는 서비스 제공>
<제화 또는 서비스 제공>와 관련한 개인정보는 수집.이용에 관한 동의일로부터<10년>까지 위 이용목적을 위하여 보유.이용됩니다.
-보유근거 : 게임내에 재화 구매
-관련법령 : 1)신용정보의 수집/처리 및 이용 등에 관한 기록 : 3년
2) 계약 또는 청약철회 등에 관한 기록 : 5년

-예외사유 :

4. 개인정보의 제3자 제공에 관한 사항

① <시나브로>('https://yangjae.tistory.com/'이하 '시나브로')은(는) 정보주체의 동의, 법률의 특별한 규정 등 개인정보 보호법 제17조 및 제18조에 해당하는 경우에만 개인정보를 제3자에게 제공합니다.

② <시나브로>('https://yangjae.tistory.com/')은(는) 다음과 같이 개인정보를 제3자에게 제공하고 있습니다.

1. <시나브로>
- 개인정보를 제공받는 자 : 시나브로
- 제공받는 자의 개인정보 이용목적 : 로그인ID, 서비스 이용 기록, 접속 로그, 결제기록
- 제공받는 자의 보유.이용기간: 10년

5. 개인정보처리 위탁

① <시나브로>('시나브로')은(는) 원활한 개인정보 업무처리를 위하여 다음과 같이 개인정보 처리업무를 위탁하고 있습니다.

1. <>
- 위탁받는 자 (수탁자) :
- 위탁하는 업무의 내용 :
- 위탁기간 :

② <시나브로>('https://yangjae.tistory.com/'이하 '시나브로')은(는) 위탁계약 체결시 개인정보 보호법 제25조에 따라 위탁업무 수행목적 외 개인정보 처리금지, 기술적․관리적 보호조치, 재위탁 제한, 수탁자에 대한 관리․감독, 손해배상 등 책임에 관한 사항을 계약서 등 문서에 명시하고, 수탁자가 개인정보를 안전하게 처리하는지를 감독하고 있습니다.

③ 위탁업무의 내용이나 수탁자가 변경될 경우에는 지체없이 본 개인정보 처리방침을 통하여 공개하도록 하겠습니다.

6. 정보주체와 법정대리인의 권리·의무 및 그 행사방법 이용자는 개인정보주체로써 다음과 같은 권리를 행사할 수 있습니다.

① 정보주체는 시나브로에 대해 언제든지 개인정보 열람,정정,삭제,처리정지 요구 등의 권리를 행사할 수 있습니다.
② 제1항에 따른 권리 행사는시나브로에 대해 개인정보 보호법 시행령 제41조제1항에 따라 서면, 전자우편, 모사전송(FAX) 등을 통하여 하실 수 있으며 시나브로은(는) 이에 대해 지체 없이 조치하겠습니다.
③ 제1항에 따른 권리 행사는 정보주체의 법정대리인이나 위임을 받은 자 등 대리인을 통하여 하실 수 있습니다. 이 경우 개인정보 보호법 시행규칙 별지 제11호 서식에 따른 위임장을 제출하셔야 합니다.
④ 개인정보 열람 및 처리정지 요구는 개인정보보호법 제35조 제5항, 제37조 제2항에 의하여 정보주체의 권리가 제한 될 수 있습니다.
⑤ 개인정보의 정정 및 삭제 요구는 다른 법령에서 그 개인정보가 수집 대상으로 명시되어 있는 경우에는 그 삭제를 요구할 수 없습니다.
⑥ 시나브로은(는) 정보주체 권리에 따른 열람의 요구, 정정·삭제의 요구, 처리정지의 요구 시 열람 등 요구를 한 자가 본인이거나 정당한 대리인인지를 확인합니다.

7. 처리하는 개인정보의 항목 작성

① <시나브로>('https://yangjae.tistory.com/'이하 '시나브로')은(는) 다음의 개인정보 항목을 처리하고 있습니다.

8. 개인정보의 파기<시나브로>('시나브로')은(는) 원칙적으로 개인정보 처리목적이 달성된 경우에는 지체없이 해당 개인정보를 파기합니다. 파기의 절차, 기한 및 방법은 다음과 같습니다.

-파기절차
이용자가 입력한 정보는 목적 달성 후 별도의 DB에 옮겨져(종이의 경우 별도의 서류) 내부 방침 및 기타 관련 법령에 따라 일정기간 저장된 후 혹은 즉시 파기됩니다. 이 때, DB로 옮겨진 개인정보는 법률에 의한 경우가 아니고서는 다른 목적으로 이용되지 않습니다.

-파기기한
이용자의 개인정보는 개인정보의 보유기간이 경과된 경우에는 보유기간의 종료일로부터 5일 이내에, 개인정보의 처리 목적 달성, 해당 서비스의 폐지, 사업의 종료 등 그 개인정보가 불필요하게 되었을 때에는 개인정보의 처리가 불필요한 것으로 인정되는 날로부터 5일 이내에 그 개인정보를 파기합니다.

9. 개인정보 자동 수집 장치의 설치•운영 및 거부에 관한 사항

시나브로 은 정보주체의 이용정보를 저장하고 수시로 불러오는 ‘쿠키’를 사용하지 않습니다.

10. 개인정보 보호책임자 작성

① 시나브로(‘https://yangjae.tistory.com/’이하 ‘시나브로) 은(는) 개인정보 처리에 관한 업무를 총괄해서 책임지고, 개인정보 처리와 관련한 정보주체의 불만처리 및 피해구제 등을 위하여 아래와 같이 개인정보 보호책임자를 지정하고 있습니다.

▶ 개인정보 보호책임자
성명 :양재준
직책 :대표
직급 :대표
연락처 :01034778267, wapffhs@naver.com,
※ 개인정보 보호 담당부서로 연결됩니다.

▶ 개인정보 보호 담당부서
부서명 :
담당자 :
연락처 :, ,
② 정보주체께서는 시나브로(‘https://yangjae.tistory.com/’이하 ‘시나브로) 의 서비스(또는 사업)을 이용하시면서 발생한 모든 개인정보 보호 관련 문의, 불만처리, 피해구제 등에 관한 사항을 개인정보 보호책임자 및 담당부서로 문의하실 수 있습니다. 시나브로(‘https://yangjae.tistory.com/’이하 ‘시나브로) 은(는) 정보주체의 문의에 대해 지체 없이 답변 및 처리해드릴 것입니다.

11. 개인정보 처리방침 변경

①이 개인정보처리방침은 시행일로부터 적용되며, 법령 및 방침에 따른 변경내용의 추가, 삭제 및 정정이 있는 경우에는 변경사항의 시행 7일 전부터 공지사항을 통하여 고지할 것입니다.

12. 개인정보의 안전성 확보 조치 <시나브로>('시나브로')은(는) 개인정보보호법 제29조에 따라 다음과 같이 안전성 확보에 필요한 기술적/관리적 및 물리적 조치를 하고 있습니다.

1. 개인정보의 암호화
이용자의 개인정보는 비밀번호는 암호화 되어 저장 및 관리되고 있어, 본인만이 알 수 있으며 중요한 데이터는 파일 및 전송 데이터를 암호화 하거나 파일 잠금 기능을 사용하는 등의 별도 보안기능을 사용하고 있습니다.

저작자표시

'Unity > 수업내용' 카테고리의 다른 글

isometric (0)	2019.05.12
[Unity자습서] 점프 및 보석 획득 (0)	2019.05.12
[Unity자습서] Background이동 (0)	2019.05.07
[Unity자습서] Space Shoot 해부 (WASD키로 이동),(화면밖으로 못나가게 하기) (0)	2019.05.02
[Unity자습서] Space Shoot 해부 (배경) (0)	2019.05.02

[프로토타입] 건물생성 시 주변가까운 캐릭터 데려오기

Project/TODO2019. 6. 12. 02:10

뷰어
댓글로
이전글
다음글

TestNearCharacter.unitypackage

추가할 것 : 이동방향 바라보기, 이미 건물로 갔던 캐릭터의 경로 재설정

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
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using UnityEngine.UI;
 
public class TestCreatedBuilding : MonoBehaviour
{
    public int colCount, rowCount;
    public Vector2[] chracterPos;
    public Button buildingBtn;
    public Button chracterMoveBtn;
 
    private int tileWidth = 64;
    private int tileHeight = 32;
    private int col = 0; //행
    private int row = 0; //열
 
    private Coroutine routine;
 
    private GameObject mapTile;
    private GameObject motherNode;
    private GameObject targetNode;
    private GameObject selectedTile;
    private GameObject selectedBuilding;
    private GameObject nearCharacter;
 
    private Dictionary<Vector2, GameObject> dicFIndTile = new Dictionary<Vector2, GameObject>();
 
    private List<GameObject> openList = new List<GameObject>();
    private List<GameObject> closeList = new List<GameObject>();
    private List<GameObject> characterList = new List<GameObject>();
    private List<GameObject> buildingList = new List<GameObject>();
 
    private void Start()
    {
        this.CreateCharacter();
        this.CreateMap();
 
        this.buildingBtn.onClick.AddListener(() =>
        {
            Createbuilding();
           
        });
 
        this.chracterMoveBtn.onClick.AddListener(() => {
 
            this.FIndNextPos();
        });
    }
 
    private void FIndNextPos()
    {
        if (this.routine != null)
        {
            StopCoroutine(this.routine);
        }
        this.routine = StartCoroutine(this.FindNextPosImpl());
    }
 
    private IEnumerator FindNextPosImpl()
    {
        while (true)
        {
            var dir = (this.motherNode.transform.position - this.nearCharacter.transform.position).normalized;
            var nextNode = Vector2.Distance(this.nearCharacter.transform.position, this.motherNode.transform.position);
            var distance = Vector2.Distance(this.nearCharacter.transform.position, this.targetNode.transform.position);
            
            this.nearCharacter.transform.position += dir * 2f * Time.deltaTime;
            
            if (nextNode <= 0.05f)
            {
                if (distance <= 0.02f)
                {
                    Debug.Log("도착");
                    this.ClearMap();
                    break;
                }
 
                this.FindNode();
                Debug.Log("다음");
            }
            yield return null;
        }
    }
    
    private void FindNode()
    {
        var nearCharacterPos = this.motherNode.GetComponent<TestTile>().vec2;
        var nearCharacterX = nearCharacterPos.x - 1;
        var nearCharacterY = nearCharacterPos.y - 1;
        var maxX = nearCharacterPos.x + 1;
        var maxY = nearCharacterPos.y + 1;
 
        if (nearCharacterX < 0)
        {
            nearCharacterX = 0;
        }
        if (nearCharacterY < 0)
        {
            nearCharacterY = 0;
        }
 
        for (int x = (int)nearCharacterX; x <= maxX; x++)
        {
            for (int y = (int)nearCharacterY; y <= maxY; y++)
            {
                if (x < this.colCount && y < this.rowCount)
                {
                    var data = new Vector2(x, y);
 
                    var tile = this.dicFIndTile[data];
 
                    if (!this.closeList.Contains(tile))
                    {
                        if (data.x == nearCharacterX && data.y == nearCharacterPos.y || data.y == nearCharacterPos.y)
                        {
                            this.openList.Add(tile);
                        }
                        if (data.y == nearCharacterY && data.x == nearCharacterPos.x || data.x == nearCharacterPos.x)
                        {
                            this.openList.Add(tile);
                        }
 
                        this.openList.Remove(motherNode);
                        
                        this.SetFGH();
                    }
                }
            }
        }
        
 
        foreach (var datas in openList)
        {
            datas.GetComponent<SpriteRenderer>().color = Color.grey;
        }
        this.closeList.Add(motherNode);
        this.NextNode();
    }
 
    private void SetFGH()
    {
        foreach (var tile in this.openList)
        {
            var tileScript = tile.GetComponent<TestTile>();
 
            var getG = tile.GetComponent<TestTile>().g;
            var getH = tile.GetComponent<TestTile>().h;
            getG = Mathf.Round(Vector2.Distance(tile.GetComponent<TestTile>().vec2, this.motherNode.GetComponent<TestTile>().vec2) * 10);
            var dx = Mathf.Abs(tile.GetComponent<TestTile>().vec2.x - this.targetNode.GetComponent<TestTile>().vec2.x);
            var dy = Mathf.Abs(tile.GetComponent<TestTile>().vec2.y - this.targetNode.GetComponent<TestTile>().vec2.y);
 
            getH = (dx + dy) * 10;
 
            tile.GetComponent<TestTile>().f = getG + getH;
 
            tileScript.G.text = getG.ToString();
            tileScript.H.text = getH.ToString();
            tileScript.F.text = tile.GetComponent<TestTile>().f.ToString();
        }
    }
 
    private void NextNode()
    {
        this.motherNode.GetComponent<SpriteRenderer>().color = Color.blue;
 
        if (this.targetNode != this.motherNode)
        {
            IEnumerable<GameObject> sortNode = this.openList.OrderBy(x => x.GetComponent<TestTile>().f);
            this.selectedTile = sortNode.FirstOrDefault<GameObject>();
 
            this.motherNode = this.selectedTile;
        }
    }
 
    private void ClearMap()
    {
        Debug.Log("타일초기화");
 
        for (int i = 0; i < colCount; i++)
        {
            for (int j = 0; j < rowCount; j++)
            {
                var tiles = new Vector2(j, i);
 
                var tile = dicFIndTile[tiles];
 
                tile.GetComponent<SpriteRenderer>().color = Color.white;
            }
        }
 
        this.openList.Clear();
        this.closeList.Clear();
        this.targetNode = null;
        this.selectedTile = null;
    }
 
    #region 마우스 클릭 시 빌딩생성
    public void Createbuilding()
    {
        if (routine != null)
        {
            StopCoroutine(this.routine);
        }
        this.routine = StartCoroutine(this.CreatebuildingImpl());
    }
 
    private IEnumerator CreatebuildingImpl()
    {
        var building = Instantiate(Resources.Load<GameObject>("Prefabs/isoTile"));
 
        while (true)
        {
            Vector2 ray = Camera.main.ScreenToWorldPoint(Input.mousePosition);
            RaycastHit2D hit = Physics2D.Raycast(ray, Vector2.zero);
            building.transform.position = ray;
 
            if (Input.GetMouseButtonDown(0))
            {
                if (hit.collider != null)
                {
                    this.selectedBuilding = hit.collider.gameObject;
                    this.targetNode = hit.collider.gameObject;
 
                    hit.collider.gameObject.GetComponent<TestTile>().isBlock = true;
 
                    this.FindNearCharacterNode();
 
                    building.transform.position = hit.collider.gameObject.transform.position;
                    break;
                }
            }
            yield return null;
        }
    }
    #endregion
 
    #region 주변캐릭터 탐색
    private void FindNearCharacterNode()
    {
        foreach (var characters in this.characterList)
        {
            var character = characters.GetComponent<TestCharacter>().vec2;
            var characterX = character.x - 1;
            var characterY = character.y - 1;
            var maxX = character.x + 1;
            var maxY = character.y + 1;
            
            if (characterX < 0)
            {
                characterX = 0;
            }
            if (characterY < 0)
            {
                characterY = 0;
            }
 
            for (int x = (int)characterX; x <= maxX; x++)
            {
                for (int y = (int)characterY; y <= maxY; y++)
                {
                    if (x < this.colCount && y < this.rowCount)
                    {
                        var data = new Vector2(x, y);
 
                        var nearNode = this.dicFIndTile[data];
                        
                        var getG = characters.GetComponent<TestCharacter>().g;
                        var getH = characters.GetComponent<TestCharacter>().h;
 
                        //다음 타일까지의 이동비용
                        getG = Mathf.Round(Vector2.Distance(characters.GetComponent<TestCharacter>().vec2, nearNode.GetComponent<TestTile>().vec2) * 10);
                        
                        //최종목적지점까지의 예상이동비용
                        var dx = Mathf.Abs(characters.GetComponent<TestCharacter>().vec2.x - this.selectedBuilding.GetComponent<TestTile>().vec2.x);
                        var dy = Mathf.Abs(characters.GetComponent<TestCharacter>().vec2.y - this.selectedBuilding.GetComponent<TestTile>().vec2.y);
                        getH = (dx + dy) * 10;
 
                        characters.GetComponent<TestCharacter>().f = getG + getH;
                    }
                }
            }
        }
        
        //F값이 제일 적은 캐릭터
        var sortCharacterF = this.characterList.OrderBy(x => x.GetComponent<TestCharacter>().f);
        this.nearCharacter = sortCharacterF.FirstOrDefault<GameObject>();
 
        //캐릭터의 키값으로 타일 찾고 마더로
        this.motherNode = this.dicFIndTile[nearCharacter.GetComponent<TestCharacter>().vec2];
    }
    #endregion
    
    #region FGH 활성화 비활성화
    private void SetActiveFGH(GameObject tile)
    {
        if (!this.openList.Contains(tile))
        {
            tile.GetComponent<TestTile>().G.gameObject.SetActive(false);
            tile.GetComponent<TestTile>().F.gameObject.SetActive(false);
            tile.GetComponent<TestTile>().H.gameObject.SetActive(false);
        }
        else
        {
            tile.GetComponent<TestTile>().G.gameObject.SetActive(true);
            tile.GetComponent<TestTile>().F.gameObject.SetActive(true);
            tile.GetComponent<TestTile>().H.gameObject.SetActive(true);
        }
    }
    #endregion
 
    #region 맵, 타일, 캐릭터 생성
    //캐릭터 생성입력
    private void CreateCharacter()
    {
        var character = Instantiate(Resources.Load<GameObject>("Prefabs/hero"));
        var character1 = Instantiate(Resources.Load<GameObject>("Prefabs/hero"));
        var character2 = Instantiate(Resources.Load<GameObject>("Prefabs/hero"));
        var character3 = Instantiate(Resources.Load<GameObject>("Prefabs/hero"));
 
        this.CreatedCharacter(character, this.chracterPos[0].x, this.chracterPos[0].y);
        this.CreatedCharacter(character1, this.chracterPos[1].x, this.chracterPos[1].y);
        this.CreatedCharacter(character2, this.chracterPos[2].x, this.chracterPos[2].y);
        this.CreatedCharacter(character3, this.chracterPos[3].x, this.chracterPos[3].y);
    }
 
    //맵생성입력
    private void CreateMap()
    {
        while (true)
        {
            this.mapTile = Instantiate(Resources.Load<GameObject>("Prefabs/tile"));
 
            this.mapTile.tag = "Tile";
 
            this.mapTile.transform.SetParent(this.transform);
 
            this.CreatedMap(this.mapTile, this.col, row);
            this.dicFIndTile.Add(new Vector2(col, row), mapTile);
            this.col++;
 
            if (this.col >= this.colCount)
            {
                this.col = 0;
                this.row++;
            }
 
            if (this.row >= this.rowCount)
            {
                row = 0;
                break;
            }
        }
    }
 
    //캐릭터생성
    private void CreatedCharacter(GameObject character, float x, float y)
    {
        var vec2 = new Vector2(x, y);
 
        character.AddComponent<TestCharacter>();
        character.GetComponent<TestCharacter>().vec2 = vec2;
 
        this.characterList.Add(character);
 
        var screen = this.MapToScreen(vec2);
 
        var screenPos = Camera.main.ScreenToWorldPoint(new Vector2(screen.x + 512, screen.y + 384 + 100));
 
        character.transform.position = new Vector3(screenPos.x, screenPos.y, 0);
    }
 
    //맵생성
    private void CreatedMap(GameObject tileMap, float x, float y)
    {
        var vec2 = new Vector2(x, y);
 
        tileMap.AddComponent<TestTile>();
        tileMap.GetComponent<TestTile>().vec2 = vec2;
 
        if (tileMap.GetComponentInChildren<TextMesh>())
        {
            tileMap.GetComponentInChildren<TextMesh>().text = string.Format("({0},{1})", x, y);
            this.SetActiveFGH(tileMap);
        }
        
        foreach (var chracter in this.characterList)
        {
            if (chracter.GetComponent<TestCharacter>().vec2 == tileMap.GetComponent<TestTile>().vec2)
            {
                this.motherNode = tileMap;
            }
        }
 
        var screen = this.MapToScreen(vec2);
 
        var screenPos = Camera.main.ScreenToWorldPoint(new Vector2(screen.x + 512, screen.y + 384 + 100));
 
        tileMap.transform.position = new Vector3(screenPos.x, screenPos.y, 0);
    }
 
    //맵포지를 스크린포지로
    public Vector2 MapToScreen(Vector2 mapPos)
    {
        var screenX = mapPos.x * this.tileWidth - (mapPos.y * this.tileWidth);
        var screenY = mapPos.y * -tileHeight - (mapPos.x * tileHeight);
 
        return new Vector2(screenX, screenY);
    }
    #endregion
}
 
Colored by Color Scripter
cs

저작자표시

'Project > TODO' 카테고리의 다른 글

[프로토타입]0626타일클릭 후 몬스터그룹 이동시키기,건물파괴 (0)	2019.06.26
프로토타입 건물생성 하면 주변 캐릭터가 찾아오기 (0)	2019.06.14
[프로토타입]캐릭터 이동 및 빌딩생성 (0)	2019.06.09
[프로토타입3단계] 캐릭터로 이동시키기 (0)	2019.06.08
[프로토타입]딕셔너리 키 오류 해결 (0)	2019.06.07

[프로토타입]캐릭터 이동 및 빌딩생성

Project/TODO2019. 6. 9. 21:25

뷰어
댓글로
이전글
다음글

프로토타입.unitypackage

빌딩 생성 후 갈 수 없게 완성

보완할 점 : 특정 구간에서 길 찾는 게 어색함 , 타일 위에 이미 빌딩이 있다면 건설 못하게 해야 함

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
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using System.Linq;
 
public class TestIsometric_4 : MonoBehaviour
{
    public Button moveBtn;
    public Button buildingBtn;
    public int colCount, rowCount;
    public Vector2 startPos;
 
    private GameObject mapTile;
    private Coroutine routine;
    private int tileWidth = 64;
    private int tileHeight = 32;
    private int col = 0; //행
    private int row = 0; //열
 
    private GameObject character;
    private GameObject building;
    private GameObject motherNode;
    private GameObject targetNode;
    private GameObject selectedTile;
 
    private Dictionary<Vector2, GameObject> dicFIndTile = new Dictionary<Vector2, GameObject>();
    private List<GameObject> closeList = new List<GameObject>();
    private List<GameObject> movePositionList = new List<GameObject>();
    
    void Start()
    {
        this.CreateCharacter();
        this.CreateMap();
        this.TileCheck();
 
        this.moveBtn.onClick.AddListener(() =>
        {
            this.FIndNextPos();
        });
        this.buildingBtn.onClick.AddListener(() =>
        {
            this.Createbuilding();
        });
    }
 
    void TileCheck()
    {
        if (this.routine != null)
        {
            StopCoroutine(this.routine);
        }
        this.routine = StartCoroutine(this.TileCheckImpl());
    }
 
    IEnumerator TileCheckImpl()
    {
        while (true)
        {
            if (Input.GetMouseButtonDown(0))
            {
                Vector2 worldPos = Camera.main.ScreenToWorldPoint(Input.mousePosition);
 
                RaycastHit2D hit = Physics2D.Raycast(worldPos, Vector2.zero);
 
                if (hit.collider != null && !hit.collider.GetComponent<TestTile>().isBlock)
                {
                    this.ClearMap();
                    this.targetNode = hit.collider.gameObject;
                    hit.collider.GetComponent<SpriteRenderer>().color = Color.cyan;
                }
            }
            yield return null;
        }
    }
    public void Createbuilding()
    {
        if (routine != null)
        {
            StopCoroutine(this.routine);
        }
        this.routine = StartCoroutine(this.CreatebuildingImpl());
    }
 
    private IEnumerator CreatebuildingImpl()
    {
        var building = Instantiate(Resources.Load<GameObject>("Prefabs/isoTile"));
 
        while (true)
        {
            Vector2 ray = Camera.main.ScreenToWorldPoint(Input.mousePosition);
            RaycastHit2D hit = Physics2D.Raycast(ray, Vector2.zero);
            building.transform.position = ray;
 
            if (Input.GetMouseButtonDown(0))
            {
                if (hit.collider != null)
                {
                    hit.collider.gameObject.GetComponent<TestTile>().isBlock = true;
                    
                    building.transform.position = hit.collider.gameObject.transform.position;
                    break;
                }
            }
            yield return null;
        }
 
        this.TileCheck();
    }
 
    private void FIndNextPos()
    {
        if (this.routine != null)
        {
            StopCoroutine(this.routine);
        }
        this.routine = StartCoroutine(this.FindNextPosImpl());
    }
 
    private IEnumerator FindNextPosImpl()
    {
        while (true)
        {
            var dir = (this.motherNode.transform.position - this.character.transform.position).normalized;
            var nextNode = Vector2.Distance(this.character.transform.position, this.motherNode.transform.position);
            var distance = Vector2.Distance(this.character.transform.position, this.targetNode.transform.position);
 
            this.character.transform.position += dir * 2f * Time.deltaTime;
 
            if (nextNode <= 0.05f)
            {
                if (distance <= 0.05f)
                {
                    Debug.Log("도착");
 
                    this.TileCheck();
                    break;
                }
                
                this.FindNode();
                Debug.Log("다음");
            }
            yield return null;
        }
    }
 
    private void CharacterMovePoint()
    {
        var mother = this.motherNode.GetComponent<TestTile>().vec2;
        var data = this.character.GetComponent<TestTile>().vec2;
        var motherX = mother.x - 1;
        var motherY = mother.y - 1;
        var maxX = mother.x + 1;
        var maxY = mother.y + 1;
        
        if (data.x == motherX && data.y == mother.y)
        {
            //Debug.Log("오른쪽아래");
            this.character.GetComponent<Animator>().Play("hero_rightdown");
            //Debug.Log(data);
        }
        if (data.x == mother.x && data.y == maxY)
        {
            //Debug.Log("오른쪽위");
            this.character.GetComponent<Animator>().Play("hero_rightup");
            //Debug.Log(data);
        }
        if (data.x == maxX && data.y == mother.y)
        {
            //Debug.Log("왼쪽위");
            this.character.GetComponent<Animator>().Play("hero_leftup");
            //Debug.Log(data);
        }
        if (data.x == mother.x && data.y == motherY)
        {
            //Debug.Log("왼쪽아래");
            this.character.GetComponent<Animator>().Play("hero_leftdown");
            //Debug.Log(data);
        }
    }
 
    private void FindNode()
    {
        var mother = this.motherNode.GetComponent<TestTile>().vec2;
        var motherX = mother.x - 1;
        var motherY = mother.y - 1;
        var maxX = mother.x + 1;
        var maxY = mother.y + 1;
 
        this.character.GetComponent<TestTile>().vec2 = mother;
 
        if (motherX < 0)
        {
            motherX = 0;
        }
        if (motherY < 0)
        {
            motherY = 0;
        }
 
        for (int x = (int)motherX; x <= maxX; x++)
        {
            for (int y = (int)motherY; y <= maxY; y++)
            {
                if (x < this.colCount && y < this.rowCount)
                {
                    var data = new Vector2(x, y);
 
                    var tile = this.dicFIndTile[data];
 
                    if (tile.GetComponent<TestTile>().isBlock != true && !this.closeList.Contains(tile))
                    {
                        if (data.x == motherX && data.y == mother.y || data.y == mother.y)
                        {
                            this.movePositionList.Add(tile);
                        }
                        if (data.y == motherY && data.x == mother.x || data.x == mother.x)
                        {
                            this.movePositionList.Add(tile);
                        }
                        
                        this.movePositionList.Remove(motherNode);
                        this.closeList.Add(motherNode);
                        if (!this.closeList.Contains(tile))
                        {
                            tile.GetComponent<SpriteRenderer>().color = Color.grey;
                            this.SetFGH();
                        }
                    }
                }
            }
        }
        this.NextNode();
        this.CharacterMovePoint();
    }
    
    private void NextNode()
    {
        IEnumerable<GameObject> sortNode = this.movePositionList.OrderBy(x => x.GetComponent<TestTile>().f);
        this.selectedTile = sortNode.FirstOrDefault<GameObject>();
        this.motherNode = this.selectedTile;
        this.motherNode.GetComponent<SpriteRenderer>().color = Color.blue;
    }
    
    private void ClearMap()
    {
        Debug.Log("타일초기화");
 
        for (int i = 0; i < colCount; i++)
        {
            for (int j = 0; j < rowCount; j++)
            {
                var tiles = new Vector2(j, i);
 
                var tile = dicFIndTile[tiles];
 
                Debug.LogFormat("{0}       {1}", tile.GetComponent<TestTile>().isBlock, tiles);
 
                tile.GetComponent<SpriteRenderer>().color = Color.white;
            }
        }
        this.closeList.Clear();
        this.targetNode = null;
        this.selectedTile = null;
 
        this.movePositionList.Clear();
    }
 
 
    #region FGH 활성화 비활성화
    private void SetActiveFGH(GameObject tile)
    {
        if (!this.movePositionList.Contains(tile))
        {
            tile.GetComponent<TestTile>().G.gameObject.SetActive(false);
            tile.GetComponent<TestTile>().F.gameObject.SetActive(false);
            tile.GetComponent<TestTile>().H.gameObject.SetActive(false);
        }
        else
        {
            tile.GetComponent<TestTile>().G.gameObject.SetActive(true);
            tile.GetComponent<TestTile>().F.gameObject.SetActive(true);
            tile.GetComponent<TestTile>().H.gameObject.SetActive(true);
        }
    }
    #endregion
    private void SetFGH()
    {
        foreach (var tile in this.movePositionList)
        {
            var getG = tile.GetComponent<TestTile>().g;
            var getH = tile.GetComponent<TestTile>().h;
            getG = Mathf.Round(Vector2.Distance(tile.GetComponent<TestTile>().vec2, this.motherNode.GetComponent<TestTile>().vec2) * 10);
            var dx = Mathf.Abs(tile.GetComponent<TestTile>().vec2.x - this.targetNode.GetComponent<TestTile>().vec2.x);
            var dy = Mathf.Abs(tile.GetComponent<TestTile>().vec2.y - this.targetNode.GetComponent<TestTile>().vec2.y);
 
            getH = (dx + dy) * 10;
 
            tile.GetComponent<TestTile>().f = getG + getH;
        }
    }
 
    #region 맵, 타일 생성
    private void CreateCharacter()
    {
        if (this.character == null)
        {
            this.character = Instantiate(Resources.Load<GameObject>("Prefabs/hero"));
 
            this.CreatedCharacter(character, this.startPos.x, this.startPos.y);
        }
    }
 
    private void CreateMap()
    {
        while (true)
        {
            this.mapTile = Instantiate(Resources.Load<GameObject>("Prefabs/tile"));
 
            this.mapTile.tag = "Tile";
 
            this.mapTile.transform.SetParent(this.transform);
 
            this.CreatedMap(this.mapTile, this.col, row);
            this.dicFIndTile.Add(new Vector2(col, row), mapTile);
            this.col++;
 
            if (this.col >= this.colCount)
            {
                this.col = 0;
                this.row++;
            }
            if (this.row >= this.rowCount)
            {
                row = 0;
                break;
            }
        }
    }
 
    private void CreatedCharacter(GameObject character, float x, float y)
    {
        var vec2 = new Vector2(x, y);
 
        if (character.GetComponentInChildren<TextMesh>())
        {
            character.GetComponentInChildren<TextMesh>().text = string.Format("({0},{1})", x, y);
            this.SetActiveFGH(character);
        }
 
        character.AddComponent<TestTile>();
        character.GetComponent<TestTile>().vec2 = vec2;
 
        var screen = this.MapToScreen(vec2);
 
        var screenPos = Camera.main.ScreenToWorldPoint(new Vector2(screen.x + 512, screen.y + 384 + 100));
 
        character.transform.position = new Vector3(screenPos.x, screenPos.y, 0);
    }
 
    private void CreatedMap(GameObject tileMap, float x, float y)
    {
        var vec2 = new Vector2(x, y);
 
        if (tileMap.GetComponentInChildren<TextMesh>())
        {
            tileMap.GetComponentInChildren<TextMesh>().text = string.Format("({0},{1})", x, y);
            this.SetActiveFGH(tileMap);
        }
 
        if (vec2 == this.character.GetComponent<TestTile>().vec2)
        {
            this.motherNode = tileMap;
        }
 
        tileMap.AddComponent<TestTile>();
        tileMap.GetComponent<TestTile>().vec2 = vec2;
 
        var screen = this.MapToScreen(vec2);
 
        var screenPos = Camera.main.ScreenToWorldPoint(new Vector2(screen.x + 512, screen.y + 384 + 100));
 
        tileMap.transform.position = new Vector3(screenPos.x, screenPos.y, 0);
    }
 
    public Vector2 MapToScreen(Vector2 mapPos)
    {
        var screenX = mapPos.x * this.tileWidth - (mapPos.y * this.tileWidth);
        var screenY = mapPos.y * -tileHeight - (mapPos.x * tileHeight);
 
        return new Vector2(screenX, screenY);
    }
    #endregion
}
 
Colored by Color Scripter
cs

저작자표시

'Project > TODO' 카테고리의 다른 글

프로토타입 건물생성 하면 주변 캐릭터가 찾아오기 (0)	2019.06.14
[프로토타입] 건물생성 시 주변가까운 캐릭터 데려오기 (0)	2019.06.12
[프로토타입3단계] 캐릭터로 이동시키기 (0)	2019.06.08
[프로토타입]딕셔너리 키 오류 해결 (0)	2019.06.07
[프로토타입 2단계] isometric Astar알고리즘 활용하여 길찾기 (0)	2019.06.06

‹ Prev 1 2 3 4 5 6 ··· 14 Next ›

Yang.공부방

[프로토타입] 일정시간 지나면 적 생성 기지로 자동으로 공격해오기

프로토타입 건물생성 하면 주변 캐릭터가 찾아오기

'Project > TODO' 카테고리의 다른 글

TestGPGS 개인정보 처리방침

'Unity > 수업내용' 카테고리의 다른 글

[프로토타입] 건물생성 시 주변가까운 캐릭터 데려오기

'Project > TODO' 카테고리의 다른 글

[프로토타입]캐릭터 이동 및 빌딩생성

'Project > TODO' 카테고리의 다른 글

최근에 올라온 글

글 보관함

티스토리툴바

« 2025/02 »
일	월	화	수	목	금	토
						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