나의 발전을 위한 공간

[랜덤 타워 디펜스] Day 11 ~ 14 타워 시스템 구현

지나가던 개발자 — Tue, 13 Jan 2026 22:07:04 +0900

목표

설치 가능 위치 고스트 초록색 불가능 위치 고스트 빨간색으로 표시 되는 기능 구현
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
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020

using UnityEngine;
using UnityEngine.InputSystem;
using Cysharp.Threading.Tasks;
using UnityEngine.EventSystems;
 
public class TowerManager : MonoBehaviour
{
    public static TowerManager Instance { get; private set; }
 
    [Header("Placement")]
    [SerializeField] private Camera mainCamera;
    [SerializeField] private LayerMask tileLayerMask;
    
    [Header("Random Build")]
    [SerializeField] private TowerData[] buildPool;
    
    [Header("Trait Data")]
    [SerializeField] private TowerTraitDatabase traitDatabase;
    
    public enum CombineMode
    {
        Exact,
        Random
    }
    
    [Header("Combine")]
    [SerializeField] private CombineMode combineMode = CombineMode.Exact;
    
    private enum PlaceState
    {
        None,
        Placing
    }
 
    [Header("Build Level (future grade roll)")]
    [SerializeField] private int buildLevel = 1;
 
    [Header("Build Level Costs")]
    [SerializeField] private int baseUpgradeCost = 50;
    [SerializeField] private int upgradeCostStep = 50;
    [SerializeField] private int maxBuildLevel = 10;
 
    [Header("GhostTower")]
    [SerializeField] private GameObject ghostPreviewPrefab;
    [SerializeField] private float previewAlpha = 0.35f;
    [SerializeField] private float previewYOffset = 0.02f;
    [SerializeField] private bool showInvalidGhost = true;
    [SerializeField] private Color validTint = new Color(0.2f, 1f, 0.2f, 1f);
    [SerializeField] private Color invalidTint = new Color(1f, 0.2f, 0.2f, 1f);
    
    [Header("Spawn Offset")]
    [SerializeField] private float towerSpawnYOffset = 0.1f;
 
    [Header("Context UI")]
    [SerializeField] private ContextUIController contextUI;
    
    [System.Serializable]
    public struct GradeChance
    {
        public TowerGrade grade;
        [Range(0, 100)] public int percent;
    }
    
    private GameObject _ghostGO;
    private readonly System.Collections.Generic.List<Renderer> _ghostRenderers = new();
    private MaterialPropertyBlock _mpb;
    
    private PlaceState _placeState = PlaceState.None;
    
    private TowerBase _selectedTower;
    private bool _combineBusy;
    
    public int BuildLevel => buildLevel;
    public bool IsPlacing => _placeState == PlaceState.Placing;
    public event System.Action<bool> OnPlacingChanged;
 
    private void Awake()
    {
        if (Instance != null && Instance != this)
        {
            Destroy(gameObject);
            return;
        }
        Instance = this;
 
        if (mainCamera == null)
        {
            mainCamera = Camera.main;
        }
        
        _mpb = new MaterialPropertyBlock();
    }
 
    private void Update()
    {
        if (_combineBusy) 
            return;
        
        if (_placeState == PlaceState.Placing)
        {
            var kb = Keyboard.current;
            if (kb != null && kb.escapeKey.wasPressedThisFrame)
            {
                CancelPlaceMode();
            }
 
            var mouse = Mouse.current;
            if (mouse != null && mouse.rightButton.wasPressedThisFrame)
            {
                CancelPlaceMode();
                return;
            }
        }
        
        if (Mouse.current == null) 
            return;
        
        if (_placeState == PlaceState.Placing)
        {
            UpdatePlacementPreview();
        }
 
        if (Mouse.current.leftButton.wasPressedThisFrame)
        {
            if (EventSystem.current != null && EventSystem.current.IsPointerOverGameObject())
                return;
 
            HandleClick();
        }
        
        if (Keyboard.current != null && Keyboard.current.vKey.wasPressedThisFrame)
        {
            combineMode = (combineMode == CombineMode.Exact) ? CombineMode.Random : CombineMode.Exact;
            Debug.Log($"[CombineMode] {combineMode}");
        }
        
        if (Keyboard.current != null && Keyboard.current.cKey.wasPressedThisFrame)
        {
            if (_combineBusy)
                return;
            
            TryCombineSelectedTowerAsync().Forget();
        }
    }
 
    private void HandleClick()
    {
        Vector2 mousePos = Mouse.current.position.ReadValue();
        Ray ray = mainCamera.ScreenPointToRay(mousePos);
 
        if (Physics.Raycast(ray, out RaycastHit hitTower, 1000f, LayerMask.GetMask("Tower")))
        {
            TowerBase tower = hitTower.collider.GetComponentInParent<TowerBase>();
            if (tower != null)
            {
                SelectTower(tower);
                return;
            }
        }
        
        if (Physics.Raycast(ray, out RaycastHit hitTile, 1000f, tileLayerMask))
        {
            GridTile tile = hitTile.collider.GetComponent<GridTile>();
            if (tile != null)
            {
                OnTileClicked(tile);
                return;
            }
        }
 
        ClearSelection();
    }
    
    private void SelectTower(TowerBase tower)
    {
        if (_selectedTower == tower) return;
 
        if (_selectedTower != null)
            _selectedTower.SetSelected(false);
 
        _selectedTower = tower;
        _selectedTower.SetSelected(true);
 
        if (contextUI != null)
            contextUI.ShowTower(_selectedTower);
    }
 
    private void ClearSelection()
    {
        if (_selectedTower != null)
            _selectedTower.SetSelected(false);
 
        _selectedTower = null;
 
        if (contextUI == null) return;
 
        if (_placeState == PlaceState.Placing)
        {
            contextUI.ShowBuild(GetMinBuildCostForCurrentLevel(), buildLevel);
        }
        else
        {
            contextUI.Hide();
        }
    }
    
    private TowerData RollBuildTowerData(TowerGrade grade)
    {
        if (buildPool == null || buildPool.Length == 0)
        {
            Debug.LogError("[TowerManager] buildPool is empty. Assign TowerData assets in Inspector.");
            return null;
        }
 
        int safety = 0;
        while (safety < 50)
        {
            int idx = Random.Range(0, buildPool.Length);
            TowerData d = buildPool[idx];
            if (d != null && d.grade == grade)
                return d;
 
            safety++;
        }
 
        Debug.LogWarning($"[TowerManager] No TowerData matched grade={grade}. Check buildPool contents.");
        return null;
    }
 
    private TowerData RollMergeResultByGrade(TowerGrade targetGrade)
    {
        if (buildPool == null || buildPool.Length == 0)
        {
            Debug.LogError("[TowerManager] buildPool is empty. Cannot roll merge result.");
            return null;
        }
        
        if (TowerDatabase.Instance != null)
        {
            return TowerDatabase.Instance.GetRandomByGrade(targetGrade);
        }
        
        int safety = 0;
        while (safety < 100)
        {
            int idx = Random.Range(0, buildPool.Length);
            TowerData d = buildPool[idx];
            if (d != null && d.grade == targetGrade)
                return d;
            safety++;
        }
 
        Debug.LogWarning("[TowerManager] No TowerData matched targetGrade for merge result.");
        return null;
    }
    
    private void FindExactTowers(TowerData grade, System.Collections.Generic.List<TowerBase> outList)
    {
        outList.Clear();
 
        TowerBase[] allTowers = FindObjectsOfType<TowerBase>();
        foreach (var t in allTowers)
        {
            TowerData d = t.GetData();
            if (d == null)
                continue;
 
            if (d.towerId == grade.towerId && d.grade == grade.grade)
                outList.Add(t);
        }
    }
    private void FindSameGradeTowers(TowerGrade grade, System.Collections.Generic.List<TowerBase> outList)
    {
        outList.Clear();
 
        TowerBase[] allTowers = FindObjectsOfType<TowerBase>();
        foreach (var t in allTowers)
        {
            TowerData d = t.GetData();
            if (d == null)
                continue;
 
            if (d.grade == grade)
                outList.Add(t);
        }
    }
    
    private void AssignTraitIfNeeded(TowerBase tower)
    {
        if (tower == null) return;
 
        TowerData d = tower.GetData();
        if (d == null) return;
 
        if (d.grade == TowerGrade.Normal)
        {
            tower.SetTrait(null);
            return;
        }
 
        if (traitDatabase == null)
        {
            Debug.LogWarning("[TowerManager] traitDatabase is null.");
            tower.SetTrait(null);
            return;
        }
 
        TowerTraitSO rolled = traitDatabase.RollTrait(d.towerId, d.grade);
        tower.SetTrait(rolled);
 
        if (rolled != null)
            Debug.Log($"[Trait] {d.towerId}({d.grade}) => {rolled.type} {rolled.tier}");
    }
    
    private async UniTaskVoid TryCombineSelectedTowerAsync()
    {
        if (_combineBusy)
            return;
 
        _combineBusy = true;
        
        try
        {
            if (_selectedTower == null)
            {
                Debug.Log("선택된 타워가 없습니다.");
                return;
            }
            
            TowerData selectedData = _selectedTower.GetData();
            if (selectedData == null)
            {
                Debug.Log("현재 타워 데이터가 없습니다.");
                return;
            }
            
            TowerGrade curGrade = selectedData.grade;
            if (!TowerGradeHelper.TryGetNextGrade(curGrade, out TowerGrade nextGrade))
            {
                Debug.Log("더 이상 합성할 수 없는 등급입니다.");
                return;
            }
            
            if (TowerDatabase.Instance == null)
            {
                Debug.LogError("TowerDatabase 인스턴스가 없습니다.");
                return;
            }
            
            // 1) 후보 수집은 모드에 따라 다름
            var candidates = new System.Collections.Generic.List<TowerBase>();
            
            if (combineMode == CombineMode.Exact)
                FindExactTowers(selectedData, candidates);
            else
                FindSameGradeTowers(curGrade, candidates);
            
            if (candidates.Count < 3)
            {
                if (combineMode == CombineMode.Exact)
                    Debug.Log($"[Exact Combine] 조건 미충족: {selectedData.towerId} ({candidates.Count}/3)");
                else
                    Debug.Log($"[Random Combine] 조건 미충족: grade={curGrade} ({candidates.Count}/3)");
                return;
            }
            
            // 2) 3개 구성(선택 타워 포함 + 나머지 2개)
            var mergeList = new System.Collections.Generic.List<TowerBase>(3);
            mergeList.Add(_selectedTower);
            
            for (int i = 0; i < candidates.Count && mergeList.Count < 3; i++)
            {
                if (candidates[i] == _selectedTower)
                    continue;
            
                mergeList.Add(candidates[i]);
            }
            
            if (mergeList.Count < 3)
            {
                Debug.Log("합성 대상 3개를 구성하지 못했습니다.");
                return;
            }
            
            // 3) 결과 TowerData 결정(모드에 따라 다름)
            TowerData resultData = null;
            
            if (combineMode == CombineMode.Exact)
            {
                string nextTowerId = GetNextTowerId(selectedData.towerId, nextGrade);
                resultData = TowerDatabase.Instance.Get(nextTowerId);
            
                if (resultData == null)
                {
                    Debug.LogError($"다음 TowerData를 찾을 수 없습니다: {nextTowerId}");
                    return;
                }
            }
            else
            {
                resultData = RollMergeResultByGrade(nextGrade);
                if (resultData == null)
                {
                    Debug.LogError($"혼합 합성 결과 TowerData를 뽑지 못했습니다. targetGrade={nextGrade}");
                    return;
                }
            }
            
            if (TowerMergeVFX.Instance == null)
            {
                Debug.LogError("TowerMergeVFX.Instance가 없습니다. 씬에 TowerMergeVFX 오브젝트가 있어야 합니다.");
                return;
            }
            
            Transform[] sources =
            {
                mergeList[0] != null ? mergeList[0].transform : null,
                mergeList[1] != null ? mergeList[1].transform : null,
                mergeList[2] != null ? mergeList[2].transform : null
            };
            
            Vector3 mergePoint = _selectedTower.transform.position;
            
            Vector3 keepScale = _selectedTower.transform.localScale;
            
            await TowerMergeVFX.Instance.PlayMergeAsync(
                sources,
                mergePoint,
                () =>
                {
                    if (resultData == null || _selectedTower == null)
                        return;
                    
                    TowerTraitSO baseTrait = _selectedTower.RuntimeTrait;
                    GridTile tile = _selectedTower.CurrentTile;
 
                    Vector3 spawnPos = tile != null ? tile.transform.position : mergePoint;
                    Quaternion rot = _selectedTower.transform.rotation;
                    
                    TowerTraitSO resultTrait = null;
                    if (resultData.grade != TowerGrade.Normal && traitDatabase != null)
                    {
                        if (combineMode == CombineMode.Exact)
                        {
                            if (baseTrait != null)
                                resultTrait = traitDatabase.UpgradeTrait(baseTrait, resultData.grade);
                            else
                                resultTrait = traitDatabase.RollTrait(resultData.towerId, resultData.grade);
                        }
                        else
                        {
                            resultTrait = traitDatabase.RollTrait(resultData.towerId, resultData.grade);
                        }
                    }
                    
                    for (int i = 0; i < mergeList.Count; i++)
                        RemoveTowerSafe(mergeList[i]);
                    
                    TowerBase newTower = SpawnTowerFromData(
                        resultData,
                        spawnPos,
                        rot,
                        tile,
                        resultTrait
                    );
 
                    if (newTower == null)
                        return;
                    
                    _selectedTower = newTower;
                    _selectedTower.SetSelected(true);
                    _selectedTower.PlaySpawnFeedback();
 
                    if (contextUI != null)
                        contextUI.ShowTower(_selectedTower);
                }
            );
        }
        finally
        {
            _combineBusy = false;
        }
    }
    
