private IEnumerator SnapView(Vector3 current, float duration, bool toPlayer)
{
snapViewRunning = true;
float elapsedTime = 0;
float ratio = 0;
Vector3 start = transform.position + transform.forward;//beamEnd.position;//= new Vector3(transform.position.x, transform.position.y, transform.position.z + beam.transform.localScale.z);
Vector3 end = current;
float beamStart = beam.transform.localScale.z;
while (ratio < 1f)
{
ratio = elapsedTime / duration;
Vector3 view = Vector3.Lerp(start, end, TweeningFunctions.EaseOutCubic(ratio));
transform.LookAt(view);
elapsedTime += Time.deltaTime;
SetBeamLength(current);
if (toPlayer)
{
float length = Mathf.Lerp(beamStart, 0f, TweeningFunctions.EaseOutCubic(ratio));
beam.SetLength(length);
}
yield return(null);
}
snapViewRunning = false;
if (toPlayer && state != BotState.Speaking)
{
state = BotState.Following;
}
}
IEnumerator StretchRoutine()
{
state = !state;
float elapsedTime = 0;
float ratio = elapsedTime / duration;
float endpoint;
if (state)
{
endpoint = 2f;
}
else
{
endpoint = 1f;
}
float startpoint = transform.localScale.x;
while (ratio < 1f)
{
ratio = elapsedTime / duration;
float value = Mathf.Lerp(startpoint, endpoint, TweeningFunctions.EaseInOut(ratio));
transform.localScale = new Vector3(value, transform.localScale.y, transform.localScale.z);
elapsedTime += Time.fixedDeltaTime;
yield return(new WaitForFixedUpdate());
}
}
private IEnumerator MoveDoorCoroutine(bool direction, float duration)
{
float end;
float start = transform.localPosition.x;
float elapsedTime = 0;
float scaledDuration;
audio.volume = Toolbox.Instance.soundEffectsVolume;
audio.mute = false;
audio.Play();
if (direction) //meaning we're opening
{
if (leftDoor)
{
end = .8f;
scaledDuration = Mathf.Abs(duration * ((start - 0.8f) / .8f));
}
else
{
end = -.8f;
scaledDuration = Mathf.Abs(duration * ((start + 0.8f) / .8f));
}
}
else //door is closing
{
end = 0f;
scaledDuration = duration * ((Mathf.Abs(start) / .8f));
}
Vector3 newposition = new Vector3(start, 0f, 0f);
float ratio = elapsedTime / scaledDuration;
while (ratio < 1f)
{
elapsedTime += Time.deltaTime;
ratio = elapsedTime / scaledDuration;
newposition.x = Mathf.Lerp(start, end, TweeningFunctions.EaseIn(ratio));
this.transform.localPosition = newposition;
yield return(null);
if ((gameObject.layer != 17) && !(gameObject.layer + 5 == Toolbox.Instance.GetPlayer().layer))
{
audio.mute = true;
}
else
{
audio.mute = false;
}
}
yield return(null);
audio.mute = true;
yield return(new WaitForSeconds(.5f));
audio.Stop();
}
IEnumerator LookAtTarget(Vector3 target, float duration)
{
rotating = true;
float elapsedTime = 0f;
float ratio = 0f;
Vector3 begin = transform.position + transform.forward;
bool playerMoved = PlayerHasMoved();
while (elapsedTime < duration)
{
ratio = elapsedTime / duration;
elapsedTime += Time.deltaTime;
Vector3 view = Vector3.Lerp(begin, target, ratio);
FrogLook(view);
if (audio && playerMoved && Toolbox.Instance.PlayerInLaser())
{
audio.volume = Toolbox.Instance.soundEffectsVolume * TweeningFunctions.BackAndForth(ratio);
}
yield return(null);
}
audio.volume = 0f;
rotating = false;
previousPlayerPosition = player.position;
}
private IEnumerator SnapView(Vector3 old, Vector3 current, float duration, bool playerHasMoved)
{
snapViewRunning = true;
float elapsedTime = 0;
float ratio = 0;
while (ratio < 1f)
{
ratio = elapsedTime / duration;
Vector3 view = Vector3.Lerp(old, current, TweeningFunctions.EaseOutCubic(ratio));
transform.LookAt(view);
elapsedTime += Time.deltaTime;
SetBeamLength(hitPoint);
if (playerHasMoved)
{
//doing lerp for focal scale
float start = beam.transform.localScale.x;
float width = Mathf.Lerp(start, unfocusedScale, ratio);
beam.SetWidth(width);
}
yield return(null);
}
lastTarget = current;
snapViewRunning = false;
}
private IEnumerator flipTransitionRoutine(float startpoint, float endpoint, float duration, bool goingToLaser)
{
partner.GetComponent <Transition>().enabled = false;
Debug.Log("duration " + duration);
isRunning = true;
//.isRunning = true;
float elapsedTime = 0;
float ratio = elapsedTime / duration;
int count = 0;
while (ratio < 1f)
{
ratio = elapsedTime / duration;
float value = Mathf.Lerp(startpoint, endpoint, TweeningFunctions.BackAndForth(ratio));
float transitionBValue;
if (!goingToLaser)
{
transitionBValue = Mathf.Lerp(1f, 0f, ratio);
}
else
{
transitionBValue = Mathf.Lerp(0f, 1f, ratio);
}
partnerRenderer.GetPropertyBlock(_propBlock);
_propBlock.SetFloat("_TransitionState", value);
partnerRenderer.SetPropertyBlock(_propBlock);
partnerMaterial.SetFloat("_TransitionStateB", transitionBValue);
if (Toolbox.Instance.GetFlip().flippedThisFrame)
{
count += 1;
if (count > 1)
{
recentlySelected = false;
isRunning = false;
SetMaterialFloatProp("_onHold", 0f);
SetMaterialFloatProp("_Shimmer", 0f);
yield break;
}
}
elapsedTime += Time.deltaTime;
yield return(null);
}
//recentlySelected = false;
isRunning = false;
// partnerLinkedPair.isRunning = false;
cancelTransition = 0;
partner.GetComponent <Transition>().enabled = true;
}
private IEnumerator ResetBeamLength(float duration)
//for after it's looked at the player
{
float elapsedTime = 0;
float ratio = elapsedTime / duration;
while (ratio < 1f)
{
ratio = elapsedTime / duration;
elapsedTime += Time.deltaTime;
//doing lerp for focal scale
float start = beam.transform.localScale.z;
float length = Mathf.Lerp(start, 0f, TweeningFunctions.EaseOutCubic(ratio));
beam.SetLength(length);
yield return(null);
}
}
private IEnumerator flipTransitionRoutine(float startpoint, float endpoint, float duration)
{
float elapsedTime = 0;
float ratio = elapsedTime / duration;
while (ratio < 1f)
{
ratio = elapsedTime / duration;
float value = Mathf.Lerp(startpoint, endpoint, TweeningFunctions.EaseInOut(ratio));
mask.enabled = false;
mat.SetFloat("_TransitionState", value);
mask.enabled = true;
elapsedTime += Time.deltaTime;
yield return(null);
}
}
private IEnumerator TransitionLaserOff()
{
GetComponent <Collider>().enabled = false;
float elapsedTime = 0;
float ratio = elapsedTime / duration;
while (ratio < 1f)
{
elapsedTime += Time.deltaTime;
ratio = elapsedTime / duration;
float value = Mathf.Lerp(0f, 1f, TweeningFunctions.EaseOut(ratio));
material.SetFloat("_TransitionState", value);
yield return(new WaitForFixedUpdate());
}
//mRenderer.enabled = false;
}
void FixedUpdate()
{
if (elapsedTime < mySpeed)
{
var ratio = elapsedTime / mySpeed;
float currentScale = Mathf.Lerp(startScale, endScale, TweeningFunctions.EaseOutCubic(ratio));
transform.localScale = new Vector3(currentScale, currentScale, currentScale);
material.SetFloat("_TransitionState", TweeningFunctions.EaseOutCubic(ratio));
elapsedTime += Time.fixedDeltaTime;
}
else
{
UnityEngine.Object.Destroy(this.gameObject);
}
}
private IEnumerator CrossfadeToLaser()
{
float start = _realToLaser;
float end = 1f;
float elapsed = 0f;
float ratio = 0f;
while (ratio < 1)
{
_realToLaser = Mathf.Lerp(start, end, TweeningFunctions.Linear(ratio));
yield return(null);
elapsed += Time.deltaTime;
ratio = elapsed / crossfadeTime;
}
_realToLaser = end;
}
IEnumerator RotateRoutine()
{
float elapsedTime = 0;
float ratio = elapsedTime / duration;
float start = transform.localEulerAngles.y;
while (ratio < 1f)
{
ratio = elapsedTime / duration;
float value = Mathf.Lerp(start, (start + 90f) % 360, TweeningFunctions.EaseInOut(ratio));
Debug.Log(value);
transform.localEulerAngles = new Vector3(transform.localEulerAngles.x, value, transform.localEulerAngles.z);
elapsedTime += Time.fixedDeltaTime;
yield return(new WaitForFixedUpdate());
}
}
private IEnumerator OutputVolumeRoutineOff()
{
var start = _volume;
var end = 0f;
var elapsed = 0f;
var ratio = 0f;
while (elapsed < routineDuration)
{
yield return(null);
elapsed += Time.deltaTime;
ratio = elapsed / routineDuration;
_volume = TweeningFunctions.EaseOut(Mathf.Lerp(start, end, ratio));
}
_volume = end;
_coroutine = null;
}
protected virtual IEnumerator flipTransitionRoutine(float startpoint, float endpoint, float duration)
{
float elapsedTime = 0;
float ratio = elapsedTime / duration;
//int property = Shader.PropertyToID("_D7A8CF01");
while (ratio < 1f)
{
ratio = elapsedTime / duration;
float value = Mathf.Lerp(startpoint, endpoint, TweeningFunctions.Tween(tween, ratio));
mRenderer.GetPropertyBlock(_propBlock);
_propBlock.SetFloat("_TransitionState", value);
mRenderer.SetPropertyBlock(_propBlock);
//material.SetFloat("_TransitionState", value);
//RendererExtensions.UpdateGIMaterials(mRenderer);
elapsedTime += Time.deltaTime;
yield return(null);
}
}
IEnumerator RotateRoutine(float actualDuration)
{
//Debug.Log("start rotation "+ startRotation + "end rotation " + endRotation + "actualduration " + actualDuration);
float elapsedTime = 0f;
ratio = 0f;
Vector3 start = transform.localEulerAngles;
Vector3 end;
if (startRotationInLaser && Toolbox.Instance.PlayerInLaser() || (!startRotationInLaser && Toolbox.Instance.PlayerInReal()))
{
end = startRotation;
}
else
{
end = endRotation;
}
while (ratio < 1f)
{
ratio = elapsedTime / actualDuration;
Vector3 value = Vector3.Lerp(start, end, TweeningFunctions.Tween(tween, ratio));
transform.localEulerAngles = value;
if (audio)
{
audio.volume = TweeningFunctions.BackAndForth(ratio);
}
elapsedTime += Time.fixedDeltaTime;
yield return(new WaitForFixedUpdate());
}
ratio = 0f;
}
private IEnumerator Focus(float duration)
//for after it's looked at the player
{
//Debug.Log("widening focus");
widenFocusRunning = true;
float elapsedTime = 0;
float ratio = elapsedTime / duration;
while (ratio < 1f)
{
ratio = elapsedTime / duration;
elapsedTime += Time.deltaTime;
//doing lerp for focal scale
float start = beam.transform.localScale.x;
float width = Mathf.Lerp(start, focusedScale, TweeningFunctions.EaseOutCubic(ratio));
beam.SetWidth(width);
yield return(null);
}
widenFocusRunning = false;
}
IEnumerator TurnToLook(GameObject targetObject)
{
state = DroneState.Waiting;
float ratio = 0;
float duration = waitDuration;
float elapsed = 0;
Quaternion begin = transform.rotation;
transform.LookAt(targetObject.transform);
transform.eulerAngles = new Vector3(0, transform.eulerAngles.y, transform.eulerAngles.z);
Quaternion end = transform.rotation;
transform.rotation = begin;
while (ratio < 1)
{
yield return(null);
elapsed += Time.deltaTime;
ratio = elapsed / duration;
transform.rotation = Quaternion.Slerp(begin, end, TweeningFunctions.EaseOut(ratio));
}
if (targetObject.GetComponent <SpawnableMutation>())
{
state = DroneState.Approaching;
target = targetObject.GetComponent <SpawnableMutation>();
}
else
{
state = DroneState.Patrolling;
}
}
private IEnumerator InteractionRoutine()
{
float elapsedTime = 0;
float ratio = elapsedTime / duration;
float start = material.GetFloat("_TransitionStateB");
while (ratio < 1f)
{
ratio = elapsedTime / duration;
float value = Mathf.Lerp(start, 1f, TweeningFunctions.EaseInOut(ratio));
//mRenderer.GetPropertyBlock(_propBlock);
//_propBlock.SetFloat("_TransitionStateB", value);
//mRenderer.SetPropertyBlock(_propBlock);
material.SetFloat("_TransitionStateB", value);
elapsedTime += Time.fixedDeltaTime;
yield return(new WaitForFixedUpdate());
}
mRenderer.enabled = false;
}
private IEnumerator MovePlatformCoroutine(Vector3 startPos, Vector3 endPos, float duration)
{
checkObjectsPlace();
platformIsMoving = true;
Debug.Log("Platformismoving");
if (startPos.Equals(start) || startPos.Equals(end.position))
{
yield return(new WaitForSeconds(.5f));
PlayAudio(SoundBox.Instance.platformStart);
yield return(new WaitForSeconds(SoundBox.Instance.platformStart.length));
}
audio.loop = true;
PlayAudio(SoundBox.Instance.platformRunning);
float elapsedTime = 0;
float ratio = elapsedTime / (duration * durationMultiplier);
PlatformObjectsUnselectable();
Vector3 carriedObjectPosition = Vector3.zero;
if (mainGuard.GetComponent <PlatformGuard>().target)
{
carriedObjectPosition = mainGuard.GetComponent <PlatformGuard>().target.transform.position;
carriedObjectPosition += endPos;
Debug.Log(mainGuard.GetComponent <PlatformGuard>().target.transform.position.y);
Debug.Log(carriedObjectPosition.y);
}
//yield return new WaitForSeconds(.5f);
//play starting sound
while (ratio < 1f)
{
if (!playerLayer)
{
audio.mute = true;
}
else
{
audio.mute = false;
}
elapsedTime += Time.deltaTime;
ratio = elapsedTime / (duration * durationMultiplier);
transform.position = Vector3.Lerp(startPos, endPos, TweeningFunctions.EaseInOut(ratio));
yield return(null);
}
transform.position = endPos;
PlatformObjectSelectable();
mainGuard.SetActive(true);
yield return(null);
audio.mute = true;
audio.loop = false;
yield return(new WaitForSeconds(.2f));
audio.Stop();
audio.mute = false;
PlayAudio(SoundBox.Instance.platformEnd);
//if (mainGuard.GetComponent<PlatformGuard>().target)
//{
// mainGuard.GetComponent<PlatformGuard>().target.transform.position = carriedObjectPosition += endPos;
//}
platformIsMoving = false;
Debug.Log("platformStoppedMoving");
}
private IEnumerator FadeRoutine()
{
texts = new List <Text>();
player = Toolbox.Instance.GetPlayer().GetComponent <MFPP.Player>();
player.Movement.AllowMovement = false;
player.Movement.AllowMouseMove = false;
_canvas = Toolbox.Instance.mainCanvas;
_uiObject = Instantiate(prefab, _canvas.transform, false);
_whiteBackground = _uiObject.GetComponent <Image>();
foreach (Transform child in _uiObject.transform)
{
if (child.parent == _uiObject.transform)
{
texts.Add(child.GetComponent <Text>());
child.gameObject.SetActive(false);
}
}
var backgroundColor = _whiteBackground.color;
backgroundColor.a = 0;
_whiteBackground.color = backgroundColor;
// fade in
var elapsed = 0f;
var ratio = 0f;
var startAlpha = 0f;
var endAlpha = 1f;
while (elapsed < fadeDuration)
{
yield return(null);
elapsed += Time.deltaTime;
ratio = elapsed / fadeDuration;
backgroundColor.a = Mathf.Lerp(startAlpha, endAlpha, TweeningFunctions.Linear(ratio));
_whiteBackground.color = backgroundColor;
}
int i = 0;
while (i < texts.Count)
{
var textColor = Color.black;
textColor.a = 0;
texts[i].gameObject.SetActive(true);
texts[i].color = textColor;
elapsed = 0;
ratio = 0;
startAlpha = 0;
endAlpha = 1f;
while (elapsed < fadeDuration)
{
yield return(null);
elapsed += Time.deltaTime;
ratio = elapsed / fadeDuration;
textColor.a = Mathf.Lerp(startAlpha, endAlpha, TweeningFunctions.Linear(ratio));
texts[i].color = textColor;
}
yield return(new WaitForSeconds(readDuration));
elapsed = 0;
ratio = 0;
startAlpha = 1f;
endAlpha = 0f;
while (elapsed < fadeDuration)
{
yield return(null);
elapsed += Time.deltaTime;
ratio = elapsed / fadeDuration;
textColor.a = Mathf.Lerp(startAlpha, endAlpha, TweeningFunctions.Linear(ratio));
texts[i].color = textColor;
}
i++;
}
// fade out
elapsed = 0f;
ratio = 0f;
startAlpha = 1f;
endAlpha = 0f;
while (elapsed < fadeDuration)
{
yield return(null);
elapsed += Time.deltaTime;
ratio = elapsed / fadeDuration;
backgroundColor.a = Mathf.Lerp(startAlpha, endAlpha, TweeningFunctions.Linear(ratio));
_whiteBackground.color = backgroundColor;
}
player.Movement.AllowMovement = true;
player.Movement.AllowMouseMove = true;
if (allowFlip)
{
Toolbox.Instance.GetFlip().canFlip = true;
}
else
{
Toolbox.Instance.GetFlip().canFlip = false;
}
Destroy(_uiObject);
}
IEnumerator BeamGrow()
{
float end_scale = Mathf.Abs(transform.position.y - target.transform.position.y);
float duration = beamTime;
float elapsed = 0;
float ratio = 0;
beam.transform.localScale = new Vector3(beam.transform.localScale.x, beam.transform.localScale.y, 0);
while (elapsed < duration)
{
yield return(null);
elapsed += Time.deltaTime;
ratio = elapsed / duration;
beam.transform.localScale = new Vector3(beam.transform.localScale.x, beam.transform.localScale.y, end_scale * TweeningFunctions.EaseIn(ratio));
}
beam.transform.localScale = new Vector3(beam.transform.localScale.x, beam.transform.localScale.y, end_scale);
target.lifePhase = SpawnableMutation.LifeCycle.Death;
state = DroneState.Destroying;
}
IEnumerator BeamShrink()
{
float end_scale = beam.transform.localScale.z;
float duration = beamTime;
float elapsed = 0;
float ratio = 0;
beam.transform.localScale = new Vector3(beam.transform.localScale.x, beam.transform.localScale.y, end_scale);
while (elapsed < duration)
{
yield return(null);
elapsed += Time.deltaTime;
ratio = elapsed / duration;
beam.transform.localScale = new Vector3(beam.transform.localScale.x, beam.transform.localScale.y, end_scale - (TweeningFunctions.EaseIn(ratio) * end_scale));
}
beam.transform.localScale = new Vector3(beam.transform.localScale.x, beam.transform.localScale.y, 0);
//beam.SetActive(false);
NewTarget();
}
// Update is called once per frame
void Update()
{
switch (lifePhase)
{
case LifeCycle.Waiting:
if (waitingProgress < waitLength)
{
waitingProgress += Time.deltaTime;
}
else
{
lifePhase = LifeCycle.Growth;
PrepareAudioLife(GetComponent <AudioSource>());
scale(startScale);
}
break;
case LifeCycle.Growth:
if (growthProgess < growthLength)
{
float ratio = growthProgess / growthLength;
scale(Mathf.Lerp(startScale, targetScale, TweeningFunctions.EaseOut(ratio)));
//using transition state b to change color over grown phase
//using one minus to go from satring in laser color to landing in real
mRenderer.GetPropertyBlock(propBlock);
propBlock.SetFloat("_BeginToBase", TweeningFunctions.EaseOut(ratio));
mRenderer.SetPropertyBlock(propBlock);
growthProgess += Time.deltaTime;
}
else
{
//move to next phase
lifePhase = LifeCycle.Life;
coll.enabled = true;
movement.Activate();
}
break;
case LifeCycle.Life:
/*
* if(lifeProgress < lifeLength)
* {
* lifeProgress += Time.deltaTime;
* } else
* {
* //move to next phase
* lifePhase = LifeCycle.Death;
* }
*/
break;
case LifeCycle.Death:
PrepareAudioDeath(GetComponent <AudioSource>());
movement.Deactivate();
if (deathProgress < deathLength)
{
float ratio = deathProgress / deathLength;
float scale = Mathf.Lerp(targetScale, 0f, TweeningFunctions.EaseOut(ratio));
transform.localScale = new Vector3(scale, scale, scale);
mRenderer.GetPropertyBlock(propBlock);
propBlock.SetFloat("_BaseToDeath", TweeningFunctions.EaseOut(ratio));
mRenderer.SetPropertyBlock(propBlock);
deathProgress += Time.deltaTime;
}
else
{
this.gameObject.SetActive(false);
}
break;
}
}
IEnumerator BeginJump(Vector3 endPos)
{
Vector3 beginPos = transform.position;
float jumpElapsed = 0;
float ratio = 0;
active = false;
MFPP.Audio.Play3D(hopSound, gameObject.transform, Toolbox.Instance.soundEffectsVolume, 1f);
while (jumpElapsed < jumpDuration)
{
jumpElapsed += Time.deltaTime;
ratio = jumpElapsed / jumpDuration;
transform.position = MathParabola.Parabola(beginPos, endPos, jumpHeight, (TweeningFunctions.EaseMiddle(ratio) + ratio) / 2f);
//Vector3.Lerp(beginPos, endPos, TweeningFunctions.EaseInOutCubic(elapsed/jumpDuration));
yield return(null);
}
transform.position = endPos;
hopParticles.Play();
if (Toolbox.Instance.PlayerInLaser())
{
MFPP.Audio.Play3D(thudSound, transform, Toolbox.Instance.soundEffectsVolume, 1f);
}
waypointIndex++;
rotationTimer = 0f;
if (repeat && waypointIndex == waypoints.Length)
{
waypointIndex = 0;
}
if (waypointIndex < waypoints.Length)
{
//Debug.LogError("Going to next");
active = true;
}
}
