// public static void SetAlpha (this tk2dTextMesh self, float alpha) {
// Color next = self.color;
// next.a = Mathf.Clamp01 ( alpha );
// self.color = next;
// }
public static Color ColorTranslate(Color a, Color b, EaseUtils.EaseType easeType, float t)
{
Color ret = a;
ret.r = EaseUtils.Ease(easeType, a.r, b.r, t);
ret.g = EaseUtils.Ease(easeType, a.g, b.g, t);
ret.b = EaseUtils.Ease(easeType, a.b, b.b, t);
ret.a = EaseUtils.Ease(easeType, a.a, b.a, t);
return(ret);
}
public static float EaseInOutBounce(float start, float end, float value)
{
end -= start;
float num = 1f;
if (value < num / 2f)
{
return(EaseUtils.EaseInBounce(0f, end, value * 2f) * 0.5f + start);
}
return(EaseUtils.EaseOutBounce(0f, end, value * 2f - num) * 0.5f + end * 0.5f + start);
}
protected IEnumerator tweenValue_cr(float start, float end, float time, EaseUtils.EaseType ease, TweenUpdateHandler updateCallback)
{
float t = 0f;
while (t < time)
{
float val = t / time;
updateCallback?.Invoke(EaseUtils.Ease(ease, start, end, val));
t += this.LocalDeltaTime;
yield return(null);
}
updateCallback?.Invoke(end);
yield return(null);
}
void Up_Tick()
{
_timer += CupheadTime.Delta[CupheadTime.Layer.Enemy];
transform.SetPosition(
EaseUtils.Linear(_startPosition.x, _upPosition.x, _timer / UpDuration),
EaseUtils.Linear(_startPosition.y, _upPosition.y, _timer / UpDuration)
);
if (_timer >= UpDuration)
{
currentState = State.Track;
}
}
private IEnumerator goTo_cr(float start, float end, float time, EaseUtils.EaseType ease)
{
float t = 0f;
base.transform.SetLocalPosition(null, start, null);
while (t < time)
{
float val = t / time;
base.transform.SetLocalPosition(null, EaseUtils.Ease(ease, start, end, val), null);
t += CupheadTime.GlobalDelta;
yield return(StartCoroutine(base.WaitForPause_CR()));
}
base.transform.SetLocalPosition(null, end, null);
}
static public IEnumerator TweenValue_cr(float start, float end, float time, EaseUtils.EaseType ease, TweenUpdateHandler updateCallback, TweenCompletedHandler endCallback = null)
{
float t = 0f;
while (t < time)
{
float val = t / time;
updateCallback?.Invoke(EaseUtils.Ease(ease, start, end, val));
t += CupheadTime.GlobalDelta;
yield return(null);
}
updateCallback?.Invoke(end);
endCallback?.Invoke();
yield return(null);
}
public static float EaseInOut(EaseType inEase, EaseType outEase, float start, float end, float value)
{
if (value < 0.5f)
{
float value2 = Mathf.Clamp(value * 2f, 0f, 1f);
float end2 = Mathf.Lerp(start, end, 0.5f);
return(EaseUtils.Ease(inEase, start, end2, value2));
}
if (value > 0.5f)
{
float value2 = Mathf.Clamp(value * 2f - 1f, 0f, 1f);
float start2 = Mathf.Lerp(start, end, 0.5f);
return(EaseUtils.Ease(outEase, start2, end, value2));
}
return(Mathf.Lerp(start, end, 0.5f));
}
static public IEnumerator TweenPosition_cr(Transform target, Vector3 start, Vector3 end, float time, EaseUtils.EaseType ease)
{
target.position = start;
float t = 0f;
while (t < time)
{
float val = t / time;
float x = EaseUtils.Ease(ease, start.x, end.x, val);
float y = EaseUtils.Ease(ease, start.y, end.y, val);
float z = EaseUtils.Ease(ease, start.z, end.z, val);
target.SetPosition(x, y, z);
t += CupheadTime.GlobalDelta;
yield return(null);
}
target.position = end;
yield return(null);
}
static public IEnumerator TweenScale_cr(Transform transform, Vector2 start, Vector2 end, float time, EaseUtils.EaseType ease, CupheadTime.Layer timeLayer, TweenCompletedHandler endCallback = null)
{
transform.SetScale(start.x, start.y, null);
float t = 0f;
while (t < time)
{
float val = t / time;
float x = EaseUtils.Ease(ease, start.x, end.x, val);
float y = EaseUtils.Ease(ease, start.y, end.y, val);
transform.SetScale(x, y, null);
t += CupheadTime.Delta[timeLayer];
yield return(null);
}
transform.SetScale(end.x, end.y, null);
endCallback?.Invoke();
yield return(null);
}
private IEnumerator tweenPosition_cr(Vector2 start, Vector2 end, float time, EaseUtils.EaseType ease, TweenUpdateHandler updateCallback = null)
{
this.transform.position = start;
float t = 0f;
while (t < time)
{
float val = t / time;
float x = EaseUtils.Ease(ease, start.x, end.x, val);
float y = EaseUtils.Ease(ease, start.y, end.y, val);
this.transform.SetPosition(x, y, 0f);
updateCallback?.Invoke(val);
t += this.LocalDeltaTime;
yield return(null);
}
this.transform.position = end;
updateCallback?.Invoke(1f);
yield return(null);
}
static public IEnumerator TweenLocalPosition_cr(Transform target, Vector3 start, Vector3 end, float time, EaseUtils.EaseType ease, CupheadTime.Layer timeLayer, TweenUpdateHandler updateCallback, TweenCompletedHandler endCallback = null)
{
target.localPosition = start;
float t = 0f;
while (t < time)
{
float val = t / time;
float x = EaseUtils.Ease(ease, start.x, end.x, val);
float y = EaseUtils.Ease(ease, start.y, end.y, val);
float z = EaseUtils.Ease(ease, start.z, end.z, val);
target.SetLocalPosition(x, y, z);
updateCallback?.Invoke(val);
t += CupheadTime.Delta[timeLayer];
yield return(null);
}
target.localPosition = end;
updateCallback?.Invoke(1f);
endCallback?.Invoke();
yield return(null);
}
static public IEnumerator TweenSpriteRendererColor_cr(SpriteRenderer renderer, Color start, Color end, float time, EaseUtils.EaseType ease, CupheadTime.Layer timeLayer, TweenCompletedHandler endCallback = null)
{
float t = 0f;
Color c = start;
while (t < time)
{
float val = t / time;
c.r = EaseUtils.Ease(ease, start.r, end.r, val);
c.g = EaseUtils.Ease(ease, start.g, end.g, val);
c.b = EaseUtils.Ease(ease, start.b, end.b, val);
c.a = EaseUtils.Ease(ease, start.a, end.a, val);
renderer.color = c;
t += CupheadTime.Delta[timeLayer];
yield return(null);
}
endCallback?.Invoke();
yield return(null);
}
private IEnumerator tweenLocalRotation2D_cr(float start, float end, float time, EaseUtils.EaseType ease, TweenUpdateHandler updateCallback = null)
{
this.transform.SetLocalEulerAngles(null, null, start);
float t = 0f;
while (t < time)
{
float val = t / time;
this.transform.SetLocalEulerAngles(null, null, EaseUtils.Ease(ease, start, end, val));
if (updateCallback != null)
{
updateCallback(val);
}
float num = t + this.LocalDeltaTime;
yield return(null);
}
this.transform.SetLocalEulerAngles(null, null, end);
if (updateCallback != null)
{
updateCallback(1f);
}
yield return(null);
}
public static float Ease(EaseType ease, float start, float end, float value)
{
switch (ease)
{
case EaseType.easeInBack:
return(EaseUtils.EaseInBack(start, end, value));
case EaseType.easeInBounce:
return(EaseUtils.EaseInBounce(start, end, value));
case EaseType.easeInCirc:
return(EaseUtils.EaseInCirc(start, end, value));
case EaseType.easeInCubic:
return(EaseUtils.EaseInCubic(start, end, value));
case EaseType.easeInElastic:
return(EaseUtils.EaseInElastic(start, end, value));
case EaseType.easeInExpo:
return(EaseUtils.EaseInExpo(start, end, value));
case EaseType.easeInOutBack:
return(EaseUtils.EaseInOutBack(start, end, value));
case EaseType.easeInOutBounce:
return(EaseUtils.EaseInOutBounce(start, end, value));
case EaseType.easeInOutCirc:
return(EaseUtils.EaseInOutCirc(start, end, value));
case EaseType.easeInOutCubic:
return(EaseUtils.EaseInOutCubic(start, end, value));
case EaseType.easeInOutElastic:
return(EaseUtils.EaseInOutElastic(start, end, value));
case EaseType.easeInOutExpo:
return(EaseUtils.EaseInOutExpo(start, end, value));
case EaseType.easeInOutQuad:
return(EaseUtils.EaseInOutQuad(start, end, value));
case EaseType.easeInOutQuart:
return(EaseUtils.EaseInOutQuart(start, end, value));
case EaseType.easeInOutQuint:
return(EaseUtils.EaseInOutQuint(start, end, value));
case EaseType.easeInOutSine:
return(EaseUtils.EaseInOutSine(start, end, value));
case EaseType.easeInQuad:
return(EaseUtils.EaseInQuad(start, end, value));
case EaseType.easeInQuart:
return(EaseUtils.EaseInQuart(start, end, value));
case EaseType.easeInQuint:
return(EaseUtils.EaseInQuint(start, end, value));
case EaseType.easeInSine:
return(EaseUtils.EaseInSine(start, end, value));
case EaseType.easeOutBack:
return(EaseUtils.EaseOutBack(start, end, value));
case EaseType.easeOutBounce:
return(EaseUtils.EaseOutBounce(start, end, value));
case EaseType.easeOutCirc:
return(EaseUtils.EaseOutCirc(start, end, value));
case EaseType.easeOutCubic:
return(EaseUtils.EaseOutCubic(start, end, value));
case EaseType.easeOutElastic:
return(EaseUtils.EaseOutElastic(start, end, value));
case EaseType.easeOutExpo:
return(EaseUtils.EaseOutExpo(start, end, value));
case EaseType.easeOutQuad:
return(EaseUtils.EaseOutQuad(start, end, value));
case EaseType.easeOutQuart:
return(EaseUtils.EaseOutQuart(start, end, value));
case EaseType.easeOutQuint:
return(EaseUtils.EaseOutQuint(start, end, value));
case EaseType.easeOutSine:
return(EaseUtils.EaseOutSine(start, end, value));
case EaseType.spring:
return(EaseUtils.Spring(start, end, value));
default:
return(Mathf.Lerp(start, end, value));
}
}