    private int GetMinBuildCostForGrade(TowerGrade grade)
    {
        if (buildPool == null) 
            return int.MaxValue;
 
        int min = int.MaxValue;
        for (int i = 0; i < buildPool.Length; i++)
        {
            var d = buildPool[i];
            if (d == null) continue;
            if (d.grade != grade) continue;
 
            if (d.buildCost < min) min = d.buildCost;
        }
 
        return min;
    }
 
 
    private string GetNextTowerId(string currentId, TowerGrade nextGrade)
    {
        int idx = currentId.LastIndexOf('_');
        if (idx < 0)
            return currentId;
 
        string baseId = currentId.Substring(0, idx);
        return $"{baseId}_{nextGrade.ToString().ToLower()}";
    }
    
    private TowerGrade GetBuildRollGrade()
    {
        TowerGrade rolled = RollGradeByBuildLevel();
        return ResolveGradeIfMissing(rolled);
    }
    
    private bool TryPlaceTower_ReturnSuccess(GridTile tile)
    {
        if (!tile.IsEmpty)
        {
            Debug.Log("설치 불가 타일이거나 이미 타워가 있습니다.");
            return false;
        }
 
        if (GameManager.Instance == null)
        {
            Debug.LogError("GameManager 인스턴스가 없습니다.");
            return false;
        }
 
        TowerGrade gradeToRoll = GetBuildRollGrade();
        TowerData rolledData = RollBuildTowerData(gradeToRoll);
        if (rolledData == null) return false;
 
        if (rolledData.towerPrefab == null)
        {
            Debug.LogError($"[TowerManager] towerPrefab is null in TowerData: {rolledData.name}");
            return false;
        }
 
        int cost = rolledData.buildCost;
 
        if (GameManager.Instance.Gold < cost)
        {
            Debug.Log("골드가 부족합니다.");
            return false;
        }
 
        Vector3 spawnPos = tile.transform.position + Vector3.up * towerSpawnYOffset;
        GameObject towerObj = Instantiate(rolledData.towerPrefab, spawnPos, Quaternion.identity);
 
        TowerBase tower = towerObj.GetComponent<TowerBase>();
        if (tower == null)
        {
            Debug.LogError("rolledData.towerPrefab에 TowerBase 컴포넌트가 없습니다.");
            Destroy(towerObj);
            return false;
        }
 
        tower.SetData(rolledData);
        AssignTraitIfNeeded(tower);
 
        tile.SetTower(tower);
        tower.SetTile(tile);
 
        GameManager.Instance.AddGold(-cost);
 
        Debug.Log($"[Build] Rolled: {rolledData.towerId} ({rolledData.grade}), cost={cost}");
        return true;
    }
 
    
    public void OnTileClicked(GridTile tile)
    {
        if (_placeState != PlaceState.Placing)
            return;
        
        bool placed = TryPlaceTower_ReturnSuccess(tile);
        if (placed)
            CancelPlaceMode();
    }
 
    public void CancelPlaceMode()
    {
        _placeState = PlaceState.None;
 
        if (_ghostGO != null)
            Destroy(_ghostGO);
 
        _ghostGO = null;
        _ghostRenderers.Clear();
 
        OnPlacingChanged?.Invoke(false);
        
        if (contextUI != null)
            contextUI.Hide();
        
        Debug.Log("[Build] Place mode OFF");
    }
    
    public int GetBuildUpgradeCost()
    {
        return baseUpgradeCost + (buildLevel - 1) * upgradeCostStep;
    }
 
    public bool TryUpgradeBuildLevel()
    {
        if (buildLevel >= maxBuildLevel)
        {
            Debug.Log("[Build] already max level");
            return false;
        }
 
        int cost = GetBuildUpgradeCost();
        if (GameManager.Instance == null) return false;
 
        if (!GameManager.Instance.TrySpendGold(cost))
        {
            Debug.Log("[Build] Not enough gold for build level up");
            return false;
        }
 
        buildLevel++;
        Debug.Log($"[Build] Level UP => {buildLevel}");
        
        if (IsPlacing && contextUI != null)
            contextUI.ShowBuild(GetMinBuildCostForCurrentLevel(), buildLevel);
        
        return true;
    }
    
    public void BeginPlaceMode()
    {
        if (_placeState == PlaceState.Placing)
            return;
        
        if (GameManager.Instance != null)
        {
            int minCost = GetMinBuildCostForCurrentLevel();
            if (GameManager.Instance.Gold < minCost)
            {
                Debug.Log("[Build] 골드 부족: 빌드 모드 진입 불가");
                return;
            }
        }
 
        _placeState = PlaceState.Placing;
        ClearSelection();
 
        EnsureGhost(ghostPreviewPrefab);
        UpdateGhostVisible(false);
        
        OnPlacingChanged?.Invoke(true);
        
        if (contextUI != null)
            contextUI.ShowBuild(GetMinBuildCostForCurrentLevel(), buildLevel);
 
        Debug.Log("[Build] Place mode ON");
    }
 
    private void EnsureGhost(GameObject prefab)
    {
        if (_ghostGO != null)
            Destroy(_ghostGO);
 
        if (prefab == null)
        {
            Debug.LogWarning("[Build] ghostPreviewPrefab is null");
            return;
        }
 
        _ghostGO = Instantiate(prefab);
        _ghostGO.name = "[GhostPreview]";
 
        foreach (var col in _ghostGO.GetComponentsInChildren<Collider>(true))
            col.enabled = false;
 
        // Ignore Raycast
        int layer = LayerMask.NameToLayer("Ignore Raycast");
        if (layer >= 0)
        {
            _ghostGO.layer = layer;
            foreach (Transform t in _ghostGO.GetComponentsInChildren<Transform>(true))
                t.gameObject.layer = layer;
        }
 
        _ghostRenderers.Clear();
        _ghostGO.GetComponentsInChildren(true, _ghostRenderers);
 
        //ApplyGhostAlpha(previewAlpha);
        ApplyGhostTint(true);
    }
    
    private void ApplyGhostTint(bool canPlace)
    {
        if (_ghostRenderers == null || _ghostRenderers.Count == 0) return;
        if (_mpb == null) _mpb = new MaterialPropertyBlock();
 
        Color tint = canPlace ? validTint : invalidTint;
        tint.a = previewAlpha;
 
        for (int i = 0; i < _ghostRenderers.Count; i++)
        {
            var r = _ghostRenderers[i];
            if (r == null) continue;
 
            r.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
            r.receiveShadows = false;
 
            r.GetPropertyBlock(_mpb);
            
            _mpb.SetColor("_BaseColor", tint);
            _mpb.SetColor("_Color", tint);
 
            r.SetPropertyBlock(_mpb);
        }
    }
 
    private void UpdateGhostVisible(bool visible)
    {
        if (_ghostGO == null) return;
        _ghostGO.SetActive(visible);
    }
 
    private void ApplyGhostAlpha(float a)
    {
        a = Mathf.Clamp01(a);
 
        for (int i = 0; i < _ghostRenderers.Count; i++)
        {
            var r = _ghostRenderers[i];
            if (r == null) continue;
 
            r.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
            r.receiveShadows = false;
 
            r.GetPropertyBlock(_mpb);
 
            if (r.sharedMaterial != null)
            {
                if (r.sharedMaterial.HasProperty("_BaseColor"))
                {
                    Color c = r.sharedMaterial.GetColor("_BaseColor");
                    c.a = a;
                    _mpb.SetColor("_BaseColor", c);
                }
                if (r.sharedMaterial.HasProperty("_Color"))
                {
                    Color c = r.sharedMaterial.GetColor("_Color");
                    c.a = a;
                    _mpb.SetColor("_Color", c);
                }
            }
 
            r.SetPropertyBlock(_mpb);
        }
    }
 
    private void UpdatePlacementPreview()
    {
        if (_ghostGO == null)
            return;
 
        Vector2 mousePos = Mouse.current.position.ReadValue();
        Ray ray = mainCamera.ScreenPointToRay(mousePos);
 
        if (!Physics.Raycast(ray, out RaycastHit hitTile, 1000f, tileLayerMask))
        {
            UpdateGhostVisible(false);
            return;
        }
 
        GridTile tile = hitTile.collider.GetComponent<GridTile>();
        if (tile == null)
        {
            UpdateGhostVisible(false);
            return;
        }
 
        bool canPlace = tile.IsEmpty && tile.TileType == TileType.Buildable;
        
        Vector3 pos = tile.transform.position;
        pos.y += previewYOffset;
        _ghostGO.transform.position = pos;
        
        if (!canPlace && !showInvalidGhost)
        {
            UpdateGhostVisible(false);
            return;
        }
 
        UpdateGhostVisible(true);
        ApplyGhostTint(canPlace);
    }
    
    private int CalculateSellRefund(TowerBase tower)
    {
        if (tower == null) return 0;
 
        TowerData d = tower.GetData();
        if (d == null) return 0;
        
        const float rate = 0.5f;
        return Mathf.Max(0, Mathf.RoundToInt(d.buildCost * rate));
    }
    
    private GradeChance[] GetChancesForLevel(int level) 
    {
        int lv = Mathf.Clamp(level, 1, maxBuildLevel);
        
        switch (lv)
        {
            case 1:  return new[] { new GradeChance{ grade = TowerGrade.Normal, percent = 100 } };
            case 2:  return new[] { new GradeChance{ grade = TowerGrade.Normal, percent = 90 }, new GradeChance{ grade = TowerGrade.Rare, percent = 10 } };
            case 3:  return new[] { new GradeChance{ grade = TowerGrade.Normal, percent = 75 }, new GradeChance{ grade = TowerGrade.Rare, percent = 22 }, new GradeChance{ grade = TowerGrade.Epic, percent = 3 } };
            case 4:  return new[] { new GradeChance{ grade = TowerGrade.Normal, percent = 60 }, new GradeChance{ grade = TowerGrade.Rare, percent = 33 }, new GradeChance{ grade = TowerGrade.Epic, percent = 7 } };
            case 5:  return new[] { new GradeChance{ grade = TowerGrade.Normal, percent = 50 }, new GradeChance{ grade = TowerGrade.Rare, percent = 35 }, new GradeChance{ grade = TowerGrade.Epic, percent = 13 }, new GradeChance{ grade = TowerGrade.Legendary, percent = 2 } };
            case 6:  return new[] { new GradeChance{ grade = TowerGrade.Normal, percent = 40 }, new GradeChance{ grade = TowerGrade.Rare, percent = 35 }, new GradeChance{ grade = TowerGrade.Epic, percent = 20 }, new GradeChance{ grade = TowerGrade.Legendary, percent = 5 } };
            case 7:  return new[] { new GradeChance{ grade = TowerGrade.Normal, percent = 30 }, new GradeChance{ grade = TowerGrade.Rare, percent = 35 }, new GradeChance{ grade = TowerGrade.Epic, percent = 25 }, new GradeChance{ grade = TowerGrade.Legendary, percent = 10 } };
            case 8:  return new[] { new GradeChance{ grade = TowerGrade.Normal, percent = 20 }, new GradeChance{ grade = TowerGrade.Rare, percent = 35 }, new GradeChance{ grade = TowerGrade.Epic, percent = 30 }, new GradeChance{ grade = TowerGrade.Legendary, percent = 15 } };
            case 9:  return new[] { new GradeChance{ grade = TowerGrade.Normal, percent = 10 }, new GradeChance{ grade = TowerGrade.Rare, percent = 35 }, new GradeChance{ grade = TowerGrade.Epic, percent = 35 }, new GradeChance{ grade = TowerGrade.Legendary, percent = 20 } };
            default: return new[] { new GradeChance{ grade = TowerGrade.Normal, percent = 5 },  new GradeChance{ grade = TowerGrade.Rare, percent = 30 }, new GradeChance{ grade = TowerGrade.Epic, percent = 40 }, new GradeChance{ grade = TowerGrade.Legendary, percent = 25 } };
        }
    }
    
