유니티

이벤트를 연쇄 동작을 이끌어내는 사건입니다. 이벤트 자체는 어떤 일을 실행하지 않지만 이벤트가 발생하면 이벤트를 구독하는 처리들이 연쇄적으로 실행됩니다.

C#에서 이벤트를 구현하는 대표적인 방법은 델리게이트를 클래스 외부로 공하는 겁니다. 외부로 공개된 델리게이트는 클래스 외부의 메서드가 등록될 수 있는 명단이자 이벤트가 됩니다. 그리고 이벤트가 발동하면 이벤트에 등록된 메서드들이 모두 실행됩니다.

여기서 이벤트들을 듣고 있다가 실행되는 메서드들을 이벤트리스너라고 합니다. 이벤트 리스너를 이벤트에 등록하는 것을 이벤트를 구독한다고 합니다.

델리게이트 타입의 변수는 event 키워드를 붙여 선언할 수 있습니다. 어떤 델리게이트 변수를 event로 선언하면 클래스 외부에서는 해당 델리게이트를 실행할 수 없게 됩니다.

event를 사용하면 이벤트를 소유하지 않는 측에서 멋대로 이벤트를 발동하는 것을 막을 수 있습니다.

​

1. OnEnable()
   1. LivingEntity의 OnEnable()메서드는 생명체의 상태를 리셋합니다. 사방상태를 flase()로 체력을 시작 체력값으로 초기화합니다. OnEnable()메서드는 LivingEntity가 활성화될 때 실행됩니다.
   2. OnEnable()은 virtual로 선언된 가상메서드이므로 자식 클래스에서 확장할 수 있습니다. 다만 자식 클래스에서 OnEnable()메서드를 접근 가능해야 확장 가능하므로 접근자를 private가 아닌 protected를 사용했습니다.
2. OnDamage()
   1. 외부에서 LivingEntity()를 공격하는데 사용됩니다.
   2. 입력으로 받은 Damage만큼 health를 깎습니다. 0보다 작은 경우 Die()를 실행합니다.
   3. virtual로 선언되었으므로 자식 클래스에서 확장할 수 있습니다.
3. RestoreHealth()
   1. 체력을 회복하는 메서드입니다.
   2. 죽지 않았다면 입력받은 회복량 newHealth만큼 현재 health를 증가 시킵니다.
   3. 가상메서드이므로 자식클래스에서 확장할 수 있습니다.
4. Die()
   1. LivingEntity의 죽음을 구현
   2. onDeath() 이벤트를 발동하여 이벤트에 등록된 메서드를 실행합니다.

​

LivingEntity 스크립트 전체코드

using System;
using UnityEngine;

// 생명체로서 동작할 게임 오브젝트들을 위한 뼈대를 제공
// 체력, 데미지 받아들이기, 사망 기능, 사망 이벤트를 제공
public class LivingEntity : MonoBehaviour, IDamageable {
    public float startingHealth = 100f; // 시작 체력
    public float health { get; protected set; } // 현재 체력
    public bool dead { get; protected set; } // 사망 상태
    public event Action onDeath; // 사망시 발동할 이벤트

    // 생명체가 활성화될때 상태를 리셋
    protected virtual void OnEnable() {
        dead = false; // 사망하지 않은 상태로 시작       
        health = startingHealth; // 체력을 시작 체력으로 초기화
    }

    // 데미지를 입는 기능
    public virtual void OnDamage(float damage, Vector3 hitPoint,
        Vector3 hitNormal) {
        // 데미지만큼 체력 감소
        health -= damage;

        // 체력이 0 이하 && 아직 죽지 않았다면 사망 처리 실행
        if (health <= 0 && !dead){
            Die();
        }
    }

    // 체력을 회복하는 기능
    public virtual void RestoreHealth(float newHealth) {
        if (dead){ // 이미 사망한 경우 체력을 회복할 수 없음
            return; 
        }
        health += newHealth; // 체력 추가
    }

    // 사망 처리
    public virtual void Die() {
        // onDeath 이벤트에 등록된 메서드가 있다면 실행
        if (onDeath != null){
            onDeath();
        }
        // 사망 상태를 참으로 변경
        dead = true;
    }
}

이장에서 다루는 내용

• 다형성을 사용해 여러타입을 하나의 타입으로 다루기
• 오버라이드를 사용해 부모 클래스의 기존메서드 확장하기
• 이벤트를 사용해 견고한 커플링을 해소하고 코드를 간결하게 만들기
• UI슬라이더 사용하기
• 게임월드내부에 UI배치하기
• 내비게이션 시스템을 사용해 인공지능 구현하기

