// Resources.cs - скрипт, с логикой ресусров поселения игрока
using UnityEngine;
using UnityEngine.UI;

public class Resources : MonoBehaviour
{
    // Строительные материалы
    public int buildingMaterials = 50;
    public Text buildingMaterialsText;

    // Продукты питания
    public int food = 50;
    public Text foodText;
    private float foodConsumptionTimer = 0f;

    // Монеты
    public int gold = 50;
    public Text goldText;

    void Start()
    {
        UpdateResourceUI();
    }

    void Update()
    {
        ConsumeFood();
    }

    // Метод для потребления еды
    void ConsumeFood()
    {
        // Получаем текущее население из GameManager
        int currentPopulation = GameManager.Instance.population;

        // Вычисляем скорость потребления еды
        float foodConsumptionRate = CalculateFoodConsumptionRate(currentPopulation);

        // Уменьшаем таймер и потребляем еду, когда таймер достигает 0
        foodConsumptionTimer -= Time.deltaTime;
        if (foodConsumptionTimer <= 0f && food > 0)
        {
            food--;
            foodConsumptionTimer = foodConsumptionRate;
            UpdateResourceUI();
        }

        // Проверка на Game Over из-за нехватки еды
        if (food <= 0)
        {
            GameManager.Instance.GameOver("Ваше поселение погибло от голода!");
        }
    }

    // Метод для вычисления скорости потребления еды
    float CalculateFoodConsumptionRate(int population)
    {
        if (population < 100)
        {
            return 10f; // 1 единица за 10 секунд
        }
        else if (population < 1000)
        {
            return 5f; // 1 единица за 5 секунд
        }
        else if (population < 5000)
        {
            return 3f; // 1 единица за 3 секунды
        }
        else
        {
            return 1f; // 1 единица за 1 секунду
        }
    }

    // Метод для обновления UI ресурсов
    public void UpdateResourceUI()
    {
        buildingMaterialsText.text = "Стройматериалы: " + buildingMaterials;
        foodText.text = "Продукты: " + food;
        goldText.text = "Монеты: " + gold;
    }
}

// SettlementDiplomacy.cs - Логика поиска поселений и дипломатии
using UnityEngine;
using UnityEngine.UI;
using System.Collections;
using System.Collections.Generic;
using UnityEngine.SceneManagement;

public class SettlementDiplomacy : MonoBehaviour
{
    public Button diplomacyButton; // Кнопка "Дипломатия" x
    public GameObject findSettlementPanel; // Панель поиска поселений x
    public Text findSettlementText; // Текст на панели поиска x
    public Image progressBar; // Индикатор прогресса поиска x
    public GameObject diplomacyPanel; // Панель дипломатии с найденным поселением x
    public Text settlementNameText; // Текст с названием поселения x
    public Text settlementPopulationText; // Текст с количеством жителей поселения x
    public Text settlementRelationText; // Текст с отношением к поселению x
    public Text settlementDescriptionText; // Текст с описанием поселения x
    public Button tradeButton; // Кнопка "Обмен опытом"
    public Button improveRelationButton; // Кнопка "Улучшить отношения"
    public Button conquerButton; // Кнопка "Захватить"
    public Button ignoreButton; // Кнопка "Обойти стороной"
    public GameObject gameOverPanel; // Панель Game Over
    public Text gameOverText; // Текст на панели Game Over
    public Button mainMenuButton; // Кнопка "Главное меню"

    public GameObject settlementsListPanel; // Панель списка поселений
    public Transform settlementsListContent; // Контент списка поселений (место для элементов списка)
    public GameObject settlementListItemPrefab; // Префаб элемента списка поселений
    public Button closeListButton; // Закрываем список поселений

    public GameManager gameManager; // Ссылка на GameManager

    private List<Settlement> settlements = new List<Settlement>(); // Список найденных поселений
    private List<Settlement> activeTrades = new List<Settlement>(); //
    private Settlement currentSettlement; // Текущее выбранное поселение

    public GameObject battlePanel;       // Панель выбора тактики
    public Button assaultButton;        // Кнопка "Штурм"
    public Button siegeButton;          // Кнопка "Осада"
    public Button sabotageButton;       // Кнопка "Диверсия"
    private bool isWarInProgress = false; // Флаг для отслеживания войны

    public Button buttonOpenSettlementsList; // Кнопка для открытия списка поселений
    private bool isSettlementsListOpen = false;
    private void UpdateSettlementsListButtonVisibility() // Метод каждый раз, когда добавляете новое поселение
    {
        buttonOpenSettlementsList.gameObject.SetActive(settlements.Count > 0);
    }

    // Метод при нажатии на кнопку buttonOpenSettlementsList
    private void OnOpenSettlementsListButtonClicked()
    {
        isSettlementsListOpen = !isSettlementsListOpen;
        settlementsListPanel.SetActive(isSettlementsListOpen);
    }

    // Изменяем struct на class
    [System.Serializable]
    public class Settlement
    {
        public string name;
        public int population;
        public SettlementRelation relation;
        public string description;
        public SettlementStatus status;
    }

    // Перечисление для отношения к поселению
    public enum SettlementRelation
    {
        Hostile,
        Neutral,
        Friendly
    }

    // Перечисление для статуса отношений с поселением
    public enum SettlementStatus
    {
        None,
        Trade,
        War
    }

    void Start()
    {
        diplomacyButton.onClick.AddListener(StartFindSettlement);
        diplomacyPanel.SetActive(false);
        gameOverPanel.SetActive(false);

        // Проверяем, назначена ли кнопка в инспекторе
        if (mainMenuButton != null)
        {
            // Добавляем обработчик события OnClick
            mainMenuButton.onClick.AddListener(GoToMainMenu);
        }
        else
        {
            Debug.LogError("Ошибка: кнопка 'mainMenuButton' не назначена в инспекторе!");
        }

        // Назначаем обработчики кнопок один раз при старте
        tradeButton.onClick.AddListener(OnTradeButtonClicked);
        improveRelationButton.onClick.AddListener(OnImproveRelationButtonClicked);
        conquerButton.onClick.AddListener(OnConquerButtonClicked);
        ignoreButton.onClick.AddListener(IgnoreSettlement);
        closeListButton.onClick.AddListener(CloseList);
        buttonOpenSettlementsList.onClick.AddListener(OnOpenSettlementsListButtonClicked);

        currentSettlement = new Settlement(); // Инициализируем структуру
    }

    // Начало поиска поселения
    private void StartFindSettlement()
    {
        findSettlementPanel.SetActive(true);
        findSettlementText.text = "Поиск поселений...";
        progressBar.fillAmount = 0f;
        // 1. Влияние размера населения на шанс найти поселение:
        float populationFactor = Mathf.Clamp01(gameManager.population / 500f); // от 0 до 1, где 500 - "идеальное" население для поиска
        float findChance = 0.5f + populationFactor * 0.3f; // Базовый шанс + бонус от населения (до 30%)

        // 2. Влияние счастья на шанс успеха поиска:
        float happinessFactor = Mathf.Clamp01(gameManager.happiness / 100f);
        findChance += happinessFactor * 0.2f; // Дополнительный бонус от счастья (до 20%)

        // 3. Разные варианты провала поиска:
        string[] failMessages = {
            "Отряд поисковиков погиб! -6 человек и -3 счастья населения",
            "Поисковики вернулись ни с чем. -1 счастье населения",
            "Обнаружены следы поселения, но оно оказалось заброшено. -2 счастья населения",
            // ... больше вариантов!
        };

        StartCoroutine(FindSettlement(findChance, failMessages));
    }