    private TowerGrade RollGradeByBuildLevel()
    {
        GradeChance[] chances = GetChancesForLevel(buildLevel);
 
        int roll = Random.Range(0, 100);
        int acc = 0;
 
        for (int i = 0; i < chances.Length; i++)
        {
            acc += chances[i].percent;
            if (roll < acc)
                return chances[i].grade;
        }
        
        return chances[chances.Length - 1].grade;
    }
    
    private bool HasAnyTowerOfGrade(TowerGrade grade)
    {
        if (buildPool == null) return false;
 
        for (int i = 0; i < buildPool.Length; i++)
        {
            var d = buildPool[i];
            if (d != null && d.grade == grade)
                return true;
        }
        return false;
    }
 
    private TowerGrade ResolveGradeIfMissing(TowerGrade rolled)
    {
        TowerGrade g = rolled;
 
        while (!HasAnyTowerOfGrade(g))
        {
            if (g == TowerGrade.Normal)
                return TowerGrade.Normal;
 
            g = (TowerGrade)((int)g - 1); // Legendary->Epic->Rare->Normal
        }
 
        return g;
    }
    
    public bool TrySellTower(TowerBase tower)
    {
        if (tower == null)
            return false;
        
        if (_selectedTower == tower)
        {
            _selectedTower.SetSelected(false);
            _selectedTower = null;
        }
 
        int refund = CalculateSellRefund(tower);
        
        tower.SetTile(null);
        
        if (GameManager.Instance != null && refund > 0)
            GameManager.Instance.AddGold(refund);
        
        Destroy(tower.gameObject);
 
        return true;
    }
    
    private TowerBase SpawnTowerFromData(
        TowerData data,
        Vector3 position,
        Quaternion rotation,
        GridTile tile,
        TowerTraitSO trait)
    {
        if (data == null || data.towerPrefab == null)
        {
            Debug.LogError("[TowerManager] SpawnTowerFromData failed");
            return null;
        }
 
        GameObject go = Instantiate(data.towerPrefab, position, rotation);
        TowerBase tower = go.GetComponent<TowerBase>();
 
        if (tower == null)
        {
            Debug.LogError("[TowerManager] Prefab has no TowerBase");
            Destroy(go);
            return null;
        }
 
        tower.SetData(data);
        tower.SetTrait(trait);
 
        if (tile != null)
        {
            tile.SetTower(tower);
            tower.SetTile(tile);
        }
 
        return tower;
    }
 
    private void RemoveTowerSafe(TowerBase tower)
    {
        if (tower == null) return;
        tower.SetTile(null);
        Destroy(tower.gameObject);
    }
    
    public string GetBuildLevelChanceLabel()
    {
        var chances = GetChancesForLevel(buildLevel);
 
        System.Text.StringBuilder sb = new System.Text.StringBuilder();
        sb.AppendLine($"Build Lv. {buildLevel}");
 
        for (int i = 0; i < chances.Length; i++)
            sb.AppendLine($"{chances[i].grade}: {chances[i].percent}%");
 
        return sb.ToString();
    }
    
    public int GetMinBuildCostForCurrentLevel()
    {
        var chances = GetChancesForLevel(buildLevel);
        if (chances == null || chances.Length == 0) 
            return int.MaxValue;
 
        int min = int.MaxValue;
 
        for (int i = 0; i < chances.Length; i++)
        {
            if (chances[i].percent <= 0) 
                continue;
 
            int c = GetMinBuildCostForGrade(chances[i].grade);
            if (c < min) 
                min = c;
        }
 
        return min;
    }
    
    public void RequestCombineExact()
    {
        combineMode = CombineMode.Exact;
        if (_combineBusy) return;
        TryCombineSelectedTowerAsync().Forget();
    }
 
    public void RequestCombineRandom()
    {
        combineMode = CombineMode.Random;
        if (_combineBusy) return;
        TryCombineSelectedTowerAsync().Forget();
    }
 
    public bool TryRerollTrait(TowerBase tower, int cost)
    {
        if (tower == null) return false;
 
        TowerData d = tower.GetData();
        if (d == null) return false;
 
        if (d.grade == TowerGrade.Normal)
            return false;
 
        if (GameManager.Instance == null)
            return false;
 
        if (!GameManager.Instance.TrySpendGold(cost))
            return false;
 
        if (traitDatabase == null)
            return false;
 
        TowerTraitSO newTrait = traitDatabase.RollTraitExclude(d.towerId, d.grade, tower.RuntimeTrait);
        if (newTrait == null)
            return false;
 
        tower.SetTrait(newTrait);
 
        return true;
    }
    
    public int GetSellRefund(TowerBase tower)
    {
        return CalculateSellRefund(tower);
    }
}
 
Colored by Color Scripter

cs

1. 타워 설치 시 고스트(Ghost) 시각화 (초록/빨간색 표시)

기능 설명:
- 플레이어가 타워를 설치하기 전, 마우스 커서를 따라다니는 반투명한 타워(고스트)를 보여줍니다.
- Raycast를 쏘아 현재 마우스가 가리키는 타일이 '건설 가능한 타일'인지 확인합니다.
- 설치 가능 (Buildable): 고스트 타워의 머티리얼 색상을 **초록색(Green)**으로 변경하여 설치 가능함을 알립니다.
- 설치 불가 (Not Buildable): 이미 타워가 있거나 건설 불가능한 구역일 경우 **빨간색(Red)**으로 변경하여 경고합니다.

2. 타워 생성 확률 시스템 (Random Probability)

기능 설명:
- 타워 건설 버튼을 눌렀을 때 실행되는 로직입니다.
- 0부터 100 사이의 난수(Random.Range)를 생성하거나, 전체 가중치의 합을 계산합니다.
- 확률 테이블 비교: 설정해둔 등급별 확률(예: 일반 60%, 희귀 30%, 영웅 10% 등)과 생성된 난수를 비교합니다.
- 조건에 맞는 등급의 타워 프리팹을 선택하여 타일에 소환합니다. 이 시스템을 통해 게임에 '뽑기(Gacha)' 요소를 부여합니다.

3. 타워 합성(Merge) 로직

기능 설명:
- 플레이어가 두 개의 타워를 선택하거나, 드래그 앤 드롭으로 겹쳤을 때 발생하는 로직입니다.
- 조건 검사: 두 타워의 등급(Grade)과 종류(Type)가 동일한지 확인합니다.
- 합성 수행: 조건이 일치하면 기존 두 타워를 파괴(Destroy)하고, 해당 위치에 한 단계 높은 등급의 타워를 생성합니다.
- 이때 파티클이나 사운드 이펙트(VFX/SFX)를 재생하여 타격감을 줍니다.

[랜덤 타워 디펜스] Day 10 타워 특성 구현

지나가던 개발자 — Mon, 12 Jan 2026 02:36:17 +0900

오늘의 목표

타워 특성 추가
1. 치명타 - 기본 대미지를 특정 배율로 변경하여 공격
2. 슬로우 - 적의 이동속도를 특정 시간동안 늦춤
3. 체인 - 특정 타겟 수에게 전이되며 줄어드는 대미지를 입히는 공격
4. 폭발 - 특정 범위에 대미지를 입히는 공격
대미지 시각화
1. 몬스터의 상단에 대미지를 출력

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

using System.Collections.Generic;
using UnityEngine;
 
public class TowerTraitDatabase : MonoBehaviour
{
    [Header("All Traits")]
    [SerializeField] private TowerTraitSO[] allTraits;
 
    [System.Serializable]
    public struct AffinityWeights
    {
        public int core;
        public int common;
        public int wild;
 
        public AffinityWeights(int core, int common, int wild)
        {
            this.core = core;
            this.common = common;
            this.wild = wild;
        }
    }
 
    // 타워 타입별 성향 가중치
    private static readonly Dictionary<string, AffinityWeights> AffinityWeightByType =
        new Dictionary<string, AffinityWeights>
        {
            { "basic",  new AffinityWeights(50, 45, 5) },
            { "cannon", new AffinityWeights(60, 30, 10) },
            { "magic",  new AffinityWeights(45, 35, 20) },
        };
 
    public TowerTraitSO RollTrait(string towerId, TowerGrade grade)
    {
        if (allTraits == null || allTraits.Length == 0)
            return null;
 
        // 1) 타워 타입 키(basic/cannon/magic)
        string typeKey = GetTypeKeyFromTowerId(towerId);
 
        // 2) 등급별 티어 확률로 티어 결정
        TraitTier tier = RollTierByGrade(grade);
 
        // 3) 타입별 성향 가중치로 affinity 결정
        AffinityWeights w = AffinityWeightByType.TryGetValue(typeKey, out var found)
            ? found
            : new AffinityWeights(50, 40, 10);
 
        TraitAffinity affinity = RollAffinity(w);
 
        // 4) 후보 수집: (tier + affinity) 매칭
        List<TowerTraitSO> candidates = new List<TowerTraitSO>(16);
        for (int i = 0; i < allTraits.Length; i++)
        {
            var t = allTraits[i];
            if (t == null) continue;
 
            if (t.tier != tier) continue;
            if (t.affinity != affinity) continue;
 
            candidates.Add(t);
        }
 
        // 5) 폴백: tier만 맞는 걸로라도 뽑기 (데이터 미구성 대비)
        if (candidates.Count == 0)
        {
            for (int i = 0; i < allTraits.Length; i++)
            {
                var t = allTraits[i];
                if (t == null) continue;
 
                if (t.tier == tier)
                    candidates.Add(t);
            }
        }
 
        if (candidates.Count == 0)
            return null;
 
        return candidates[Random.Range(0, candidates.Count)];
    }
 
    private static TraitTier RollTierByGrade(TowerGrade grade)
    {
        // 네 룰: Normal은 Trait 없음이니 이 함수는 Rare/Epic/Legend에만 호출한다고 가정
        int t1, t2, t3;
 
        switch (grade)
        {
            case TowerGrade.Rare:
                t1 = 80; t2 = 20; t3 = 0;
                break;
            case TowerGrade.Epic:
                t1 = 50; t2 = 45; t3 = 5;
                break;
            case TowerGrade.Legendary:
                t1 = 25; t2 = 55; t3 = 20;
                break;
            default:
                t1 = 100; t2 = 0; t3 = 0;
                break;
        }
 
        int sum = t1 + t2 + t3;
        int roll = Random.Range(1, sum + 1);
 
        if (roll <= t1) return TraitTier.T1;
        roll -= t1;
        if (roll <= t2) return TraitTier.T2;
        return TraitTier.T3;
    }
 
    private static TraitAffinity RollAffinity(AffinityWeights w)
    {
        int core = Mathf.Max(0, w.core);
        int common = Mathf.Max(0, w.common);
        int wild = Mathf.Max(0, w.wild);
 
        int sum = Mathf.Max(1, core + common + wild);
        int roll = Random.Range(1, sum + 1);
 
        if (roll <= core) return TraitAffinity.Core;
        roll -= core;
        if (roll <= common) return TraitAffinity.Common;
        return TraitAffinity.Wild;
    }
 
    private static string GetTypeKeyFromTowerId(string towerId)
    {
        if (string.IsNullOrEmpty(towerId))
            return "basic";
 
        string lower = towerId.ToLower();
        if (lower.Contains("cannon")) return "cannon";
        if (lower.Contains("magic")) return "magic";
        return "basic";
    }
}
 
Colored by Color Scripter

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

using System.Collections.Generic;
using UnityEngine;
 
public static class TraitProcessor
{
    public static LayerMask MonsterLayerMask = ~0;
 
    public static int ModifyDamage(TowerTraitSO trait, int baseDamage)
    {
        if (trait == null) return baseDamage;
 
        switch (trait.type)
        {
            case TowerTraitType.Critical:
            {
                // value=확률(0~1), range=배율(>=1)
                float chance = Mathf.Clamp01(trait.value);
                float mul = Mathf.Max(1f, trait.range);
 
                if (Random.value < chance)
                    return Mathf.RoundToInt(baseDamage * mul);
 
                return baseDamage;
            }
            default:
                return baseDamage;
        }
    }
    
