유니티

GunData를 선택후 인스펙터뷰에서 Shot Clip, Reload Clip필드의 소스를 선택해 오디오클립을 지정해줍니다.

1. Gun 스크립트 변수들

총의 상태를 나타내는 state변수가 있습니다. Gun의 상태는 Ready, Empty, Reloading중 하나입니다.

Gun 스크립트

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

Gun게임 오브젝트 준비가 끝났습니다. 이제 총의 동작을 구현하는 Gun 스크립트를 Gun게임 오브젝트에 추가하고 스크립트를 분석해 보겠습니다.

4. 코루틴

발사효과를 재생하는 ShotEffect()메서드는 시각효과를 재생하고 탄알 궤적을 그리기위해 라인렌더러를 켜서 선을 그린다음 라인렌더러를 꺼야 합니다. 이때 매우 짧은 시간동안 처리를 일시정지합니다. 따라서 라인렌더러를 끄고 켜는 대기시간이 필요합니다. 이때 코루틴이 사용됩니다.

유니티의 코루틴은 대기시간을 가질 수 있는 메서드입니다. 유니티에서 코루틴메서드는 IEnumerator타입을 반환해야하며, 처리가 일시 대기할 곳에 yield키워드를 명시해야합니다.

yield return new WaitForSecond(float 초); // 초단위로 쉬기

yield return null; // 한프레임 쉬기

코루틴은 StartCoroutine()메서드로 실행됩니다. 2가지 방법이 있습니다.

StartCoroutine(메서드());

StartCoroutine("메서드이름"); // 꼭 StopCroutine("메서드이름")으로 종료시켜야합니다.

​

5. ShotEffect()메서드

나중에 Shot()에서 불리워집니다.

Gun프리팹 갱신하기

인스펙터 상단 Overrides>Apply All 클릭

Gun.CS 전체코드

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

라인 렌더러는 포지션필드에 지정된 점 사이를 이어 선을 그립니다. 지금은 선을 그리지 못하도록 Size를 0으로 하고 비활성화했습니다.

C# 인터페이스

public class MyConnection : Component, IDbConnection, IDisposable
{
   // IDbConnection을 구현
   // IDisposable을 구현
}

public interface IComparable
{
   // 멤버 앞에 접근제한자 사용 안함
   int CompareTo(object obj);
}

C# 인터페이스의 구현

public class MyClass : IComparable
{
   private int key;
   private int value;

   // IComparable 의 CompareTo 메서드 구현
   public int CompareTo(object obj)
   {
      MyClass target = (MyClass)obj;
      return this.key.CompareTo(target.key);
   }
}

public void Run()
{
   // 인터페이스 사용하기 때문에
   // 특정 DB Connection을 신경 쓸 필요가 없다
   IDbConnection dbCon = GetDbConnection();
   dbCon.Open();
   if (dbCon.State == ConnectionState.Open)
   {
      dbCon.Close();
   }
}

// IDbConnection 인터페이스를 리턴
public IDbConnection GetDbConnection()
{
   IDbConnection dbConn = null;
   string cn = ConfigurationManager.AppSettings["Connection"];
   switch (ConfigurationManager.AppSettings["DbType"])
   {
      case "SQLServer":
         dbConn = new SqlConnection(cn);
         break;
      case "Oracle":
         dbConn = new OracleConnection(cn);
         break;
      case "OleDB":
         dbConn = new OleDbConnection(cn);
         break;         
   }
   return dbConn;
}

인터페이스와 느슨한 커플링

IItem을 상속한 클래스는 Use()메서드를 아이템의 역할에 따라 반드시 구현해야 합니다.

​

느슨한 커플링

IItem인터페이스를 상속한 클래스는 많아지고 충돌시 이들 모두를 검사하여 개별 처리하는 것보다

private void OnTriggerEnter(Collider other) {
    AmmoPack ammoPack = other.GetComponent<AmmoPack>();
    if(ammoPack != null) {
        ammoPack.Use();
    }
    HealthPack HealthPack = other.GetComponent<HealthPack>();
    if (HealthPack != null) {
        HealthPack.Use();
    }
}

 다음과 같이 IItem타입으로 처리가능합니다.

void OnTriggerenter(Collider other) {
    IItem item = other.GetComponent<IItem>();
    if(item != null) {
        item.Use();
    }
}