    // Корутина для имитации поиска поселения
    private IEnumerator FindSettlement(float successChance, string[] failMessages)
    {
        float timer = 0f;
        while (timer < 5f)
        {
            timer += Time.deltaTime;
            progressBar.fillAmount = timer / 5f;
            yield return null;
        }

        // После завершения поиска - рандомный результат
        if (Random.value < successChance)
        {
            findSettlementText.text = "Мы нашли поселение!";
            Settlement newSettlement = GenerateSettlement();
            settlements.Add(newSettlement);
            OpenDiplomacyPanel(newSettlement);
        }
        else
        {
            // Выбираем случайное сообщение о провале:
            string failMessage = failMessages[Random.Range(0, failMessages.Length)];
            findSettlementText.text = failMessage;

            // Применяем последствия провала в зависимости от сообщения:
            if (failMessage.Contains("погиб"))
            {
                gameManager.population -= 6;
                gameManager.happiness -= 3;
            }
            else if (failMessage.Contains("счастье"))
            {
                // Извлекаем число из строки (например, "-3" из " -3 счастья населения")
                int happinessChange = int.Parse(failMessage.Substring(failMessage.IndexOf('-') + 1, 1));
                gameManager.happiness += happinessChange; // Обратите внимание на "+" - мы уменьшаем счастье
            }

            gameManager.UpdatePopulationText();
            gameManager.UpdateHappinessText();
        }

        yield return new WaitForSeconds(2f); // Пауза для просмотра результата
        findSettlementPanel.SetActive(false); // Скрываем панель поиска
    }

    // Генерация случайного поселения
    private Settlement GenerateSettlement()
    {
        Settlement settlement = new Settlement();

        // Список имён для поселений
        string[] settlementNames = {
            "Союз Выживших", "Братство Воды", "Стальной Кулак",
            "Новое Начало", "Оазис Надежды", "Стражи Свободы",
            "Дети Атома", "Хранители Знаний", "Потомки Солнца",
            "Лига Справедливости", "Анклав" // Добавьте больше имён по желанию!
        };

        // Список описаний для поселений
        string[] settlementDescriptions = {
            "Мирное поселение тороговцев и ремесленников.",
            "Группа воинов, защищающих слабые поселения.",
            "Поселение обосновалось вокруг старого военного бункера.",
            // ... добавьте больше описаний!
        };

        settlement.name = settlementNames[Random.Range(0, settlementNames.Length)];
        settlement.population = Random.Range(100, 1000);
        settlement.relation = (SettlementRelation)Random.Range(0, 3);
        settlement.description = settlementDescriptions[Random.Range(0, settlementDescriptions.Length)];
        settlement.status = SettlementStatus.None;

        return settlement;
    }

    // Открытие панели дипломатии
    private void OpenDiplomacyPanel(Settlement settlement)
    {
        currentSettlement = settlement; // Сохраняем текущее поселение

        diplomacyPanel.SetActive(true);
        settlementNameText.text = settlement.name;
        settlementPopulationText.text = "Население: " + settlement.population;
        settlementRelationText.text = "Отношение: " + settlement.relation;
        settlementDescriptionText.text = settlement.description;
        settlementDescriptionText.text += "\nСтатус: " + settlement.status;

        // Обновляем доступность кнопки "Обмен опытом"
        tradeButton.interactable = settlement.relation == SettlementRelation.Friendly && !activeTrades.Contains(settlement);

        // Обновляем доступность кнопки "Улучшить отношения"
        improveRelationButton.interactable = settlement.relation != SettlementRelation.Friendly;

        // Ищем компонент Text на кнопке или её потомках
        Text tradeButtonText = tradeButton.GetComponentInChildren<Text>();

        // Проверяем, найден ли компонент Text
        if (tradeButtonText != null)
        {
            tradeButtonText.color = settlement.relation == SettlementRelation.Friendly ? Color.white : Color.gray;
        }
        else
        {
            Debug.LogError("Компонент Text не найден на кнопке 'tradeButton' или её потомках!");
        }

        UpdateConquerButtonInteractable();
        UpdateImproveRelationButtonInteractable();
        UpdateTradeButtonInteractable();

        UpdateSettlementsListButtonVisibility(); // Обновляем видимость кнопки 

        // Если список поселений открыт, закрываем его
        if (isSettlementsListOpen)
        {
            isSettlementsListOpen = false;
            settlementsListPanel.SetActive(false);
        }
    }

    private void UpdateImproveRelationButtonInteractable()
    {
        improveRelationButton.interactable = currentSettlement != null &&
                                            currentSettlement.relation != SettlementRelation.Friendly;
    }


    private void UpdateTradeButtonInteractable()
    {
        tradeButton.interactable = currentSettlement != null &&
                                   currentSettlement.relation == SettlementRelation.Friendly &&
                                   !activeTrades.Contains(currentSettlement);
    }

    // Обработчики кнопок
    private void OnTradeButtonClicked()
    {
        if (tradeButton.interactable)
        {
            activeTrades.Add(currentSettlement);
            UpdateSettlementStatus(currentSettlement.name, SettlementStatus.Trade);
            StartCoroutine(TradeExperience(currentSettlement));
            OpenSettlementsListPanel();
            diplomacyPanel.SetActive(false);
            currentSettlement = null;
        }
    }

    private void OnImproveRelationButtonClicked()
    {
        if (improveRelationButton.interactable)
        {
            ImproveRelation(currentSettlement);
            UpdateSettlementStatus(currentSettlement.name, SettlementStatus.None);
            OpenSettlementsListPanel();
            diplomacyPanel.SetActive(false);
            currentSettlement = null;
        }
    }

    private void OnConquerButtonClicked()
    {
        if (conquerButton.interactable)
        {
            // Вместо начала боя, показываем панель выбора тактики:
            UpdateSettlementStatus(currentSettlement.name, SettlementStatus.War);
            battlePanel.SetActive(true);
            diplomacyPanel.SetActive(false);

            // Назначаем обработчики кнопок тактики
            assaultButton.onClick.AddListener(() =>
                StartCoroutine(ConquerSettlement(currentSettlement, "Assault")));
            siegeButton.onClick.AddListener(() =>
                StartCoroutine(ConquerSettlement(currentSettlement, "Siege")));
            sabotageButton.onClick.AddListener(() =>
                StartCoroutine(ConquerSettlement(currentSettlement, "Sabotage")));
        }
        else if (isWarInProgress)
        {
            Debug.Log($"Война с {currentSettlement.name} уже идет!");
        }
        else if (gameManager.population < currentSettlement.population)
        {
            Debug.Log($"У вас недостаточно населения для войны с {currentSettlement.name}!");
        }
    }

    private void UpdateConquerButtonInteractable()
    {
        conquerButton.interactable = currentSettlement != null &&
                                     gameManager.population >= currentSettlement.population &&
                                     currentSettlement.relation == SettlementRelation.Hostile &&
                                     !isWarInProgress;
    }

    // Обмен опытом
    private void StartTrade(Settlement settlement)
    {
        // Проверяем, что отношения с поселением дружественные
        if (settlement.relation == SettlementRelation.Friendly)
        {
            // Запускаем корутину для обмена опытом
            StartCoroutine(TradeExperience(settlement));
            OpenSettlementsListPanel();
        }

    }