    public static void ApplyOnHit(TowerTraitSO trait, TowerBase source, MonsterAI target, int hitDamage)
    {
        if (trait == null || target == null) return;
 
        switch (trait.type)
        {
            case TowerTraitType.Slow:
                ApplySlow(trait, target);
                break;
 
            case TowerTraitType.Chain:
                ApplyChain(trait, target, hitDamage);
                break;
 
            case TowerTraitType.Explosion:
                ApplyExplosion(trait, target.transform.position, target, hitDamage);
                break;
        }
    }
 
    private static void ApplySlow(TowerTraitSO trait, MonsterAI target)
    {
        // value=둔화율(0.3이면 30% 느려짐), duration=지속시간
        float slowRate = Mathf.Clamp01(trait.value);
        float dur = Mathf.Max(0.1f, trait.duration);
        target.ApplySlow(slowRate, dur);
    }
 
    private static void ApplyChain(TowerTraitSO trait, MonsterAI firstTarget, int hitDamage)
    {
        // range = 다음 타겟 탐색 반경
        // count = 추가로 맞출 타겟 수
        // value = 연쇄 데미지 비율(원 데미지 대비)
        float searchRadius = Mathf.Max(0.1f, trait.range);
        int jumps = Mathf.Max(0, trait.count);
        float dmgRatio = Mathf.Clamp01(trait.value);
 
        if (jumps <= 0 || dmgRatio <= 0f) return;
 
        int chainDamage = Mathf.Max(1, Mathf.RoundToInt(hitDamage * dmgRatio));
 
        // 이미 맞은 대상은 다시 맞지 않도록
        HashSet<MonsterAI> hitSet = new HashSet<MonsterAI>();
        hitSet.Add(firstTarget);
 
        MonsterAI current = firstTarget;
 
        for (int i = 0; i < jumps; i++)
        {
            MonsterAI next = FindNearestMonster(current.transform.position, searchRadius, hitSet);
            if (next == null) break;
 
            hitSet.Add(next);
            next.TakeDamage(chainDamage);
 
            current = next;
        }
    }
 
    private static void ApplyExplosion(TowerTraitSO trait, Vector3 center, MonsterAI directTarget, int hitDamage)
    {
        // range = 폭발 반경
        // value = 폭발 데미지 비율
        float radius = Mathf.Max(0.1f, trait.range);
        float dmgRatio = Mathf.Clamp01(trait.value);
 
        if (dmgRatio <= 0f) return;
 
        int splashDamage = Mathf.Max(1, Mathf.RoundToInt(hitDamage * dmgRatio));
 
        Collider[] cols = Physics.OverlapSphere(center, radius, MonsterLayerMask);
 
        for (int i = 0; i < cols.Length; i++)
        {
            MonsterAI m = cols[i].GetComponentInParent<MonsterAI>();
            if (m == null) continue;
            
            if (m == directTarget) continue;
 
            m.TakeDamage(splashDamage);
        }
    }
 
    private static MonsterAI FindNearestMonster(Vector3 center, float radius, HashSet<MonsterAI> exclude)
    {
        Collider[] cols = Physics.OverlapSphere(center, radius, MonsterLayerMask);
 
        MonsterAI best = null;
        float bestDistSq = float.PositiveInfinity;
 
        for (int i = 0; i < cols.Length; i++)
        {
            MonsterAI m = cols[i].GetComponentInParent<MonsterAI>();
            if (m == null) continue;
            if (exclude != null && exclude.Contains(m)) continue;
 
            float distSq = (m.transform.position - center).sqrMagnitude;
            if (distSq < bestDistSq)
            {
                bestDistSq = distSq;
                best = m;
            }
        }
 
        return best;
    }
}
 
Colored by Color Scripter

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

private void AssignTraitIfNeeded(TowerBase tower)
    {
        if (tower == null) return;
 
        TowerData d = tower.GetData();
        if (d == null) return;
 
        if (d.grade == TowerGrade.Normal)
        {
            tower.SetTrait(null);
            return;
        }
 
        if (traitDatabase == null)
        {
            Debug.LogWarning("[TowerManager] traitDatabase is null.");
            tower.SetTrait(null);
            return;
        }
 
        TowerTraitSO rolled = traitDatabase.RollTrait(d.towerId, d.grade);
        tower.SetTrait(rolled);
 
        if (rolled != null)
            Debug.Log($"[Trait] {d.towerId}({d.grade}) => {rolled.type} {rolled.tier}");
    }
Colored by Color Scripter

cs

유니티 한글 폰트 추가

지나가던 개발자 — Fri, 9 Jan 2026 03:07:53 +0900

1. 한글이 포함되어 있는 폰트 파일을 유니티 프로젝트에 추가한다.

2. Window - TextMeshPro - Font Asset Creator

3. Source Font에 1번에 해당하는 폰트를 넣는다

4. Atlas Resolution을 4096 x 4096으로 설정한다

5. Character Set을 Custom Range로 설정한다

6. Character Sequence에 32-126,44032-55203,12593-12643,8200-9900를 입력

7. Generate Font Atlas 클릭

8. Save 버튼 클릭 -> Save를 안하면 적용이 안되니 꼭 Save를 할 것

[랜덤 타워 디펜스] Day 9 버프/디버프 시스템

지나가던 개발자 — Thu, 8 Jan 2026 07:49:49 +0900

오늘의 목표

증강 시스템 추가
임시 보스 몬스터 추가
버프/디버프 시스템 적용

특정 패턴(보스 잡기)등이 끝난 후 증강을 고를 수 있는 카드를 출력하고 선택하게 하는 기능을 구현하였습니다.

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

using UnityEngine;
 
public class AugmentSystem : MonoBehaviour
{
    [Header("UI")]
    [SerializeField] private AugmentChoiceUI augmentUI;
 
    [Header("Pool")]
    [SerializeField] private AugmentSO[] augmentPool;
 
    public bool IsChoosing { get; private set; }
 
    private readonly AugmentSO[] _offered = new AugmentSO[3];
    private System.Action _onChoiceComplete;
 
    // 누적값 (런 동안 유지)
    private float _towerDamageMul = 1f;
    private float _towerAttackSpeedMul = 1f;
    private float _towerRangeAdd = 0f;
 
    private float _enemySpeedMul = 1f;
    private float _enemyHpMul = 1f;
 
    public float TowerDamageMul => _towerDamageMul;
    public float TowerAttackSpeedMul => _towerAttackSpeedMul;
    public float TowerRangeAdd => _towerRangeAdd;
 
    public float EnemySpeedMul => _enemySpeedMul;
    public float EnemyHpMul => _enemyHpMul;
    
    public void BeginChoice(System.Action onChoiceComplete)
    {
        if (IsChoosing)
            return;
 
        if (augmentUI == null)
        {
            Debug.LogWarning("[AugmentSystem] augmentUI is null. Skip choice.");
            onChoiceComplete?.Invoke();
            return;
        }
 
        IsChoosing = true;
        _onChoiceComplete = onChoiceComplete;
 
        RollOptions(_offered);
 
        Time.timeScale = 0f;
        augmentUI.Show(_offered, OnPicked);
    }
 
    private void OnPicked(AugmentSO picked)
    {
        if (!IsChoosing)
            return;
 
        if (picked != null)
        {
            ApplyAugment(picked);
            RefreshAllTowers();
        }
 
        if (augmentUI != null)
            augmentUI.Hide();
 
        Time.timeScale = 1f;
 
        IsChoosing = false;
 
        var cb = _onChoiceComplete;
        _onChoiceComplete = null;
        cb?.Invoke();
    }
    
    private void RefreshAllTowers()
    {
        TowerBase[] towers = FindObjectsOfType<TowerBase>();
        for (int i = 0; i < towers.Length; i++)
        {
            if (towers[i] != null)
                towers[i].RefreshStats();
        }
    }
 
    private void RollOptions(AugmentSO[] outArr)
    {
        for (int i = 0; i < outArr.Length; i++)
            outArr[i] = null;
 
        if (augmentPool == null || augmentPool.Length == 0)
            return;
 
        int filled = 0;
        int safety = 0;
 
        while (filled < outArr.Length && safety < 200)
        {
            safety++;
            AugmentSO pick = augmentPool[Random.Range(0, augmentPool.Length)];
            if (pick == null) continue;
 
            bool dup = false;
            for (int j = 0; j < filled; j++)
            {
                if (outArr[j] == pick) { dup = true; break; }
            }
            if (dup) continue;
 
            outArr[filled] = pick;
            filled++;
        }
    }
 
    private void ApplyAugment(AugmentSO a)
    {
        if (a == null) return;
 
        // 타워 버프
        if (a.target == AugmentTarget.Tower)
        {
            switch (a.type)
            {
                case AugmentType.TowerDamageMul:
                    _towerDamageMul *= a.value;
                    break;
 
                case AugmentType.TowerAttackSpeedMul:
                    _towerAttackSpeedMul *= a.value;
                    break;
 
                case AugmentType.TowerRangeAdd:
                    _towerRangeAdd += a.value;
                    break;
            }
            return;
        }
 
        // 적 디버프
        if (a.target == AugmentTarget.Enemy)
        {
            switch (a.type)
            {
                case AugmentType.EnemySpeedMul:
                    _enemySpeedMul *= a.value;
                    break;
 
                case AugmentType.EnemyHpMul:
                    _enemyHpMul *= a.value;
                    break;
            }
        }
    }
}
 
Colored by Color Scripter

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

using UnityEngine;
 
public enum AugmentTarget
{
    Tower,
    Enemy
}
 
public enum AugmentType
{
    // Tower buffs
    TowerDamageMul,
    TowerAttackSpeedMul,
    TowerRangeAdd,
 
    // Enemy debuffs
    EnemySpeedMul,
    EnemyHpMul
}
 
[CreateAssetMenu(menuName = "RTD/Augment/Augment", fileName = "Augment_")]
public class AugmentSO : ScriptableObject
{
    public string augmentId;
    public string title;
    [TextArea] public string desc;
 
    public AugmentTarget target;
    public AugmentType type;
 
    public float value = 1f;
}
Colored by Color Scripter

cs



 

선택 된 증강에 따라 타워 혹은 몬스터들에게 버프/디버프 값을 적용합니다.

선택 된 증강에 해당하는 값을 AugmentSystem에 누적하여 저장하고

GameManager를 통하여 타워와 몬스터들에게 적용합니다.

[랜덤 타워 디펜스] Day 8 몬스터 Wave별 추가 스탯 적용

지나가던 개발자 — Fri, 2 Jan 2026 22:27:24 +0900

오늘의 목표

몬스터 웨이브 별 추가 속성(스탯) 적용
웨이브 증가 기능 추가 구현

몬스터에 스탯을 적용하기 위한 클래스 추가 후 몬스터 스포너에서 생성을 하는 시점에 몬스터의

ApplyWaveModifiers

함수를 호출하여 스탯을 적용시킵니다.

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

using System.Collections.Generic;
using UnityEngine;
 
public static class WaveModifierRoller
{
    private enum ModType
    {
        SpeedUp,
        Tanky,
        Shield
    }
 
    private struct WeightedMod
    {
        public ModType type;
        public int weight;
        public WeightedMod(ModType t, int w) { type = t; weight = w; }
    }
 
    private static readonly Dictionary<ModType, float> SpeedMul = new Dictionary<ModType, float>
    {
        { ModType.SpeedUp, 1.25f }
    };
 
    private static readonly Dictionary<ModType, float> HpMul = new Dictionary<ModType, float>
    {
        { ModType.Tanky, 1.50f }
    };
 
    private static readonly Dictionary<ModType, int> ShieldHp = new Dictionary<ModType, int>
    {
        { ModType.Shield, 30 }
    };
 
    private static readonly WeightedMod[] Pool =
    {
        new WeightedMod(ModType.SpeedUp, 40),
        new WeightedMod(ModType.Tanky,  35),
        new WeightedMod(ModType.Shield, 25),
    };
 
    public static WaveModifiers Roll(int minCount, int maxCount)
    {
        int count = Random.Range(minCount, maxCount + 1);
 
        // Copy pool to list for no-duplicate draws
        List<WeightedMod> temp = new List<WeightedMod>(Pool);
 
        WaveModifiers result = new WaveModifiers
        {
            speedMul = 1f,
            hpMul = 1f,
            shieldHp = 0,
            label = ""
        };
 
        List<string> labels = new List<string>();
 
        for (int i = 0; i < count; i++)
        {
            if (temp.Count == 0)
                break;
 
            int pickedIndex = PickWeightedIndex(temp);
            ModType picked = temp[pickedIndex].type;
            temp.RemoveAt(pickedIndex);
 
            ApplyOne(ref result, picked, labels);
        }
 
        result.label = labels.Count == 0 ? "None" : string.Join(", ", labels);
        return result;
    }
 