1. 다형성
   • 이장에서는 적 AI와 플레이어 캐릭터를 포함하여 생명체로 동작할 모든 클래스가 공유하는 기반 클래스 LivingEntity를 사용합니다. 생명체로 동작할 모든 클래스는 LivingEntity 클래스를 상속하고 그 위에 자신만의 기능을 추가합니다.
   • LivingEntity를 상속한 자식 클래스는 LivingEntity의 구현을 재사용할수 있을 뿐만 아니라 LivingEntyty타입으로 취급될 수 있습니다. 따라서 LivingEntity를 상속한 다양한 타입의 게임속 생명체를 LivingEntity 타입으로 일괄 처리 할 수 있습니다.
   • 이것은 다형성이라는 객체지향의 특징 덕분입니다. LivingEntity 클래스를 사용하기 전에 상속을 이해하고 다형성이 무엇인지 살펴보겠습니다. 그리고 다형성이 코드를 쉽고 간결하게 만드는 데 어떻게 도움을 주는지 알아보겠습니다.
2. 상속관계에서의 다형성
   • 다형성을 문자 그대로 해석하면 여러형태입니다. c#에서 다형성은 자식 클래스 타입을 부모클래스 타입으로 다룰 수 있게 합니다.
   • 상속이란 부모클래스를 기반으로 자식클래스를 만드는 방법입니다. 이것은 현실에서 어떤 물체를 더 포괄적인 분류로 다루는 것에 비유할 수 있습니다. 예를 들어 동물이나 식물은 더 포괄적인 분류인 생명체로 다룰 수 있습니다.
   • class Monster{ public void Attack(); public float damage=100f;}라는 클래스가 있습니다.
     • class Orc : Monster { public void Cry()}, Monster를 상속받는 자식 클라스를 만들었습니다.
     • Orc orc; Monster monster = orc; 로 orc객체를 monster에 할당합니다. 변형이 아닙니다.
     • monster.Attack()는 문제 없지만 monster.Cry()는 에러입니다. monster클래스에는 Cry()가 없기 때문입니다.
   • 다형성을 사용한 패턴
     • class Dragon:Monster {public void Fly();}는 다른 자식클래스를 만듭니다.
     • 게임중 Dragon과 Orc의 객체를 많이 만듭니다.
     • Monster[] monsters = findObjectsOfType<Monsters>();
     • for(int i = 0;i<Monsters.Length;i++) monsters[i].damage += 10f;
     • 위와 같이 <Monster>로Dragon과 Orc객체들의 damage를 갱신할 수 있습니다.
3. 오버라이드
   • 부모클래스에서 정의된 메서드를 자식클래스에서 재정의하는 걸 오버라이드라고 합니다.
   • Orc와 Dragon의 Attack()기술이 다를 경우 활용할수 있습니다.
   • class Monster{ public virtual void Attack(){Debug.Log("공격");}}이라고 할때
   • class Orc : Monster {public override void Attack() {base.Attack; 추가처리;} }오버라이드할 수 있습니다
     
     1. virtual 키워드로 지정된 메서드는 가상 메서드가 됩니다. 가상 메서드는 자식 클래스가 오버라이드 할 수 있도록 허용된 메서드 입니다. 자식 클래스는 override 키워드를 사용해 부모 클래스의 가상 메서드를 재정의 할 수 있습니다. 자식 객체가 연결된 부모 참조의 오버라이드된 메서드는 자식 메서드가 실행됩니다.
     2. Orc orc; Monster monster = orc; monster.Attack();  <- Orc에서 재정의된 Attack()가 실행
   • virtual로 지정된 메서드는 가상메서드가 됩니다. 자식클래스에서override를 허용해줍니다.
   • base를 사용해 부모의 원형 메서드로 접근할 수 있습니다.
   • class Dragon : Monster {public override void Attack() { base.Attack(); Debug.Log("추가"); } }
4. 오버라이드 활용 : 다양한 자식 클래스의 같은 이름의 메서드를 실행하되 실제 처리는 각자 다르게 만들수 있습니다.
   • for(int i = 0;i<Monsters.Length;i++) monsters[i].Attack();