    private IEnumerator TradeExperience(Settlement settlement)
    {
        // Проверка условий для обмена
        if (settlement.relation != SettlementRelation.Friendly || !activeTrades.Contains(settlement))
        {
            Debug.Log("Невозможно обмениватсья опытом с поселением, без дружеских отношений.");
            yield break; // Прекращаем корутину
        }

        activeTrades.Add(settlement);

        while (true)
        {
            gameManager.population += 5;
            gameManager.happiness += 10;
            gameManager.UpdatePopulationText();
            gameManager.UpdateHappinessText();

            // Добавить звук или анимацию для обмена

            yield return new WaitForSeconds(30);

            // Удаляем поселение из списка активных обменов:
            activeTrades.Remove(settlement);
        }
    }

    // Улучшение отношений
    private void ImproveRelation(Settlement settlement)
    {
        if (settlement.relation == SettlementRelation.Hostile)
        {
            // Попытка установить нейтральные отношения
            settlement.relation = SettlementRelation.Neutral;
            settlementRelationText.text = "Отношение: " + SettlementRelation.Neutral;

            // Вывод сообщения о том, что отношения стали нейтральными
            Debug.Log($"Отношения с {settlement.name} стали нейтральными.");

            // Добавьте визуальный эффект или звук для изменения отношений
        }
        else if (settlement.relation == SettlementRelation.Neutral)
        {
            // Попытка установить дружеские отношения
            // 50/50 шанс успеха
            if (Random.value < 0.5f)
            {
                settlement.relation = SettlementRelation.Friendly;
                settlementRelationText.text = "Отношение: " + SettlementRelation.Friendly;
                gameManager.happiness += 5;
                gameManager.UpdateHappinessText();

                // Вывод сообщения о том, что отношения стали дружескими
                Debug.Log($"Отношения с {settlement.name} стали дружескими.");

                // Добавьте визуальный эффект или звук для изменения отношений
            }
            else
            {
                // Отношения остаются нейтральными
                settlementRelationText.text = "Отношение: " + SettlementRelation.Neutral;
                gameManager.happiness -= 3;
                gameManager.UpdateHappinessText();

                // Вывод сообщения о том, что отношения не изменились
                Debug.Log($"Попытка улучшить отношения с {settlement.name} провалилась.");

                // Добавьте визуальный эффект или звук для провала попытки
            }
        }
        else if (settlement.relation == SettlementRelation.Friendly)
        {
            // Вывод сообщения о том, что отношения уже дружеские
            Debug.Log($"Отношения с {settlement.name} уже дружеские.");
        }
    }

    // Начало захвата
    private void StartConquest(Settlement settlement, string tactic)
    {
        // Проверяем, что отношения с поселением враждебные
        if (settlement.relation == SettlementRelation.Hostile)
        {
            settlement.status = SettlementStatus.War;
            StartCoroutine(ConquerSettlement(settlement, tactic)); // Передаём tactic
        }
    }

    // Корутина для захвата поселения (с выбором тактики)
    private IEnumerator ConquerSettlement(Settlement settlement, string tactic)
    {
        isWarInProgress = true;
        battlePanel.SetActive(false); // Скрываем панель выбора

        // Базовый шанс на победу
        float winChance = Mathf.Clamp01((float)gameManager.population /
                                        (float)(gameManager.population + settlement.population));

        // Модификаторы шанса и потерь в зависимости от тактики
        float winChanceModifier = 0f;
        float playerLossModifier = 1f;
        float enemyLossModifier = 1f;

        switch (tactic)
        {
            case "Assault":
                winChanceModifier = 0.15f;  // +15% к шансу победы
                playerLossModifier = 1.5f; // +50% к потерям игрока
                enemyLossModifier = 2f;    // x2 к потерям противника
                                           // Дополнительный текст или эффекты для штурма
                Debug.Log("Вы начали яростный штурм поселения!");
                break;
            case "Siege":
                winChanceModifier = -0.1f;   // -10% к шансу победы
                playerLossModifier = 0.7f; // -30% к потерям игрока
                enemyLossModifier = 0.8f; // -20% к потерям противника
                                          // Дополнительный текст или эффекты для осады
                Debug.Log("Вы окружили поселение и начали осаду!");
                yield return new WaitForSeconds(2f); // Имитация долгой подготовки
                break;
            case "Sabotage":
                // Диверсия не влияет на шанс победы напрямую, 
                // но уменьшает население противника перед битвой
                int sabotageLosses = Mathf.RoundToInt(settlement.population * 0.1f); // 10%
                settlement.population -= sabotageLosses;
                settlementPopulationText.text = "Население: " + settlement.population; // Обновляем UI
                                                                                       // Дополнительный текст или эффекты для диверсии
                Debug.Log("Ваши диверсанты проникли в поселение!");
                yield return new WaitForSeconds(2f); // Задержка для имитации диверсии
                break;
        }

        // Применяем модификаторы
        winChance += winChanceModifier;
        winChance = Mathf.Clamp01(winChance);

        // Имитируем битву (например, текстом в UI)
        Debug.Log("Идет ожесточенная битва!...");
        yield return new WaitForSeconds(2f);

        // Определяем исход битвы 
        bool isVictory = Random.value < winChance;

        if (isVictory)
        {
            // Логика победы:
            settlement.status = SettlementStatus.None;

            // Население присоединившегося поселения (часть от начального)
            int joinedPopulation = Mathf.RoundToInt(settlement.population * 0.7f);
            gameManager.population += joinedPopulation;

            settlement.population = joinedPopulation;
            settlement.relation = SettlementRelation.Friendly;
            settlement.description = "Поселение присоединилось к вам!";

            // Обновление интерфейса
            settlementRelationText.text = "Отношение: " + SettlementRelation.Friendly;
            settlementDescriptionText.text = "Поселение захвачено!";

            Debug.Log("Победа! Поселение захвачено!");
        }
        else
        {
            // Логика поражения:
            int playerLosses = Mathf.RoundToInt(gameManager.population * 0.3f * playerLossModifier);
            gameManager.population -= playerLosses;

            // Потери противника (ИСПОЛЬЗУЕМ enemyLossModifier)
            int enemyLosses = Mathf.RoundToInt(settlement.population * 0.2f * enemyLossModifier);
            settlement.population -= enemyLosses;
            settlementPopulationText.text = "Население: " + settlement.population; // Обновляем UI

            // Дополнительные действия при поражении (например, изменение отношений)
            settlement.relation = SettlementRelation.Hostile;
            settlementRelationText.text = "Отношение: " + SettlementRelation.Hostile;
            settlementDescriptionText.text = "Вы потерпели поражение!";

            Debug.Log("Поражение! Ваша армия отступила...");
        }

        // Обновляем интерфейс и флаг войны
        gameManager.UpdatePopulationText();
        UpdateConquerButtonInteractable();
        isWarInProgress = false;
    }

    // Игнорирование поселения
    private void IgnoreSettlement()
    {
        diplomacyPanel.SetActive(false);

        // Удаляем поселение из списка settlements, если оно там есть
        settlements.Remove(currentSettlement);

        // Очищаем currentSettlement
        currentSettlement = null;

        UpdateSettlementsListButtonVisibility();
    }

