public override void Update(GameTime gameTime, bool otherScreenHasFocus, bool coveredByOtherScreen)
        {
            base.Update(gameTime, otherScreenHasFocus, coveredByOtherScreen);

            if (!InputManager.IsPlayerIndexDetected)
            {
//                System.Diagnostics.Debug.WriteLine($"-BEFOR- IsPlayerIndexDetected: {InputManager.IsPlayerIndexDetected}");
                InputManager.DetectPlayerIndex();
//                System.Diagnostics.Debug.WriteLine($"-AFTER- IsPlayerIndexDetected: {InputManager.IsPlayerIndexDetected}");
            }

            StorageManager.Instance.Update(gameTime);

            if (PuzzleEngine.IsCheckRender)
            {
                PuzzleEngine.RenderTextures();
            }

            switch (mode)
            {
            case MainGameScreenMode.ShowSignIn:
                if (signInTask == null)
                {
                    signInTask = SignInManager.Instance.SignIn();
                }

                /*
                 * else if (signInTask.IsCompleted)
                 * {
                 *  if (signInTask.Result)
                 *  {
                 *      // sign-in successful
                 *      mode = MainGameScreenMode.Closed;
                 *  }
                 *  else
                 *  {
                 *      // sign-in failure
                 *      mode = MainGameScreenMode.HandleSignInFailure;
                 *  }
                 *  signInTask = null;
                 * }
                 */
                else
                {
                    ShowSigningInMessage();
                    mode = MainGameScreenMode.SigningIn;
                }
                break;

            case MainGameScreenMode.SigningIn:
                if (signInTask.IsCompleted)
                {
                    signingInScreen.ExitScreen();

                    if (signInTask.Result)
                    {
                        // sign-in successful
                        mode = MainGameScreenMode.Closed;
                    }
                    else
                    {
                        // sign-in failure
                        mode = MainGameScreenMode.HandleSignInFailure;
                    }
                    signInTask = null;
                }
                break;

            case MainGameScreenMode.HandleSignInFailure:
//                    if (!Guide.IsVisible)
//                    {
                ShowSignInWarning();
                mode = MainGameScreenMode.Closed;
//                    }

                break;

            case MainGameScreenMode.ShowSignedOutMessage:
                //#if XBOX
                //                    if (!Guide.IsVisible)
                //#endif
                ShowSignOutWarning();
                mode = MainGameScreenMode.Closed;
//                    signInTask = null;
//                    }
                break;

/*
 *              case MainGameScreenMode.HandleSignedOutResult:
 *                  if (signedOutResult.IsCompleted)
 *                  {
 *                      mode = MainGameScreenMode.ResetGame;
 *                  }
 *                  break;
 */



            case MainGameScreenMode.ResetGame:
                InputManager.Initialize();
                InputManager.ClearPlayerIndex();
                StorageManager.Instance.Reset();
                endSession();

                ScreenManager.AddScreen(new SplashScreen(false));

                slotPanel.Reset();
                AudioManager.StopMusic();

                doorRightPosition       = new Vector2(ANCHOR_DOORCLOSED_RIGHT_X, 0);
                doorRightShadowPosition = new Vector2(ANCHOR_DOORSHADOWCLOSED_RIGHT_X, 0);
                doorLeftPosition        = Vector2.Zero;
                doorLeftShadowPosition  = Vector2.Zero;

                helpPanel.Off(false);

                mode = MainGameScreenMode.Closed;

                break;

            case MainGameScreenMode.Open:
                break;

            case MainGameScreenMode.Closed:
                if (!isStorageMessageDisplayed && IsActive && StorageManager.Instance.IsFirstPassDone)
                {
                    ShowStorageWarning(StorageDeviceWarningType.AutoSaveWarn);
                }
                break;

            case MainGameScreenMode.DelayOpening:
                openingDelayTimer += (float)gameTime.ElapsedGameTime.TotalSeconds;
                if (openingDelayTimer >= OPENING_DELAY_MAX)
                {
                    openingDelayTimer = 0;
                    mode = MainGameScreenMode.Opening;
                    slotPanel.Open();
                }
                break;

            case MainGameScreenMode.Opening:
                if (StorageManager.Instance.IsRefreshRequired)
                {
                    StorageManager.Instance.RefreshSaveGameDescriptions();
                    StorageManager.Instance.IsRefreshRequired = false;
                }

                doorRightPosition.X       += DEFAULT_DOORSPEED_RIGHT;
                doorRightShadowPosition.X += DEFAULT_DOORSPEED_RIGHT;
                doorLeftPosition.X        -= DEFAULT_DOORSPEED_LEFT;
                doorLeftShadowPosition.X  -= DEFAULT_DOORSPEED_LEFT;

                if (doorRightPosition.X >= ANCHOR_DOOROPEN_RIGHT_X)
                {
                    doorRightPosition.X = ANCHOR_DOOROPEN_RIGHT_X;
                }
                if (doorLeftPosition.X <= ANCHOR_DOOROPEN_LEFT_X)
                {
                    doorLeftPosition.X = ANCHOR_DOOROPEN_LEFT_X;
                }
                if (doorLeftPosition.X == ANCHOR_DOOROPEN_LEFT_X &&
                    doorRightPosition.X == ANCHOR_DOOROPEN_RIGHT_X)
                {
                    mode = MainGameScreenMode.SlotPanel;
                }
                break;

            case MainGameScreenMode.SlotPanel:
                if (isReadyToLoad)
                {
                    isLoadConfirmed = false;

                    AudioManager.PopMusic();

                    stopCogs(true);
                    resetTexture();

                    mode        = MainGameScreenMode.Loading;
                    loadingMode = LoadingMode.Starting;
                }
                break;

            case MainGameScreenMode.PickerPanel:
                if (isReadyForPuzzle)
                {
                    PuzzleEngine.SetPuzzle();

                    mode = MainGameScreenMode.PuzzlePanel;
                    puzzlePanel.Open();
                    isReadyForPuzzle = false;
                }
                break;

            case MainGameScreenMode.PuzzlePanel:
                if (isBackToPicker)
                {
                    mode = MainGameScreenMode.PickerPanel;
                    pickerPanel.Open();
                    isBackToPicker = false;
                }
                break;

            case MainGameScreenMode.CreditsPanel:

                break;

            case MainGameScreenMode.Closing:
                doorRightPosition.X       -= DEFAULT_DOORSPEED_RIGHT;
                doorRightShadowPosition.X -= DEFAULT_DOORSPEED_RIGHT;
                doorLeftPosition.X        += DEFAULT_DOORSPEED_LEFT;
                doorLeftShadowPosition.X  += DEFAULT_DOORSPEED_LEFT;

                if (doorRightPosition.X <= ANCHOR_DOORCLOSED_RIGHT_X)
                {
                    doorRightPosition.X = ANCHOR_DOORCLOSED_RIGHT_X;
                }
                if (doorLeftPosition.X >= ANCHOR_DOORCLOSED_LEFT_X)
                {
                    doorLeftPosition.X = ANCHOR_DOORCLOSED_LEFT_X;
                }
                if (doorLeftPosition.X == ANCHOR_DOORCLOSED_LEFT_X &&
                    doorRightPosition.X == ANCHOR_DOORCLOSED_RIGHT_X)
                {
                    mode = MainGameScreenMode.Closed;

                    AudioManager.PopMusic();

                    endSession();
                }
                break;

            case MainGameScreenMode.Exiting:
                if (ScreenState == ScreenState.FinishedExiting)
                {
                    ScreenManager.Game.Exit();
                }
                break;

            case MainGameScreenMode.Loading:
                switch (loadingMode)
                {
                case LoadingMode.Starting:
                    loadingAlpha += LOAD_ALPHA_STEP;
                    if (loadingAlpha >= 1)
                    {
                        loadingMode  = LoadingMode.Processing;
                        loadingAlpha = 1;
                    }
                    break;

                case LoadingMode.Finishing:
                    loadingPauseTimer += (float)gameTime.ElapsedGameTime.TotalSeconds;

                    if (loadingPauseTimer >= LOADING_PAUSE_LIMIT)
                    {
                        loadingAlpha -= LOAD_ALPHA_STEP;
                        if (loadingAlpha <= 0)
                        {
                            loadingPauseTimer = 0;

                            loadingAlpha = 0;
                            startCogs(true);

                            AudioManager.PlayMusic("bgCogsTurning");

                            loadingMode = LoadingMode.Finished;
                        }
                    }
                    break;

                case LoadingMode.Finished:
                    mode = MainGameScreenMode.PickerPanel;
                    pickerPanel.Open();
                    break;

                case LoadingMode.Processing:
                    // load new or saved game
                    if (isNewGame)
                    {
                        GameStartDescription gsd = ScreenManager.GlobalContent.Load <GameStartDescription>("NewGameDescription");
                        gsd.SaveSlotNumber = slotPanel.CurrentSlot.SlotNumber;
                        pickerPanel        = new PickerPanel(this, gsd);
                        puzzlePanel        = new PuzzlePanel(this);
                        pickerPanel.LoadContent(ScreenManager.SessionContent);
                        puzzlePanel.LoadContent(ScreenManager.SessionContent);

                        Session.QuickSave();

                        LoadProcessingComplete();
                    }
                    else if (!isLoadProcessingFirstPassDone)
                    {
                        pickerPanel = new PickerPanel(this, slotPanel.CurrentSlot.SaveGameDescription);
                        puzzlePanel = new PuzzlePanel(this);
                        pickerPanel.LoadContent(ScreenManager.SessionContent);
                        puzzlePanel.LoadContent(ScreenManager.SessionContent);
                        isLoadProcessingFirstPassDone = true;
                    }

                    break;
                }
                break;

            case MainGameScreenMode.Paused:

                switch (pauseMode)
                {
                case PauseMode.Waiting:
                    break;

                case PauseMode.Starting:
                    pauseAlpha += PAUSE_ALPHA_STEP;
                    if (pauseAlpha >= 1)
                    {
                        pauseMode  = PauseMode.Paused;
                        pauseAlpha = 1;
                    }
                    break;

                case PauseMode.Paused:
                    break;

                case PauseMode.Stopping:
                    pauseAlpha -= PAUSE_ALPHA_STEP;
                    if (pauseAlpha <= 0)
                    {
                        pauseMode = PauseMode.Waiting;
                        mode      = MainGameScreenMode.PuzzlePanel;
                        startCogs(true);

                        AudioManager.PlayMusic("bgCogsTurning");

                        puzzlePanel.startCogs();
                        PuzzleEngine.IsTimerDisabled = false;
                        pauseAlpha = 0;

                        IsPaused = false;
                    }
                    break;
                }
                break;
            }

            if (mode != MainGameScreenMode.Closed && mode != MainGameScreenMode.Exiting)
            {
                if (helpPanel != null)
                {
                    helpPanel.Update(gameTime);
                }
                if (slotPanel != null)
                {
                    slotPanel.Update(gameTime);
                }
                if (pickerPanel != null)
                {
                    pickerPanel.Update(gameTime);
                }
                if (puzzlePanel != null)
                {
                    puzzlePanel.Update(gameTime);
                }
                if (creditsPanel != null)
                {
                    creditsPanel.Update(gameTime);
                }
            }

            if (cogSpritesList != null)
            {
                foreach (BackgroundCogSprite cog in cogSpritesList)
                {
                    cog.Update(gameTime);
                }
            }
        }