Scripts/Scenes/PauseMenu.cs - master - arti4/Diplom

Scripts/Scenes/PauseMenu.cs
355 строк9 KB
arti4
Загрузка всех скриптов
17 май 2026, 09:08
17 май 2026, 09:08cc2e1cd
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.Audio;
using UnityEngine.UI;
using TMPro;

public class PauseMenu : MonoBehaviour
{
    [Header("Panels")]
    [SerializeField] private GameObject pauseCanvas;
    [SerializeField] private GameObject pausePanel;
    [SerializeField] private GameObject loadingCanvas;

    [Header("UI Elements")]
    [SerializeField] private TextMeshProUGUI pauseTitle;
    [SerializeField] private Button resumeButton;
    [SerializeField] private Button mainMenuButton;
    [SerializeField] private Button endRaceButton;

    [Header("Audio Settings")]
    [SerializeField] private Slider masterVolumeSlider;
    [SerializeField] private AudioMixer audioMixer;

    [Header("Settings")]
    [SerializeField] private string mainMenuSceneName = "MainMenu";

    [Header("Game Progress")]
    [SerializeField] private GameProgress gameProgress;

    private bool isPaused = false;
    private float timeScaleBeforePause = 1f;
    private float nextSaveTime = 180f;

    void Start()
    {
        pauseCanvas.SetActive(false);

        if (pauseTitle != null)
            pauseTitle.text = "�����";

        if (audioMixer == null)
        {
            Debug.LogError("AudioMixer �� �������� � ����������!");

            audioMixer = Resources.Load<AudioMixer>("Master");
            if (audioMixer == null)
            {
                audioMixer = Resources.Load<AudioMixer>("MasterMixer");
            }
        }

        LoadVolumeSettings();

        masterVolumeSlider.onValueChanged.AddListener(SetMasterVolume);

        resumeButton.onClick.AddListener(ResumeGame);
        mainMenuButton.onClick.AddListener(ReturnToMainMenu);
        endRaceButton.onClick.AddListener(EndRaceWithoutReward);
        UpdateButtonsVisibility();

        if (gameProgress == null)
        {
            gameProgress = FindObjectOfType<GameProgress>();
            if (gameProgress == null)
            {
                Debug.LogWarning("GameProgress �� ������!");
            }
        }
    }

    void Update()
    {
        if (Input.GetKeyDown(KeyCode.Escape))
        {
            if (GameController.IsMapOpenStatic)
            {
                return;
            }

            if (IsRaceCountdownActive())
            {
                return;
            }

            GarageManager garageManager = FindFirstObjectByType<GarageManager>();
            if (garageManager != null && garageManager.IsInGarage())
            {
                garageManager.ExitGarage();
                return;
            }

            if (isPaused)
            {
                ResumeGame();
            }
            else
            {
                PauseGame();
            }
        }

        if (Time.timeSinceLevelLoad > nextSaveTime)
        {
            SaveGame();
            nextSaveTime = Time.timeSinceLevelLoad + 30f;
        }

        if (Time.frameCount % 3 == 0)
        {
            UpdateButtonsVisibility();
        }
    }

    void UpdateButtonsVisibility()
    {
        bool isRacing = CheckIfRaceIsActive();

        if (endRaceButton != null)
            endRaceButton.gameObject.SetActive(isRacing);

        if (mainMenuButton != null)
            mainMenuButton.gameObject.SetActive(!isRacing);
    }

    bool CheckIfRaceIsActive()
    {
        RaceManager[] allRaceManagers = FindObjectsByType<RaceManager>(FindObjectsSortMode.None);
        foreach (var rm in allRaceManagers)
        {
            if (rm != null && rm.IsRaceActive())
                return true;
        }
        return false;
    }

    void EndRaceWithoutReward()
    {
        RaceManager[] allRaceManagers = FindObjectsByType<RaceManager>(FindObjectsSortMode.None);
        RaceManager activeRaceManager = null;

        foreach (var rm in allRaceManagers)
        {
            if (rm != null && rm.IsRaceActive())
            {
                activeRaceManager = rm;
                break;
            }
        }

        if (activeRaceManager != null)
        {
            activeRaceManager.EndRaceWithoutReward();

            RaceUI raceUI = FindFirstObjectByType<RaceUI>();
            if (raceUI != null)
            {
                raceUI.ResetDisplay();
            }

            ResumeGame();
        }
    }