    // Открытие панели списка поселений
    public void OpenSettlementsListPanel()
    {
        settlementsListPanel.SetActive(true);

        // Очистка предыдущего списка
        foreach (Transform child in settlementsListContent.transform)
        {
            Destroy(child.gameObject);
        }

        // Заполнение списка найденными поселениями
        foreach (Settlement settlement in settlements)
        {
            GameObject listItem = Instantiate(settlementListItemPrefab, settlementsListContent);

            // Находим компонент Text внутри prefab'а
            Text listItemText = listItem.GetComponentInChildren<Text>();

            // Формируем текст для элемента списка
            string settlementInfo = $"{settlement.name} ({settlement.population} жителей)\n" +
                                   $"Отношение: {settlement.relation}, Статус: {settlement.status}";

            // Устанавливаем текст для элемента списка
            listItemText.text = settlementInfo;

            // Добавляем обработчик нажатия на элемент списка
            Button listItemButton = listItem.GetComponent<Button>();

            // Используем лямбда-выражение для передачи settlement в OpenDiplomacyPanel
            listItemButton.onClick.AddListener(() =>
            {
                OpenDiplomacyPanel(settlement);
                settlementsListPanel.SetActive(false);
            });
        }
    }

    public void CloseList()
    {
        settlementsListPanel.SetActive(false);
    }

    // Game Over
    private void GameOver(string message)
    {
        gameOverPanel.SetActive(true);
        gameOverText.text = message;
        diplomacyButton.interactable = false;
    }

    // Функция для обновления статуса поселения в списке settlements
    private void UpdateSettlementStatus(string settlementName, SettlementStatus newStatus)
    {
        // Создаем копию списка settlements
        List<Settlement> settlementsCopy = new List<Settlement>(settlements);

        // Находим индекс поселения в списке settlementsCopy
        int index = settlementsCopy.FindIndex(s => s.name == settlementName);

        // Если поселение найдено, обновляем его статус в settlementsCopy
        if (index != -1)
        {
            settlementsCopy[index].status = newStatus;
        }

        // Заменяем исходный список settlements на измененную копию
        settlements = settlementsCopy;
    }

    public void GoToMainMenu()
    {
        SceneManager.LoadScene("SampleScene");
    }
}

// Advistor.cs - скрипт с логикой советника
using UnityEngine;
using UnityEngine.UI;

public class Advisor : MonoBehaviour
{
    public GameObject advisorIcon;         // Ссылка на иконку советника
    public GameObject speechBubble;      // Ссылка на облако диалога
    public Text speechBubbleText;        // Ссылка на текст внутри облака

    public void GiveAdvice(Question currentQuestion)
    {
        // Генерируем подсказку на основе текущего вопроса
        string advice = GenerateAdvice(currentQuestion);

        // Отображаем подсказку в облаке диалога
        speechBubbleText.text = advice;
        speechBubble.SetActive(true);
    }

    // Скрываем подсказку, когда она больше не нужна
    public void HideAdvice()
    {
        speechBubble.SetActive(false);
    }

    // Логика генерации подсказки
    private string GenerateAdvice(Question currentQuestion)
    {
        //  Анализируем currentQuestion (текст, варианты ответов, население, счастье)
        //  и выбираем наиболее подходящий совет. 

        // Простой пример: совет на основе populationChange:
        int bestChoiceIndex = 0;
        int highestPopulationChange = int.MinValue;

        for (int i = 0; i < currentQuestion.choices.Length; i++)
        {
            if (currentQuestion.choices[i].populationChange > highestPopulationChange)
            {
                highestPopulationChange = currentQuestion.choices[i].populationChange;
                bestChoiceIndex = i;
            }
        }

        // Вернуть совет, указывающий на лучший выбор (не раскрывая его полностью)
        return $"Возможно, стоит обратить внимание на вариант: \"{currentQuestion.choices[bestChoiceIndex].text.Substring(0, 10)}...\"";
    }
}

// GameManager.cs - главный скрипт игры, менеджер
using UnityEngine;
using UnityEngine.UI;
using System.Collections;
using System.Collections.Generic;
using UnityEngine.SceneManagement; // для работы со сценами

// Объявление структур вне классов
public struct Question
{
    public string text;
    public Choice[] choices;
    public int populationType; // 1 - до 100, 2 - до 500, 3 - до 1500, 4 - до 5000, 5 - до 10000

    public Question(string text, Choice[] choices, int populationType)
    {
        this.text = text;
        this.choices = choices;
        this.populationType = populationType;
    }
}

public struct Choice
{
    public string text;
    public int populationChange;
    public int happinessChange;
    public string resultText;

    public Choice(string text, int populationChange, int happinessChange, string resultText)
    {
        this.text = text;
        this.populationChange = populationChange;
        this.happinessChange = happinessChange;
        this.resultText = resultText;
    }
}

public class GameManager : MonoBehaviour
{
    public static GameManager Instance { get; private set; }
    public Question currentQuestion;

    public Text questionText;
    public Text populationText;
    //public Text happinessText;
    public Button button1;
    public Button button2;
    public Button button3;
    public Button button4;
    public GameObject gameOverPanel;
    public Text gameOverText;
    public Button mainMenuButton;

    // Ссылки на картинки обводки для каждой кнопки
    public Image button1Highlight;
    public Image button2Highlight;
    public Image button3Highlight;
    public Image button4Highlight;

    private bool isChoiceLocked = false;

    public QuestsLogic questsLogic; // Ссылка на скрипт с логикой квестов

    // Панель с инфой о том, на что повлиял выбор
    public Text resultText;
    public GameObject resultPanel;
    public Button understandButton;

    // Переменные для случайных событий
    public GameObject randomEventsPanel;
    public Text randomEventText;
    public Button understandEventButton;
    private int questionsUntilNextEvent;

    public Text proftiInfoText;

    private bool bonusPopulationApplied = false;

    // Скролбар счастья
    public Scrollbar HappinessScrollbar; // Ссылка на Scrollbar для отображения счастья
    public Text happinessText;         // Ссылка на текст внутри Scrollbar

    // Советник
    public Advisor advisor;
    private bool isAdvisorAvailable = false;
    public GameObject advisorAvailabilityMessage; // Ссылка на объект с сообщением о доступности советника

    //Показатели поселения
    public int population = 20;
    public int happiness = 50;

    void Awake()
    {
        if (Instance == null)
        {
            Instance = this;
        }
        else
        {
            Destroy(gameObject);
        }
    }

    void Start()
    {
        questsLogic.Initialize();
        UpdatePopulationText();
        UpdateHappinessText();
        HideButtonHighlights();
        gameOverPanel.SetActive(false);
        resultPanel.SetActive(false);
        randomEventsPanel.SetActive(false);
        questionsUntilNextEvent = Random.Range(2, 4);
        resultPanel.SetActive(false);
        proftiInfoText.gameObject.SetActive(false); // Скрываем текст
        advisor.advisorIcon.GetComponent<Button>().onClick.AddListener(() =>
            advisor.GiveAdvice(currentQuestion));
        UpdateAdvisorAvailability();

        DisplayQuestion();

        // Проверяем, назначена ли кнопка в инспекторе
        if (mainMenuButton != null)
        {
            // Добавляем обработчик события OnClick
            mainMenuButton.onClick.AddListener(GoToMainMenu);
        }
        else
        {
            Debug.LogError("Ошибка: кнопка 'mainMenuButton' не назначена в инспекторе!");
        }
    }