5. LivingEntity기반 클래스
   • 체력, 피해, 사망기능,사망이벤트 제공
   • LivingEntity 클래스는 IDamageable을 상속하므로 OnDamage()메서드를 반드시 구현해야 합니다.
   • LivingEntity의 필드
     • startingHealth // 시작 체력
     • health { get; protected set; } // 현재 체력
     • public bool dead { get; protected set; } // 사망 상태
     • public event Action onDeath; // 사망시 발동할 이벤트
6. Action
   1. Action 타입은 입력과 출력이 없는 메서드를 가리킬 수 있는 델리게이트입니다. 델리게이트는 대리자로 번역되며 메서드를 값으로 할당받을 수 있는 타입입니다.
   2. Action으로 지정된 객체는 +=를 이용해 메서드를 등록할 수 있습니다. 괄호없이 이름만 명시하면 됩니다. action += Func1(); action += Func2();
   3. 괄호를 붙이면 실행후 결과값이 들어가므로 에러입니다.
   4. Action 변수()를 실행하면 등록된 메서드들이 일괄 실행 됩니다.
   5.  

public class Cleaner : MonoBehaviour {
	Action OnClean;
    void Start() {
    	onClean += CleaningRoomA;  // += 로 메스드 등록
        onClean += CleaningRoomB;
      	}
    void Update() {
    	if (Input.GetMouseButtonDown(0)) {
        	onClean(); // CleaningRoomA()와 CleaningRoomB() 실행
        }
    }
    void CleaningRoomA() {
    	Debug.Log("A방 청소");
    }
    void CleaningRoomA() {
    	Debug.Log("A방 청소");
    }
}

PlayerShooter 스크립트를 새로 만듭니다. 첨부된 파일을 Assets에 추가하셔도 됩니다.

스크립트를 Player에 추가합니다. 플레이어에는 다음과 같이 3개의 스크립트가 추가되어 있고 다음과 같이 참조들이 연결되어 있어야 합니다.

GunShooter의 전체 스크립트입니다.

gun.Fire(),gun.Reload()가 있는 gun의 참조를 글로벌로 받아오고

입력을 받아올 playerInput컴포넌트를 playerInput 참조에 연결해줍니다.

Update() 에서 playerInput.fire가 참이면 gun.Fire()를 실행해 총알을 발사합니다. playerInput.fire가 참일경우 gun.Reload()를 실행합니다. Animatior가 있는 경우 애니메이션을 실행하나 여기서는 실행하지 않습니다. 마지막으로 UpdateUI()함수를 불러 UI를 업데이트 합니다. 아직 UI가 null이므로 실행하지는 않습니다.

using UnityEngine;

// 주어진 Gun 오브젝트를 쏘거나 재장전
// 알맞은 애니메이션을 재생하고 IK를 사용해 캐릭터 양손이 총에 위치하도록 조정
public class PlayerShooter : MonoBehaviour {
    public Gun gun; // 사용할 총
    public Transform gunPivot; // 총 배치의 기준점


    private PlayerInput playerInput; // 플레이어의 입력
    //private Animator playerAnimator; // 애니메이터 컴포넌트

    private void Start() {
        // 사용할 컴포넌트들을 가져오기
        playerInput = GetComponent<PlayerInput>();
        //playerAnimator = GetComponent<Animator>();
    }

    private void OnEnable() {
        // 슈터가 활성화될 때 총도 함께 활성화
        gun.gameObject.SetActive(true);
    }

    private void OnDisable() {
        // 슈터가 비활성화될 때 총도 함께 비활성화
        gun.gameObject.SetActive(false);
    }

    private void Update() {
        // 입력을 감지하고 총 발사하거나 재장전
        if (playerInput.fire) {
            // 발사 입력 감지시 총 발사
            //Debug.Log("Player Shooter Input.fire");
            gun.Fire();
        } else if (playerInput.reload) {
            // 재장전 입력 감지시 재장전
            if (gun.Reload()) {
                // 재장전 성공시에만 재장전 애니메이션 재생
                //playerAnimator.SetTrigger("Reload");
                Debug.Log("Reload");
            }
        }

        // 남은 탄약 UI를 갱신
        //UpdateUI();
    }

    // 탄약 UI 갱신
    /*
    private void UpdateUI() {
        if (gun != null && UIManager.instance != null) {
            // UI 매니저의 탄약 텍스트에 탄창의 탄약과 남은 전체 탄약을 표시
            UIManager.instance.UpdateAmmoText(gun.magAmmo, gun.ammoRemain);
        }
    }
    */

