Scripts/Other/LargeBuildingsManager.cs - master - arti4/Diplom

Scripts/Other/LargeBuildingsManager.cs
286 строк8 KB
arti4
Загрузка всех скриптов
17 май 2026, 09:08
17 май 2026, 09:08cc2e1cd
using UnityEngine;
using System.Collections.Generic;

public class LargeBuildingsManager : MonoBehaviour
{
    [Header("���������")]
    [SerializeField] private Transform player;
    [SerializeField] private float activationRadius = 800f;
    [SerializeField] private float updateInterval = 0.5f;

    [Header("���������")]
    [SerializeField] private GameObject[] largeBuildings;

    [Header("������")]
    [SerializeField] private GameController gameController;
    [SerializeField] private TerrainLODManager terrainLODManager;

    private Dictionary<GameObject, bool> buildingOriginalStates = new Dictionary<GameObject, bool>();
    private bool wasMapOpen = false;
    private float lastUpdateTime;
    private bool isInitialSpawnComplete = false;
    private float initialSpawnTime = 0f;
    private float initialHideDelay = 5f;
    void Start()
    {
        Initialize();
        LateStart();
    }

    void Initialize()
    {
        if (player == null)
        {
            GameObject playerObj = GameObject.FindGameObjectWithTag("Player");
            if (playerObj != null)
                player = playerObj.transform;
        }

        if (gameController == null)
            gameController = FindFirstObjectByType<GameController>();

        HideAllBuildings();

        if (player != null)
        {
            UpdateBuildingsVisibility();
        }

        lastUpdateTime = Time.time;

        Debug.Log($"LargeBuildingsManager: ���������������. ��������: {largeBuildings.Length}, ������: {activationRadius}");
    }

    void HideAllBuildings()
    {
        buildingOriginalStates.Clear();

        foreach (GameObject building in largeBuildings)
        {
            if (building != null)
            {
                buildingOriginalStates[building] = building.activeSelf;

                building.SetActive(false);
            }
        }

        Debug.Log("LargeBuildingsManager: ��� ��������� ������");
    }

    void LateStart()
    {
        initialSpawnTime = Time.time;
        isInitialSpawnComplete = false;
        Debug.Log("LargeBuildingsManager: ����� 5 ������ ����� ������ ��������� ������ 800 ������");
    }

    void Update()
    {
        if (player == null)
        {
            GameObject playerObj = GameObject.FindGameObjectWithTag("Player");
            if (playerObj != null)
            {
                player = playerObj.transform;
                Debug.Log("LargeBuildingsManager: ����� ������");
            }
            return;
        }

        if (Time.time - lastUpdateTime >= updateInterval)
        {
            UpdateBuildingsVisibility();
            lastUpdateTime = Time.time;
        }
    }

    void UpdateBuildingsVisibility()
    {
        if (largeBuildings == null || player == null) return;

        bool isMapOpen = gameController != null && gameController.IsMapOpen();

        bool isInitialPeriod = !isInitialSpawnComplete && (Time.time - initialSpawnTime) < initialHideDelay;

        int visibleCount = 0;
        int hiddenCount = 0;

        foreach (GameObject building in largeBuildings)
        {
            if (building == null) continue;

            bool shouldBeVisible;

            if (isMapOpen)
            {
                shouldBeVisible = true;
            }
            else if (isInitialPeriod)
            {
                shouldBeVisible = true;
            }
            else
            {
                float distanceToEdge = DistanceToBuildingEdge(building, player.position);
                shouldBeVisible = distanceToEdge <= activationRadius;
            }

            if (building.activeSelf != shouldBeVisible)
            {
                building.SetActive(shouldBeVisible);

                if (shouldBeVisible)
                    visibleCount++;
                else
                    hiddenCount++;
            }
        }

        if (!isInitialSpawnComplete && (Time.time - initialSpawnTime) >= initialHideDelay)
        {
            isInitialSpawnComplete = true;
            Debug.Log("LargeBuildingsManager: ��������� ������ ��������. ��������� ������ 800 ������ ������. ����� ������ �� ����������� ������.");

            ForceUpdateVisibility();
        }

        if (visibleCount > 0 || hiddenCount > 0)
        {
        }
    }

    private Bounds GetCombinedBounds(GameObject obj)
    {
        Bounds combinedBounds = new Bounds(obj.transform.position, Vector3.zero);
        bool hasRenderer = false;

        Renderer[] renderers = obj.GetComponentsInChildren<Renderer>();

        if (renderers.Length > 0)
        {
            combinedBounds = renderers[0].bounds;
            for (int i = 1; i < renderers.Length; i++)
            {
                combinedBounds.Encapsulate(renderers[i].bounds);
            }
            hasRenderer = true;
        }

        if (!hasRenderer)
        {
            Collider[] colliders = obj.GetComponentsInChildren<Collider>();
            if (colliders.Length > 0)
            {
                combinedBounds = colliders[0].bounds;
                for (int i = 1; i < colliders.Length; i++)
                {
                    combinedBounds.Encapsulate(colliders[i].bounds);
                }
                hasRenderer = true;
            }
        }

        if (!hasRenderer)
        {
            combinedBounds = new Bounds(obj.transform.position, Vector3.one);
        }

        return combinedBounds;
    }

    private float DistanceToBuildingEdge(GameObject building, Vector3 playerPos)
    {
        Bounds bounds = GetCombinedBounds(building);

        Vector3 closestPoint = bounds.ClosestPoint(playerPos);

        return Vector3.Distance(playerPos, closestPoint);
    }

    public void ForceUpdateVisibility()
    {
        UpdateBuildingsVisibility();
    }

    public void SetMapMode(bool isMapOpen)
    {
        if (isMapOpen)
        {
            ShowAllBuildings();
        }
        else
        {
            UpdateBuildingsVisibility();
        }
    }

    public void ShowAllBuildings()
    {
        foreach (GameObject building in largeBuildings)
        {
            if (building != null && !building.activeSelf)
            {
                building.SetActive(true);
            }
        }
        Debug.Log("LargeBuildingsManager: �������� ��� ��������� (����� �����)");
    }

    public void RestoreOriginalStates()
    {
        foreach (var kvp in buildingOriginalStates)
        {
            if (kvp.Key != null)
            {
                kvp.Key.SetActive(kvp.Value);
            }
        }
        Debug.Log("LargeBuildingsManager: ������������� �������� ��������� ��������");
    }

    public void AddBuilding(GameObject building)
    {
        if (building == null) return;

        List<GameObject> buildingList = new List<GameObject>(largeBuildings);
        buildingList.Add(building);
        largeBuildings = buildingList.ToArray();

        buildingOriginalStates[building] = building.activeSelf;
        building.SetActive(false);

        Debug.Log($"LargeBuildingsManager: ��������� ��������� {building.name}");
    }

    void OnDrawGizmosSelected()
    {
        if (!Application.isPlaying) return;

        Gizmos.color = Color.cyan;
        foreach (GameObject building in largeBuildings)
        {
            if (building != null)
            {
                Gizmos.DrawWireSphere(building.transform.position, activationRadius);

                if (player != null)
                {
                    float distance = Vector3.Distance(player.position, building.transform.position);
                    if (distance <= activationRadius)
                    {
                        Gizmos.color = Color.green;
                        Gizmos.DrawLine(player.position, building.transform.position);
                        Gizmos.color = Color.cyan;
                    }
                }
            }
        }

        if (player != null)
        {
            Gizmos.color = Color.yellow;
            Gizmos.DrawSphere(player.position, 20f);
        }
    }
}