    private bool IsRaceCountdownActive()
    {
        RaceCountdownUI countdownUI = FindFirstObjectByType<RaceCountdownUI>();
        if (countdownUI != null && countdownUI.IsCountingDown())
        {
            return true;
        }

        RaceManager raceManager = FindFirstObjectByType<RaceManager>();
        if (raceManager != null && raceManager.IsCountdownActive())
        {
            return true;
        }

        if (Mathf.Approximately(Time.timeScale, 0f))
        {
            RaceCountdownUI ui = FindFirstObjectByType<RaceCountdownUI>();
            if (ui != null && ui.IsCountingDown())
            {
                return true;
            }
        }

        return false;
    }

    void SaveGame()
    {
        GameManager gm = FindObjectOfType<GameManager>();
        if (gm != null)
        {
            gm.SaveGame();
        }
    }

    public void PauseGame()
    {
        isPaused = true;
        timeScaleBeforePause = Time.timeScale;
        Time.timeScale = 0f;

        pauseCanvas.SetActive(true);

        Cursor.lockState = CursorLockMode.None;
        Cursor.visible = true;

        AudioListener.pause = true;
    }

    public void ResumeGame()
    {
        isPaused = false;
        Time.timeScale = timeScaleBeforePause;

        pauseCanvas.SetActive(false);

        GarageManager garageManager = FindFirstObjectByType<GarageManager>();
        bool isInGarage = garageManager != null && garageManager.IsInGarage();

        if (isInGarage)
        {
            Cursor.lockState = CursorLockMode.None;
            Cursor.visible = true;
        }
        else
        {
            Cursor.lockState = CursorLockMode.Locked;
            Cursor.visible = false;
        }

        AudioListener.pause = false;
    }

    public void ReturnToMainMenu()
    {
        pauseCanvas.SetActive(false);
        if (loadingCanvas != null) loadingCanvas.SetActive(true);
        SaveCurrentGame();

        Time.timeScale = timeScaleBeforePause;
        AudioListener.pause = false;
        SceneManager.LoadScene(mainMenuSceneName);
    }

    private void SaveCurrentGame()
    {
        if (gameProgress == null)
        {
            Debug.LogWarning("GameProgress �� ������, ���� �� ���������!");
            return;
        }

        GameData data = new GameData();

        GameObject player = GameObject.FindGameObjectWithTag("Player");
        if (player != null)
        {
            data.playerPosition = player.transform.position;
        }

        data.level = SceneManager.GetActiveScene().buildIndex;

        gameProgress.SaveGame(data);
    }

    void SetMasterVolume(float volume)
    {
        float dB;
        if (volume <= 0.0001f)
        {
            dB = -80f;
        }
        else
        {
            dB = Mathf.Log10(volume) * 20f;
        }

        bool success = audioMixer.SetFloat("CarsVolume", dB);

        float currentValue;
        bool getSuccess = audioMixer.GetFloat("CarsVolume", out currentValue);

        if (!success || !getSuccess)
        {
            Debug.LogWarning("Parameter 'CarsVolume' not found! Trying alternative names...");

            bool alt1 = audioMixer.SetFloat("Volume", dB);
            bool alt2 = audioMixer.SetFloat("MasterVolume", dB);
            bool alt3 = audioMixer.SetFloat("Cars", dB);

            DebugExposedParameters();
        }

        AudioListener.volume = volume;

        PlayerPrefs.SetFloat("MasterVolume", volume);
        PlayerPrefs.Save();
    }

    void DebugExposedParameters()
    {
        if (audioMixer == null) return;

        var exposedParams = audioMixer.GetType().GetMethod("GetExposedParameters",
            System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);

        if (exposedParams != null)
        {
            var result = exposedParams.Invoke(audioMixer, null) as string[];
            if (result != null)
            {
                foreach (string param in result)
                {
                    float value;
                    audioMixer.GetFloat(param, out value);
                }
            }
         }
    }

    void LoadVolumeSettings()
    {
        float savedMasterVolume = PlayerPrefs.GetFloat("MasterVolume", 0.75f);
        masterVolumeSlider.value = savedMasterVolume;
        SetMasterVolume(savedMasterVolume);
    }

    public bool IsPaused
    {
        get { return isPaused; }
    }

    public void ForceUnpause()
    {
        if (isPaused)
        {
            ResumeGame();
        }
    }

    void OnDestroy()
    {
        if (masterVolumeSlider != null)
            masterVolumeSlider.onValueChanged.RemoveListener(SetMasterVolume);

        if (resumeButton != null)
            resumeButton.onClick.RemoveListener(ResumeGame);

        if (mainMenuButton != null)
            mainMenuButton.onClick.RemoveListener(ReturnToMainMenu);
    }
}