406 lines
17 KiB
C#
406 lines
17 KiB
C#
using System;
|
|
using System.Globalization;
|
|
using System.Text;
|
|
|
|
// МОДУЛЬ НАСЕЛЕНИЯ: сколько в городе людей, кто где работает, сколько едят и как прирастают.
|
|
// Документ: Docs/Modules/Population.md. Без Unity: правила те же, что будут на сервере.
|
|
//
|
|
// Люди города = жители (этот модуль) + воины (модуль Армии). Воин -- тоже человек: он ест (0.2 еды в час)
|
|
// и входит в общее население, но хранится в Армии, чтобы один человек не был записан в двух местах.
|
|
// Жители: часть может работать (Workforce, стартовый город -- 120 из 270), из них рабочие стоят на профессиях.
|
|
//
|
|
// Время -- только из GameClock. Расчёт идёт кусками по 10 минут: раз в несколько секунд в игре,
|
|
// при входе в игру (офлайн-прогресс) и при перемотке в отладочной панели -- правила одни и те же.
|
|
// В каждом куске: сначала добыча (IProduction), потом еда, потом прирост.
|
|
public sealed class PopulationService : IPopulation, ISaveParticipant
|
|
{
|
|
const long SecondsPerHour = 3600;
|
|
const long StepSeconds = 600; // офлайн-время считаем кусками по 10 минут -- так же, как в игре
|
|
const double Epsilon = 1e-9;
|
|
|
|
readonly PopulationRules rules;
|
|
|
|
int civilians;
|
|
readonly int[] jobs = new int[WorkJobs.Count]; // рабочих по профессиям
|
|
bool jobsInitialized; // рабочих хоть раз расставляли (старому сохранению расставим сами)
|
|
int houseLevels; // сумма уровней Домов в городе (сообщает App/CitySync)
|
|
double growthProgress; // накопленная доля следующего человека (0..1)
|
|
double foodOwed; // съедено, но ещё не списано со склада (меньше 1 еды)
|
|
long lastTickUnix; // до какого момента население уже посчитано; 0 -- ещё ни разу
|
|
bool starving;
|
|
bool startingKitGiven; // стартовое войско и ресурсы новой игры уже выданы (или это старое сохранение)
|
|
|
|
public PopulationService(PopulationRules rules)
|
|
{
|
|
this.rules = rules ?? new PopulationRules();
|
|
SetStartState();
|
|
}
|
|
|
|
public PopulationRules Rules => rules;
|
|
public long LastTickUnix => lastTickUnix;
|
|
public bool RestoredFromSave { get; private set; }
|
|
public bool JobsInitialized => jobsInitialized;
|
|
public int HouseLevels => houseLevels;
|
|
|
|
// ---------------- Контракт IPopulation ----------------
|
|
|
|
public int Civilians => civilians;
|
|
|
|
public int Workers
|
|
{
|
|
get { int n = 0; foreach (var j in jobs) n += j; return n; }
|
|
}
|
|
|
|
public int Idle => Math.Max(0, civilians - Workers);
|
|
|
|
// Доля жителей, способных работать: 120 из 270 в стартовом городе
|
|
public int Workforce
|
|
{
|
|
get
|
|
{
|
|
int startCiv = Math.Max(1, rules.StartCivilians);
|
|
double share = Math.Min(1.0, rules.StartWorkers / (double)startCiv);
|
|
return (int)Math.Floor(civilians * share + Epsilon);
|
|
}
|
|
}
|
|
|
|
public int FreeWorkers => Math.Max(0, Workforce - Workers);
|
|
|
|
public int Soldiers
|
|
{
|
|
get
|
|
{
|
|
if (!GameServices.TryGet(out IArmy army)) return 0;
|
|
return army.SoldiersAtHome + army.TroopsInMarches;
|
|
}
|
|
}
|
|
|
|
public int Total => civilians + Soldiers;
|
|
|
|
public int HousingCap
|
|
{
|
|
get
|
|
{
|
|
int level = GameServices.TryGet(out ISettlement settlement) ? Math.Max(1, settlement.TownHallLevel) : 1;
|
|
return rules.HousingBase + rules.HousingPerTownHallLevel * (level - 1) + rules.HousingPerHouseLevel * houseLevels;
|
|
}
|
|
}
|
|
|
|
public float FoodPerHour => (float)FoodPerHourExact(Soldiers);
|
|
public float GrowthPerHour => starving || Total >= HousingCap ? 0f : (float)rules.GrowthPerHour;
|
|
public bool IsStarving => starving;
|
|
|
|
double FoodPerHourExact(int soldiers)
|
|
{
|
|
return civilians * rules.FoodPerCivilianPerHour + soldiers * rules.FoodPerSoldierPerHour;
|
|
}
|
|
|
|
public int GetWorkers(WorkJob job)
|
|
{
|
|
int j = (int)job;
|
|
return j >= 0 && j < WorkJobs.Count ? jobs[j] : 0;
|
|
}
|
|
|
|
public int SetWorkers(WorkJob job, int count)
|
|
{
|
|
int j = (int)job;
|
|
if (j < 0 || j >= WorkJobs.Count) return 0;
|
|
|
|
int limit = jobs[j] + FreeWorkers; // больше, чем есть свободных, не поставить
|
|
int slots = SlotsFor(job);
|
|
if (slots >= 0) limit = Math.Min(limit, slots); // и больше, чем мест в зданиях
|
|
int value = Math.Max(0, Math.Min(count, limit));
|
|
if (value != jobs[j])
|
|
{
|
|
jobs[j] = value;
|
|
jobsInitialized = true;
|
|
WorkersChanged();
|
|
}
|
|
return jobs[j];
|
|
}
|
|
|
|
// Мест для профессии: -1 -- модуль добычи не подключён (тесты без него), ограничения нет
|
|
static int SlotsFor(WorkJob job)
|
|
{
|
|
return GameServices.TryGet(out IProduction production) ? production.Slots(job) : -1;
|
|
}
|
|
|
|
public void Tick(long unixNow)
|
|
{
|
|
if (lastTickUnix == 0)
|
|
{
|
|
lastTickUnix = unixNow; // первый расчёт: отсюда и считаем
|
|
Changed();
|
|
return;
|
|
}
|
|
|
|
long elapsed = unixNow - lastTickUnix;
|
|
if (elapsed < 0)
|
|
{
|
|
// Часы ушли назад (сброс отладочной перемотки, перевод часов на телефоне) -- просто продолжаем с "сейчас"
|
|
lastTickUnix = unixNow;
|
|
return;
|
|
}
|
|
if (elapsed == 0) return;
|
|
|
|
long max = (long)rules.MaxOfflineHours * SecondsPerHour;
|
|
if (elapsed > max) elapsed = max;
|
|
|
|
Simulate(elapsed);
|
|
lastTickUnix = unixNow;
|
|
}
|
|
|
|
// ---------------- Расчёт ----------------
|
|
|
|
void Simulate(long seconds)
|
|
{
|
|
if (!GameServices.TryGet(out IEconomy economy)) return; // без склада считать нечего
|
|
GameServices.TryGet(out IProduction production);
|
|
|
|
int totalBefore = Total;
|
|
bool starvingBefore = starving;
|
|
int soldiers = Soldiers;
|
|
|
|
long remaining = seconds;
|
|
while (remaining > 0)
|
|
{
|
|
long step = Math.Min(remaining, StepSeconds);
|
|
remaining -= step;
|
|
double hours = step / (double)SecondsPerHour;
|
|
|
|
// 0. Добыча: рабочие приносят ресурсы (в том числе еду) -- до того, как город поест
|
|
production?.Produce(hours);
|
|
|
|
// 1. Едим. Со склада списываются только целые единицы, доли копятся здесь (foodOwed):
|
|
// склад хранит float, и тысячи мелких списаний по 0.02 давали бы ошибку округления.
|
|
foodOwed += FoodPerHourExact(soldiers) * hours;
|
|
int portion = (int)Math.Floor(foodOwed + Epsilon);
|
|
double have = economy.Get(ResourceType.Food);
|
|
bool fed;
|
|
if (portion <= 0)
|
|
{
|
|
fed = have >= foodOwed - Epsilon; // пока едим из уже взятого -- голод, только если склад пуст
|
|
}
|
|
else if (have >= portion)
|
|
{
|
|
economy.Add(ResourceType.Food, -portion);
|
|
foodOwed -= portion;
|
|
fed = true;
|
|
}
|
|
else
|
|
{
|
|
int rest = (int)Math.Floor(have);
|
|
if (rest > 0) economy.Add(ResourceType.Food, -rest); // доедаем остатки
|
|
foodOwed = 0; // долг за голодное время не копим
|
|
fed = false;
|
|
}
|
|
starving = !fed;
|
|
|
|
// 2. Прирост -- только сытым и только до предела жилья. Что ещё бывает при голоде -- решит команда.
|
|
if (fed)
|
|
{
|
|
int room = HousingCap - (civilians + soldiers);
|
|
if (room > 0)
|
|
{
|
|
growthProgress += rules.GrowthPerHour * hours;
|
|
int born = (int)Math.Floor(growthProgress + Epsilon);
|
|
if (born > 0)
|
|
{
|
|
growthProgress = Math.Max(0, growthProgress - born);
|
|
civilians += Math.Min(born, room);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
growthProgress = 0; // упёрлись в предел -- не копим "запас" людей
|
|
}
|
|
}
|
|
}
|
|
|
|
if (starving != starvingBefore) EventBus.Publish(new StarvationChangedEvent { IsStarving = starving });
|
|
if (Total != totalBefore) Changed();
|
|
}
|
|
|
|
// ---------------- Рабочие: расстановка ----------------
|
|
|
|
// Поставить свободных рабочих на пустые места профессии (новое здание, улучшение). Возвращает, сколько поставлено.
|
|
public int AutoFill(WorkJob job)
|
|
{
|
|
int slots = SlotsFor(job);
|
|
int room = slots < 0 ? FreeWorkers : Math.Min(FreeWorkers, slots - jobs[(int)job]);
|
|
if (room <= 0) return 0;
|
|
SetWorkers(job, jobs[(int)job] + room);
|
|
return room;
|
|
}
|
|
|
|
// Расставить свободных по всем профессиям поровну (старое сохранение, первый запуск после этапа 3)
|
|
public void AutoFillAll()
|
|
{
|
|
bool changed = false;
|
|
bool progress = true;
|
|
while (FreeWorkers > 0 && progress)
|
|
{
|
|
progress = false;
|
|
for (int j = 0; j < WorkJobs.Count && FreeWorkers > 0; j++)
|
|
{
|
|
int slots = SlotsFor((WorkJob)j);
|
|
if (slots >= 0 && jobs[j] >= slots) continue;
|
|
jobs[j]++;
|
|
progress = changed = true;
|
|
}
|
|
}
|
|
jobsInitialized = true;
|
|
if (changed) WorkersChanged();
|
|
}
|
|
|
|
// Мест стало меньше или работников меньше (призыв в будущем) -- снять лишних
|
|
public void ClampJobs()
|
|
{
|
|
bool changed = false;
|
|
for (int j = 0; j < WorkJobs.Count; j++)
|
|
{
|
|
int slots = SlotsFor((WorkJob)j);
|
|
if (slots >= 0 && jobs[j] > slots) { jobs[j] = slots; changed = true; }
|
|
}
|
|
int over = Workers - Workforce;
|
|
for (int j = WorkJobs.Count - 1; j >= 0 && over > 0; j--)
|
|
{
|
|
int take = Math.Min(over, jobs[j]);
|
|
jobs[j] -= take; over -= take;
|
|
if (take > 0) changed = true;
|
|
}
|
|
if (changed) WorkersChanged();
|
|
}
|
|
|
|
// Сумма уровней Домов (каждый уровень прибавляет к пределу жилья)
|
|
public void SetHouseLevels(int levels)
|
|
{
|
|
levels = Math.Max(0, levels);
|
|
if (levels == houseLevels) return;
|
|
houseLevels = levels;
|
|
Changed();
|
|
}
|
|
|
|
void WorkersChanged()
|
|
{
|
|
EventBus.Publish(new WorkersChangedEvent { Workers = Workers, FreeWorkers = FreeWorkers });
|
|
}
|
|
|
|
// ---------------- Связь с остальной игрой (вызывает App/GameModules) ----------------
|
|
|
|
// Сохранение загружено: досчитать офлайн-время. Старое сохранение без секции населения -- стартовый набор не выдаём.
|
|
public void OnGameLoaded(long unixNow)
|
|
{
|
|
startingKitGiven = true;
|
|
Tick(unixNow);
|
|
Changed();
|
|
}
|
|
|
|
// Новая игра (нет файла) или сброс: стартовый набор (войско, ресурсы) выдаётся один раз.
|
|
// true -- выдать сейчас; false -- уже выдан или это старое сохранение.
|
|
public bool TryTakeStartingKit()
|
|
{
|
|
if (startingKitGiven) return false;
|
|
startingKitGiven = true;
|
|
return true;
|
|
}
|
|
|
|
// Изменилась Армия, Ратуша или Дома -- пересчитать общее число людей для интерфейса
|
|
public void Changed()
|
|
{
|
|
EventBus.Publish(new PopulationChangedEvent
|
|
{
|
|
Total = Total,
|
|
Civilians = civilians,
|
|
Soldiers = Soldiers,
|
|
HousingCap = HousingCap
|
|
});
|
|
}
|
|
|
|
void SetStartState()
|
|
{
|
|
civilians = Math.Max(0, rules.StartCivilians);
|
|
Array.Clear(jobs, 0, jobs.Length);
|
|
jobsInitialized = false;
|
|
houseLevels = 0;
|
|
growthProgress = 0;
|
|
foodOwed = 0;
|
|
lastTickUnix = 0;
|
|
starving = false;
|
|
startingKitGiven = false;
|
|
}
|
|
|
|
// ---------------- Сохранение (секция "population") ----------------
|
|
// Модуль без Unity, поэтому формат -- простые строки "ключ=значение", как у Армии.
|
|
|
|
public string SaveKey => "population";
|
|
|
|
public string Capture()
|
|
{
|
|
var sb = new StringBuilder();
|
|
sb.Append("civilians=").Append(civilians.ToString(CultureInfo.InvariantCulture)).Append('\n');
|
|
var parts = new string[jobs.Length];
|
|
for (int i = 0; i < jobs.Length; i++) parts[i] = jobs[i].ToString(CultureInfo.InvariantCulture);
|
|
sb.Append("jobs=").Append(string.Join(",", parts)).Append('\n');
|
|
sb.Append("jobsInit=").Append(jobsInitialized ? "1" : "0").Append('\n');
|
|
sb.Append("houses=").Append(houseLevels.ToString(CultureInfo.InvariantCulture)).Append('\n');
|
|
sb.Append("growth=").Append(growthProgress.ToString("R", CultureInfo.InvariantCulture)).Append('\n');
|
|
sb.Append("food=").Append(foodOwed.ToString("R", CultureInfo.InvariantCulture)).Append('\n');
|
|
sb.Append("lastTick=").Append(lastTickUnix.ToString(CultureInfo.InvariantCulture)).Append('\n');
|
|
sb.Append("starving=").Append(starving ? "1" : "0").Append('\n');
|
|
sb.Append("kit=").Append(startingKitGiven ? "1" : "0").Append('\n');
|
|
return sb.ToString();
|
|
}
|
|
|
|
public void Restore(string data)
|
|
{
|
|
SetStartState();
|
|
RestoredFromSave = true;
|
|
if (string.IsNullOrEmpty(data)) return;
|
|
|
|
foreach (var raw in data.Split('\n'))
|
|
{
|
|
string line = raw.Trim();
|
|
int eq = line.IndexOf('=');
|
|
if (eq <= 0) continue;
|
|
string key = line.Substring(0, eq);
|
|
string value = line.Substring(eq + 1);
|
|
|
|
switch (key)
|
|
{
|
|
case "civilians": civilians = Math.Max(0, ParseInt(value, civilians)); break;
|
|
case "jobs":
|
|
string[] p = value.Split(',');
|
|
for (int i = 0; i < jobs.Length && i < p.Length; i++) jobs[i] = Math.Max(0, ParseInt(p[i].Trim(), 0));
|
|
break;
|
|
case "jobsInit": jobsInitialized = value == "1"; break;
|
|
case "houses": houseLevels = Math.Max(0, ParseInt(value, 0)); break;
|
|
case "growth":
|
|
if (double.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out double g)) growthProgress = Math.Max(0, Math.Min(0.999, g));
|
|
break;
|
|
case "food":
|
|
if (double.TryParse(value, NumberStyles.Float, CultureInfo.InvariantCulture, out double f)) foodOwed = Math.Max(0, Math.Min(1, f));
|
|
break;
|
|
case "lastTick":
|
|
if (long.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out long t)) lastTickUnix = Math.Max(0, t);
|
|
break;
|
|
case "starving": starving = value == "1"; break;
|
|
case "kit": startingKitGiven = value == "1"; break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Новая игра: стартовый город. Стартовое войско выдаст App/GameModules после сброса всех модулей.
|
|
public void ResetState()
|
|
{
|
|
SetStartState();
|
|
Changed();
|
|
WorkersChanged();
|
|
}
|
|
|
|
static int ParseInt(string s, int fallback)
|
|
{
|
|
return int.TryParse(s, NumberStyles.Integer, CultureInfo.InvariantCulture, out int v) ? v : fallback;
|
|
}
|
|
}
|