    // 애니메이터의 IK 갱신
}

using UnityEngine;

public class GunData
{
    public AudioClip shotClip; // 발사 소리
    public AudioClip reloadClip; // 재장전 소리

    public float damage = 25; // 공격력

    public int startAmmoRemain = 100; // 처음에 주어질 전체 탄약
    public int magCapacity = 25; // 탄창 용량

    public float timeBetFire = 0.12f; // 총알 발사 간격
    public float reloadTime = 1.8f; // 재장전 소요 시간
}

현재 GunData는 단순 클래스입니다. 이걸 스트립터블 오브젝트 타입상속하고 CreateAssetMenu()를 이용 에셋 생성메뉴에 추가하겠습니다.

using UnityEngine;
[CreateAssetMenu(menuName = "Scriptable/GunData",fileName = "Gun Data")]
public class GunData : ScriptableObject
{ 생략 }

Gun 스크립트

이제 Gun스크립트를 Gun게임 오브젝트에 추가하고 스크립트를 완성합니다. 하이라키의 FirePosition, MuzzleFlashEffect와 ShellEjectEffect를 끌어다 연결해줍니다.

Gun의 메서드

Awake() : 사용할 컴포넌트를 가져오고

OnEnable() : 총의 상태를 초기화

Fire() : 총을 발사를 시도

Shot() : 발사가능 상태에서만 발사, 안전하게 감싸는 껍떼기

ShotEffect(): 발사효과를 재생하고 탄알 궤적을 그립니다.

Reload() : r을 누르면 재장전이 가능한지 체크하고 다음 루팅을 Call합니다. 성공하면 true를 리턴

ReloadRoutine(): 실제 장전하는 곳

ShotEffect()와 ReloadRoutine()은 IEnumerator라는 코루틴메서드 타입을 반환

​

Gun의 필드

이제 Gun의 스크립트의 변수를 살펴봅시다.

public enum State {
        Ready, // 발사 준비됨
        Empty, // 탄창이 빔
        Reloading // 재장전 중
    }
public State state { get; private set; } // 현재 총의 상태 외부에서 변경 불가능

public Transform fireTransform; // 총알이 발사될 위치와 방향을 나타내는 변수 Fire Position과 연결

public ParticleSystem muzzleFlashEffect; // 총구 화염 효과

public ParticleSystem shellEjectEffect; // 탄피 배출 효과

private LineRenderer bulletLineRenderer; // 총알 궤적을 그리기 위한 렌더러

다음은 총소리를 위한 변수가 있습니다.

private AudioSource gunAudioPlayer; // 총 소리 재생기

음원및 총의 데이터는 Gundata로 따로 만들어 놓고 연결해 씁니다.

인스펙트창에서 연결해 줍니다.

public GunData gunData; // 총의 현재 데이터

 Awake()메서드

Gun 스크립트의 Awake()함수를 완성합니다.

private void Awake() {
    // 사용할 컴포넌트들의 참조를 가져오기
    gunAudioPlayer = GetComponent<AudioSource>();
    bulletLineRenderer = GetComponent<LineRenderer>();

    bulletLineRenderer.positionCount = 2; // 렌더러에서 사용할 점을 두개로 변경
    bulletLineRenderer.enabled = false; // 라인 렌더러를 비활성화, 스크립터에서 총을 쏠때만 나타나게 함
}

3. OnEnable()메써드

private void OnEnable() {
        ammoRemain = gunData.startAmmoRemain; // 전체 예비 탄약 양을 초기
        magAmmo = gunData.magCapacity; // 현재 탄창을 가득채우기
        state = State.Ready; // 총의 현재 상태를 총을 쏠 준비가 된 상태로 변경
        lastFireTime = 0; // 마지막으로 총을 쏜 시점을 초기화
    }

private IEnumerator ShotEffect(Vector3 hitPosition) {
    muzzleFlashEffect.Play();  // 총구 화염 효과 재생
    shellEjectEffect.Play(); // 탄피 배출 효과 재생
    gunAudioPlayer.PlayOneShot(gunData.shotClip);  // 총격 소리 재생
    bulletLineRenderer.SetPosition(0, fireTransform.position); // 선의 시작점은 총구의 위치
    bulletLineRenderer.SetPosition(1, hitPosition);  // 선의 끝점은 입력으로 들어온 충돌 위치
    bulletLineRenderer.enabled = true;  // 라인 렌더러를 활성화하여 총알 궤적을 그린다
    yield return new WaitForSeconds(0.03f);   // 0.03초 동안 잠시 처리를 대기
    bulletLineRenderer.enabled = false;  // 라인 렌더러를 비활성화하여 총알 궤적을 지운다
}

