AlexanderandClaude Opus 5.5
af7150a006
- Мир: поход на армию (targetMarchId), точка перехвата по маршруту армии и скорости отряда, наблюдение рядом с ней, домой от места конца наблюдения; не догнать -- поход не начинается
- Разведка: ReconTargetKind.Army, ReconArmyGameHours {1, 2}; отчёт -- точный состав армии
- Карта: тап по чужой армии -- окно «ЧУЖАЯ АРМИЯ» с планом и кнопками «Разведка II / III»
- 4 теста
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
519 lines
28 KiB
C#
519 lines
28 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
using Bogatyri.World;
|
||
using UnityEngine;
|
||
|
||
// МОДУЛЬ ГЛОБАЛЬНОГО МИРА: карта и походы. Документ: Docs/Modules/World.md
|
||
// Живёт между сценами (создаётся сам при запуске игры), поэтому войско идёт и возвращается,
|
||
// даже пока игрок в городе.
|
||
//
|
||
// С другими модулями -- только через контракты и события:
|
||
// войска -> IArmy (забрать в поход, вернуть выживших)
|
||
// добыча -> IEconomy
|
||
// бой -> IBattleSystem (передаётся в WorldSimulation)
|
||
// сохранение -> сам ISaveParticipant, секция "world"
|
||
// наружу -> MarchStartedEvent, MarchBattleResolvedEvent, MarchReturnedEvent
|
||
// разведка -> сам IWorldMap (где армии в момент t), WorldAdvancingEvent перед каждым расчётом
|
||
//
|
||
// Точка расширения под мультиплеер: сейчас WorldSimulation крутится прямо здесь.
|
||
// Позже TryStartMarch будет отправлять запрос на сервер, а походы и их итоги -- приходить с сервера.
|
||
public class MarchManager : MonoBehaviour, IWorld, IWorldMap, ISaveParticipant
|
||
{
|
||
public const string LocalPlayerId = LocalPlayer.Id;
|
||
|
||
public static MarchManager Instance { get; private set; }
|
||
|
||
// События для интерфейса карты (с полными данными похода). Модули слушают события EventBus.
|
||
public event Action<MarchData> OnMarchStarted;
|
||
public event Action<MarchData> OnBattleResolved;
|
||
public event Action<MarchData> OnMarchReturned;
|
||
public event Action<MarchData> OnGatherStarted; // дошли до ресурсной точки (targetEmpty -- точки уже нет)
|
||
public event Action<MarchData> OnScoutArrived; // разведка дошла до цели и повернула домой (или начала наблюдение)
|
||
public event Action<MarchData> OnReconCompleted; // Разведка М2: наблюдение закончено, отчёт готов
|
||
|
||
// Время мира -- по часам игры (GameClock): перемотка "+1 час" в отладочной панели проматывает и походы.
|
||
// Миллисекунды берём от настоящих часов, чтобы отряды на карте двигались плавно. В мультиплеере -- время сервера.
|
||
public static long NowMs => DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() + GameClock.OffsetSeconds * 1000;
|
||
|
||
private readonly List<WorldEvent> events = new List<WorldEvent>();
|
||
private WorldSimulation world;
|
||
private List<MarchData> pendingMarches; // загружены раньше, чем мир был создан
|
||
private List<CampState> pendingCamps;
|
||
private ResourcePointsState pendingPoints;
|
||
private PatrolState pendingPatrols;
|
||
|
||
// Мир создаётся при первом обращении: к этому моменту Боевая система уже зарегистрирована
|
||
public WorldSimulation World
|
||
{
|
||
get
|
||
{
|
||
if (world == null)
|
||
{
|
||
world = new WorldSimulation(WorldMapLayout.CreateDefault(), GameServices.Get<IBattleSystem>(), SpeedRules, PointRules);
|
||
world.AttackerConditions = m => m.ownerId == LocalPlayerId ? PlayerConditionsAt(m.arriveMs / 1000) : BattleCondition.None;
|
||
world.Patrols = Patrols;
|
||
world.LoadPatrolState(pendingPatrols);
|
||
pendingPatrols = null;
|
||
if (pendingPoints != null) world.LoadPointsState(pendingPoints); // точки -- до походов: поход к точке ищет её
|
||
if (pendingMarches != null) world.LoadMarches(pendingMarches);
|
||
if (pendingCamps != null) world.LoadCampStates(pendingCamps);
|
||
pendingMarches = null;
|
||
pendingCamps = null;
|
||
pendingPoints = null;
|
||
}
|
||
return world;
|
||
}
|
||
}
|
||
|
||
// Скорости маршей из таблицы MarchConfig -- их задаёт App/GameModules при запуске (модуль таблицу не видит)
|
||
public static MarchSpeedRules SpeedRules = MarchSpeedRules.Default;
|
||
// Числа ресурсных точек из таблицы WorldResourceConfig -- тоже задаёт App/GameModules
|
||
public static ResourcePointRules PointRules = ResourcePointRules.Default;
|
||
// Патрули-заглушки соседей (Разведка М1) из таблицы MarchConfig -- тоже задаёт App/GameModules
|
||
public static PatrolRules Patrols = PatrolRules.Default;
|
||
|
||
[RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.BeforeSceneLoad)]
|
||
static void CreateInstance()
|
||
{
|
||
var go = new GameObject("MarchManager");
|
||
DontDestroyOnLoad(go);
|
||
go.AddComponent<MarchManager>();
|
||
}
|
||
|
||
void Awake()
|
||
{
|
||
Instance = this;
|
||
GameServices.Register<IWorld>(this);
|
||
GameServices.Register<IWorldMap>(this);
|
||
SaveRegistry.Register(this);
|
||
}
|
||
|
||
void OnDestroy()
|
||
{
|
||
if (Instance != this) return;
|
||
GameServices.Unregister<IWorld>(this);
|
||
GameServices.Unregister<IWorldMap>(this);
|
||
SaveRegistry.Unregister(this);
|
||
}
|
||
|
||
void Update()
|
||
{
|
||
// Без армии и экономики некуда вернуть войско и добычу -- ждём, пока они появятся
|
||
if (!GameServices.Has<IArmy>() || !GameServices.Has<IEconomy>()) return;
|
||
|
||
long now = NowMs;
|
||
CatchUpPopulationBeforeBattles(now);
|
||
// Мир досчитывается по событиям, перед каждым шагом Разведка досчитывает наблюдение до него:
|
||
// походы ещё на карте и их выжившие уже известны (после офлайна обратный путь тоже виден)
|
||
events.Clear();
|
||
World.AdvanceInSteps(now, events, t => EventBus.Publish(new WorldAdvancingEvent { ToMs = t }));
|
||
|
||
foreach (var e in events)
|
||
{
|
||
if (e.Type == WorldEventType.BattleResolved) HandleBattleResolved(e.March);
|
||
else if (e.Type == WorldEventType.MarchReturned) HandleMarchReturned(e.March);
|
||
else if (e.Type == WorldEventType.GatherStarted) HandleGatherStarted(e.March);
|
||
else if (e.Type == WorldEventType.ScoutArrived) HandleScoutArrived(e.March);
|
||
else if (e.Type == WorldEventType.ReconCompleted) HandleReconCompleted(e.March);
|
||
else if (e.Type == WorldEventType.GatherFinished)
|
||
Debug.Log($"[СБОР] Сбор окончен: {e.March.cargo} ({World.TargetName(e.March)}), войско идёт домой");
|
||
}
|
||
|
||
if (events.Count > 0 && GameServices.TryGet(out ISaveSystem save)) save.SaveNow();
|
||
}
|
||
|
||
// Состояние войск игрока сейчас: голод -- из модуля Населения. Для окна атаки (прогноз).
|
||
// Усталость пока не выставляется -- правила её учёта не утверждены.
|
||
public static BattleCondition PlayerConditions()
|
||
{
|
||
return GameServices.TryGet(out IPopulation population) && population.IsStarving
|
||
? BattleCondition.Famine
|
||
: BattleCondition.None;
|
||
}
|
||
|
||
// Состояние войск игрока в момент боя (решение №9: голод проверяется на момент боя).
|
||
// Бой, прошедший пока игра была закрыта, спрашивает историю голода модуля Населения (WasStarvingAt).
|
||
static BattleCondition PlayerConditionsAt(long unixTime)
|
||
{
|
||
return GameServices.TryGet(out IPopulation population) && population.WasStarvingAt(unixTime)
|
||
? BattleCondition.Famine
|
||
: BattleCondition.None;
|
||
}
|
||
|
||
// Офлайн -- в причинно-следственном порядке (документ 02): прежде чем считать бой, прошедший в прошлом,
|
||
// просим Население досчитать время до "сейчас" -- иначе в его истории ещё нет голода за эти часы.
|
||
// Tick -- публичный метод Населения, тот же, что зовёт PopulationTicker; сам модуль не меняется.
|
||
void CatchUpPopulationBeforeBattles(long nowMs)
|
||
{
|
||
bool battleDue = false;
|
||
foreach (var m in World.Marches)
|
||
if (m.ownerId == LocalPlayerId && m.state == MarchState.Outbound && nowMs >= m.arriveMs) { battleDue = true; break; }
|
||
if (battleDue && GameServices.TryGet(out IPopulation population)) population.Tick(GameClock.UnixNow);
|
||
}
|
||
|
||
// ---------------- Контракт IWorld ----------------
|
||
|
||
public int ActiveMarches
|
||
{
|
||
get { int n = 0; foreach (var m in World.Marches) if (m.ownerId == LocalPlayerId) n++; return n; }
|
||
}
|
||
|
||
// ---------------- Контракт IWorldMap (для Разведки) ----------------
|
||
|
||
public int HalfWidth => WorldMapLayout.HalfWidth;
|
||
public int HalfHeight => WorldMapLayout.HalfHeight;
|
||
|
||
public bool TryGetSettlement(string ownerId, out int x, out int y)
|
||
{
|
||
foreach (var n in World.Nodes)
|
||
if (n.ownerId == ownerId && (n.type == MapNodeType.PlayerCity || n.type == MapNodeType.NeighborCity))
|
||
{
|
||
x = n.x; y = n.y;
|
||
return true;
|
||
}
|
||
x = y = 0;
|
||
return false;
|
||
}
|
||
|
||
// Цель разведки с отчётом (М2): замок, соседний город, лагерь -- гарнизон, стены, что можно взять
|
||
public bool TryGetReconTarget(string targetId, out ReconTarget target)
|
||
{
|
||
target = default;
|
||
// Движущаяся армия ("march_<номер>", как в GetArmies): состав -- на этот момент, без стен и ресурсов
|
||
if (TryParseArmyId(targetId, out int marchId))
|
||
{
|
||
MarchData m = World.FindMarch(marchId);
|
||
if (m == null || m.ownerId == LocalPlayerId) return false;
|
||
int[] units = m.units != null && m.units.Length == TroopType.Count ? (int[])m.units.Clone() : new[] { m.soldiers, 0, 0, 0 };
|
||
MapNode home = World.GetNode(m.fromNodeId);
|
||
target = new ReconTarget
|
||
{
|
||
Id = targetId, Name = home != null ? $"Армия из «{home.displayName}»" : "Чужая армия", Kind = ReconTargetKind.Army,
|
||
Units = units, Fortified = false, HasHero = false, // героев пока нет
|
||
ResourceNames = new string[0], ResourceAmounts = new int[0]
|
||
};
|
||
return true;
|
||
}
|
||
MapNode node = World.GetNode(targetId);
|
||
if (node == null) return false;
|
||
ReconTargetKind kind = node.type == MapNodeType.BossCastle ? ReconTargetKind.Castle
|
||
: node.type == MapNodeType.NeighborCity ? ReconTargetKind.Settlement
|
||
: node.type == MapNodeType.Camp ? ReconTargetKind.Camp : ReconTargetKind.None;
|
||
if (kind == ReconTargetKind.None) return false;
|
||
var names = new string[node.rewards.Count];
|
||
var amounts = new int[node.rewards.Count];
|
||
for (int i = 0; i < node.rewards.Count; i++) { names[i] = node.rewards[i].resource; amounts[i] = node.rewards[i].amount; }
|
||
target = new ReconTarget
|
||
{
|
||
Id = node.id, Name = node.displayName, Kind = kind,
|
||
Units = WorldMapLayout.GarrisonUnits(node), Fortified = WorldMapLayout.IsFortified(node), HasHero = false, // героев пока нет
|
||
ResourceNames = names, ResourceAmounts = amounts
|
||
};
|
||
return true;
|
||
}
|
||
|
||
// Все армии на карте в момент timeMs: свои походы, патрули соседей (позже -- армии других игроков с сервера)
|
||
public void GetArmies(long timeMs, List<ArmyOnMap> result)
|
||
{
|
||
foreach (var m in World.Marches)
|
||
{
|
||
if (!World.TryGetPositionAt(m, timeMs, out int x, out int y, out int toX, out int toY, out int soldiers)) continue;
|
||
result.Add(new ArmyOnMap { Id = "march_" + m.id, OwnerId = m.ownerId, X = x, Y = y, ToX = toX, ToY = toY, Soldiers = soldiers });
|
||
}
|
||
}
|
||
|
||
public bool TryStartMarch(string targetId, int soldiers, out string error)
|
||
{
|
||
return TryStart(targetId, soldiers, false, out error);
|
||
}
|
||
|
||
// Поход «Разведка» (решения 31.10, п. 2): тот же путь отправки и тот же слот, но без боя и сбора
|
||
public bool TryStartScout(string targetId, int soldiers, out string error)
|
||
{
|
||
return TryStart(targetId, soldiers, true, out error);
|
||
}
|
||
|
||
// Разведка с отчётом (Разведка М2): уровень II или III, наблюдение у цели -- время уровня из модуля Разведки
|
||
public bool TryStartRecon(string targetId, int soldiers, int level, out string error)
|
||
{
|
||
if (level < 2 || level > 3) { error = "Уровень разведки -- II или III"; return false; }
|
||
if (!GameServices.TryGet(out IIntelligence intel)) { error = "Модуль Разведки не подключён"; return false; }
|
||
long hold = intel.ReconDurationMs(targetId, level);
|
||
if (hold <= 0) { error = "Разведку с отчётом можно отправить на поселение, замок или лагерь"; return false; }
|
||
return TryStart(targetId, soldiers, true, out error, level, hold);
|
||
}
|
||
|
||
public static bool TryParseArmyId(string id, out int marchId)
|
||
{
|
||
marchId = 0;
|
||
return id != null && id.StartsWith("march_") && int.TryParse(id.Substring(6), out marchId) && marchId > 0;
|
||
}
|
||
|
||
// Цель отчёта разведки этого похода: армия ("march_<номер>") или узел карты
|
||
public static string ReconTargetId(MarchData march) =>
|
||
WorldSimulation.IsArmyRecon(march) ? "march_" + march.targetMarchId : march.targetNodeId;
|
||
|
||
// Разведка движущейся армии (Разведка М2, ТЗ раздел 6): отряд догоняет армию, идёт рядом время наблюдения,
|
||
// приносит отчёт и возвращается. armyId -- как в GetArmies ("march_<номер>")
|
||
public bool TryStartArmyRecon(string armyId, int soldiers, int level, out string error)
|
||
{
|
||
if (!TryParseArmyId(armyId, out int targetMarchId)) { error = "Это не армия"; return false; }
|
||
if (level < 2 || level > 3) { error = "Уровень разведки -- II или III"; return false; }
|
||
if (!GameServices.TryGet(out IIntelligence intel)) { error = "Модуль Разведки не подключён"; return false; }
|
||
long hold = intel.ReconDurationMs(armyId, level);
|
||
if (hold <= 0) { error = "Эту армию разведать нельзя"; return false; }
|
||
return TryStart(armyId, soldiers, true, out error, level, hold, targetMarchId);
|
||
}
|
||
|
||
// План разведки армии без старта: когда догонят, когда отчёт, когда дома (как для пехоты -- состав ещё не выбран)
|
||
public bool TryPlanArmyRecon(string armyId, int level, out long meetMs, out long reportMs, out long homeMs, out string error)
|
||
{
|
||
meetMs = reportMs = homeMs = 0;
|
||
if (!TryParseArmyId(armyId, out int targetMarchId)) { error = "Это не армия"; return false; }
|
||
long hold = GameServices.TryGet(out IIntelligence intel) ? intel.ReconDurationMs(armyId, level) : 0;
|
||
if (hold <= 0) { error = "Эту армию разведать нельзя"; return false; }
|
||
return World.TryPlanArmyRecon(WorldMapLayout.PlayerCityId, targetMarchId, NowMs, hold, out meetMs, out reportMs, out homeMs, out error);
|
||
}
|
||
|
||
bool TryStart(string targetId, int soldiers, bool scout, out string error, int reconLevel = 0, long reconHoldMs = 0, int targetMarchId = 0)
|
||
{
|
||
if (!GameServices.TryGet(out IArmy army))
|
||
{
|
||
error = "Нет данных о войске -- запусти игру из города";
|
||
return false;
|
||
}
|
||
if (army.AvailableForMarch < soldiers)
|
||
{
|
||
error = army.GarrisonTotal > 0
|
||
? $"Не хватает свободных воинов: {army.GarrisonTotal} стоят в гарнизоне. Гарнизон меняется в окне «Войска»"
|
||
: "Не хватает воинов. Наймите их в Казармах";
|
||
return false;
|
||
}
|
||
|
||
// Слоты похода (регламент 31.10): база 2, «Военная логистика» -- позже
|
||
if (army.ActiveMarches >= army.MarchSlots)
|
||
{
|
||
error = $"Все слоты похода заняты ({army.ActiveMarches} из {army.MarchSlots}). Дождитесь возвращения войска";
|
||
return false;
|
||
}
|
||
|
||
MarchData march = targetMarchId > 0
|
||
? World.StartArmyRecon(LocalPlayerId, WorldMapLayout.PlayerCityId, targetMarchId, soldiers, NowMs, reconLevel, reconHoldMs, out error)
|
||
: World.StartMarch(LocalPlayerId, WorldMapLayout.PlayerCityId, targetId, soldiers, NowMs, out error, scout);
|
||
if (march == null) return false;
|
||
if (reconLevel > 0 && targetMarchId == 0) World.SetRecon(march, reconLevel, reconHoldMs);
|
||
|
||
// Отправка целиком или никак: поход существует, только если Армия действительно забрала воинов.
|
||
// Иначе поход откатывается -- он не должен вернуть домой воинов, которых не забирал.
|
||
if (!army.TakeForMarch(march.id, soldiers))
|
||
{
|
||
World.CancelMarch(march.id);
|
||
error = "Не удалось собрать войско в поход";
|
||
return false;
|
||
}
|
||
// Состав похода -- для боя с типами войск и для скорости: время прихода по средней скорости состава
|
||
World.AssignUnits(march, army.GetMarchUnits(march.id));
|
||
if (GameServices.TryGet(out ISaveSystem save)) save.SaveNow();
|
||
|
||
Debug.Log($"[ПОХОД] {soldiers} солдат выступили {(scout ? "в разведку" : "на")} {World.TargetName(march)}");
|
||
OnMarchStarted?.Invoke(march);
|
||
EventBus.Publish(new MarchStartedEvent { MarchId = march.id, TimeMs = march.departMs, TargetId = targetId, Soldiers = soldiers, IsScout = scout });
|
||
if (reconLevel > 0)
|
||
EventBus.Publish(new ReconStartedEvent { EventId = ReportId(march), TargetId = targetId, Level = reconLevel, TimeMs = march.departMs });
|
||
return true;
|
||
}
|
||
|
||
static string ReportId(MarchData march) => "recon_" + march.id;
|
||
|
||
// Наблюдение закончено: Разведка составляет отчёт по цели на этот момент (один раз на поход)
|
||
void HandleReconCompleted(MarchData march)
|
||
{
|
||
if (GameServices.TryGet(out IIntelligence intel))
|
||
intel.CompleteRecon(ReportId(march), ReconTargetId(march), march.reconLevel, march.gatherEndMs);
|
||
Debug.Log($"[РАЗВЕДКА] Отчёт уровня {march.reconLevel}: {World.TargetName(march)}");
|
||
OnReconCompleted?.Invoke(march);
|
||
}
|
||
|
||
void HandleBattleResolved(MarchData march)
|
||
{
|
||
// Пропавшие без вести (решения 01.11, п. 5): уходят из похода в Армию отдельной группой -- вернутся сами
|
||
if (Sum(march.missingUnits) > 0 && GameServices.TryGet(out IArmy army))
|
||
{
|
||
army.MarkMissing(march.id, march.missingUnits, march.arriveMs, Math.Max(0, march.returnMs - march.arriveMs));
|
||
army.ProcessMissing(NowMs);
|
||
}
|
||
MapNode target = World.GetNode(march.targetNodeId);
|
||
if (march.targetEmpty) Debug.Log($"[ПОХОД] {target.displayName} уже разбит -- войско возвращается без боя");
|
||
else Debug.Log($"[ПОХОД] Бой у {target.displayName}: {(march.victory ? "ПОБЕДА" : "поражение")}. " +
|
||
$"{march.soldiers} против {march.defenders}, возвращаются {march.survivors}.");
|
||
OnBattleResolved?.Invoke(march);
|
||
EventBus.Publish(new MarchBattleResolvedEvent
|
||
{
|
||
MarchId = march.id,
|
||
BattleId = march.battleSeed,
|
||
TimeMs = march.arriveMs,
|
||
TargetId = march.targetNodeId,
|
||
Victory = march.victory,
|
||
Soldiers = march.soldiers,
|
||
Survivors = march.survivors
|
||
});
|
||
}
|
||
|
||
void HandleGatherStarted(MarchData march)
|
||
{
|
||
string target = World.TargetName(march);
|
||
if (march.targetEmpty) Debug.Log($"[СБОР] {target}: точки уже нет или она занята -- войско возвращается");
|
||
else Debug.Log($"[СБОР] {march.soldiers} воинов начали сбор: {target}, унесут {march.cargo}");
|
||
OnGatherStarted?.Invoke(march);
|
||
}
|
||
|
||
void HandleScoutArrived(MarchData march)
|
||
{
|
||
string target = World.TargetName(march);
|
||
Debug.Log(march.targetEmpty
|
||
? $"[РАЗВЕДКА] {target}: цели уже нет -- войско возвращается"
|
||
: $"[РАЗВЕДКА] Войско дошло до цели: {target}, возвращается домой");
|
||
OnScoutArrived?.Invoke(march);
|
||
}
|
||
|
||
// Солдаты и добыча зачисляются, только когда войско дошло до дома
|
||
void HandleMarchReturned(MarchData march)
|
||
{
|
||
IArmy army = GameServices.Get<IArmy>();
|
||
bool returned = march.survivorUnits != null && march.survivorUnits.Length == TroopType.Count
|
||
? army.ReturnUnits(march.id, march.survivorUnits, march.woundedUnits, march.returnMs) // по типам; раненые -- в госпиталь
|
||
: army.ReturnFromMarch(march.id, march.survivors); // старый поход без состава -- по пропорции
|
||
|
||
// Армия не знает этот поход (уже зачислен или испорченное сохранение): ни воинов, ни добычи
|
||
if (!returned)
|
||
{
|
||
Debug.LogWarning($"[ПОХОД] Поход {march.id} неизвестен Армии -- воины и добыча не зачислены");
|
||
return;
|
||
}
|
||
|
||
IEconomy economy = GameServices.Get<IEconomy>();
|
||
foreach (var reward in march.loot)
|
||
{
|
||
if (Enum.TryParse(reward.resource, out ResourceType type))
|
||
economy.Add(type, reward.amount);
|
||
else
|
||
Debug.LogWarning($"[ПОХОД] Неизвестный ресурс награды: {reward.resource}");
|
||
}
|
||
|
||
Debug.Log($"[ПОХОД] Войско вернулось: {march.survivors} солдат, добыча: {FormatLoot(march.loot)}");
|
||
OnMarchReturned?.Invoke(march);
|
||
EventBus.Publish(new MarchReturnedEvent
|
||
{
|
||
MarchId = march.id,
|
||
TimeMs = march.returnMs,
|
||
Victory = march.victory,
|
||
Survivors = march.survivors,
|
||
Sent = march.soldiers,
|
||
TargetEmpty = march.targetEmpty,
|
||
IsGather = march.gather,
|
||
IsScout = march.scout,
|
||
Wounded = Sum(march.woundedUnits),
|
||
Missing = Sum(march.missingUnits),
|
||
TargetName = World.TargetName(march),
|
||
LootText = FormatLoot(march.loot)
|
||
});
|
||
}
|
||
|
||
// ---------------- Сохранение (секция "world") ----------------
|
||
|
||
[Serializable]
|
||
class WorldSaveData
|
||
{
|
||
public List<MarchData> marches = new List<MarchData>();
|
||
public List<CampState> camps = new List<CampState>(); // разбитые лагеря и когда они появятся
|
||
public ResourcePointsState points; // ресурсные точки: запасы, сроки, кто собирает
|
||
public PatrolState patrols; // патрули-заглушки: когда следующий
|
||
}
|
||
|
||
public string SaveKey => "world";
|
||
|
||
public string Capture()
|
||
{
|
||
var camps = world != null ? world.GetCampStates() : new List<CampState>(pendingCamps ?? new List<CampState>());
|
||
var points = world != null ? world.GetPointsState() : pendingPoints;
|
||
var patrols = world != null ? world.GetPatrolState() : pendingPatrols;
|
||
return JsonUtility.ToJson(new WorldSaveData { marches = GetMarchesForSave(), camps = camps, points = points, patrols = patrols });
|
||
}
|
||
|
||
public void Restore(string json)
|
||
{
|
||
WorldSaveData data = JsonUtility.FromJson<WorldSaveData>(json);
|
||
// Точки -- до походов. Старое сохранение без точек: точки появятся при первом расчёте мира
|
||
if (world != null) world.LoadPointsState(data?.points);
|
||
else pendingPoints = data?.points;
|
||
LoadMarches(data?.marches);
|
||
if (world != null) world.LoadCampStates(data?.camps);
|
||
else pendingCamps = data?.camps;
|
||
if (world != null) world.LoadPatrolState(data?.patrols);
|
||
else pendingPatrols = data?.patrols;
|
||
}
|
||
|
||
// Новая игра: все походы отменяются (войска сбрасывает Армия вместе с прогрессом), лагеря на месте
|
||
public void ResetState()
|
||
{
|
||
pendingMarches = null;
|
||
pendingCamps = null;
|
||
pendingPoints = null;
|
||
pendingPatrols = null;
|
||
if (world != null)
|
||
{
|
||
world.LoadPatrolState(null);
|
||
world.LoadMarches(new List<MarchData>());
|
||
world.LoadCampStates(null);
|
||
world.LoadPointsState(null); // ресурсные точки появятся заново
|
||
}
|
||
}
|
||
|
||
public List<MarchData> GetMarchesForSave()
|
||
{
|
||
return world != null ? new List<MarchData>(world.Marches) : new List<MarchData>(pendingMarches ?? new List<MarchData>());
|
||
}
|
||
|
||
// Загрузить походы (из сохранения или из старого progress.json). Мир может быть ещё не создан.
|
||
public void LoadMarches(List<MarchData> saved)
|
||
{
|
||
if (world != null) world.LoadMarches(saved);
|
||
else pendingMarches = saved;
|
||
}
|
||
|
||
static int Sum(int[] units)
|
||
{
|
||
int n = 0;
|
||
if (units != null) foreach (var u in units) n += Math.Max(0, u);
|
||
return n;
|
||
}
|
||
|
||
// ---------------- ТЕКСТ ДЛЯ UI ----------------
|
||
|
||
public static string FormatLoot(List<RewardEntry> loot)
|
||
{
|
||
if (loot == null || loot.Count == 0) return "нет";
|
||
|
||
var parts = new List<string>();
|
||
foreach (var r in loot)
|
||
{
|
||
parts.Add($"+{r.amount} {GetResourceName(r.resource)}");
|
||
}
|
||
return string.Join(", ", parts);
|
||
}
|
||
|
||
static string GetResourceName(string resource)
|
||
{
|
||
switch (resource)
|
||
{
|
||
case "Food": return "еды";
|
||
case "Wood": return "дерева";
|
||
case "Stone": return "камня";
|
||
case "Iron": return "металла";
|
||
case "Gold": return "золота";
|
||
case "Gems": return "кристаллов";
|
||
default: return resource;
|
||
}
|
||
}
|
||
}
|