    private static int PickWeightedIndex(List<WeightedMod> list)
    {
        int total = 0;
        for (int i = 0; i < list.Count; i++)
            total += list[i].weight;
 
        int r = Random.Range(0, total);
        int acc = 0;
 
        for (int i = 0; i < list.Count; i++)
        {
            acc += list[i].weight;
            if (r < acc)
                return i;
        }
 
        return list.Count - 1;
    }
 
    private static void ApplyOne(ref WaveModifiers mods, ModType type, List<string> labels)
    {
        switch (type)
        {
            case ModType.SpeedUp:
                mods.speedMul *= SpeedMul[type];
                labels.Add("SpeedUp");
                break;
 
            case ModType.Tanky:
                mods.hpMul *= HpMul[type];
                labels.Add("Tanky");
                break;
 
            case ModType.Shield:
                mods.shieldHp += ShieldHp[type];
                labels.Add("Shield");
                break;
        }
    }
}
 
Colored by Color Scripter

cs

1
2
3
4
5
6
7
8
9
10

using System;
 
[Serializable]
public struct WaveModifiers
{
    public float speedMul;   // 1.25f
    public float hpMul;      // 1.50f
    public int shieldHp;     // +30
    public string label;     // "SpeedUp, Shield"
}
Colored by Color Scripter

cs

게임 매니저에서 다음 스테이지를 호출 할 수 있는 함수를 만들어 호출하는 방식으로 다음 스테이지를 불러옵니다.

1
2
3
4
5
6
7
8
9
10

public void NextWave()
{
    currentWave++;
    if (currentWave > maxWave)
        currentWave = maxWave;
 
    UIManager.Instance.UpdateWave(currentWave, maxWave);
 
    StartWave(currentWave);
}
Colored by Color Scripter

cs

[랜덤 타워 디펜스] Day 7 타워 투사체 및 연출 구현

지나가던 개발자 — Tue, 30 Dec 2025 21:47:57 +0900

오늘의 목표

눈으로 보이는 타워 투사체 구현
타워 생성 시 연출 구현
타워 합성 시 연출 구현

투사체 구현 관련 코드입니다.

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

using UnityEngine;
 
public class Projectile : MonoBehaviour
{
    private Transform _target;
    private MonsterAI _targetMonster;
    private float _speed;
    private int _damage;
    private float _lifeTime;
    private float _lifeTimer;
 
    private ProjectilePool _poolOwner;
    public Projectile PrefabKey { get; private set; }
 
    public void SetPoolOwner(ProjectilePool owner, Projectile prefabKey)
    {
        _poolOwner = owner;
        PrefabKey = prefabKey;
    }
 
    public void Init(MonsterAI target, float speed, int damage, float lifeTime = 3f)
    {
        _targetMonster = target;
        _target = (target != null) ? target.transform : null;
        _speed = speed;
        _damage = damage;
        _lifeTime = lifeTime;
        _lifeTimer = 0f;
    }
 
    private void Update()
    {
        _lifeTimer += Time.deltaTime;
        if (_lifeTimer >= _lifeTime)
        {
            ReleaseOrDestroy();
            return;
        }
 
        if (_target == null)
        {
            ReleaseOrDestroy();
            return;
        }
 
        Vector3 to = _target.position - transform.position;
        float distThisFrame = _speed * Time.deltaTime;
 
        if (to.sqrMagnitude <= distThisFrame * distThisFrame)
        {
            Hit();
            return;
        }
 
        Vector3 dir = to.normalized;
        transform.position += dir * distThisFrame;
        transform.forward = dir;
    }
 
    private void Hit()
    {
        if (_targetMonster != null)
            _targetMonster.TakeDamage(_damage);
 
        ReleaseOrDestroy();
    }
 
    private void ReleaseOrDestroy()
    {
        if (_poolOwner != null && ProjectilePool.Instance != null)
        {
            _poolOwner.Release(this);
            return;
        }
 
        Destroy(gameObject);
    }
}
Colored by Color Scripter

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
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

using UnityEngine;
using UnityEngine.InputSystem;
using Cysharp.Threading.Tasks;
 
public class TowerManager : MonoBehaviour
{
    public static TowerManager Instance { get; private set; }
 
    [Header("Placement")]
    [SerializeField] private Camera mainCamera;
    [SerializeField] private LayerMask tileLayerMask;
    
    [Header("Random Build")]
    [SerializeField] private TowerGrade buildRollGrade = TowerGrade.Normal;
    [SerializeField] private TowerData[] buildPool;
    
    public enum CombineMode
    {
        Exact,
        Random
    }
    
    [Header("Combine")]
    [SerializeField] private CombineMode combineMode = CombineMode.Exact;
    
    private TowerBase _selectedTower;
    private bool _combineBusy;
 
    private void Awake()
    {
        if (Instance != null && Instance != this)
        {
            Destroy(gameObject);
            return;
        }
        Instance = this;
 
        if (mainCamera == null)
        {
            mainCamera = Camera.main;
        }
    }
 
    private void Update()
    {
        if (_combineBusy) 
            return;
        
        if (Mouse.current == null) 
            return;
 
        if (Mouse.current.leftButton.wasPressedThisFrame)
        {
            HandleClick();
        }
        
        if (Keyboard.current != null && Keyboard.current.vKey.wasPressedThisFrame)
        {
            combineMode = (combineMode == CombineMode.Exact) ? CombineMode.Random : CombineMode.Exact;
            Debug.Log($"[CombineMode] {combineMode}");
        }
        
        if (Keyboard.current != null && Keyboard.current.cKey.wasPressedThisFrame)
        {
            if (_combineBusy)
                return;
            
            TryCombineSelectedTowerAsync().Forget();
        }
    }
 
    private void HandleClick()
    {
        Vector2 mousePos = Mouse.current.position.ReadValue();
        Ray ray = mainCamera.ScreenPointToRay(mousePos);
 
        if (Physics.Raycast(ray, out RaycastHit hitTower, 1000f, LayerMask.GetMask("Tower")))
        {
            TowerBase tower = hitTower.collider.GetComponentInParent<TowerBase>();
            if (tower != null)
            {
                SelectTower(tower);
                return;
            }
        }
        
        if (Physics.Raycast(ray, out RaycastHit hitTile, 1000f, tileLayerMask))
        {
            GridTile tile = hitTile.collider.GetComponent<GridTile>();
            if (tile != null)
            {
                OnTileClicked(tile);
                return;
            }
        }
 
        ClearSelection();
    }
    
    private void SelectTower(TowerBase tower)
    {
        if (_selectedTower == tower)
            return;
 
        if (_selectedTower != null)
            _selectedTower.SetSelected(false);
 
        _selectedTower = tower;
        _selectedTower.SetSelected(true);
    }
 
    private void ClearSelection()
    {
        if (_selectedTower != null)
            _selectedTower.SetSelected(false);
 
        _selectedTower = null;
    }
    
    public void OnTileClicked(GridTile tile)
    {
        TryPlaceTower(tile);
    }
 
    private void TryPlaceTower(GridTile tile)
    {
        if (!tile.IsEmpty)
        {
            Debug.Log("설치 불가 타일이거나 이미 타워가 있습니다.");
            return;
        }
 
        if (GameManager.Instance == null)
        {
            Debug.LogError("GameManager 인스턴스가 없습니다.");
            return;
        }
        
        TowerData rolledData = RollBuildTowerData();
        if (rolledData == null)
            return;
 
        if (rolledData.towerPrefab == null)
        {
            Debug.LogError($"[TowerManager] towerPrefab is null in TowerData: {rolledData.name}");
            return;
        }
 
        int cost = rolledData.buildCost;
        
        if (GameManager.Instance.Gold < cost)
        {
            Debug.Log("골드가 부족합니다.");
            return;
        }
        
        Vector3 spawnPos = tile.transform.position;
        GameObject towerObj = Instantiate(rolledData.towerPrefab, spawnPos, Quaternion.identity);
 
        TowerBase tower = towerObj.GetComponent<TowerBase>();
        if (tower == null)
        {
            Debug.LogError("rolledData.towerPrefab에 TowerBase 컴포넌트가 없습니다.");
            Destroy(towerObj);
            return;
        }
        
        tower.SetData(rolledData);
        
        tile.SetTower(tower);
        tower.SetTile(tile);
        GameManager.Instance.AddGold(-cost);
 
        Debug.Log($"[Build] Rolled: {rolledData.towerId} ({rolledData.grade}), cost={cost}");
    }
    
    private TowerData RollBuildTowerData()
    {
        if (buildPool == null || buildPool.Length == 0)
        {
            Debug.LogError("[TowerManager] buildPool is empty. Assign TowerData assets in Inspector.");
            return null;
        }
        
        int safety = 0;
        while (safety < 50)
        {
            int idx = Random.Range(0, buildPool.Length);
            TowerData d = buildPool[idx];
            if (d != null && d.grade == buildRollGrade)
                return d;
 
            safety++;
        }
 
        Debug.LogWarning("[TowerManager] No TowerData matched buildRollGrade. Check buildPool contents.");
        return null;
    }
 
    private TowerData RollMergeResultByGrade(TowerGrade targetGrade)
    {
        if (buildPool == null || buildPool.Length == 0)
        {
            Debug.LogError("[TowerManager] buildPool is empty. Cannot roll merge result.");
            return null;
        }
        
        if (TowerDatabase.Instance != null)
        {
            return TowerDatabase.Instance.GetRandomByGrade(targetGrade);
        }
        
        int safety = 0;
        while (safety < 100)
        {
            int idx = Random.Range(0, buildPool.Length);
            TowerData d = buildPool[idx];
            if (d != null && d.grade == targetGrade)
                return d;
            safety++;
        }
 
        Debug.LogWarning("[TowerManager] No TowerData matched targetGrade for merge result.");
        return null;
    }
    
    private void FindExactTowers(TowerData grade, System.Collections.Generic.List<TowerBase> outList)
    {
        outList.Clear();
 
        TowerBase[] allTowers = FindObjectsOfType<TowerBase>();
        foreach (var t in allTowers)
        {
            TowerData d = t.GetData();
            if (d == null)
                continue;
 
            if (d.towerId == grade.towerId && d.grade == grade.grade)
                outList.Add(t);
        }
    }
    private void FindSameGradeTowers(TowerGrade grade, System.Collections.Generic.List<TowerBase> outList)
    {
        outList.Clear();
 
        TowerBase[] allTowers = FindObjectsOfType<TowerBase>();
        foreach (var t in allTowers)
        {
            TowerData d = t.GetData();
            if (d == null)
                continue;
 
            if (d.grade == grade)
                outList.Add(t);
        }
    }
    