    // Вызывается из QuestsLogic, когда нужно отобразить вопрос
    public void DisplayQuestion()
    {
        HideButtonHighlights(); // Скрываем обводки перед показом нового вопроса

        // Проверяем, нужно ли показать случайное событие
        if (questionsUntilNextEvent <= 0)
        {
            ShowRandomEvent();
        }
        else
        {
            // Логика отображения вопроса, если событие не показывается
            currentQuestion = questsLogic.GetCurrentQuestion();

            if (currentQuestion.text != null)
            {
                questionText.text = currentQuestion.text;

                button1.GetComponentInChildren<Text>().text = currentQuestion.choices[0].text;
                button1.onClick.RemoveAllListeners();
                button1.onClick.AddListener(() => MakeChoice(0));

                button2.GetComponentInChildren<Text>().text = currentQuestion.choices[1].text;
                button2.onClick.RemoveAllListeners();
                button2.onClick.AddListener(() => MakeChoice(1));

                button3.GetComponentInChildren<Text>().text = currentQuestion.choices[2].text;
                button3.onClick.RemoveAllListeners();
                button3.onClick.AddListener(() => MakeChoice(2));

                button4.GetComponentInChildren<Text>().text = currentQuestion.choices[3].text;
                button4.onClick.RemoveAllListeners();
                button4.onClick.AddListener(() => MakeChoice(3));
            }
            else
            {
                GameOver("Вы прошли все испытания и привели свое поселение к процветанию!");
            }

            questionsUntilNextEvent--; // Уменьшаем счетчик после показа вопроса
        }
    }



    public AudioSource audioSource;
    public AudioClip fxMinusPeople;
    public AudioClip fxMinusHappy;
    public AudioClip fxPlusHappy;
    public AudioClip fxPlusPeople;
    public AudioClip fxGameOver;
    public AudioClip highlightSound;

    public void MakeChoice(int index)
    {
        if (isChoiceLocked) return;

        advisor.HideAdvice();

        Choice chosenChoice = questsLogic.MakeChoice(index, currentQuestion);

        population += chosenChoice.populationChange;
        happiness += chosenChoice.happinessChange;
        resultText.text = chosenChoice.resultText;

        ShowButtonHighlight(index);

        // Форматируем текст с учётом знака изменений:
        string populationChangeText = chosenChoice.populationChange > 0
            ? $"<color=green>+{chosenChoice.populationChange} население</color>"
            : $"<color=red>{chosenChoice.populationChange} население</color>";
        string happinessChangeText = chosenChoice.happinessChange > 0
            ? $"<color=green>+{chosenChoice.happinessChange} счастье</color>"
            : $"<color=red>{chosenChoice.happinessChange} счастье</color>";

        // Отображаем изменения в proftiInfoText:
        proftiInfoText.text = $"{populationChangeText}\n{happinessChangeText}";

        PlayChoiceSound(chosenChoice);

        // --- Начало блока обработки бонуса за счастье ---
        if (happiness >= 100 && !bonusPopulationApplied)
        {
            population++;
            bonusPopulationApplied = true;
            Debug.Log("Бонус +1 к населению за счастье!");
        }

        bonusPopulationApplied = false; // Сбрасываем флаг в конце хода
        // --- Конец блока обработки бонуса за счастье ---

        if (!isAdvisorAvailable)
        {
            UpdateAdvisorAvailability();
        }

        isChoiceLocked = true; // Блокируем кнопки после выбора
        StartCoroutine(ShowResultAndContinue(2f));
    }

    private void PlayChoiceSound(Choice choice)
    {
        if (choice.populationChange < 0 && Mathf.Abs(choice.populationChange) > Mathf.Abs(choice.happinessChange))
        {
            audioSource.PlayOneShot(fxMinusPeople);
        }
        else if (choice.happinessChange < 0 && Mathf.Abs(choice.happinessChange) > Mathf.Abs(choice.populationChange))
        {
            audioSource.PlayOneShot(fxMinusHappy);
        }
        else if (choice.happinessChange > 0 && choice.happinessChange > choice.populationChange)
        {
            audioSource.PlayOneShot(fxPlusHappy);
        }
        else if (choice.populationChange > 0 && choice.populationChange > choice.happinessChange)
        {
            audioSource.PlayOneShot(fxPlusPeople);
        }
    }

    private void UpdateAdvisorAvailability()
    {
        if (population >= 100 && !isAdvisorAvailable)
        {
            advisor.advisorIcon.transform.parent.gameObject.SetActive(true);
            advisorAvailabilityMessage.SetActive(true);
            StartCoroutine(HideAvailabilityMessage(5f));
            isAdvisorAvailable = true; // Советник теперь доступен
        }
    }

    private IEnumerator HideAvailabilityMessage(float delay)
    {
        yield return new WaitForSeconds(delay);
        advisorAvailabilityMessage.SetActive(false);
    }
    private IEnumerator ShowResultAndContinue(float delay)
    {
        // Открываем панель результата
        resultPanel.SetActive(true);
        understandButton.onClick.RemoveAllListeners();
        proftiInfoText.gameObject.SetActive(true);

        // Ждём нажатия кнопки “Понял”
        bool understood = false;
        understandButton.onClick.AddListener(() => understood = true);

        // Пока кнопку не нажали, ждём
        yield return new WaitUntil(() => understood);

        // Скрываем текст вместе с панелью результатов:
        resultPanel.SetActive(false);
        proftiInfoText.gameObject.SetActive(false);

        // Очищаем результат
        resultText.text = "";
        UpdatePopulationText();
        UpdateHappinessText();

        if (happiness <= 0)
        {
            GameOver("Ваше поселение погрузилось в хаос и отчаяние!");
        }
        else if (population <= 1)
        {
            GameOver("Ваше поселение погибло!");
        }
        else
        {
            resultPanel.SetActive(false);
            isChoiceLocked = false;
            DisplayQuestion();
        }
    }

    public void UpdatePopulationText()
    {
        populationText.text = "Население: " + population;
    }

    public void UpdateHappinessText()
    {
        // Ограничиваем счастье до 100
        happiness = Mathf.Clamp(happiness, 0, 100);

        // Обновляем значение Scrollbar (от 0 до 1)
        HappinessScrollbar.size = happiness / 100f;

        // Обновляем текстовое значение
        happinessText.text = "Счастье: " + happiness;
    }

    public void GameOver(string message)
    {
        gameOverPanel.SetActive(true);
        gameOverText.text = message;
        audioSource.PlayOneShot(fxGameOver);

        // Скрываем лишние элементы при Game Over:
        questionText.gameObject.SetActive(false);
        button1.gameObject.SetActive(false);
        button2.gameObject.SetActive(false);
        button3.gameObject.SetActive(false);
        button4.gameObject.SetActive(false);
        resultPanel.SetActive(false);
        advisor.advisorIcon.transform.parent.gameObject.SetActive(false); // Скрываем иконку советника
    }

    public void GoToMainMenu()
    {
        SceneManager.LoadScene("SampleScene");
    }

    // Функция для отображения обводки выбранной кнопки
    private void ShowButtonHighlight(int buttonIndex)
    {
        // Сначала скрываем все обводки
        HideButtonHighlights();

        // Включаем обводку для выбранной кнопки
        switch (buttonIndex)
        {
            case 0:
                button1Highlight.gameObject.SetActive(true);
                break;
            case 1:
                button2Highlight.gameObject.SetActive(true);
                break;
            case 2:
                button3Highlight.gameObject.SetActive(true);
                break;
            case 3:
                button4Highlight.gameObject.SetActive(true);
                break;
        }

        // Проигрываем звук
        if (highlightSound != null)
        {
            audioSource.PlayOneShot(highlightSound);
        }
    }

