765 lines
41 KiB
C#
765 lines
41 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
using TMPro;
|
||
using UnityEngine;
|
||
using UnityEngine.UI;
|
||
|
||
// Окно здания. Открывается тапом по зданию (подписей над зданиями больше нет -- всё здесь).
|
||
// У каждого здания своё окно:
|
||
// - добывающее (Лесопилка, Ферма, Каменоломня, Шахта, Рудник): рабочие этой профессии и кнопки "−" / "+",
|
||
// добыча в час, сколько ресурса на складе и когда склад заполнится, что даст улучшение и его цена;
|
||
// - Склад и Амбар: запас / лимит по их ресурсам, что даст улучшение и цена;
|
||
// - Дом: сколько жилья даёт, население / предел, улучшение и цена;
|
||
// - Ратуша: жильё, резерв для найма, что откроется на следующем уровне, цена улучшения;
|
||
// - Кристалл: где добывается, запас / лимит;
|
||
// - Казармы: очередь обучения, какие войска открыты и что нужно для остальных, улучшение (открывает войска),
|
||
// кнопка "Нанять войска" (панель "Войска").
|
||
// - Стройка и улучшение идут по времени (BuildTimer, 01.11, ТЕСТ): полоска, сколько осталось, ускорение за кристаллы.
|
||
// Пока здание строится, в окне только стройка; при улучшении здание работает на старом уровне.
|
||
// - У построенных зданий (кроме Ратуши) -- кнопка "Перенести" (бесплатно, уровень и стройка сохраняются). Сноса нет (04.11).
|
||
// Без здания (кнопка "Рабочие" в панели DEV и "Все рабочие" в окне) -- список рабочих по всем профессиям.
|
||
// Окно -- только интерфейс: рабочих ставит модуль Населения, добычу считает модуль Экономики.
|
||
// Пока окно открыто, цифры обновляются сами (раз в полсекунды).
|
||
public static class BuildingWindow
|
||
{
|
||
static GameObject root;
|
||
static GameObject focus; // здание, по которому тапнули (null -- список рабочих)
|
||
static readonly List<Action> live = new List<Action>(); // что обновлять, пока окно открыто
|
||
|
||
public static void OnWorkplaceTapped(ResourceCollector building) { Open(building != null ? building.gameObject : null); }
|
||
public static void OnStorageTapped(StorageBuilding building) { Open(building != null ? building.gameObject : null); }
|
||
public static void OnTownHallTapped(TownHall townHall) { Open(townHall != null ? townHall.gameObject : null); }
|
||
|
||
public static void Open(GameObject building)
|
||
{
|
||
// В режиме стройки тап -- это выбор места, а не здания
|
||
if (BuildModeController.Instance != null && BuildModeController.Instance.IsActive) return;
|
||
focus = building;
|
||
Rebuild();
|
||
}
|
||
|
||
public static void Close()
|
||
{
|
||
if (root != null) UnityEngine.Object.Destroy(root);
|
||
root = null;
|
||
focus = null;
|
||
live.Clear();
|
||
}
|
||
|
||
static void Rebuild()
|
||
{
|
||
if (root != null) UnityEngine.Object.Destroy(root);
|
||
live.Clear();
|
||
var modal = UIKit.Modal(TitleFor(focus), out root);
|
||
root.AddComponent<BuildingWindowTicker>();
|
||
var card = ScrollBody(modal); // длинное окно прокручивается, "Закрыть" всегда видна внизу (05.11)
|
||
|
||
var rc = focus != null ? focus.GetComponent<ResourceCollector>() : null;
|
||
var storage = focus != null ? focus.GetComponent<StorageBuilding>() : null;
|
||
var townHall = focus != null ? focus.GetComponent<TownHall>() : null;
|
||
var barracks = focus != null ? focus.GetComponent<Barracks>() : null;
|
||
var hospital = focus != null ? focus.GetComponent<Hospital>() : null;
|
||
var heroCastle = focus != null ? focus.GetComponent<HeroCastle>() : null;
|
||
|
||
bool constructing = focus != null && BuildTimer.IsConstructing(focus.transform);
|
||
if (focus != null) TimerBlock(card, focus);
|
||
|
||
if (focus == null) WorkersList(card);
|
||
else if (constructing) UIKit.Text(card, "Пока здание строится, оно не работает.", 22, UIKit.Theme.TextDim, TextAlignmentOptions.Center);
|
||
else if (townHall != null) TownHallSection(card, townHall);
|
||
else if (barracks != null) BarracksSection(card, barracks);
|
||
else if (hospital != null) HospitalSection(card, hospital);
|
||
else if (heroCastle != null) HeroCastleSection(card);
|
||
else if (rc != null && rc.IsWorkplace) WorkplaceSection(card, rc);
|
||
else if (rc != null && rc.IsHouse) HouseSection(card, rc);
|
||
else if (rc != null && rc.resourceType == ResourceType.Gems) CrystalSection(card);
|
||
else if (storage != null) StorageSection(card, storage);
|
||
|
||
if (focus != null) ActionsBlock(card, focus);
|
||
UIKit.Button(modal, "Закрыть", UIKit.Theme.Gray, Close, -1, 80, 28);
|
||
}
|
||
|
||
// Окно не выше экрана: заголовок сверху, содержимое прокручивается, кнопка "Закрыть" -- внизу, вне прокрутки.
|
||
// Закрыть можно и тапом по затемнению вокруг окна, и кнопкой "Назад" (Escape).
|
||
static RectTransform ScrollBody(RectTransform modal)
|
||
{
|
||
var fit = modal.GetComponent<ContentSizeFitter>();
|
||
if (fit != null) UnityEngine.Object.DestroyImmediate(fit);
|
||
modal.anchorMin = new Vector2(0.06f, 0.05f);
|
||
modal.anchorMax = new Vector2(0.94f, 0.95f);
|
||
modal.offsetMin = Vector2.zero;
|
||
modal.offsetMax = Vector2.zero;
|
||
|
||
var dim = root.GetComponent<Image>();
|
||
if (dim != null)
|
||
{
|
||
var outside = root.AddComponent<Button>();
|
||
outside.transition = Selectable.Transition.None;
|
||
outside.onClick.AddListener(Close);
|
||
}
|
||
|
||
var holder = UIKit.Make("Body", modal);
|
||
UIKit.Size(holder, -1, -1).flexibleHeight = 1;
|
||
ScrollRect scroll;
|
||
return UIKit.ScrollList(holder, out scroll, 14);
|
||
}
|
||
|
||
// Стройка закончилась (BuildTimer.Completed): окно этого здания показывает новый уровень
|
||
internal static void OnBuildCompleted(BuildTimer timer)
|
||
{
|
||
if (root != null && timer != null && focus == timer.gameObject) Rebuild();
|
||
}
|
||
|
||
internal static void Tick()
|
||
{
|
||
if (root == null) return;
|
||
if (focus == null && FocusWasDestroyed) { Close(); return; }
|
||
foreach (var update in live) update();
|
||
}
|
||
|
||
static bool focusSet;
|
||
static bool FocusWasDestroyed => focusSet && focus == null;
|
||
|
||
static string TitleFor(GameObject building)
|
||
{
|
||
focusSet = building != null;
|
||
if (building == null) return "РАБОЧИЕ";
|
||
var townHall = building.GetComponent<TownHall>();
|
||
if (townHall != null) return $"РАТУША — {townHall.currentLevel} УР.";
|
||
var id = building.GetComponent<PlacedBuildingId>();
|
||
var leveled = building.GetComponent<ILeveledBuilding>();
|
||
string name = id != null && !string.IsNullOrEmpty(id.buildingName) ? id.buildingName : building.name;
|
||
return leveled != null ? $"{name.ToUpper()} — {leveled.Level} УР." : name.ToUpper();
|
||
}
|
||
|
||
// ---------------- Добывающее здание ----------------
|
||
|
||
static void WorkplaceSection(RectTransform card, ResourceCollector rc)
|
||
{
|
||
if (!WorkJobs.TryFromResource(rc.resourceType, out WorkJob job)) return;
|
||
var production = GameModules.Production;
|
||
if (production == null || !GameServices.TryGet(out IPopulation population) || !GameServices.TryGet(out IEconomy economy))
|
||
{
|
||
UIKit.Text(card, "Модули Населения и Экономики не подключены", 26, UIKit.Theme.Red, TextAlignmentOptions.Center);
|
||
return;
|
||
}
|
||
ResourceType res = WorkJobs.Resource(job);
|
||
string resName = GameData.ResName(res).ToLower();
|
||
double norm = production.Rules.PerWorkerPerHour[(int)job];
|
||
|
||
// Что даёт это здание
|
||
int slots = production.BuildingSlots(rc.level);
|
||
double eff = production.BuildingEfficiency(rc.level);
|
||
UIKit.Text(card, $"Здание даёт {slots} мест, норма ×{eff:0.##} — до {slots * norm * eff:0.#} {resName} в час при полном штате.",
|
||
24, UIKit.Theme.TextDim, TextAlignmentOptions.Center);
|
||
|
||
// Рабочие профессии и кнопки
|
||
Header(card, $"Рабочие: {WorkJobs.Name(job).ToLower()}");
|
||
Live(card, () => $"{population.GetWorkers(job)} / {production.Slots(job)} мест в городе • свободных жителей: {population.FreeWorkers}",
|
||
26, UIKit.Theme.Text);
|
||
var row = UIKit.Row(card, 72, 8);
|
||
StepButton(row, "−5", job, -5);
|
||
StepButton(row, "−1", job, -1);
|
||
StepButton(row, "+1", job, +1);
|
||
StepButton(row, "+5", job, +5);
|
||
|
||
// Добыча и склад
|
||
Header(card, "Добыча и склад");
|
||
Live(card, () =>
|
||
{
|
||
float rate = production.RatePerHour(res);
|
||
string famine = population.IsStarving ? " <color=#ff7a7a>голод: добыча ×0.5</color>" : "";
|
||
return $"Сейчас: <color=#9be29b>+{rate:0.#} {resName} в час</color>{famine}";
|
||
}, 26, UIKit.Theme.Text);
|
||
StorageBar(card, economy, res);
|
||
Live(card, () => FillTimeText(economy, res, production.RatePerHour(res)), 22, UIKit.Theme.TextDim);
|
||
|
||
// Улучшение
|
||
int nextSlots = production.BuildingSlots(rc.level + 1);
|
||
double nextEff = production.BuildingEfficiency(rc.level + 1);
|
||
UpgradeBlock(card, rc.level,
|
||
$"мест {slots} → {nextSlots}, норма ×{eff:0.##} → ×{nextEff:0.##}",
|
||
() => rc.Level = rc.level + 1);
|
||
|
||
UIKit.Button(card, "Все рабочие", UIKit.Theme.Blue, () => Open(null), -1, 70, 24);
|
||
}
|
||
|
||
// ---------------- Дом ----------------
|
||
|
||
static void HouseSection(RectTransform card, ResourceCollector house)
|
||
{
|
||
int perLevel = EconomyConfig.Load().population.housingPerHouseLevel;
|
||
UIKit.Text(card, $"Дом даёт +{perLevel * house.level} к пределу жилья (+{perLevel} за уровень).", 24, UIKit.Theme.TextDim, TextAlignmentOptions.Center);
|
||
if (GameServices.TryGet(out IPopulation population))
|
||
{
|
||
Header(card, "Население");
|
||
LiveBar(card, () => population.HousingCap > 0 ? (float)population.Total / population.HousingCap : 0f,
|
||
() => $"{population.Total} / {population.HousingCap} человек", UIKit.Theme.Blue);
|
||
Live(card, () => population.Total >= population.HousingCap
|
||
? "Предел жилья: прирост стоит, нужны Дома или Ратуша выше"
|
||
: $"Прирост: +{population.GrowthPerHour:0.#} человека в час", 22, UIKit.Theme.TextDim);
|
||
}
|
||
UpgradeBlock(card, house.level, $"жильё +{perLevel * house.level} → +{perLevel * (house.level + 1)}", () => house.Level = house.level + 1);
|
||
}
|
||
|
||
// ---------------- Кристалл ----------------
|
||
|
||
static void CrystalSection(RectTransform card)
|
||
{
|
||
UIKit.Text(card, "Синий кристалл добывается в кристальных разломах на карте мира. Здание не улучшается.", 24, UIKit.Theme.TextDim, TextAlignmentOptions.Center);
|
||
if (GameServices.TryGet(out IEconomy economy)) StorageBar(card, economy, ResourceType.Gems);
|
||
}
|
||
|
||
// ---------------- Склад и Амбар ----------------
|
||
|
||
static void StorageSection(RectTransform card, StorageBuilding storage)
|
||
{
|
||
var s = EconomyConfig.Load().storage;
|
||
bool warehouse = storage.kind == StorageBuilding.Kind.Warehouse;
|
||
float perLevel = warehouse ? s.perWarehouseLevel : s.perGranaryLevel;
|
||
UIKit.Text(card, warehouse
|
||
? $"Склад даёт +{perLevel * storage.level:0} к лимиту дерева, камня, металла и золота."
|
||
: $"Амбар даёт +{perLevel * storage.level:0} к лимиту еды.",
|
||
24, UIKit.Theme.TextDim, TextAlignmentOptions.Center);
|
||
|
||
if (GameServices.TryGet(out IEconomy economy))
|
||
{
|
||
Header(card, "Запас / лимит");
|
||
if (warehouse)
|
||
{
|
||
StorageBar(card, economy, ResourceType.Wood);
|
||
StorageBar(card, economy, ResourceType.Stone);
|
||
StorageBar(card, economy, ResourceType.Iron);
|
||
StorageBar(card, economy, ResourceType.Gold);
|
||
}
|
||
else StorageBar(card, economy, ResourceType.Food);
|
||
UIKit.Text(card, "Сверх лимита ресурс не прибавляется — пропадает.", 22, UIKit.Theme.TextDim, TextAlignmentOptions.Center);
|
||
|
||
if (GameServices.TryGet(out IResourceProtection protection))
|
||
{
|
||
Header(card, "Защита от грабежа");
|
||
var p = EconomyConfig.Load().protection;
|
||
ResourceType[] kinds = warehouse
|
||
? new[] { ResourceType.Wood, ResourceType.Stone, ResourceType.Iron, ResourceType.Gold }
|
||
: new[] { ResourceType.Food };
|
||
Live(card, () =>
|
||
{
|
||
var lines = new List<string>();
|
||
foreach (var k in kinds)
|
||
lines.Add($"{GameData.ResName(k)}: спрятано {protection.Protected(k):0}, можно унести {protection.Lootable(k):0}");
|
||
return string.Join("\n", lines.ToArray());
|
||
}, 22, UIKit.Theme.Text);
|
||
UIKit.Text(card, warehouse
|
||
? $"Каждый уровень Склада прячет ещё {p.perWarehouseLevel:0} каждого ресурса — в набеге их не унесут."
|
||
: $"Каждый уровень Амбара прячет ещё {p.perGranaryLevel:0} еды — в набеге её не унесут.",
|
||
22, UIKit.Theme.TextDim, TextAlignmentOptions.Center);
|
||
}
|
||
}
|
||
|
||
UpgradeBlock(card, storage.level, $"лимит +{perLevel * storage.level:0} → +{perLevel * (storage.level + 1):0}",
|
||
() => storage.Level = storage.level + 1);
|
||
}
|
||
|
||
// ---------------- Ратуша ----------------
|
||
|
||
static void TownHallSection(RectTransform card, TownHall townHall)
|
||
{
|
||
var config = EconomyConfig.Load();
|
||
int level = townHall.currentLevel;
|
||
int next = level + 1;
|
||
var p = config.population;
|
||
|
||
UIKit.Text(card, $"Ратуша даёт {p.housingBase + p.housingPerTownHallLevel * (level - 1)} мест жилья. От её уровня зависят резерв для найма и доступные здания и войска.",
|
||
24, UIKit.Theme.TextDim, TextAlignmentOptions.Center);
|
||
|
||
if (GameServices.TryGet(out IPopulation population))
|
||
{
|
||
Header(card, "Город");
|
||
LiveBar(card, () => population.HousingCap > 0 ? (float)population.Total / population.HousingCap : 0f,
|
||
() => $"Население {population.Total} / {population.HousingCap}", UIKit.Theme.Blue);
|
||
Live(card, () => $"Жителей {population.Civilians}: рабочих {population.Workers}, свободных {population.Idle} • воинов {population.Soldiers}",
|
||
22, UIKit.Theme.TextDim);
|
||
Live(card, () => $"Резерв для найма: {population.CivilianReserve} • можно нанять: {population.Recruitable}", 22, UIKit.Theme.TextDim);
|
||
}
|
||
|
||
if (level >= townHall.maxLevel)
|
||
{
|
||
UIKit.Text(card, "Максимальный уровень", 26, UIKit.Theme.Gold, TextAlignmentOptions.Center);
|
||
return;
|
||
}
|
||
|
||
// Что даст следующий уровень
|
||
Header(card, $"Уровень {next}");
|
||
var gains = new List<string> { $"жильё +{p.housingPerTownHallLevel}" };
|
||
int nowReserve = ReserveAt(level), nextReserve = ReserveAt(next);
|
||
if (nextReserve != nowReserve) gains.Add($"резерв для найма {nowReserve} → {nextReserve}");
|
||
UIKit.Text(card, string.Join(", ", gains.ToArray()), 24, UIKit.Theme.Text, TextAlignmentOptions.Center);
|
||
string unlocks = UnlocksAt(next);
|
||
if (unlocks.Length > 0) UIKit.Text(card, "Откроется: " + unlocks, 24, UIKit.Theme.Gold, TextAlignmentOptions.Center);
|
||
|
||
string more = MoreBuildingsAt(level, next);
|
||
if (more.Length > 0) UIKit.Text(card, "Больше зданий: " + more, 22, UIKit.Theme.TextDim, TextAlignmentOptions.Center);
|
||
if (TimerRunning(townHall.gameObject)) return; // улучшение уже идёт -- полоска сверху
|
||
|
||
var cost = BuildingData.ToAmounts(townHall.GetUpgradeCost());
|
||
UIKit.Text(card, "Цена: " + CostText(cost), 24, UIKit.Theme.Text, TextAlignmentOptions.Center);
|
||
long ms = config.ConstructionMs(true, next);
|
||
TimeText(card, ms);
|
||
bool canPay = townHall.CanUpgrade();
|
||
var b = UIKit.Button(card, $"Улучшить до {next} ур.", canPay ? UIKit.Theme.Green : UIKit.Theme.Gray, () =>
|
||
{
|
||
if (!townHall.CanUpgrade()) { UIKit.Toast("Не хватает ресурсов"); return; }
|
||
if (ms > 0 && BuildTimer.FreeBuilders == 0) { UIKit.Toast("Все строители заняты"); return; }
|
||
if (!GameServices.TryGet(out IEconomy e) || !e.TrySpend(cost)) { UIKit.Toast("Не хватает ресурсов"); return; }
|
||
if (ms <= 0) BuildTimer.Begin(townHall.gameObject, BuildTimer.Kind.Upgrade, next, 0, 0).Complete();
|
||
else
|
||
{
|
||
long now = GameClock.UnixNowMs;
|
||
BuildTimer.Begin(townHall.gameObject, BuildTimer.Kind.Upgrade, next, now, now + ms);
|
||
UIKit.Toast($"Ратуша улучшается до {next} уровня");
|
||
}
|
||
Rebuild();
|
||
}, -1, 80, 26);
|
||
LiveAfford(b, canPay, () => townHall != null && townHall.CanUpgrade());
|
||
}
|
||
|
||
// Каких зданий на следующем уровне Ратуши можно построить больше: "Лес 2 → 3, Дом 3 → 4"
|
||
static string MoreBuildingsAt(int level, int next)
|
||
{
|
||
var config = EconomyConfig.Load();
|
||
var parts = new List<string>();
|
||
if (config.buildingLimits != null)
|
||
foreach (var l in config.buildingLimits)
|
||
{
|
||
if (l == null) continue;
|
||
int a = config.BuildingLimitFor(l.buildingName, level), b = config.BuildingLimitFor(l.buildingName, next);
|
||
if (b > a) parts.Add($"{l.buildingName} {a} → {b}");
|
||
}
|
||
return string.Join(", ", parts.ToArray());
|
||
}
|
||
|
||
// ---------------- Казармы ----------------
|
||
|
||
static void BarracksSection(RectTransform card, Barracks barracks)
|
||
{
|
||
var gp = GameProgress.Instance;
|
||
UIKit.Text(card, $"Казармы обучают войска. Казарм в городе: {Barracks.Count}, мест в очереди: {Barracks.QueueSize}. " +
|
||
$"Новые войска открывает уровень самых прокачанных Казарм ({Barracks.MaxLevel} ур.) вместе с уровнем Ратуши.",
|
||
24, UIKit.Theme.TextDim, TextAlignmentOptions.Center);
|
||
|
||
if (gp != null)
|
||
{
|
||
Header(card, "Обучение");
|
||
Live(card, () =>
|
||
{
|
||
var training = gp.Training;
|
||
if (training.Count == 0) return "Никто не обучается";
|
||
var o = training[0];
|
||
string more = training.Count > 1 ? $" (ещё заказов: {training.Count - 1})" : "";
|
||
return $"{GameData.Troops[o.Type].name} ×{o.Count} — осталось {GameData.FormatTime(gp.TrainingSecondsLeft(o))}{more}";
|
||
}, 24, UIKit.Theme.Text);
|
||
if (GameServices.TryGet(out IPopulation population))
|
||
Live(card, () => $"Можно нанять из жителей: {population.Recruitable} • в Казармах: {population.InTraining}", 22, UIKit.Theme.TextDim);
|
||
|
||
Header(card, "Войска");
|
||
for (int i = 0; i < GameData.Troops.Count; i++)
|
||
{
|
||
string lockText = gp.TroopLockText(i);
|
||
UIKit.Text(card, lockText.Length == 0
|
||
? $"<color=#9be59b>{GameData.Troops[i].name} — открыты</color>"
|
||
: $"{GameData.Troops[i].name} — нужно: {lockText}",
|
||
24, lockText.Length == 0 ? UIKit.Theme.Text : UIKit.Theme.Gold, TextAlignmentOptions.Center);
|
||
}
|
||
}
|
||
|
||
// Что откроет следующий уровень этих Казарм
|
||
var opens = new List<string>();
|
||
if (gp != null)
|
||
for (int i = 0; i < GameData.Troops.Count; i++)
|
||
if (gp.RequiredBarracksLevel(i) == barracks.level + 1 && Barracks.MaxLevel <= barracks.level) opens.Add(GameData.Troops[i].name);
|
||
string effect = opens.Count > 0
|
||
? $"откроются: {string.Join(", ", opens.ToArray())} (если хватает уровня Ратуши)"
|
||
: "ближе к новым войскам";
|
||
UpgradeBlock(card, barracks.level, effect, () => barracks.Level = barracks.level + 1);
|
||
|
||
UIKit.Button(card, "Нанять войска", UIKit.Theme.Blue, () =>
|
||
{
|
||
Close();
|
||
if (UIPanelManager.Instance != null) UIPanelManager.Instance.Open("Troops");
|
||
}, -1, 80, 26);
|
||
}
|
||
|
||
// ---------------- Госпиталь (решения 31.10, п. 7) ----------------
|
||
|
||
static void HospitalSection(RectTransform card, Hospital hospital)
|
||
{
|
||
UIKit.Text(card, $"Госпиталь лечит раненых после боёв. Мест: {Hospital.BedsAt(Hospital.MaxLevel)} " +
|
||
"(считается самый прокачанный госпиталь). Кто не поместился -- ждёт места.",
|
||
24, UIKit.Theme.TextDim, TextAlignmentOptions.Center);
|
||
|
||
if (GameServices.TryGet(out IArmy army))
|
||
{
|
||
Header(card, "Раненые");
|
||
Live(card, () =>
|
||
{
|
||
int healingNow = 0, waiting = 0;
|
||
long readyMs = long.MaxValue;
|
||
foreach (var h in army.Healing) { healingNow += h.Count; readyMs = Math.Min(readyMs, h.EndMs); }
|
||
for (int t = 0; t < army.TypeCount; t++) waiting += army.GetWoundedWaiting(t);
|
||
if (healingNow + waiting == 0) return "Раненых нет";
|
||
string next = readyMs != long.MaxValue
|
||
? $", ближайшие вылечатся через {GameData.FormatTime(Math.Max(0, readyMs - GameClock.UnixNowMs) / 1000.0)}"
|
||
: "";
|
||
return $"Лечатся {healingNow} из {army.HospitalBeds} мест, ждут места {waiting}{next}";
|
||
}, 24, UIKit.Theme.Text);
|
||
Live(card, () =>
|
||
{
|
||
var lines = new List<string>();
|
||
foreach (var h in army.Healing)
|
||
if (h.Type >= 0 && h.Type < GameData.Troops.Count)
|
||
lines.Add($"{GameData.Troops[h.Type].name} ×{h.Count} — {GameData.FormatTime(Math.Max(0, h.EndMs - GameClock.UnixNowMs) / 1000.0)}");
|
||
return lines.Count > 0 ? string.Join("\n", lines.ToArray()) : "";
|
||
}, 22, UIKit.Theme.TextDim);
|
||
var rules = HospitalConfig.Load().healGameHours;
|
||
UIKit.Text(card, $"Лечение одного воина: пехота и лучники {rules[0]}, кавалерия {rules[2]}, осадные {rules[3]} игровых ч " +
|
||
"(игровой час = 5 мин). Лечатся и пока игра закрыта.", 22, UIKit.Theme.TextDim, TextAlignmentOptions.Center);
|
||
}
|
||
|
||
UpgradeBlock(card, hospital.level, $"мест {Hospital.BedsAt(hospital.level)} → {Hospital.BedsAt(hospital.level + 1)}",
|
||
() => hospital.Level = hospital.level + 1, Hospital.MaxBuildLevel);
|
||
}
|
||
|
||
// ---------------- Терем богатыря: окно героя ----------------
|
||
// Числа героя -- те же, что в панели "Герой" (GameProgress / GameData), механика не меняется.
|
||
|
||
static void HeroCastleSection(RectTransform card)
|
||
{
|
||
var gp = GameProgress.Instance;
|
||
UIKit.Text(card, "В Тереме живёт богатырь -- верховный командир. Он гуляет по городу; тапните по нему, чтобы поговорить.",
|
||
24, UIKit.Theme.TextDim, TextAlignmentOptions.Center);
|
||
if (gp == null) return;
|
||
|
||
int lvl = gp.Data.heroLevel, maxLvl = gp.HeroMaxLevel;
|
||
var head = UIKit.Row(card, 140, 16);
|
||
UIKit.Icon(head, new Color(0.55f, 0.4f, 0.2f), "Б", 130); // место под портрет
|
||
var info = UIKit.Card(head, new Color(0, 0, 0, 0), 0, 4);
|
||
UIKit.Size(info, -1, -1, 1);
|
||
UIKit.Text(info, $"Уровень {lvl} / {maxLvl}", 30, UIKit.Theme.Gold).fontStyle = FontStyles.Bold;
|
||
UIKit.Text(info, $"Сила героя: {GameData.HeroPower(lvl)}", 24, UIKit.Theme.Text);
|
||
UIKit.Text(info, $"Бонус к силе армии: +{Mathf.RoundToInt(gp.ArmyBonus * 100)}%", 24, UIKit.Theme.Text);
|
||
|
||
Header(card, "Навыки");
|
||
for (int i = 0; i < GameData.HeroSkillNames.Length; i++)
|
||
{
|
||
bool has = gp.HasHeroSkill(i);
|
||
UIKit.Text(card, has ? $"<color=#9be59b>✓</color> {GameData.HeroSkillNames[i]}"
|
||
: $"{GameData.HeroSkillNames[i]} — с {GameData.HeroSkillLevels[i]} ур.",
|
||
22, has ? UIKit.Theme.Text : UIKit.Theme.TextDim);
|
||
}
|
||
|
||
Header(card, "Улучшение героя");
|
||
if (lvl >= maxLvl)
|
||
{
|
||
UIKit.Text(card, $"Предел уровня. Улучшите Ратушу до {gp.TownHallLevel + 1} ур., чтобы поднять предел до " +
|
||
$"{GameData.HeroMaxLevel(gp.TownHallLevel + 1)}.", 22, UIKit.Theme.TextDim, TextAlignmentOptions.Center);
|
||
}
|
||
else
|
||
{
|
||
var cost = GameData.HeroUpgradeCost(lvl);
|
||
Live(card, () =>
|
||
{
|
||
var parts = new List<string>();
|
||
foreach (var c in cost)
|
||
{
|
||
bool enough = gp.Res(c.type) >= c.amount;
|
||
parts.Add($"<color={(enough ? "#9be59b" : "#ff7a7a")}>{GameData.ResName(c.type)} {c.amount:N0}</color>");
|
||
}
|
||
return "Цена: " + string.Join(", ", parts.ToArray());
|
||
}, 22, UIKit.Theme.Text);
|
||
UIKit.Text(card, $"Дальше: сила {GameData.HeroPower(lvl)} → {GameData.HeroPower(lvl + 1)}, " +
|
||
$"бонус армии +{GameData.HeroArmyBonusPercent(lvl)}% → +{GameData.HeroArmyBonusPercent(lvl + 1)}%",
|
||
22, UIKit.Theme.TextDim, TextAlignmentOptions.Center);
|
||
var up = UIKit.Button(card, $"Улучшить до {lvl + 1} ур.", UIKit.Theme.Green, () =>
|
||
{
|
||
if (!gp.CanUpgradeHero) { UIKit.Toast("Не хватает ресурсов"); return; }
|
||
gp.UpgradeHero();
|
||
Rebuild();
|
||
}, -1, 80, 26);
|
||
live.Add(() => up.interactable = gp.CanUpgradeHero);
|
||
}
|
||
|
||
UIKit.Button(card, "Подробнее о герое", UIKit.Theme.Blue, () =>
|
||
{
|
||
Close();
|
||
if (UIPanelManager.Instance != null) UIPanelManager.Instance.Open("Hero");
|
||
}, -1, 80, 26);
|
||
}
|
||
|
||
// Резерв для найма на уровне Ратуши (те же числа, что у модуля Населения)
|
||
static int ReserveAt(int townHallLevel)
|
||
{
|
||
var table = GameModules.Population != null ? GameModules.Population.Rules.CivilianReserveByTownHallLevel : null;
|
||
if (table == null || table.Length == 0) return 0;
|
||
return table[Mathf.Clamp(townHallLevel, 1, table.Length) - 1];
|
||
}
|
||
|
||
// Здания и войска, которые открываются ровно на этом уровне Ратуши
|
||
static string UnlocksAt(int townHallLevel)
|
||
{
|
||
var names = new List<string>();
|
||
if (BuildManager.Instance != null && BuildManager.Instance.allBuildings != null)
|
||
foreach (var b in BuildManager.Instance.allBuildings)
|
||
if (b != null && b.requiredTownHallLevel == townHallLevel) names.Add(b.buildingName);
|
||
foreach (var t in GameData.Troops)
|
||
if (t.requiredTownHall == townHallLevel) names.Add(t.name);
|
||
return string.Join(", ", names.ToArray());
|
||
}
|
||
|
||
// ---------------- Улучшение (общее для зданий с уровнем, кроме Ратуши) ----------------
|
||
|
||
static void UpgradeBlock(RectTransform card, int level, string effect, Action raiseLevel, int maxLevel = 0)
|
||
{
|
||
var config = EconomyConfig.Load();
|
||
if (level >= (maxLevel > 0 ? maxLevel : config.upgrade.maxLevel)) // у госпиталя свой предел: I-V
|
||
{
|
||
UIKit.Text(card, "Максимальный уровень", 26, UIKit.Theme.Gold, TextAlignmentOptions.Center);
|
||
return;
|
||
}
|
||
Header(card, $"Улучшение до {level + 1} ур.");
|
||
UIKit.Text(card, effect, 24, UIKit.Theme.Text, TextAlignmentOptions.Center);
|
||
if (focus != null && TimerRunning(focus)) return; // улучшение уже идёт -- полоска сверху
|
||
var cost = config.UpgradeCost(level);
|
||
UIKit.Text(card, "Цена: " + CostText(cost), 24, UIKit.Theme.Text, TextAlignmentOptions.Center);
|
||
long ms = config.ConstructionMs(false, level + 1);
|
||
TimeText(card, ms);
|
||
var building = focus;
|
||
|
||
bool canPay = GameServices.TryGet(out IEconomy economy) && economy.CanAfford(cost);
|
||
var b = UIKit.Button(card, $"Улучшить до {level + 1} ур.", canPay ? UIKit.Theme.Green : UIKit.Theme.Gray, () =>
|
||
{
|
||
bool timed = ms > 0 && building != null;
|
||
if (timed && BuildTimer.FreeBuilders == 0) { UIKit.Toast("Все строители заняты"); return; }
|
||
if (!GameServices.TryGet(out IEconomy e) || !e.TrySpend(cost)) { UIKit.Toast("Не хватает ресурсов"); return; }
|
||
if (timed)
|
||
{
|
||
long now = GameClock.UnixNowMs;
|
||
BuildTimer.Begin(building, BuildTimer.Kind.Upgrade, level + 1, now, now + ms);
|
||
UIKit.Toast($"Улучшение до {level + 1} уровня началось");
|
||
}
|
||
else
|
||
{
|
||
raiseLevel();
|
||
if (CitySync.Instance != null) CitySync.Instance.SyncNow();
|
||
UIKit.Toast($"Улучшено до {level + 1} уровня");
|
||
}
|
||
Rebuild();
|
||
}, -1, 80, 26);
|
||
LiveAfford(b, canPay, () => GameServices.TryGet(out IEconomy now) && now.CanAfford(cost));
|
||
}
|
||
|
||
// Кнопка «Улучшить» следит за ресурсами, пока окно открыто: ресурсов стало хватать -- зелёная и нажимается,
|
||
// перестало -- серая (05.11: раньше нужно было закрыть и открыть окно)
|
||
static void LiveAfford(Button b, bool canPay, Func<bool> can)
|
||
{
|
||
b.interactable = canPay;
|
||
bool shown = canPay;
|
||
live.Add(() =>
|
||
{
|
||
if (b == null) return;
|
||
bool c = can();
|
||
if (c == shown) return;
|
||
shown = c;
|
||
b.interactable = c;
|
||
var img = b.GetComponent<Image>();
|
||
if (img != null) img.color = c ? UIKit.Theme.Green : UIKit.Theme.Gray;
|
||
});
|
||
}
|
||
|
||
// ---------------- Стройка по времени (BuildTimer) ----------------
|
||
|
||
static bool TimerRunning(GameObject building)
|
||
{
|
||
var t = BuildTimer.Of(building);
|
||
return t != null && BuildTimer.All.Contains(t);
|
||
}
|
||
|
||
static void TimeText(RectTransform card, long ms)
|
||
{
|
||
if (ms <= 0) return;
|
||
Live(card, () => $"Время: {GameData.FormatTime(ms / 1000.0)} • строителей свободно: {BuildTimer.FreeBuilders} из {BuildTimer.Builders}",
|
||
22, UIKit.Theme.TextDim);
|
||
}
|
||
|
||
// Полоска стройки или улучшения, сколько осталось, ускорение за кристаллы
|
||
static void TimerBlock(RectTransform card, GameObject building)
|
||
{
|
||
var t = BuildTimer.Of(building);
|
||
if (t == null || !BuildTimer.All.Contains(t)) return;
|
||
Header(card, t.IsConstruction ? "Идёт стройка" : $"Идёт улучшение до {t.targetLevel} ур.");
|
||
var bar = UIKit.Bar(card, t.Progress, UIKit.Theme.Gold, 26);
|
||
live.Add(() => { if (t != null) UIKit.SetBar(bar, t.Progress); });
|
||
Live(card, () => t != null ? "Осталось " + GameData.FormatTime(t.SecondsLeft) : "Готово", 24, UIKit.Theme.Text);
|
||
|
||
int perGem = Mathf.Max(1, EconomyConfig.Load().construction.secondsPerGem);
|
||
Func<int> gems = () => t != null ? Mathf.Max(1, Mathf.CeilToInt((float)t.SecondsLeft / perGem)) : 0;
|
||
var speed = UIKit.Button(card, "", UIKit.Theme.Blue, () =>
|
||
{
|
||
if (t == null) return;
|
||
int price = gems();
|
||
if (!GameServices.TryGet(out IEconomy e) || !e.TrySpend(ResourceType.Gems, price))
|
||
{
|
||
UIKit.Toast($"Нужно {price} кристаллов");
|
||
return;
|
||
}
|
||
t.Complete(); // окно перестроит OnBuildCompleted
|
||
}, -1, 80, 26);
|
||
live.Add(() => { if (t != null) UIKit.SetButton(speed, $"Ускорить за {gems()} кристаллов", true); });
|
||
UIKit.SetButton(speed, $"Ускорить за {gems()} кристаллов", true);
|
||
}
|
||
|
||
// ---------------- Перенос (решения 04.11: сноса нет) ----------------
|
||
// Здание можно бесплатно переставить в пределах поселения: уровень, стройка или улучшение сохраняются.
|
||
// Снести здание и вернуть ресурсы нельзя -- такой кнопки нет.
|
||
|
||
static void ActionsBlock(RectTransform card, GameObject building)
|
||
{
|
||
var id = building.GetComponent<PlacedBuildingId>();
|
||
if (id == null || string.IsNullOrEmpty(id.buildingName)) return; // Ратуша и стартовые постройки сцены
|
||
UIKit.Button(card, "Перенести", UIKit.Theme.Blue, () =>
|
||
{
|
||
Close();
|
||
if (BuildModeController.Instance != null) BuildModeController.Instance.StartMove(building);
|
||
}, -1, 80, 26);
|
||
}
|
||
|
||
// Цена: чего хватает -- зелёным, чего нет -- красным, со сколько есть
|
||
static string CostText(ResourceAmount[] cost)
|
||
{
|
||
GameServices.TryGet(out IEconomy economy);
|
||
var parts = new string[cost.Length];
|
||
for (int i = 0; i < cost.Length; i++)
|
||
{
|
||
float have = economy != null ? economy.Get(cost[i].Type) : 0f;
|
||
bool ok = have >= cost[i].Amount;
|
||
string name = GameData.ResName(cost[i].Type).ToLower();
|
||
parts[i] = ok
|
||
? $"<color=#9be59b>{cost[i].Amount:0}</color> {name}"
|
||
: $"<color=#ff7a7a>{cost[i].Amount:0}</color> {name} (есть {have:0})";
|
||
}
|
||
return string.Join(", ", parts);
|
||
}
|
||
|
||
// ---------------- Склад: полоска и время до заполнения ----------------
|
||
|
||
static void StorageBar(RectTransform card, IEconomy economy, ResourceType res)
|
||
{
|
||
string name = GameData.ResName(res);
|
||
LiveBar(card, () =>
|
||
{
|
||
float cap = economy.GetCapacity(res);
|
||
return float.IsInfinity(cap) || cap <= 0 ? 0f : economy.Get(res) / cap;
|
||
},
|
||
() =>
|
||
{
|
||
float cap = economy.GetCapacity(res);
|
||
return float.IsInfinity(cap) ? $"{name}: {economy.Get(res):0}" : $"{name}: {economy.Get(res):0} / {cap:0}";
|
||
},
|
||
new Color(0.85f, 0.65f, 0.25f));
|
||
}
|
||
|
||
static string FillTimeText(IEconomy economy, ResourceType res, float ratePerHour)
|
||
{
|
||
float cap = economy.GetCapacity(res), have = economy.Get(res);
|
||
if (float.IsInfinity(cap)) return "";
|
||
if (have >= cap) return "<color=#ff7a7a>Склад полон — добыча пропадает. Улучшите Склад или Амбар.</color>";
|
||
if (ratePerHour <= 0) return "Добычи нет — поставьте рабочих";
|
||
float hours = (cap - have) / ratePerHour;
|
||
return hours < 1f ? $"Склад заполнится через {Mathf.CeilToInt(hours * 60)} мин" : $"Склад заполнится через {hours:0.#} ч";
|
||
}
|
||
|
||
// ---------------- Список рабочих по всем профессиям ----------------
|
||
|
||
static void WorkersList(RectTransform card)
|
||
{
|
||
if (!GameServices.TryGet(out IPopulation pop) || !GameServices.TryGet(out IProduction prod))
|
||
{
|
||
UIKit.Text(card, "Модули Населения и Экономики не подключены", 26, UIKit.Theme.Red, TextAlignmentOptions.Center);
|
||
return;
|
||
}
|
||
|
||
for (int j = 0; j < WorkJobs.Count; j++)
|
||
{
|
||
var job = (WorkJob)j;
|
||
var row = UIKit.Row(card, 72, 8);
|
||
var label = Live(row, () =>
|
||
{
|
||
int slots = prod.Slots(job);
|
||
if (slots <= 0) return $"{WorkJobs.Name(job)}: нет зданий";
|
||
return $"{WorkJobs.Name(job)}: {pop.GetWorkers(job)} / {slots} <color=#9be29b>+{prod.RatePerHour(WorkJobs.Resource(job)):0.#}/ч</color>";
|
||
}, 24, UIKit.Theme.Text);
|
||
label.enableAutoSizing = true; label.fontSizeMin = 14; label.fontSizeMax = 24;
|
||
label.alignment = TextAlignmentOptions.Left;
|
||
UIKit.Size(label, -1, 72, 1);
|
||
|
||
StepButton(row, "−5", job, -5);
|
||
StepButton(row, "−1", job, -1);
|
||
StepButton(row, "+1", job, +1);
|
||
StepButton(row, "+5", job, +5);
|
||
}
|
||
|
||
Live(card, () => $"Свободных жителей: <b>{pop.FreeWorkers}</b> из {pop.Civilians}", 24, UIKit.Theme.Gold);
|
||
}
|
||
|
||
// Кнопка "−" / "+": активна, только если есть кого снять или куда и кого поставить
|
||
static void StepButton(Transform row, string label, WorkJob job, int delta)
|
||
{
|
||
Button b = null;
|
||
b = UIKit.Button(row, label, delta > 0 ? UIKit.Theme.Blue : UIKit.Theme.Gray, () =>
|
||
{
|
||
if (GameServices.TryGet(out IPopulation pop)) pop.SetWorkers(job, pop.GetWorkers(job) + delta);
|
||
Tick();
|
||
}, 86, 64, 24);
|
||
live.Add(() =>
|
||
{
|
||
if (b == null || !GameServices.TryGet(out IPopulation pop) || !GameServices.TryGet(out IProduction prod)) return;
|
||
int workers = pop.GetWorkers(job), slots = prod.Slots(job);
|
||
b.interactable = delta < 0 ? workers > 0 : slots > workers && pop.FreeWorkers > 0;
|
||
});
|
||
}
|
||
|
||
// ---------------- Мелочи ----------------
|
||
|
||
static void Header(RectTransform card, string text)
|
||
{
|
||
UIKit.Text(card, text, 28, UIKit.Theme.Gold, TextAlignmentOptions.Center).fontStyle = FontStyles.Bold;
|
||
}
|
||
|
||
// Текст, который обновляется, пока окно открыто
|
||
static TextMeshProUGUI Live(Transform parent, Func<string> text, float size, Color color)
|
||
{
|
||
var t = UIKit.Text(parent, text(), size, color, TextAlignmentOptions.Center);
|
||
live.Add(() => { if (t != null) t.text = text(); });
|
||
return t;
|
||
}
|
||
|
||
static void LiveBar(RectTransform card, Func<float> fraction, Func<string> label, Color color)
|
||
{
|
||
var bar = UIKit.Bar(card, fraction(), color, 34, label());
|
||
live.Add(() => { if (bar != null) UIKit.SetBar(bar, fraction(), label()); });
|
||
}
|
||
}
|
||
|
||
// Обновляет открытое окно здания раз в полсекунды (добыча идёт, склад наполняется)
|
||
public class BuildingWindowTicker : MonoBehaviour
|
||
{
|
||
float next;
|
||
|
||
void Update()
|
||
{
|
||
if (Input.GetKeyDown(KeyCode.Escape)) { BuildingWindow.Close(); return; } // "Назад" на телефоне
|
||
if (Time.unscaledTime < next) return;
|
||
next = Time.unscaledTime + 0.5f;
|
||
BuildingWindow.Tick();
|
||
}
|
||
}
|