private IEnumerator ProcessOpen(bool status, float targetPosition)
{
_opened = status;
PlayerInput.AllInputBlocked = status;
_targetPosition = status ? targetPosition : _closedWindowPosition;
yield return(null);
if (_opened)
{
OnConsoleOpened?.Invoke();
_commandInput.ActivateInputField();
}
else
{
OnConsoleClosed?.Invoke();
_commandInput.DeactivateInputField();
}
var min = _tf.anchorMin;
var max = _tf.anchorMax;
var lerpHolder = new LerpHolder();
lerpHolder.RestartLerp(min.y, _targetPosition, _positionLerpTime, true);
while (!lerpHolder.IsFinished)
{
min.y = lerpHolder.GetLerpValue();
max.y = min.y + 1;
_tf.anchorMin = min;
_tf.anchorMax = max;
yield return(null);
}
}
public void OnPoolSpawned()
{
float duration;
//if (!ParticleC== null) {
// duration = ParticleC.lifetime + ParticleC.lifetimeOffset;
//}
if (_particle != null)
{
duration = _particle.main.duration;
}
else
{
duration = _defaultDuration;
}
_lerp.RestartLerp(0, 1, duration);
if (_unscaled)
{
TimeManager.StartUnscaled(UpdateLight());
}
else
{
TimeManager.StartTask(UpdateLight());
}
}
private void MovementUpdateInternal(float deltaTime)
{
// a = v/t, should probably expose as a variable
var acceleration = MaxSpeed / 0.4f;
// Get our current position. We read from transform.position as few times as possible as it is relatively slow
// (at least compared to a local variable)
var currentPosition = Tr.position;
// Update which point we are moving towards
_interpolator.MoveToCircleIntersection2D(currentPosition, _pickNextWaypointDist, _movementPlane);
var dir = _movementPlane.ToPlane(SteeringTargetV3 - currentPosition);
// Calculate the distance to the end of the path
var distanceToEnd = dir.magnitude + MathEx.Max(0, _interpolator.remainingDistance);
// Check if we have reached the target
var prevTargetReached = TargetReached;
TargetReached = distanceToEnd <= _endReachedDistance && _interpolator.valid;
if (!prevTargetReached && TargetReached)
{
MovementCompleted();
}
// Check if we have a valid path to follow and some other script has not stopped the character
float slowdown = 1;
if (_interpolator.valid)
{
// How fast to move depending on the distance to the destination.
// Move slower as the character gets closer to the destination.
// This is always a value between 0 and 1.
if (distanceToEnd < _slowdownDistance)
{
slowdown = Mathf.Sqrt(distanceToEnd / _slowdownDistance);
_slowLerp.Enabled = false;
}
else
{
if (_interpolator.ShouldSlow())
{
if (!_slowLerp.Enabled)
{
_slowLerp.RestartLerp(1, 0, _slowdownTime);
}
slowdown = _slowLerp.GetLerpValue();
}
else
{
_slowLerp.Enabled = false;
}
}
if (TargetReached && _goToExactEndPoint)
{
// Slow down as quickly as possible
_velocity2D -= Vector2.ClampMagnitude(_velocity2D, acceleration * deltaTime);
}
else
{
// Normalized direction of where the agent is looking
var forwards = _movementPlane.ToPlane(Tr.rotation * Vector3.forward);
_velocity2D += MovementUtilities.CalculateAccelerationToReachPoint(dir, dir.normalized * MaxSpeed, _velocity2D, acceleration, _rotationSpeed, MaxSpeed, forwards) * deltaTime;
}
}
else
{
slowdown = 1;
// Slow down as quickly as possible
_velocity2D -= Vector2.ClampMagnitude(_velocity2D, acceleration * deltaTime);
}
_velocity2D = MovementUtilities.ClampVelocity(
_velocity2D, MaxSpeed, slowdown, _slowWhenNotFacingTarget,
_movementPlane.ToPlane(Tr.forward));
ApplyGravity(deltaTime);
if (_rvoController != null && _rvoController.enabled)
{
// Send a message to the RVOController that we want to move
// with this velocity. In the next simulation step, this
// velocity will be processed and it will be fed back to the
// rvo controller and finally it will be used by this script
// when calling the CalculateMovementDelta method below
// Make sure that we don't move further than to the end point
// of the path. If the RVO simulation FPS is low and we did
// not do this, the agent might overshoot the target a lot.
var rvoTarget = currentPosition + _movementPlane.ToWorld(Vector2.ClampMagnitude(_velocity2D, distanceToEnd), 0f);
_rvoController.SetTarget(rvoTarget, _velocity2D.magnitude, MaxSpeed);
}
Vector2 desiredRotationDirection;
if (_rvoController != null && _rvoController.enabled)
{
// When using local avoidance, use the actual velocity we are moving with (delta2D/deltaTime) if that velocity
// is high enough, otherwise fall back to the velocity that we want to move with (velocity2D).
// The local avoidance velocity can be very jittery when the character is close to standing still
// as it constantly makes small corrections. We do not want the rotation of the character to be jittery.
//var actualVelocity = delta2D / deltaTime;
var actualVelocity = _lastDeltaPosition / _lastDeltaTime;
desiredRotationDirection = Vector2.Lerp(_velocity2D, actualVelocity, 4 * actualVelocity.magnitude / (MaxSpeed + 0.0001f));
}
else
{
desiredRotationDirection = _velocity2D;
}
var delta2D = _lastDeltaPosition = CalculateDeltaToMoveThisFrame(_movementPlane.ToPlane(currentPosition), distanceToEnd, deltaTime);
// Rotate towards the direction we are moving in
var currentRotationSpeed = _rotationSpeed * MathEx.Max(0, (slowdown - 0.3f) / 0.7f);
RotateTowards(desiredRotationDirection, currentRotationSpeed * deltaTime);
var deltaPosition = _movementPlane.ToWorld(delta2D, _verticalVelocity * deltaTime);
Move(currentPosition, deltaPosition);
}