private bool onFriendLocationReceived(FriendsServiceEvents.FriendLocationInRoomReceived evt)
{
eventChannel.RemoveListener <FriendsServiceEvents.FriendLocationInRoomReceived>(onFriendLocationReceived);
eventChannel.RemoveListener <FriendsServiceEvents.FriendNotInRoom>(onFriendNotInRoom);
Vector3 location = evt.Location;
if (!(Vector3.Distance(SceneRefs.ZoneLocalPlayerManager.LocalPlayerGameObject.transform.position, location) <= 3f))
{
LocomotionTracker component = SceneRefs.ZoneLocalPlayerManager.LocalPlayerGameObject.GetComponent <LocomotionTracker>();
GameObjectReferenceData component2;
if (component.IsCurrentControllerOfType <SlideController>())
{
component.SetCurrentController <RunController>();
}
else if (component.IsCurrentControllerOfType <SwimController>() && dataEntityCollection.TryGetComponent <GameObjectReferenceData>(Handle, out component2))
{
LocomotionTracker component3 = component2.GameObject.GetComponent <LocomotionTracker>();
if (component3.IsCurrentControllerOfType <RunController>())
{
Animator component4 = SceneRefs.ZoneLocalPlayerManager.LocalPlayerGameObject.GetComponent <Animator>();
component4.SetTrigger(AnimationHashes.Params.SwimToWalk);
component.SetCurrentController <RunController>();
}
}
if (component.IsCurrentControllerOfType <RunController>())
{
location.y += 0.5f;
}
SceneRefs.ZoneLocalPlayerManager.LocalPlayerGameObject.transform.position = location;
ClubPenguin.Core.SceneRefs.Get <BaseCamera>().Snap();
CoroutineRunner.Start(LocomotionUtils.nudgePlayer(component), component.gameObject, "MoveAfterJump");
}
destroyAndCloseCellPhone();
return(false);
}
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 Update()
{
LocomotionTracker component = GetTarget().GetComponent <LocomotionTracker>();
if (component == null)
{
Completed(null, conditionBranchValue: false);
}
else if (Sitting && component.IsCurrentControllerOfType <SitController>())
{
Completed();
}
else if (Tubing && component.IsCurrentControllerOfType <SlideController>())
{
Completed();
}
else if (Swimming && component.IsCurrentControllerOfType <SwimController>())
{
Completed();
}
else if (Running && component.IsCurrentControllerOfType <RunController>())
{
Completed();
}
else
{
Completed(null, conditionBranchValue: false);
}
}
private void jumpToRestartLocation()
{
GameObject localPlayerGameObject = SceneRefs.ZoneLocalPlayerManager.LocalPlayerGameObject;
Vector3 raceRestartPosition = tubeRaceDefinition.RaceRestartPosition;
RaceController component = localPlayerGameObject.GetComponent <RaceController>();
if (component != null)
{
component.setControlsEnabled(enabled: true);
}
LocomotionTracker component2 = localPlayerGameObject.GetComponent <LocomotionTracker>();
if (!component2.IsCurrentControllerOfType <RunController>())
{
component2.SetCurrentController <RunController>();
}
localPlayerGameObject.transform.position = raceRestartPosition;
RaceGameController component3 = localPlayerGameObject.GetComponent <RaceGameController>();
if (component3 != null)
{
component3.RemoveLocalPlayerRaceData();
Object.Destroy(component3);
}
Service.Get <EventDispatcher>().DispatchEvent(new CinematographyEvents.CameraSnapLockEvent(snapPosition: false, snapAim: true));
CoroutineRunner.Start(LocomotionUtils.nudgePlayer(component2), component2.gameObject, "MoveAfterJump");
}
protected override void Update()
{
LocomotionTracker component = GetTarget().GetComponent <LocomotionTracker>();
if (component != null)
{
if (RunDelay > 0f)
{
component.DisallowController <RunController>(RunDelay);
}
if (SwimDelay > 0f)
{
component.DisallowController <SwimController>(SwimDelay);
}
if (SlideDelay > 0f)
{
component.DisallowController <SlideController>(SlideDelay);
}
if (SitDelay > 0f)
{
component.DisallowController <SitController>(SitDelay);
}
}
Completed();
}
private void Awake()
{
anim = GetComponent <Animator>();
locomotionEventBroadcaster = GetComponent <LocomotionEventBroadcaster>();
locomotionEventBroadcaster.OnDoActionEvent += OnLocomotionBroadcasterDoAction;
locomotionTracker = GetComponent <LocomotionTracker>();
propInteractionQueue = new List <PropInteractionRequest>();
}
public virtual void Awake()
{
dataEntityCollection = Service.Get <CPDataEntityCollection>();
locoEventBroadcaster = GetComponent <LocomotionEventBroadcaster>();
dispatcher = Service.Get <EventDispatcher>();
interactRequest = new ActionRequest(PenguinUserControl.DefaultActionRequestBufferTime);
locomotionTracker = GetComponent <LocomotionTracker>();
currentActionGraphGameObject = null;
}
private void disableOtherLocomotionControllers()
{
LocomotionTracker component = Target.Value.gameObject.GetComponent <LocomotionTracker>();
if (component != null)
{
component.DisallowController <SlideController>(2f);
}
}
private void moveLocalPlayerToPosition(Vector3 position)
{
GameObject localPlayerGameObject = SceneRefs.ZoneLocalPlayerManager.LocalPlayerGameObject;
localPlayerGameObject.transform.position = position + new Vector3(0f, 0.5f, 0f);
LocomotionTracker component = localPlayerGameObject.GetComponent <LocomotionTracker>();
CoroutineRunner.Start(LocomotionUtils.nudgePlayer(component), component.gameObject, "MoveAfterJump");
}
public void Awake()
{
agent = GetComponent <NavMeshAgent>();
tracker = GetComponent <LocomotionTracker>();
agent.updatePosition = false;
agent.updateRotation = false;
tracker.SetCurrentController <RunController>();
runController = GetComponent <RunController>();
runController.Behaviour.SetStyle(LocoStyle);
}
public void ResetPlayer()
{
LocomotionTracker component = GetComponent <LocomotionTracker>();
if (component != null)
{
component.SetCurrentController <RunController>();
}
base.transform.position = startingPosition;
base.transform.rotation = startingRotation;
Service.Get <EventDispatcher>().DispatchEvent(new OutOfBoundsWarperEvents.ResetPlayer(base.gameObject));
}
private void Awake()
{
if (base.gameObject.CompareTag("Player") && SurfaceSamplingData != null)
{
anim = GetComponent <Animator>();
tracker = GetComponent <LocomotionTracker>();
locoStatus = LocomotionStatus.Unknown;
CoroutineRunner.Start(SampleSurface(), this, "SampleSurface");
}
else
{
base.enabled = false;
}
}
private void Awake()
{
dataEntityCollection = Service.Get <CPDataEntityCollection>();
locomotionTracker = GetComponent <LocomotionTracker>();
locomotionStateSetter = GetComponent <AvatarLocomotionStateSetter>();
playerDataHandle = GetComponent <AvatarDataHandle>();
positionTimeline = new PositionTimeline(MaxQueueTimeMS, WarningQueueTimeMS);
remoteSnowballLauncher = GetComponent <RemotePenguinSnowballThrower>();
timer = new Stopwatch();
eventChannel = new EventChannel(Service.Get <EventDispatcher>());
eventChannel.AddListener <PlayerActionServiceEvents.LocomotionActionReceived>(onLocomotionAction);
locomotionEventBroadcaster = GetComponent <LocomotionEventBroadcaster>();
locomotionEventBroadcaster.OnControlsLocked += onControlsLocked;
locomotionEventBroadcaster.OnControlsUnLocked += onControlsUnLocked;
}
private void Start()
{
locomotionTracker = GetComponent <LocomotionTracker>();
locomotionEventBroadcaster = GetComponent <LocomotionEventBroadcaster>();
locomotionEventBroadcaster.OnDoActionEvent += sendDoActionEvent;
locomotionEventBroadcaster.OnLocomotionStateChangedEvent += sendLocomotionStateChangedEvent;
locomotionEventBroadcaster.OnInteractionStartedEvent += filterSendInteractionEvent;
locomotionEventBroadcaster.OnSteerDirectionEvent += onSteerDirectionChanged;
locomotionEventBroadcaster.OnSteerRotationDirectionEvent += onSteerRotationDirectionChanged;
locomotionEventBroadcaster.OnSteerRotationFlushEvent += onSteerRotationFlush;
locomotionEventBroadcaster.OnControllerChangedEvent += onControllerChanged;
locomotionEventBroadcaster.OnControlsLocked += onControlsLocked;
locomotionEventBroadcaster.OnControlsUnLocked += onControlsUnLocked;
networkService = Service.Get <INetworkServicesManager>();
Service.Get <EventDispatcher>().AddListener <WorldServiceEvents.SelfWillLeaveRoomEvent>(onUserLeaving);
Service.Get <EventDispatcher>().AddListener <WorldServiceEvents.SelfRoomJoinedEvent>(onUserJoined);
}
private IEnumerator setPositionToSpawnPointWaitAFrame(SpawnPointSelector spawner)
{
base.transform.position = spawner.SelectSpawnPosition(CoordinateSpace.World);
base.transform.rotation = spawner.SelectSpawnRotation(CoordinateSpace.World);
yield return(null);
LocomotionTracker tracker = ClubPenguin.SceneRefs.ZoneLocalPlayerManager.LocalPlayerGameObject.GetComponent <LocomotionTracker>();
if (tracker != null)
{
tracker.SetCurrentController <RunController>();
}
base.transform.position = spawner.SelectSpawnPosition(CoordinateSpace.World);
base.transform.rotation = spawner.SelectSpawnRotation(CoordinateSpace.World);
yield return(null);
LocomotionActionEvent movement = default(LocomotionActionEvent);
movement.Type = LocomotionAction.Move;
movement.Position = base.transform.position;
movement.Direction = Vector3.zero;
sendNetworkMessage(movement);
}
private void onViewReady(AvatarBaseAsync view)
{
if (locomotionData == null)
{
return;
}
LocomotionTracker component = GetComponent <LocomotionTracker>();
switch (locomotionData.LocoState)
{
case LocomotionState.Slide:
if (component.IsCurrentControllerOfType <SlideController>())
{
GetComponent <Animator>().SetBool(AnimationHashes.Params.Slide, value: true);
GetComponent <Animator>().Play(AnimationHashes.States.Slide.Enter, 0);
}
else
{
component.SetCurrentController <SlideController>();
}
break;
case LocomotionState.Sitting:
{
if (!component.IsCurrentControllerOfType <SitController>())
{
component.SetCurrentController <SitController>();
}
SitController sitController = component.GetCurrentController() as SitController;
if (sitController != null)
{
sitController.RemoteSit(null);
}
break;
}
}
}
private bool isInteractingWithZiplineActionGraph(GameObject player)
{
if (player.IsDestroyed())
{
return(false);
}
LocomotionTracker component = player.GetComponent <LocomotionTracker>();
if (component == null)
{
return(false);
}
if (component.IsCurrentControllerOfType <ZiplineController>())
{
return(true);
}
GameObject trigger = ClubPenguin.SceneRefs.ActionSequencer.GetTrigger(player);
if (trigger == null)
{
return(false);
}
return(trigger.GetComponent <SetZiplineLocomotionAction>() != null);
}
protected override void awake()
{
tracker = GetComponent <LocomotionTracker>();
base.enabled = false;
}
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);
}
}
public void SpawnPlayer(SpawnPlayerParams spawnPlayerParams)
{
if (spawnPlayerParams.Zone != null || !string.IsNullOrEmpty(spawnPlayerParams.SceneName))
{
bool flag = false;
PresenceData component = dataEntityCollection.GetComponent <PresenceData>(dataEntityCollection.LocalPlayerHandle);
ZoneTransitionService zoneTransitionService = Service.Get <ZoneTransitionService>();
if (spawnPlayerParams.Zone != null)
{
ZoneDefinition zoneBySceneName = zoneTransitionService.GetZoneBySceneName(component.Room);
flag = (zoneBySceneName != null && string.Equals(spawnPlayerParams.Zone.ZoneName, zoneBySceneName.ZoneName));
}
else if (!string.IsNullOrEmpty(spawnPlayerParams.SceneName))
{
flag = ((!zoneTransitionService.IsInIgloo) ? string.Equals(component.Room, spawnPlayerParams.SceneName) : string.Equals(zoneTransitionService.CurrentZone.SceneName, spawnPlayerParams.SceneName));
}
if (!flag)
{
if (!dataEntityCollection.TryGetComponent(dataEntityCollection.LocalPlayerHandle, out SpawnData component2))
{
component2 = dataEntityCollection.AddComponent <SpawnData>(dataEntityCollection.LocalPlayerHandle);
}
if (spawnPlayerParams.SpawnedAction != null)
{
component2.SpawnedAction = spawnPlayerParams.SpawnedAction;
}
component2.Position = spawnPlayerParams.Position;
component2.Rotation = spawnPlayerParams.Rotation;
component2.PendingReward = spawnPlayerParams.PendingReward;
if (spawnPlayerParams.Zone != null)
{
zoneTransitionService.LoadZone(spawnPlayerParams.Zone, "Loading");
}
else
{
zoneTransitionService.LoadZone(spawnPlayerParams.SceneName, "Loading");
}
return;
}
}
if (spawnPlayerParams.PendingReward != null)
{
Service.Get <EventDispatcher>().DispatchEvent(new RewardServiceEvents.MyRewardEarned(RewardSource.QUICK_NOTIFICATION, "", spawnPlayerParams.PendingReward));
}
if (Vector3.Distance(base.transform.position, spawnPlayerParams.Position) <= 3f)
{
if (spawnPlayerParams.SpawnedAction != null)
{
executeSpawedAction(spawnPlayerParams.SpawnedAction);
}
return;
}
LocomotionTracker component3 = base.gameObject.GetComponent <LocomotionTracker>();
if (component3.IsCurrentControllerOfType <SlideController>())
{
component3.SetCurrentController <RunController>();
}
else if (spawnPlayerParams.GetOutOfSwimming && component3.IsCurrentControllerOfType <SwimController>())
{
Animator component4 = base.gameObject.GetComponent <Animator>();
component4.SetTrigger(AnimationHashes.Params.SwimToWalk);
component3.SetCurrentController <RunController>();
}
Vector3 zero = Vector3.zero;
if (spawnPlayerParams.NudgePlayer && component3.IsCurrentControllerOfType <RunController>())
{
zero.y = 0.5f;
}
base.transform.position = spawnPlayerParams.Position + zero;
ClubPenguin.Core.SceneRefs.Get <BaseCamera>().Snap();
if (spawnPlayerParams.NudgePlayer)
{
actionOnSpawned = spawnPlayerParams.SpawnedAction;
CoroutineRunner.Start(LocomotionUtils.nudgePlayer(component3, onNudgePlayerDone), component3.gameObject, "MoveAfterJump");
}
else if (spawnPlayerParams.SpawnedAction != null)
{
executeSpawedAction(spawnPlayerParams.SpawnedAction);
}
}
private void Awake()
{
locomotionTracker = GetComponent <LocomotionTracker>();
}
protected virtual void identifiedLocalPlayer(GameObject localPlayer)
{
locomotionTracker = localPlayer.GetComponent <LocomotionTracker>();
}