    // Функция для скрытия всех обводкок
    private void HideButtonHighlights()
    {
        button1Highlight.gameObject.SetActive(false);
        button2Highlight.gameObject.SetActive(false);
        button3Highlight.gameObject.SetActive(false);
        button4Highlight.gameObject.SetActive(false);
    }

    private void ShowRandomEvent()
    {

        randomEventsPanel.SetActive(true);
        RandomEvent eventData = GetRandomEvent();
        randomEventText.text = eventData.text;

        population += eventData.populationChange;
        happiness += eventData.happinessChange;

        PlayChoiceSound(new Choice("", eventData.populationChange, eventData.happinessChange, ""));

        UpdatePopulationText();
        UpdateHappinessText();

        understandEventButton.onClick.RemoveAllListeners();
        understandEventButton.onClick.AddListener(() =>
        {
            randomEventsPanel.SetActive(false);
            questionsUntilNextEvent = Random.Range(4, 11);
            DisplayQuestion();
        });
    }

    // Структура для хранения данных о случайном событии
    public struct RandomEvent
    {
        public string text;
        public int populationChange;
        public int happinessChange;

        public RandomEvent(string text, int populationChange, int happinessChange)
        {
            this.text = text;
            this.populationChange = populationChange;
            this.happinessChange = happinessChange;
        }
    }

    // Список возможных случайных событий
    private List<RandomEvent> randomEvents = new List<RandomEvent>()
    {
        // Положительные события
        new RandomEvent("В другом поселении случился конфликт! Люди перешли к вам", 10, 0),
        new RandomEvent("Группа торговцев решила обосноваться в вашем поселении", 5, 2),
        new RandomEvent("Праздник урожая! Люди счастливы!", 0, 10),
        new RandomEvent("К вам прибился отряд опытных выживальщиков!", 5, 5),
        new RandomEvent("В лесу обнаружены богатые залежи ягод и грибов!", 0, 15),
        new RandomEvent("Рождаемость в поселении резко увеличилась!", 20, 10),
        new RandomEvent("Лекарь исцелил больных!", 5, 20),
        new RandomEvent("Ваши охотники добыли огромного зверя!", 0, 10),
        new RandomEvent("Найдено уцелевшее хранилище с припасами!", 10, 5),
        new RandomEvent("Соседнее поселение прислало дары в знак дружбы!", 5, 5),

        // Нейтральные события
        new RandomEvent("Стая гнилых волков обосновалась неподалеку от поселения.", 0, -2),
        new RandomEvent("Несколько дней шли кислотные дожди.", 0, -1),
        new RandomEvent("В поселении родился ребенок.", 1, 1),
        new RandomEvent("Один из жителей пропал без вести.", -1, -2),
        new RandomEvent("Произошел небольшой пожар, но его быстро потушили.", -2, -3),
        new RandomEvent("В поселении произошла драка между жителями.", 0, -5),
        new RandomEvent("К поселению примкнули опытные охотники.", 0, 2),
        new RandomEvent("Несколько жителей заболели кровавой простудой.", -2, -2),
        new RandomEvent("Ваши разведчики обнаружили уцелевшую машину.", 0, 1),
        new RandomEvent("Произошло солнечное затмение.", 0, -1),

        // Отрицательные события
        new RandomEvent("Неурожай, несколько человек погибло от голода!", -10, -5),
        new RandomEvent("Эпидемия радиоактивной язвы! Умирающие лежат на улицах!", -15, -10),
        new RandomEvent("На поселение напали бандиты!", -10, -15),
        new RandomEvent("Зима пришла раньше обычного, начались заморозки.", -5, -10),
        new RandomEvent("Запасы воды на исходе, родник чем-то перекрыт.", -5, -5),
        new RandomEvent("В поселении завелись крысы, которые портят запасы еды.", -3, -5),
        new RandomEvent("Произошло отравление старыми консервами, есть погибшие.", -10, -20),
        new RandomEvent("Один из жителей сошел с ума и напал на других.", -3, -10),
        new RandomEvent("Группа жителей решила покинуть поселение.", -5, -2),
        new RandomEvent("В поселении объявился предатель, который сотрудничает с бандитами.", -2, -10)
    };

    // Метод для получения случайного события из списка
    private RandomEvent GetRandomEvent()
    {
        int randomIndex = Random.Range(0, randomEvents.Count);
        return randomEvents[randomIndex];
    }
}

// QuestsLogic.cs - в этом скрипте логика квестов и сами вопросы
using UnityEngine;
using System.Collections.Generic;

public class QuestsLogic : MonoBehaviour
{
    private List<Question> questionsType1 = new List<Question>();
    private List<Question> questionsType2 = new List<Question>();
    private List<Question> questionsType3 = new List<Question>();
    private List<Question> questionsType4 = new List<Question>();
    private List<Question> questionsType5 = new List<Question>();

    private int currentQuestionType = 1; // Текущий тип вопросов

