[4Idle - Gazzlers] Enemy 를 GameScene에 생성 - wave 1 초기 생성

- 현재 GameScene에서는 적이 없으므로 적을 생성시켜 준다.

https://made-myblog.tistory.com/62

Gazzlers 개발일지 - Enemy생성

- 팀원의 포스팅을 바탕으로 enemy를 생성해보았다.

- Enemy는 총 세종류로 각각 Enemy1, Enemy2, Enemy3 스크립트를 갖고있으며 이 스크립트들은 EnemyMove 스크립트를 상속받는다.

main 수정 - 변수 생성 및 start함수 수정

-테스트용 Main을 팀원분의 코드를 기반으로 수정하였다.

 

 

 

main 수정 - 메서드 추가

-먼저 하나의 Enemy만 생성하도록 하였다.

-start에서 코루틴 함수를 호출한다.

-빈 오브젝트로 target 1, 2, 3을 생성하고, 1과 2의 x값을 10,-10으로 바꾸어준 후 main에 할당한다.

-Enemy1에 새로 부착한 스크립트를 갖도록 한 뒤 프리팹으로 만든 후 enemyPool의 Enemy Prefab에 할당해보았다.

-철도의 콜라이더를 꺼주고 camMove의 속도를 높인 후 한 종류의 몬스터가 잘 생성되는지 확인해보았다.

한 종류의 적 생성 결과

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System.IO;
using System;
namespace hyw
{
    public class EnemyPool : MonoBehaviour
    {
        public static EnemyPool instance;

        [SerializeField] private GameObject enemyPrefab;
        [SerializeField] private EnemyGenerator enemyGenerator;
        private List<Enemy1> enemyPool = new List<Enemy1>();


        void Awake()
        {
            instance = this;

            
        }

       
        private void Start()
        {
            this.GenerateEnemy();
        }

        private void GenerateEnemy()
        {
            for (int i = 0; i < 2; i++)
            {
                GameObject go = Instantiate(enemyPrefab, this.transform);
                go.SetActive(false);
                enemyPool.Add(go.GetComponent<Enemy1>());
                //  enemyPool.Add(go.GetComponent<EnemyController>());
               // this.enemyPool.Add(this.enemyGenerator.Generate(GameEnums.eEnemyType.Enemy1, this.transform.position));

            }
        }

        public Enemy1 EnableEnemy()
        {
            Enemy1 result = null;
           
            for (int i = 0; i < enemyPool.Count; i++)
            {
                if (enemyPool[i].gameObject.activeSelf == false)
                {
                    result = enemyPool[i];
                    //result.gameObject.SetActive(true);
                    result.transform.SetParent(null);
                    break;
                }
            }
            return result;

            
        }

        public void DisableEnemy(Enemy1 enemy)
        {
            enemy.gameObject.SetActive(false);
            enemy.transform.SetParent(this.transform);
        }
    
    }
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using TMPro;


namespace hyw { 
    public class TestGenerateEnemyMain : MonoBehaviour
    {
        //[SerializeField] EnemyGenerator enemyGen;
        [SerializeField] Canvas worldCanvas;
        [SerializeField] Canvas rightHandCanvas;
        [SerializeField] TextMeshProUGUI guideText;
        [SerializeField] GameObject uiHPBarPrefab;
        [SerializeField] GameObject uiDamageTextPrefab;
        [SerializeField] GameObject uiEnergyCellPrefab;
        [SerializeField] GameObject gunEnergyCellGo;
        [SerializeField] EnergyCellController energyCellForCharge;
        [SerializeField] RightHandController rightHand;
        [SerializeField] Transform uiEnergyCellTransform;
        [SerializeField] Transform worldUITransform;

        public bool isFirstHP = false;

        private GameObject hpBarUIGo;
        private GameObject damageTextUIGo;
        private GameObject energyTextUIGo;

        // private EnemyGenerator enemyGenerator;

        private string currGunType;
        private int currGunDamage;
        private int currGunEnergy;
        private int currGunMaxEnergy;
        private List<EnemyController> enemyList = new List<EnemyController>();
        private List<GameObject> enemyHpBarPools = new List<GameObject>();
        private List<GameObject> activeHPBar = new List<GameObject>();


        //----------------------------------SJY Map Main-----------------------------------------------------------
        [SerializeField] private MapController mapController;
        [SerializeField] private CamMove camMove;


