private void resetCamera()
{
if (!isCameraSetUp)
{
return;
}
if (playerPenguinGO != null)
{
playerPenguinGO.transform.rotation = previousPenguinRotation;
}
if (Camera.main != null)
{
CameraCullingMaskHelper.ShowLayer(Camera.main, "RemotePlayer");
}
GameObject gameObject = GameObject.FindWithTag(UIConstants.Tags.UI_Chat);
if (gameObject != null)
{
Canvas[] componentsInChildren = gameObject.GetComponentsInChildren <Canvas>();
for (int i = 0; i < componentsInChildren.Length; i++)
{
componentsInChildren[i].enabled = true;
}
}
Service.Get <EventDispatcher>().DispatchEvent(default(BlobShadowEvents.EnableBlobShadows));
if (isZoomSetup)
{
CinematographyEvents.ZoomCameraEvent evt = new CinematographyEvents.ZoomCameraEvent(state: false);
Service.Get <EventDispatcher>().DispatchEvent(evt);
isZoomSetup = false;
}
}
private void focusCameraOnPenguin()
{
playerPenguinGO = ClubPenguin.SceneRefs.ZoneLocalPlayerManager.LocalPlayerGameObject;
if (playerPenguinGO == null)
{
return;
}
CameraCullingMaskHelper.HideLayer(Camera.main, "RemotePlayer");
GameObject gameObject = GameObject.FindWithTag(UIConstants.Tags.UI_Chat);
if (gameObject != null)
{
Canvas[] componentsInChildren = gameObject.GetComponentsInChildren <Canvas>();
for (int i = 0; i < componentsInChildren.Length; i++)
{
componentsInChildren[i].enabled = false;
}
}
Service.Get <EventDispatcher>().DispatchEvent(new BlobShadowEvents.DisableBlobShadows(includeLocalPlayerShadow: false));
previousPenguinRotation = playerPenguinGO.transform.rotation;
Vector3 vector = Camera.main.transform.position - playerPenguinGO.transform.position;
playerPenguinGO.transform.rotation = Quaternion.LookRotation(new Vector3(vector.x, 0f, vector.z));
CinematographyEvents.ZoomCameraEvent evt = new CinematographyEvents.ZoomCameraEvent(state: true, ZoomPercentage, ZoomPercentage, 0f, ZoomHeightOffset, ZoomMinDist);
Service.Get <EventDispatcher>().DispatchEvent(evt);
isZoomSetup = true;
isCameraSetUp = true;
}
private void onPropUsed()
{
SpawnedInstance = (IsInstance ? PrefabToSpawn : Object.Instantiate(PrefabToSpawn));
if (ParentToUser)
{
SpawnedInstance.transform.SetParent(prop.PropUserRef.transform, worldPositionStays: false);
}
else
{
SpawnedInstance.transform.position = prop.OnUseDestination;
CameraCullingMaskHelper.SetLayerRecursive(SpawnedInstance.transform, "AllPlayerInteractibles");
}
SpawnedInstance.InstanceId = prop.ExperienceInstanceId;
SpawnedInstance.OwnerId = prop.OwnerId;
SpawnedInstance.IsOwnerLocalPlayer = prop.IsOwnerLocalPlayer;
SpawnedInstance.PropDef = prop.PropDef;
if (HideInitially)
{
SpawnedInstance.gameObject.SetActive(value: false);
}
else
{
SpawnedInstance.StartExperience();
}
if (ApplyUserForwardVect)
{
SpawnedInstance.transform.forward = prop.PropUserRef.transform.forward;
}
}
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;
}
}
private IEnumerator renderSprite(string unlockID)
{
AssetRequest <GameObject> assetRequest = Content.LoadAsync <GameObject>(unlockID);
yield return(assetRequest);
GameObject itemModel = Object.Instantiate(assetRequest.Asset);
itemModel.transform.rotation = Quaternion.Euler(ITEM_MODEL_ROTATION);
CameraCullingMaskHelper.SetLayerIncludingChildren(itemModel.transform, "IconRender");
if (unlitTextureShader == null)
{
unlitTextureShader = Shader.Find("Unlit/Texture");
}
Material mat = new Material(unlitTextureShader)
{
mainTexture = itemModel.GetComponent <Renderer>().sharedMaterial.mainTexture
};
itemModel.GetComponent <Renderer>().material = mat;
itemModel.AddComponent <ResourceCleaner>();
ModelRenderer modelRenderer = new ModelRenderer(new ModelRendererConfig(itemModel.transform, MODEL_RENDER_OFFSET, new Vector2(256f, 256f))
{
FrameObjectInCamera = true
});
yield return(new WaitForEndOfFrame());
callback(Sprite.Create(modelRenderer.Image, new Rect(0f, 0f, modelRenderer.Image.width, modelRenderer.Image.height), Vector2.zero), null);
modelRenderer.Destroy();
}
private IEnumerator cullCamera()
{
previousCameraCullingMask = Camera.main.cullingMask;
yield return(new WaitForSeconds(1f));
CameraCullingMaskHelper.HideAllLayers(Camera.main);
Service.Get <EventDispatcher>().DispatchEvent(new UIDisablerEvents.CameraCullingStateChanged(isRenderingEnabled: false));
}
private void Awake()
{
CameraCullingMaskHelper.HideLayer(Camera.main, "IconRender");
SceneRefs.SetClothingDesignerCameraController(this);
mainCamera = GetComponent <Camera>();
isAnimatingCamera = false;
isAnimatingViewport = false;
checkPosition = false;
wasOriginalViewportSet = false;
}
private void OnPropEffectSpawned(string path, GameObject prefab)
{
GameObject gameObject = Object.Instantiate(prefab);
if (ParentToUser && prop.PropUserRef != null)
{
gameObject.transform.SetParent(prop.PropUserRef.transform, worldPositionStays: false);
CameraCullingMaskHelper.SetLayerRecursive(gameObject.transform, LayerMask.LayerToName(prop.PropUserRef.transform.gameObject.layer));
}
}
public void AnimEvent_ReleaseSnowball()
{
if (!base.gameObject.IsDestroyed() && CameraCullingMaskHelper.IsLayerOn(Camera.main, "RemotePlayer"))
{
if (snowballInst.Snowball == null)
{
AnimEvent_SpawnSnowball();
}
ReleaseSnowball(snowballInst.Snowball.transform.position, snowballInst.LaunchVel, snowballInst.TrailAlpha);
}
}
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 spawnProjectile()
{
PropProjectile propProjectile = UnityEngine.Object.Instantiate(ProjectilePrefab);
CameraCullingMaskHelper.SetLayerRecursive(propProjectile.transform, "AllPlayerInteractibles");
propProjectile.WorldStart = prop.transform.position;
propProjectile.WorldDestination = prop.OnUseDestination;
propProjectile.transform.forward = prop.PropUserRef.transform.forward;
if (this.ProjectileInstanceCreated != null)
{
this.ProjectileInstanceCreated(propProjectile);
}
}
private void OnParticlesLoaded(string key, GameObject asset)
{
if (!base.gameObject.IsDestroyed())
{
GameObject gameObject = Object.Instantiate(asset);
gameObject.transform.SetParent(base.transform, worldPositionStays: false);
CameraCullingMaskHelper.SetLayerRecursive(gameObject.transform, LayerMask.LayerToName(base.gameObject.layer));
if (isLocalPlayer)
{
StartCoroutine(DelayResetStatus(15f));
}
}
}
protected void spawnParticles()
{
if (mutableData.ParticlesPrefab != null)
{
particles = Object.Instantiate(mutableData.ParticlesPrefab);
particles.Stop();
CameraCullingMaskHelper.SetLayerIncludingChildren(particles.transform, LayerMask.LayerToName(base.gameObject.layer));
Vector3 localPosition = new Vector3(particles.transform.position.x, particles.transform.position.y, particles.transform.position.z);
Quaternion localRotation = new Quaternion(particles.transform.rotation.x, particles.transform.rotation.y, particles.transform.rotation.z, particles.transform.rotation.w);
particles.transform.parent = base.transform;
particles.transform.localPosition = localPosition;
particles.transform.localRotation = localRotation;
}
}
public void AnimEvent_SpawnSled()
{
if (base.enabled && sled == null)
{
if (!IsSliding)
{
AnimEvent_ApplyImpulse();
}
sled = Object.Instantiate(mutableData.SledPrefab, thisTransform.position, thisTransform.rotation);
sledTransform = sled.transform;
sled.GetComponent <TubeLoader>().SetDataHandle(GetComponent <AvatarDataHandle>(), this);
CameraCullingMaskHelper.SetLayerIncludingChildren(sledTransform, LayerMask.LayerToName(base.gameObject.layer));
}
}
public void AnimEvent_SpawnSnowball()
{
if (!base.gameObject.IsDestroyed() && CameraCullingMaskHelper.IsLayerOn(Camera.main, "RemotePlayer"))
{
snowballInst.Snowball = SnowballManager.Instance.SpawnSnowball();
if (snowballInst.Snowball != null)
{
snowballInst.Snowball.transform.SetParent(LauncherBone, worldPositionStays: false);
snowballInst.Snowball.transform.localPosition = Vector3.zero;
snowballInst.Snowball.OnAttached();
snowballInst.Lifetime.Reset();
}
}
}
private void enableWaterEffects()
{
if (mutableData.Ripples != null && waterRipples == null)
{
waterRipples = UnityEngine.Object.Instantiate(mutableData.Ripples);
waterRipples.Stop();
CameraCullingMaskHelper.SetLayerIncludingChildren(waterRipples.transform, LayerMask.LayerToName(base.gameObject.layer));
}
if (mutableData.Splash != null)
{
GameObject gameObject = UnityEngine.Object.Instantiate(mutableData.Splash);
gameObject.transform.position = new Vector3(base.transform.position.x, logicalSurfaceHeight + mutableData.SplashHeightOffset, base.transform.position.z);
CameraCullingMaskHelper.SetLayerIncludingChildren(gameObject.transform, LayerMask.LayerToName(base.gameObject.layer));
}
}
private void setUpNameTag(DataEntityHandle handle, bool isLocalPlayer)
{
if (handle.IsNull || !dataEntityCollection.TryGetComponent <SessionIdData>(handle, out var component))
{
return;
}
long sessionId = component.SessionId;
string displayName = dataEntityCollection.GetComponent <DisplayNameData>(handle).DisplayName;
bool flag = dataEntityCollection.HasComponent <FriendData>(handle);
if (!activePlayerNameTags.ContainsKey(sessionId))
{
PlayerNameTag playerNameTagFromPool = getPlayerNameTagFromPool();
if (isLocalPlayer)
{
playerNameTagFromPool.transform.SetParent(LocalPlayerContainer, worldPositionStays: false);
playerNameTagFromPool.SetNameTagType(PlayerNameTag.Type.LocalPlayer);
}
else if (flag)
{
playerNameTagFromPool.transform.SetParent(FriendPlayersContainer, worldPositionStays: false);
playerNameTagFromPool.SetNameTagType(PlayerNameTag.Type.Friend);
}
else
{
playerNameTagFromPool.transform.SetParent(RemotePlayersContainer, worldPositionStays: false);
playerNameTagFromPool.SetNameTagType(PlayerNameTag.Type.RemotePlayer);
}
playerNameTagFromPool.Handle = handle;
playerNameTagFromPool.SetNameText(displayName);
playerNameTagFromPool.transform.localScale = Vector3.one;
playerNameTagFromPool.transform.localRotation = Quaternion.identity;
Transform transform = getTransform(sessionId);
if (transform != null)
{
CameraCullingMaskHelper.SetLayerIncludingChildren(playerNameTagFromPool.transform, LayerMask.LayerToName(transform.gameObject.layer));
}
activePlayerNameTags.Add(sessionId, new PlayerNameTagAndRectTransform(playerNameTagFromPool, playerNameTagFromPool.GetComponent <RectTransform>()));
if (this.OnPlayerNameAdded != null)
{
this.OnPlayerNameAdded(sessionId);
}
if (!nameTagsActive)
{
playerNameTagFromPool.SetActive(isActive: false);
}
}
}
private void setChatVisible(bool visible)
{
if (localPlayerIsInGame)
{
if (visible)
{
CinematicSpeechState.ShowChatUI();
CameraCullingMaskHelper.ShowLayer(Camera.main, "AllPlayerInteractibles");
}
else
{
CinematicSpeechState.HideChatUI();
CameraCullingMaskHelper.HideLayer(Camera.main, "AllPlayerInteractibles");
}
}
}
public static void ShowRemotePlayers()
{
CameraCullingMaskHelper.ShowLayer(Camera.main, "RemotePlayer");
CameraCullingMaskHelper.ShowLayer(Camera.main, "AllPlayerInteractibles");
Service.Get <EventDispatcher>().DispatchEvent(default(BlobShadowEvents.EnableBlobShadows));
Service.Get <EventDispatcher>().DispatchEvent(default(PlayerNameEvents.ShowPlayerNames));
Service.Get <EventDispatcher>().DispatchEvent(default(PlayerIndicatorEvents.ShowPlayerIndicators));
if (SceneRefs.UiChatRoot != null)
{
WorldChatController componentInChildren = SceneRefs.UiChatRoot.GetComponentInChildren <WorldChatController>();
if (componentInChildren != null)
{
componentInChildren.IgnoreRemoteChat = false;
}
}
}
private void onPropAccessoryLoaded(string path, GameObject prefab)
{
if (base.gameObject.IsDestroyed())
{
return;
}
if (prefab != null)
{
propAccessory = UnityEngine.Object.Instantiate(prefab);
Prop component = GetComponent <Prop>();
if (component != null && component.PropUserRef != null)
{
Rig component2 = component.PropUserRef.GetComponent <Rig>();
parentPropAccessoryToTargetBone(component2);
CameraCullingMaskHelper.SetLayerRecursive(component.transform, LayerMask.LayerToName(component.gameObject.layer));
}
}
isLoadingComplete = true;
}
public void OnCollisionEnter(Collision collision)
{
if (!base.enabled)
{
return;
}
if (collision.gameObject.layer == waterLayer)
{
if (collision.contacts.Length > 0 && mutableData.WaterSplash != null && pilotBody != null && Time.time - lastSplashTime >= mutableData.SplashCooldown)
{
GameObject gameObject = Object.Instantiate(mutableData.WaterSplash);
if (gameObject != null)
{
Vector3 position = pilotBody.transform.position;
position.y = collision.contacts[0].point.y + mutableData.SplashOffset;
gameObject.transform.position = position;
CameraCullingMaskHelper.SetLayerIncludingChildren(gameObject.transform, LayerMask.LayerToName(base.gameObject.layer));
}
lastSplashTime = Time.time;
}
transitionToWater();
}
if (LocomotionUtils.GetAnimatorStateInfo(animator).tagHash == AnimationHashes.Tags.ReactingToHit || !(collision.impulse.sqrMagnitude >= minMagnitudeForBumpSq) || !(Mathf.Abs(collision.impulse.y) < 0.707f))
{
return;
}
Vector3 vector = thisTransform.position - collision.contacts[0].point;
vector.y = 0f;
if (vector.x != 0f && vector.z != 0f)
{
Vector3 forward = thisTransform.forward;
forward.y = 0f;
if (forward.x != 0f && forward.z != 0f)
{
float num = LocomotionUtils.SignedAngle(forward.normalized, vector.normalized);
num = ((num < -157.5f) ? 180f : ((num < -112.5f) ? (-135f) : ((num < -67.5f) ? (-90f) : ((num < -22.5f) ? (-45f) : ((num < 22.5f) ? 0f : ((num < 67.5f) ? 45f : ((num < 112.5f) ? 90f : ((!(num < 157.5f)) ? 180f : 135f))))))));
animator.SetFloat(AnimationHashes.Params.Angle, num);
animator.SetTrigger(AnimationHashes.Params.Bump);
}
}
}
private GameObject getParticleFromPool()
{
GameObject gameObject = null;
for (int i = 0; i < objectPool.Count; i++)
{
if (!objectPool[i].activeSelf)
{
gameObject = objectPool[i];
}
}
if (gameObject == null)
{
gameObject = UnityEngine.Object.Instantiate(particlePrefab);
CameraCullingMaskHelper.SetLayerIncludingChildren(gameObject.transform, "UI");
objectPool.Add(gameObject);
}
gameObject.SetActive(value: true);
return(gameObject);
}
private Camera createCamera()
{
GameObject gameObject = new GameObject();
gameObject.name = "ModelRenderCamera";
gameObject.layer = iconRenderLayer;
Camera camera = gameObject.AddComponent <Camera>();
camera.aspect = config.TextureDimensions.x / config.TextureDimensions.y;
camera.clearFlags = CameraClearFlags.Color;
camera.backgroundColor = new Color(1f, 1f, 1f, 0f);
camera.orthographic = config.IsOrthographic;
camera.fieldOfView = config.FieldOfView;
camera.useOcclusionCulling = config.UseOcclusionCulling;
CameraCullingMaskHelper.SetSingleLayer(camera, "IconRender");
if (config.UseSolidBackground)
{
camera.backgroundColor = config.CameraBackgroundColor;
}
gameObject.transform.SetParent(modelRendererTransform);
gameObject.transform.localPosition = Vector3.zero;
return(camera);
}
public void RenderReward(DReward reward, RewardIconRenderComplete callback)
{
this.callback = callback;
CameraCullingMaskHelper.HideLayer(Camera.main, "IconRender");
CoroutineRunner.Start(renderSprite((string)reward.UnlockID), this, "RewardIconRenderer_Sprite.renderSprite");
}
public void Start()
{
CameraCullingMaskHelper.SetLayerIncludingChildren(base.gameObject.transform, "AllPlayerInteractibles", recursive: true);
}
private IEnumerator performPropRetrieve(Prop propToRetrieve, Vector3 immediateUseDestination)
{
while (anim != null && anim.GetCurrentAnimatorStateInfo(1).fullPathHash != AnimationHashes.States.TorsoIdle)
{
yield return(null);
}
if (anim == null || base.gameObject.IsDestroyed() || Prop != null)
{
yield break;
}
Prop = propToRetrieve;
parentPropToTargetBone(Prop);
Prop.PropUserRef = this;
CameraCullingMaskHelper.SetLayerRecursive(Prop.transform, LayerMask.LayerToName(base.gameObject.layer));
Prop.gameObject.SetActive(value: true);
ShowPropControls();
List <PropAccessory> accessories = new List <PropAccessory>(propToRetrieve.GetComponentsInChildren <PropAccessory>());
float MAX_WAIT_TIME = 1f;
float time = Time.time;
while (accessories.Count > 0)
{
yield return(null);
if ((Time.time - time).CompareTo(MAX_WAIT_TIME) > 0)
{
break;
}
for (int num = accessories.Count - 1; num >= 0; num--)
{
if (accessories[num].IsLoadingComplete)
{
accessories.RemoveAt(num);
}
}
}
if (Prop.AnimReplacementController != null)
{
anim.runtimeAnimatorController = Prop.AnimReplacementController;
}
else if (Prop.AnimOverrideController != null)
{
anim.runtimeAnimatorController = Prop.AnimOverrideController;
}
else
{
anim.runtimeAnimatorController = defaultAnimatorController;
}
setInteractionButtonActive();
if (this.EPropSpawned != null)
{
this.EPropSpawned(Prop);
}
if (Prop.UseOnceImmediately)
{
UsePropAtDestination(immediateUseDestination);
if (Prop.StoreAfterUse)
{
StoreProp();
}
}
StartUserPropMode(PropMode.Retrieve, waitForModeAnimCompletion: true);
Prop.SetAnimatorMode(PropMode.Retrieve, OnPropRetrieveCompleted);
if (Prop.PropDef.PropType == PropDefinition.PropTypes.InteractiveObject && Prop.IsOwnerLocalPlayer)
{
Service.Get <ICPSwrveService>().Action("game.interactive_object", Prop.PropDef.name, "start");
}
}
private void adjustSceneCullingMasks()
{
CameraCullingMaskHelper.HideLayer(Camera.main, "IconRender");
}