    private async UniTaskVoid TryCombineSelectedTowerAsync()
    {
        if (_combineBusy)
            return;
 
        _combineBusy = true;
        
        try
        {
            if (_selectedTower == null)
            {
                Debug.Log("선택된 타워가 없습니다.");
                return;
            }
            
            TowerData selectedData = _selectedTower.GetData();
            if (selectedData == null)
            {
                Debug.Log("현재 타워 데이터가 없습니다.");
                return;
            }
            
            TowerGrade curGrade = selectedData.grade;
            if (!TowerGradeHelper.TryGetNextGrade(curGrade, out TowerGrade nextGrade))
            {
                Debug.Log("더 이상 합성할 수 없는 등급입니다.");
                return;
            }
            
            if (TowerDatabase.Instance == null)
            {
                Debug.LogError("TowerDatabase 인스턴스가 없습니다.");
                return;
            }
            
            // 1) 후보 수집은 모드에 따라 다름
            var candidates = new System.Collections.Generic.List<TowerBase>();
            
            if (combineMode == CombineMode.Exact)
                FindExactTowers(selectedData, candidates);
            else
                FindSameGradeTowers(curGrade, candidates);
            
            if (candidates.Count < 3)
            {
                if (combineMode == CombineMode.Exact)
                    Debug.Log($"[Exact Combine] 조건 미충족: {selectedData.towerId} ({candidates.Count}/3)");
                else
                    Debug.Log($"[Random Combine] 조건 미충족: grade={curGrade} ({candidates.Count}/3)");
                return;
            }
            
            // 2) 3개 구성(선택 타워 포함 + 나머지 2개)
            var mergeList = new System.Collections.Generic.List<TowerBase>(3);
            mergeList.Add(_selectedTower);
            
            for (int i = 0; i < candidates.Count && mergeList.Count < 3; i++)
            {
                if (candidates[i] == _selectedTower)
                    continue;
            
                mergeList.Add(candidates[i]);
            }
            
            if (mergeList.Count < 3)
            {
                Debug.Log("합성 대상 3개를 구성하지 못했습니다.");
                return;
            }
            
            // 3) 결과 TowerData 결정(모드에 따라 다름)
            TowerData resultData = null;
            
            if (combineMode == CombineMode.Exact)
            {
                string nextTowerId = GetNextTowerId(selectedData.towerId, nextGrade);
                resultData = TowerDatabase.Instance.Get(nextTowerId);
            
                if (resultData == null)
                {
                    Debug.LogError($"다음 TowerData를 찾을 수 없습니다: {nextTowerId}");
                    return;
                }
            }
            else
            {
                resultData = RollMergeResultByGrade(nextGrade);
                if (resultData == null)
                {
                    Debug.LogError($"혼합 합성 결과 TowerData를 뽑지 못했습니다. targetGrade={nextGrade}");
                    return;
                }
            }
            
            if (TowerMergeVFX.Instance == null)
            {
                Debug.LogError("TowerMergeVFX.Instance가 없습니다. 씬에 TowerMergeVFX 오브젝트가 있어야 합니다.");
                return;
            }
            
            Transform[] sources =
            {
                mergeList[0] != null ? mergeList[0].transform : null,
                mergeList[1] != null ? mergeList[1].transform : null,
                mergeList[2] != null ? mergeList[2].transform : null
            };
            
            Vector3 mergePoint = _selectedTower.transform.position;
            
            Vector3 keepScale = _selectedTower.transform.localScale;
            
            await TowerMergeVFX.Instance.PlayMergeAsync(
                sources,
                mergePoint,
                () =>
                {
                    for (int i = 0; i < mergeList.Count; i++)
                    {
                        if (mergeList[i] == null) continue;
                        if (mergeList[i] == _selectedTower) continue;
                        Destroy(mergeList[i].gameObject);
                    }
            
                    if (_selectedTower == null) return;
                    
                    _selectedTower.transform.localScale = keepScale;
            
                    _selectedTower.SetData(resultData);
                    _selectedTower.SetSelected(true);
            
                    _selectedTower.PlaySpawnFeedback();
                }
            );
        }
        finally
        {
            _combineBusy = false;
        }
    }
 
 
    private string GetNextTowerId(string currentId, TowerGrade nextGrade)
    {
        int idx = currentId.LastIndexOf('_');
        if (idx < 0)
            return currentId;
 
        string baseId = currentId.Substring(0, idx);
        return $"{baseId}_{nextGrade.ToString().ToLower()}";
    }
}
 
Colored by Color Scripter

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

using System;
using Cysharp.Threading.Tasks;
using UnityEngine;
 
public class TowerMergeVFX : MonoBehaviour
{
    public static TowerMergeVFX Instance { get; private set; }
 
    [Header("Timing")]
    [SerializeField] private float mergeDuration = 0.22f;
 
    [Header("Motion")]
    [SerializeField] private AnimationCurve moveCurve = AnimationCurve.EaseInOut(0f, 0f, 1f, 1f);
    [SerializeField] private AnimationCurve scaleCurve = AnimationCurve.EaseInOut(0f, 1f, 1f, 0f);
 
    [Header("FX")]
    [SerializeField] private ParticleSystem mergeBurstPrefab;
 
    private void Awake()
    {
        if (Instance != null && Instance != this)
        {
            Destroy(gameObject);
            return;
        }
        Instance = this;
    }
 
    // sources: 합성에 쓰이는 3개 타워(Transform)
    // mergePoint: 빨려 들어갈 위치(대개 중앙 타일 or 결과 타워 생성 위치)
    // afterVfx: 연출이 끝난 직후 실행할 실제 합성 로직(3개 제거 + 결과 생성 등)
    public async UniTask PlayMergeAsync(Transform[] sources, Vector3 mergePoint, Action afterVfx)
    {
        if (sources == null || sources.Length == 0)
        {
            afterVfx?.Invoke();
            return;
        }
 
        float dur = Mathf.Max(0.05f, mergeDuration);
        
        int n = sources.Length;
        Vector3[] startPos = new Vector3[n];
        Vector3[] startScale = new Vector3[n];
 
        for (int i = 0; i < n; i++)
        {
            if (sources[i] == null) continue;
            startPos[i] = sources[i].position;
            startScale[i] = sources[i].localScale;
        }
 
        float t = 0f;
        while (t < dur)
        {
            t += Time.deltaTime;
            float u = Mathf.Clamp01(t / dur);
 
            float mu = (moveCurve != null) ? moveCurve.Evaluate(u) : u;
            float su = (scaleCurve != null) ? scaleCurve.Evaluate(u) : (1f - u);
 
            for (int i = 0; i < n; i++)
            {
                Transform tr = sources[i];
                if (tr == null) continue;
 
                tr.position = Vector3.Lerp(startPos[i], mergePoint, mu);
                tr.localScale = startScale[i] * su;
            }
 
            await UniTask.Yield(PlayerLoopTiming.Update);
        }
        
        afterVfx?.Invoke();
        
        if (mergeBurstPrefab != null)
        {
            Instantiate(mergeBurstPrefab, mergePoint, Quaternion.identity);
        }
    }
}
 
Colored by Color Scripter

cs



 

[랜덤 타워 디펜스] Day 6 타워 랜덤 생성 시스템 구현

지나가던 개발자 — Sat, 27 Dec 2025 22:46:56 +0900

오늘의 목표

랜덤 타워 생성 시스템 구현
1. 같은 등급 같은 종류 타워 3종 합성 시 상위 등급 같은 종류 타워로 변환
2. 같은 등급 다른 종류 타워 3종 합성 시 상위 등급 랜덤 종류 타워로 변환
타워의 등급을 확인 할 수 있도록 외형 구현
1. 타워 상단에 1글자로 타워의 종류를 표현
2. 타워 주위에 링 모양을 배치하여 해당 링 색으로 등급을 표현

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

using UnityEngine;
using System.Collections.Generic;
 
public class TowerDatabase : MonoBehaviour
{
    public static TowerDatabase Instance { get; private set; }
 
    [Header("All Tower Data")]
    [SerializeField] private TowerData[] allTowerData;
 
    private Dictionary<string, TowerData> _table;
 
    private void Awake()
    {
        if (Instance != null && Instance != this)
        {
            Destroy(gameObject);
            return;
        }
        Instance = this;
 
        BuildTable();
    }
 
    private void BuildTable()
    {
        _table = new Dictionary<string, TowerData>();
 
        foreach (var data in allTowerData)
        {
            if (data == null)
                continue;
 
            if (string.IsNullOrEmpty(data.towerId))
            {
                Debug.LogWarning("TowerData has empty towerId", data);
                continue;
            }
 
            if (_table.ContainsKey(data.towerId))
            {
                Debug.LogWarning($"Duplicate towerId detected: {data.towerId}", data);
                continue;
            }
 
            _table.Add(data.towerId, data);
        }
    }
 
    public TowerData Get(string towerId)
    {
        if (string.IsNullOrEmpty(towerId))
            return null;
 
        return _table.TryGetValue(towerId, out var data) ? data : null;
    }
    
    public TowerData GetRandomByGrade(TowerGrade grade)
    {
        if (allTowerData == null || allTowerData.Length == 0)
            return null;
        
        List<TowerData> candidates = new List<TowerData>();
        for (int i = 0; i < allTowerData.Length; i++)
        {
            TowerData d = allTowerData[i];
            if (d == null)
                continue;
 
            if (d.grade == grade)
                candidates.Add(d);
        }
 
        if (candidates.Count == 0)
            return null;
 
        int idx = Random.Range(0, candidates.Count);
        return candidates[idx];
    }
}
Colored by Color Scripter

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
354
355
356
357
358
359
360
361
362

using UnityEngine;
using UnityEngine.InputSystem;
 
public class TowerManager : MonoBehaviour
{
    public static TowerManager Instance { get; private set; }
 
    [Header("Placement")]
    [SerializeField] private Camera mainCamera;
    [SerializeField] private LayerMask tileLayerMask;
    
    [Header("Random Build")]
    [SerializeField] private TowerGrade buildRollGrade = TowerGrade.Normal;
    [SerializeField] private TowerData[] buildPool;
    
    public enum CombineMode
    {
        Exact,
        Random
    }
    
    [Header("Combine")]
    [SerializeField] private CombineMode combineMode = CombineMode.Exact;
    
    private TowerBase _selectedTower;
 
    private void Awake()
    {
        if (Instance != null && Instance != this)
        {
            Destroy(gameObject);
            return;
        }
        Instance = this;
 
        if (mainCamera == null)
        {
            mainCamera = Camera.main;
        }
    }
 
    private void Update()
    {
        if (Mouse.current == null) 
            return;
 
        if (Mouse.current.leftButton.wasPressedThisFrame)
        {
            HandleClick();
        }
        
        if (Keyboard.current != null && Keyboard.current.vKey.wasPressedThisFrame)
        {
            combineMode = (combineMode == CombineMode.Exact) ? CombineMode.Random : CombineMode.Exact;
            Debug.Log($"[CombineMode] {combineMode}");
        }
        
        if (Keyboard.current != null && Keyboard.current.cKey.wasPressedThisFrame)
        {
            TryCombineSelectedTower();
        }
    }
 
    private void HandleClick()
    {
        Vector2 mousePos = Mouse.current.position.ReadValue();
        Ray ray = mainCamera.ScreenPointToRay(mousePos);
 
        if (Physics.Raycast(ray, out RaycastHit hitTower, 1000f, LayerMask.GetMask("Tower")))
        {
            TowerBase tower = hitTower.collider.GetComponentInParent<TowerBase>();
            if (tower != null)
            {
                SelectTower(tower);
                return;
            }
        }
        
        if (Physics.Raycast(ray, out RaycastHit hitTile, 1000f, tileLayerMask))
        {
            GridTile tile = hitTile.collider.GetComponent<GridTile>();
            if (tile != null)
            {
                OnTileClicked(tile);
                return;
            }
        }
 
        ClearSelection();
    }
    
    private void SelectTower(TowerBase tower)
    {
        if (_selectedTower == tower)
            return;
 
        if (_selectedTower != null)
            _selectedTower.SetSelected(false);
 
        _selectedTower = tower;
        _selectedTower.SetSelected(true);
    }
 
    private void ClearSelection()
    {
        if (_selectedTower != null)
            _selectedTower.SetSelected(false);
 
        _selectedTower = null;
    }
    
    public void OnTileClicked(GridTile tile)
    {
        TryPlaceTower(tile);
    }
 
    private void TryPlaceTower(GridTile tile)
    {
        if (!tile.IsEmpty)
        {
            Debug.Log("설치 불가 타일이거나 이미 타워가 있습니다.");
            return;
        }
 
        if (GameManager.Instance == null)
        {
            Debug.LogError("GameManager 인스턴스가 없습니다.");
            return;
        }
        
        TowerData rolledData = RollBuildTowerData();
        if (rolledData == null)
            return;
 
        if (rolledData.towerPrefab == null)
        {
            Debug.LogError($"[TowerManager] towerPrefab is null in TowerData: {rolledData.name}");
            return;
        }
 
        int cost = rolledData.buildCost;
        
        if (GameManager.Instance.Gold < cost)
        {
            Debug.Log("골드가 부족합니다.");
            return;
        }
        
        Vector3 spawnPos = tile.transform.position;
        GameObject towerObj = Instantiate(rolledData.towerPrefab, spawnPos, Quaternion.identity);
 
        TowerBase tower = towerObj.GetComponent<TowerBase>();
        if (tower == null)
        {
            Debug.LogError("rolledData.towerPrefab에 TowerBase 컴포넌트가 없습니다.");
            Destroy(towerObj);
            return;
        }
        
        tower.SetData(rolledData);
        
        tile.SetTower(tower);
        tower.SetTile(tile);
        GameManager.Instance.AddGold(-cost);
 
        Debug.Log($"[Build] Rolled: {rolledData.towerId} ({rolledData.grade}), cost={cost}");
    }
    
    private TowerData RollBuildTowerData()
    {
        if (buildPool == null || buildPool.Length == 0)
        {
            Debug.LogError("[TowerManager] buildPool is empty. Assign TowerData assets in Inspector.");
            return null;
        }
        
        int safety = 0;
        while (safety < 50)
        {
            int idx = Random.Range(0, buildPool.Length);
            TowerData d = buildPool[idx];
            if (d != null && d.grade == buildRollGrade)
                return d;
 
            safety++;
        }
 
        Debug.LogWarning("[TowerManager] No TowerData matched buildRollGrade. Check buildPool contents.");
        return null;
    }
 
