protected virtual void OnEnable()
{
if (canSlideFromCurrentState())
{
animator.SetBool(AnimationHashes.Params.Slide, value: true);
wasInAirAtStart = LocomotionUtils.IsInAir(LocomotionUtils.GetAnimatorStateInfo(animator));
IsSliding = false;
isFloatingOnWater = false;
isSupportedByWater = false;
lastSplashTime = -1f;
impulses = base.gameObject.AddComponent <ForceAccumulatorPrimitive>();
impulses.SetData(mutableData.ImpulseProperties);
impulses.enabled = true;
mutableData.WaterProperties = MasterData.WaterProperties;
maxSpeedOnWaterWhenSteering = mutableData.WaterProperties.MaxSpeed;
curSpeedOnWater = motion.Velocity.magnitude;
curSpeedOnWater = Mathf.Clamp(curSpeedOnWater, 0f, maxSpeedOnWaterWhenSteering);
momentumAtStart = motion.Velocity;
if (mutableData.WaterRipples != null)
{
waterRipples = Object.Instantiate(mutableData.WaterRipples);
waterRipples.Stop();
CameraCullingMaskHelper.SetLayerIncludingChildren(waterRipples.transform, LayerMask.LayerToName(base.gameObject.layer));
}
base.Broadcaster.OnInteractionPreStartedEvent += onInteractionPreStartedEvent;
}
else
{
base.enabled = false;
}
}
protected void DefaultDoAction(LocomotionAction action, object userData = null)
{
switch (action)
{
case LocomotionAction.ChargeThrow:
if (snowballThrow != null)
{
snowballThrow.ChargeSnowball();
}
break;
case LocomotionAction.LaunchThrow:
if (snowballThrow != null)
{
snowballThrow.LaunchSnowball((float)userData);
}
break;
case LocomotionAction.Interact:
{
PenguinInteraction component = GetComponent <PenguinInteraction>();
if (component != null && component.RequestInteraction())
{
Broadcaster.BroadcastOnDoAction(action, userData);
}
break;
}
case LocomotionAction.Action1:
case LocomotionAction.Action2:
case LocomotionAction.Action3:
{
PenguinInteraction component = GetComponent <PenguinInteraction>();
if (component != null && !LocomotionUtils.IsInAir(LocomotionUtils.GetAnimatorStateInfo(animator)))
{
Broadcaster.BroadcastOnDoAction(action, userData);
}
break;
}
}
}
private IEnumerator SampleSurface()
{
while (true)
{
if (base.isActiveAndEnabled)
{
Vector3 hitPoint = Vector3.zero;
int num = LocomotionUtils.SampleSurface(base.transform, SurfaceSamplingData, out hitPoint);
AnimatorStateInfo animatorStateInfo = LocomotionUtils.GetAnimatorStateInfo(anim);
if (LocomotionUtils.IsLocomoting(animatorStateInfo))
{
if (LocomotionUtils.IsWalking(animatorStateInfo))
{
if (locoStatus != LocomotionStatus.Walking || num != prevSurfaceTypeIndex)
{
locoStatus = LocomotionStatus.Walking;
if (num >= 0)
{
if (!string.IsNullOrEmpty(SurfaceSamplingData.Effects[num].WalkSwitch.SwitchValue))
{
EventManager.Instance.PostEvent(SurfaceSamplingData.Effects[num].WalkSwitch.EventName, EventAction.SetSwitch, SurfaceSamplingData.Effects[num].WalkSwitch.SwitchValue, base.gameObject);
}
}
else if (!string.IsNullOrEmpty(SurfaceSamplingData.DefaultWalkSwitch.EventName))
{
EventManager.Instance.PostEvent(SurfaceSamplingData.DefaultWalkSwitch.EventName, EventAction.SetSwitch, SurfaceSamplingData.DefaultWalkSwitch.SwitchValue, base.gameObject);
}
}
}
else if (locoStatus != LocomotionStatus.Jogging || num != prevSurfaceTypeIndex)
{
locoStatus = LocomotionStatus.Jogging;
if (num >= 0)
{
if (!string.IsNullOrEmpty(SurfaceSamplingData.Effects[num].JogSwitch.SwitchValue))
{
EventManager.Instance.PostEvent(SurfaceSamplingData.Effects[num].JogSwitch.EventName, EventAction.SetSwitch, SurfaceSamplingData.Effects[num].JogSwitch.SwitchValue, base.gameObject);
}
}
else if (!string.IsNullOrEmpty(SurfaceSamplingData.DefaultJogSwitch.EventName))
{
EventManager.Instance.PostEvent(SurfaceSamplingData.DefaultJogSwitch.EventName, EventAction.SetSwitch, SurfaceSamplingData.DefaultJogSwitch.SwitchValue, base.gameObject);
}
}
}
else if (LocomotionUtils.IsInAir(animatorStateInfo) || LocomotionUtils.IsLanding(animatorStateInfo))
{
if (locoStatus != LocomotionStatus.InAir || num != prevSurfaceTypeIndex)
{
locoStatus = LocomotionStatus.InAir;
if (num >= 0)
{
if (!string.IsNullOrEmpty(SurfaceSamplingData.Effects[num].LandSwitch.SwitchValue))
{
EventManager.Instance.PostEvent(SurfaceSamplingData.Effects[num].LandSwitch.EventName, EventAction.SetSwitch, SurfaceSamplingData.Effects[num].LandSwitch.SwitchValue, base.gameObject);
}
}
else if (!string.IsNullOrEmpty(SurfaceSamplingData.DefaultLandSwitch.EventName))
{
EventManager.Instance.PostEvent(SurfaceSamplingData.DefaultLandSwitch.EventName, EventAction.SetSwitch, SurfaceSamplingData.DefaultLandSwitch.SwitchValue, base.gameObject);
}
}
}
else if (tracker.IsCurrentControllerOfType <SlideController>())
{
if (locoStatus != LocomotionStatus.Tubing || num != prevSurfaceTypeIndex)
{
locoStatus = LocomotionStatus.Tubing;
if (num >= 0)
{
if (!string.IsNullOrEmpty(SurfaceSamplingData.Effects[num].TubeSlideLoopSwitch.SwitchValue))
{
EventManager.Instance.PostEvent(SurfaceSamplingData.Effects[num].TubeSlideLoopSwitch.EventName, EventAction.SetSwitch, SurfaceSamplingData.Effects[num].TubeSlideLoopSwitch.SwitchValue, base.gameObject);
}
}
else if (!string.IsNullOrEmpty(SurfaceSamplingData.DefaultTubeSlideLoopSwitch.EventName))
{
EventManager.Instance.PostEvent(SurfaceSamplingData.DefaultTubeSlideLoopSwitch.EventName, EventAction.SetSwitch, SurfaceSamplingData.DefaultTubeSlideLoopSwitch.SwitchValue, base.gameObject);
}
}
}
else
{
locoStatus = LocomotionStatus.Unknown;
}
prevSurfaceTypeIndex = num;
}
yield return(new WaitForSeconds(sampleTime));
}
}
protected override void OnEnable()
{
AnimatorStateInfo animatorStateInfo = LocomotionUtils.GetAnimatorStateInfo(animator);
LocomotionController currentController = GetComponent <LocomotionTracker>().GetCurrentController();
if (currentController is SlideController)
{
base.Sled = ((SlideController)currentController).Sled;
base.SledTransform = ((SlideController)currentController).SledTransform;
base.Pilot = ((SlideController)currentController).Pilot;
if (base.Sled == null || base.SledTransform == null || base.Pilot == null || LocomotionUtils.IsInAir(animatorStateInfo) || LocomotionUtils.IsLanding(animatorStateInfo) || ((SlideController)currentController).CurrentMode == Mode.Animated)
{
base.enabled = false;
return;
}
((SlideController)currentController).ToRaceController = true;
FromSlideController = true;
}
else if (!LocomotionUtils.IsIdling(animatorStateInfo) && !LocomotionUtils.IsLocomoting(animatorStateInfo))
{
base.enabled = false;
return;
}
base.OnEnable();
if (myMutableData.SpeedLinesTubeRacePrefab != null)
{
speedLines = Object.Instantiate(myMutableData.SpeedLinesTubeRacePrefab);
CameraCullingMaskHelper.SetLayerIncludingChildren(speedLines.transform, LayerMask.LayerToName(base.gameObject.layer));
Vector3 localPosition = new Vector3(speedLines.transform.position.x, speedLines.transform.position.y, speedLines.transform.position.z);
Quaternion localRotation = new Quaternion(speedLines.transform.rotation.x, speedLines.transform.rotation.y, speedLines.transform.rotation.z, speedLines.transform.rotation.w);
speedLines.transform.parent = base.transform;
speedLines.transform.localPosition = localPosition;
speedLines.transform.localRotation = localRotation;
speedLines.SetActive(value: false);
}
if (visualizeTrackSegment)
{
steeringObject = new GameObject();
steeringObjectRenderer = steeringObject.AddComponent <LineRenderer>();
steeringObjectRenderer.transform.parent = base.gameObject.transform;
steeringObjectRenderer.useWorldSpace = true;
trackDirObject = new GameObject();
trackDirRenderer = trackDirObject.AddComponent <LineRenderer>();
trackDirObject.transform.parent = base.gameObject.transform;
trackDirRenderer.useWorldSpace = true;
}
if (FromSlideController)
{
mode = Mode.Animated;
base.IsSliding = true;
}
steerVel = Vector3.zero;
}
private void Update()
{
curStateInfo = LocomotionUtils.GetAnimatorStateInfo(animator);
isInAir = LocomotionUtils.IsInAir(curStateInfo);
isWalking = LocomotionUtils.IsWalking(curStateInfo);
isLanding = LocomotionUtils.IsLanding(curStateInfo);
isJogging = LocomotionUtils.IsJogging(curStateInfo);
isSprinting = LocomotionUtils.IsSprinting(curStateInfo);
isStopping = LocomotionUtils.IsStopping(curStateInfo);
isPivoting = LocomotionUtils.IsPivoting(curStateInfo);
curFacing = base.transform.forward;
curFacing.y = 0f;
curFacing.Normalize();
animator.SetFloat(AnimationHashes.Params.GroundFriction, mutableData.GroundFriction);
gravityVector.y = (0f - mutableData.Gravity) * Time.deltaTime;
updateActionRequests();
if (wsSteerDir != Vector3.zero)
{
if (Behaviour.Style == PlayerLocoStyle.Style.Walk)
{
curLocoMode = LocoMode.Walk;
}
else if (mutableData.JogParams.ElapsedJogTime >= mutableData.SprintParams.MinTimeToStartSprinting)
{
curLocoMode = LocoMode.Sprint;
}
else if (isWalking || (isLanding && curLocoMode == LocoMode.Walk))
{
float num = mutableData.JogParams.MinSteerMag * mutableData.JogParams.MinSteerMag;
if (wsSteerDir.sqrMagnitude >= num && mutableData.WalkParams.ElapsedWalkTime >= mutableData.JogParams.MinTimeToStartJogging)
{
curLocoMode = LocoMode.Jog;
}
else
{
curLocoMode = LocoMode.Walk;
}
}
else if (isJogging || (isLanding && curLocoMode == LocoMode.Jog))
{
float num = mutableData.JogParams.MinSteerMag - 0.1f;
num *= num;
if (wsSteerDir.sqrMagnitude < num)
{
curLocoMode = LocoMode.Walk;
}
else
{
curLocoMode = LocoMode.Jog;
}
}
else
{
curLocoMode = LocoMode.Walk;
}
desiredFacing = wsSteerDir;
elapsedMoveTime += Time.deltaTime;
}
else
{
curLocoMode = LocoMode.Idle;
if (elapsedMoveTime > 0f)
{
snapToDesiredFacing = true;
}
else if (!snapToDesiredFacing)
{
desiredFacing = curFacing;
}
elapsedMoveTime = 0f;
}
Debug.DrawRay(base.transform.position, curFacing, Color.blue, 0f, depthTest: false);
Debug.DrawRay(base.transform.position, desiredFacing, Color.red, 0f, depthTest: false);
float normalizedTime = curStateInfo.normalizedTime;
animator.SetInteger(AnimationHashes.Params.LoopCount, Mathf.FloorToInt(normalizedTime));
animator.SetFloat(AnimationHashes.Params.NormTime, normalizedTime - Mathf.Floor(normalizedTime));
animator.SetInteger(AnimationHashes.Params.LocoMode, (int)curLocoMode);
animator.SetBool(AnimationHashes.Params.Shuffle, snapToDesiredFacing);
int fullPathHash = curStateInfo.fullPathHash;
if (prevAnimState != fullPathHash)
{
onStateTransitioned();
}
if (isInAir)
{
updateInAirState();
}
else
{
updateOnGroundState();
}
mutableData.JogParams.speedMult = Mathf.Clamp(mutableData.JogParams.speedMult, 0f, 1f);
animator.SetFloat(AnimationHashes.Params.JogSpeedMult, mutableData.JogParams.speedMult);
mutableData.WalkParams.speedMult = Mathf.Clamp(mutableData.WalkParams.speedMult, 0f, 1f);
animator.SetFloat(AnimationHashes.Params.WalkSpeedMult, mutableData.WalkParams.speedMult);
mutableData.SprintParams.speedMult = Mathf.Clamp(mutableData.SprintParams.speedMult, 0f, 1f);
animator.SetFloat(AnimationHashes.Params.SprintSpeedMult, mutableData.SprintParams.speedMult);
prevAnimState = fullPathHash;
prevStateInfo = curStateInfo;
}
protected virtual bool canSlideFromCurrentState()
{
AnimatorStateInfo animatorStateInfo = LocomotionUtils.GetAnimatorStateInfo(animator);
return(LocomotionUtils.IsIdling(animatorStateInfo) || LocomotionUtils.IsLocomoting(animatorStateInfo) || LocomotionUtils.IsInAir(animatorStateInfo) || LocomotionUtils.IsLanding(animatorStateInfo));
}
private bool canSitFromCurrentState()
{
AnimatorStateInfo animatorStateInfo = LocomotionUtils.GetAnimatorStateInfo(animator);
return(LocomotionUtils.IsIdling(animatorStateInfo) || LocomotionUtils.IsLocomoting(animatorStateInfo) || LocomotionUtils.IsInAir(animatorStateInfo) || LocomotionUtils.IsLanding(animatorStateInfo) || LocomotionUtils.IsSwimming(animatorStateInfo));
}