        //----------------------------------SJY Enemy1Move Main-----------------------------------------------------------
        [SerializeField] private Transform[] arrTargetPos;
        private List<Enemy1> listEnemys = new List<Enemy1>(); 
        private List<bool> isTargeted = new List<bool>();
         private int EnemyCount = 2;
    private void Awake()
        {
            // this.enemyGenerator = enemyGen;
            //----------------------------------Generate Enemy-----------------------------------------------------------
            //  this.enemyList.Add(this.enemyGenerator.Generate(GameEnums.eEnemyType.FrankenStein, new Vector3(-0.09f, -1.35f, 4.3f)));
            //   this.enemyList.Add(this.enemyGenerator.Generate(GameEnums.eEnemyType.FrankenStein, new Vector3(2.41f, -1.35f, 4.3f)));
        }
        // Start is called before the first frame update
        void Start()
        {
            this.guideText.gameObject.SetActive(false);
            this.worldCanvas.transform.SetParent(this.worldUITransform);
            this.worldCanvas.transform.localPosition = Vector3.zero;
            this.worldCanvas.transform.localRotation = Quaternion.identity;

            DataManager.Instance.LoadPlayerDatas();
            DataManager.Instance.LoadGunrDatas();
            DataManager.Instance.LoadEnemyDatas();

            List<PlayerData> playerData = DataManager.Instance.GetPlayerDatas();
            List<GunData> gunData = DataManager.Instance.GetGunDatas();
            List<EnemyData> enemyData = DataManager.Instance.GetEnemyDatas();

            var playerGunId = playerData[0].currGunId;

            // Debug.Log(playerGunId);
            for (int i = 0; i < gunData.Count; i++)
            {
                if (playerGunId == gunData[i].gunId)
                {//Find player's current gun's Data on GunData 
                    Debug.Log(gunData[i].gunType);
                    this.currGunType = gunData[i].gunType;
                    this.currGunDamage = gunData[i].gunDamage;
                    this.currGunEnergy = gunData[i].gunEnergyCell;
                    this.currGunMaxEnergy = gunData[i].gunEnergyCell;
                    //gunData[i].gunDamage;
                }
            }

            this.enemyHpBarPool();

            for (int i = 0; i < this.enemyList.Count; i++)
            {
                this.activeHPBar.Add(this.CreateHpBar(this.enemyList[i].hpBarPoint.position));

                for (int j = 0; j < enemyData.Count; j++)
                {
                    if (this.enemyList[j].name == enemyData[j].enemyType)
                    {
                        //Debug.Log(enemyData[j].enemyType);
                        var slider = this.activeHPBar[i].GetComponent<Slider>();
                        slider.maxValue = enemyData[j].enemyHp;
                        Debug.Log(slider.maxValue);
                        slider.value = slider.maxValue;//reset slider value as full state
                    }
                }
            }



            this.damageTextUIGo = Instantiate(this.uiDamageTextPrefab, this.worldCanvas.transform);
            this.damageTextUIGo.SetActive(false);

            this.energyTextUIGo = Instantiate(this.uiEnergyCellPrefab, this.rightHandCanvas.transform);
            // this.energyTextUIGo.transform.SetParent(this.uiEnergyCellTransform);
            this.rightHandCanvas.transform.SetParent(this.uiEnergyCellTransform);
            this.rightHandCanvas.transform.localPosition = Vector3.zero;
            this.rightHandCanvas.transform.localRotation = Quaternion.identity;
            // this.energyTextUIGo.GetComponent<TextMeshProUGUI>().text = string.Format("{0}", this.currGunEnergy);

            this.rightHand.OnHitEnemy = (hitPos, hitObject) =>
            {
            // Debug.LogFormat("Hit Enemy! Point: {0}", hitPos);
            StartCoroutine(this.CoShowDamageText(hitPos));

                for (int i = 0; i < this.enemyList.Count; i++)
                {
                    if (hitObject == this.enemyList[i].gameObject)
                    {
                        Debug.LogFormat("Object: {0} , Damage : {1}", i, currGunDamage);
                        this.activeHPBar[i].GetComponent<Slider>().value -= currGunDamage;
                    }
                }

            };

            this.rightHand.OnShoot = () =>
            {
                this.currGunEnergy -= 1;
            };

            this.energyCellForCharge.OnCharge = () =>
            {


                this.currGunEnergy = this.currGunMaxEnergy;//reset energyCell as full state
                this.gunEnergyCellGo.SetActive(true);
                StartCoroutine(this.CoResetEnergyCellItem());

            };
            //----------------------------------SJY Map Main-----------------------------------------------------------

            Vector3 camPos = Vector3.zero;
            this.mapController.onInformInitPos = (pos) =>
            {
                camPos = pos;
            };
            this.mapController.onInformRoute = (rail) =>
            {
                this.camMove.UpdateRoute(rail.GetRoute());
            };
            this.mapController.Init();
            this.camMove.Init(camPos);

          //----------------------------------SJY Enemy1Move Main-----------------------------------------------------------
         // EnemyPool.instance.LoadAll();

        for (int i = 0; i < arrTargetPos.Length; i++)
        {
            isTargeted.Add(false);
        }
        this.StartCoroutine(this.CoStartSpawnEnemy());
    }
        private IEnumerator CoResetEnergyCellItem()
        {
            this.energyCellForCharge.gameObject.SetActive(false);
            yield return new WaitForSeconds(2f);
            // Debug.Log("Rest Energy Item");
            this.energyCellForCharge.transform.SetParent(this.energyCellForCharge.energyCellOriginalPoint);
            this.energyCellForCharge.transform.localPosition = Vector3.zero;
            this.energyCellForCharge.transform.localRotation = Quaternion.identity;
            this.energyCellForCharge.gameObject.SetActive(true);
        }
        private void enemyHpBarPool()
        {
            for (int i = 0; i < this.enemyList.Count; i++)
            {
                GameObject go = Instantiate(this.uiHPBarPrefab, this.worldCanvas.transform);
                go.SetActive(false);
                this.enemyHpBarPools.Add(go);
            }
        }
        private GameObject GetEnemyHpBarInPool()
        {
            foreach (GameObject hpBar in enemyHpBarPools)
            {
                if (hpBar.activeSelf == false)
                {
                    return hpBar;
                }
            }
            return null;
        }
        private GameObject CreateHpBar(Vector3 position)
        {
            GameObject go = this.GetEnemyHpBarInPool();
            go.transform.position = position;
            go.SetActive(true);
            return go;
        }
       
