private void applyRotation(float progress)
{
Quaternion quaternion;
float valueAt;
if (this.m_animation != null)
{
valueAt = AnimationCurveExtensions.GetValueAt(this.m_animation, progress);
}
else
{
valueAt = Easing.Apply(progress, this.m_rotation.easing);
}
if (this.m_rotation.lazy)
{
quaternion = Quaternion.Lerp(this.m_rotation.start, this.m_rotation.target, valueAt);
}
else
{
quaternion = Quaternion.Euler(this.m_rotation.start.eulerAngles + ((Vector3)(this.m_rotation.rotateBy * valueAt)));
}
Vector3 eulerAngles = quaternion.eulerAngles;
if (this.m_rotation.local)
{
Vector3 vector2 = this.m_transform.localRotation.eulerAngles;
this.m_transform.localRotation = Quaternion.Euler(new Vector3(!this.m_rotation.axis[0] ? vector2.x : eulerAngles.x, !this.m_rotation.axis[1] ? vector2.y : eulerAngles.y, !this.m_rotation.axis[2] ? vector2.z : eulerAngles.z));
}
else
{
Vector3 vector3 = this.m_transform.rotation.eulerAngles;
this.m_transform.rotation = Quaternion.Euler(new Vector3(!this.m_rotation.axis[0] ? vector3.x : eulerAngles.x, !this.m_rotation.axis[1] ? vector3.y : eulerAngles.y, !this.m_rotation.axis[2] ? vector3.z : eulerAngles.z));
}
}
protected void Update()
{
for (int i = this.m_activeResourceAnimations.Count - 1; i >= 0; i--)
{
ResourceAnimation item = this.m_activeResourceAnimations[i];
bool flag = true;
int num2 = 0;
double num3 = 0.0;
for (int j = 0; j < item.NumSprites; j++)
{
if (!item.CleanupFlag[j])
{
Vector3 vector2;
item.ElapsedTime[j] += Time.unscaledDeltaTime;
float v = Mathf.Clamp01(item.ElapsedTime[j] / item.Lifetime[j]);
float t = Easing.Apply(v, item.TranslationEasingFunction);
Vector2 screenPoint = Vector2.Lerp(item.SourceScreenPos[j], item.TargetScreenPos[j], t) + ((Vector2)(item.OffsetScreen[j] * Mathf.Sin(v * 3.141593f)));
RectTransformUtility.ScreenPointToWorldPointInRectangle(this.RootTm, screenPoint, this.m_canvasCam, out vector2);
item.ImageTm[j].position = vector2;
if (item.ElapsedTime[j] > item.Lifetime[j])
{
item.CleanupFlag[j] = true;
Binder.ResourceGainImagePool.returnObject(item.Image[j]);
item.Image[j] = null;
num2++;
num3 += item.ResourceChunks[item.ResourceChunkIndex++];
}
else
{
flag = false;
}
}
}
if ((num2 > 0) && (item.EndCallback != null))
{
item.EndCallback(num2, item.NumSprites, num3, item.FromMenu);
}
if (flag)
{
this.m_activeResourceAnimations.Remove(item);
this.m_resourceAnimationPool.returnObject(item);
}
}
}
private void applyTranslationToAnchoredPos(float progress)
{
float valueAt;
Vector2 zero = Vector2.zero;
if (this.m_animation != null)
{
valueAt = AnimationCurveExtensions.GetValueAt(this.m_animation, progress);
}
else
{
valueAt = Easing.Apply(progress, this.m_translationAnchoredPosition.easing);
}
if (this.m_translationAnchoredPosition.algorithm == TranslationAlgorithm.LINEAR)
{
zero = this.m_translationAnchoredPosition.start + ((Vector2)((this.m_translationAnchoredPosition.target - this.m_translationAnchoredPosition.start) * valueAt));
}
this.m_rectTransform.anchoredPosition = new Vector2(zero.x, zero.y);
}
private void applyTranslation(float progress)
{
float valueAt;
Vector3 zero = Vector3.zero;
if (this.m_animation != null)
{
valueAt = AnimationCurveExtensions.GetValueAt(this.m_animation, progress);
}
else
{
valueAt = Easing.Apply(progress, this.m_translation.easing);
}
if (this.m_translation.algorithm == TranslationAlgorithm.LINEAR)
{
zero = this.m_translation.start + ((Vector3)((this.m_translation.target - this.m_translation.start) * valueAt));
}
else if (this.m_translation.algorithm == TranslationAlgorithm.CATMULL_ROM)
{
zero = MathUtil.CatmullRom(valueAt, this.m_translation.start + this.m_translation.cp0, this.m_translation.start, this.m_translation.target, this.m_translation.target + this.m_translation.cp1);
}
else if (this.m_translation.algorithm == TranslationAlgorithm.QUADRATIC_BEZIER)
{
zero = MathUtil.QuadraticBezier(valueAt, this.m_translation.start, this.m_translation.cp0, this.m_translation.target);
}
else if (this.m_translation.algorithm == TranslationAlgorithm.CUBIC_BEZIER)
{
zero = MathUtil.CubicBezier(valueAt, this.m_translation.start, this.m_translation.cp0, this.m_translation.cp1, this.m_translation.target);
}
else if (this.m_translation.algorithm == TranslationAlgorithm.QUARTIC_BEZIER)
{
zero = MathUtil.QuarticBezier(valueAt, this.m_translation.start, this.m_translation.cp0, this.m_translation.cp1, this.m_translation.cp2, this.m_translation.target);
}
if (this.m_translation.local)
{
this.m_transform.localPosition = new Vector3(!this.m_translation.axis[0] ? this.m_transform.localPosition.x : zero.x, !this.m_translation.axis[1] ? this.m_transform.localPosition.y : zero.y, !this.m_translation.axis[2] ? this.m_transform.localPosition.z : zero.z);
}
else
{
this.m_transform.position = new Vector3(!this.m_translation.axis[0] ? this.m_transform.position.x : zero.x, !this.m_translation.axis[1] ? this.m_transform.position.y : zero.y, !this.m_translation.axis[2] ? this.m_transform.position.z : zero.z);
}
}
// ********************************************************************
// Function: LateUpdate()
// Purpose: Called once per frame, after other objects have
// updated.
// ********************************************************************
void LateUpdate()
{
if (!m_lerp && m_player.GetAxis(m_scrollAxis) < 0)
{
PreviousScreen();
}
if (!m_lerp && m_player.GetAxis(m_scrollAxis) > 0)
{
NextScreen();
}
if (m_lerp)
{
float xPos = m_lerpTarget.x;
if (Time.time - m_lerpStartTime < m_lerpCurrentDuration)
{
xPos = Easing.Apply(EasingFunction.QuadEaseOut,
Time.time - m_lerpStartTime,
m_lerpStartPos.x,
m_lerpTarget.x - m_lerpStartPos.x,
m_lerpCurrentDuration);
m_screensContainer.localPosition = new Vector3(xPos, m_screensContainer.localPosition.y, m_screensContainer.localPosition.z);
}
else
{
m_lerp = false;
m_momentumEffectivelyStopped = true;
m_screensContainer.localPosition = new Vector3(xPos, m_screensContainer.localPosition.y, m_screensContainer.localPosition.z);
m_contentsStartPoint = m_screensContainer.localPosition; // to keep current drag in right place
}
}
else if (!m_dragScrollControlScheme.Contains(InputManager.controlScheme) || (m_allowDragOff && !m_allowingThisDrag && m_currentlyDragging))
{
m_screensContainer.localPosition = m_contentsStartPoint;
}
m_centerItem = GetCenterItemIndex();
}
private void applyScaling(float progress)
{
float valueAt;
if (this.m_animation != null)
{
valueAt = AnimationCurveExtensions.GetValueAt(this.m_animation, progress);
}
else
{
valueAt = Easing.Apply(progress, this.m_scaling.easing);
}
Vector3 scale = this.m_scaling.start + ((Vector3)((this.m_scaling.target - this.m_scaling.start) * valueAt));
if (this.m_scaling.local)
{
this.m_transform.localScale = new Vector3(!this.m_scaling.axis[0] ? this.m_transform.localScale.x : scale.x, !this.m_scaling.axis[1] ? this.m_transform.localScale.y : scale.y, !this.m_scaling.axis[2] ? this.m_transform.localScale.z : scale.z);
}
else
{
scale = new Vector3(!this.m_scaling.axis[0] ? this.m_transform.lossyScale.x : scale.x, !this.m_scaling.axis[1] ? this.m_transform.lossyScale.y : scale.y, !this.m_scaling.axis[2] ? this.m_transform.lossyScale.z : scale.z);
TransformExtensions.SetWorldScale(this.m_transform, scale);
}
}
protected override bool onGetTargetAnimationState(out AbstractCharacterAnimator.State state, out float speed)
{
speed = 1f;
state = AbstractCharacterAnimator.State.IDLE;
if (base.CharacterView.Character.isAttacking())
{
return(false);
}
if (base.CharacterView.Character.isExecutingSkill(SkillType.Whirlwind) || base.CharacterView.Character.isExecutingSkill(SkillType.Dash))
{
return(false);
}
if ((base.CharacterView.Character.TargetCharacter == null) && (base.CharacterView.Character.ManualTargetPos == Vector3.zero))
{
state = AbstractCharacterAnimator.State.IDLE;
return(true);
}
if (base.CharacterView.Character.ExternallyControlled)
{
if (base.CharacterView.Character.SpinningAround)
{
state = AbstractCharacterAnimator.State.RUN;
speed = 2f;
return(true);
}
state = AbstractCharacterAnimator.State.IDLE;
return(true);
}
if (base.CharacterView.Character.Velocity != Vector3.zero)
{
speed = Mathf.Clamp(1.15f + ((base.CharacterView.Character.MovementSpeed(true) * 0.05f) * Easing.Apply(base.CharacterView.Character.RunAccelerationTimer.normalizedProgress(), ConfigGameplay.CHARACTER_FULLSPEED_ACCELERATION_EASING)), 0.1f, float.MaxValue);
state = AbstractCharacterAnimator.State.RUN;
return(true);
}
return(base.onGetTargetAnimationState(out state, out speed));
}