using System.Collections;
using UnityEngine;

// 총을 구현한다
public class Gun : MonoBehaviour {
    // 총의 상태를 표현하는데 사용할 타입을 선언한다
    public enum State {
        Ready, // 발사 준비됨
        Empty, // 탄창이 빔
        Reloading // 재장전 중
    }

    public State state { get; private set; } // 현재 총의 상태

    public Transform fireTransform; // 총알이 발사될 위치

    public ParticleSystem muzzleFlashEffect; // 총구 화염 효과
    public ParticleSystem shellEjectEffect; // 탄피 배출 효과

    private LineRenderer bulletLineRenderer; // 총알 궤적을 그리기 위한 렌더러
    private AudioSource gunAudioPlayer; // 총 소리 재생기

    public GunData gunData; // 총의 현재 데이터
    
    private float fireDistance = 50f; // 사정거리

    public int ammoRemain = 100; // 남은 전체 탄약
    public int magAmmo; // 현재 탄창에 남아있는 탄약
    
    private float lastFireTime; // 총을 마지막으로 발사한 시점
    
    private void Awake() {
        // 사용할 컴포넌트들의 참조를 가져오기
        gunAudioPlayer = GetComponent<AudioSource>();
        bulletLineRenderer = GetComponent<LineRenderer>();

        // 사용할 점을 두개로 변경
        bulletLineRenderer.positionCount = 2;
        // 라인 렌더러를 비활성화
        bulletLineRenderer.enabled = false;
    }

    private void OnEnable() {
        // 전체 예비 탄약 양을 초기화
        ammoRemain = gunData.startAmmoRemain;
        // 현재 탄창을 가득채우기
        magAmmo = gunData.magCapacity;

        // 총의 현재 상태를 총을 쏠 준비가 된 상태로 변경
        state = State.Ready;
        // 마지막으로 총을 쏜 시점을 초기화
        lastFireTime = 0;
    }

    // 발사 시도
    public void Fire() {
        // 현재 상태가 발사 가능한 상태
        // && 마지막 총 발사 시점에서 timeBetFire 이상의 시간이 지남
        if (state == State.Ready && Time.time >= lastFireTime + gunData.timeBetFire)
        {
            // 마지막 총 발사 시점을 갱신
            lastFireTime = Time.time;
            // 실제 발사 처리 실행
            Shot();
        }
    }

    // 실제 발사 처리
    private void Shot() {
        RaycastHit hit; // 레이캐스트에 의한 충돌 정보를 저장하는 컨테이너
        Vector3 hitPosition = Vector3.zero; // 총알이 맞은 곳을 저장할 변수
        // 레이캐스트(시작지점, 방향, 충돌 정보 컨테이너, 사정거리)
        if (Physics.Raycast(fireTransform.position,
            fireTransform.forward, out hit, fireDistance)){
            // 레이가 어떤 물체와 충돌한 경우
            // 충돌한 상대방으로부터 IDamageable 오브젝트를 가져오기 시도
            IDamageable target =
                hit.collider.GetComponent<IDamageable>();

            // 상대방으로 부터 IDamageable 오브젝트를 가져오는데 성공했다면
            if (target != null){
                // 상대방의 OnDamage 함수를 실행시켜서 상대방에게 데미지 주기
                target.OnDamage(gunData.damage, hit.point, hit.normal);
            }

            // 레이가 충돌한 위치 저장
            hitPosition = hit.point;
        } else { // 레이가 다른 물체와 충돌하지 않았다면
            // 총알이 최대 사정거리까지 날아갔을때의 위치를 충돌 위치로 사용
            hitPosition = fireTransform.position +
                          fireTransform.forward * fireDistance;
        }

        // 발사 이펙트 재생 시작
        StartCoroutine(ShotEffect(hitPosition));

        // 남은 탄환의 수를 -1
        magAmmo--;
        if (magAmmo <= 0)
        {
            // 탄창에 남은 탄약이 없다면, 총의 현재 상태를 Empty으로 갱신
            state = State.Empty;
        }
    }