        private IEnumerator CoShowDamageText(Vector3 UIPos)
        {
            this.damageTextUIGo.transform.position = UIPos;
            this.damageTextUIGo.SetActive(true);

            var text = this.damageTextUIGo.GetComponent<TextMeshProUGUI>();
            text.text = string.Format("{0}", this.currGunDamage);
            yield return new WaitForSeconds(0.3f);
            this.damageTextUIGo.SetActive(false);
        }
        // Update is called once per frame
        void Update()
        {
            for (int i = 0; i < this.enemyList.Count; i++)
            {
                this.activeHPBar[i].transform.position = this.enemyList[i].hpBarPoint.position;


            }

            //this.energyTextUIGo.transform.position = this.uiEnergyCellTransform.position;
            this.energyTextUIGo.GetComponent<TextMeshProUGUI>().text = string.Format("{0}", this.currGunEnergy);

            this.rightHand.isAttack = true;
            if (this.currGunEnergy <= 0)
            {
                this.gunEnergyCellGo.SetActive(false);
                this.rightHand.isAttack = false;
            }

            if (isFirstHP)
            {
                this.guideText.gameObject.SetActive(true);
                this.guideText.text = "물약을 잡아 HP를 회복하세요.";
            }
        }

    //Methods
    //----------------------------------SJY Enemy1Move Main-----------------------------------------------------------

    private IEnumerator CoStartSpawnEnemy()
    {
            for (int i = 0; i < this.EnemyCount; i++)
            {
                yield return new WaitForSeconds(5f);
                //GameObject go = EnemyPool.instance.EnableEnemy().gameObject;
                //Enemy1 enemy = go.GetComponent<Enemy1>();
                Enemy1 enemy = EnemyPool.instance.EnableEnemy();
                this.listEnemys.Add(enemy);
                enemy.onChangeTarget = (idx) =>
                {
                    Debug.Log("target change!");
                    Debug.LogFormat("<color=yellow>{0} preTargetPos: {1}</color>", enemy.name, arrTargetPos[idx]);
                    this.SetTargetPos(enemy);
                    this.isTargeted[idx] = false;
                };
                this.SpawnEnemy(enemy);
                this.SetTargetPos(enemy);
            }
        }

        private void SpawnEnemy(Enemy1 enemy)
        {
            float x = Random.Range(-3f, 3f);
            float z = Random.Range(10f, 15f);
            while (true)
            {
                int layer = 1 << 3 | 1 << 6 | 1 << 7;
                //Debug.Log(layer.ToBinaryString());
                //Debug.Log(enemy.gameObject.layer.ToString());
                Collider[] hit = new Collider[10];
                int num = Physics.OverlapSphereNonAlloc(this.arrTargetPos[2].position + Vector3.right * x
                    + Vector3.forward * z, 2f, hit, layer);
                if (num == 0)
                    break;
                x = Random.Range(-3f, 3f);
                z = Random.Range(10f, 20f);
            }

            Vector3 pos = this.arrTargetPos[2].position + Vector3.right * x + Vector3.forward * z;
            enemy.Init(pos);
        }

        private void SetTargetPos(Enemy1 enemy)
        {
            List<int> listIndex = new List<int>();
            for (int i = 0; i < this.isTargeted.Count; i++)
            {
                if (!isTargeted[i])
                {
                    listIndex.Add(i);
                }
            }
            int rand = Random.Range(0, listIndex.Count);
            int idx = listIndex[rand];
            enemy.UpdateTargetPos(idx, this.arrTargetPos[idx]);
            this.isTargeted[idx] = true;
            Debug.LogFormat("<color=magenta>{0} curTargetPos: {1}</color>", enemy.name, arrTargetPos[idx]);
        }
    }

}