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

Scripts/Scenes/MainMenu.cs
310 строк10 KB
arti4
Загрузка всех скриптов
17 май 2026, 09:08
17 май 2026, 09:08cc2e1cd
using System.Collections.Generic;
using System.Linq;
using TMPro;
using UnityEngine;
using UnityEngine.Audio;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

public class MainMenu : MonoBehaviour
{
    [Header("Panels")]
    [SerializeField] private GameObject mainMenuPanel;
    [SerializeField] private GameObject settingsPanel;
    [SerializeField] private GameObject loadingCanvas;

    [Header("Settings UI")]
    [SerializeField] private TMP_Dropdown resolutionDropdown;
    [SerializeField] private Toggle fullscreenToggle;
    [SerializeField] private Slider masterVolumeSlider;
    [SerializeField] private Toggle hideObjectsToggle;
    [SerializeField] private Toggle shadowsToggle;

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

    [Header("Save Key")]
    [SerializeField] private string saveKey = "GameProgress";

    private Resolution[] resolutions;
    private List<string> resolutionOptions = new List<string>();

    private bool tempFullscreen;
    private float tempMasterVolume;
    private int tempResolutionIndex;
    private bool tempHideObjects;
    private bool tempShadowsEnabled;

    private bool savedFullscreen;
    private float savedMasterVolume;
    private int savedResolutionIndex;
    private bool savedHideObjects;
    private bool savedShadowsEnabled;

    void Start()
    {
        mainMenuPanel.SetActive(true);
        settingsPanel.SetActive(false);

        SetupResolutionDropdown();
        LoadSettings();

        fullscreenToggle.onValueChanged.AddListener(OnFullscreenChanged);
        masterVolumeSlider.onValueChanged.AddListener(OnMasterVolumeChanged);
        resolutionDropdown.onValueChanged.AddListener(OnResolutionChanged);
        hideObjectsToggle.onValueChanged.AddListener(OnHideObjectsChanged);
    }

    void SetupResolutionDropdown()
    {
        resolutions = Screen.resolutions;
        resolutionDropdown.ClearOptions();
        resolutionOptions.Clear();

        int currentResolutionIndex = 0;

        for (int i = 0; i < resolutions.Length; i++)
        {
            string option = resolutions[i].width + " x " + resolutions[i].height;
            resolutionOptions.Add(option);

            if (resolutions[i].width == Screen.currentResolution.width &&
                resolutions[i].height == Screen.currentResolution.height)
            {
                currentResolutionIndex = i;
            }
        }

        resolutionDropdown.AddOptions(resolutionOptions);
        resolutionDropdown.value = currentResolutionIndex;
        resolutionDropdown.RefreshShownValue();
        shadowsToggle.onValueChanged.AddListener(OnShadowsChanged);
    }

    private void OnFullscreenChanged(bool isFullscreen)
    {
        tempFullscreen = isFullscreen;
    }

    private void OnMasterVolumeChanged(float volume)
    {
        tempMasterVolume = volume;
        ApplyVolumePreview(tempMasterVolume);
    }

    private void OnResolutionChanged(int resolutionIndex)
    {
        tempResolutionIndex = resolutionIndex;
    }

    private void OnHideObjectsChanged(bool hide)
    {
        tempHideObjects = hide;
    }

    private void ApplyVolumePreview(float volume)
    {
        if (audioMixer != null)
        {
            float dB = volume <= 0.0001f ? -80f : Mathf.Log10(volume) * 20f;
            audioMixer.SetFloat("CarsVolume", dB);
        }
        AudioListener.volume = volume;
    }

    public void NewGame()
    {
        if (loadingCanvas != null) loadingCanvas.SetActive(true);
        SceneManager.LoadScene("MainScene");
    }

    public void Continue()
    {
        if (PlayerPrefs.HasKey(saveKey))
        {
            if (loadingCanvas != null) loadingCanvas.SetActive(true);
            SceneManager.LoadScene("MainScene");
        }
        else
        {
            Debug.Log("��� ����������� ����!");
        }
    }

    private void OnShadowsChanged(bool isOn)
    {
        tempShadowsEnabled = isOn;
        ApplyShadowsPreview(tempShadowsEnabled);
    }

    private void ApplyShadowsPreview(bool shadowsDisabled)
    {
        Light[] lights = FindObjectsByType<Light>(FindObjectsSortMode.None);
        foreach (Light light in lights)
        {
            if (light.type == LightType.Directional)
            {
                light.shadows = shadowsDisabled ? LightShadows.None : LightShadows.Soft;
            }
        }
        QualitySettings.shadows = shadowsDisabled ? ShadowQuality.Disable : ShadowQuality.All;
    }

    public void OpenSettings()
    {
        mainMenuPanel.SetActive(false);
        settingsPanel.SetActive(true);
        SaveCurrentSettingsToBackup();
        LoadTempFromSaved();
        UpdateSettingsUIFromTemp();
    }

    public void CloseSettings()
    {
        RestoreSettingsFromBackup();

        mainMenuPanel.SetActive(true);
        settingsPanel.SetActive(false);
    }

    public void SaveSettings()
    {
        ApplyTempSettings();
        ApplyShadowsPreview(!savedShadowsEnabled);

        PlayerPrefs.SetInt("Fullscreen", savedFullscreen ? 1 : 0);
        PlayerPrefs.SetFloat("MasterVolume", savedMasterVolume);
        PlayerPrefs.SetInt("ResolutionIndex", savedResolutionIndex);
        PlayerPrefs.SetInt("HideObjects", savedHideObjects ? 1 : 0);
        PlayerPrefs.SetInt("ShadowsEnabled", savedShadowsEnabled ? 1 : 0);
        PlayerPrefs.Save();

        CloseSettings();
    }

