325 lines
17 KiB
C#
325 lines
17 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
|
||
// Контракты модулей: всё, что один модуль может попросить у другого.
|
||
// Реализация живёт в своём модуле, здесь -- только "что умеет".
|
||
// Добавляя метод сюда, обнови документ модуля в Docs/Modules.
|
||
|
||
// ---------------- Экономика: ресурсы и производство ----------------
|
||
public interface IEconomy
|
||
{
|
||
float Get(ResourceType type);
|
||
bool Has(ResourceType type, float amount);
|
||
void Add(ResourceType type, float amount);
|
||
bool TrySpend(ResourceType type, float amount);
|
||
|
||
bool CanAfford(IReadOnlyList<ResourceAmount> cost);
|
||
// Списывает всё или ничего
|
||
bool TrySpend(IReadOnlyList<ResourceAmount> cost);
|
||
|
||
// Лимит склада для ресурса. float.PositiveInfinity -- без лимита (люди, сила).
|
||
// Сверх лимита ресурс не прибавляется (добыча, награды) -- лишнее пропадает.
|
||
float GetCapacity(ResourceType type);
|
||
}
|
||
|
||
// Добыча через рабочих (этап 3). Реализует модуль Экономики (ProductionService).
|
||
public interface IProduction
|
||
{
|
||
int Slots(WorkJob job); // мест для рабочих этой профессии во всех зданиях города
|
||
float Efficiency(WorkJob job); // множитель от уровня зданий (1 -- здания 1 уровня)
|
||
float RatePerHour(ResourceType type); // добыча ресурса в час сейчас
|
||
// Добыть за hours часов (вызывает модуль Населения в своём расчёте -- сначала добыли, потом съели)
|
||
void Produce(double hours);
|
||
}
|
||
|
||
// ---------------- Поселение: здания и развитие города ----------------
|
||
public interface ISettlement
|
||
{
|
||
int TownHallLevel { get; }
|
||
int BuildingCount { get; }
|
||
bool IsCityLoaded { get; } // открыта ли сейчас сцена города
|
||
}
|
||
|
||
// Здание с уровнем (добывающие постройки и т.п.) -- Поселение сохраняет уровень, не зная, чьё это здание
|
||
public interface ILeveledBuilding
|
||
{
|
||
int Level { get; set; }
|
||
}
|
||
|
||
// ---------------- Население (часть модуля Поселения): жители, еда, прирост, найм ----------------
|
||
public interface IPopulation
|
||
{
|
||
int Total { get; } // все люди города: жители + обучаются в Казармах + воины (в городе и в походах)
|
||
int Civilians { get; } // жители (не воины)
|
||
int Workers { get; } // жители на работе (все профессии вместе)
|
||
int Idle { get; } // остальные жители: Civilians - Workers
|
||
int Workforce { get; } // сколько жителей могут работать: 40% всех людей города (стартовый город -- 120 из 300)
|
||
int FreeWorkers { get; } // могут работать, но без работы: Workforce - Workers
|
||
int Soldiers { get; } // воины -- их хранит модуль Армии
|
||
int HousingCap { get; } // предел населения: выше него прирост не идёт
|
||
|
||
float FoodPerHour { get; } // сколько город съедает в час
|
||
float GrowthPerHour { get; } // прирост в час сейчас (0 -- если голод или упёрлись в предел)
|
||
bool IsStarving { get; } // еды не хватило на последний расчёт
|
||
// Голодал ли город в момент unixTime (секунды). Для боёв, прошедших, пока игра была закрыта:
|
||
// история хранится за последние MaxOfflineHours (48 ч), точность -- 10 минут (шаг расчёта).
|
||
bool WasStarvingAt(long unixTime);
|
||
|
||
// Найм воинов (решение команды от 19.10.2026): воины берутся из свободных жителей, гражданский резерв не отдаётся.
|
||
int CivilianReserve { get; } // гражданский резерв: столько свободных жителей в войско не взять
|
||
int Recruitable { get; } // сколько воинов можно нанять прямо сейчас: (свободные - резерв) / жителей на воина
|
||
int InTraining { get; } // людей, взятых из жителей и ещё обучающихся в Казармах
|
||
bool TryRecruit(int soldiers); // забрать людей в Казармы (в начале обучения); false -- столько жителей нет
|
||
void RecruitsTrained(int soldiers); // обучение закончено: этих людей теперь считает Армия
|
||
|
||
// Досчитать население до момента unixNow (вызывается раз в несколько секунд и при перемотке)
|
||
void Tick(long unixNow);
|
||
|
||
// Рабочие по профессиям (этап 3)
|
||
int GetWorkers(WorkJob job);
|
||
// Поставить count рабочих на профессию (в пределах мест в зданиях и свободных рабочих). Возвращает, сколько стоит теперь.
|
||
int SetWorkers(WorkJob job, int count);
|
||
}
|
||
|
||
// ---------------- Армия: войска ----------------
|
||
public interface IArmy
|
||
{
|
||
int TypeCount { get; } // типов войск (пехота, лучники, кавалерия, осадные)
|
||
int GetTroops(int type); // воинов этого типа в городе
|
||
int SoldiersAtHome { get; } // всего воинов в городе (вместе с гарнизоном)
|
||
int TroopsInMarches { get; } // воинов в походах
|
||
|
||
// Гарнизон -- часть воинов в городе: защищает город и в походы не уходит. Всего воинов от этого не меняется.
|
||
int GarrisonTotal { get; }
|
||
int GetGarrison(int type);
|
||
int AvailableForMarch { get; } // можно отправить в поход: в городе минус гарнизон
|
||
int SetGarrison(int count); // назначить гарнизон (по составу армии); возвращает, сколько назначено
|
||
|
||
void AddTroops(int type, int count); // обучены / вернулись
|
||
int LoseFraction(double fraction); // потери в бою: доля от каждого типа; возвращает, сколько погибло
|
||
|
||
// Забрать свободных воинов в поход (запоминает состав похода).
|
||
// false -- ничего не взято: не хватает воинов или поход с таким номером уже есть.
|
||
bool TakeForMarch(int marchId, int count);
|
||
// Вернуть выживших из похода по тем же типам войск.
|
||
// Зачисляет только по известному походу и только один раз; false -- такого похода нет, никто не добавлен.
|
||
bool ReturnFromMarch(int marchId, int survivors);
|
||
|
||
// Состав похода по типам (копия); null -- такого похода нет
|
||
int[] GetMarchUnits(int marchId);
|
||
// Вернуть выживших точно по типам (бой посчитал потери каждого типа). Правила те же, что у ReturnFromMarch.
|
||
bool ReturnUnits(int marchId, int[] survivorUnits);
|
||
}
|
||
|
||
// ---------------- Глобальный мир: карта и перемещения ----------------
|
||
public interface IWorld
|
||
{
|
||
int ActiveMarches { get; }
|
||
bool TryStartMarch(string targetId, int soldiers, out string error);
|
||
}
|
||
|
||
// ---------------- Боевая система: урон, потери, исход ----------------
|
||
// Типы войск в бою -- порядок как в GameData.Troops и в модуле Армии
|
||
public static class TroopType
|
||
{
|
||
public const int Infantry = 0; // пехота
|
||
public const int Archers = 1; // лучники
|
||
public const int Cavalry = 2; // кавалерия
|
||
public const int Siege = 3; // осадные
|
||
public const int Count = 4;
|
||
}
|
||
|
||
// Состояние войск стороны в бою (план от 27.10.2026). Штрафы применяются последовательно:
|
||
// голод (-50%) и усталость (-20%) вместе оставляют 40% силы, а не 30%. Числа -- в правилах боя.
|
||
[Flags]
|
||
public enum BattleCondition
|
||
{
|
||
None = 0,
|
||
Famine = 1, // голод в поселении на момент боя
|
||
Fatigue = 2 // войско недавно сражалось (пока не выставляется: правила учёта усталости не утверждены)
|
||
}
|
||
|
||
public struct BattleRequest
|
||
{
|
||
// Состав сторон по типам войск (TroopType). Если состав не задан (null) --
|
||
// берётся число Attackers / Defenders, и все считаются пехотой.
|
||
public int[] AttackerUnits;
|
||
public int[] DefenderUnits;
|
||
public int Attackers;
|
||
public int Defenders;
|
||
|
||
public bool DefenderFortified; // защитники за стенами (город, замок)
|
||
public int AttackerBonusPercent; // герой, технологии, голод (минус) -- +10 = на 10% сильнее
|
||
public int DefenderBonusPercent;
|
||
|
||
// Состояния сторон: голод, усталость. Действуют последовательно (умножаются), см. BattleCondition
|
||
public BattleCondition AttackerConditions;
|
||
public BattleCondition DefenderConditions;
|
||
|
||
// Номер боя: из него считается случайность сторон (±5%). Один и тот же Seed с теми же войсками --
|
||
// всегда тот же итог, бой можно перепроверить. В мультиплеере Seed выдаёт сервер.
|
||
public long Seed;
|
||
}
|
||
|
||
// Итог боя -- одинаково полный для обеих сторон. Все массивы -- по типам войск (TroopType).
|
||
// По каждому типу: до боя = выжившие + погибшие + раненые.
|
||
public struct BattleOutcome
|
||
{
|
||
public bool Victory; // победил атакующий
|
||
public long BattleId; // = Seed запроса
|
||
public int RulesVersion; // версия правил боя (баланса), по которой посчитан итог
|
||
|
||
public int AttackerLosses; // выбыли из строя: погибшие + раненые
|
||
public int DefenderLosses;
|
||
public int Survivors; // сколько атакующих осталось в строю
|
||
|
||
public long AttackerPower; // итоговая сила сторон x100: с контрами, стенами, бонусами и случайностью
|
||
public long DefenderPower;
|
||
public int AttackerLuckPermille; // случайность стороны в десятых долях процента: +23 = +2,3%
|
||
public int DefenderLuckPermille;
|
||
public int AttackerConditionPercent; // сколько силы оставили состояния стороны: 100 -- без штрафов, 50 -- голод
|
||
public int DefenderConditionPercent;
|
||
|
||
public int[] AttackerUnitsBefore, DefenderUnitsBefore;
|
||
public int[] AttackerSurvivorUnits, DefenderSurvivorUnits;
|
||
public int[] AttackerDeadUnits, DefenderDeadUnits;
|
||
public int[] AttackerWoundedUnits, DefenderWoundedUnits; // пока нули: доля раненых не утверждена командой
|
||
public int[] DefenderLossUnits; // погибшие + раненые защитника (для старого кода)
|
||
}
|
||
|
||
// Прогноз до боя: с учётом случайности, без раскрытия итога (план от 27.10.2026)
|
||
public enum BattleChance
|
||
{
|
||
Advantage, // победа при любой случайности
|
||
Uncertain, // исход зависит от случайности
|
||
HighRisk // поражение при любой случайности
|
||
}
|
||
|
||
public struct BattleForecast
|
||
{
|
||
public BattleChance Chance;
|
||
public long AttackerPowerMin, AttackerPowerMax; // x100, крайние значения случайности
|
||
public long DefenderPowerMin, DefenderPowerMax;
|
||
public int AttackerLossesMin, AttackerLossesMax;
|
||
}
|
||
|
||
public interface IBattleSystem
|
||
{
|
||
BattleOutcome Resolve(BattleRequest request);
|
||
BattleForecast Forecast(BattleRequest request); // Seed не нужен: перебираются крайние значения случайности
|
||
}
|
||
|
||
// ---------------- Чат: общий мир и Круг ----------------
|
||
public enum ChatChannel
|
||
{
|
||
World, // общий чат всего мира
|
||
Circle // чат своего Круга
|
||
}
|
||
|
||
[Serializable]
|
||
public class ChatMessage
|
||
{
|
||
public ChatChannel channel;
|
||
public string senderId;
|
||
public string senderName;
|
||
public string text;
|
||
public long timeMs; // Unix-время в миллисекундах
|
||
}
|
||
|
||
public interface IChat
|
||
{
|
||
int MaxMessageLength { get; }
|
||
IReadOnlyList<ChatMessage> GetMessages(ChatChannel channel);
|
||
bool CanWrite(ChatChannel channel); // в канал "Круг" -- только состоя в Круге
|
||
// Отправить от имени локального игрока. false -- пустое сообщение или канал "Круг" без Круга
|
||
bool Send(ChatChannel channel, string text);
|
||
}
|
||
|
||
// ---------------- Круг: объединение игроков ----------------
|
||
public enum CircleRole
|
||
{
|
||
Leader, // глава
|
||
Member // участник
|
||
}
|
||
|
||
[Serializable]
|
||
public class CircleMember
|
||
{
|
||
public string playerId;
|
||
public string name;
|
||
public CircleRole role;
|
||
}
|
||
|
||
[Serializable]
|
||
public class CircleInfo
|
||
{
|
||
public string id;
|
||
public string name;
|
||
public List<CircleMember> members = new List<CircleMember>();
|
||
|
||
public string LeaderName
|
||
{
|
||
get
|
||
{
|
||
foreach (var m in members) if (m.role == CircleRole.Leader) return m.name;
|
||
return "";
|
||
}
|
||
}
|
||
}
|
||
|
||
public interface ICircle
|
||
{
|
||
int MaxMembers { get; }
|
||
CircleInfo Current { get; } // Круг игрока; null -- игрок не в Круге
|
||
bool IsInCircle { get; }
|
||
bool IsLeader { get; }
|
||
IReadOnlyList<CircleInfo> GetCircles(); // все Круги, в которые можно вступить
|
||
|
||
bool TryCreate(string name, out string error); // создатель становится главой
|
||
bool TryJoin(string circleId, out string error);
|
||
void Leave(); // глава один в Круге -- Круг распускается
|
||
}
|
||
|
||
// ---------------- Сохранения: игровое состояние ----------------
|
||
public interface ISaveSystem
|
||
{
|
||
bool HasSave { get; }
|
||
void SaveNow();
|
||
void DeleteSave();
|
||
// Новая игра: все модули возвращаются к стартовому состоянию, файл перезаписывается
|
||
void ResetAll();
|
||
}
|
||
|
||
// Участник сохранения: каждый модуль сам решает, что и как хранит, в своей секции файла.
|
||
public interface ISaveParticipant
|
||
{
|
||
string SaveKey { get; } // имя секции в файле: "economy", "settlement", "world"...
|
||
string Capture(); // JSON секции; null -- оставить то, что уже было в файле
|
||
void Restore(string json);
|
||
void ResetState(); // вернуться к состоянию новой игры (сброс сохранений)
|
||
}
|
||
|
||
// Список участников. Модули регистрируются сами, модуль Сохранений обходит их при записи и загрузке.
|
||
public static class SaveRegistry
|
||
{
|
||
private static readonly List<ISaveParticipant> participants = new List<ISaveParticipant>();
|
||
|
||
public static IReadOnlyList<ISaveParticipant> All => participants;
|
||
|
||
public static void Register(ISaveParticipant participant)
|
||
{
|
||
participants.RemoveAll(p => p.SaveKey == participant.SaveKey);
|
||
participants.Add(participant);
|
||
}
|
||
|
||
public static void Unregister(ISaveParticipant participant)
|
||
{
|
||
participants.Remove(participant);
|
||
}
|
||
|
||
public static void Clear()
|
||
{
|
||
participants.Clear();
|
||
}
|
||
}
|