// 코루틴 접근 방식: 일시 중지 및 재개

private IEnumerator LoadMainMenuRoutine()

{

    // 1일차: 플레이어 에셋 다운로드 시작 및 

    // 완료를 기다리는 동안 잠시 휴식

    yield return DownloadPlayerAssetsRoutine();

    // 2일차: 월드 에셋 다운로드 시작 및

    // 완료를 기다리는 동안 잠시 휴식

    yield return DownloadWorldAssetsRoutine();

    // 3일차: 오디오 에셋 다운로드 시작 및

    // 완료를 기다리는 동안 잠시 휴식

    yield return DownloadAudioAssetsRoutine();

    ShowMainUI(); // 게임이 계속 응답 가능한 상태로 유지됨!

}

// 어드레서블 에셋을 비동기적으로 로드하는 코루틴

public IEnumerator GetAssetRoutine(string assetName, Action onAssetLoaded)

{

    // 에셋 로딩을 시작하고 완료될 때까지 기다릴 수 있도록 핸들을 유지합니다

    var asyncOperationHandle = Addressables.LoadAssetAsync(assetName);   

   // 로딩이 완료될 때까지 대기

    yield return asyncOperationHandle;

    // 핸들에서 로드된 에셋 가져오기

    var loadedAsset = asyncOperationHandle.Result;

    // 콜백을 통해 결과 전달    

    onAssetLoaded(loadedAsset);

}

public void Start()

{

    // 다음과 같이 작성할 것으로 예상할 수 있습니다.

    // GameObject loadedAsset = StartCoroutine(GetAssetRoutine("boat"));

    // Debug.Log(loadedAsset);

    // 하지만 코루틴은 값을 직접 반환할 수 없습니다.

    // 그 대신 콜백을 사용해서 로드된 에셋을 받아야 합니다.

    StartCoroutine(GetAssetRoutine("boat",(loadedAsset) => { Debug.Log(loadedAsset); }));

}

public IEnumerator GetAssetRoutine(string assetName, Action onAssetLoaded)

{

    var asyncOperationHandle = Addressables.LoadAssetAsync(assetName);

    yield return asyncOperationHandle;

    var loadedAsset = asyncOperationHandle.Result;  
    onAssetLoaded(loadedAsset);

}

public void Start()

{

    StartCoroutine(GetAssetRoutine("boat", (loadedAsset) => {

        DoSomething(loadedAsset, (result1) => {

            DoSomething2(result1, (result2) => {

                DoSomething3(result2, (result3) => {

                    // 콜백 지옥에 오신 것을 환영합니다!

                });

            });

        });

    }));

}

public async Task GetAssetAsync(string assetName)

{

   // 에셋 로딩을 시작하고 완료될 때까지 기다릴 수 있도록 핸들을 유지합니다

    var asyncOperationHandle = Addressables.LoadAssetAsync(assetName);

    // .Task가 비동기 작업을 Task로 노출하므로 await할 수 있습니다

    // 로딩 작업이 완료될 때까지 기다립니다(차단하지 않음)

    await asyncOperationHandle.Task; 

    // 로드된 에셋을 반환합니다

    return asyncOperationHandle.Result;

}

public async void Start()

{

    // 에셋이 로드될 때까지 기다립니다

    GameObject loadedAsset = await GetAssetAsync("boat");

    // 이후 비동기 작업을 순차적으로 실행합니다

    await DoSomethingAsync(loadedAsset);

    await DoSomething2Async(loadedAsset);

    await DoSomething3Async(loadedAsset);

}

private async void Start()

{

    var task = SomeAsync(); // 매번 Task 오브젝트가 생성됨

    await task;

}

private async Task SomeAsync()

{

    Time.timeScale = 2f;

    Debug.Log($"Time: {Time.time}");

    // 게임이 두 배 속도로 실행되고 있을 때도

    // 여전히 실제 시간으로 100ms를 기다려야 합니다.

    await Task.Delay(100);

    Debug.Log($"Time: {Time.time}");

}

public async Awaitable GetAssetAsync(string assetName)

{

    var asyncOperationHandle = Addressables.LoadAssetAsync(assetName);

    // .Task가 비동기 작업을 Task로 노출하므로 await할 수 있습니다

    // 로딩 작업이 완료될 때까지 기다립니다(차단하지 않음)

    await asyncOperationHandle.Task;

    // 로딩이 완료되면 로드된 에셋을 반환합니다

    return asyncOperationHandle.Result;

}

public async void Start()

{

    var loadedAsset = await GetAssetAsync("boat");

}

 // 잘못된 방식

async Awaitable AwaitableExample()

{

    var awaitableInstance = SomeAwaitableMethod();

    await awaitableInstance; // 첫 번째 await - 정상적으로 완료

    // 이 시점에서, awaitable 인스턴스는 풀로 돌아갑니다!

    await awaitableInstance; // 두 번째 await - 정의되지 않은 동작!

}

async void Start()

{

    Awaitable awaitable1 = TestAsyncMethod();

    await awaitable1;

    Awaitable awaitable2 = TestAsyncMethod();

    // 이는 풀링으로 인해 참일 가능성이 높습니다!

    if(awaitable1 == awaitable2)

    {

        Debug.LogError("Same Awaitable instance reused from pool!");

    }

    // awaitable1은 이제 awaitable2의 작업을 나타낼 수도 있습니다

    // 교착 상태 또는 예기치 않은 동작 발생 가능

    await awaitable1; 

}

async Awaitable TestAsyncMethod()

{

    await Awaitable.WaitForSecondsAsync(1f);

}

async void Start(){

    // 잘못된 방식: Awaitable 인스턴스를 저장해서 나중에 await

    Awaitable awaitable = TestAsyncMethod();

    await awaitable;

    // 바람직한 방식: 즉시 await

    await TestAsyncMethod();

}

public class TimingComparison : MonoBehaviour

{

    async void Start()

    {

        Debug.Log($"Starting at Time: {Time.time}");

        Time.timeScale = 2f; // 게임 속도 2배

        // 실제 시간 지연(timeScale의 영향을 받지 않음)

        await Task.Delay(2000); // 항상 실제 2초에 해당하는 시간

        Debug.Log($"Task.Delay completed at Time: {Time.time}");

        // 게임 시간 지연(timeScale의 영향을 받음) 

        await Awaitable.WaitForSecondsAsync(2f); // 2배 속도에서 1초의 실제 시간

        Debug.Log($"Awaitable completed at Time: {Time.time}");

        Time.timeScale = 1f;

    }

}

await Awaitable.BackgroundThreadAsync(); // 백그라운드 스레드로 전환

await Awaitable.MainThreadAsync();       // 메인 스레드로 다시 전환

async Awaitable PerformanceExample()

{

    await Awaitable.MainThreadAsync();      // 지연 없음(이미 메인 스레드에 있음)

    await Awaitable.BackgroundThreadAsync(); // 다음 줄에 대한 1프레임 지연

    DoBackgroundWork();

    await Awaitable.MainThreadAsync();       // 또 다른 1프레임 지연

    DoMainThreadWork();

}