    private void SaveCurrentSettingsToBackup()
    {
        savedFullscreen = Screen.fullScreen;
        savedMasterVolume = PlayerPrefs.GetFloat("MasterVolume", 0.75f);
        savedResolutionIndex = resolutionDropdown.value;
        savedHideObjects = PlayerPrefs.GetInt("HideObjects", 0) == 1;
        savedShadowsEnabled = QualitySettings.shadows == ShadowQuality.Disable;
    }

    private void LoadTempFromSaved()
    {
        tempFullscreen = savedFullscreen;
        tempMasterVolume = savedMasterVolume;
        tempResolutionIndex = savedResolutionIndex;
        tempHideObjects = savedHideObjects;
        tempShadowsEnabled = savedShadowsEnabled;
    }

    private void UpdateSettingsUIFromTemp()
    {
        fullscreenToggle.SetIsOnWithoutNotify(tempFullscreen);
        masterVolumeSlider.SetValueWithoutNotify(tempMasterVolume);
        resolutionDropdown.SetValueWithoutNotify(tempResolutionIndex);
        hideObjectsToggle.SetIsOnWithoutNotify(tempHideObjects);
        shadowsToggle.SetIsOnWithoutNotify(tempShadowsEnabled);

        ApplyVolumePreview(tempMasterVolume);
        ApplyShadowsPreview(tempShadowsEnabled);
    }

    private void ApplyTempSettings()
    {
        Screen.fullScreen = tempFullscreen;
        savedFullscreen = tempFullscreen;

        if (tempResolutionIndex >= 0 && tempResolutionIndex < resolutions.Length)
        {
            Resolution resolution = resolutions[tempResolutionIndex];
            Screen.SetResolution(resolution.width, resolution.height, Screen.fullScreen);
            savedResolutionIndex = tempResolutionIndex;
        }
        ApplyShadowsPreview(tempShadowsEnabled);
        savedMasterVolume = tempMasterVolume;
        savedShadowsEnabled = tempShadowsEnabled;
        ObjectVisibilityManager.SetHideObjects(tempHideObjects);
        savedHideObjects = tempHideObjects;
    }

    private void RestoreSettingsFromBackup()
    {
        Screen.fullScreen = savedFullscreen;

        if (savedResolutionIndex >= 0 && savedResolutionIndex < resolutions.Length)
        {
            Resolution resolution = resolutions[savedResolutionIndex];
            Screen.SetResolution(resolution.width, resolution.height, Screen.fullScreen);
        }

        ApplyShadowsPreview(savedShadowsEnabled);
        ApplyVolumePreview(savedMasterVolume);

        ObjectVisibilityManager.SetHideObjects(savedHideObjects);
    }

    public void ExitGame()
    {
#if UNITY_EDITOR
        UnityEditor.EditorApplication.isPlaying = false;
#else
        Application.Quit();
#endif
    }

    void LoadSettings()
    {
        savedFullscreen = PlayerPrefs.GetInt("Fullscreen", 1) == 1;
        savedMasterVolume = PlayerPrefs.GetFloat("MasterVolume", 0.75f);
        savedResolutionIndex = PlayerPrefs.GetInt("ResolutionIndex", -1);
        savedHideObjects = PlayerPrefs.GetInt("HideObjects", 0) == 1;
        savedShadowsEnabled = PlayerPrefs.GetInt("ShadowsEnabled", 0) == 1;

        if (savedResolutionIndex < 0 || savedResolutionIndex >= resolutions.Length)
        {
            savedResolutionIndex = GetCurrentResolutionIndex();
        }

        Screen.fullScreen = savedFullscreen;

        if (savedResolutionIndex >= 0 && savedResolutionIndex < resolutions.Length)
        {
            Resolution resolution = resolutions[savedResolutionIndex];
            Screen.SetResolution(resolution.width, resolution.height, Screen.fullScreen);
        }

        ApplyVolumePreview(savedMasterVolume);
        ObjectVisibilityManager.SetHideObjects(savedHideObjects);
        ApplyShadowsPreview(savedShadowsEnabled);
        shadowsToggle.SetIsOnWithoutNotify(savedShadowsEnabled);

        fullscreenToggle.SetIsOnWithoutNotify(savedFullscreen);
        masterVolumeSlider.SetValueWithoutNotify(savedMasterVolume);
        resolutionDropdown.SetValueWithoutNotify(savedResolutionIndex);
        hideObjectsToggle.SetIsOnWithoutNotify(savedHideObjects);
    }

    private int GetCurrentResolutionIndex()
    {
        for (int i = 0; i < resolutions.Length; i++)
        {
            if (resolutions[i].width == Screen.currentResolution.width &&
                resolutions[i].height == Screen.currentResolution.height)
            {
                return i;
            }
        }
        return 0;
    }

    void UpdateSettingsUI()
    {
        fullscreenToggle.SetIsOnWithoutNotify(savedFullscreen);
        masterVolumeSlider.SetValueWithoutNotify(savedMasterVolume);
        resolutionDropdown.SetValueWithoutNotify(savedResolutionIndex);
        hideObjectsToggle.SetIsOnWithoutNotify(savedHideObjects);
    }
}