public void OnTriggerEnter(Collider collider)
{
Vector3 vector = (collider.transform.position - base.transform.position).normalized * Magnitude;
Rigidbody attachedRigidbody = collider.attachedRigidbody;
if (attachedRigidbody != null)
{
attachedRigidbody.AddForce(vector, ForceMode.VelocityChange);
return;
}
LocomotionController currentController = LocomotionHelper.GetCurrentController(collider.gameObject);
if (currentController != null)
{
currentController.SetForce(vector, base.gameObject);
}
}
private void applyImpulse(Collider collider)
{
Vector3 vector = ((ZDirection != null) ? (ZDirection.forward * Magnitude) : (base.transform.forward * Magnitude));
LocomotionController locomotionController = LocomotionHelper.GetCurrentController(collider.gameObject);
if (collider.gameObject.layer == LayerMask.NameToLayer(LayerConstants.TubeLayer))
{
SlideControllerListener component = collider.GetComponent <SlideControllerListener>();
if (component != null)
{
locomotionController = component.SlideController;
}
}
if (locomotionController != null)
{
if (!IgnoreIfRunController || !(locomotionController is RunController))
{
if (Behaviour == ImpulseType.AddVelocity)
{
locomotionController.AddForce(vector * Time.fixedDeltaTime, base.gameObject);
}
else
{
locomotionController.SetForce(vector, base.gameObject);
}
}
return;
}
Rigidbody attachedRigidbody = collider.attachedRigidbody;
if (attachedRigidbody != null)
{
if (Behaviour == ImpulseType.SnapVelocity)
{
attachedRigidbody.velocity = vector;
}
else
{
attachedRigidbody.AddForce(vector, ForceMode.VelocityChange);
}
}
}
protected override void Update()
{
GameObject target = GetTarget();
if (target != null)
{
Vector3 vector = base.transform.forward;
if (IncomingUserData != null && IncomingUserData.GetType() == typeof(Vector3))
{
vector = ((Vector3)IncomingUserData).normalized;
}
else if (DirectionY != null)
{
vector = DirectionY.up;
}
else if (DirectionZ != null)
{
vector = DirectionZ.forward;
}
else if (DirectionTo != null)
{
vector = (DirectionTo.position - target.transform.position).normalized;
}
else if (Direction != Vector3.zero)
{
vector = Direction;
}
Vector3 vector2 = vector * Magnitude + AddDirection * AddMagnitude;
bool flag = LocomotionHelper.IsCurrentControllerOfType <SlideController>(target);
Rigidbody component = target.GetComponent <Rigidbody>();
if (!flag && component != null)
{
if (StartTransform != null)
{
component.transform.position = StartTransform.position;
component.transform.rotation = StartTransform.rotation;
component.velocity = Vector3.zero;
component.angularVelocity = Vector3.zero;
component.WakeUp();
}
component.AddForce(vector2, ForceMode.VelocityChange);
}
else
{
if (SetRunLocomotion && (!PreserveTubing || !flag))
{
LocomotionHelper.SetCurrentController <RunController>(target);
flag = false;
}
if (!flag && StartTransform != null)
{
target.transform.position = StartTransform.position;
target.transform.rotation = StartTransform.rotation;
}
LocomotionController currentController = LocomotionHelper.GetCurrentController(target);
if (currentController != null)
{
if (currentController is RunController)
{
((RunController)currentController).ClearAllVelocityInputs();
}
currentController.SetForce(vector2, base.gameObject);
}
}
}
Completed();
}
public override void OnProximityStay(ProximityListener other)
{
if (!other.gameObject.CompareTag("Player"))
{
return;
}
float num = calcDistance();
float value = num;
value = 3f - Mathf.Clamp(value, 2.5f, 3f);
value = 1f - value * 2f;
anim.SetFloat(HASH_PARAM_WARN_DISTANCE, value);
switch (chomperState)
{
case ChomperState.HUNGRY:
if (num <= 2f)
{
chomperState = ChomperState.LUNGE;
break;
}
setAnimation(ChomperAnimation.ANIM_IDLE_HUNGRY);
base.transform.LookAt(LookAtPlayer(chomperState));
break;
case ChomperState.LUNGE:
setAnimation(ChomperAnimation.ANIM_LUNGE);
base.transform.LookAt(LookAtPlayer(chomperState));
if (IsPenguinGrabbed)
{
chomperState = ChomperState.LUNGE_SUCCESS;
dispatcher.DispatchEvent(new DivingEvents.CollisionEffects(penguinObj.tag));
}
break;
case ChomperState.LUNGE_SUCCESS:
enablePenguinSwallow(isEnabled: false);
setAnimation(ChomperAnimation.ANIM_SUCCESS);
chomperState = ChomperState.LUNGE_SUCCESS_SPIT_WAIT;
break;
case ChomperState.LUNGE_SUCCESS_SPIT_COMPLETE:
anim.SetFloat(HASH_PARAM_WARN_DISTANCE, 1f);
enablePenguinSwallow(isEnabled: true);
if (savedCollider != null)
{
Vector3 vector = (penguinObj.transform.position - base.transform.position).normalized * SpitStrength;
Rigidbody attachedRigidbody = savedCollider.attachedRigidbody;
if (attachedRigidbody != null)
{
attachedRigidbody.AddForce(vector, ForceMode.Impulse);
}
else
{
LocomotionController currentController = LocomotionHelper.GetCurrentController(savedCollider.gameObject);
if (currentController != null)
{
currentController.SetForce(vector, base.gameObject);
}
}
}
isPenguinGrabbed = false;
chomperState = ChomperState.LUNGE_SUCCESS_ANIMATION_WAIT;
break;
case ChomperState.LUNGE_SUCCESS_ANIMATION_COMPLETE:
StartCoroutine(PauseChomper(3f));
chomperState = ChomperState.REVIVE_PAUSE_WAIT;
break;
case ChomperState.LUNGE_MISS:
setAnimation(ChomperAnimation.ANIM_MISS);
break;
case ChomperState.LUNGE_MISS_ANIMATION_COMPLETE:
StartCoroutine(PauseChomper(1f));
chomperState = ChomperState.REVIVE_PAUSE_WAIT;
break;
default:
Log.LogError(this, $"O_o\t ChomperController.OnTriggerStay: ERROR: illegal internalState {(int)chomperState}, defaulting to hungry");
chomperState = ChomperState.HUNGRY;
setAnimation(ChomperAnimation.ANIM_IDLE_HUNGRY);
break;
case ChomperState.LUNGE_SUCCESS_SPIT_WAIT:
case ChomperState.LUNGE_SUCCESS_ANIMATION_WAIT:
case ChomperState.LUNGE_MISS_ANIMATION_WAIT:
case ChomperState.REVIVE_PAUSE_WAIT:
break;
}
if (chomperState == ChomperState.LUNGE_SUCCESS_ANIMATION_WAIT)
{
return;
}
Vector3 eulerAngles = base.gameObject.transform.eulerAngles;
if (chomperState == ChomperState.LUNGE)
{
eulerAngles.x = (eulerAngles.x + 90f) % 360f;
if (eulerAngles.x > 90f && eulerAngles.x <= 180f)
{
eulerAngles.x = 90f;
}
else if (eulerAngles.x > 180f && eulerAngles.x < 270f)
{
eulerAngles.x = 270f;
}
}
else
{
eulerAngles.x = 0f;
}
if (eulerAngles.y > 90f && eulerAngles.y <= 180f)
{
eulerAngles.y = 90f;
}
else if (eulerAngles.y > 180f && eulerAngles.y < 270f)
{
eulerAngles.y = 270f;
}
base.gameObject.transform.eulerAngles = eulerAngles;
}
protected override void Update()
{
if (keyFrames.Count > 1)
{
if (isWarpingToStart)
{
if (SnapToStart)
{
vehicleTransform.position = keyFrames[0].pos;
isWarpingToStart = false;
}
else
{
Vector3 position = vehicleTransform.position;
Vector3 rhs = keyFrames[0].pos - position;
Vector3 normalized = rhs.normalized;
curWarpSpeed += StartAccel * Time.deltaTime;
curWarpSpeed = Mathf.Clamp(curWarpSpeed, 0f, TravelSpeed);
elapsedWarpTime += Time.deltaTime;
float t = Mathf.Clamp01(elapsedWarpTime / timeToAlign);
Vector3 b = normalized * curWarpSpeed;
curVel = Vector3.Lerp(curVel, b, t);
Vector3 vector = position + curVel * Time.deltaTime;
vehicleTransform.position = vector;
Vector3 lhs = keyFrames[0].pos - vector;
float sqrMagnitude = lhs.sqrMagnitude;
if (sqrMagnitude < closeEnoughDistSq || Vector3.Dot(lhs, rhs) <= 0f)
{
isWarpingToStart = false;
}
}
if (!isWarpingToStart && TravelStartSpeed >= 0f)
{
curWarpSpeed = TravelStartSpeed;
}
updateSeat();
}
else
{
elapsedTravelTime += Time.deltaTime;
if (elapsedTravelTime >= TravelDelay)
{
if (TravelAccelCurve.length > 1)
{
curWarpSpeed = TravelAccelCurve.Evaluate(elapsedTravelTime) * TravelSpeed;
curWarpSpeed = Mathf.Clamp(curWarpSpeed, minAccelCurveValue, TravelSpeed);
}
else
{
curWarpSpeed = TravelSpeed;
}
float deltaDist = curWarpSpeed * Time.deltaTime;
Vector3 vector = GetNextPos(deltaDist);
if (vector != vehicleTransform.position)
{
curVel = (vector - vehicleTransform.position) / Time.deltaTime;
vehicleTransform.position = vector;
updateSeat();
}
else
{
if (!string.IsNullOrEmpty(ExitAnimTrigger))
{
int trigger = Animator.StringToHash(ExitAnimTrigger);
anim.SetTrigger(trigger);
}
if (StopAtEndPoint)
{
vehicleTransform.position = vehicleStartPos;
vehicleTransform.rotation = vehicleStartRot;
}
else
{
vehicleTransform.position += curVel * Time.deltaTime;
updateSeat();
LocomotionTracker component = GetTarget().GetComponent <LocomotionTracker>();
if (component != null)
{
LocomotionController currentController = component.GetCurrentController();
if (currentController != null)
{
currentController.SetForce(curVel);
}
}
}
Completed(curVel);
}
}
}
if (!(elapsedTravelTime >= TravelDelay) || !(curVel.sqrMagnitude > 0f))
{
return;
}
Vector3 normalized2 = curVel.normalized;
Vector3 upwards = Vector3.up;
if (!UseWorldUp)
{
if (!Is3DSpace)
{
upwards = new Vector3(0f - normalized2.y, normalized2.x, 0f);
}
else
{
Vector3 lhs2 = Vector3.Cross(normalized2, Vector3.up);
upwards = Vector3.Cross(lhs2, normalized2);
}
}
Quaternion b2 = Quaternion.LookRotation(normalized2, upwards);
vehicleTransform.rotation = Quaternion.Slerp(vehicleTransform.rotation, b2, TurnSmoothing * Time.deltaTime);
}
else
{
Completed(Vector3.zero);
}
}