    public void Initialize()
    {
        // --- Вопросы для населения до 100 ---
        questionsType1.Add(new Question("В реке была найдена мёртвая туша неведомого монстра",
            new Choice[]
            {
                new Choice("Найти логово монстров", -6, -3, "Группа набрела на логово монстров и была растерзана"),
                new Choice("Отнести повару и накормить жителей", -20, -15, "После супа из мяса монстра большая часть жителей не пережила ночь"),
                new Choice("Приказать сжечь тушу дотла и развеять пепел по реке", 0, 15, "Монстры прекратили посещать ваши края. Люди счастливы!"),
                new Choice("Выяснить причину смерти", 3, 5, "Выяснилось, что монстр был убит охотниками одиночками, которые с радостью к нам примкнули")
            }, 1));
        questionsType1.Add(new Question("Стая голодных собак окружила группу людей неподалёку от вашего лагеря, примите решение",
            new Choice[]
            {
                new Choice("Проигнорировать", 0, -10, "Из-за вас погибла семейная пара, люди напуганы"),
                new Choice("Отправить группу на спасение", 3, 15, "Вы спасли семью, и она к вам примкнула. Люди счастливы!"),
                new Choice("Навести шума", -15, -20, "Громкими звуками вы приманили ещё больше собак. Много погибших, люди в панике!"),
                new Choice("Позвать людей сюда из-за забора", 1, -5, "Это была молодая семья, выжил только отец. Люди насторожены")
            }, 1));
        questionsType1.Add(new Question("К вам подходит группа людей, утверждающая, что сбежала из соседнего поселения, которое захватили бандиты. Ваши действия?",
            new Choice[]
            {
                new Choice("Принять их к себе", 5, 10, "Беженцы оказались мирными жителями. Люди рады новым соседям!"),
                new Choice("Прогнать их", -3, -15, "Среди жителей поднялась паника. Люди напуганы!"),
                new Choice("Допросить их с пристрастием", -8, -25, "Оказалось, что это были шпионы бандитов.  Люди напуганы и возмущены!"),
                new Choice("Предложить им пройти испытание на верность", 2, -5, "Испытание прошли не все.  Люди настороженно относятся к новичкам.")
            }, 1));
        questionsType1.Add(new Question("На лагерь надвигается сильный шторм. Что вы будете делать?",
            new Choice[]
            {
                new Choice("Ничего, переждём в домах", -5, -10, "Шторм оказался разрушительным. Люди напуганы."),
                new Choice("Укрепить ветхий забор и постройки", 2, 15, "Вам удалось минимизировать потери. Люди благодарны за вашу предусмотрительность!"),
                new Choice("Эвакуироваться в ближайшую пещеру", 0, -5, "Пещера оказалась тесной и неудобной. Люди недовольны."),
                new Choice("Попробовать договориться с духами шторма", -10, -20, "Люди вышли на встречу стихии. Есть погибшие!")
            }, 1));
        questionsType1.Add(new Question("Обнаружены залежи неизвестного металла. Что делать?",
            new Choice[]
            {
                new Choice("Игнорировать, это может быть опасно", 0, 5, "Люди немного насторожены, но доверяют вашему решению."),
                new Choice("Начать добычу немедленно!", -5, -10, "Металл оказался радиоактивным. Несколько человек погибло."),
                new Choice("Отправить группу на разведку", 2, 10, "Разведка прошла успешно, металл оказался ценным ресурсом!"),
                new Choice("Попытаться продать информацию о металле", 5, -5, "Покупатель обманул вас, люди недовольны.")
            }, 1));
        questionsType1.Add(new Question("Группа детей нашла странное светящееся растение. Что делать?",
            new Choice[]
            {
                new Choice("Уничтожить растение, это может быть опасно", 1, 5, "Растение оказалось безвредным, но люди ценят вашу осторожность."),
                new Choice("Попробовать использовать его в пищу", -10, -15, "Растение оказалось ядовитым! Много пострадавших."),
                new Choice("Изучить растение", 3, 10, "Растение оказалось ценным лекарственным средством!"),
                new Choice("Попытаться вырастить ещё таких растений", -2, -5, "Ничего не вышло, семена не прорастают. Люди разочарованы.")
            }, 1));
        questionsType1.Add(new Question("К вам прибился странствующий торговец. Ваши действия?",
            new Choice[]
            {
                new Choice("Прогнать его", -2, -5, "Торговец предлагал выгодную сделку. Люди недовольны."),
                new Choice("Ограбить его", -5, -15, "Слухи о вашем поступке разлетелись быстро. Теперь с вами никто не торгует."),
                new Choice("Поторговать с ним", 3, 10, "Вы заключили выгодную сделку! Люди довольны."),
                new Choice("Арестовать его", 0, -5, "У торговца не оказалось ничего запрещённого. Люди не понимают, зачем вы его арестовали.")
            }, 1));


        // --- Вопросы для населения от 100 до 500 ---
        questionsType2.Add(new Question("До вас дошли слухи, что некий житель планирует покушение на вас",
            new Choice[]
            {
                new Choice("Публично казнить", -50, -10, "Люди в ужасе! Целыми семьями бегут в другие поселения."),
                new Choice("Встретиться для личной беседы", -10, 20, "Ваш недоброжелатель решил мирно покинуть поселение со своими преспешниками!"),
                new Choice("Подстроить несчастный случай, в котором он погибнет", -1, -15, "Никто не знает куда пропал ваш недоброжелатель. Ходят слухи..."),
                new Choice("Ничего не делать", -100, -20, "Спустя несколько дней он со своими преспешниками устроил резню в поселении и сжёг дома. Люди погибли, как и он.")
            }, 2));
        questionsType2.Add(new Question("Запасы еды на исходе. Что делать?",
            new Choice[]
            {
                new Choice("Организовать экспедицию в поисках продовольствия", -10, -5, "Экспедиция вернулась ни с чем. Люди голодают."),
                new Choice("Ввести жесткий режим экономии", -20, -15, "Люди голодают и недовольны вашим правлением."),
                new Choice("Начать выращивать собственную еду", 30, 15, "Первый урожай не заставил себя долго ждать! Люди счастливы."),
                new Choice("Начать торговлю с соседним поселением", 15, 5, "Соседи оказались не очень-то рады вас видеть. Сделка прошла не очень выгодно.")
            }, 2));
        questionsType2.Add(new Question("Соседнее поселение просит о помощи - на них напали бандиты",
            new Choice[]
            {
                new Choice("Отказать, наши люди важнее", 0, -10, "Соседнее поселение раз разграблено дотла. Люди напуганы."),
                new Choice("Помочь, отправив отряд добровольцев", 5, 15, "Ваши воины прогнали бандитов. Соседи благодарны вам!"),
                new Choice("Предложить им убежище в вашем поселении", 20, 5, "Среди беженцев оказались хорошие ремесленники. Люди довольны!"),
                new Choice("Выторговать что-то ценное в обмен на помощь", -10, -20, "Соседи отказались от такой сделки и прогнали ваших посланников. Люди возмущены!")
            }, 2));

        // --- Вопросы для населения от 500 до 1500 ---
        questionsType3.Add(new Question("Жители жалуются, что вода слишком грязная и от неё смердит трупами",
            new Choice[]
            {
                new Choice("Построить очистные сооружения", -253, -10, "Пока длилась стройка люди гибли от грязной воды."),
                new Choice("Выяснить причину загрязнения и устранить", 154, 50, "Вы отправили группу людей на поиски и обнаружили причину, чистая вода привлекла людей из других поселений."),
                new Choice("Демонстративно выпить её самому, возразив что она грязная!", -98, 30, "Вы насмешили народ. Но и погубили."),
                new Choice("Позвать на помощь людей из других поселений", 251, 50, "Проблемы была решена! Людям из других поселений понравилось ваше и они решили остаться.")
            }, 3));
        questionsType3.Add(new Question("В поселении назревает бунт. Группа жителей недовольна вашим правлением. Ваши действия?",
            new Choice[]
            {
                new Choice("Подавить бунт силой!", -100, -50, "Кровь пролилась рекой. Вы жестоко расправились с бунтовщиками, но люди напуганы."),
                new Choice("Выслушать требования бунтовщиков и попытаться договориться", 50, 25, "Вам удалось мирно уладить конфликт и удовлетворить требования бунтовщиков."),
                new Choice("Проигнорировать бунт, он сам собой рассосется", -200, -75, "Бунт разросся с невероятной скоростью. Вас свергли и изгнали из поселения."),
                new Choice("Тайно избавиться от главарей бунта", -50, -25, "Вам удалось устранить главарей, но это не решило проблему. Бунт продолжается.")
            }, 3));
        questionsType3.Add(new Question("К вам прибывает группа торговцев из далекого города. Что делать?",
            new Choice[]
            {
                new Choice("Прогнать чужаков, нам не нужна их помощь", -50, -25, "Торговцы предлагали ценные товары и информацию. Люди недовольны вашим решением."),
                new Choice("Начать торговлю с ними", 100, 50, "Вы заключили выгодную сделку! Поселение процветает."),
                new Choice("Ограбить караван", -200, -100, "Вести о вашем поступке быстро разлетелись. Теперь на вас объявлена награда."),
                new Choice("Арестовать торговцев и конфисковать их товары", -150, -75, "Торговцы оказались под защитой могущественной гильдии. Вас ждут неприятности.")
            }, 3));

        // --- Вопросы для населения от 1500 до 5000 ---
        questionsType4.Add(new Question("В поселении развивается странная болезнь, которая убивает за считаные часы",
            new Choice[]
            {
                new Choice("Заразить соседнее поселение", -821, -32, "Вы чуть не погубили себя и других выживших."),
                new Choice("Карантин и полная изоляция больных", -373, 23, "Вам удалось победить болезнь. Все больные умерли, но новых заражённых нет."),
                new Choice("Отправить врачей к больным", -426, -27, "Врачи лишь развели руками. Через несколько недель погибли сотни..."),
                new Choice("Найти лекарство", 950, 50, "Ваши медики нашли лекарство! К вам потянулись люди из других поселений.")
            }, 4));
        questionsType4.Add(new Question("Ваши разведчики обнаружили древний храм, полный сокровищ. Ваши действия?",
            new Choice[]
            {
                new Choice("Отправить экспедицию за сокровищами", -200, -50, "Храм оказался ловушкой. Многие погибли."),
                new Choice("Игнорировать находку, это слишком опасно", 0, 25, "Возможно, это было мудрое решение. Люди ценят вашу осторожность."),
                new Choice("Провести ритуал в храме, чтобы задобрить духов", 300, 100, "Духи даровали вам свою благосклонность! Поселение процветает."),
                new Choice("Разграбить храм и осквернить святыни", -500, -200, "На поселение обрушилось проклятие. Люди в ужасе.")
            }, 4));
        questionsType4.Add(new Question("Представители могущественной гильдии предлагают вам заключить союз. Что ответите?",
            new Choice[]
            {
                new Choice("Отказать им, мы никому не подчиняемся!", -100, 50, "Гильдия не потерпит неуважения. Отношения испорчены."),
                new Choice("Согласиться на союз, это выгодно для нас", 200, 100, "Союз с гильдией принес свои плоды! Поселение процветает."),
                new Choice("Попытаться обмануть гильдию", -300, -100, "Вас раскрыли! Гильдия объявила вам войну."),
                new Choice("Попросить время на размышления", 0, -25, "Гильдия не любит ждать.  Вы упустили свой шанс.")
            }, 4));

        // --- Вопросы для населения от 5000 до 10000 ---
        questionsType5.Add(new Question("Мэр соседнего поселения поменьше предложил вам объедениться",
            new Choice[]
            {
                new Choice("Отказать", -263, 50, "Объеденение для него было лишь предлогом захвата. В войне вы понесли минимальные потери."),
                new Choice("Согласиться", -2626, -30, "Объеденение для него было лишь предлогом захвата. Битву вы победили, но с огромными потерями."),
                new Choice("Отправить шпиона выяснить все детали", 1326, 60, "Объеденение для него было лишь предлогом захвата. Подняв шумиху вы переманили всех жителей его поселения."),
                new Choice("Заказать его убийство", 0, -30, "Жители не понимают вашего решения! Однако, ходят слухи о том, что у него были коварные планы...")
            }, 5));
        questionsType5.Add(new Question("Обнаружены следы древней цивилизации. Что делать?",
            new Choice[]
            {
                new Choice("Начать раскопки и изучать находки", 500, 100, "Вы обнаружили ценные технологии! Поселение процветает."),
                new Choice("Оставить все как есть, это не наше дело", 0, 25, "Возможно, это было мудрое решение. Люди доверяют вам."),
                new Choice("Продать информацию о находке", 1000, -50, "Покупатель оказался мошенником. Вы потеряли деньги и репутацию."),
                new Choice("Уничтожить все следы, это может быть опасно", -250, -100, "Вы уничтожили ценные артефакты. Люди в ярости!")
            }, 5));
        questionsType5.Add(new Question("На ваши земли претендует группа кочевников. Что делать?",
            new Choice[]
            {
                new Choice("Дать отпор силой!", -500, -100, "Битва была долгой и кровопролитной.  Многие погибли."),
                new Choice("Попытаться договориться мирным путем", 250, 100, "Вам удалось заключить мирный договор с кочевниками."),
                new Choice("Откупиться от кочевников", -250, -50, "Кочевники взяли деньги и все равно напали на вас.  "),
                new Choice("Обратиться за помощью к союзникам", 0, 50, "Союзники не спешат вам на помощь. Кочевники разоряют ваши земли.")
            }, 5));

}

