private bool OnPlayerJoins(WorldServiceEvents.PlayerJoinRoomEvent evt)
{
if (isLocalPlayer(evt.SessionId))
{
return(false);
}
DataEntityHandle handle = PlayerDataEntityFactory.CreateRemotePlayerEntity(dataEntityCollection, evt.Name, evt.SessionId);
PlayerDataEntityFactory.AddCommonDataComponents(dataEntityCollection, handle);
PlayerDataEntityFactory.AddCommonZoneScopeDataComponents(dataEntityCollection, handle);
if (!dataEntityCollection.HasComponent <RemotePlayerData>(handle))
{
dataEntityCollection.AddComponent <RemotePlayerData>(handle);
}
if (!dataEntityCollection.HasComponent <ParticipationData>(handle))
{
dataEntityCollection.AddComponent <ParticipationData>(handle);
}
PresenceData component = dataEntityCollection.GetComponent <PresenceData>(handle);
if (dataEntityCollection.TryGetComponent <PresenceData>(dataEntityCollection.LocalPlayerHandle, out var component2))
{
component.World = component2.World;
component.Room = component2.Room;
component.ContentIdentifier = component2.ContentIdentifier;
component.InstanceRoom = component2.InstanceRoom;
}
component.IsDisconnecting = false;
eventDispatcher.DispatchEvent(new NetworkControllerEvents.RemotePlayerJoinedRoomEvent(handle));
return(false);
}
private void showCurrentServerInfo()
{
PresenceData component = Service.Get <CPDataEntityCollection>().GetComponent <PresenceData>(Service.Get <CPDataEntityCollection>().LocalPlayerHandle);
currentWorldDefinition = Service.Get <ZoneTransitionService>().GetWorld(component.World);
CurrentServer.LoadWorld(currentWorldDefinition, currentServer: true);
}
private bool createRemotePlayer(DataEntityHandle remotePlayerHandle, bool attemptSpawn = true)
{
if (!dataEntityCollection.HasComponent <GameObjectReferenceData>(remotePlayerHandle))
{
dataEntityCollection.AddComponent <GameObjectReferenceData>(remotePlayerHandle);
}
if (!dataEntityCollection.HasComponent <AirBubbleData>(remotePlayerHandle))
{
dataEntityCollection.AddComponent <AirBubbleData>(remotePlayerHandle);
}
PositionData component = dataEntityCollection.GetComponent <PositionData>(remotePlayerHandle);
RemotePlayerData component2 = dataEntityCollection.GetComponent <RemotePlayerData>(remotePlayerHandle);
component2.PlayerRemoved += onPlayerRemoved;
playerRemovedListeners.Add(component2);
PresenceData component3 = dataEntityCollection.GetComponent <PresenceData>(remotePlayerHandle);
if (component3 != null)
{
component3.PresenceDataUpdated += onPresenceDataUpdated;
}
if (!dataEntityCollection.HasComponent <LODRequestReference>(remotePlayerHandle))
{
LODRequestData requestData = new LODRequestData(LODSystem.REMOTE_PLAYER, remotePlayerHandle, component);
requestData.OnGameObjectGeneratedEvent += onLODGameObjectGenerated;
requestData.OnGameObjectRevokedEvent += onLODGameObjectRevoked;
LODRequest request = Service.Get <LODService>().Request(requestData, attemptSpawn);
dataEntityCollection.AddComponent <LODRequestReference>(remotePlayerHandle).Request = request;
}
return(false);
}
private void onTemporaryHeadStatusUpdated(PresenceData presenceData)
{
HeadStatusView component = base.gameObject.GetComponent <HeadStatusView>();
if (component != null)
{
component.LoadParticlePrefab(presenceData.TemporaryHeadStatusType);
}
}
protected virtual bool onRoomJoined(WorldServiceEvents.SelfRoomJoinedEvent evt)
{
DataEntityHandle localPlayerHandle = dataEntityCollection.LocalPlayerHandle;
if (localPlayerHandle.IsNull)
{
throw new MissingReferenceException("The local player handle does not exist!");
}
PlayerDataEntityFactory.AddCommonDataComponents(dataEntityCollection, localPlayerHandle);
PlayerDataEntityFactory.AddCommonZoneScopeDataComponents(dataEntityCollection, localPlayerHandle);
dataEntityCollection.AddComponent <LocalPlayerInZoneData>(localPlayerHandle);
PresenceData component2 = dataEntityCollection.GetComponent <PresenceData>(localPlayerHandle);
if (string.IsNullOrEmpty(evt.Room.zoneId.instanceId))
{
component2.World = evt.Room.world;
component2.Room = evt.Room.zoneId.name;
component2.ContentIdentifier = evt.Room.contentIdentifier;
component2.InstanceRoom = null;
}
else
{
component2.InstanceRoom = evt.Room.zoneId;
}
DataEntityHandle[] remotePlayerHandles = dataEntityCollection.GetRemotePlayerHandles();
for (int i = 0; i < remotePlayerHandles.Length; i++)
{
PresenceData component3 = dataEntityCollection.GetComponent <PresenceData>(remotePlayerHandles[i]);
if (string.IsNullOrEmpty(evt.Room.zoneId.instanceId))
{
component3.World = evt.Room.world;
component3.Room = evt.Room.zoneId.name;
component3.ContentIdentifier = evt.Room.contentIdentifier;
component3.InstanceRoom = null;
}
else
{
component3.InstanceRoom = evt.Room.zoneId;
}
}
if (dataEntityCollection.TryGetComponent <SessionIdData>(localPlayerHandle, out var component4))
{
component4.SessionId = evt.SessionId;
}
else
{
component4 = dataEntityCollection.AddComponent(localPlayerHandle, delegate(SessionIdData component)
{
component.SessionId = evt.SessionId;
});
}
eventDispatcher.DispatchEvent(new NetworkControllerEvents.LocalPlayerJoinedRoomEvent(localPlayerHandle, evt.Room.world, evt.Room.zoneId.name));
return(false);
}
private void handlePresenceData(PresenceData presenceData)
{
if (!string.IsNullOrEmpty(presenceData.World))
{
SettingsPanelServerListButton buttonForWorld = getButtonForWorld(presenceData.World);
if (buttonForWorld != null)
{
buttonForWorld.ShowFriendIndicator();
}
else
{
worldsWithFriends.Add(presenceData.World);
}
}
}
private void onPresenceDataUpdated(PresenceData presenceData)
{
DataEntityHandle entityByComponent = dataEntityCollection.GetEntityByComponent(presenceData);
if (!entityByComponent.IsNull && dataEntityCollection.TryGetComponent <LODRequestReference>(entityByComponent, out var component))
{
if (presenceData.AFKState.Type == AwayFromKeyboardStateType.AwayFromWorld)
{
Service.Get <LODService>().PauseRequest(component.Request);
}
else if (component.Request.IsPaused)
{
Service.Get <LODService>().UnpauseRequest(component.Request);
}
}
}
private bool OnAwayFromKeyboardStateChanged(PlayerStateServiceEvents.AwayFromKeyboardStateChanged evt)
{
if (isLocalPlayer(evt.SessionId))
{
return(false);
}
DataEntityHandle dataEntityHandle = dataEntityCollection.FindEntity <SessionIdData, long>(evt.SessionId);
if (!dataEntityHandle.IsNull)
{
PresenceData component = dataEntityCollection.GetComponent <PresenceData>(dataEntityHandle);
if (component != null)
{
component.AFKState = new AwayFromKeyboardState((AwayFromKeyboardStateType)evt.Value, evt.EquippedObject);
}
}
return(false);
}
private bool OnTemporaryHeadStatusChanged(PlayerStateServiceEvents.TemporaryHeadStatusChanged evt)
{
if (isLocalPlayer(evt.SessionId))
{
return(false);
}
DataEntityHandle dataEntityHandle = dataEntityCollection.FindEntity <SessionIdData, long>(evt.SessionId);
if (!dataEntityHandle.IsNull)
{
PresenceData component = dataEntityCollection.GetComponent <PresenceData>(dataEntityHandle);
if (component != null)
{
component.TemporaryHeadStatusType = (TemporaryHeadStatusType)evt.Type;
}
}
return(false);
}
private void returnToPreviousScene()
{
isCancelledSceneTransitionRequested = false;
PresenceData component = dataEntityCollection.GetComponent <PresenceData>(dataEntityCollection.LocalPlayerHandle);
dataEntityCollection.ClearZoneScope();
Service.Get <GameStateController>().GoOffline();
Service.Get <LoadingController>().ClearAllLoadingSystems();
if (component.IsInInstancedRoom)
{
LoadIgloo(component.InstanceRoom, Service.Get <Localizer>().Language, SceneStateData.SceneState.Play, Service.Get <GameStateController>().SceneConfig.TransitionSceneName);
}
else
{
LoadZone(component.Room, Service.Get <GameStateController>().SceneConfig.TransitionSceneName, component.World);
}
Service.Get <GameStateController>().TriggerZoneConnectingEvent();
}
private void onPresenceDataUpdated(PresenceData obj)
{
switch (obj.AFKState.Type)
{
case AwayFromKeyboardStateType.Here:
setAfkAnimation(AnimationHashes.Params.AwayFromKeyboardExitTrigger, AnimationHashes.Params.AwayFromKeyboardEnterTrigger);
if (isUsingAFKProp)
{
clearAfkProp();
}
break;
case AwayFromKeyboardStateType.CellPhone:
setAfkProp(cellPhoneAFKProp);
break;
case AwayFromKeyboardStateType.ClothingDesigner:
setAfkProp(dressingBoothAFKProp);
break;
case AwayFromKeyboardStateType.Exchange:
setAfkAnimation(AnimationHashes.Params.AwayFromKeyboardEnterTrigger, AnimationHashes.Params.AwayFromKeyboardExitTrigger);
break;
case AwayFromKeyboardStateType.IglooEditor:
setAfkProp(iglooPlansAFKProp);
break;
case AwayFromKeyboardStateType.Marketplace:
setAfkAnimation(AnimationHashes.Params.AwayFromKeyboardEnterTrigger, AnimationHashes.Params.AwayFromKeyboardExitTrigger);
break;
case AwayFromKeyboardStateType.Map:
setAfkProp(mapAFKProp);
break;
case AwayFromKeyboardStateType.AwayFromWorld:
break;
}
}
public bool ConnectToZone(string sceneName, string worldName = null, string onJoinNotificationTag = null)
{
ZoneDefinition zoneBySceneName = GetZoneBySceneName(sceneName);
if (zoneBySceneName == null)
{
Log.LogError(this, "Attempting to join a zone that doesn't exist");
return(false);
}
if (!startZoneTransition(sceneName, onJoinNotificationTag))
{
return(false);
}
PresenceData component = dataEntityCollection.GetComponent <PresenceData>(dataEntityCollection.LocalPlayerHandle);
ContentIdentifier contentIdentifier = generateContentIdentifier();
if (!string.IsNullOrEmpty(worldName))
{
targetWorldToJoin = worldName;
ZoneId zoneId = new ZoneId();
zoneId.name = zoneBySceneName.ZoneName;
Service.Get <INetworkServicesManager>().WorldService.JoinRoomInWorld(new RoomIdentifier(worldName, Service.Get <Localizer>().Language, zoneId, contentIdentifier.ToString()), this);
}
else if (component != null && !string.IsNullOrEmpty(component.World))
{
targetWorldToJoin = component.World;
ZoneId zoneId = new ZoneId();
zoneId.name = zoneBySceneName.ZoneName;
Service.Get <INetworkServicesManager>().WorldService.JoinRoomInWorld(new RoomIdentifier(component.World, Service.Get <Localizer>().Language, zoneId, contentIdentifier.ToString()), this);
}
else
{
targetWorldToJoin = null;
Service.Get <INetworkServicesManager>().WorldService.JoinRoom(zoneBySceneName.ZoneName, contentIdentifier.ToString(), Service.Get <Localizer>().LanguageString, this);
}
PreviousZone = CurrentZone;
CurrentZone = zoneBySceneName;
CurrentInstanceId = "";
return(IsConnecting);
}
private void setUpProfile(ProfileData profileData, PresenceData presenceData, MembershipData membershipData, OtherPlayerData data)
{
profileData.PenguinAgeInDays = ((data.profile != null) ? data.profile.daysOld : 0);
profileData.MascotXP = data.mascotXP;
membershipData.IsMember = data.member;
profileData.ZoneId = data.zoneId;
membershipData.MembershipType = (data.member ? MembershipType.Member : MembershipType.None);
if (!membershipData.IsMember && Service.Get <AllAccessService>().IsAllAccessActive())
{
membershipData.IsMember = true;
membershipData.MembershipType = MembershipType.AllAccessEventMember;
}
if (data.onlineLocation != null)
{
profileData.IsOnline = true;
presenceData.World = data.onlineLocation.world;
presenceData.Room = data.onlineLocation.zoneId.name;
presenceData.ContentIdentifier = data.onlineLocation.contentIdentifier;
if (string.IsNullOrEmpty(data.onlineLocation.zoneId.instanceId))
{
presenceData.InstanceRoom = null;
}
else
{
presenceData.InstanceRoom = data.onlineLocation.zoneId;
}
}
else
{
profileData.IsOnline = false;
presenceData.World = null;
presenceData.Room = null;
presenceData.ContentIdentifier = null;
presenceData.InstanceRoom = null;
}
}
private void OnPresenceDataUpdated(PresenceData presenceData)
{
handlePresenceData(presenceData);
presenceData.PresenceDataUpdated -= OnPresenceDataUpdated;
}
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 <SpawnData>(dataEntityCollection.LocalPlayerHandle, out var 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);
}
}
