protected override void OnEnable()
{
if (IsEnabled)
{
actionTarget = GetTarget();
tracker = actionTarget.GetComponent <LocomotionTracker>();
if (tracker.SetCurrentController <RunController>())
{
thisTransform = actionTarget.transform;
raycastLayerMask = LayerConstants.GetPlayerLayerCollisionMask();
actorRadius = 0f;
actorHalfHeight = 0.1f;
CharacterController component = actionTarget.GetComponent <CharacterController>();
if (component != null)
{
actorRadius = component.radius;
actorHalfHeight = component.height / 2f;
}
runController = actionTarget.GetComponent <RunController>();
base.OnEnable();
CoroutineRunner.Start(doMoveTo(), this, "doMoveTo");
}
}
else
{
CoroutineRunner.Start(completeAfterFrame(), this, "completeAfterFrame");
}
}
protected override void awake()
{
mutableData = Object.Instantiate(MasterData);
tracker = GetComponent <LocomotionTracker>();
raycastLayerMask = LayerConstants.GetPlayerLayerCollisionMask();
DefaultAnimatorController = animator.runtimeAnimatorController;
dispatcher = Service.Get <EventDispatcher>();
jumpRequest = new ActionRequest(PenguinUserControl.DefaultActionRequestBufferTime, animator, AnimationHashes.Params.Jump);
}
public void Awake()
{
SphereCollider component = base.GetComponent <SphereCollider>();
this.spherePos = base.transform.position + component.center;
this.sphereRadius = component.radius;
this.count = 0;
this.layerMask = LayerConstants.GetAllPlayersLayerCollisionMask();
CoroutineRunner.Start(this.updateCount(), this, "ObjectiveListener");
}
public Weapon(GameObject owner)
{
Owner = owner;
if (Owner.layer == LayerConstants.GetLayer("Player"))
{
projectileLayer = LayerConstants.GetLayer(LayerConstants.PlayerProjectiles);
}
else
{
projectileLayer = LayerConstants.GetLayer(LayerConstants.EnemyProjectiles);
}
}
private bool isWaterTooShallow(float maxDepth)
{
if (isInShallowWater)
{
Vector3 position = base.transform.position;
position.y = visibleSurfaceHeight;
if (Physics.Raycast(position, Vector3.down, maxDepth, LayerConstants.GetPlayerLayerCollisionMask()))
{
return(true);
}
}
return(false);
}
protected override void awake()
{
waterLayer = LayerMask.NameToLayer(LayerConstants.WaterLayer);
raycastLayerMask = LayerConstants.GetTubeLayerCollisionMask();
motion = GetComponent <MotionTracker>();
isLocalPlayer = base.gameObject.CompareTag("Player");
thisTransform = base.transform;
ToRaceController = false;
mutableData = instantiateData();
minSpeedForFastLoopAnim = Mathf.Max(mutableData.MinSpeedForSlowLoopAnim, mutableData.MinSpeedForFastLoopAnim);
minMagnitudeForBumpSq = mutableData.MinMagnitudeForBump * mutableData.MinMagnitudeForBump;
jumpRequest = new ActionRequest(PenguinUserControl.DefaultActionRequestBufferTime, animator, AnimationHashes.Params.Jump);
base.enabled = false;
}
private void OnDrawGizmosSelected()
{
Vector3?vector = PhysicsUtil.IntersectionPointWithLayer(base.gameObject, LayerConstants.GetPlayerLayerCollisionMask(), 20f, Vector3.down);
if (vector.HasValue)
{
Gizmos.color = GeyserColor;
Gizmos.DrawLine(base.gameObject.transform.position, vector.Value);
Gizmos.DrawSphere(vector.Value, 0.05f);
Gizmos.DrawWireSphere(vector.Value, GeyserDiameter / 2f);
Gizmos.color = MagnetColor;
Gizmos.DrawSphere(vector.Value + new Vector3(0f, GeyserHeight, 0f), 0.05f);
Gizmos.DrawWireSphere(vector.Value + new Vector3(0f, GeyserHeight, 0f), MagnetDiameter / 2f);
}
}
private void initialize()
{
isEventFogActive = false;
isAdjustmentOverride = false;
geyserPhase = GeyserPhase.None;
int num = CollectibleObjects.Length;
spawnPoint = new Vector3?[num];
for (int i = 0; i < num; i++)
{
GameObject gameObject = CollectibleObjects[i];
ref Vector3?reference = ref spawnPoint[i];
reference = PhysicsUtil.IntersectionPointWithLayer(gameObject, LayerConstants.GetPlayerLayerCollisionMask(), 20f, Vector3.down);
gameObject.SetActive(value: false);
}
private bool CanReachWaypoint()
{
bool result = true;
Vector3 vector = base.transform.position + Vector3.up * actorHalfHeight;
Vector3 vector2 = targetDestination.transform.position + Vector3.up * actorHalfHeight;
Vector3 direction = vector2 - vector;
float magnitude = direction.magnitude;
Vector3 normalized = new Vector3(0f - direction.z, 0f, direction.x).normalized;
int playerLayerCollisionMask = LayerConstants.GetPlayerLayerCollisionMask();
if (Physics.Raycast(vector + normalized * actorRadius, direction, magnitude, playerLayerCollisionMask) || Physics.Raycast(vector - normalized * actorRadius, direction, magnitude, playerLayerCollisionMask))
{
result = false;
}
return(result);
}
public void Awake()
{
raycastLayerMask = LayerConstants.GetPlayerLayerCollisionMask();
}
public void LateUpdate()
{
if (!(player != null) || !base.enabled)
{
return;
}
raycastLayerMask = LayerConstants.GetTubeLayerCollisionMask();
totalForce = Vector3.zero;
calcTargetForward(player);
targetPos = player.transform.position;
calcDesiredBoom();
if (Collision)
{
avoidWalls();
}
arrive();
Vector3 a = totalForce / Mass;
curVelocity += a * Time.deltaTime;
curVelocity = Vector3.ClampMagnitude(curVelocity, MaxSpeed);
desiredTransform.position += curVelocity * Time.deltaTime;
Vector3 normalized = (targetPos - base.transform.position).normalized;
Quaternion b;
if (TrackGuides && isTrackTargetPointValid)
{
Vector3 vector = trackTargetPoint - base.transform.position;
vector.y = targetPos.y - base.transform.position.y;
vector.Normalize();
float num = Vector3.Dot(normalized, vector);
vector = ((!(num < 0f)) ? (vector * num) : Vector3.zero);
if (curTrackDirBlendTime < TrackDirBlendDuration)
{
curTrackDirBlendTime += Time.deltaTime;
curTrackDirBlendTime = Mathf.Min(curTrackDirBlendTime, TrackDirBlendDuration);
curTrackDir = Vector3.Lerp(startTrackDir, vector, TrackDirBlendCurve.Evaluate(curTrackDirBlendTime / TrackDirBlendDuration));
}
else
{
curTrackDir = Vector3.Lerp(curTrackDir, vector, 5f * Time.deltaTime);
}
Debug.DrawLine(base.transform.position, base.transform.position + curTrackDir * 20f, Color.blue, 0.1f);
Debug.DrawLine(base.transform.position, trackTargetPoint, Color.black, 0.1f);
Vector3 vector2 = normalized * TargetDirectionContribution + curTrackDir * TrackDirectionContribution;
b = Quaternion.LookRotation(vector2);
Debug.DrawLine(base.transform.position, base.transform.position + vector2 * 20f, Color.red, 0.1f);
}
else
{
b = Quaternion.LookRotation(normalized);
}
if (Banking)
{
bank(player);
desiredTransform.rotation = oldRotation;
desiredTransform.rotation = Quaternion.Slerp(desiredTransform.rotation, b, LookatSmoothing * Time.deltaTime);
oldRotation = desiredTransform.rotation;
float num2 = 1f - Mathf.Min(bankAngle / 45f, 1f);
desiredTransform.Rotate(VerticalOffsetAngle * num2, 0f, bankAngle * BankWeight, Space.Self);
}
else
{
desiredTransform.rotation = Quaternion.Slerp(base.transform.rotation, b, LookatSmoothing * Time.deltaTime);
oldRotation = desiredTransform.rotation;
}
base.transform.rotation = desiredTransform.rotation;
base.transform.position = desiredTransform.position;
}
public static int SampleSurface(Transform transform, SurfaceEffectsData data, out Vector3 hitPoint)
{
hitPoint = Vector3.zero;
int result = -1;
if (Physics.Raycast(transform.position + Vector3.up * 0.9f, Vector3.down, out var hitInfo, 2f, LayerConstants.GetSurfaceSamplerLayerCollisionMask()))
{
hitPoint = hitInfo.point;
result = GetSurfaceType(ref hitInfo, data);
}
return(result);
}