    private TowerData RollMergeResultByGrade(TowerGrade targetGrade)
    {
        if (buildPool == null || buildPool.Length == 0)
        {
            Debug.LogError("[TowerManager] buildPool is empty. Cannot roll merge result.");
            return null;
        }
        
        if (TowerDatabase.Instance != null)
        {
            return TowerDatabase.Instance.GetRandomByGrade(targetGrade);
        }
        
        int safety = 0;
        while (safety < 100)
        {
            int idx = Random.Range(0, buildPool.Length);
            TowerData d = buildPool[idx];
            if (d != null && d.grade == targetGrade)
                return d;
            safety++;
        }
 
        Debug.LogWarning("[TowerManager] No TowerData matched targetGrade for merge result.");
        return null;
    }
    
    private void FindExactTowers(TowerData grade, System.Collections.Generic.List<TowerBase> outList)
    {
        outList.Clear();
 
        TowerBase[] allTowers = FindObjectsOfType<TowerBase>();
        foreach (var t in allTowers)
        {
            TowerData d = t.GetData();
            if (d == null)
                continue;
 
            if (d.towerId == grade.towerId && d.grade == grade.grade)
                outList.Add(t);
        }
    }
    private void FindSameGradeTowers(TowerGrade grade, System.Collections.Generic.List<TowerBase> outList)
    {
        outList.Clear();
 
        TowerBase[] allTowers = FindObjectsOfType<TowerBase>();
        foreach (var t in allTowers)
        {
            TowerData d = t.GetData();
            if (d == null)
                continue;
 
            if (d.grade == grade)
                outList.Add(t);
        }
    }
    
    private void TryCombineSelectedTower()
    {
        if (_selectedTower == null)
        {
            Debug.Log("선택된 타워가 없습니다.");
            return;
        }
    
        TowerData selectedData = _selectedTower.GetData();
        if (selectedData == null)
        {
            Debug.Log("현재 타워 데이터가 없습니다.");
            return;
        }
    
        TowerGrade curGrade = selectedData.grade;
        if (!TowerGradeHelper.TryGetNextGrade(curGrade, out TowerGrade nextGrade))
        {
            Debug.Log("더 이상 합성할 수 없는 등급입니다.");
            return;
        }
    
        if (TowerDatabase.Instance == null)
        {
            Debug.LogError("TowerDatabase 인스턴스가 없습니다.");
            return;
        }
    
        // 1) 후보 수집은 모드에 따라 다름
        var candidates = new System.Collections.Generic.List<TowerBase>();
    
        if (combineMode == CombineMode.Exact)
            FindExactTowers(selectedData, candidates);
        else
            FindSameGradeTowers(curGrade, candidates);
    
        if (candidates.Count < 3)
        {
            if (combineMode == CombineMode.Exact)
                Debug.Log($"[Exact Combine] 조건 미충족: {selectedData.towerId} ({candidates.Count}/3)");
            else
                Debug.Log($"[Random Combine] 조건 미충족: grade={curGrade} ({candidates.Count}/3)");
            return;
        }
    
        // 2) 3개 구성(선택 타워 포함 + 나머지 2개)
        var mergeList = new System.Collections.Generic.List<TowerBase>(3);
        mergeList.Add(_selectedTower);
    
        for (int i = 0; i < candidates.Count && mergeList.Count < 3; i++)
        {
            if (candidates[i] == _selectedTower)
                continue;
    
            mergeList.Add(candidates[i]);
        }
    
        if (mergeList.Count < 3)
        {
            Debug.Log("합성 대상 3개를 구성하지 못했습니다.");
            return;
        }
    
        // 3) 결과 TowerData 결정(모드에 따라 다름)
        TowerData resultData = null;
    
        if (combineMode == CombineMode.Exact)
        {
            string nextTowerId = GetNextTowerId(selectedData.towerId, nextGrade);
            resultData = TowerDatabase.Instance.Get(nextTowerId);
    
            if (resultData == null)
            {
                Debug.LogError($"다음 TowerData를 찾을 수 없습니다: {nextTowerId}");
                return;
            }
        }
        else
        {
            resultData = RollMergeResultByGrade(nextGrade);
            if (resultData == null)
            {
                Debug.LogError($"혼합 합성 결과 TowerData를 뽑지 못했습니다. targetGrade={nextGrade}");
                return;
            }
        }
        
        for (int i = 0; i < mergeList.Count; i++)
        {
            if (mergeList[i] == _selectedTower)
                continue;
    
            Destroy(mergeList[i].gameObject);
        }
        
        _selectedTower.SetData(resultData);
        _selectedTower.SetSelected(true);
    
        Debug.Log($"합성 성공: mode={combineMode} ({curGrade}) -> ({nextGrade}) result={resultData.towerId}");
    }
 
 
    private string GetNextTowerId(string currentId, TowerGrade nextGrade)
    {
        int idx = currentId.LastIndexOf('_');
        if (idx < 0)
            return currentId;
 
        string baseId = currentId.Substring(0, idx);
        return $"{baseId}_{nextGrade.ToString().ToLower()}";
    }
}
 
Colored by Color Scripter

cs



 

[랜덤 타워 디펜스] Day 5 타워 데이터 셋팅 및 합성 시스템

지나가던 개발자 — Sun, 21 Dec 2025 22:39:21 +0900

오늘의 목표

타워 데이터 셋팅
타워 합성 시스템 구현

타워 데이터 셋팅을 위한 스크립터블 오브젝트 생성

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

using UnityEngine;
 
[CreateAssetMenu(menuName = "RTD/Tower Data")]
public class TowerData : ScriptableObject
{
    [Header("Identity")]
    public string towerId;
    public TowerGrade grade;
 
    [Header("Stats")]
    public float damage;
    public float attackSpeed;
    public float range;
 
    [Header("Cost")]
    public int buildCost;
 
    [Header("Visual")]
    public GameObject towerPrefab;
    public Color gradeColor;
}
 
Colored by Color Scripter

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

using UnityEngine;
using UnityEngine.InputSystem;
 
public class TowerManager : MonoBehaviour
{
    public static TowerManager Instance { get; private set; }
 
    [Header("Placement")]
    [SerializeField] private Camera mainCamera;
    [SerializeField] private GameObject towerPrefab;
    [SerializeField] private int towerCost = 10;
    [SerializeField] private LayerMask tileLayerMask;
    
    private TowerBase _selectedTower;
 
    private void Awake()
    {
        if (Instance != null && Instance != this)
        {
            Destroy(gameObject);
            return;
        }
        Instance = this;
 
        if (mainCamera == null)
        {
            mainCamera = Camera.main;
        }
    }
 
    private void Update()
    {
        if (Mouse.current == null) 
            return;
 
        if (Mouse.current.leftButton.wasPressedThisFrame)
        {
            HandleClick();
        }
        
        if (Keyboard.current != null && Keyboard.current.cKey.wasPressedThisFrame)
        {
            TryCombineSelectedTower();
        }
    }
 
    private void HandleClick()
    {
        Vector2 mousePos = Mouse.current.position.ReadValue();
        Ray ray = mainCamera.ScreenPointToRay(mousePos);
 
        if (Physics.Raycast(ray, out RaycastHit hitTower, 1000f, LayerMask.GetMask("Tower")))
        {
            TowerBase tower = hitTower.collider.GetComponentInParent<TowerBase>();
            if (tower != null)
            {
                SelectTower(tower);
                return;
            }
        }
        
        if (Physics.Raycast(ray, out RaycastHit hitTile, 1000f, tileLayerMask))
        {
            GridTile tile = hitTile.collider.GetComponent<GridTile>();
            if (tile != null)
            {
                OnTileClicked(tile);
                return;
            }
        }
 
        ClearSelection();
    }
    
    private void SelectTower(TowerBase tower)
    {
        if (_selectedTower == tower)
            return;
 
        if (_selectedTower != null)
            _selectedTower.SetSelected(false);
 
        _selectedTower = tower;
        _selectedTower.SetSelected(true);
    }
 
    private void ClearSelection()
    {
        if (_selectedTower != null)
            _selectedTower.SetSelected(false);
 
        _selectedTower = null;
    }
    
    public void OnTileClicked(GridTile tile)
    {
        TryPlaceTower(tile);
    }
 
    private void TryPlaceTower(GridTile tile)
    {
        if (!tile.IsEmpty)
        {
            Debug.Log("설치 불가 타일이거나 이미 타워가 있습니다.");
            return;
        }
        
        TowerBase prefabTower = towerPrefab != null ? towerPrefab.GetComponent<TowerBase>() : null;
        int cost = towerCost;
 
        if (prefabTower != null)
        {
            TowerData d = prefabTower.GetData(); // TowerBase에 GetData()가 있어야 함
            if (d != null)
                cost = d.buildCost;
        }
 
        if (GameManager.Instance == null)
        {
            Debug.LogError("GameManager 인스턴스가 없습니다.");
            return;
        }
 
        if (GameManager.Instance.Gold < cost)
        {
            Debug.Log("골드가 부족합니다.");
            return;
        }
 
        Vector3 spawnPos = tile.transform.position;
        GameObject towerObj = Instantiate(towerPrefab, spawnPos, Quaternion.identity);
 
        TowerBase tower = towerObj.GetComponent<TowerBase>();
        if (tower == null)
        {
            Debug.LogError("towerPrefab에 Tower 컴포넌트가 없습니다.");
            Destroy(towerObj);
            return;
        }
 
        tile.SetTower(tower);
        GameManager.Instance.AddGold(-cost);
    }
    
    private void FindSameTowers(TowerData 기준, System.Collections.Generic.List<TowerBase> outList)
    {
        outList.Clear();
 
        TowerBase[] allTowers = FindObjectsOfType<TowerBase>();
        foreach (var t in allTowers)
        {
            TowerData d = t.GetData();
            if (d == null)
                continue;
 
            if (d.towerId == 기준.towerId && d.grade == 기준.grade)
            {
                outList.Add(t);
            }
        }
    }
    
    private void TryCombineSelectedTower()
    {
        if (_selectedTower == null)
        {
            Debug.Log("선택된 타워가 없습니다.");
            return;
        }
 
        TowerData currentData = _selectedTower.GetData();
        if (currentData == null)
        {
            Debug.Log("현재 타워 데이터가 없습니다.");
            return;
        }
        
        if (!TowerGradeHelper.TryGetNextGrade(currentData.grade, out TowerGrade nextGrade))
        {
            Debug.Log("더 이상 합성할 수 없는 등급입니다.");
            return;
        }
        
        var sameTowers = new System.Collections.Generic.List<TowerBase>();
        FindSameTowers(currentData, sameTowers);
 
        if (sameTowers.Count < 3)
        {
            Debug.Log($"합성 조건 미충족: {currentData.towerId} ({sameTowers.Count}/3)");
            return;
        }
        
        string nextTowerId = GetNextTowerId(currentData.towerId, nextGrade);
        TowerData nextData = TowerDatabase.Instance.Get(nextTowerId);
        if (nextData == null)
        {
            Debug.LogError($"다음 TowerData를 찾을 수 없습니다: {nextTowerId}");
            return;
        }
        
        int removed = 0;
        for (int i = 0; i < sameTowers.Count && removed < 2; i++)
        {
            if (sameTowers[i] == _selectedTower)
                continue;
 
            Destroy(sameTowers[i].gameObject);
            removed++;
        }
        
        _selectedTower.SetData(nextData);
        _selectedTower.SetSelected(true);
 
        Debug.Log($"합성 성공: {currentData.towerId} → {nextTowerId}");
    }
 
    private string GetNextTowerId(string currentId, TowerGrade nextGrade)
    {
        int idx = currentId.LastIndexOf('_');
        if (idx < 0)
            return currentId;
 
        string baseId = currentId.Substring(0, idx);
        return $"{baseId}_{nextGrade.ToString().ToLower()}";
    }
}
 
Colored by Color Scripter

cs



 

[랜덤 타워 디펜스] Day 4 기초 UI 및 타워 건설

지나가던 개발자 — Fri, 12 Dec 2025 19:53:21 +0900

오늘의 목표

기초 UI 추가 (Gold, Life, Wave)
타워 건설 기능 구현
기본 타워 구현

기초 UI를 만들고 관리하기 위한 UIManager 생성

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

using TMPro;
using UnityEngine;
using UnityEngine.UI;
 