    public Question GetCurrentQuestion()
    {
        List<Question> currentQuestions = GetCurrentQuestionList();

        // Если в текущем типе вопросов больше нет, переходим к следующему
        while (currentQuestions.Count == 0 && currentQuestionType < 5)
        {
            currentQuestionType++;
            currentQuestions = GetCurrentQuestionList();
        }

        if (currentQuestions.Count == 0)
        {
            return new Question(null, null, 0); // Возвращаем пустой вопрос, если вопросов нет
        }

        int randomIndex = Random.Range(0, currentQuestions.Count);
        return currentQuestions[randomIndex];
    }

    // Получение списка вопросов в зависимости от текущего типа
    private List<Question> GetCurrentQuestionList()
    {
        switch (currentQuestionType)
        {
            case 1:
                return questionsType1;
            case 2:
                return questionsType2;
            case 3:
                return questionsType3;
            case 4:
                return questionsType4;
            case 5:
                return questionsType5;
            default:
                return questionsType1; // По умолчанию возвращаем первый тип
        }
    }

    public Choice MakeChoice(int index, Question currentQuestion)
    {
        Choice choice = currentQuestion.choices[index];

        // Удаляем вопрос из списка
        GetCurrentQuestionList().Remove(currentQuestion);

        return choice;
    }
}

Это скрипты моей квестовой игры на движке Unity. Её смысл в том, что игрок является мэром одного из оставшихся
в выживших поселений и ему нужно следить за раличными показателями его населения и принимать важные решения влияющие
на ресурсы поселения и само поселение.
Твоя задача помочь мне с реализацией следующей задумки управления поселением, создания возможности строить и улучшать постройку,
которая потом будет приносить различные ресурсы. Тебе нужно сделать это в новой панели (SettlementManagementPanel), которая
открывается на кнопку, кнопка находится внутри Canvas главной сцены.
Задумка:
У игрока есть кнопка на главном экране игры "Управление поселением", когда он нажимает на неё, то ему открывается
panel, на этой панели  изображена карта (в виде image на panel) на ней размещён image у этого image, есть следующая логика:

Здание (картинка): Жилые постройки - приносят игроку прирост к населению.
	1.1 Постройка этой постройки стоит 10 стройматериалов. А дальше уже срабатывает логика улучшения (такая же и для последующих построек). После постройки любая постройка становится 1 уровня.
	1.2 Улучшение постройки на 2 уровень стоит 20 стройматериалов. 
	1.3 Улучшение постройки на 3 уровень стоит 50 стройматериалов.
Профит от "Жилые постройки":
	1.4 Постройка "Жилые постройки" на 1 уровне приносит каждые 7 минут +5 населения.
	1.5 Если улучшить постройку на 2 уровень, тогда каждые 5 минут +10 населения, 
	1.6 Если улучшить постройку на 3 (максимальный) уровень, то каждые 3 минуты +25 населения.

Например игрок нажимает на панели SettlementManagementPanel на картинку "Жилые постройки" или пустой квадратик и ему вылазит лист-меню со следующим
содержимым: 
1. Построить (если квадратик пустой) 
2. Улучшить (если постройка уже построена)
3. Информация (выводит на экран информацию о том, какой прирост ресурса постройка будет давать)

Конечно же, с каждым уровнем постройки кратинка меняется. ЭТО ДОЛЖНА БЫТЬ КАРТИНКА, НЕ СПРАЙТЫ!!
Помоги мне полностью проработать эту логику, разработай её и пошагово объясни как реализовать, как профессианальный
разработчик игр.