private static CharacterInput ApplyStallPrevention(CharacterInput input, FlightStatistics target, float stallLimitStrength, float rollLimitStrength)
{
// Disable stall prevention if super-maneuvre inputs are active
stallLimitStrength *= 1f - input.Cannonball;
rollLimitStrength *= 1f - input.Cannonball;
rollLimitStrength *= 1f - Mathf.Max(input.CloseLeftArm, input.CloseRightArm);
// Limit both positive and negative pitch motion to keep body from stalling
if (input.Pitch > 0f)
{
float multiplier = 1f - Mathf.InverseLerp(0f, -20f, target.AngleOfAttack) * stallLimitStrength;
input.Pitch *= multiplier;
}
else
{
float multiplier = 1f - Mathf.InverseLerp(0f, 20f, target.AngleOfAttack) * stallLimitStrength;
input.Pitch *= multiplier;
}
// Limit roll rate
if (input.Roll > 0f)
{
float multiplier = 1f - Mathf.Clamp01((-target.LocalAngularVelocity.y - 1f) * 1f) * rollLimitStrength;
input.Roll *= multiplier;
}
else
{
float multiplier = 1f - Mathf.Clamp01((target.LocalAngularVelocity.y - 1f) * 1f) * rollLimitStrength;
input.Roll *= multiplier;
}
return(input);
}
public void OnSpawn()
{
Initialize();
for (int i = 0; i < Rigidbodies.Count; i++)
{
var r = Rigidbodies[i];
r.isKinematic = _kinematicState[r];
if (!r.isKinematic)
{
r.velocity = Vector3.zero;
r.angularVelocity = Vector3.zero;
}
}
for (int i = 0; i < AerodynamicSurfaces.Count; i++)
{
AerodynamicSurfaces[i].Clear();
}
FlightStatistics.OnSpawn();
Controller.Clear();
for (int i = 0; i < _adaptiveTrailRenderers.Count; i++)
{
var adaptiveTrailRenderer = _adaptiveTrailRenderers[i];
adaptiveTrailRenderer.OnSpawn();
}
for (int i = 0; i < _jointControllers.Count; i++)
{
var jointController = _jointControllers[i];
jointController.OnSpawn();
}
}
private static Vector3 GetGyroError(float deltaTime, FlightStatistics target, Vector3 lastError, float smoothingSpeed)
{
Vector3 error = target.LocalAngularVelocity + target.LocalAngularAcceleration * 0.5f;
error = Quaternion.Euler(-90f, 0f, 0f) * error;
return(Vector3.Lerp(lastError, error, deltaTime * smoothingSpeed));
}
public void SetParachuteTarget(FlightStatistics target, Parachute parachute)
{
_target = target;
_targetType = AvatarType.Parachute;
_parachuteConfig.MinOrbitDistance = UnityParachuteFactory.OrbitDistance(parachute);
_transitionStartTime = _clock.CurrentTime;
}
public CharacterInput ApplyStabilization(CharacterInput input, FlightStatistics target, float deltaTime)
{
input = ApplyStallPrevention(input, target, _userConfig.StallLimiterStrength, _userConfig.RollLimiterStrength);
var stabilityInput = CharacterInput.Zero;
// Update gyroscopic stability
var error = GetGyroError(deltaTime, target, _lastGyroError, _c.ErrorSmoothingSpeed);
_lastGyroError = error;
var pids = GetGyroPidOutputs(error);
var gyroCorrection = PidOutputToCharacterInput(pids);
gyroCorrection = CharacterInput.Lerp(_lastGyroCorrection, gyroCorrection, _c.StabilityCorrectionSpeed * deltaTime);
_lastGyroCorrection = gyroCorrection;
stabilityInput += gyroCorrection;
// Apply stability overrides (Player input cancels out stabilization effects)
var stabilityOverride = GetStabilityOverrides(input, _c.MaxStabilityOverride);
stabilityInput = ApplyStabilityOverride(stabilityInput, stabilityOverride);
input += stabilityInput;
// Apply speed scaling to summed inputs
float normalizedSpeed = Mathf.Clamp01(target.RelativeVelocity.magnitude / _c.MaxSpeed);
return(ApplySpeedScaling(input, normalizedSpeed, _userConfig.InputSpeedScaling, 1.5f));
}
private void OnChallengeTriggered(int challengeIndex, FlightStatistics player)
{
// Disable all gates
for (int i = 0; i < _gates.Length; i++)
{
_gates[i].gameObject.SetActive(false);
}
var challenge = _challenges[challengeIndex];
_activeChallenge = Maybe.Just(challenge);
_coroutineScheduler.Run(BeginChallenge(challenge, player));
}
private IEnumerator <WaitCommand> BeginChallenge(IChallenge challenge, FlightStatistics player)
{
if (_isChallengeStarting)
{
Debug.LogError("Challenge '" + challenge.Name + "' start is triggered while another challenge '" +
_activeChallenge.Value.Name + "' is already starting");
yield break;
}
_isChallengeStarting = true;
Debug.Log("Starting challenge: " + challenge.Name);
yield return(WaitCommand.Interleave(
challenge.Begin(player),
_challengeAnnouncerUi.Introduce(challenge.ChallengeType.PrettyString(), Color.white, challenge.Name)));
_isChallengeStarting = false;
}
private void OnChallengeFinished(FlightStatistics player, FinishCondition finishCondition)
{
Debug.Log(_activeChallenge.Value.Name + " challenge finished");
_activeChallenge = Maybe.Nothing <Challenge>();
// Enable all gates
for (int i = 0; i < _gates.Length; i++)
{
_gates[i].gameObject.SetActive(true);
}
// TODO Allow players to restart a challenge
// Restart
// else {
// _coroutineScheduler.Run(BeginChallenge(_activeChallenge.Value, player));
// }
}
IEnumerator <WaitCommand> EmitParticles(FlightStatistics player)
{
using (var ps = _particleSystemPool.Take()) {
var velocity = player.WorldVelocity * 2f;
Debug.Log("player velocty " + player.WorldVelocity);
var psVelocity = ps.Instance.velocityOverLifetime;
psVelocity.xMultiplier = velocity.x;
psVelocity.yMultiplier = velocity.y;
psVelocity.zMultiplier = velocity.z;
ps.Instance.transform.position = _transform.position;
ps.Instance.Play();
// Wait until the last particle is emitted before disposing it
yield return(WaitCommand.WaitSeconds(
ps.Instance.main.duration +
ps.Instance.main.startLifetime.constant));
}
}
void Awake()
{
if (_statistics == null)
{
_statistics = gameObject.GetComponent <FlightStatistics>();
}
_collisionIndicatorRenderer = _collisionIndicator.GetComponent <Renderer>();
_collisionIndicatorLight = _collisionIndicator.GetComponent <Light>();
_collisionIndicatorRenderer.gameObject.SetActive(false);
InitializeLine();
Transform lineParent = AerodynamicsVisualizationManager.GetOrCreateLineParent();
// _line.rectTransform.SetParent(lineParent);
_isVisualizationActive = true;
}
public override IEnumerator <WaitCommand> Begin(FlightStatistics player)
{
_startTime = _clock.CurrentTime;
_nextRing = 0;
_ringsPassed.Clear();
_player = player;
for (int i = 0; i < _rings.Count; i++)
{
var ring = _rings[i];
ring.SetEnabled(true);
}
for (int i = 0; i < _turrets.Count; i++)
{
//_turrets[i].SetTarget(player);
_turrets[i].gameObject.SetActive(true);
}
_notificationList.AddTimedNotification(_activeLanguage.Table["course"] + ": " + Name, _notificationTimeout.Seconds());
Fmod.PlayOneShot("event:/Objects/ring_pass_start");
yield return(WaitCommand.DontWait);
}
public void SetWingsuitTarget(FlightStatistics target)
{
_target = target;
_targetType = AvatarType.Wingsuit;
_transitionStartTime = _clock.CurrentTime;
}
public void RemoveTarget()
{
_target = null;
}
public void SetTarget(FlightStatistics target, AvatarType avatarType)
{
_avatarType = avatarType;
_flightStats = target;
_prevSmoothAirSpeed = Vector3.zero;
}
private void OnPlayerRespawned(Events.PlayerSpawned evt)
{
_target = evt.Player.FlightStatistics;
}
private void OnPlayerSpawned(Events.PlayerSpawned evt)
{
_target = evt.Player.FlightStatistics;
enabled = true;
}
public abstract IEnumerator <WaitCommand> Begin(FlightStatistics player);
