public float Ease(LerpType type, float duracion)
{
float lerpTime = duracion;
currentLerpTime += Time.deltaTime;
float t = currentLerpTime / lerpTime;
switch(type)
{
case LerpType.Linear:
return t;
case LerpType.In:
t = Mathf.Sin(t * Mathf.PI * 0.5f);
break;
case LerpType.Out:
t = t*t;
break;
case LerpType.Smooth:
t = t*t*t * (t * (6f*t - 15f) + 10f);
break;
}
if (currentLerpTime > lerpTime) {
currentLerpTime = lerpTime;
}
return t;
}
public void OffScreen(float updatedLerpTime, LerpType overrideType)
{
SetActive();
originalLerpTime = lerpTime;
lerpTime = updatedLerpTime;
needToResetLerpTime = true;
OffScreenOverride(overrideType);
}
public AnimationPosition(AnimationPosition source) : base(source)
{
fromPos = source.fromPos;
toPos = source.toPos;
lerpType = source.lerpType;
posType = source.posType;
isFromTarget = source.isFromTarget;
}
public AnimationPosition(RectTransform target, float length, AnimationCurve curve, Vector3 from_pos, Vector3 to_pos, LerpType lerp_type, PosType pos_type, bool is_from_target) : base(target, length, curve)
{
fromPos = from_pos;
toPos = to_pos;
lerpType = lerp_type;
posType = pos_type;
isFromTarget = is_from_target;
}
public RotateLevelData(float activeTime, float angle, float time, LerpType lerpType, int level)
{
this.activeTime = activeTime;
this.angle = angle;
this.time = time;
this.lerpType = lerpType;
this.level = level;
}
public EnlargeLevelData(float activeTime, float rate, float time, LerpType lerpType, int level)
{
this.activeTime = activeTime;
this.rate = rate;
this.time = time;
this.lerpType = lerpType;
this.level = level;
}
public void lerpAlpha(float duration)
{
_lerpType = LerpType.Alpha;
this.duration = duration;
currentColor = originalColor;
setLerp();
}
public static Vector2d Lerp(LerpType lerpType, Vector2d current, Vector2d target, double amount)
{
if (lerpType == LerpType.Lerp)
{
return(Vector2d.Lerp(current, target, amount));
}
return(Vector2d.SmoothStep(current, target, amount));
}
public MoveLevelData(float activeTime, float x, float y, float time, LerpType lerpType, int level)
{
this.activeTime = activeTime;
this.x = x;
this.y = y;
this.time = time;
this.lerpType = lerpType;
this.level = level;
}
public static Vector2f Lerp(LerpType lerpType, Vector2f current, Vector2f target, float amount)
{
if (lerpType == LerpType.Lerp)
{
return(Vector2f.Lerp(current, target, amount));
}
return(Vector2f.SmoothStep(current, target, amount));
}
public LerpHelper(float from, float to, float margin, float speed, LerpType lerpType)
{
this.From = from;
this.CurrentValue = from;
this.To = to;
this.Margin = margin;
this.Speed = speed;
this._currentLerpType = lerpType;
}
public static float MatchedLerpType(LerpType lerpType, float t)
{
switch (lerpType)
{
case LerpType.Liner:
return(Liner(t));
case LerpType.EaseInQuad:
return(EaseInQuad(t));
case LerpType.EaseOutQuad:
return(EaseOutQuad(t));
case LerpType.EaseInOutQuad:
return(EaseInOutQuad(t));
case LerpType.EaseInCubic:
return(EaseInCubic(t));
case LerpType.EaseOutCubic:
return(EaseOutCubic(t));
case LerpType.EaseInOutCubic:
return(EaseInOutCubic(t));
case LerpType.EaseInQuart:
return(EaseInQuart(t));
case LerpType.EaseOutQuart:
return(EaseOutQuart(t));
case LerpType.EaseInOutQuart:
return(EaseInOutQuart(t));
case LerpType.EaseInQuint:
return(EaseInQuint(t));
case LerpType.EaseOutQuint:
return(EaseOutQuint(t));
case LerpType.EaseInOutQuint:
return(EaseInOutQuint(t));
case LerpType.EaseInElastic:
return(EaseInElastic(t));
case LerpType.EaseOutElastic:
return(EaseOutElastic(t));
case LerpType.EaseInOutElastic:
return(EaseInOutElastic(t));
default:
return(t);
}
}
/// <summary>
/// 카메라 확대
/// </summary>
private void AddEnlargeLevel(float activeTime, float rate, float time, LerpType lerpType, int level)
{
XmlElement Item = (XmlElement)root.AppendChild(doc.CreateElement("EnlargeLevel"));
Item.SetAttribute("ActiveTime", activeTime.ToString());
Item.SetAttribute("Rate", rate.ToString());
Item.SetAttribute("Time", time.ToString());
Item.SetAttribute("LerpType", lerpType.ToString());
Item.SetAttribute("Level", level.ToString());
}
static public IEnumerable <float> LerpE(float min, float max, float time, LerpType type)
{
float currentTime = 0;
while (currentTime <= time)
{
currentTime += Time.deltaTime;
yield return(Lerp(min, max, currentTime / time, type));
}
}
public ColorData(ColorDataList colorData, float activeTime, float r, float g, float b, float time, LerpType lerpType, int level)
{
this.colorData = colorData;
this.activeTime = activeTime;
this.r = r;
this.g = g;
this.b = b;
this.time = time;
this.lerpType = lerpType;
this.level = level;
}
/// <summary>
/// 카메라 이동
/// </summary>
private void AddMoveLevel(float activeTime, float x, float y, float time, LerpType lerpType, int level)
{
XmlElement Item = (XmlElement)root.AppendChild(doc.CreateElement("MoveLevel"));
Item.SetAttribute("ActiveTime", activeTime.ToString());
Item.SetAttribute("X", x.ToString());
Item.SetAttribute("Y", y.ToString());
Item.SetAttribute("Time", time.ToString());
Item.SetAttribute("LerpType", lerpType.ToString());
Item.SetAttribute("Level", level.ToString());
}
public static float Lerp(float t, LerpType lerp)
{
switch (lerp)
{
case LerpType.Accelerate:
return AccelerateLerp(t);
case LerpType.Smooth:
return SmoothLerp(t);
default:
return t;
}
}
public static float Lerp(LerpType lerpType, float value1, float value2, float amount)
{
if (lerpType == LerpType.Lerp)
{
return(FlaiMath.Lerp(value1, value2, amount));
}
else if (lerpType == LerpType.Instant)
{
return(value2);
}
return(FlaiMath.SmoothStep(value1, value2, amount));
}
//https://chicounity3d.wordpress.com/2014/05/23/how-to-lerp-like-a-pro/
static public float LerpTime(float time, LerpType type)
{
switch (type)
{
case LerpType.EASE_OUT: return(Mathf.Sin(time * Mathf.PI * 0.5f));
case LerpType.SMOOTH_STEP: return(time = time * time * (3f - 2f * time));
case LerpType.SMOOTHER_STEP: return(time * time * time * (time * (6f * time - 15f) + 10f));
default: return(time);
}
}
public static float Lerp(float t, LerpType lerp)
{
switch (lerp)
{
case LerpType.Accelerate:
return(AccelerateLerp(t));
case LerpType.Smooth:
return(SmoothLerp(t));
default:
return(t);
}
}
static float LerpFunc(LerpType typ, float t, float speed)
{
switch (typ)
{
case LerpType.None:
return(0f);
case LerpType.Linear:
return(Mathf.PingPong((speed * t) + 0.5f, 1f) * 2f - 1f);
case LerpType.Sinusoidal:
return(Mathf.Sin(speed * t));
}
throw new System.Exception("BobFunc, No type found: " + typ.ToString());
}
/// <summary>
/// 게임 플레이 화면을 이동시킨다.
/// </summary>
/// <param name="x">이동시킬 x좌표</param>
/// <param name="y">이동시킬 y좌표</param>
/// <param name="time">이동시킬 시간</param>
public void MoveLevel(float x, float y, float time, LerpType lerpType, int level = 1)
{
// 생존 중일때만 작동한다.
if (playing)
{
// 변화 중이라면
if (moveEnable)
{
// 변화를 중지하고 코루틴을 멈춘다
moveEnable = false;
StopCoroutine(moveCoroutine);
}
moveCoroutine = MoveCoroutine(x, y, time, lerpType, level);
StartCoroutine(moveCoroutine);
}
}
/// <summary>
/// 게임 플레이 화면을 일정 비율 확대시킨다.
/// 숫자가 작을수록 화면이 커진다.
/// </summary>
/// <param name="rate">확대시킬 비율</param>
/// <param name="time">확대시킬 시간</param>
public void EnlargeLevel(float rate, float time, LerpType lerpType, int level = 1)
{
// 생존 중일때만 작동한다.
if (playing)
{
// 변화 중이라면
if (enlargeEnable)
{
// 변화를 중지하고 코루틴을 멈춘다
enlargeEnable = false;
StopCoroutine(enlargeCoroutine);
}
enlargeCoroutine = EnlargeCoroutine(rate, time, lerpType, level);
StartCoroutine(enlargeCoroutine);
}
}
/// <summary>
/// Enemy의 색을 지정된 시간동안 서서히 바꾼다.
/// </summary>
/// <param name="color">바꿀 색상</param>
/// <param name="time">바꿀 시간</param>
public void ChangeEnemyColor(Color color, float time, LerpType lerpType, int level = 1)
{
// 생존 중일때만 작동한다.
if (playing)
{
// 변화 중이라면
if (eChangeEnable)
{
// 변화를 중지하고 코루틴을 멈춘다
eChangeEnable = false;
StopCoroutine(eChangeCoroutine);
}
eChangeCoroutine = EnemyChangeCoroutine(color, time, lerpType, level);
StartCoroutine(eChangeCoroutine);
}
}
/// <summary>
/// 게임 플레이 화면을 일정 각도 회전시킨다.
/// </summary>
/// <param name="angle">회전시킬 각도</param>
/// <param name="time">회전시킬 시간</param>
public void RotateLevel(float angle, float time, LerpType lerpType, int level = 1)
{
// 생존 중일때만 작동한다.
if (playing)
{
// 변화 중이라면
if (rotateEnable)
{
// 변화를 중지하고 코루틴을 멈춘다
rotateEnable = false;
StopCoroutine(rotateCoroutine);
}
rotateCoroutine = RotateCoroutine(angle, time, lerpType, level);
StartCoroutine(rotateCoroutine);
}
}
private IEnumerator MovingLeftAndRight(float amount, float speed, LerpType lerpType)
{
float t = 0;
float time = amount / speed;
Vector3 startPos = transform.position;
Vector3 endPos;
if (Random.value <= 0.5f)
{
endPos = startPos + Vector3.left * amount;
}
else
{
endPos = startPos + Vector3.right * amount;
}
while (t < time)
{
t += Time.deltaTime;
float factor = EasyType.MatchedLerpType(lerpType, t / time);
transform.position = Vector3.Lerp(startPos, endPos, factor);
yield return(null);
}
while (true)
{
t = 0;
startPos = transform.position;
if (startPos.x > 0) //On right
{
endPos = new Vector3(-amount, startPos.y, startPos.z);
}
else //On left
{
endPos = new Vector3(amount, startPos.y, startPos.z);
}
while (t < time)
{
t += Time.deltaTime;
float factor = EasyType.MatchedLerpType(lerpType, t / time);
transform.position = Vector3.Lerp(startPos, endPos, factor);
yield return(null);
}
}
}
// 카메라 회전 코루틴
private IEnumerator RotateCoroutine(float rotateAngle, float time, LerpType lerpType, int level)
{
rotateEnable = true;
float originalAngle = mainCamera.transform.localRotation.z;
float tempTime = 0;
while (true)
{
if (playing)
{
// 변화 시간이 다 지나지 않았을 경우
if (tempTime < time)
{
// 카메라의 각도를 본래 각도에서 바꿀 각도로 지정된 시간동안 변화시킴
mainCamera.transform.localRotation = Quaternion.Lerp(
new Quaternion(mainCamera.transform.localRotation.x, mainCamera.transform.localRotation.y, originalAngle, mainCamera.transform.localRotation.w),
new Quaternion(mainCamera.transform.localRotation.x, mainCamera.transform.localRotation.y, rotateAngle, mainCamera.transform.localRotation.w),
GetLerpTime(lerpType, level, tempTime, time));
// 시간 카운트
tempTime += Time.deltaTime;
}
// 변화 시간이 다 지났을 경우
else
{
// 카메라 각도를 지정된 각도로 변경
mainCamera.transform.localRotation = new Quaternion(
mainCamera.transform.localRotation.x,
mainCamera.transform.localRotation.y,
rotateAngle,
mainCamera.transform.localRotation.w);
// 변화 활성화를 해제
rotateEnable = false;
// 코루틴 중지
StopCoroutine(rotateCoroutine);
}
}
else
{
// 변화 활성화를 해제
rotateEnable = false;
// 코루틴 중지
StopCoroutine(rotateCoroutine);
}
yield return(null);
}
}
public static Vector3 lerp(Vector3 from, Vector3 to, float time, LerpType mode)
{
switch (mode)
{
case LerpType.lerpLinear:
{
return(lerp(from, to, time));
}
case LerpType.lerpEaseInSine:
{
return(lerpEaseInSine(from, to, time));
}
case LerpType.lerpEaseOutSine:
{
return(lerpEaseOutSine(from, to, time));
}
case LerpType.lerpEaseInOutSine:
{
return(lerpEaseInOutSine(from, to, time));
}
case LerpType.lerpEaseInQuad:
{
return(lerpEaseInQuad(from, to, time));
}
case LerpType.lerpEaseOutQuad:
{
return(lerpEaseOutQuad(from, to, time));
}
case LerpType.lerpEaseInOutQuad:
{
return(lerpEaseInOutQuad(from, to, time));
}
default:
{
throw new System.ArgumentException("Unknown case.");
}
}
}
// 이동 코루틴
private IEnumerator MoveCoroutine(float x, float y, float time, LerpType lerpType, int level)
{
moveEnable = true;
Vector3 originalVector = mainCamera.transform.position;
float tempTime = 0;
Vector3 moveVector = new Vector3(-x, -y, -10);
while (true)
{
if (playing)
{
// 변화 시간이 다 지나지 않았을 경우
if (tempTime < time)
{
// 카메라의 위치를 본래 위치에서 바꿀 위치로 지정된 사간동안 변화시킴
mainCamera.transform.position = Vector3.Lerp(
originalVector,
moveVector,
GetLerpTime(lerpType, level, tempTime, time));
// 시간 카운트
tempTime += Time.deltaTime;
}
// 변화 시간이 다 지났을 경우
else
{
// 카메라 위치를 지정된 위치로 변경
mainCamera.transform.position = moveVector;
// 변화 활성화를 해제
moveEnable = false;
// 코루틴 중지
StopCoroutine(moveCoroutine);
}
}
else
{
// 변화 활성화를 해제
moveEnable = false;
// 코루틴 중지
StopCoroutine(moveCoroutine);
}
yield return(null);
}
}
public float ApplyCurveToLerpTime(float t, LerpType type)
{
switch (type)
{
case LerpType.EaseOut:
return(Mathf.Sin(t * Mathf.PI * 0.5f));
case LerpType.EaseIn:
return(1f - Mathf.Cos(t * Mathf.PI * 0.5f));
case LerpType.Exponential:
return(t * t);
case LerpType.SmoothStep:
return(t * t * (3f - 2f * t));
}
return(t);
}
public static int Lerp(int startPoint, int endPoint, float lerpPosition, LerpType lerpType)
{
switch (lerpType)
{
default:
case LerpType.Normal:
return NormalLerp(startPoint, endPoint, lerpPosition);
case LerpType.FadeOut:
return FadeOut(startPoint, endPoint, lerpPosition);
case LerpType.FadeIn:
return FadeIn(startPoint, endPoint, lerpPosition);
case LerpType.Exponential:
return Exponential(startPoint, endPoint, lerpPosition);
case LerpType.Smooth:
return SmoothLerp(startPoint, endPoint, lerpPosition);
case LerpType.Smoother:
return SmootherLerp(startPoint, endPoint, lerpPosition);
}
}
// 장애물 색 변화 코루틴
private IEnumerator EnemyChangeCoroutine(Color changeColor, float time, LerpType lerpType, int level)
{
eChangeEnable = true;
Color originalColor = LevelData.Instance.enemyColor;
float tempTime = 0;
while (true)
{
if (playing)
{
// 변화 시간이 다 지나지 않았을 경우
if (tempTime < time)
{
// 배경색을 본래 색에서 바꿀 색으로 지정된 시간동안 변화시킴
LevelData.Instance.enemyColor = Color.Lerp(
originalColor,
changeColor,
GetLerpTime(lerpType, level, tempTime, time));
// 시간 카운트
tempTime += Time.deltaTime;
}
// 변화 시간이 다 지났을 경우
else
{
// 배경색을 지정된 색으로 변경
LevelData.Instance.enemyColor = changeColor;
// 변화 활성화를 해제
eChangeEnable = false;
// 코루틴 중지
StopCoroutine(eChangeCoroutine);
}
}
else
{
// 변화 활성화를 해제
eChangeEnable = false;
// 코루틴 중지
StopCoroutine(eChangeCoroutine);
}
yield return(null);
}
}
// 확대 코루틴
private IEnumerator EnlargeCoroutine(float enlargeRate, float time, LerpType lerpType, int level)
{
enlargeEnable = true;
float originalSize = cameraComp.orthographicSize;
float tempTime = 0;
while (true)
{
if (playing)
{
// 변화 시간이 다 지나지 않았을 경우
if (tempTime < time)
{
// 카메라의 시야 크기를 본래 크기에서 바꿀 크기로 지정된 사간동안 변화시킴
cameraComp.orthographicSize = Mathf.Lerp(
originalSize,
enlargeRate * cameraSize,
GetLerpTime(lerpType, level, tempTime, time));
// 시간 카운트
tempTime += Time.deltaTime;
}
// 변화 시간이 다 지났을 경우
else
{
// 카메라 시야 크기를 지정된 크기로 변경
cameraComp.orthographicSize = enlargeRate * cameraSize;
// 변화 활성화를 해제
enlargeEnable = false;
// 코루틴 중지
StopCoroutine(enlargeCoroutine);
}
}
else
{
// 변화 활성화를 해제
enlargeEnable = false;
// 코루틴 중지
StopCoroutine(enlargeCoroutine);
}
yield return(null);
}
}
public static float Lerp(float start, float end, float value, LerpType lerpType)
{
switch (lerpType)
{
case LerpType.Linear: return Lerp(start,end,value);
case LerpType.Hermite: return Hermite(start,end,value);
case LerpType.Sinerp: return Sinerp(start,end,value);
case LerpType.Coserp: return Coserp(start,end,value);
case LerpType.Clerp: return Clerp(start,end,value);
case LerpType.Berp: return Berp(start,end,value);
case LerpType.EaseInQuad: return EaseInQuad(start,end,value);
case LerpType.EaseOutQuad: return EaseOutQuad(start,end,value);
case LerpType.EaseInOutQuad: return EaseInOutQuad(start,end,value);
case LerpType.EaseInCubic: return EaseInCubic(start,end,value);
case LerpType.EaseOutCubic: return EaseOutCubic(start,end,value);
case LerpType.EaseInOutCubic: return EaseInOutCubic(start,end,value);
case LerpType.EaseInQuart: return EaseInQuart(start,end,value);
case LerpType.EaseOutQuart: return EaseOutQuart(start,end,value);
case LerpType.EaseInOutQuart: return EaseInOutQuart(start,end,value);
case LerpType.EaseInQuint: return EaseInQuint(start,end,value);
case LerpType.EaseOutQuint: return EaseOutQuint(start,end,value);
case LerpType.EaseInOutQuint: return EaseInOutQuint(start,end,value);
case LerpType.EaseInSine: return EaseInSine(start,end,value);
case LerpType.EaseOutSine: return EaseOutSine(start,end,value);
case LerpType.EaseInOutSine: return EaseInOutSine(start,end,value);
case LerpType.EaseInExpo: return EaseInExpo(start,end,value);
case LerpType.EaseOutExpo: return EaseOutExpo(start,end,value);
case LerpType.EaseInOutExpo: return EaseInOutExpo(start,end,value);
case LerpType.EaseInCirc: return EaseInCirc(start,end,value);
case LerpType.EaseOutCirc: return EaseOutCirc(start,end,value);
case LerpType.EaseInOutCirc: return EaseInOutCirc(start,end,value);
case LerpType.Spring: return Spring(start,end,value);
case LerpType.EaseInBounce: return EaseInBounce(start,end,value);
case LerpType.EaseOutBounce: return EaseOutBounce(start,end,value);
case LerpType.EaseInOutBounce: return EaseInOutBounce(start,end,value);
case LerpType.EaseInBack: return EaseInBack(start,end,value);
case LerpType.EaseOutBack: return EaseOutBack(start,end,value);
case LerpType.EaseInOutBack: return EaseInOutBack(start,end,value);
case LerpType.EaseInElastic: return EaseInElastic(start,end,value);
case LerpType.EaseOutElastic: return EaseOutElastic(start,end,value);
case LerpType.EaseInOutElastic: return EaseInOutElastic(start,end,value);
}
return 0;
}
public static IEnumerator TranslateRescale(GameObject obj, Vector3 destPos, Vector2 destScale, float duration, LerpType lerp)
{
float elapsed = 0f;
float p;
Transform t = obj.transform;
Vector3 startScale = t.localScale;
Vector3 startPos = new Vector3(t.position.x, t.position.y, destPos.z);
do
{
p = Lerp(elapsed / duration, lerp);
t.position = Vector3.Lerp(startPos, destPos, p);
t.localScale = Vector3.Lerp(startScale, destScale, p);
yield return new WaitForEndOfFrame();
if (t.gameObject == null) yield break;
elapsed += Time.deltaTime;
} while (elapsed <= duration);
t.position = destPos;
t.localScale = destScale;
}
public static IEnumerator TranslateResize(GameObject obj, Vector3 destPos, Vector2 destSize, float duration, LerpType lerp)
{
//float elapsed = 0f;
// float p;
Transform t = obj.transform;
SpriteRenderer sr = obj.GetComponent<SpriteRenderer>();
Vector2 startSize = sr.bounds.size;
Vector3 startScale = t.localScale;
Vector3 destScale = new Vector3(startScale.x * (destSize.x / startSize.x),
startScale.y * (destSize.y / startSize.y), t.localScale.z);
yield return TranslateRescale(obj, destPos, destScale, duration, lerp);
/*Vector3 startPos = new Vector3(t.position.x, t.position.y, destPos.z);
do
{
p = Lerp(elapsed / duration, lerp);
t.position = Vector3.Lerp(startPos, destPos, p);
t.localScale = Vector3.Lerp(startScale, destScale, p);
yield return new WaitForEndOfFrame();
elapsed += Time.deltaTime;
} while (elapsed <= duration);
t.position = destPos;
t.localScale = destScale;*/
}
