public IPromise Wait(float seconds, Action <float> progressCallback = null)
{
Deferred deferred = Deferred.GetFromPool();
awaiters.Add(new Awaiter
{
duration = seconds,
finishTime = Time.time + seconds,
unscaledTime = false,
additionalCondition = null,
progressCallback = progressCallback,
resolver = deferred,
});
return(deferred);
}
public IPromise WaitForTrue(Func <bool> condition)
{
Deferred deferred = Deferred.GetFromPool();
awaiters.Add(new Awaiter
{
duration = 0f,
finishTime = Time.unscaledTime,
unscaledTime = true,
additionalCondition = condition,
progressCallback = null,
resolver = deferred,
});
return(deferred);
}
/// <summary>
/// adds new promise constructor to current promise and returns wrapper that resolves with added promise
/// A.Then(B) - returns promise that resolves when promise from B is resolved
/// </summary>
/// <param name="next">constructor for next promise</param>
/// <returns>Promise</returns>
public IPromise Then(Func <IPromise> next)
{
Deferred deferred = Deferred.GetFromPool();
Done(() =>
{
IPromise promise = next();
promise.Done(() => deferred.Resolve());
promise.Fail(ex => deferred.Reject(ex));
});
Fail(ex => deferred.Reject(ex));
return(deferred);
}
public static Promise <T> WithCoroutine <T> (IEnumerator coroutine)
{
var deferred = new Deferred <T>();
return(deferred.RunAsync(coroutine));
}
internal Promise(Deferred <TResult, TInput> deferred)
{
this.deferred = deferred;
callbacks = new Queue <Callback <TResult> >();
exceptions = new Queue <Callback <Exception> >();
}