public class UIManager : MonoBehaviour
{
    public static UIManager Instance;
 
    [Header("UI Elements")]
    [SerializeField] private TextMeshProUGUI goldText;
    [SerializeField] private TextMeshProUGUI lifeText;
    [SerializeField] private TextMeshProUGUI waveText;
 
    private void Awake()
    {
        Instance = this;
    }
 
    public void UpdateGold(int value)
    {
        goldText.text = $"Gold : {value}";
    }
 
    public void UpdateLife(int value)
    {
        lifeText.text = $"Life : {value}";
    }
 
    public void UpdateWave(int curr, int max)
    {
        waveText.text = $"Wave : {curr}/{max}";
    }
}
Colored by Color Scripter

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

using UnityEngine;
using UnityEngine.InputSystem;
 
public class TowerManager : MonoBehaviour
{
    public static TowerManager Instance { get; private set; }
 
    [Header("Placement")]
    [SerializeField] private Camera mainCamera;
    [SerializeField] private GameObject towerPrefab;
    [SerializeField] private int towerCost = 10;
    [SerializeField] private LayerMask tileLayerMask;
    
    private TowerBase _selectedTower;
 
    private void Awake()
    {
        if (Instance != null && Instance != this)
        {
            Destroy(gameObject);
            return;
        }
        Instance = this;
 
        if (mainCamera == null)
        {
            mainCamera = Camera.main;
        }
    }
 
    private void Update()
    {
        if (Mouse.current == null) 
            return;
 
        if (Mouse.current.leftButton.wasPressedThisFrame)
        {
            HandleClick();
        }
    }
 
    private void HandleClick()
    {
        Vector2 mousePos = Mouse.current.position.ReadValue();
        Ray ray = mainCamera.ScreenPointToRay(mousePos);
 
        if (Physics.Raycast(ray, out RaycastHit hit, 1000f))
        {
            TowerBase tower = hit.collider.GetComponentInParent<TowerBase>();
            if (tower != null)
            {
                SelectTower(tower);
                return;
            }
            
            GridTile tile = hit.collider.GetComponent<GridTile>();
            if (tile != null)
            {
                OnTileClicked(tile);
                return;
            }
            
            ClearSelection();
        }
        else
        {
            ClearSelection();
        }
    }
    
    private void SelectTower(TowerBase tower)
    {
        if (_selectedTower == tower)
            return;
 
        if (_selectedTower != null)
            _selectedTower.SetSelected(false);
 
        _selectedTower = tower;
        _selectedTower.SetSelected(true);
    }
 
    private void ClearSelection()
    {
        if (_selectedTower != null)
            _selectedTower.SetSelected(false);
 
        _selectedTower = null;
    }
    
    public void OnTileClicked(GridTile tile)
    {
        TryPlaceTower(tile);
    }
 
    private void TryPlaceTower(GridTile tile)
    {
        if (!tile.IsEmpty)
        {
            Debug.Log("설치 불가 타일이거나 이미 타워가 있습니다.");
            return;
        }
 
        if (GameManager.Instance == null)
        {
            Debug.LogError("GameManager 인스턴스가 없습니다.");
            return;
        }
 
        if (GameManager.Instance.Gold < towerCost)
        {
            Debug.Log("골드가 부족합니다.");
            return;
        }
 
        Vector3 spawnPos = tile.transform.position;
        GameObject towerObj = Instantiate(towerPrefab, spawnPos, Quaternion.identity);
 
        TowerBase tower = towerObj.GetComponent<TowerBase>();
        if (tower == null)
        {
            Debug.LogError("towerPrefab에 Tower 컴포넌트가 없습니다.");
            Destroy(towerObj);
            return;
        }
 
        tile.SetTower(tower);
        GameManager.Instance.AddGold(-towerCost);
    }
}
 
Colored by Color Scripter

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

using UnityEngine;
 
public abstract class TowerBase : MonoBehaviour
{
    [Header("Stats")]
    public float range = 3f;
    public float attackInterval = 1f;
    public int damage = 5;
 
    [Header("Visual")]
    [SerializeField] private GameObject rangeVisual;
 
    protected float _attackTimer;
 
    protected virtual void Start()
    {
        if (rangeVisual != null)
        {
            Vector3 s = rangeVisual.transform.localScale;
            rangeVisual.transform.localScale = new Vector3(range * 2f, s.y, range * 2f);
            rangeVisual.SetActive(false);
        }
    }
 
    protected virtual void Update()
    {
        _attackTimer += Time.deltaTime;
 
        if (_attackTimer >= attackInterval)
        {
            _attackTimer = 0f;
            Attack();
        }
    }
    
    protected abstract void Attack();
    
    protected virtual MonsterAI FindTarget()
    {
        MonsterAI[] monsters = FindObjectsOfType<MonsterAI>();
 
        MonsterAI closest = null;
        float closestDist = Mathf.Infinity;
        Vector3 myPos = transform.position;
 
        foreach (var m in monsters)
        {
            if (!m.isActiveAndEnabled) continue;
 
            float dist = Vector3.Distance(myPos, m.transform.position);
            if (dist <= range && dist < closestDist)
            {
                closest = m;
                closestDist = dist;
            }
        }
 
        return closest;
    }
    
    public void SetSelected(bool selected)
    {
        if (rangeVisual != null)
            rangeVisual.SetActive(selected);
    }
    
    private void OnDrawGizmosSelected()
    {
        Gizmos.color = Color.red;
        Gizmos.DrawWireSphere(transform.position, range);
    }
}
Colored by Color Scripter

cs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

using UnityEngine;
 
public class BasicTower : TowerBase
{
    // 기본 타워는 단일 타겟에게 데미지를 주는 형태
    protected override void Attack()
    {
        MonsterAI target = FindTarget();
        
        if (target != null)
        {
            target.TakeDamage(damage);
        }
    }
}
Colored by Color Scripter

cs

타워 건설 시 Gold 사용
이동 경로에 건설 불가
타워 공격 범위 시각화
타워 공격
몬스터 제거 시 Gold 증가

를 구현하였습니다.

[랜덤 타워 디펜스] Day 3 Waypoint 생성 및 몬스터 이동 구현

지나가던 개발자 — Thu, 11 Dec 2025 23:48:56 +0900

오늘의 구현 목표

Path 타일 기반으로 Waypoint 생성
몬스터 이동 시스템 1차 구현

기존 GridManager에 Waypoint를 만들어주는 함수 구현
만들어 둔 PathTile을 순서대로 가져와서 이동가능한 Waypoint로 구현

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

using UnityEngine;
using System.Collections.Generic;
 
public class GridManager : MonoBehaviour
{
    public static GridManager Instance { get; private set; }
 
    public int width = 16;
    public int height = 12;
    public float cellSize = 1f;
 
    public GameObject buildablePrefab;
    public GameObject pathPrefab;
 
    public Transform tileParent;
 
    [Header("Path Tiles")] public List<Vector2Int> pathTiles = new List<Vector2Int>();
 
    [Header("Waypoints")] public List<Transform> waypoints = new List<Transform>();
 
    private GridTile[,] tiles;
 
    private void Awake()
    {
        if (Instance != null && Instance != this)
        {
            Debug.LogWarning("여러 개의 GridManager가 씬에 있습니다.");
        }
 
        Instance = this;
 
        GenerateGrid();
        GenerateWaypoints();
    }
 
    private void GenerateGrid()
    {
        tiles = new GridTile[width, height];
 
        for (int x = 0; x < width; x++)
        {
            for (int y = 0; y < height; y++)
            {
                Vector2Int pos = new Vector2Int(x, y);
                bool isPath = pathTiles.Contains(pos);
 
                GameObject prefab = isPath ? pathPrefab : buildablePrefab;
                TileType tileType = isPath ? TileType.Path : TileType.Buildable;
 
                CreateTile(pos, prefab, tileType);
            }
        }
    }
 
    private void CreateTile(Vector2Int gridPos, GameObject prefab, TileType tileType)
    {
        Vector3 worldPos = new Vector3(gridPos.x * cellSize, 0f, gridPos.y * cellSize);
 
        GameObject obj = Instantiate(prefab, worldPos, Quaternion.identity, tileParent);
 
        GridTile tile = obj.GetComponent<GridTile>();
        if (tile == null)
        {
            tile = obj.AddComponent<GridTile>();
        }
 
        tile.Init(gridPos, tileType);
 
        tiles[gridPos.x, gridPos.y] = tile;
    }
 
    private void GenerateWaypoints()
    {
        waypoints.Clear();
 
        if (tiles == null)
        {
            Debug.LogError("타일이 아직 생성되지 않았습니다. GenerateGrid 이후에 호출해야 합니다.");
            return;
        }
 
        foreach (Vector2Int gridPos in pathTiles)
        {
            if (gridPos.x < 0 || gridPos.x >= width || gridPos.y < 0 || gridPos.y >= height)
            {
                Debug.LogWarning($"PathTile {gridPos} 좌표가 Grid 범위를 벗어났습니다.");
                continue;
            }
 
            GridTile tile = tiles[gridPos.x, gridPos.y];
            if (tile == null)
            {
                Debug.LogWarning($"PathTile {gridPos} 위치에 타일이 없습니다.");
                continue;
            }
 
            waypoints.Add(tile.transform);
        }
 
        if (waypoints.Count == 0)
        {
            Debug.LogWarning("Waypoint가 하나도 생성되지 않았습니다. pathTiles를 확인하세요.");
        }
    }
 
    public Transform GetWaypoint(int index)
    {
        if (index < 0 || index >= waypoints.Count)
            return null;
 
        return waypoints[index];
    }
    
    public int WaypointCount => waypoints.Count;
    
    #if UNITY_EDITOR
        private void OnDrawGizmosSelected()
        {
            if (pathTiles == null || pathTiles.Count == 0)
                return;
    
            Gizmos.color = Color.yellow;
    
            Vector3 prevPos = Vector3.zero;
            bool hasPrev = false;
    
            foreach (Vector2Int gridPos in pathTiles)
            {
                Vector3 worldPos = new Vector3(gridPos.x * cellSize, 0f, gridPos.y * cellSize);
                Vector3 drawPos = worldPos + Vector3.up * 0.3f;
    
                Gizmos.DrawSphere(drawPos, 0.1f);
    
                if (hasPrev)
                {
                    Gizmos.DrawLine(prevPos, drawPos);
                }
    
                prevPos = drawPos;
                hasPrev = true;
            }
        }
    #endif
}
Colored by Color Scripter

cs

몬스터가 Waypoint를 따라 이동하도록 구현

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

using UnityEngine;
 
public class MonsterAI : MonoBehaviour
{
    [Header("Move Settings")]
    [SerializeField] private float moveSpeed = 2f;
    [SerializeField] private float stoppingDistance = 0.05f;
 
    private int _currentIndex = 0;
    private Transform _currentTarget;
 
    private void Start()
    {
        if (GridManager.Instance == null)
        {
            Debug.LogError("GridManager 인스턴스가 없습니다.");
            enabled = false;
            return;
        }
 
        if (GridManager.Instance.WaypointCount == 0)
        {
            Debug.LogError("Waypoint가 하나도 없습니다. pathTiles를 설정했는지 확인하세요.");
            enabled = false;
            return;
        }
        
        Transform startPoint = GridManager.Instance.GetWaypoint(0);
        transform.position = startPoint.position;
        
        _currentIndex = 1;
        SetNextTarget();
    }
 
    private void Update()
    {
        MoveAlongPath();
    }
 
    private void MoveAlongPath()
    {
        if (_currentTarget == null)
            return;
 
        Vector3 targetPos = _currentTarget.position;
        Vector3 dir = targetPos - transform.position;
        
        dir.y = 0f;
 
        float distanceToTarget = dir.magnitude;
        float moveThisFrame = moveSpeed * Time.deltaTime;
        
        if (distanceToTarget <= moveThisFrame + stoppingDistance)
        {
            _currentIndex++;
            SetNextTarget();
            return;
        }
 
        Vector3 move = dir.normalized * moveThisFrame;
        transform.position += move;
        
        if (dir.sqrMagnitude > 0.0001f)
        {
            transform.rotation = Quaternion.LookRotation(dir);
        }
    }
 
    private void SetNextTarget()
    {
        if (_currentIndex >= GridManager.Instance.WaypointCount)
        {
            ReachGoal();
            return;
        }
 
        _currentTarget = GridManager.Instance.GetWaypoint(_currentIndex);
    }
 
    private void ReachGoal()
    {
        Destroy(gameObject);
    }
}
 
Colored by Color Scripter

cs

결과물