    // 발사 이펙트와 소리를 재생하고 총알 궤적을 그린다
    private IEnumerator ShotEffect(Vector3 hitPosition) {
        // 총구 화염 효과 재생
        muzzleFlashEffect.Play();
        // 탄피 배출 효과 재생
        shellEjectEffect.Play();

        // 총격 소리 재생
        gunAudioPlayer.PlayOneShot(gunData.shotClip);

        // 선의 시작점은 총구의 위치
        bulletLineRenderer.SetPosition(0, fireTransform.position);
        // 선의 끝점은 입력으로 들어온 충돌 위치
        bulletLineRenderer.SetPosition(1, hitPosition);
        // 라인 렌더러를 활성화하여 총알 궤적을 그린다
        bulletLineRenderer.enabled = true;

        // 0.03초 동안 잠시 처리를 대기
        yield return new WaitForSeconds(0.03f);

        // 라인 렌더러를 비활성화하여 총알 궤적을 지운다
        bulletLineRenderer.enabled = false;
    }

    // 재장전 시도
    public bool Reload() {
        if (state == State.Reloading ||
            ammoRemain <= 0 || magAmmo >= gunData.magCapacity)
        {
            // 이미 재장전 중이거나, 남은 총알이 없거나
            // 탄창에 총알이 이미 가득한 경우 재장전 할수 없다
            return false;
        }

        // 재장전 처리 시작
        StartCoroutine(ReloadRoutine());
        return true;
    }

    // 실제 재장전 처리를 진행
    private IEnumerator ReloadRoutine() {
        // 현재 상태를 재장전 중 상태로 전환
        state = State.Reloading;
        // 재장전 소리 재생
        gunAudioPlayer.PlayOneShot(gunData.reloadClip);

        // 재장전 소요 시간 만큼 처리를 쉬기
        yield return new WaitForSeconds(gunData.reloadTime);

        // 탄창에 채울 탄약을 계산한다
        int ammoToFill = gunData.magCapacity - magAmmo;

        // 탄창에 채워야할 탄약이 남은 탄약보다 많다면,
        // 채워야할 탄약 수를 남은 탄약 수에 맞춰 줄인다
        if (ammoRemain < ammoToFill)
        {
            ammoToFill = ammoRemain;
        }

        // 탄창을 채운다
        magAmmo += ammoToFill;
        // 남은 탄약에서, 탄창에 채운만큼 탄약을 뺸다
        ammoRemain -= ammoToFill;

        // 총의 현재 상태를 발사 준비된 상태로 변경
        state = State.Ready;
    }
}

총과 총을 쏘는 슈터를 분리해 보겠습니다. 이유는 플레이어를 변경없이 총만 변경가능하기 때문입니다.

건(Gun)오브젝트 준비하기

플레이어에 총을 배치할 기준점이 될 자식 게임오브젝트 Pivot을 추가하겠습니다.

Gun  배치지점(Pivot) 생성

하이라키에서 플레이어를 선택하고  마우스 우클릭 > Create Empty 클릭

생성된 자식 게임 오브젝트의 이름을 Gun Pivot으로, 위치를 (0.5,0,0)로 변경

Gun 프리팹 생성

하이라키에서 +를 눌러 Create Empty> 이름을 Gun으로 변경,

Gun을 선택후 위를 우클릭후 3D Object>Cylinder 이름을 Barrel로 변경, Scale(0,2,0.5,0,2) , Rotation Y 90

Gun에 라인렌더러 추가하기

3. Gun에 탄알의 궤적을 그리기 위해 라인렌더러 추가하기

3.1 Gun 게임 오브젝트에 Line Renderer 컴포넌트 추가

3.2. Line Renderer 컴포넌트 체크 해제하여 비활성화

3.3 Positions 탭 펼치기>Size 0, Width를 0.02로 변경

3.4 Materials 탭 펼치기 > Element 0에 Bullet 머터리얼 할당 (Element 0 옆의 선택버튼 클릭) 선택창에서 Bullet을 선택 

Bullet.mat

0.00MB

3.5 Cast Shadows off로 변경, Receive Shadows 체크해제

하이라키에서 Gun 오브젝트를 선택후 Add Component> Audio Source 추가 Play On Awake 언체크 Audio Clip연결

Prefabs에서 MuzzleFlashEffect와 ShellEjectEffect를 끌어다 연결

완성된 Gun을 끌어다 프로젝트뷰에 놓으면 프리팹으로 만들어지고 하이라키의 이름이 파란색으로 변경된다.

Gun을 Gun Pivot의 자식으로 연결