/// <summary>
/// Enters the warp tunnel.
/// </summary>
/// <returns>An awaitable task.</returns>
private async Task EnterTunnel()
{
RenderCameraFlareLayerEnabled = true;
Spaceship.Thrusters.PhysicsEnabled = false;
float allocatedTime = _warpLaunchTime * InverseJumpSplit;
for (float alpha = 0.0f; alpha <= 1.0f; alpha += Time.deltaTime / allocatedTime)
{
WarpTunnelFade = 1 - alpha;
Spaceship.Thrusters.ShakePowerAndStrength = Mathf.Lerp(allocatedTime, 1, alpha);
Spaceship.Thrusters.ShakePowerAndStrength = Mathf.Lerp(allocatedTime, 1, alpha);
// All done, hold until the next frame.
await Await.NextUpdate();
}
// Floating point inaccuracies combined with time deltas not being exact fractions of seconds
// mean this value might never fully reach its destination, so it will be forced to do so here.
WarpTunnelFade = 0;
SunEnabled = false;
Spaceship.Thrusters.ShowSpeedlines = false;
}
private async void Unfade()
{
float startTime = Time.realtimeSinceStartup;
float endTime = startTime + UnfadeTime;
while (Time.realtimeSinceStartup < endTime)
{
float percentage = (Time.realtimeSinceStartup - startTime) /
(endTime - startTime);
foreach (Fadable fadable in FadeTargets)
{
fadable.OnUpdateColour(Color.Lerp(FadedColour, UnfadedColour, UnfadeCurve.Evaluate(percentage)),
percentage);
}
await Await.NextUpdate();
}
foreach (Fadable fadable in FadeTargets)
{
fadable.OnUpdateColour(UnfadedColour, 0f);
}
Fading = false;
OnFadeComplete.Invoke();
}
private void OnPacketPlayerFireWeapon(ref PlayerFireWeapon p)
{
PlayerClient player = playersByIndex[p.Index];
if (player == null)
{
return;
}
if (player.Connection != p.SenderConnection)
{
throw new InvalidOperationException();
}
Vector3 initialPos = p.InitialPos;
Vector3 gunspotPos = p.GunspotPos;
float angle = p.Angle;
WeaponType weaponType = p.WeaponType;
Player proxyActor = player.ProxyActor;
Await.NextUpdate().OnCompleted(() => {
if (proxyActor == null)
{
return;
}
proxyActor.LastInitialPos = initialPos;
proxyActor.LastGunspotPos = gunspotPos;
proxyActor.LastAngle = angle;
proxyActor.FireWeapon(weaponType);
});
}
/// <summary>
/// Moves the system's contents quickly out of the way.
/// </summary>
/// <returns>An awaitable task.</returns>
private async Task WarpOut()
{
Spaceship.Thrusters.ThrustPower = 1.0f;
SkyboxEnabled = false;
Vector3 dynamicWarpPoint = -transform.forward * _dynamicWarpDistance;
Vector3 backdropWarpPoint = transform.forward * _backdropWarpDistance;
float allocatedTime = _warpLaunchTime * JumpSplit;
for (float alpha = 0.0f; alpha <= 1.0f; alpha += Time.deltaTime / allocatedTime)
{
_dynamicSystem.position = Vector3.Lerp
(
Vector3.zero,
dynamicWarpPoint,
Utilities.InverseCircleInterpolate(alpha)
);
_skyboxManager.Position = Vector3.Lerp
(
Vector3.zero,
backdropWarpPoint,
Utilities.InverseCircleInterpolate(alpha, 8)
);
// All done, hold until the next frame.
await Await.NextUpdate();
}
SetDynamicSystemVisible(false);
}
/// <summary>
/// Hides/shows the upper portion of the UI.
/// </summary>
/// <returns>An awaitable task.</returns>
private static async Task SetUpper(bool state)
{
RectTransform upperUI = Instance._upperUI;
float startBottom = Screen.height / (state ? 2 : 1);
float startTop = (Screen.height / 2) * (state ? 0 : 1);
float targetBottom = Screen.height / (state ? 1 : 2);
float targetTop = (Screen.height / 2) * (state ? 1 : 0);
for (float alpha = 0; alpha <= 1.0f; alpha += Time.deltaTime * 2)
{
Vector2 lowerAnchor = upperUI.offsetMin;
Vector2 upperAnchor = upperUI.offsetMax;
upperAnchor.y = Mathf.Lerp(startTop, targetTop, alpha);
lowerAnchor.y = Mathf.Lerp(startBottom, targetBottom, alpha);
upperUI.offsetMin = lowerAnchor;
upperUI.offsetMax = upperAnchor;
// Wait one frame...
await Await.NextUpdate();
}
}
private async void Unfade()
{
CacheCanvasRenderers();
List <CanvasRenderer> canvasRenderers;
if (!_cachedRenderers.TryGetValue(FadeTarget, out canvasRenderers))
{
return;
}
float startTime = Time.realtimeSinceStartup;
float endTime = startTime + UnfadeTime;
while (Time.realtimeSinceStartup < endTime)
{
UpdateCanvasRendererColours(canvasRenderers,
Color.Lerp(FadedColour, UnfadedColour,
(Time.realtimeSinceStartup - startTime) /
(endTime - startTime)));
await Await.NextUpdate();
}
UpdateCanvasRendererColours(canvasRenderers, UnfadedColour);
Fading = false;
OnFadeComplete.Invoke();
}
/// <summary>
/// Warp that will only end after receiving a MUST DROP instruction.
/// </summary>
/// <returns>An awaitable task.</returns>
private async Task InfiniteWarp()
{
while (!_mustDrop)
{
OnHyperspaceUpdate?.Invoke(this, null);
await Await.NextUpdate();
}
_mustDrop = false;
}
/// <summary>
/// Warp that will end after a given countdown OR after receiving
/// a MUST DROP instruction.
/// </summary>
/// <returns>An awaitable task.</returns>
private async Task TimedWarp()
{
for (float t = 0; t < _warpDuration && !_mustDrop; t += Time.deltaTime)
{
OnHyperspaceUpdate?.Invoke(this, null);
await Await.NextUpdate();
}
_mustDrop = false;
}
/// <summary>
/// Performs the countdown procedure before jumping.
/// </summary>
/// <returns>An awaitable task.</returns>
private async Task LaunchCountdown()
{
CountdownPerSecond();
for (float t = 0; t < _warpCountdown; t += Time.deltaTime)
{
OnCountdownUpdate?.Invoke(this, new WarpCountdownArgs(_warpCountdown - t));
await Await.NextUpdate();
}
OnCountdownFinished?.Invoke(this, EventArgs.Empty);
}
/// <summary>
/// Initiates the fade.
/// </summary>
public async void Fade()
{
if (!Fading && gameObject.activeInHierarchy)
{
OnFadeStart.Invoke();
Fading = true;
float startTime = Time.realtimeSinceStartup;
float endTime = startTime + FadeTime;
while (Time.realtimeSinceStartup < endTime)
{
float percentage = (Time.realtimeSinceStartup - startTime) /
(endTime - startTime);
foreach (Fadable fadable in FadeTargets)
{
fadable.OnUpdateColour(Color.Lerp(UnfadedColour, FadedColour, FadeCurve.Evaluate(percentage)),
percentage);
}
await Await.NextUpdate();
}
foreach (Fadable fadable in FadeTargets)
{
fadable.OnUpdateColour(FadedColour, 1f);
}
if (!OnlyFade)
{
OnFadeWait.Invoke();
await Await.Seconds(WaitBetweenFades);
Unfade();
}
else
{
Fading = false;
OnFadeComplete.Invoke();
}
}
}
/// <summary>
/// Initiates the fade.
/// </summary>
public async void Fade()
{
if (!Fading && gameObject.activeInHierarchy)
{
Fading = true;
CacheCanvasRenderers();
List <CanvasRenderer> canvasRenderers;
if (!_cachedRenderers.TryGetValue(FadeTarget, out canvasRenderers))
{
return;
}
float startTime = Time.realtimeSinceStartup;
float endTime = startTime + FadeTime;
while (Time.realtimeSinceStartup < endTime)
{
UpdateCanvasRendererColours(canvasRenderers,
Color.Lerp(UnfadedColour, FadedColour,
(Time.realtimeSinceStartup - startTime) /
(endTime - startTime)));
await Await.NextUpdate();
}
UpdateCanvasRendererColours(canvasRenderers, FadedColour);
OnFadeWait.Invoke();
if (!OnlyFade)
{
await Await.Seconds(WaitBetweenFades);
Unfade();
}
else
{
Fading = false;
}
}
}
/// <summary>
/// Fades the given audio source.
/// </summary>
/// <param name="audioSource"></param>
/// <param name="targetVolume"></param>
/// <param name="fadeTime"></param>
public async void FadeAudio(AudioSource audioSource, float targetVolume, float fadeTime)
{
float startingVolume = audioSource.volume;
float startTime = Time.realtimeSinceStartup;
float endTime = startTime + fadeTime;
while (Time.realtimeSinceStartup < endTime)
{
float percentage = (Time.realtimeSinceStartup - startTime) /
(endTime - startTime);
audioSource.volume = Mathf.Lerp(startingVolume, targetVolume, percentage);
await Await.NextUpdate();
}
audioSource.volume = targetVolume;
}
public async void Save(Graph graph, bool forcedAskFileName)
{
async Task Save(string path)
{
if (string.IsNullOrWhiteSpace(path))
{
return;
}
Bus.SetStatusLabel += "Saving " + path;
await Await.NextUpdate();
try
{
switch (Path.GetExtension(path).ToLower())
{
case ".pxw":
GraphHelper.SaveGraph(path);
break;
case "": path += ".pxw"; goto case ".pxw";
}
}
catch (Exception ex)
{
UIManager.ShowDialog(null, ex.Message, "Ok");
}
Bus.SetStatusLabel += "Completed.";
}
if (forcedAskFileName || string.IsNullOrWhiteSpace(Graph.Instance.SceneFilePath))
{
OpenFileController.Instance.SaveFile("Save Graph", Graph.Instance.GetProposedNameOfScene(), "px Works Graph|*.pxw", async(path) => await Save(path));
}
else
{
await Save(Graph.Instance.SceneFilePath);
}
}
/// <summary>
/// Moves the system's contents quickly back in view.
/// </summary>
/// <returns>An awaitable task.</returns>
private async Task WarpIn()
{
SetDynamicSystemVisible(true);
Vector3 dynamicStartPoint = transform.forward * _dynamicWarpDistance;
Vector3 backdropStartPoint = -_skyboxManager.Position;
float allocatedTime = _warpDropTime * DropSplit;
float unavailableTime = _warpDropTime * InverseDropSplit;
for (float alpha = 0.0f; alpha <= 1.0f; alpha += Time.deltaTime / allocatedTime)
{
_dynamicSystem.position = Vector3.Lerp
(
dynamicStartPoint,
Vector3.zero,
Utilities.CircleInterpolate(alpha)
);
_skyboxManager.Position = Vector3.Lerp
(
backdropStartPoint,
Vector3.zero,
Utilities.CircleInterpolate(alpha, 8)
);
if (!_condenseDrop)
{
Spaceship.Thrusters.ShakePower = Mathf.Lerp(unavailableTime, 0, alpha);
Spaceship.Thrusters.ThrustPower = Mathf.Lerp(unavailableTime, 0, alpha);
}
// All done, hold until the next frame.
await Await.NextUpdate();
}
SkyboxEnabled = true;
}