private IEnumerator Despawn(float length)
{
_hideTween.Restart(_group.alpha, 0, length);
while (_hideTween.Active)
{
_group.alpha = _hideTween.Get();
yield return(null);
}
ItemPool.Despawn(gameObject);
}
private IEnumerator TransitionRenderTexture(float totalTime, float extraPause)
{
yield return(extraPause);
_normalFade.Restart(0, 1, totalTime);
while (_normalFade.Active)
{
_rtMaterial.SetFloat("_Cutoff", _normalFade.Get());
yield return(null);
}
_image.enabled = false;
_canvasGroup.alpha = 0;
}
private IEnumerator DamageTween()
{
_animatingColor = true;
var modelComponent = this.GetEntity().Get <ModelComponent>();
var blocks = modelComponent.GetMatBlocks;
if (blocks == null)
{
yield break;
}
var renderers = modelComponent.GetRenderers;
if (renderers == null)
{
yield break;
}
Color[] colors = new Color[blocks.Length];
Color[] emissive = new Color[blocks.Length];
for (int i = 0; i < blocks.Length; i++)
{
colors[i] = renderers[i].sharedMaterial.GetColor(_shaderColor);
emissive[i] = renderers[i].sharedMaterial.GetColor(_shaderEmissive);
blocks[i].SetColor(_shaderColor, Color.red);
blocks[i].SetColor(_shaderEmissive, Color.red);
}
modelComponent.ApplyMaterialBlocks(blocks);
_scaleDmgTween.Restart(1, _dmgMaxScale);
var scale = _spriteRender.transform.localScale;
while (_scaleDmgTween.Active)
{
_spriteRender.transform.localScale = new Vector3(scale.x * _scaleDmgTween.Get(),
scale.y, scale.z);
yield return(null);
}
_scaleDmgTween.Restart(_dmgMaxScale, 1);
while (_scaleDmgTween.Active)
{
_spriteRender.transform.localScale = new Vector3(scale.x * _scaleDmgTween.Get(),
scale.y, scale.z);
for (int i = 0; i < blocks.Length; i++)
{
blocks[i].SetColor(_shaderColor, Color.Lerp(Color.red, colors[i], _scaleDmgTween.Get()));
blocks[i].SetColor(_shaderEmissive, Color.Lerp(Color.red, emissive[i], _scaleDmgTween.Get()));
}
modelComponent.ApplyMaterialBlocks(blocks);
yield return(null);
}
_animatingColor = false;
}
public void OnSystemUpdate(float delta)
{
if (_actor != null && _statTween.Active)
{
_statSlider.value = _statTween.Get();
}
}
private void CheckSliders(CharacterNode unit)
{
_state = State.Waiting;
if (!_healthTween.Active)
{
var healthPercent = unit.GetVital(_targetVital).CurrentPercent;
var statDifference = Math.Abs(_healthSlider.value - healthPercent);
if (statDifference > 0.01f)
{
_healthTween.Restart
(_healthSlider.value, healthPercent, Mathf.Lerp(0.15f, _maxTweenLength, statDifference));
}
}
else
{
_state = State.Active;
_healthSlider.value = _healthTween.Get();
}
//if (!_shieldTween.Active) {
// //var shieldPercent = unit.VitalStats[Vitals.Shield].CurrentPercent;
// var statDifference = Math.Abs(_shieldSlider.value - shieldPercent);
// if ( statDifference > 0.01f) {
// _shieldTween.Restart
// (_shieldSlider.value, shieldPercent, Mathf.Lerp(0.15f, _maxTweenLength, statDifference));
// }
//}
//else {
// _shieldSlider.value = _shieldTween.Get();
// _state = State.Active;
//}
}
public override void UpdateMovement(Vector3 moveVector, bool isForward, ref Vector3 moveDirection)
{
if (!_addedVector)
{
SurfaceDetector.main.PlayJumpingSound(_context);
if (moveVector.magnitude < 0.15f)
{
var screenMovementSpace = Quaternion.Euler(0f, Player.Cam.transform.eulerAngles.y, 0f);
var forwardVector = screenMovementSpace * Vector3.forward * -2;
var rightVector = screenMovementSpace * Vector3.right * 0;
moveDirection = forwardVector + rightVector;
}
_dodgeVector = moveDirection * Settings.DodgeForce;
_dodgeVector.y = Settings.DodgeForce * 0.5f;
_dodgeTween = new TweenFloat(0, 1, Settings.DodgeLength, Settings.DodgeEase, true);
_dodgeTween.Init();
_addedVector = true;
}
moveDirection = _dodgeVector * _dodgeTween.Get();
//moveDirection = FallVector(moveDirection);
if (!_dodgeTween.Active)
{
_machine.ChangeState <FpNormalState>();
}
}
private IEnumerator FadeIn()
{
_revealTween.Restart(0, 1);
while (_revealTween.Active)
{
_group.alpha = _revealTween.Get();
yield return(null);
}
}
private IEnumerator FadeInItem()
{
var tweener = new TweenFloat(0, 1, 0.5f, EasingTypes.SinusoidalInOut, true);
tweener.Init();
while (tweener.Active)
{
for (int i = 0; i < _entity.Renderers.Length; i++)
{
_entity.Renderers[i].material.SetFloat("_DissolveAmount", tweener.Get());
}
yield return(null);
}
}
public IEnumerator CloseRadial()
{
_state = State.Closing;
_fadeOut.Restart(1, 0);
if (_currentLayer != null)
{
_currentLayer.StartClose();
}
while (true)
{
if (_fadeOut.Active)
{
_canvasGroup.alpha = _fadeOut.Get();
}
if (_currentLayer != null)
{
if (_currentLayer.TransitionComplete() && !_fadeOut.Active)
{
break;
}
}
else
{
if (!_fadeOut.Active)
{
break;
}
}
yield return(null);
}
if (_currentLayer != null)
{
_currentLayer.Pool();
_currentLayer = null;
}
for (int i = 0; i < _previousLayers.Count; i++)
{
_previousLayers[i].Pool();
}
_previousLayers.Clear();
_canvasGroup.SetActive(false);
if (GameOptions.PauseForInput)
{
Game.RemovePause("Radial");
}
Game.RemoveCursorUnlock("Radial");
_state = State.Disabled;
}
public override void UpdateTween()
{
_canvasGroup.alpha = _tweener.Get();
if (!_adjustInteractive)
{
return;
}
if (_canvasGroup.alpha >= 0.99f)
{
_canvasGroup.interactable = _canvasGroup.blocksRaycasts = true;
}
else if (_canvasGroup.alpha <= 0.01f)
{
_canvasGroup.interactable = _canvasGroup.blocksRaycasts = false;
}
}
public IEnumerator SetTargetText(string text, float duration, Vector3 end, Color color)
{
_text.text = text;
_text.color = _defaultColor;
_moveTween.Restart(transform.position, end, duration);
_colorTween.Restart(0, 1, duration);
while (_moveTween.Active)
{
_text.color = Color.Lerp(_defaultColor, _endColor, _colorTween.Get());
transform.position = _moveTween.Get();
transform.LookAt(transform.position + Player.Cam.transform.rotation * Vector3.forward,
Player.Cam.transform.rotation * Vector3.up);
//_text.fontSize = Vector3.Distance(transform.position, Player.Cam.transform.position) * 0.35f;
yield return(null);
}
ItemPool.Despawn(gameObject);
}
private IEnumerator PainAnimation()
{
_image.color = _painColor;
_image.material = null;
_image.texture = null;
_image.enabled = true;
_canvasGroup.alpha = _maxAlpha;
yield return(_painHoldTime);
_painEnd.Restart(_maxAlpha, 0);
while (_painEnd.Active)
{
_canvasGroup.alpha = _painEnd.Get();
yield return(null);
}
_image.enabled = false;
}
private IEnumerator UpdateBar(CharacterNode unit, float offset)
{
_healthSlider.value = unit.GetVital(_targetVital).CurrentPercent;
//_shieldSlider.value = unit.VitalStats[Vitals.Shield].CurrentPercent;
_endTime = TimeManager.Time + _timeOut;
_state = State.Waiting;
transform.position = unit.Entity.GetPosition();
_canvasGroup.alpha = 1;
var v3Offset = new Vector3(0, offset, 0);
while (true)
{
transform.position = unit.Entity.GetPosition() + v3Offset;
Player.Cam.FaceCamera(transform, false);
if (_state != State.Fading)
{
CheckSliders(unit);
}
if (_state == State.Waiting && TimeManager.Time > _endTime)
{
_fadeTween.Restart(1, 0);
_state = State.Fading;
}
if (_state == State.Fading)
{
if (_fadeTween.Active)
{
_canvasGroup.alpha = _fadeTween.Get();
}
else
{
break;
}
}
yield return(null);
}
_activeBars.Remove(unit);
ItemPool.Despawn(gameObject);
}
void Update()
{
if (_tween != null && _tween.Active)
{
_canvasGroup.alpha = _tween.Get();
}
switch (_state)
{
case State.Disabled:
return;
case State.WaitingToDisable:
if (!_waitTimer.IsActive)
{
_state = State.Disabled;
SetFadeTooltip(false);
}
break;
case State.WaitingToShow:
if (!_waitTimer.IsActive)
{
_state = State.Showing;
SetFadeTooltip(true);
}
break;
//case State.Showing:
// //_rect.position = GetMouseRectPosition();
// AnchorPosition();
// LerpPosition();
// break;
}
if (Cursor.lockState == CursorLockMode.Locked || !PlayerInputSystem.IsCursorOverUI)
{
HideTooltip();
}
}
void Update()
{
if (_state == State.Disabled || _state == State.Closing)
{
return;
}
switch (_state)
{
case State.Opening:
if (_fadeIn.Active)
{
_canvasGroup.alpha = _fadeIn.Get();
}
if (_currentLayer.TransitionComplete() && !_fadeIn.Active)
{
_state = State.Open;
}
break;
case State.Changing:
if (_currentLayer.TransitionComplete() && _nextLayer.TransitionComplete())
{
_currentLayer = _nextLayer;
_state = State.Open;
}
break;
}
//hurry up is breaking animation fix later
if (_currentLayer == null || _currentLayer.IsTransitioningOut || _state == State.Opening)
{
return;
}
_currentControl = ControlMethod.None;
TouchInput();
ControllerInput();
MouseInput();
}
public override void PlayFrame(float normalized)
{
_canvasGroup.alpha = _tweener.Get(normalized);
}
