public void Teardown()
{
timer.gameObject.SetActive(value: false);
MenuCameraEffects.FadeInMainMenu();
ReleaseWebCam();
paintMenu.paint.StopStream();
}
public void Teardown()
{
MenuCameraEffects.LeaveCustomization();
instance = null;
Listener.instance.EndTransfromOverride();
NetGame.instance.StartLocalGame();
}
public void AfterLoad(int checkpointNumber, int subobjectives)
{
MenuCameraEffects menuCameraEffects = MenuCameraEffects.instance;
if ((bool)menuCameraEffects && currentLevelNumber >= 0 && currentLevelNumber < levels.Length)
{
string text = levels[currentLevelNumber];
if (text != null && text == "Halloween")
{
menuCameraEffects.ForceDisableOcclusion(forceDisableOcclusion: true);
}
else
{
menuCameraEffects.ForceDisableOcclusion(forceDisableOcclusion: false);
}
}
state = GameState.PlayingLevel;
defaultLight.gameObject.SetActive(value: false);
currentCheckpointNumber = Mathf.Min(checkpointNumber, currentLevel.checkpoints.Length - 1);
currentCheckpointSubObjectives = subobjectives;
currentLevel.BeginLevel();
if (currentLevel.prerespawn != null)
{
currentLevel.prerespawn(currentCheckpointNumber, startingLevel: true);
}
RespawnAllPlayers();
currentLevel.Reset(currentCheckpointNumber, currentCheckpointSubObjectives);
CheckpointLoaded(checkpointNumber);
SignalManager.EndReset();
currentLevel.PostEndReset(currentCheckpointNumber);
}
private IEnumerator StallFreeBack()
{
float dur = 0.1f;
if (MenuSystem.instance.activeMenu == this)
{
MenuSystem.instance.FocusOnMouseOver(enable: false);
Transition(0.9999f, 0f);
}
MenuCameraEffects.FadeToBlack(dur);
yield return(null);
yield return(new WaitForSeconds(dur));
yield return(null);
App.instance.LeaveCustomization();
while (!Game.instance.HasSceneLoaded)
{
yield return(null);
}
for (int index = 0; index < 3; index++)
{
yield return(null);
}
goingBack = false;
MenuSystem.instance.TransitionBack <MainMenu>(this, 0f);
}
public override void ApplyMenuEffects()
{
if (CustomizationController.instance != null)
{
MenuCameraEffects.FadeInMainMenu();
}
}
public void Process(bool show, bool pick)
{
if (base.isActiveAndEnabled != show)
{
base.gameObject.SetActive(show);
}
if (allowPicking != pick)
{
allowPicking = pick;
if (allowPicking)
{
MenuCameraEffects.SuspendEffects(suspend: true);
mainCamera.SetReplacementShader(Shaders.instance.customizeUnlitShader, "RenderType");
mainCamera.renderingPath = RenderingPath.Forward;
}
else
{
MenuCameraEffects.SuspendEffects(suspend: false);
mainCamera.ResetReplacementShader();
mainCamera.renderingPath = RenderingPath.UsePlayerSettings;
}
}
if (show)
{
Vector2 anchoredPosition = UICanvas.ScreenPointToLocal(parentRect, Input.mousePosition);
rect.anchoredPosition = anchoredPosition;
if (allowPicking)
{
StartCoroutine(PickColor());
}
colorPreviewBox.color = color;
}
}
public void LevelLoadedServer(ulong level, WorkshopItemSource levelType, uint hash)
{
lock (stateLock)
{
if (state == AppSate.ServerLoadLevel)
{
Dialogs.HideProgress();
MenuCameraEffects.FadeOut(1f);
if (hash == 0 || hash == 57005)
{
NetGame.instance.StopServer();
ExitGame();
EnterMenu();
UnityEngine.Debug.LogError("LevelNotNetReady");
Dialogs.CreateServerFailed("LevelNotNetReady", delegate
{
MenuSystem.instance.ShowMenu <MainMenu>();
});
}
else
{
state = AppSate.ServerPlayLevel;
NetGame.instance.ServerLoadLevel(level, levelType, start: true, (hash != 0) ? hash : 57005u);
}
}
}
}
private void Resume()
{
Game.instance.Resume();
MenuCameraEffects.FadeInCredits();
MenuSystem.instance.ExitMenus();
FadeOutBack();
}
public void LaunchCustomLevel(string path, WorkshopItemSource levelType, int checkpoint, int subObjectives)
{
StartCoroutine(LaunchGame(path, 0uL, levelType, checkpoint, subObjectives, delegate
{
MenuCameraEffects.FadeOut(1f);
state = AppSate.PlayLevel;
}));
}
public void Initialize()
{
instance = this;
defaultSkyboxMaterial = RenderSettings.skybox;
skyboxMaterial = new Material(defaultSkyboxMaterial);
RenderSettings.skybox = skyboxMaterial;
defaultSkyboxColor = new Color(0.585f, 0.585f, 0.585f);
Dependencies.OnInitialized(this);
}
public void LaunchSinglePlayer(ulong level, WorkshopItemSource levelType, int checkpoint, int subObjectives)
{
startedCheckpoint = checkpoint;
LaunchGame(level, levelType, checkpoint, subObjectives, delegate
{
MenuCameraEffects.FadeOut(1f);
state = AppSate.PlayLevel;
});
}
private void GotoRatingsMenu(RatingMenu.RatingDestination destination, bool showLoading)
{
MenuCameraEffects.FadeInPauseMenu();
RatingMenu.instance.SetDestination(destination);
if (showLoading)
{
SubtitleManager.instance.SetProgress(ScriptLocalization.TUTORIAL.LOADING, 1f, 1f);
}
MenuSystem.instance.ShowMainMenu <RatingMenu>();
}
public void HideMenus()
{
MenuCameraEffects.FadeOut();
MenuTransition menuTransition = activeMenu;
instance.ExitMenus();
if (menuTransition != null)
{
menuTransition.FadeOutBack();
}
}
public void UnloadLevel()
{
StatsAndAchievements.Save();
Resume();
AfterUnload();
MenuCameraEffects menuCameraEffects = MenuCameraEffects.instance;
if ((bool)menuCameraEffects)
{
menuCameraEffects.ForceDisableOcclusion(forceDisableOcclusion: false);
}
}
public void LobbyLoadLevel(ulong level)
{
MenuCameraEffects.FadeToBlack(0.02f);
Dialogs.ShowLoadLevelProgress(57005uL);
Listener.instance.EndTransfromOverride();
SceneManager.LoadScene("Empty");
EnterLobby(NetGame.isServer);
if (NetGame.isServer)
{
NetGame.instance.ServerLoadLobby(level, WorkshopItemSource.BuiltInLobbies, start: false, 0u);
}
}
private IEnumerator CompleteTransitionIn()
{
for (int index = 0; index < 3; index++)
{
yield return(null);
}
MenuCameraEffects.FadeFromBlack(0.25f);
yield return(new WaitForSeconds(0.15f));
Transition(0f, 0.3f);
goingBack = false;
}
public void Initialize()
{
MenuCameraEffects.EnterCustomization();
NetGame.instance.StopLocalGame();
Listener.instance.OverrideTransform(cameraController.cameraHolder);
customizations[0] = InitializeRagdoll(mainCharacter);
customizations[1] = InitializeRagdoll(coopCharacter);
ReloadSkin(0);
ReloadSkin(1);
activePlayer = PlayerPrefs.GetInt("MainSkinIndex", 0);
activeCustomization = customizations[activePlayer];
turntable.rotation = Quaternion.Euler(0f, (activePlayer > 0) ? 180 : 0, 0f);
}
public void Cancel()
{
if (state != 0)
{
MenuCameraEffects.SuperMasterFade(0f, 1f);
if (state == State.WaitThenPause && ShowingProgress && SubtitleManager.instance.CheckProgressText(string.Empty))
{
SubtitleManager.instance.ClearProgress();
}
state = State.Off;
FadeInProgress = false;
callback = null;
base.enabled = false;
}
}
public void SkipStartupExperience(object multiplayerServer)
{
cameraEffects = Object.FindObjectOfType <MenuCameraEffects>();
cameraController = Object.FindObjectOfType <CameraController3>();
human = Object.FindObjectOfType <Human>();
ragdoll = human.ragdoll;
if (StartupExperienceUI.instance.gameObject != null)
{
StartupExperienceUI.instance.gameObject.SetActive(value: false);
}
Object.Destroy(StartupExperienceUI.instance.gameObject);
LeaveGameStartupXP();
DestroyStartupStuff();
MenuSystem.instance.ShowMainMenu(hideLogo: true);
if (multiplayerServer != null)
{
App.instance.AcceptInvite(multiplayerServer);
}
}
private IEnumerator TransitionToCustomisation()
{
RemoveStartExperienceLogo();
if (MenuSystem.instance.activeMenu == this)
{
MenuSystem.instance.FocusOnMouseOver(enable: false);
Transition(-0.99f, 0.3f);
}
float dur = 0.5f;
MenuCameraEffects.FadeToBlack(dur);
yield return(null);
yield return(new WaitForSeconds(dur));
yield return(null);
transitioning = false;
MenuSystem.instance.TransitionForward <CustomizationRootMenu>(this, 0f, 10000f);
}
public override void OnGotFocus()
{
paintMenu = MenuSystem.instance.GetMenu <CustomizationPaintMenu>();
base.OnGotFocus();
MenuButton component = lastFocusedElement.GetComponent <MenuButton>();
if (component != null)
{
component.OnSelect(null);
}
MenuCameraEffects.FadeInWebcamMenu();
prepareUI.SetActive(value: true);
desiredCameraIndex = PlayerPrefs.GetInt("WebCamIdx", 0);
desiredCameraName = PlayerPrefs.GetString("WebCamName", null);
mirror = PlayerPrefs.GetInt("WebCamMirror", 1);
if (mirror == 0)
{
mirror = 1;
}
StartWebCam();
}
private bool LevelLoadedClient()
{
lock (stateLock)
{
if (serverLoadedLevel == loadedLevel)
{
Dialogs.HideProgress();
MenuCameraEffects.FadeOut(1f);
if (loadedHash == serverLoadedHash)
{
state = AppSate.ClientPlayLevel;
}
else
{
NetGame.instance.LeaveGame();
ExitGame();
EnterMenu();
if (serverLoadedHash == 57005)
{
Dialogs.ConnectionFailed("LevelNotNetReady", delegate
{
MenuSystem.instance.ShowMainMenu();
});
}
else
{
UnityEngine.Debug.LogError("Incompatible level. Server hash: " + serverLoadedHash + ". Client Hash: " + loadedHash);
Dialogs.ConnectionFailed("IncompatibleLevel", delegate
{
MenuSystem.instance.ShowMainMenu();
});
}
queueAfterLevelLoad = null;
}
return(true);
}
return(false);
}
}
public static void ApplyCameraEffects()
{
MenuCameraEffects.EnableEffects(advancedVideoAA, advancedVideoAO, advancedVideoHDR > 0, advancedVideoExposure > 0, advancedVideoBloom > 0, advancedVideoDOF > 0, advancedVideoChromatic > 0);
}
public void OnRequestLoadLevel(ulong level, WorkshopItemSource levelType, bool start, uint hash)
{
if (start && loadingLevel != level)
{
RatingMenu.instance.LoadInit();
}
if (NetGame.netlog)
{
UnityEngine.Debug.LogFormat("On RequestLoad {0} {1} {2} {3}", level, levelType, start, hash);
}
lock (stateLock)
{
if (state == AppSate.ClientLoadLevel || state == AppSate.ClientLoadLobby)
{
if (NetGame.netlog)
{
UnityEngine.Debug.Log("Queueing on request load");
}
queueAfterLevelLoad = delegate
{
OnRequestLoadLevel(level, levelType, start, hash);
};
}
else
{
queueAfterLevelLoad = null;
if (hash == 0)
{
serverLoadedLevel = 57005uL;
}
if (!start)
{
loadingLevel = (loadedLevel = 57005uL);
loadedHash = 0u;
queueAfterLevelLoad = null;
if (state == AppSate.ClientLobby)
{
MultiplayerLobbyMenu multiplayerLobbyMenu = MenuSystem.instance.activeMenu as MultiplayerLobbyMenu;
if (multiplayerLobbyMenu != null)
{
multiplayerLobbyMenu.RebindLevel();
}
state = AppSate.ClientLobby;
}
else if (isClient)
{
RatingMenu.instance.LevelOver();
if (Game.instance.state == GameState.Paused || Game.instance.state == GameState.PlayingLevel)
{
ExitGame();
}
if (RatingMenu.instance.ShowRatingMenu())
{
GotoRatingsMenu(RatingMenu.RatingDestination.kMultiplayerLobby, showLoading: true);
}
else
{
MenuCameraEffects.FadeToBlack(0.02f);
Dialogs.ShowLoadLevelProgress(57005uL);
}
EnterLobby(isServer: false, delegate
{
state = AppSate.ClientLobby;
});
}
}
else
{
if (loadingLevel != level)
{
if (state == AppSate.ClientLobby)
{
ExitLobby();
}
loadingLevel = level;
LaunchGame(level, levelType, 0, 0, delegate
{
loadedLevel = level;
loadedHash = Game.currentLevel.netHash;
if (!LevelLoadedClient())
{
state = AppSate.ClientWaitServerLoad;
}
});
}
if (hash != 0)
{
serverLoadedLevel = level;
serverLoadedHash = hash;
LevelLoadedClient();
}
}
}
}
}
public override void ApplyMenuEffects()
{
MenuCameraEffects.FadeToBlack(0.001f);
}
private static void ApplyVideoBrightness()
{
MenuCameraEffects.SetGamma((float)videoBrightness / 20f);
}
public void PauseLeave(bool instantLeave = false)
{
lock (stateLock)
{
RatingMenu.instance.LevelOver();
bool flag = RatingMenu.instance.ShowRatingMenu();
bool flag2 = Game.instance.workshopLevel != null;
ExitGame();
if (state == AppSate.PlayLevel)
{
EnterMenu();
PlayerManager.SetSingle();
if (flag2)
{
MenuCameraEffects.instance.RemoveOverride();
LevelSelectMenu2.instance.SetMultiplayerMode(inMultiplayer: false);
LevelSelectMenu2.instance.ShowSubscribed();
if (flag)
{
GotoRatingsMenu(RatingMenu.RatingDestination.kLevelSelectMenu, showLoading: false);
}
else
{
MenuSystem.instance.ShowMainMenu <LevelSelectMenu2>();
}
}
else
{
MenuSystem.instance.ShowMainMenu();
}
}
else if (state == AppSate.ServerPlayLevel)
{
if (!instantLeave)
{
if (flag)
{
GotoRatingsMenu(RatingMenu.RatingDestination.kMultiplayerLobby, showLoading: true);
}
else
{
MenuCameraEffects.FadeToBlack(0.02f);
Dialogs.ShowLoadLevelProgress(57005uL);
}
EnterLobby(isServer: true);
NetGame.instance.ServerLoadLevel(NetGame.instance.currentLevel, NetGame.instance.currentLevelType, start: false, 0u);
}
else
{
EnterMenu();
MenuSystem.instance.ShowMainMenu();
NetGame.instance.LeaveGame();
}
}
else if (state == AppSate.ClientPlayLevel)
{
NetGame.instance.LeaveGame();
EnterMenu();
if (flag)
{
GotoRatingsMenu(RatingMenu.RatingDestination.kMainMenu, showLoading: false);
}
else
{
MenuSystem.instance.ShowMainMenu();
}
}
}
}
private void UpdateFromState()
{
if (state < State.Ground)
{
if (MenuCameraEffects.instance.creditsAdjust == 0f && MenuSystem.instance.state == MenuSystemState.Inactive)
{
MenuCameraEffects.FadeInCredits();
}
}
else if (MenuCameraEffects.instance.creditsAdjust != 0f && !MenuCameraEffects.instance.CreditsAdjustInTransition && MenuSystem.instance.state == MenuSystemState.Inactive)
{
MenuCameraEffects.FadeOut(1.5f);
}
SetCloudState(state < State.Ground);
if (!skipDrag)
{
bool flag = state < State.NearGround;
if (flag != lastDrag)
{
lastDrag = flag;
currentDrag = ((!flag) ? 0.05f : 0.4f);
for (int i = 0; i < Human.all.Count; i++)
{
Human human = Human.all[i];
if (humansInLevel.Contains(human) && !skipDrag)
{
human.SetDrag(currentDrag);
}
human.state = HumanState.Spawning;
}
}
}
bool flag2 = state >= State.FadeOut;
if (fadeRunning == flag2)
{
return;
}
fadeRunning = flag2;
if (flag2)
{
CreditsFadeOutAndEnd.Trigger(base.gameObject, delegate
{
GetComponentInParent <Level>().respawnLocked = true;
ClearDrag();
hasFinishedCredits = true;
startupDoor.SetActive(value: false);
for (int j = 0; j < blocks.Count; j++)
{
blocks[j].gameObject.SetActive(value: false);
}
});
return;
}
CreditsFadeOutAndEnd component = base.gameObject.GetComponent <CreditsFadeOutAndEnd>();
if (component != null)
{
component.Cancel();
}
}
public override void ApplyMenuEffects()
{
MenuCameraEffects.FadeInPauseMenu();
}
private IEnumerator LaunchGame(string levelPath, ulong level, WorkshopItemSource type, int checkpoint, int subObjectives, Action onComplete)
{
object obj = stateLock;
Monitor.Enter(obj);
try
{
if (state == AppSate.Menu || state == AppSate.PlayLevel || state == AppSate.ClientJoin || state == AppSate.ClientLobby || state == AppSate.ClientPlayLevel || state == AppSate.ClientWaitServerLoad || state == AppSate.ServerLobby || state != AppSate.ServerPlayLevel)
{
}
bool ui = state == AppSate.Menu || state == AppSate.ServerLobby || state == AppSate.ClientLobby || state == AppSate.ClientJoin;
if (ui)
{
MenuSystem.instance.FadeOutActive();
}
if (isServer || isClient)
{
MenuCameraEffects.FadeToBlack((!ui) ? 0.02f : 0.2f);
Dialogs.ShowLoadLevelProgress(level);
}
if (isServer)
{
state = AppSate.ServerLoadLevel;
}
else if (isClient)
{
state = AppSate.ClientLoadLevel;
}
else
{
state = AppSate.LoadLevel;
}
queueAfterLevelLoad = null;
if (ui)
{
yield return(new WaitForSeconds(0.2f));
}
NetStream.DiscardPools();
Game.instance.BeginLoadLevel(levelPath, level, checkpoint, subObjectives, delegate
{
lock (stateLock)
{
if (state == AppSate.LoadLevel || state == AppSate.ServerLoadLevel || state != AppSate.ClientLoadLevel)
{
}
MenuSystem.instance.ExitMenus();
NetStream.DiscardPools();
ResumeDeltasAfterLoad();
if (onComplete != null)
{
onComplete();
}
if (queueAfterLevelLoad != null)
{
Action action = queueAfterLevelLoad;
queueAfterLevelLoad = null;
if (NetGame.netlog)
{
UnityEngine.Debug.Log("Executing queue");
}
action();
}
}
}, type);
}
finally
{
}
}
