Compare commits
30
Commits
@@ -0,0 +1,119 @@
|
||||
using UnityEditor;
|
||||
using UnityEditor.SceneManagement;
|
||||
using UnityEngine;
|
||||
using UnityEngine.Rendering;
|
||||
using UnityEngine.Rendering.Universal;
|
||||
using UnityEngine.SceneManagement;
|
||||
|
||||
// Создаёт сцену 3D-поселения (прототип, этап I ТЗ «Система строительства поселения» от 04.11.2026):
|
||||
// Tools -> Bogatyri -> 3D-город: создать сцену City3D.
|
||||
//
|
||||
// Что делает:
|
||||
// 1. Добавляет в настройки URP второй рендерер -- обычный 3D (Assets/Settings/Renderer3D.asset).
|
||||
// Старые 2D-сцены продолжают рисоваться 2D-рендерером: он остаётся рендерером по умолчанию.
|
||||
// 2. Создаёт Assets/Scenes/City3D.unity: камера (3D-рендерер, перспектива), солнце с тенями,
|
||||
// объект City3D с City3DController -- всё остальное (земля, деревья, здания) он строит сам при запуске.
|
||||
// 3. Добавляет сцену в Build Settings и открывает её. Дальше -- просто Play.
|
||||
public static class City3DSetup
|
||||
{
|
||||
const string ScenePath = "Assets/Scenes/City3D.unity";
|
||||
const string RendererPath = "Assets/Settings/Renderer3D.asset";
|
||||
|
||||
[MenuItem("Tools/Bogatyri/3D-город: создать сцену City3D")]
|
||||
static void Create()
|
||||
{
|
||||
if (!EditorSceneManager.SaveCurrentModifiedScenesIfUserWantsTo()) return;
|
||||
|
||||
int rendererIndex = EnsureRenderer3D();
|
||||
|
||||
var scene = EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single);
|
||||
|
||||
var camGo = new GameObject("Main Camera") { tag = "MainCamera" };
|
||||
var cam = camGo.AddComponent<Camera>();
|
||||
cam.orthographic = false;
|
||||
cam.fieldOfView = 40f;
|
||||
cam.nearClipPlane = 0.3f;
|
||||
cam.farClipPlane = 300f;
|
||||
cam.clearFlags = CameraClearFlags.SolidColor;
|
||||
cam.backgroundColor = new Color(0.55f, 0.72f, 0.9f);
|
||||
camGo.AddComponent<AudioListener>();
|
||||
var data = camGo.AddComponent<UniversalAdditionalCameraData>();
|
||||
if (rendererIndex >= 0) data.SetRenderer(rendererIndex);
|
||||
camGo.AddComponent<City3DCamera>();
|
||||
|
||||
var sunGo = new GameObject("Sun");
|
||||
var sun = sunGo.AddComponent<Light>();
|
||||
sun.type = LightType.Directional;
|
||||
sun.intensity = 1.2f;
|
||||
sun.shadows = LightShadows.Soft;
|
||||
sunGo.transform.rotation = Quaternion.Euler(50f, -30f, 0f);
|
||||
RenderSettings.ambientMode = AmbientMode.Flat;
|
||||
RenderSettings.ambientLight = new Color(0.55f, 0.58f, 0.62f);
|
||||
|
||||
new GameObject("City3D").AddComponent<City3DController>();
|
||||
|
||||
EditorSceneManager.SaveScene(scene, ScenePath);
|
||||
AddToBuildSettings();
|
||||
Debug.Log($"[3D-ГОРОД] Сцена создана: {ScenePath}. 3D-рендерер: индекс {rendererIndex}. Нажмите Play.");
|
||||
}
|
||||
|
||||
// Второй рендерер URP -- обычный (3D). Добавляется в URP Asset из Graphics Settings и из КАЖДОГО уровня качества
|
||||
// (в этом проекте URP задан только в Quality). Возвращает индекс рендерера в списке (или -1)
|
||||
[MenuItem("Tools/Bogatyri/3D: добавить 3D-рендерер в URP")]
|
||||
static void AddRendererMenu()
|
||||
{
|
||||
int index = EnsureRenderer3D();
|
||||
Debug.Log(index >= 0 ? $"[3D] 3D-рендерер подключён (индекс {index}). Можно запускать карту мира и City3D."
|
||||
: "[3D] URP Asset не найден ни в Graphics, ни в Quality Settings.");
|
||||
}
|
||||
|
||||
static int EnsureRenderer3D()
|
||||
{
|
||||
var pipelines = new System.Collections.Generic.List<UniversalRenderPipelineAsset>();
|
||||
void Add(RenderPipelineAsset a) { if (a is UniversalRenderPipelineAsset u && !pipelines.Contains(u)) pipelines.Add(u); }
|
||||
Add(GraphicsSettings.defaultRenderPipeline);
|
||||
for (int q = 0; q < QualitySettings.names.Length; q++) Add(QualitySettings.GetRenderPipelineAssetAt(q));
|
||||
if (pipelines.Count == 0)
|
||||
{
|
||||
Debug.LogWarning("[3D-ГОРОД] Нет URP Asset ни в Graphics, ни в Quality Settings -- камера будет рисовать рендерером по умолчанию");
|
||||
return -1;
|
||||
}
|
||||
|
||||
var renderer = AssetDatabase.LoadAssetAtPath<UniversalRendererData>(RendererPath);
|
||||
if (renderer == null)
|
||||
{
|
||||
renderer = ScriptableObject.CreateInstance<UniversalRendererData>();
|
||||
AssetDatabase.CreateAsset(renderer, RendererPath);
|
||||
AssetDatabase.SaveAssets();
|
||||
}
|
||||
|
||||
int result = -1;
|
||||
foreach (var pipeline in pipelines)
|
||||
{
|
||||
var so = new SerializedObject(pipeline);
|
||||
var list = so.FindProperty("m_RendererDataList");
|
||||
int found = -1;
|
||||
for (int i = 0; i < list.arraySize; i++)
|
||||
if (list.GetArrayElementAtIndex(i).objectReferenceValue == renderer) found = i;
|
||||
if (found < 0)
|
||||
{
|
||||
list.arraySize++;
|
||||
list.GetArrayElementAtIndex(list.arraySize - 1).objectReferenceValue = renderer;
|
||||
so.ApplyModifiedProperties();
|
||||
EditorUtility.SetDirty(pipeline);
|
||||
found = list.arraySize - 1;
|
||||
}
|
||||
if (result < 0) result = found;
|
||||
}
|
||||
AssetDatabase.SaveAssets();
|
||||
return result;
|
||||
}
|
||||
|
||||
static void AddToBuildSettings()
|
||||
{
|
||||
var scenes = new System.Collections.Generic.List<EditorBuildSettingsScene>(EditorBuildSettings.scenes);
|
||||
foreach (var s in scenes) if (s.path == ScenePath) return;
|
||||
scenes.Add(new EditorBuildSettingsScene(ScenePath, true));
|
||||
EditorBuildSettings.scenes = scenes.ToArray();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 37d458150cc84d538a23b4c6612995c7
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -12,12 +12,41 @@ MonoBehaviour:
|
||||
m_Script: {fileID: 11500000, guid: 7264ce138a844adc81fa69b77a27c8a6, type: 3}
|
||||
m_Name: BattleConfig
|
||||
m_EditorClassIdentifier:
|
||||
version: 2
|
||||
version: 8
|
||||
counterPercent: 25
|
||||
wallsPercent: 20
|
||||
siegeVsWallsPercent: 50
|
||||
siegeInFieldPercent: -25
|
||||
loserLossPercent: 50
|
||||
randomPercent: 5
|
||||
famineStrengthPercent: 50
|
||||
fatigueStrengthPercent: 80
|
||||
lossRatioPermille:
|
||||
- 1000
|
||||
- 3000
|
||||
- 5000
|
||||
- 7000
|
||||
- 10000
|
||||
strongLossPermille:
|
||||
- 450
|
||||
- 160
|
||||
- 110
|
||||
- 74
|
||||
- 20
|
||||
weakLossPermille:
|
||||
- 450
|
||||
- 740
|
||||
- 880
|
||||
- 920
|
||||
- 950
|
||||
weakLossMaxPermille: 990
|
||||
deadRatioPermille:
|
||||
- 200
|
||||
- 500
|
||||
- 1000
|
||||
- 3000
|
||||
deadSharePermille:
|
||||
- 700
|
||||
- 450
|
||||
- 300
|
||||
- 200
|
||||
missingSharePermille: 0
|
||||
|
||||
@@ -18,6 +18,11 @@ MonoBehaviour:
|
||||
startSoldiers: 30
|
||||
foodPerCivilianPerHour: 0.1
|
||||
foodPerSoldierPerHour: 0.2
|
||||
foodPerTroopTypePerHour:
|
||||
- 0.15
|
||||
- 0.2
|
||||
- 0.15
|
||||
- 0.15
|
||||
growthPerHour: 2.5
|
||||
housingBase: 300
|
||||
housingPerTownHallLevel: 50
|
||||
|
||||
@@ -0,0 +1,26 @@
|
||||
%YAML 1.1
|
||||
%TAG !u! tag:unity3d.com,2011:
|
||||
--- !u!114 &11400000
|
||||
MonoBehaviour:
|
||||
m_ObjectHideFlags: 0
|
||||
m_CorrespondingSourceObject: {fileID: 0}
|
||||
m_PrefabInstance: {fileID: 0}
|
||||
m_PrefabAsset: {fileID: 0}
|
||||
m_GameObject: {fileID: 0}
|
||||
m_Enabled: 1
|
||||
m_EditorHideFlags: 0
|
||||
m_Script: {fileID: 11500000, guid: c25bbe993b314a15a6d1a8aaf0017d55, type: 3}
|
||||
m_Name: HospitalConfig
|
||||
m_EditorClassIdentifier:
|
||||
bedsByLevel: 140000001e00000028000000320000003c000000
|
||||
temporaryBeds: 5
|
||||
requiredTownHallLevel: 1
|
||||
buildWood: 250
|
||||
buildStone: 150
|
||||
healGameHours: 04000000040000000600000008000000
|
||||
healFoodPerSoldier: 00000000000000000000000000000000
|
||||
healGoldPerSoldier: 01000000010000000200000003000000
|
||||
missingReturnPercent: 50
|
||||
missingWoundedPercent: 30
|
||||
missingWindowGameHours: 6
|
||||
missingMaxGroups: 4
|
||||
@@ -0,0 +1,8 @@
|
||||
fileFormatVersion: 2
|
||||
guid: d92d3f1bd32b432e9a30ee269f436ca0
|
||||
NativeFormatImporter:
|
||||
externalObjects: {}
|
||||
mainObjectFileID: 11400000
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -0,0 +1,23 @@
|
||||
%YAML 1.1
|
||||
%TAG !u! tag:unity3d.com,2011:
|
||||
--- !u!114 &11400000
|
||||
MonoBehaviour:
|
||||
m_ObjectHideFlags: 0
|
||||
m_CorrespondingSourceObject: {fileID: 0}
|
||||
m_PrefabInstance: {fileID: 0}
|
||||
m_PrefabAsset: {fileID: 0}
|
||||
m_GameObject: {fileID: 0}
|
||||
m_Enabled: 1
|
||||
m_EditorHideFlags: 0
|
||||
m_Script: {fileID: 11500000, guid: c249ad34e2f94460b9f99b49c71760c8, type: 3}
|
||||
m_Name: IntelligenceConfig
|
||||
m_EditorClassIdentifier:
|
||||
settlementRadius: 5
|
||||
armyRadius: 1
|
||||
observationPercent: 0a000000140000001e000000
|
||||
testObservationLevel: 0
|
||||
lastContactMinutes: 10
|
||||
approxPercent: 20
|
||||
identifyPercent: 50
|
||||
sampleStepSeconds: 10
|
||||
hideUnexploredObjects: 0
|
||||
@@ -0,0 +1,8 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 4972288700954eda8b97a86b3f7a5492
|
||||
NativeFormatImporter:
|
||||
externalObjects: {}
|
||||
mainObjectFileID: 11400000
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -0,0 +1,8 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 18e162eeff424f8bb3a71543eafba0c8
|
||||
folderAsset: yes
|
||||
DefaultImporter:
|
||||
externalObjects: {}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -0,0 +1,58 @@
|
||||
%YAML 1.1
|
||||
%TAG !u! tag:unity3d.com,2011:
|
||||
--- !u!114 &-7493335797097805923
|
||||
MonoBehaviour:
|
||||
m_ObjectHideFlags: 11
|
||||
m_CorrespondingSourceObject: {fileID: 0}
|
||||
m_PrefabInstance: {fileID: 0}
|
||||
m_PrefabAsset: {fileID: 0}
|
||||
m_GameObject: {fileID: 0}
|
||||
m_Enabled: 1
|
||||
m_EditorHideFlags: 0
|
||||
m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3}
|
||||
m_Name:
|
||||
m_EditorClassIdentifier: Unity.RenderPipelines.Universal.Editor::UnityEditor.Rendering.Universal.AssetVersion
|
||||
version: 10
|
||||
--- !u!21 &2100000
|
||||
Material:
|
||||
serializedVersion: 8
|
||||
m_ObjectHideFlags: 0
|
||||
m_CorrespondingSourceObject: {fileID: 0}
|
||||
m_PrefabInstance: {fileID: 0}
|
||||
m_PrefabAsset: {fileID: 0}
|
||||
m_Name: Map3DLit
|
||||
m_Shader: {fileID: 4800000, guid: 933532a4fcc9baf4fa0491de14d08ed7, type: 3}
|
||||
m_Parent: {fileID: 0}
|
||||
m_ModifiedSerializedProperties: 0
|
||||
m_ValidKeywords: []
|
||||
m_InvalidKeywords: []
|
||||
m_LightmapFlags: 4
|
||||
m_EnableInstancingVariants: 1
|
||||
m_DoubleSidedGI: 0
|
||||
m_CustomRenderQueue: -1
|
||||
stringTagMap:
|
||||
RenderType: Opaque
|
||||
disabledShaderPasses: []
|
||||
m_LockedProperties:
|
||||
m_SavedProperties:
|
||||
serializedVersion: 3
|
||||
m_TexEnvs:
|
||||
- _BaseMap:
|
||||
m_Texture: {fileID: 0}
|
||||
m_Scale: {x: 1, y: 1}
|
||||
m_Offset: {x: 0, y: 0}
|
||||
- _MainTex:
|
||||
m_Texture: {fileID: 0}
|
||||
m_Scale: {x: 1, y: 1}
|
||||
m_Offset: {x: 0, y: 0}
|
||||
m_Ints: []
|
||||
m_Floats:
|
||||
- _Cull: 2
|
||||
- _Metallic: 0
|
||||
- _Smoothness: 0.12
|
||||
- _Surface: 0
|
||||
m_Colors:
|
||||
- _BaseColor: {r: 1, g: 1, b: 1, a: 1}
|
||||
- _Color: {r: 1, g: 1, b: 1, a: 1}
|
||||
m_BuildTextureStacks: []
|
||||
m_AllowLocking: 1
|
||||
@@ -0,0 +1,8 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 0ec4d2749e73404eba2facea709d9f24
|
||||
NativeFormatImporter:
|
||||
externalObjects: {}
|
||||
mainObjectFileID: 2100000
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -0,0 +1,26 @@
|
||||
%YAML 1.1
|
||||
%TAG !u! tag:unity3d.com,2011:
|
||||
--- !u!114 &11400000
|
||||
MonoBehaviour:
|
||||
m_ObjectHideFlags: 0
|
||||
m_CorrespondingSourceObject: {fileID: 0}
|
||||
m_PrefabInstance: {fileID: 0}
|
||||
m_PrefabAsset: {fileID: 0}
|
||||
m_GameObject: {fileID: 0}
|
||||
m_Enabled: 1
|
||||
m_EditorHideFlags: 0
|
||||
m_Script: {fileID: 11500000, guid: 0427eef4612041d2b8a359f9bf358779, type: 3}
|
||||
m_Name: MarchConfig
|
||||
m_EditorClassIdentifier:
|
||||
infantry: 8
|
||||
archers: 9
|
||||
cavalry: 12
|
||||
siege: 4
|
||||
typeSpeedBonusPercent: 00000000000000000000000000000000
|
||||
armySpeedBonusPercent: 0
|
||||
baseMarchSlots: 2
|
||||
patrolsEnabled: 1
|
||||
patrolMaxActive: 3
|
||||
patrolIntervalMinutes: 10
|
||||
patrolSoldiersMin: 10
|
||||
patrolSoldiersMax: 40
|
||||
@@ -0,0 +1,8 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 99295aa9eabc4ab6bf8cc687f4d89d96
|
||||
NativeFormatImporter:
|
||||
externalObjects: {}
|
||||
mainObjectFileID: 11400000
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -0,0 +1,58 @@
|
||||
%YAML 1.1
|
||||
%TAG !u! tag:unity3d.com,2011:
|
||||
--- !u!114 &11400000
|
||||
MonoBehaviour:
|
||||
m_ObjectHideFlags: 0
|
||||
m_CorrespondingSourceObject: {fileID: 0}
|
||||
m_PrefabInstance: {fileID: 0}
|
||||
m_PrefabAsset: {fileID: 0}
|
||||
m_GameObject: {fileID: 0}
|
||||
m_Enabled: 1
|
||||
m_EditorHideFlags: 0
|
||||
m_Script: {fileID: 11500000, guid: 6ee3759b377140c0b759a4a386327510, type: 3}
|
||||
m_Name: WorldResourceConfig
|
||||
m_EditorClassIdentifier:
|
||||
woodStock:
|
||||
- 200
|
||||
- 600
|
||||
- 1500
|
||||
stoneStock:
|
||||
- 150
|
||||
- 450
|
||||
- 1000
|
||||
metalStock:
|
||||
- 80
|
||||
- 250
|
||||
- 600
|
||||
goldStock:
|
||||
- 30
|
||||
- 100
|
||||
- 250
|
||||
woodPerGameHour: 2
|
||||
stonePerGameHour: 1.5
|
||||
metalPerGameHour: 1
|
||||
goldPerGameHour: 0.5
|
||||
woodCargo: 12
|
||||
stoneCargo: 10
|
||||
metalCargo: 8
|
||||
goldCargo: 5
|
||||
lifetimeRealHours:
|
||||
- 12
|
||||
- 24
|
||||
- 48
|
||||
woodCount:
|
||||
- 4
|
||||
- 3
|
||||
- 1
|
||||
stoneCount:
|
||||
- 4
|
||||
- 2
|
||||
- 1
|
||||
metalCount:
|
||||
- 2
|
||||
- 2
|
||||
- 1
|
||||
goldCount:
|
||||
- 2
|
||||
- 1
|
||||
- 1
|
||||
@@ -0,0 +1,8 @@
|
||||
fileFormatVersion: 2
|
||||
guid: b95775cbe52447a6abff99bfeb488500
|
||||
NativeFormatImporter:
|
||||
externalObjects: {}
|
||||
mainObjectFileID: 11400000
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -0,0 +1,431 @@
|
||||
%YAML 1.1
|
||||
%TAG !u! tag:unity3d.com,2011:
|
||||
--- !u!29 &1
|
||||
OcclusionCullingSettings:
|
||||
m_ObjectHideFlags: 0
|
||||
serializedVersion: 2
|
||||
m_OcclusionBakeSettings:
|
||||
smallestOccluder: 5
|
||||
smallestHole: 0.25
|
||||
backfaceThreshold: 100
|
||||
m_SceneGUID: 00000000000000000000000000000000
|
||||
m_OcclusionCullingData: {fileID: 0}
|
||||
--- !u!104 &2
|
||||
RenderSettings:
|
||||
m_ObjectHideFlags: 0
|
||||
serializedVersion: 10
|
||||
m_Fog: 0
|
||||
m_FogColor: {r: 0.5, g: 0.5, b: 0.5, a: 1}
|
||||
m_FogMode: 3
|
||||
m_FogDensity: 0.01
|
||||
m_LinearFogStart: 0
|
||||
m_LinearFogEnd: 300
|
||||
m_AmbientSkyColor: {r: 0.55, g: 0.58, b: 0.62, a: 1}
|
||||
m_AmbientEquatorColor: {r: 0.114, g: 0.125, b: 0.133, a: 1}
|
||||
m_AmbientGroundColor: {r: 0.047, g: 0.043, b: 0.035, a: 1}
|
||||
m_AmbientIntensity: 1
|
||||
m_AmbientMode: 3
|
||||
m_SubtractiveShadowColor: {r: 0.42, g: 0.478, b: 0.627, a: 1}
|
||||
m_SkyboxMaterial: {fileID: 0}
|
||||
m_HaloStrength: 0.5
|
||||
m_FlareStrength: 1
|
||||
m_FlareFadeSpeed: 3
|
||||
m_HaloTexture: {fileID: 0}
|
||||
m_SpotCookie: {fileID: 10001, guid: 0000000000000000e000000000000000, type: 0}
|
||||
m_DefaultReflectionMode: 0
|
||||
m_DefaultReflectionResolution: 128
|
||||
m_ReflectionBounces: 1
|
||||
m_ReflectionIntensity: 1
|
||||
m_CustomReflection: {fileID: 0}
|
||||
m_Sun: {fileID: 0}
|
||||
m_UseRadianceAmbientProbe: 0
|
||||
--- !u!157 &3
|
||||
LightmapSettings:
|
||||
m_ObjectHideFlags: 0
|
||||
serializedVersion: 13
|
||||
m_BakeOnSceneLoad: 0
|
||||
m_GISettings:
|
||||
serializedVersion: 2
|
||||
m_BounceScale: 1
|
||||
m_IndirectOutputScale: 1
|
||||
m_AlbedoBoost: 1
|
||||
m_EnvironmentLightingMode: 0
|
||||
m_EnableBakedLightmaps: 0
|
||||
m_EnableRealtimeLightmaps: 0
|
||||
m_LightmapEditorSettings:
|
||||
serializedVersion: 12
|
||||
m_Resolution: 2
|
||||
m_BakeResolution: 40
|
||||
m_AtlasSize: 1024
|
||||
m_AO: 0
|
||||
m_AOMaxDistance: 1
|
||||
m_CompAOExponent: 1
|
||||
m_CompAOExponentDirect: 0
|
||||
m_ExtractAmbientOcclusion: 0
|
||||
m_Padding: 2
|
||||
m_LightmapParameters: {fileID: 0}
|
||||
m_LightmapsBakeMode: 1
|
||||
m_TextureCompression: 1
|
||||
m_ReflectionCompression: 2
|
||||
m_MixedBakeMode: 2
|
||||
m_BakeBackend: 2
|
||||
m_PVRSampling: 1
|
||||
m_PVRDirectSampleCount: 32
|
||||
m_PVRSampleCount: 512
|
||||
m_PVRBounces: 2
|
||||
m_PVREnvironmentSampleCount: 256
|
||||
m_PVREnvironmentReferencePointCount: 2048
|
||||
m_PVRFilteringMode: 1
|
||||
m_PVRDenoiserTypeDirect: 1
|
||||
m_PVRDenoiserTypeIndirect: 1
|
||||
m_PVRDenoiserTypeAO: 1
|
||||
m_PVRFilterTypeDirect: 0
|
||||
m_PVRFilterTypeIndirect: 0
|
||||
m_PVRFilterTypeAO: 0
|
||||
m_PVREnvironmentMIS: 1
|
||||
m_PVRCulling: 1
|
||||
m_PVRFilteringGaussRadiusDirect: 1
|
||||
m_PVRFilteringGaussRadiusIndirect: 1
|
||||
m_PVRFilteringGaussRadiusAO: 1
|
||||
m_PVRFilteringAtrousPositionSigmaDirect: 0.5
|
||||
m_PVRFilteringAtrousPositionSigmaIndirect: 2
|
||||
m_PVRFilteringAtrousPositionSigmaAO: 1
|
||||
m_ExportTrainingData: 0
|
||||
m_TrainingDataDestination: TrainingData
|
||||
m_LightProbeSampleCountMultiplier: 4
|
||||
m_LightingDataAsset: {fileID: 20201, guid: 0000000000000000f000000000000000, type: 0}
|
||||
m_LightingSettings: {fileID: 0}
|
||||
--- !u!196 &4
|
||||
NavMeshSettings:
|
||||
serializedVersion: 2
|
||||
m_ObjectHideFlags: 0
|
||||
m_BuildSettings:
|
||||
serializedVersion: 3
|
||||
agentTypeID: 0
|
||||
agentRadius: 0.5
|
||||
agentHeight: 2
|
||||
agentSlope: 45
|
||||
agentClimb: 0.4
|
||||
ledgeDropHeight: 0
|
||||
maxJumpAcrossDistance: 0
|
||||
minRegionArea: 2
|
||||
manualCellSize: 0
|
||||
cellSize: 0.16666667
|
||||
manualTileSize: 0
|
||||
tileSize: 256
|
||||
buildHeightMesh: 0
|
||||
maxJobWorkers: 0
|
||||
preserveTilesOutsideBounds: 0
|
||||
debug:
|
||||
m_Flags: 0
|
||||
m_NavMeshData: {fileID: 0}
|
||||
--- !u!1 &110794169
|
||||
GameObject:
|
||||
m_ObjectHideFlags: 0
|
||||
m_CorrespondingSourceObject: {fileID: 0}
|
||||
m_PrefabInstance: {fileID: 0}
|
||||
m_PrefabAsset: {fileID: 0}
|
||||
serializedVersion: 6
|
||||
m_Component:
|
||||
- component: {fileID: 110794174}
|
||||
- component: {fileID: 110794173}
|
||||
- component: {fileID: 110794172}
|
||||
- component: {fileID: 110794171}
|
||||
- component: {fileID: 110794170}
|
||||
m_Layer: 0
|
||||
m_Name: Main Camera
|
||||
m_TagString: MainCamera
|
||||
m_Icon: {fileID: 0}
|
||||
m_NavMeshLayer: 0
|
||||
m_StaticEditorFlags: 0
|
||||
m_IsActive: 1
|
||||
--- !u!114 &110794170
|
||||
MonoBehaviour:
|
||||
m_ObjectHideFlags: 0
|
||||
m_CorrespondingSourceObject: {fileID: 0}
|
||||
m_PrefabInstance: {fileID: 0}
|
||||
m_PrefabAsset: {fileID: 0}
|
||||
m_GameObject: {fileID: 110794169}
|
||||
m_Enabled: 1
|
||||
m_EditorHideFlags: 0
|
||||
m_Script: {fileID: 11500000, guid: e8645f0028574904969b5802443f100f, type: 3}
|
||||
m_Name:
|
||||
m_EditorClassIdentifier: Assembly-CSharp::City3DCamera
|
||||
pitch: 52
|
||||
yaw: 45
|
||||
distance: 26
|
||||
minDistance: 8
|
||||
maxDistance: 55
|
||||
target: {x: 0, y: 0, z: 0}
|
||||
bounds:
|
||||
serializedVersion: 2
|
||||
x: 0
|
||||
y: 0
|
||||
width: 48
|
||||
height: 48
|
||||
--- !u!114 &110794171
|
||||
MonoBehaviour:
|
||||
m_ObjectHideFlags: 0
|
||||
m_CorrespondingSourceObject: {fileID: 0}
|
||||
m_PrefabInstance: {fileID: 0}
|
||||
m_PrefabAsset: {fileID: 0}
|
||||
m_GameObject: {fileID: 110794169}
|
||||
m_Enabled: 1
|
||||
m_EditorHideFlags: 0
|
||||
m_Script: {fileID: 11500000, guid: a79441f348de89743a2939f4d699eac1, type: 3}
|
||||
m_Name:
|
||||
m_EditorClassIdentifier: Unity.RenderPipelines.Universal.Runtime::UnityEngine.Rendering.Universal.UniversalAdditionalCameraData
|
||||
m_RenderShadows: 1
|
||||
m_RequiresDepthTextureOption: 2
|
||||
m_RequiresOpaqueTextureOption: 2
|
||||
m_CameraType: 0
|
||||
m_Cameras: []
|
||||
m_RendererIndex: -1
|
||||
m_VolumeLayerMask:
|
||||
serializedVersion: 2
|
||||
m_Bits: 1
|
||||
m_VolumeTrigger: {fileID: 0}
|
||||
m_VolumeFrameworkUpdateModeOption: 2
|
||||
m_RenderPostProcessing: 0
|
||||
m_Antialiasing: 0
|
||||
m_AntialiasingQuality: 2
|
||||
m_StopNaN: 0
|
||||
m_Dithering: 0
|
||||
m_ClearDepth: 1
|
||||
m_AllowXRRendering: 1
|
||||
m_AllowHDROutput: 1
|
||||
m_UseScreenCoordOverride: 0
|
||||
m_ScreenSizeOverride: {x: 0, y: 0, z: 0, w: 0}
|
||||
m_ScreenCoordScaleBias: {x: 0, y: 0, z: 0, w: 0}
|
||||
m_RequiresDepthTexture: 0
|
||||
m_RequiresColorTexture: 0
|
||||
m_TaaSettings:
|
||||
m_Quality: 3
|
||||
m_FrameInfluence: 0.1
|
||||
m_JitterScale: 1
|
||||
m_MipBias: 0
|
||||
m_VarianceClampScale: 0.9
|
||||
m_ContrastAdaptiveSharpening: 0
|
||||
m_Version: 2
|
||||
--- !u!81 &110794172
|
||||
AudioListener:
|
||||
m_ObjectHideFlags: 0
|
||||
m_CorrespondingSourceObject: {fileID: 0}
|
||||
m_PrefabInstance: {fileID: 0}
|
||||
m_PrefabAsset: {fileID: 0}
|
||||
m_GameObject: {fileID: 110794169}
|
||||
m_Enabled: 1
|
||||
--- !u!20 &110794173
|
||||
Camera:
|
||||
m_ObjectHideFlags: 0
|
||||
m_CorrespondingSourceObject: {fileID: 0}
|
||||
m_PrefabInstance: {fileID: 0}
|
||||
m_PrefabAsset: {fileID: 0}
|
||||
m_GameObject: {fileID: 110794169}
|
||||
m_Enabled: 1
|
||||
serializedVersion: 2
|
||||
m_ClearFlags: 2
|
||||
m_BackGroundColor: {r: 0.55, g: 0.72, b: 0.9, a: 1}
|
||||
m_projectionMatrixMode: 1
|
||||
m_GateFitMode: 2
|
||||
m_FOVAxisMode: 0
|
||||
m_Iso: 200
|
||||
m_ShutterSpeed: 0.005
|
||||
m_Aperture: 16
|
||||
m_FocusDistance: 10
|
||||
m_FocalLength: 50
|
||||
m_BladeCount: 5
|
||||
m_Curvature: {x: 2, y: 11}
|
||||
m_BarrelClipping: 0.25
|
||||
m_Anamorphism: 0
|
||||
m_SensorSize: {x: 36, y: 24}
|
||||
m_LensShift: {x: 0, y: 0}
|
||||
m_NormalizedViewPortRect:
|
||||
serializedVersion: 2
|
||||
x: 0
|
||||
y: 0
|
||||
width: 1
|
||||
height: 1
|
||||
near clip plane: 0.3
|
||||
far clip plane: 300
|
||||
field of view: 40
|
||||
orthographic: 0
|
||||
orthographic size: 5
|
||||
m_Depth: 0
|
||||
m_CullingMask:
|
||||
serializedVersion: 2
|
||||
m_Bits: 4294967295
|
||||
m_RenderingPath: -1
|
||||
m_TargetTexture: {fileID: 0}
|
||||
m_TargetDisplay: 0
|
||||
m_TargetEye: 3
|
||||
m_HDR: 1
|
||||
m_AllowMSAA: 1
|
||||
m_AllowDynamicResolution: 0
|
||||
m_ForceIntoRT: 0
|
||||
m_OcclusionCulling: 1
|
||||
m_StereoConvergence: 10
|
||||
m_StereoSeparation: 0.022
|
||||
--- !u!4 &110794174
|
||||
Transform:
|
||||
m_ObjectHideFlags: 0
|
||||
m_CorrespondingSourceObject: {fileID: 0}
|
||||
m_PrefabInstance: {fileID: 0}
|
||||
m_PrefabAsset: {fileID: 0}
|
||||
m_GameObject: {fileID: 110794169}
|
||||
serializedVersion: 2
|
||||
m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
|
||||
m_LocalPosition: {x: 0, y: 0, z: 0}
|
||||
m_LocalScale: {x: 1, y: 1, z: 1}
|
||||
m_ConstrainProportionsScale: 0
|
||||
m_Children: []
|
||||
m_Father: {fileID: 0}
|
||||
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
|
||||
--- !u!1 &1225367365
|
||||
GameObject:
|
||||
m_ObjectHideFlags: 0
|
||||
m_CorrespondingSourceObject: {fileID: 0}
|
||||
m_PrefabInstance: {fileID: 0}
|
||||
m_PrefabAsset: {fileID: 0}
|
||||
serializedVersion: 6
|
||||
m_Component:
|
||||
- component: {fileID: 1225367367}
|
||||
- component: {fileID: 1225367366}
|
||||
m_Layer: 0
|
||||
m_Name: City3D
|
||||
m_TagString: Untagged
|
||||
m_Icon: {fileID: 0}
|
||||
m_NavMeshLayer: 0
|
||||
m_StaticEditorFlags: 0
|
||||
m_IsActive: 1
|
||||
--- !u!114 &1225367366
|
||||
MonoBehaviour:
|
||||
m_ObjectHideFlags: 0
|
||||
m_CorrespondingSourceObject: {fileID: 0}
|
||||
m_PrefabInstance: {fileID: 0}
|
||||
m_PrefabAsset: {fileID: 0}
|
||||
m_GameObject: {fileID: 1225367365}
|
||||
m_Enabled: 1
|
||||
m_EditorHideFlags: 0
|
||||
m_Script: {fileID: 11500000, guid: 44d822c903694362bef912c055adda5b, type: 3}
|
||||
m_Name:
|
||||
m_EditorClassIdentifier: Assembly-CSharp::City3DController
|
||||
--- !u!4 &1225367367
|
||||
Transform:
|
||||
m_ObjectHideFlags: 0
|
||||
m_CorrespondingSourceObject: {fileID: 0}
|
||||
m_PrefabInstance: {fileID: 0}
|
||||
m_PrefabAsset: {fileID: 0}
|
||||
m_GameObject: {fileID: 1225367365}
|
||||
serializedVersion: 2
|
||||
m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
|
||||
m_LocalPosition: {x: 0, y: 0, z: 0}
|
||||
m_LocalScale: {x: 1, y: 1, z: 1}
|
||||
m_ConstrainProportionsScale: 0
|
||||
m_Children: []
|
||||
m_Father: {fileID: 0}
|
||||
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
|
||||
--- !u!1 &1935466178
|
||||
GameObject:
|
||||
m_ObjectHideFlags: 0
|
||||
m_CorrespondingSourceObject: {fileID: 0}
|
||||
m_PrefabInstance: {fileID: 0}
|
||||
m_PrefabAsset: {fileID: 0}
|
||||
serializedVersion: 6
|
||||
m_Component:
|
||||
- component: {fileID: 1935466180}
|
||||
- component: {fileID: 1935466179}
|
||||
m_Layer: 0
|
||||
m_Name: Sun
|
||||
m_TagString: Untagged
|
||||
m_Icon: {fileID: 0}
|
||||
m_NavMeshLayer: 0
|
||||
m_StaticEditorFlags: 0
|
||||
m_IsActive: 1
|
||||
--- !u!108 &1935466179
|
||||
Light:
|
||||
m_ObjectHideFlags: 0
|
||||
m_CorrespondingSourceObject: {fileID: 0}
|
||||
m_PrefabInstance: {fileID: 0}
|
||||
m_PrefabAsset: {fileID: 0}
|
||||
m_GameObject: {fileID: 1935466178}
|
||||
m_Enabled: 1
|
||||
serializedVersion: 13
|
||||
m_Type: 1
|
||||
m_Color: {r: 1, g: 1, b: 1, a: 1}
|
||||
m_Intensity: 1.2
|
||||
m_Range: 10
|
||||
m_SpotAngle: 30
|
||||
m_InnerSpotAngle: 21.80208
|
||||
m_CookieSize2D: {x: 0.5, y: 0.5}
|
||||
m_Shadows:
|
||||
m_Type: 2
|
||||
m_Resolution: -1
|
||||
m_CustomResolution: -1
|
||||
m_Strength: 1
|
||||
m_Bias: 0.05
|
||||
m_NormalBias: 0.4
|
||||
m_NearPlane: 0.2
|
||||
m_CullingMatrixOverride:
|
||||
e00: 1
|
||||
e01: 0
|
||||
e02: 0
|
||||
e03: 0
|
||||
e10: 0
|
||||
e11: 1
|
||||
e12: 0
|
||||
e13: 0
|
||||
e20: 0
|
||||
e21: 0
|
||||
e22: 1
|
||||
e23: 0
|
||||
e30: 0
|
||||
e31: 0
|
||||
e32: 0
|
||||
e33: 1
|
||||
m_UseCullingMatrixOverride: 0
|
||||
m_Cookie: {fileID: 0}
|
||||
m_DrawHalo: 0
|
||||
m_Flare: {fileID: 0}
|
||||
m_RenderMode: 0
|
||||
m_CullingMask:
|
||||
serializedVersion: 2
|
||||
m_Bits: 4294967295
|
||||
m_RenderingLayerMask: 1
|
||||
m_Lightmapping: 4
|
||||
m_LightShadowCasterMode: 0
|
||||
m_AreaSize: {x: 1, y: 1}
|
||||
m_BounceIntensity: 1
|
||||
m_ColorTemperature: 6570
|
||||
m_UseColorTemperature: 0
|
||||
m_BoundingSphereOverride: {x: 0, y: 0, z: 0, w: 0}
|
||||
m_UseBoundingSphereOverride: 0
|
||||
m_UseViewFrustumForShadowCasterCull: 1
|
||||
m_ForceVisible: 0
|
||||
m_ShapeRadius: 0.025
|
||||
m_ShadowAngle: 0
|
||||
m_LightUnit: 1
|
||||
m_LuxAtDistance: 1
|
||||
m_EnableSpotReflector: 1
|
||||
--- !u!4 &1935466180
|
||||
Transform:
|
||||
m_ObjectHideFlags: 0
|
||||
m_CorrespondingSourceObject: {fileID: 0}
|
||||
m_PrefabInstance: {fileID: 0}
|
||||
m_PrefabAsset: {fileID: 0}
|
||||
m_GameObject: {fileID: 1935466178}
|
||||
serializedVersion: 2
|
||||
m_LocalRotation: {x: 0.40821794, y: -0.23456973, z: 0.10938166, w: 0.8754261}
|
||||
m_LocalPosition: {x: 0, y: 0, z: 0}
|
||||
m_LocalScale: {x: 1, y: 1, z: 1}
|
||||
m_ConstrainProportionsScale: 0
|
||||
m_Children: []
|
||||
m_Father: {fileID: 0}
|
||||
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
|
||||
--- !u!1660057539 &9223372036854775807
|
||||
SceneRoots:
|
||||
m_ObjectHideFlags: 0
|
||||
m_Roots:
|
||||
- {fileID: 110794174}
|
||||
- {fileID: 1935466180}
|
||||
- {fileID: 1225367367}
|
||||
@@ -0,0 +1,7 @@
|
||||
fileFormatVersion: 2
|
||||
guid: c1c34719f0605c247a3575d077f3d656
|
||||
DefaultImporter:
|
||||
externalObjects: {}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -13,7 +13,7 @@ using UnityEngine;
|
||||
public class BattleConfig : ScriptableObject
|
||||
{
|
||||
[Tooltip("Версия баланса боя. Поменял числа -- подними версию: итог боя запоминает, по какой версии посчитан")]
|
||||
public int version = 2;
|
||||
public int version = 4;
|
||||
|
||||
[Tooltip("Контра, %: пехота > кавалерия > лучники > пехота. Взвешивается по доле нужного типа у врага")]
|
||||
public int counterPercent = 25;
|
||||
@@ -23,11 +23,28 @@ public class BattleConfig : ScriptableObject
|
||||
public int siegeVsWallsPercent = 50;
|
||||
[Tooltip("Осадные в поле и в обороне, % (минус)")]
|
||||
public int siegeInFieldPercent = -25;
|
||||
[Tooltip("Потери проигравшего, % от каждого типа. Не окончательная формула")]
|
||||
public int loserLossPercent = 50;
|
||||
[Tooltip("Случайность каждой стороны: от -N% до +N%. 0 -- без случайности")]
|
||||
public int randomPercent = 5;
|
||||
|
||||
[Header("Кривая потерь (решение №14, регламент 31.10, ТЕСТ)")]
|
||||
[Tooltip("Опорные точки соотношения сил (сильная / слабая) в десятых долях процента: 1000 = 1:1, 3000 = 3:1. Первая -- обязательно 1000, дальше по возрастанию")]
|
||||
public int[] lossRatioPermille = { 1000, 3000, 5000, 7000, 10000 };
|
||||
[Tooltip("Доля выбывших у сильной стороны в каждой точке, десятые доли процента: 450 = 45%")]
|
||||
public int[] strongLossPermille = { 450, 160, 110, 74, 20 };
|
||||
[Tooltip("Доля выбывших у слабой стороны в каждой точке, десятые доли процента: 740 = 74%")]
|
||||
public int[] weakLossPermille = { 450, 740, 880, 920, 950 };
|
||||
[Tooltip("Разгром дальше последней точки: слабая сторона плавно стремится к этому пределу, десятые доли процента. Решения 31.10, п. 5: 990 = 99%")]
|
||||
public int weakLossMaxPermille = 990;
|
||||
|
||||
[Header("Погибшие и раненые (регламент 31.10, решения 31.10, п. 7, ТЕСТ)")]
|
||||
[Tooltip("Соотношение сил стороны (своя / чужая) в десятых долях процента: 200 = 1:5, 1000 = 1:1, 3000 = 3:1. По возрастанию")]
|
||||
public int[] deadRatioPermille = { 200, 500, 1000, 3000 };
|
||||
[Tooltip("Доля погибших среди выбывших в каждой точке, десятые доли процента: 700 = 70%. Остальные выбывшие -- раненые")]
|
||||
public int[] deadSharePermille = { 700, 450, 300, 200 };
|
||||
|
||||
[Tooltip("Пропавшие без вести (решения 01.11, п. 5): доля выбывших, десятые доли процента. НЕ УТВЕРЖДЕНА -- 0, механика выключена. Для проверки -- например 150 (15%)")]
|
||||
public int missingSharePermille = 0;
|
||||
|
||||
[Tooltip("Голод: сколько силы остаётся, %. Утверждено 27.10.2026: -50% (остаётся 50). Проверяется на момент боя")]
|
||||
public int famineStrengthPercent = 50;
|
||||
[Tooltip("Усталость: сколько силы остаётся, %. Утверждено 27.10.2026: -20% (остаётся 80). Вместе с голодом -- 40%")]
|
||||
@@ -58,7 +75,13 @@ public class BattleConfig : ScriptableObject
|
||||
WallsPercent = wallsPercent,
|
||||
SiegeVsWallsPercent = siegeVsWallsPercent,
|
||||
SiegeInFieldPercent = siegeInFieldPercent,
|
||||
LoserLossPercent = loserLossPercent,
|
||||
LossRatioPermille = lossRatioPermille,
|
||||
StrongLossPermille = strongLossPermille,
|
||||
WeakLossPermille = weakLossPermille,
|
||||
WeakLossMaxPermille = weakLossMaxPermille,
|
||||
DeadRatioPermille = deadRatioPermille,
|
||||
DeadSharePermille = deadSharePermille,
|
||||
MissingSharePermille = Mathf.Clamp(missingSharePermille, 0, 1000),
|
||||
RandomPercent = Mathf.Max(0, randomPercent),
|
||||
FamineStrengthPercent = Mathf.Clamp(famineStrengthPercent, 0, 100),
|
||||
FatigueStrengthPercent = Mathf.Clamp(fatigueStrengthPercent, 0, 100)
|
||||
|
||||
@@ -54,10 +54,12 @@ public static class BuildingWindow
|
||||
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;
|
||||
|
||||
if (focus == null) WorkersList(card);
|
||||
else if (townHall != null) TownHallSection(card, townHall);
|
||||
else if (barracks != null) BarracksSection(card, barracks);
|
||||
else if (hospital != null) HospitalSection(card, hospital);
|
||||
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);
|
||||
@@ -261,11 +263,11 @@ public static class BuildingWindow
|
||||
Header(card, "Обучение");
|
||||
Live(card, () =>
|
||||
{
|
||||
var d = gp.Data;
|
||||
if (d.training.Count == 0) return "Никто не обучается";
|
||||
var o = d.training[0];
|
||||
string more = d.training.Count > 1 ? $" (ещё заказов: {d.training.Count - 1})" : "";
|
||||
return $"{GameData.Troops[o.troopIndex].name} ×{o.count} — осталось {GameData.FormatTime(gp.TrainingSecondsLeft(o))}{more}";
|
||||
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);
|
||||
@@ -298,6 +300,46 @@ public static class BuildingWindow
|
||||
}, -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);
|
||||
}
|
||||
|
||||
// Резерв для найма на уровне Ратуши (те же числа, что у модуля Населения)
|
||||
static int ReserveAt(int townHallLevel)
|
||||
{
|
||||
@@ -320,10 +362,10 @@ public static class BuildingWindow
|
||||
|
||||
// ---------------- Улучшение (общее для зданий с уровнем, кроме Ратуши) ----------------
|
||||
|
||||
static void UpgradeBlock(RectTransform card, int level, string effect, Action raiseLevel)
|
||||
static void UpgradeBlock(RectTransform card, int level, string effect, Action raiseLevel, int maxLevel = 0)
|
||||
{
|
||||
var config = EconomyConfig.Load();
|
||||
if (level >= config.upgrade.maxLevel)
|
||||
if (level >= (maxLevel > 0 ? maxLevel : config.upgrade.maxLevel)) // у госпиталя свой предел: I-V
|
||||
{
|
||||
UIKit.Text(card, "Максимальный уровень", 26, UIKit.Theme.Gold, TextAlignmentOptions.Center);
|
||||
return;
|
||||
|
||||
@@ -24,8 +24,11 @@ public class EconomyConfig : ScriptableObject
|
||||
|
||||
[Tooltip("Еды в час на одного жителя")]
|
||||
public float foodPerCivilianPerHour = 0.1f;
|
||||
[Tooltip("Еды в час на одного воина")]
|
||||
[Tooltip("Еды в час на одного воина (и новобранца в Казармах), если норма по типам не задана")]
|
||||
public float foodPerSoldierPerHour = 0.2f;
|
||||
[Tooltip("Еды в час на воина по типам: пехота, лучники, кавалерия, осадные. Решения 01.11, п. 4: 0,15 / 0,20 / 0,15 / 0,15. " +
|
||||
"Раненые едят так же, даже ожидая койку. Пусто -- все по foodPerSoldierPerHour")]
|
||||
public float[] foodPerTroopTypePerHour = { 0.15f, 0.2f, 0.15f, 0.15f };
|
||||
|
||||
[Tooltip("Прирост людей в час, если есть еда (документ: 2–3)")]
|
||||
public float growthPerHour = 2.5f;
|
||||
|
||||
@@ -22,12 +22,52 @@ public static class GameModules
|
||||
for (int i = 0; i < TroopType.Count && i < GameData.Troops.Count; i++) unitPower[i] = GameData.Troops[i].power;
|
||||
GameServices.Register<IBattleSystem>(new BattleSystem(BattleConfig.Load().ToRules(unitPower)));
|
||||
|
||||
// Марши: скорости по типам -- в модуль Мира, слоты похода -- в модуль Армии (таблица MarchConfig)
|
||||
var marchConfig = MarchConfig.Load();
|
||||
MarchManager.SpeedRules = marchConfig.ToSpeedRules();
|
||||
MarchManager.PointRules = WorldResourceConfig.Load().ToRules(); // ресурсные точки (регламент 31.10)
|
||||
MarchManager.Patrols = marchConfig.ToPatrolRules(); // патрули-заглушки соседей (Разведка М1)
|
||||
|
||||
// Разведка -- чистый C#: туман, обзор, чужие армии (секция "intelligence"). Карту и армии читает у Мира
|
||||
// через IWorldMap; досчитывает наблюдение перед каждым расчётом мира (WorldAdvancingEvent)
|
||||
var intelConfig = IntelligenceConfig.Load();
|
||||
var intelligence = new IntelligenceService(intelConfig.ToRules());
|
||||
GameServices.Register<IIntelligence>(intelligence);
|
||||
SaveRegistry.Register(intelligence);
|
||||
EventBus.Subscribe<WorldAdvancingEvent>(e => intelligence.ObserveUntil(e.ToMs));
|
||||
// «Обзор» для теста, пока нет дерева технологий (после загрузки и в новой игре)
|
||||
void TestObservation() { if (intelConfig.testObservationLevel > 0) intelligence.ObservationLevel = intelConfig.testObservationLevel; }
|
||||
TestObservation();
|
||||
EventBus.Subscribe<GameLoadedEvent>(_ => TestObservation());
|
||||
EventBus.Subscribe<GameResetEvent>(_ => TestObservation());
|
||||
|
||||
// Армия -- чистый C#, единственное место хранения войск (секция "army")
|
||||
var army = new ArmyService();
|
||||
var army = new ArmyService(marchConfig.baseMarchSlots, HospitalConfig.Load().ToRules(), HospitalConfig.Load().ToMissingRules()); // госпиталь, пропавшие
|
||||
GameServices.Register<IArmy>(army);
|
||||
SaveRegistry.Register(army);
|
||||
EventBus.Subscribe<TroopsChangedEvent>(_ => { if (GameProgress.HasInstance) GameProgress.Instance.MarkChanged(); });
|
||||
EventBus.Subscribe<GameLoadedEvent>(_ => MigrateLegacyArmy(army));
|
||||
// Очередь обучения -- у Армии (решения 31.10, п. 8): статистика заданий по её событию, старая очередь -- переносится
|
||||
EventBus.Subscribe<TroopsTrainedEvent>(e => { if (GameProgress.HasInstance) GameProgress.Instance.OnTroopsTrained(e); });
|
||||
EventBus.Subscribe<GameLoadedEvent>(_ => MigrateLegacyTraining(army));
|
||||
// Пропавшие без вести вернулись / списаны (решения 01.11, п. 5)
|
||||
EventBus.Subscribe<MissingReturnedEvent>(e =>
|
||||
{
|
||||
if (e.Healthy + e.Wounded > 0)
|
||||
UIKit.Toast($"Вернулись пропавшие без вести: {e.Healthy + e.Wounded}" + (e.Wounded > 0 ? $" (ранены {e.Wounded} -- в госпиталь)" : ""));
|
||||
if (GameProgress.HasInstance) GameProgress.Instance.MarkChanged();
|
||||
});
|
||||
EventBus.Subscribe<MissingWrittenOffEvent>(e =>
|
||||
{
|
||||
if (e.Count > 0) UIKit.Toast($"Не вернулись и списаны пропавшие без вести: {e.Count}");
|
||||
if (GameProgress.HasInstance) GameProgress.Instance.MarkChanged();
|
||||
});
|
||||
// Раненые вылечены -- вернулись в город
|
||||
EventBus.Subscribe<SoldiersHealedEvent>(e =>
|
||||
{
|
||||
if (e.Type >= 0 && e.Type < GameData.Troops.Count) UIKit.Toast("Вылечены в госпитале: " + e.Count + " × " + GameData.Troops[e.Type].name);
|
||||
if (GameProgress.HasInstance) GameProgress.Instance.MarkChanged();
|
||||
});
|
||||
|
||||
// Население -- чистый C#: жители, рабочие, еда, прирост (секция "population"). Числа -- из EconomyConfig.
|
||||
var config = EconomyConfig.Load();
|
||||
@@ -71,6 +111,10 @@ public static class GameModules
|
||||
// Казармы появляются в списке стройки кодом -- до восстановления зданий из сохранения
|
||||
EventBus.Subscribe<SettlementRestoringEvent>(_ => BarracksBootstrap.Ensure());
|
||||
|
||||
// Госпиталь (решения 31.10, п. 7): здание города даёт места для лечения Армии через контракт IHospital
|
||||
GameServices.Register<IHospital>(new HospitalBeds());
|
||||
EventBus.Subscribe<SettlementRestoringEvent>(_ => HospitalBootstrap.Ensure());
|
||||
|
||||
// Статистика для заданий (GameProgress) -- по событиям Мира
|
||||
EventBus.Subscribe<MarchStartedEvent>(OnMarchStarted);
|
||||
EventBus.Subscribe<MarchReturnedEvent>(OnMarchReturned);
|
||||
@@ -135,6 +179,36 @@ public static class GameModules
|
||||
GameProgress.Instance.MarkChanged();
|
||||
}
|
||||
|
||||
// Очередь обучения раньше вёл GameProgress (progress.json, Data.training, время -- тики реальных часов).
|
||||
// Теперь -- Армия (save.json, "army", мс часов игры). Переносим один раз, с тем же оставшимся временем.
|
||||
static void MigrateLegacyTraining(ArmyService army)
|
||||
{
|
||||
var data = GameProgress.Instance.Data;
|
||||
if (data.training == null || data.training.Count == 0) return;
|
||||
|
||||
// В Армии уже есть заказы -- перенос уже был (сохранение записалось, а progress.json -- ещё нет): только убрать старое
|
||||
if (army.Training.Count == 0)
|
||||
{
|
||||
long epochTicks = new System.DateTime(1970, 1, 1, 0, 0, 0, System.DateTimeKind.Utc).Ticks;
|
||||
long offsetMs = GameClock.OffsetSeconds * 1000; // старые тики -- реальное время, Армия -- часы игры
|
||||
var orders = new System.Collections.Generic.List<(int, int, long, long, bool)>();
|
||||
foreach (var o in data.training)
|
||||
orders.Add((o.troopIndex, o.count, (o.startTicks - epochTicks) / 10_000 + offsetMs, (o.endTicks - epochTicks) / 10_000 + offsetMs, o.recruited));
|
||||
army.ImportLegacyTraining(orders);
|
||||
Debug.Log($"[МОДУЛИ] Очередь обучения перенесена из progress.json в модуль Армии: заказов {orders.Count}.");
|
||||
}
|
||||
|
||||
// Из progress.json убираем, только когда очередь уже записана в save.json -- иначе вылет игры её потеряет
|
||||
EventBus.Subscribe<GameSavedEvent>(ClearLegacyTraining);
|
||||
}
|
||||
|
||||
static void ClearLegacyTraining(GameSavedEvent e)
|
||||
{
|
||||
EventBus.Unsubscribe<GameSavedEvent>(ClearLegacyTraining);
|
||||
GameProgress.Instance.Data.training.Clear();
|
||||
GameProgress.Instance.MarkChanged();
|
||||
}
|
||||
|
||||
// ---------------- Население и экономика ----------------
|
||||
|
||||
static PopulationRules ToPopulationRules(EconomyConfig config)
|
||||
@@ -147,6 +221,8 @@ public static class GameModules
|
||||
StartSoldiers = p.startSoldiers,
|
||||
FoodPerCivilianPerHour = p.foodPerCivilianPerHour,
|
||||
FoodPerSoldierPerHour = p.foodPerSoldierPerHour,
|
||||
FoodPerTroopTypePerHour = p.foodPerTroopTypePerHour != null && p.foodPerTroopTypePerHour.Length > 0
|
||||
? System.Array.ConvertAll(p.foodPerTroopTypePerHour, f => (double)f) : null,
|
||||
GrowthPerHour = p.growthPerHour,
|
||||
HousingBase = p.housingBase,
|
||||
HousingPerTownHallLevel = p.housingPerTownHallLevel,
|
||||
|
||||
@@ -0,0 +1,89 @@
|
||||
using UnityEngine;
|
||||
|
||||
// ТАБЛИЦА ГОСПИТАЛЯ: места и время лечения раненых (регламент 31.10, решения по 8 вопросам Саши от 31.10, п. 7). Числа -- ТЕСТ.
|
||||
//
|
||||
// Ассет: Assets/Resources/HospitalConfig.asset (выдели его в окне Project и меняй числа в Inspector;
|
||||
// изменения действуют со следующего запуска игры). Создать заново: правый клик в Project ->
|
||||
// Create -> Bogatyri -> Hospital Config, имя файла -- HospitalConfig, папка -- Resources.
|
||||
//
|
||||
// Модуль Армии таблицу не видит: App/GameModules передаёт числа в ArmyService.
|
||||
// Места даёт здание «Госпиталь» (Meta/Build/Hospital.cs) через контракт IHospital.
|
||||
[CreateAssetMenu(fileName = "HospitalConfig", menuName = "Bogatyri/Hospital Config")]
|
||||
public class HospitalConfig : ScriptableObject
|
||||
{
|
||||
[Header("Здание «Госпиталь» (ТЕСТ)")]
|
||||
[Tooltip("Мест для лечения по уровням госпиталя I..V. Регламент 31.10: 20..60. Число строк -- число уровней")]
|
||||
public int[] bedsByLevel = { 20, 30, 40, 50, 60 };
|
||||
[Tooltip("Мест, пока в городе нет госпиталя. Решения 01.11, п. 3: 5. После постройки заменяются штатными, не складываются")]
|
||||
public int temporaryBeds = 5;
|
||||
[Tooltip("С какого уровня Ратуши можно строить")]
|
||||
public int requiredTownHallLevel = 1;
|
||||
[Tooltip("Цена постройки: дерево")]
|
||||
public int buildWood = 250;
|
||||
[Tooltip("Цена постройки: камень")]
|
||||
public int buildStone = 150;
|
||||
|
||||
[Header("Лечение одного воина, ИГРОВЫХ часов (1 игровой час = 5 реальных минут)")]
|
||||
[Tooltip("Пехота, лучники, кавалерия, осадные. Регламент 31.10: 4 / 4 / 6 / 8")]
|
||||
public int[] healGameHours = { 4, 4, 6, 8 };
|
||||
|
||||
[Header("Цена лечения одного воина (решения 01.11, п. 3: золото 1 / 1 / 2 / 3)")]
|
||||
[Tooltip("Еды за воина: пехота, лучники, кавалерия, осадные")]
|
||||
public int[] healFoodPerSoldier = { 0, 0, 0, 0 };
|
||||
[Tooltip("Золота за воина: пехота, лучники, кавалерия, осадные")]
|
||||
public int[] healGoldPerSoldier = { 1, 1, 2, 3 };
|
||||
|
||||
[Header("Пропавшие без вести (решения 01.11, п. 5). Долю пропавших в бою задаёт BattleConfig.missingSharePermille")]
|
||||
[Tooltip("Сколько пропавших вернётся, %. Утверждён диапазон 10-90%, формула НЕ утверждена -- ТЕСТ")]
|
||||
public int missingReturnPercent = 50;
|
||||
[Tooltip("Из вернувшихся ранены, %. Утверждено: 30 (70% здоровыми)")]
|
||||
public int missingWoundedPercent = 30;
|
||||
[Tooltip("Окно возвращения после обратного пути, ИГРОВЫХ часов. Утверждено: до 6")]
|
||||
public int missingWindowGameHours = 6;
|
||||
[Tooltip("Возвращаются группами: от 2 до стольких. Утверждено: 2-4")]
|
||||
public int missingMaxGroups = 4;
|
||||
|
||||
static HospitalConfig cached;
|
||||
|
||||
public static HospitalConfig Load()
|
||||
{
|
||||
if (cached != null) return cached;
|
||||
cached = Resources.Load<HospitalConfig>("HospitalConfig");
|
||||
if (cached == null)
|
||||
{
|
||||
Debug.LogWarning("[ГОСПИТАЛЬ] Нет Assets/Resources/HospitalConfig.asset -- берутся числа по умолчанию из HospitalConfig.cs.");
|
||||
cached = CreateInstance<HospitalConfig>();
|
||||
}
|
||||
return cached;
|
||||
}
|
||||
|
||||
public MissingRules ToMissingRules()
|
||||
{
|
||||
return new MissingRules
|
||||
{
|
||||
ReturnPercent = Mathf.Clamp(missingReturnPercent, 0, 100),
|
||||
WoundedPercent = Mathf.Clamp(missingWoundedPercent, 0, 100),
|
||||
WindowGameHours = Mathf.Max(0, missingWindowGameHours),
|
||||
MaxGroups = Mathf.Max(2, missingMaxGroups)
|
||||
};
|
||||
}
|
||||
|
||||
public HospitalRules ToRules()
|
||||
{
|
||||
var hours = new int[TroopType.Count];
|
||||
var cost = new ResourceAmount[TroopType.Count][];
|
||||
for (int i = 0; i < TroopType.Count; i++)
|
||||
{
|
||||
hours[i] = healGameHours != null && i < healGameHours.Length ? Mathf.Max(0, healGameHours[i]) : 4;
|
||||
int food = healFoodPerSoldier != null && i < healFoodPerSoldier.Length ? Mathf.Max(0, healFoodPerSoldier[i]) : 0;
|
||||
int gold = healGoldPerSoldier != null && i < healGoldPerSoldier.Length ? Mathf.Max(0, healGoldPerSoldier[i]) : 0;
|
||||
cost[i] = new[] { new ResourceAmount(ResourceType.Food, food), new ResourceAmount(ResourceType.Gold, gold) };
|
||||
}
|
||||
return new HospitalRules
|
||||
{
|
||||
TemporaryBeds = Mathf.Max(0, temporaryBeds),
|
||||
HealGameHours = hours,
|
||||
HealCostPerSoldier = cost
|
||||
};
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
fileFormatVersion: 2
|
||||
guid: c25bbe993b314a15a6d1a8aaf0017d55
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -0,0 +1,73 @@
|
||||
using UnityEngine;
|
||||
|
||||
// ТАБЛИЦА РАЗВЕДКИ, этап М1: радиусы обзора, последний контакт, примерная численность, опознание (ТЗ разведки 31.10).
|
||||
// Числа -- ТЕСТ.
|
||||
//
|
||||
// Ассет: Assets/Resources/IntelligenceConfig.asset (выдели его в окне Project и меняй числа в Inspector;
|
||||
// изменения действуют со следующего запуска игры). Создать заново: правый клик в Project ->
|
||||
// Create -> Bogatyri -> Intelligence Config, имя файла -- IntelligenceConfig, папка -- Resources.
|
||||
//
|
||||
// Модуль таблицу не видит: App/GameModules передаёт числа в модуль Разведки.
|
||||
// Патрули-заглушки соседей включаются в таблице MarchConfig (это походы Мира).
|
||||
[CreateAssetMenu(fileName = "IntelligenceConfig", menuName = "Bogatyri/Intelligence Config")]
|
||||
public class IntelligenceConfig : ScriptableObject
|
||||
{
|
||||
[Header("Радиус обзора, клеток карты")]
|
||||
[Tooltip("Своё поселение. ТЗ разведки: 5")]
|
||||
public float settlementRadius = 5f;
|
||||
[Tooltip("Обычная армия в походе. ТЗ разведки: 1")]
|
||||
public float armyRadius = 1f;
|
||||
|
||||
[Header("Технология «Обзор» (не складывается, уровень заменяет)")]
|
||||
[Tooltip("Прибавка к радиусам на уровнях I, II, III, %. ТЗ: 10 / 20 / 30")]
|
||||
public int[] observationPercent = { 10, 20, 30 };
|
||||
[Tooltip("ТОЛЬКО ДЛЯ ТЕСТА: уровень «Обзора» 0..3, пока нет дерева технологий")]
|
||||
public int testObservationLevel = 0;
|
||||
|
||||
[Header("Чужие армии")]
|
||||
[Tooltip("Метка последнего контакта живёт, РЕАЛЬНЫХ минут. ТЗ: 10")]
|
||||
public float lastContactMinutes = 10f;
|
||||
[Tooltip("Примерная численность: ±%. ТЗ: 20")]
|
||||
public int approxPercent = 20;
|
||||
[Tooltip("Шанс опознать владельца за одно событие наблюдения, %. ТЗ: 50")]
|
||||
public int identifyPercent = 50;
|
||||
[Tooltip("Шаг расчёта наблюдения за время, пока игра была закрыта, РЕАЛЬНЫХ секунд")]
|
||||
public float sampleStepSeconds = 10f;
|
||||
|
||||
[Header("Туман на карте")]
|
||||
[Tooltip("Выключено (по умолчанию): города, лагеря и точки видны всегда, туман только затемняет землю. " +
|
||||
"Включено: неисследованная местность закрыта полностью вместе с объектами. Решения 31.10, п. 1: для М1 не требуется, оставлено переключателем")]
|
||||
public bool hideUnexploredObjects = false;
|
||||
|
||||
static IntelligenceConfig cached;
|
||||
|
||||
public static IntelligenceConfig Load()
|
||||
{
|
||||
if (cached != null) return cached;
|
||||
cached = Resources.Load<IntelligenceConfig>("IntelligenceConfig");
|
||||
if (cached == null)
|
||||
{
|
||||
Debug.LogWarning("[РАЗВЕДКА] Нет Assets/Resources/IntelligenceConfig.asset -- берутся числа по умолчанию из IntelligenceConfig.cs.");
|
||||
cached = CreateInstance<IntelligenceConfig>();
|
||||
}
|
||||
return cached;
|
||||
}
|
||||
|
||||
public IntelligenceRules ToRules()
|
||||
{
|
||||
var levels = new int[4];
|
||||
for (int i = 0; i < 3 && observationPercent != null && i < observationPercent.Length; i++) levels[i + 1] = Mathf.Max(0, observationPercent[i]);
|
||||
return new IntelligenceRules
|
||||
{
|
||||
SettlementRadius = Milli(settlementRadius),
|
||||
ArmyRadius = Milli(armyRadius),
|
||||
ObservationPercent = levels,
|
||||
LastContactMs = (long)(Mathf.Max(0f, lastContactMinutes) * 60_000f),
|
||||
ApproxPercent = Mathf.Clamp(approxPercent, 0, 100),
|
||||
IdentifyPercent = Mathf.Clamp(identifyPercent, 0, 100),
|
||||
SampleStepMs = (long)(Mathf.Max(1f, sampleStepSeconds) * 1000f)
|
||||
};
|
||||
}
|
||||
|
||||
static int Milli(float cells) => Mathf.Max(0, Mathf.RoundToInt(cells * 1000f));
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
fileFormatVersion: 2
|
||||
guid: c249ad34e2f94460b9f99b49c71760c8
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -0,0 +1,82 @@
|
||||
using UnityEngine;
|
||||
|
||||
// ТАБЛИЦА МАРШЕЙ: скорости войск по типам и слоты похода (регламент 31.10, раздел 7). Числа -- ТЕСТ.
|
||||
//
|
||||
// Ассет: Assets/Resources/MarchConfig.asset (выдели его в окне Project и меняй числа в Inspector;
|
||||
// изменения действуют со следующего запуска игры). Создать заново: правый клик в Project ->
|
||||
// Create -> Bogatyri -> March Config, имя файла -- MarchConfig, папка -- Resources.
|
||||
//
|
||||
// Модули таблицу не видят: App/GameModules передаёт скорости в модуль Мира, слоты -- в модуль Армии.
|
||||
// Бонусы героя (+15%) и технологии (+20%) к скорости появятся вместе с героями и технологиями.
|
||||
[CreateAssetMenu(fileName = "MarchConfig", menuName = "Bogatyri/March Config")]
|
||||
public class MarchConfig : ScriptableObject
|
||||
{
|
||||
[Header("Скорость: клеток карты за 1 РЕАЛЬНЫЙ час (марш идёт в реальном времени)")]
|
||||
[Tooltip("Пехота. Регламент 31.10: 8")]
|
||||
public float infantry = 8f;
|
||||
[Tooltip("Лучники. Регламент 31.10: 9")]
|
||||
public float archers = 9f;
|
||||
[Tooltip("Кавалерия. Регламент 31.10: 12")]
|
||||
public float cavalry = 12f;
|
||||
[Tooltip("Осадные. Регламент 31.10: 4")]
|
||||
public float siege = 4f;
|
||||
|
||||
[Header("Модификаторы скорости, % (решения 31.10, п. 4: смешанное войско -- средняя по численности)")]
|
||||
[Tooltip("По типам: пехота, лучники, кавалерия, осадные. +10 -- быстрее на 10%. Позже -- бонусы героев и технологий. ТЕСТ")]
|
||||
public int[] typeSpeedBonusPercent = { 0, 0, 0, 0 };
|
||||
[Tooltip("Общий модификатор всего войска, применяется один раз. ТЕСТ")]
|
||||
public int armySpeedBonusPercent = 0;
|
||||
|
||||
[Header("Слоты похода")]
|
||||
[Tooltip("Сколько походов игрока могут идти одновременно. Регламент 31.10: 2 (технология «Военная логистика» -- до 7)")]
|
||||
public int baseMarchSlots = 2;
|
||||
|
||||
[Header("Патрули-заглушки соседей (Разведка М1, ВРЕМЕННАЯ тестовая механика)")]
|
||||
[Tooltip("Соседние города иногда отправляют отряды к другим городам и лагерям -- проверить обнаружение, численность, опознание и потерю контакта. Выключить, когда появится настоящий PvP")]
|
||||
public bool patrolsEnabled = true;
|
||||
[Tooltip("Сколько патрулей одновременно на карте")]
|
||||
public int patrolMaxActive = 3;
|
||||
[Tooltip("Новый патруль -- раз в столько РЕАЛЬНЫХ минут (если не превышен предел)")]
|
||||
public float patrolIntervalMinutes = 10f;
|
||||
public int patrolSoldiersMin = 10;
|
||||
public int patrolSoldiersMax = 40;
|
||||
|
||||
static MarchConfig cached;
|
||||
|
||||
public static MarchConfig Load()
|
||||
{
|
||||
if (cached != null) return cached;
|
||||
cached = Resources.Load<MarchConfig>("MarchConfig");
|
||||
if (cached == null)
|
||||
{
|
||||
Debug.LogWarning("[МАРШИ] Нет Assets/Resources/MarchConfig.asset -- берутся числа по умолчанию из MarchConfig.cs.");
|
||||
cached = CreateInstance<MarchConfig>();
|
||||
}
|
||||
return cached;
|
||||
}
|
||||
|
||||
// Скорости для модуля Мира: милли-единиц карты (1000 = клетка) за реальный час
|
||||
public Bogatyri.World.MarchSpeedRules ToSpeedRules()
|
||||
{
|
||||
return new Bogatyri.World.MarchSpeedRules
|
||||
{
|
||||
SpeedMilliPerHour = new[] { Milli(infantry), Milli(archers), Milli(cavalry), Milli(siege) },
|
||||
TypeBonusPercent = (int[])(typeSpeedBonusPercent ?? new int[4]).Clone(),
|
||||
ArmyBonusPercent = armySpeedBonusPercent
|
||||
};
|
||||
}
|
||||
|
||||
public Bogatyri.World.PatrolRules ToPatrolRules()
|
||||
{
|
||||
return new Bogatyri.World.PatrolRules
|
||||
{
|
||||
Enabled = patrolsEnabled,
|
||||
MaxActive = Mathf.Max(0, patrolMaxActive),
|
||||
IntervalMs = (long)(Mathf.Max(1f, patrolIntervalMinutes) * 60_000f),
|
||||
SoldiersMin = Mathf.Max(1, patrolSoldiersMin),
|
||||
SoldiersMax = Mathf.Max(1, patrolSoldiersMax)
|
||||
};
|
||||
}
|
||||
|
||||
static int Milli(float cellsPerHour) => Mathf.Max(1, Mathf.RoundToInt(cellsPerHour * 1000f));
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 0427eef4612041d2b8a359f9bf358779
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -0,0 +1,84 @@
|
||||
using UnityEngine;
|
||||
|
||||
// ТАБЛИЦА РЕСУРСНЫХ ТОЧЕК (регламент 31.10, раздел 7: «Изменять числа через WorldResourceConfig.asset»). Числа -- ТЕСТ.
|
||||
//
|
||||
// Ассет: Assets/Resources/WorldResourceConfig.asset (выдели его в окне Project и меняй числа в Inspector;
|
||||
// изменения действуют со следующего запуска игры). Создать заново: правый клик в Project ->
|
||||
// Create -> Bogatyri -> World Resource Config, имя файла -- WorldResourceConfig, папка -- Resources.
|
||||
//
|
||||
// Модуль Мира таблицу не видит: App/GameModules переводит её в ResourcePointRules.
|
||||
// Состояние точек (запас, сроки) ведёт Мир; зачисление добычи и складские лимиты -- Экономика (решение №46).
|
||||
[CreateAssetMenu(fileName = "WorldResourceConfig", menuName = "Bogatyri/World Resource Config")]
|
||||
public class WorldResourceConfig : ScriptableObject
|
||||
{
|
||||
[Header("Запас точки: малая / средняя / крупная")]
|
||||
public int[] woodStock = { 200, 600, 1500 };
|
||||
public int[] stoneStock = { 150, 450, 1000 };
|
||||
public int[] metalStock = { 80, 250, 600 };
|
||||
public int[] goldStock = { 30, 100, 250 };
|
||||
|
||||
[Header("Добыча одного воина за ИГРОВОЙ час (1 игровой час = 5 реальных минут)")]
|
||||
public float woodPerGameHour = 2f;
|
||||
public float stonePerGameHour = 1.5f;
|
||||
public float metalPerGameHour = 1f;
|
||||
public float goldPerGameHour = 0.5f;
|
||||
|
||||
[Header("Груз одного воина (осадные машины груза не несут)")]
|
||||
public int woodCargo = 12;
|
||||
public int stoneCargo = 10;
|
||||
public int metalCargo = 8;
|
||||
public int goldCargo = 5;
|
||||
|
||||
[Header("Срок жизни точки, РЕАЛЬНЫХ часов с момента появления: малая / средняя / крупная")]
|
||||
public int[] lifetimeRealHours = { 12, 24, 48 };
|
||||
|
||||
[Header("Сколько точек на карте: малых / средних / крупных (решения 31.10, п. 6, ТЕСТ)")]
|
||||
[Tooltip("Решения 31.10: всего 24 -- лес 8, камень 7, металл 5, золото 4; по размерам 12 / 8 / 4. Раскладка по ресурсам -- здесь")]
|
||||
public int[] woodCount = { 4, 3, 1 };
|
||||
public int[] stoneCount = { 4, 2, 1 };
|
||||
public int[] metalCount = { 2, 2, 1 };
|
||||
public int[] goldCount = { 2, 1, 1 };
|
||||
|
||||
static WorldResourceConfig cached;
|
||||
|
||||
public static WorldResourceConfig Load()
|
||||
{
|
||||
if (cached != null) return cached;
|
||||
cached = Resources.Load<WorldResourceConfig>("WorldResourceConfig");
|
||||
if (cached == null)
|
||||
{
|
||||
Debug.LogWarning("[РЕСУРСНЫЕ ТОЧКИ] Нет Assets/Resources/WorldResourceConfig.asset -- берутся числа по умолчанию.");
|
||||
cached = CreateInstance<WorldResourceConfig>();
|
||||
}
|
||||
return cached;
|
||||
}
|
||||
|
||||
public Bogatyri.World.ResourcePointRules ToRules()
|
||||
{
|
||||
var d = Bogatyri.World.ResourcePointRules.Default;
|
||||
return new Bogatyri.World.ResourcePointRules
|
||||
{
|
||||
Stock = new[] { Three(woodStock, d.Stock[0]), Three(stoneStock, d.Stock[1]), Three(metalStock, d.Stock[2]), Three(goldStock, d.Stock[3]) },
|
||||
MiningMilliPerGameHour = new[] { Milli(woodPerGameHour), Milli(stonePerGameHour), Milli(metalPerGameHour), Milli(goldPerGameHour) },
|
||||
CargoPerSoldier = new[] { Mathf.Max(0, woodCargo), Mathf.Max(0, stoneCargo), Mathf.Max(0, metalCargo), Mathf.Max(0, goldCargo) },
|
||||
LifetimeRealHours = Three(lifetimeRealHours, d.LifetimeRealHours),
|
||||
Count = new[] { Counts(woodCount, d.Count[0]), Counts(stoneCount, d.Count[1]), Counts(metalCount, d.Count[2]), Counts(goldCount, d.Count[3]) }
|
||||
};
|
||||
}
|
||||
|
||||
static int Milli(float perHour) => Mathf.Max(0, Mathf.RoundToInt(perHour * 1000f));
|
||||
|
||||
// Число точек: ровно три значения, не меньше 0 (0 -- такого размера нет), иначе -- значения по умолчанию
|
||||
static int[] Counts(int[] values, int[] fallback)
|
||||
{
|
||||
if (values == null || values.Length != 3) return (int[])fallback.Clone();
|
||||
return new[] { Mathf.Max(0, values[0]), Mathf.Max(0, values[1]), Mathf.Max(0, values[2]) };
|
||||
}
|
||||
|
||||
// Ровно три значения (малая / средняя / крупная), иначе -- значения по умолчанию
|
||||
static int[] Three(int[] values, int[] fallback)
|
||||
{
|
||||
if (values == null || values.Length != 3) return (int[])fallback.Clone();
|
||||
return new[] { Mathf.Max(1, values[0]), Mathf.Max(1, values[1]), Mathf.Max(1, values[2]) };
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 6ee3759b377140c0b759a4a386327510
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -0,0 +1,8 @@
|
||||
fileFormatVersion: 2
|
||||
guid: efa023adb1ce408c971a4f76ced19585
|
||||
folderAsset: yes
|
||||
DefaultImporter:
|
||||
externalObjects: {}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -0,0 +1,106 @@
|
||||
using UnityEngine;
|
||||
|
||||
// КАМЕРА 3D-ПОСЕЛЕНИЯ (2.5D): наклонный вид под фиксированным углом, без вращения.
|
||||
// Перемещение -- перетаскиванием (палец / мышь), приближение -- двумя пальцами или колесом.
|
||||
// Не уходит за пределы полезной карты. FocusOn -- плавно показать область (открытие новой зоны).
|
||||
public class City3DCamera : MonoBehaviour
|
||||
{
|
||||
public float pitch = 52f; // наклон, градусы от горизонта
|
||||
public float yaw = 45f; // поворот вида вокруг вертикали
|
||||
public float distance = 26f;
|
||||
public float minDistance = 8f;
|
||||
public float maxDistance = 55f;
|
||||
|
||||
public Vector3 target; // точка на земле, на которую смотрит камера
|
||||
public Rect bounds = new Rect(0, 0, 48, 48); // где может быть target (x, z)
|
||||
|
||||
Camera cam;
|
||||
Vector3 focusTarget;
|
||||
float focusDistance;
|
||||
bool focusing;
|
||||
Vector3 lastPointer;
|
||||
bool panning;
|
||||
float lastPinch;
|
||||
|
||||
// Перемещение камеры пальцем можно выключить на время перетаскивания здания
|
||||
public bool AllowPan { get; set; } = true;
|
||||
|
||||
void Awake()
|
||||
{
|
||||
cam = GetComponent<Camera>();
|
||||
}
|
||||
|
||||
public void FocusOn(Rect area)
|
||||
{
|
||||
focusTarget = new Vector3(area.center.x, 0, area.center.y);
|
||||
// отойти так, чтобы область поместилась по высоте экрана (с запасом)
|
||||
float size = Mathf.Max(area.width, area.height);
|
||||
focusDistance = Mathf.Clamp(size * 1.15f, minDistance, maxDistance);
|
||||
focusing = true;
|
||||
}
|
||||
|
||||
// Начать / продолжить / закончить перемещение камеры. Зовёт контроллер ввода (он решает, что под пальцем)
|
||||
public void BeginPan(Vector3 screen) { panning = AllowPan; lastPointer = screen; focusing = false; }
|
||||
public void EndPan() { panning = false; }
|
||||
|
||||
public void Pan(Vector3 screen)
|
||||
{
|
||||
if (!panning || cam == null) return;
|
||||
Vector3 a = GroundPoint(lastPointer), b = GroundPoint(screen);
|
||||
target += a - b;
|
||||
lastPointer = screen;
|
||||
Clamp();
|
||||
}
|
||||
|
||||
public void Zoom(float delta)
|
||||
{
|
||||
focusing = false;
|
||||
distance = Mathf.Clamp(distance * (1f - delta), minDistance, maxDistance);
|
||||
}
|
||||
|
||||
void Update()
|
||||
{
|
||||
// Колесо мыши (редактор, ПК)
|
||||
float wheel = Input.mouseScrollDelta.y;
|
||||
if (Mathf.Abs(wheel) > 0.01f) Zoom(wheel * 0.1f);
|
||||
|
||||
// Два пальца -- приближение
|
||||
if (Input.touchCount == 2)
|
||||
{
|
||||
float d = Vector2.Distance(Input.GetTouch(0).position, Input.GetTouch(1).position);
|
||||
if (Input.GetTouch(1).phase == TouchPhase.Began) lastPinch = d;
|
||||
else if (lastPinch > 0) { Zoom((d - lastPinch) / Mathf.Max(200f, Screen.height)); lastPinch = d; }
|
||||
}
|
||||
else lastPinch = 0;
|
||||
|
||||
if (focusing)
|
||||
{
|
||||
target = Vector3.Lerp(target, focusTarget, Time.unscaledDeltaTime * 2.5f);
|
||||
distance = Mathf.Lerp(distance, focusDistance, Time.unscaledDeltaTime * 2.5f);
|
||||
if (Vector3.Distance(target, focusTarget) < 0.05f && Mathf.Abs(distance - focusDistance) < 0.05f) focusing = false;
|
||||
}
|
||||
Apply();
|
||||
}
|
||||
|
||||
void Clamp()
|
||||
{
|
||||
target.x = Mathf.Clamp(target.x, bounds.xMin, bounds.xMax);
|
||||
target.z = Mathf.Clamp(target.z, bounds.yMin, bounds.yMax);
|
||||
target.y = 0;
|
||||
}
|
||||
|
||||
public void Apply()
|
||||
{
|
||||
Quaternion rot = Quaternion.Euler(pitch, yaw, 0);
|
||||
transform.rotation = rot;
|
||||
transform.position = target - rot * Vector3.forward * distance;
|
||||
}
|
||||
|
||||
// Точка на плоскости земли (y = 0) под экранной точкой
|
||||
Vector3 GroundPoint(Vector3 screen)
|
||||
{
|
||||
Ray ray = cam.ScreenPointToRay(screen);
|
||||
var plane = new Plane(Vector3.up, Vector3.zero);
|
||||
return plane.Raycast(ray, out float t) ? ray.GetPoint(t) : target;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
fileFormatVersion: 2
|
||||
guid: e8645f0028574904969b5802443f100f
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -0,0 +1,755 @@
|
||||
using System.Collections.Generic;
|
||||
using Bogatyri.Settlement.Placement;
|
||||
using TMPro;
|
||||
using UnityEngine;
|
||||
|
||||
// 3D-ПОСЕЛЕНИЕ, ЭТАП I -- ПРОТОТИП НА ПРИМИТИВАХ (ТЗ «Система строительства поселения» от 04.11.2026).
|
||||
// Сцена Assets/Scenes/City3D.unity (создаётся: Tools -> Bogatyri -> 3D-город: создать сцену City3D).
|
||||
//
|
||||
// Что умеет:
|
||||
// - местность с холмами, рекой, скалами, деревьями, валунами и травой (City3DLayout);
|
||||
// - невидимая сетка: видна только в режиме стройки / редактирования вместе с границей открытой зоны;
|
||||
// - новое здание: выбрать тип -> призрак-куб тянется пальцем, привязан к клеткам, зелёный / красный с причиной,
|
||||
// поворот 0/90/180/270, «Поставить» / «Отмена»;
|
||||
// - перенос: кнопка в меню здания или общий режим редактирования; то же здание (тот же id), подтверждение / отмена;
|
||||
// - расчистка дерева / валуна (без ожидания и цены); трава прячется под зданием и возвращается;
|
||||
// - зоны по уровню Ратуши (кнопки «Ратуша -/+» -- ТОЛЬКО ДЛЯ ТЕСТА), камера плавно показывает новую зону.
|
||||
// Правила места -- в модуле Поселения (Bogatyri.Settlement.Placement, тесты PlacementTests), здесь только показ и ввод.
|
||||
//
|
||||
// Пока НЕ подключено (этапы II-III): цена и таймер стройки, Экономика и награда за расчистку, сохранение,
|
||||
// дороги, настоящие модели. Кнопки -- временные (IMGUI); окна согласуются с Володей.
|
||||
public class City3DController : MonoBehaviour
|
||||
{
|
||||
// Тип здания для прототипа: максимальный габарит (клеток) с первого уровня, высота куба, цвет
|
||||
struct BuildingType
|
||||
{
|
||||
public string Name;
|
||||
public int W, H;
|
||||
public float Height;
|
||||
public Color Color;
|
||||
}
|
||||
|
||||
static readonly BuildingType[] Types =
|
||||
{
|
||||
new BuildingType { Name = "Ратуша", W = 4, H = 4, Height = 3.0f, Color = new Color(0.85f, 0.75f, 0.35f) },
|
||||
new BuildingType { Name = "Дом", W = 2, H = 2, Height = 1.4f, Color = new Color(0.85f, 0.55f, 0.35f) },
|
||||
new BuildingType { Name = "Ферма", W = 3, H = 3, Height = 1.0f, Color = new Color(0.9f, 0.85f, 0.4f) },
|
||||
new BuildingType { Name = "Лесопилка", W = 3, H = 2, Height = 1.5f, Color = new Color(0.55f, 0.4f, 0.25f) },
|
||||
new BuildingType { Name = "Каменоломня", W = 3, H = 2, Height = 1.3f, Color = new Color(0.6f, 0.6f, 0.62f) },
|
||||
new BuildingType { Name = "Шахта", W = 2, H = 2, Height = 1.5f, Color = new Color(0.4f, 0.45f, 0.55f) },
|
||||
new BuildingType { Name = "Склад", W = 2, H = 3, Height = 1.8f, Color = new Color(0.65f, 0.5f, 0.3f) },
|
||||
new BuildingType { Name = "Амбар", W = 2, H = 3, Height = 1.8f, Color = new Color(0.8f, 0.65f, 0.3f) },
|
||||
new BuildingType { Name = "Казармы", W = 3, H = 3, Height = 2.0f, Color = new Color(0.75f, 0.3f, 0.3f) },
|
||||
new BuildingType { Name = "Госпиталь", W = 3, H = 3, Height = 1.8f, Color = new Color(0.85f, 0.95f, 1f) },
|
||||
};
|
||||
|
||||
enum Mode { View, Edit, Place, Move }
|
||||
|
||||
City3DLayout layout;
|
||||
SettlementMap map;
|
||||
City3DCamera cameraRig;
|
||||
Camera cam;
|
||||
Material baseMaterial;
|
||||
Texture2D groundTexture;
|
||||
const int PixelsPerCell = 8;
|
||||
|
||||
readonly Dictionary<string, GameObject> buildingViews = new Dictionary<string, GameObject>();
|
||||
readonly Dictionary<string, int> buildingType = new Dictionary<string, int>();
|
||||
readonly Dictionary<string, GameObject> obstacleViews = new Dictionary<string, GameObject>();
|
||||
readonly List<GameObject> grassViews = new List<GameObject>();
|
||||
int nextBuildingId = 1;
|
||||
int townHallLevel = 1;
|
||||
|
||||
Mode mode = Mode.View;
|
||||
int placingType = -1; // Place: какой тип ставим
|
||||
string movingId; // Move: какое здание переносим
|
||||
int ghostX, ghostY, ghostRot;
|
||||
PlacedRect moveOriginal; // Move: последнее подтверждённое положение
|
||||
GameObject ghost, footprint;
|
||||
Material okMaterial, badMaterial;
|
||||
PlaceError ghostError;
|
||||
int ghostFoundation;
|
||||
bool draggingGhost;
|
||||
Vector3 pointerDown;
|
||||
bool pointerMoved, pointerOverGui;
|
||||
|
||||
string selectedBuilding, selectedObstacle; // меню здания / препятствия (тап в обычном режиме)
|
||||
string message = "";
|
||||
float messageUntil;
|
||||
|
||||
// ---------------- Построение сцены ----------------
|
||||
|
||||
void Start()
|
||||
{
|
||||
cam = Camera.main;
|
||||
Map3D.UseRenderer3D(cam); // обычный 3D-рендерер URP (на случай, если сцену собрали вручную)
|
||||
cameraRig = cam.GetComponent<City3DCamera>() ?? cam.gameObject.AddComponent<City3DCamera>();
|
||||
cameraRig.bounds = new Rect(2, 2, City3DLayout.Size - 4, City3DLayout.Size - 4);
|
||||
cameraRig.target = new Vector3(City3DLayout.Size / 2f, 0, City3DLayout.Size / 2f);
|
||||
cameraRig.Apply();
|
||||
|
||||
Map3D.SetUpLook(cam, 30f, 85f); // солнце, небо, дымка вдали
|
||||
|
||||
layout = City3DLayout.Create();
|
||||
map = layout.Map;
|
||||
BuildGround();
|
||||
BuildObstacles();
|
||||
BuildGrass();
|
||||
|
||||
// Ратуша стоит в центре с самого начала
|
||||
int c = City3DLayout.Size / 2;
|
||||
PlaceNew(0, c - 2, c - 2, 0);
|
||||
RefreshGround();
|
||||
}
|
||||
|
||||
static Material Mat(Color color) => Map3D.Mat(color);
|
||||
|
||||
void BuildGround()
|
||||
{
|
||||
int n = City3DLayout.Size;
|
||||
var verts = new Vector3[(n + 1) * (n + 1)];
|
||||
var uvs = new Vector2[verts.Length];
|
||||
for (int z = 0; z <= n; z++)
|
||||
for (int x = 0; x <= n; x++)
|
||||
{
|
||||
int i = z * (n + 1) + x;
|
||||
verts[i] = new Vector3(x, City3DLayout.HeightAt(x, z), z);
|
||||
uvs[i] = new Vector2(x / (float)n, z / (float)n);
|
||||
}
|
||||
var tris = new int[n * n * 6];
|
||||
int t = 0;
|
||||
for (int z = 0; z < n; z++)
|
||||
for (int x = 0; x < n; x++)
|
||||
{
|
||||
int i = z * (n + 1) + x;
|
||||
tris[t++] = i; tris[t++] = i + n + 1; tris[t++] = i + 1;
|
||||
tris[t++] = i + 1; tris[t++] = i + n + 1; tris[t++] = i + n + 2;
|
||||
}
|
||||
var mesh = new Mesh { name = "City3D_Ground", indexFormat = UnityEngine.Rendering.IndexFormat.UInt32 };
|
||||
mesh.vertices = verts;
|
||||
mesh.uv = uvs;
|
||||
mesh.triangles = tris;
|
||||
mesh.RecalculateNormals();
|
||||
|
||||
var go = new GameObject("Ground");
|
||||
go.transform.SetParent(transform, false);
|
||||
go.AddComponent<MeshFilter>().sharedMesh = mesh;
|
||||
groundTexture = new Texture2D(n * PixelsPerCell, n * PixelsPerCell, TextureFormat.RGBA32, false)
|
||||
{
|
||||
filterMode = FilterMode.Point,
|
||||
wrapMode = TextureWrapMode.Clamp
|
||||
};
|
||||
go.AddComponent<MeshRenderer>().sharedMaterial = Map3D.TexturedMat(groundTexture);
|
||||
go.AddComponent<MeshCollider>().sharedMesh = mesh;
|
||||
|
||||
// Лес и луга за краем участка: камера не видит пустого неба
|
||||
Map3D.Block(transform, "OuterLand", PrimitiveType.Cube, new Color(0.24f, 0.4f, 0.22f), new Vector3(n / 2f, -0.7f, n / 2f),
|
||||
new Vector2(n + 200f, n + 200f), 0.1f);
|
||||
var forest = new System.Random(7);
|
||||
for (int i = 0; i < 140; i++)
|
||||
{
|
||||
// кольцо деревьев вокруг участка
|
||||
float angle = (float)forest.NextDouble() * Mathf.PI * 2f, r = n * 0.72f + (float)forest.NextDouble() * 14f;
|
||||
var p = new Vector3(n / 2f + Mathf.Cos(angle) * r, -0.6f, n / 2f + Mathf.Sin(angle) * r);
|
||||
if (p.x > 0 && p.x < n && p.z > 0 && p.z < n) continue; // внутри участка -- свои деревья
|
||||
Map3D.Tree(transform, "ForestTree", p, 1.4f + (float)forest.NextDouble() * 0.8f, forest.Next(6));
|
||||
}
|
||||
|
||||
// Вода -- плоскость над руслом
|
||||
var water = GameObject.CreatePrimitive(PrimitiveType.Cube);
|
||||
water.name = "River";
|
||||
Destroy(water.GetComponent<Collider>());
|
||||
water.transform.SetParent(transform, false);
|
||||
water.transform.position = new Vector3(37f, -0.25f, n / 2f);
|
||||
water.transform.localScale = new Vector3(9f, 0.05f, n);
|
||||
water.GetComponent<Renderer>().sharedMaterial = Mat(new Color(0.3f, 0.58f, 0.85f));
|
||||
}
|
||||
|
||||
void BuildObstacles()
|
||||
{
|
||||
int i = 0;
|
||||
foreach (var o in layout.Obstacles)
|
||||
{
|
||||
Vector2 center = Vector2.zero;
|
||||
foreach (var c in o.Cells) center += new Vector2(c.x + 0.5f, c.y + 0.5f);
|
||||
center /= o.Cells.Count;
|
||||
var ground = new Vector3(center.x, City3DLayout.HeightAt(center.x, center.y), center.y);
|
||||
i++;
|
||||
var view = o.IsTree
|
||||
? Map3D.Tree(transform, o.Id, ground, 1.0f + (i * 37 % 10) * 0.05f, i) // ели и лиственные вперемешку
|
||||
: Map3D.Rock(transform, o.Id, ground, o.Cells.Count > 1 ? 1.7f : 0.85f, i);
|
||||
obstacleViews[o.Id] = view.gameObject;
|
||||
}
|
||||
}
|
||||
|
||||
// Трава кустиками -- только украшение: прячется под зданием и возвращается
|
||||
void BuildGrass()
|
||||
{
|
||||
Color[] greens = { new Color(0.3f, 0.6f, 0.25f), new Color(0.38f, 0.66f, 0.28f), new Color(0.45f, 0.68f, 0.3f) };
|
||||
for (int i = 0; i < layout.Grass.Count; i++)
|
||||
{
|
||||
Vector2 p = layout.Grass[i];
|
||||
var g = Map3D.Shape(transform, "Grass", Map3D.Cone, greens[i % greens.Length],
|
||||
new Vector3(p.x, City3DLayout.HeightAt(p.x, p.y), p.y), Vector2.one * 0.28f, 0.22f + (i % 3) * 0.06f).gameObject;
|
||||
grassViews.Add(g);
|
||||
}
|
||||
}
|
||||
|
||||
static GameObject Part(GameObject parent, PrimitiveType type, Vector3 localPos, Vector3 scale, Material mat)
|
||||
{
|
||||
var p = GameObject.CreatePrimitive(type);
|
||||
Object.Destroy(p.GetComponent<Collider>());
|
||||
p.transform.SetParent(parent.transform, false);
|
||||
p.transform.localPosition = localPos;
|
||||
p.transform.localScale = scale;
|
||||
p.GetComponent<Renderer>().sharedMaterial = mat;
|
||||
return p;
|
||||
}
|
||||
|
||||
// Текстура земли: обычная -- трава, скалы, русло; в режиме стройки -- клетки, открытая зона и следующая
|
||||
void RefreshGround()
|
||||
{
|
||||
int n = City3DLayout.Size, px = PixelsPerCell;
|
||||
bool grid = mode != Mode.View;
|
||||
var pixels = new Color32[n * px * n * px];
|
||||
for (int y = 0; y < n; y++)
|
||||
for (int x = 0; x < n; x++)
|
||||
{
|
||||
CellKind k = map.KindAt(x, y);
|
||||
bool shore = k == CellKind.Ground && (map.KindAt(x - 1, y) == CellKind.Water || map.KindAt(x + 1, y) == CellKind.Water
|
||||
|| map.KindAt(x, y - 1) == CellKind.Water || map.KindAt(x, y + 1) == CellKind.Water);
|
||||
float hm = map.HeightAt(x, y) / 1000f;
|
||||
Color c = k == CellKind.Water ? new Color(0.32f, 0.5f, 0.72f)
|
||||
: k == CellKind.Mountain ? Color.Lerp(new Color(0.48f, 0.45f, 0.42f), new Color(0.85f, 0.86f, 0.88f), Mathf.Clamp01((hm - 3.2f) / 1.5f)) // снег на вершинах
|
||||
: shore ? new Color(0.78f, 0.72f, 0.52f) // песчаный берег
|
||||
: Color.Lerp(new Color(0.33f, 0.56f, 0.27f), new Color(0.45f, 0.66f, 0.32f), Mathf.PerlinNoise(x * 0.25f, y * 0.25f));
|
||||
if (grid && k == CellKind.Ground)
|
||||
{
|
||||
int zone = map.ZoneAt(x, y);
|
||||
if (zone > 0 && zone <= townHallLevel) c = Color.Lerp(c, new Color(0.6f, 0.95f, 0.6f), 0.25f); // открыто
|
||||
else if (zone == townHallLevel + 1) c = Color.Lerp(c, new Color(0.95f, 0.85f, 0.4f), 0.3f); // откроется следующим
|
||||
else c *= 0.55f; // закрыто
|
||||
}
|
||||
bool open = map.IsOpen(x, y, townHallLevel);
|
||||
for (int iy = 0; iy < px; iy++)
|
||||
for (int ix = 0; ix < px; ix++)
|
||||
{
|
||||
Color p = c;
|
||||
if (grid && (ix == 0 || iy == 0)) p *= 0.85f; // линии клеток
|
||||
// граница открытой зоны -- светлая линия
|
||||
if (grid && open && (ix == 0 && !map.IsOpen(x - 1, y, townHallLevel) || ix == px - 1 && !map.IsOpen(x + 1, y, townHallLevel)
|
||||
|| iy == 0 && !map.IsOpen(x, y - 1, townHallLevel) || iy == px - 1 && !map.IsOpen(x, y + 1, townHallLevel)))
|
||||
p = new Color(1f, 1f, 1f);
|
||||
p.a = 1;
|
||||
pixels[(y * px + iy) * n * px + x * px + ix] = p;
|
||||
}
|
||||
}
|
||||
groundTexture.SetPixels32(pixels);
|
||||
groundTexture.Apply(false);
|
||||
}
|
||||
|
||||
// ---------------- Здания ----------------
|
||||
|
||||
bool PlaceNew(int type, int x, int y, int rot)
|
||||
{
|
||||
var t = Types[type];
|
||||
string id = "b_" + nextBuildingId;
|
||||
PlaceError e = map.Place(id, t.Name, x, y, t.W, t.H, rot, townHallLevel);
|
||||
if (e != PlaceError.None) { Say(SettlementMap.ErrorText(e)); return false; }
|
||||
nextBuildingId++;
|
||||
buildingType[id] = type;
|
||||
buildingViews[id] = CreateBuildingView(id, type);
|
||||
UpdateBuildingView(id);
|
||||
UpdateGrass();
|
||||
return true;
|
||||
}
|
||||
|
||||
// Кровля по типу здания
|
||||
static Color RoofFor(int type)
|
||||
{
|
||||
switch (Types[type].Name)
|
||||
{
|
||||
case "Ратуша": return new Color(0.65f, 0.15f, 0.12f);
|
||||
case "Госпиталь": return new Color(0.45f, 0.55f, 0.65f);
|
||||
case "Казармы": return new Color(0.4f, 0.15f, 0.12f);
|
||||
case "Каменоломня":
|
||||
case "Шахта": return new Color(0.35f, 0.35f, 0.38f);
|
||||
default: return Color.Lerp(Types[type].Color, new Color(0.3f, 0.15f, 0.1f), 0.55f);
|
||||
}
|
||||
}
|
||||
|
||||
// Здание на примитивах: стены и двускатная крыша в «единичном» объёме Body (растягивается под габарит и высоту),
|
||||
// у некоторых -- свои приметы: башня Ратуши, флаг Казарм, крест Госпиталя, тёмный вход Шахты
|
||||
GameObject CreateBuildingView(string id, int type)
|
||||
{
|
||||
var t = Types[type];
|
||||
var root = new GameObject(id + "_" + t.Name);
|
||||
root.transform.SetParent(transform, false);
|
||||
var body = new GameObject("Body").transform;
|
||||
body.SetParent(root.transform, false);
|
||||
var hit = body.gameObject.AddComponent<BoxCollider>(); // тап по зданию попадает в него целиком
|
||||
hit.center = new Vector3(0, 0.5f, 0);
|
||||
hit.size = Vector3.one;
|
||||
|
||||
Color walls = Color.Lerp(t.Color, Color.white, 0.3f), roofColor = RoofFor(type);
|
||||
Unit(body, PrimitiveType.Cube, new Vector3(0, 0.31f, 0), new Vector3(1f, 0.62f, 1f), walls);
|
||||
var top = Map3D.Shape(body, "Roof", Map3D.Roof, roofColor, Vector3.zero, new Vector2(1.08f, 1.12f), 0.38f).transform;
|
||||
top.localPosition = new Vector3(0, 0.62f, 0);
|
||||
switch (t.Name)
|
||||
{
|
||||
case "Ратуша":
|
||||
Unit(body, PrimitiveType.Cube, new Vector3(0.3f, 0.7f, 0.3f), new Vector3(0.28f, 1.4f, 0.28f), walls);
|
||||
var spire = Map3D.Shape(body, "Spire", Map3D.Pyramid, roofColor, Vector3.zero, Vector2.one * 0.4f, 0.4f, 45f).transform;
|
||||
spire.localPosition = new Vector3(0.3f, 1.4f, 0.3f);
|
||||
break;
|
||||
case "Казармы":
|
||||
Unit(body, PrimitiveType.Cylinder, new Vector3(-0.4f, 0.75f, 0.4f), new Vector3(0.03f, 0.75f, 0.03f), new Color(0.35f, 0.25f, 0.15f));
|
||||
Unit(body, PrimitiveType.Cube, new Vector3(-0.32f, 1.35f, 0.4f), new Vector3(0.16f, 0.12f, 0.01f), new Color(0.8f, 0.15f, 0.15f));
|
||||
break;
|
||||
case "Госпиталь":
|
||||
Unit(body, PrimitiveType.Cube, new Vector3(0, 0.38f, -0.505f), new Vector3(0.08f, 0.28f, 0.01f), new Color(0.85f, 0.1f, 0.1f));
|
||||
Unit(body, PrimitiveType.Cube, new Vector3(0, 0.38f, -0.505f), new Vector3(0.24f, 0.08f, 0.01f), new Color(0.85f, 0.1f, 0.1f));
|
||||
break;
|
||||
case "Шахта":
|
||||
Unit(body, PrimitiveType.Cube, new Vector3(0, 0.2f, -0.505f), new Vector3(0.35f, 0.4f, 0.02f), new Color(0.1f, 0.1f, 0.12f));
|
||||
break;
|
||||
case "Ферма":
|
||||
// грядки перед амбаром
|
||||
for (int i = 0; i < 3; i++)
|
||||
Unit(body, PrimitiveType.Cube, new Vector3(-0.3f + i * 0.3f, 0.02f, -0.62f), new Vector3(0.22f, 0.04f, 0.2f), new Color(0.55f, 0.75f, 0.25f));
|
||||
break;
|
||||
}
|
||||
|
||||
var door = Part(root, PrimitiveType.Cube, Vector3.zero, Vector3.one, Mat(new Color(0.28f, 0.18f, 0.1f)));
|
||||
door.name = "Door"; // показывает, куда повёрнуто здание
|
||||
var foundation = Part(root, PrimitiveType.Cube, Vector3.zero, Vector3.one, Mat(new Color(0.62f, 0.58f, 0.52f)));
|
||||
foundation.name = "Foundation";
|
||||
|
||||
var labelGo = new GameObject("Label");
|
||||
labelGo.transform.SetParent(root.transform, false);
|
||||
var label = labelGo.AddComponent<TextMeshPro>();
|
||||
label.text = t.Name;
|
||||
label.fontSize = 4;
|
||||
label.alignment = TextAlignmentOptions.Center;
|
||||
label.color = Color.white;
|
||||
label.outlineWidth = 0.2f;
|
||||
label.outlineColor = Color.black;
|
||||
label.rectTransform.sizeDelta = new Vector2(8, 2);
|
||||
return root;
|
||||
}
|
||||
|
||||
// Деталь в единичном объёме здания (Body растягивается под габарит и высоту)
|
||||
static void Unit(Transform body, PrimitiveType type, Vector3 localPos, Vector3 scale, Color color)
|
||||
{
|
||||
var p = GameObject.CreatePrimitive(type);
|
||||
Destroy(p.GetComponent<Collider>());
|
||||
p.transform.SetParent(body, false);
|
||||
p.transform.localPosition = localPos;
|
||||
p.transform.localScale = scale;
|
||||
p.GetComponent<Renderer>().sharedMaterial = Mat(color);
|
||||
}
|
||||
|
||||
// Положение, поворот, фундамент по данным карты (или призрака при переносе)
|
||||
void UpdateBuildingView(string id) { if (map.TryGetBuilding(id, out var r)) LayoutView(buildingViews[id], buildingType[id], r.X, r.Y, r.Rotation); }
|
||||
|
||||
void LayoutView(GameObject root, int type, int x, int y, int rot)
|
||||
{
|
||||
var t = Types[type];
|
||||
bool swap = rot == 90 || rot == 270;
|
||||
int w = swap ? t.H : t.W, h = swap ? t.W : t.H;
|
||||
int min = int.MaxValue, max = int.MinValue;
|
||||
for (int cy = y; cy < y + h; cy++)
|
||||
for (int cx = x; cx < x + w; cx++) { int v = map.HeightAt(cx, cy); min = Mathf.Min(min, v); max = Mathf.Max(max, v); }
|
||||
if (min == int.MaxValue) { min = 0; max = 0; }
|
||||
float top = max / 1000f, bottom = min / 1000f - 0.3f;
|
||||
|
||||
root.transform.position = new Vector3(x + w / 2f, top, y + h / 2f);
|
||||
// Body -- в размерах без поворота и повёрнут сам: конёк крыши и приметы поворачиваются вместе со зданием
|
||||
var body = root.transform.Find("Body");
|
||||
body.localScale = new Vector3(t.W - 0.3f, t.Height, t.H - 0.3f);
|
||||
body.localPosition = Vector3.zero;
|
||||
body.localRotation = Quaternion.Euler(0, -rot, 0);
|
||||
var foundation = root.transform.Find("Foundation");
|
||||
foundation.localScale = new Vector3(w - 0.1f, top - bottom, h - 0.1f);
|
||||
foundation.localPosition = new Vector3(0, (bottom - top) / 2f, 0);
|
||||
|
||||
// дверь -- на «переднюю» сторону: 0 -- юг, 90 -- запад, 180 -- север, 270 -- восток
|
||||
var door = root.transform.Find("Door");
|
||||
Vector3 dir = Quaternion.Euler(0, -rot, 0) * Vector3.back;
|
||||
float halfDepth = (rot == 0 || rot == 180 ? h : w) / 2f - 0.15f;
|
||||
door.localPosition = dir * halfDepth + Vector3.up * 0.4f;
|
||||
door.localScale = rot == 0 || rot == 180 ? new Vector3(0.6f, 0.8f, 0.1f) : new Vector3(0.1f, 0.8f, 0.6f);
|
||||
|
||||
var label = root.transform.Find("Label");
|
||||
label.localPosition = new Vector3(0, t.Height + 0.8f, 0);
|
||||
}
|
||||
|
||||
void UpdateGrass()
|
||||
{
|
||||
for (int i = 0; i < grassViews.Count; i++)
|
||||
{
|
||||
Vector2 p = layout.Grass[i];
|
||||
bool hidden = map.BuildingAt((int)p.x, (int)p.y) != null;
|
||||
// и под призраком при переносе: прежнее место -- трава вернётся только после подтверждения
|
||||
if (!hidden && mode == Mode.Move && movingId != null && map.TryGetBuilding(movingId, out var r))
|
||||
hidden = (int)p.x >= r.X && (int)p.x < r.X + r.W && (int)p.y >= r.Y && (int)p.y < r.Y + r.H;
|
||||
grassViews[i].SetActive(!hidden);
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------- Призрак: новое здание или перенос ----------------
|
||||
|
||||
void StartPlacing(int type)
|
||||
{
|
||||
CancelGhost();
|
||||
mode = Mode.Place;
|
||||
placingType = type;
|
||||
var t = Types[type];
|
||||
ghost = CreateBuildingView("ghost", type);
|
||||
ghostRot = 0;
|
||||
Vector3 c = cameraRig.target;
|
||||
ghostX = Mathf.Clamp(Mathf.RoundToInt(c.x - t.W / 2f), 0, City3DLayout.Size - t.W);
|
||||
ghostY = Mathf.Clamp(Mathf.RoundToInt(c.z - t.H / 2f), 0, City3DLayout.Size - t.H);
|
||||
EnsureFootprint();
|
||||
RefreshGround();
|
||||
UpdateGhost();
|
||||
}
|
||||
|
||||
void StartMoving(string id)
|
||||
{
|
||||
if (!map.TryGetBuilding(id, out var r)) return;
|
||||
CancelGhost();
|
||||
mode = Mode.Move;
|
||||
movingId = id;
|
||||
moveOriginal = r;
|
||||
ghostX = r.X; ghostY = r.Y; ghostRot = r.Rotation;
|
||||
ghost = buildingViews[id]; // переносится ТО ЖЕ здание -- новое не создаётся
|
||||
EnsureFootprint();
|
||||
RefreshGround();
|
||||
UpdateGhost();
|
||||
}
|
||||
|
||||
void EnsureFootprint()
|
||||
{
|
||||
if (footprint != null) return;
|
||||
footprint = GameObject.CreatePrimitive(PrimitiveType.Cube);
|
||||
footprint.name = "Footprint";
|
||||
Destroy(footprint.GetComponent<Collider>());
|
||||
footprint.transform.SetParent(transform, false);
|
||||
}
|
||||
|
||||
int GhostType => mode == Mode.Move ? buildingType[movingId] : placingType;
|
||||
|
||||
void UpdateGhost()
|
||||
{
|
||||
if (ghost == null) return;
|
||||
var t = Types[GhostType];
|
||||
ghostError = map.Validate(ghostX, ghostY, t.W, t.H, ghostRot, townHallLevel, mode == Mode.Move ? movingId : null, out ghostFoundation);
|
||||
LayoutView(ghost, GhostType, ghostX, ghostY, ghostRot);
|
||||
|
||||
bool swap = ghostRot == 90 || ghostRot == 270;
|
||||
int w = swap ? t.H : t.W, h = swap ? t.W : t.H;
|
||||
float top = ghost.transform.position.y;
|
||||
footprint.transform.position = new Vector3(ghostX + w / 2f, top + 0.03f, ghostY + h / 2f);
|
||||
footprint.transform.localScale = new Vector3(w, 0.06f, h);
|
||||
if (okMaterial == null) { okMaterial = Mat(new Color(0.3f, 0.95f, 0.35f)); badMaterial = Mat(new Color(0.95f, 0.25f, 0.2f)); }
|
||||
footprint.GetComponent<Renderer>().sharedMaterial = ghostError == PlaceError.None ? okMaterial : badMaterial;
|
||||
UpdateGrass();
|
||||
}
|
||||
|
||||
void ConfirmGhost()
|
||||
{
|
||||
if (ghostError != PlaceError.None) { Say(SettlementMap.ErrorText(ghostError)); return; }
|
||||
if (mode == Mode.Place)
|
||||
{
|
||||
int type = placingType;
|
||||
int x = ghostX, y = ghostY, rot = ghostRot;
|
||||
CancelGhost();
|
||||
if (PlaceNew(type, x, y, rot)) Say(Types[type].Name + " построено (прототип: без цены и таймера)");
|
||||
}
|
||||
else if (mode == Mode.Move)
|
||||
{
|
||||
// Подтверждение -- одно изменение: позиция и поворот того же здания; ошибка -- всё как было
|
||||
PlaceError e = map.Move(movingId, ghostX, ghostY, ghostRot, townHallLevel);
|
||||
string id = movingId;
|
||||
if (e != PlaceError.None) { Say(SettlementMap.ErrorText(e)); return; }
|
||||
movingId = null;
|
||||
ghost = null;
|
||||
mode = Mode.Edit;
|
||||
UpdateBuildingView(id);
|
||||
Say("Перенесено. Здание то же: уровень, рабочие и таймеры не меняются");
|
||||
FinishGhost();
|
||||
}
|
||||
}
|
||||
|
||||
// Отмена: новое -- не создаётся; перенос -- здание возвращается на последнее подтверждённое место
|
||||
void CancelGhost()
|
||||
{
|
||||
if (mode == Mode.Place && ghost != null) Destroy(ghost);
|
||||
if (mode == Mode.Move && movingId != null) UpdateBuildingView(movingId);
|
||||
bool wasMove = mode == Mode.Move;
|
||||
ghost = null;
|
||||
movingId = null;
|
||||
placingType = -1;
|
||||
mode = wasMove ? Mode.Edit : Mode.View;
|
||||
FinishGhost();
|
||||
}
|
||||
|
||||
void FinishGhost()
|
||||
{
|
||||
if (footprint != null) { Destroy(footprint); footprint = null; }
|
||||
draggingGhost = false;
|
||||
cameraRig.AllowPan = true;
|
||||
UpdateGrass();
|
||||
RefreshGround();
|
||||
}
|
||||
|
||||
// ---------------- Ввод ----------------
|
||||
|
||||
void Update()
|
||||
{
|
||||
if (cam == null) return;
|
||||
bool down, held, up;
|
||||
Vector3 pos;
|
||||
if (Input.touchCount > 0)
|
||||
{
|
||||
if (Input.touchCount > 1) { cameraRig.EndPan(); draggingGhost = false; return; } // два пальца -- зум камеры
|
||||
Touch touch = Input.GetTouch(0);
|
||||
pos = touch.position;
|
||||
down = touch.phase == TouchPhase.Began;
|
||||
up = touch.phase == TouchPhase.Ended || touch.phase == TouchPhase.Canceled;
|
||||
held = !down && !up;
|
||||
}
|
||||
else
|
||||
{
|
||||
pos = Input.mousePosition;
|
||||
down = Input.GetMouseButtonDown(0);
|
||||
up = Input.GetMouseButtonUp(0);
|
||||
held = Input.GetMouseButton(0) && !down;
|
||||
}
|
||||
|
||||
if (down)
|
||||
{
|
||||
pointerOverGui = OverGui(pos);
|
||||
if (pointerOverGui) return;
|
||||
pointerDown = pos;
|
||||
pointerMoved = false;
|
||||
draggingGhost = (mode == Mode.Place || mode == Mode.Move) && CellUnder(pos, true, out int cx, out int cy) && InsideGhost(cx, cy);
|
||||
cameraRig.AllowPan = !draggingGhost;
|
||||
cameraRig.BeginPan(pos);
|
||||
}
|
||||
else if (held && !pointerOverGui)
|
||||
{
|
||||
if ((pos - pointerDown).magnitude > Screen.height * 0.015f) pointerMoved = true;
|
||||
if (draggingGhost) DragGhost(pos);
|
||||
else cameraRig.Pan(pos);
|
||||
}
|
||||
else if (up && !pointerOverGui)
|
||||
{
|
||||
cameraRig.EndPan();
|
||||
if (!pointerMoved && !draggingGhost) Tap(pos);
|
||||
draggingGhost = false;
|
||||
cameraRig.AllowPan = true;
|
||||
}
|
||||
}
|
||||
|
||||
void DragGhost(Vector3 pos)
|
||||
{
|
||||
if (!CellUnder(pos, true, out int cx, out int cy)) return;
|
||||
var t = Types[GhostType];
|
||||
bool swap = ghostRot == 90 || ghostRot == 270;
|
||||
int w = swap ? t.H : t.W, h = swap ? t.W : t.H;
|
||||
int nx = Mathf.Clamp(cx - w / 2, 0, City3DLayout.Size - w), ny = Mathf.Clamp(cy - h / 2, 0, City3DLayout.Size - h);
|
||||
if (nx == ghostX && ny == ghostY) return;
|
||||
ghostX = nx; ghostY = ny;
|
||||
UpdateGhost();
|
||||
}
|
||||
|
||||
bool InsideGhost(int cx, int cy)
|
||||
{
|
||||
if (ghost == null) return false;
|
||||
var t = Types[GhostType];
|
||||
bool swap = ghostRot == 90 || ghostRot == 270;
|
||||
int w = swap ? t.H : t.W, h = swap ? t.W : t.H;
|
||||
return cx >= ghostX - 1 && cx < ghostX + w + 1 && cy >= ghostY - 1 && cy < ghostY + h + 1; // с запасом на палец
|
||||
}
|
||||
|
||||
void Tap(Vector3 pos)
|
||||
{
|
||||
if (!CellUnder(pos, mode == Mode.Place || mode == Mode.Move, out int cx, out int cy)) return;
|
||||
if (mode == Mode.Place || mode == Mode.Move)
|
||||
{
|
||||
// тап по земле -- переставить призрак туда
|
||||
DragGhost(pos);
|
||||
return;
|
||||
}
|
||||
string building = map.BuildingAt(cx, cy);
|
||||
if (mode == Mode.Edit && building != null) { StartMoving(building); return; }
|
||||
selectedBuilding = building;
|
||||
selectedObstacle = building == null ? map.ObstacleAt(cx, cy) : null;
|
||||
}
|
||||
|
||||
// Клетка под пальцем. groundOnly -- только земля (перетаскивание призрака); иначе здание под пальцем -- его клетка
|
||||
bool CellUnder(Vector3 screen, bool groundOnly, out int x, out int y)
|
||||
{
|
||||
x = y = -1;
|
||||
Ray ray = cam.ScreenPointToRay(screen);
|
||||
var hits = Physics.RaycastAll(ray, 500f);
|
||||
System.Array.Sort(hits, (a, b) => a.distance.CompareTo(b.distance));
|
||||
foreach (var hit in hits)
|
||||
{
|
||||
Transform root = hit.collider.transform.parent;
|
||||
if (!groundOnly && root != null)
|
||||
foreach (var pair in buildingViews)
|
||||
if (pair.Value != null && pair.Value.transform == root && map.TryGetBuilding(pair.Key, out var r))
|
||||
{
|
||||
x = r.X; y = r.Y;
|
||||
return true;
|
||||
}
|
||||
if (hit.collider.gameObject.name != "Ground") continue;
|
||||
x = Mathf.FloorToInt(hit.point.x);
|
||||
y = Mathf.FloorToInt(hit.point.z);
|
||||
return map.InMap(x, y);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
// Подписи зданий всегда смотрят в камеру
|
||||
void LateUpdate()
|
||||
{
|
||||
if (cam == null) return;
|
||||
foreach (var v in buildingViews.Values)
|
||||
if (v != null) { var l = v.transform.Find("Label"); if (l != null) l.rotation = cam.transform.rotation; }
|
||||
if (ghost != null) { var l = ghost.transform.Find("Label"); if (l != null) l.rotation = cam.transform.rotation; }
|
||||
}
|
||||
|
||||
void ChangeTownHall(int delta)
|
||||
{
|
||||
int before = townHallLevel;
|
||||
townHallLevel = Mathf.Clamp(townHallLevel + delta, 1, 5);
|
||||
if (townHallLevel == before) return;
|
||||
RefreshGround();
|
||||
if (ghost != null) UpdateGhost();
|
||||
if (townHallLevel > before)
|
||||
{
|
||||
// Открылась зона -- камера плавно отходит и показывает её; здания остаются на местах
|
||||
int half = City3DLayout.ZoneHalfSize(townHallLevel), c = City3DLayout.Size / 2;
|
||||
cameraRig.FocusOn(new Rect(c - half, c - half, half * 2, half * 2));
|
||||
Say($"Ратуша {townHallLevel} ур.: открыта новая зона");
|
||||
}
|
||||
}
|
||||
|
||||
void Say(string text)
|
||||
{
|
||||
message = text;
|
||||
messageUntil = Time.unscaledTime + 4f;
|
||||
}
|
||||
|
||||
// ---------------- Кнопки (временные, IMGUI) ----------------
|
||||
|
||||
readonly List<Rect> guiRects = new List<Rect>();
|
||||
float guiScale = 1f;
|
||||
GUIStyle button, label, box;
|
||||
|
||||
bool OverGui(Vector3 screen)
|
||||
{
|
||||
var p = new Vector2(screen.x / guiScale, (Screen.height - screen.y) / guiScale);
|
||||
foreach (var r in guiRects) if (r.Contains(p)) return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
bool Button(Rect r, string text)
|
||||
{
|
||||
guiRects.Add(r);
|
||||
return GUI.Button(r, text, button);
|
||||
}
|
||||
|
||||
void Box(Rect r, string text)
|
||||
{
|
||||
guiRects.Add(r);
|
||||
GUI.Box(r, text, box);
|
||||
}
|
||||
|
||||
void OnGUI()
|
||||
{
|
||||
guiScale = Screen.height / 720f;
|
||||
GUI.matrix = Matrix4x4.Scale(new Vector3(guiScale, guiScale, 1));
|
||||
float w = Screen.width / guiScale, h = 720f;
|
||||
if (button == null)
|
||||
{
|
||||
button = new GUIStyle(GUI.skin.button) { fontSize = 20, wordWrap = true };
|
||||
label = new GUIStyle(GUI.skin.label) { fontSize = 20, wordWrap = true, alignment = TextAnchor.MiddleCenter };
|
||||
label.normal.textColor = Color.white;
|
||||
box = new GUIStyle(GUI.skin.box) { fontSize = 20, wordWrap = true, alignment = TextAnchor.MiddleCenter };
|
||||
box.normal.textColor = Color.white;
|
||||
}
|
||||
if (Event.current.type == EventType.Layout) guiRects.Clear();
|
||||
|
||||
// Верх: режим, Ратуша (тест), редактирование
|
||||
Box(new Rect(10, 10, 330, 44), $"3D-поселение (прототип) • Ратуша {townHallLevel} ур.");
|
||||
if (Button(new Rect(350, 10, 60, 44), "−")) ChangeTownHall(-1);
|
||||
if (Button(new Rect(415, 10, 60, 44), "+")) ChangeTownHall(+1);
|
||||
if (mode == Mode.View || mode == Mode.Edit)
|
||||
{
|
||||
if (Button(new Rect(w - 250, 10, 240, 44), mode == Mode.Edit ? "Готово" : "Редактировать"))
|
||||
{
|
||||
mode = mode == Mode.Edit ? Mode.View : Mode.Edit;
|
||||
selectedBuilding = selectedObstacle = null;
|
||||
RefreshGround();
|
||||
if (mode == Mode.Edit) Say("Режим редактирования: нажмите здание, чтобы перенести");
|
||||
}
|
||||
}
|
||||
|
||||
// Слева: что построить
|
||||
if (mode == Mode.View || mode == Mode.Edit)
|
||||
{
|
||||
float y = 64;
|
||||
for (int i = 1; i < Types.Length; i++)
|
||||
{
|
||||
if (Button(new Rect(10, y, 200, 40), $"{Types[i].Name} {Types[i].W}×{Types[i].H}")) StartPlacing(i);
|
||||
y += 44;
|
||||
}
|
||||
}
|
||||
|
||||
// Низ: призрак -- поворот, поставить, отмена
|
||||
if (mode == Mode.Place || mode == Mode.Move)
|
||||
{
|
||||
string status = ghostError == PlaceError.None
|
||||
? (ghostFoundation > 0 ? $"Можно ставить (фундамент {ghostFoundation / 1000f:0.0} м)" : "Можно ставить")
|
||||
: SettlementMap.ErrorText(ghostError);
|
||||
Box(new Rect(w / 2 - 300, h - 120, 600, 44), (mode == Mode.Move ? "Перенос: " : Types[GhostType].Name + ": ") + status);
|
||||
if (Button(new Rect(w / 2 - 300, h - 70, 190, 60), "Повернуть 90°")) { ghostRot = (ghostRot + 90) % 360; UpdateGhost(); }
|
||||
if (Button(new Rect(w / 2 - 95, h - 70, 190, 60), mode == Mode.Move ? "Подтвердить" : "Поставить")) ConfirmGhost();
|
||||
if (Button(new Rect(w / 2 + 110, h - 70, 190, 60), "Отмена")) CancelGhost();
|
||||
}
|
||||
|
||||
// Меню здания: перенос
|
||||
if (mode == Mode.View && selectedBuilding != null && map.TryGetBuilding(selectedBuilding, out var b))
|
||||
{
|
||||
Box(new Rect(w / 2 - 250, h - 120, 500, 44), $"{b.Type} • {b.W}×{b.H} клеток • поворот {b.Rotation}°");
|
||||
if (Button(new Rect(w / 2 - 250, h - 70, 245, 60), "Переместить")) { string id = selectedBuilding; selectedBuilding = null; StartMoving(id); }
|
||||
if (Button(new Rect(w / 2 + 5, h - 70, 245, 60), "Закрыть")) selectedBuilding = null;
|
||||
}
|
||||
|
||||
// Меню дерева / валуна: расчистка без цены и ожидания
|
||||
if (mode == Mode.View && selectedObstacle != null)
|
||||
{
|
||||
bool tree = selectedObstacle.StartsWith("tree");
|
||||
Box(new Rect(w / 2 - 250, h - 120, 500, 44), tree ? "Дерево" : "Валун");
|
||||
if (Button(new Rect(w / 2 - 250, h - 70, 245, 60), "Расчистить"))
|
||||
{
|
||||
if (map.ClearObstacle(selectedObstacle) && obstacleViews.TryGetValue(selectedObstacle, out var view))
|
||||
{
|
||||
Destroy(view);
|
||||
Say((tree ? "Дерево" : "Валун") + " расчищено. Награда " + (tree ? "деревом" : "камнем") +
|
||||
" -- после подключения сохранений (этап III)");
|
||||
}
|
||||
selectedObstacle = null;
|
||||
}
|
||||
if (Button(new Rect(w / 2 + 5, h - 70, 245, 60), "Закрыть")) selectedObstacle = null;
|
||||
}
|
||||
|
||||
if (Time.unscaledTime < messageUntil)
|
||||
GUI.Label(new Rect(w / 2 - 350, 64, 700, 60), message, label);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 44d822c903694362bef912c055adda5b
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -0,0 +1,97 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using Bogatyri.Settlement.Placement;
|
||||
using UnityEngine;
|
||||
|
||||
// ТЕСТОВЫЙ УЧАСТОК 3D-ПОСЕЛЕНИЯ (ТЗ «Система строительства поселения» от 04.11.2026, этап I, прототип).
|
||||
// Холмы, река, скалы, деревья и валуны строятся из seed -- одинаково при каждом запуске.
|
||||
// Зоны стройки открываются уровнем Ратуши квадратами от центра (ТЕСТ, число и пороги зон -- на согласование).
|
||||
// Все числа здесь -- предложение для прототипа, не утверждённый баланс.
|
||||
public sealed class City3DLayout
|
||||
{
|
||||
public const int Size = 48; // клеток по каждой стороне
|
||||
public const int Seed = 4112026;
|
||||
|
||||
public struct Obstacle
|
||||
{
|
||||
public string Id;
|
||||
public bool IsTree; // дерево (иначе валун)
|
||||
public List<(int x, int y)> Cells;
|
||||
}
|
||||
|
||||
public SettlementMap Map;
|
||||
public readonly List<Obstacle> Obstacles = new List<Obstacle>();
|
||||
public readonly List<Vector2> Grass = new List<Vector2>(); // мелкий декор: скрывается под зданиями
|
||||
|
||||
// Сколько клеток от центра открывает уровень Ратуши: 1 -- 16 x 16, 2 -- 24 x 24, ... 5 -- весь участок
|
||||
public static int ZoneHalfSize(int townHallLevel) => Mathf.Min(Size / 2, 8 + 4 * (Mathf.Max(1, townHallLevel) - 1));
|
||||
|
||||
// Высота земли в точке (мировые единицы, клетка = 1)
|
||||
public static float HeightAt(float x, float z)
|
||||
{
|
||||
float cx = x - Size / 2f, cz = z - Size / 2f;
|
||||
float fromCenter = Mathf.Sqrt(cx * cx + cz * cz) / (Size / 2f);
|
||||
// Холмы: в центре почти ровно, к краям -- выше и круче
|
||||
float hills = (Mathf.Sin(x * 0.27f) * 0.5f + Mathf.Cos(z * 0.21f) * 0.45f + Mathf.PerlinNoise(x * 0.11f, z * 0.11f) * 0.9f)
|
||||
* Mathf.Lerp(0.25f, 1.6f, Mathf.Clamp01(fromCenter));
|
||||
if (IsMountain(x, z)) hills += 2.5f + Mathf.PerlinNoise(x * 0.3f, z * 0.3f) * 2f;
|
||||
if (IsRiver(x, z)) hills = -0.5f;
|
||||
return hills;
|
||||
}
|
||||
|
||||
static float RiverX(float z) => 37f + 3f * Mathf.Sin(z * 0.17f);
|
||||
static bool IsRiver(float x, float z) => Mathf.Abs(x - RiverX(z)) < 1.3f;
|
||||
static bool IsMountain(float x, float z) => x < 9f && z > 34f || x < 4f && z > 24f;
|
||||
|
||||
public static City3DLayout Create(PlacementRules rules = null)
|
||||
{
|
||||
var layout = new City3DLayout { Map = new SettlementMap(Size, Size, rules) };
|
||||
var map = layout.Map;
|
||||
int c = Size / 2;
|
||||
|
||||
for (int y = 0; y < Size; y++)
|
||||
for (int x = 0; x < Size; x++)
|
||||
{
|
||||
float px = x + 0.5f, pz = y + 0.5f;
|
||||
CellKind kind = IsRiver(px, pz) ? CellKind.Water : IsMountain(px, pz) ? CellKind.Mountain : CellKind.Ground;
|
||||
float dist = Mathf.Max(Mathf.Abs(px - c), Mathf.Abs(pz - c)); // квадратное кольцо от центра
|
||||
int zone = 0;
|
||||
for (int lvl = 1; lvl <= 5; lvl++) if (dist < ZoneHalfSize(lvl)) { zone = lvl; break; }
|
||||
map.SetCell(x, y, kind, Mathf.RoundToInt(HeightAt(px, pz) * 1000f), zone);
|
||||
}
|
||||
|
||||
// Деревья и валуны: не в центральной поляне 10 x 10 (там Ратуша), не на воде и скалах
|
||||
var rng = new System.Random(Seed);
|
||||
var taken = new HashSet<int>();
|
||||
bool Free(int x, int y) => map.InMap(x, y) && map.KindAt(x, y) == CellKind.Ground && !taken.Contains(y * Size + x)
|
||||
&& (Math.Abs(x - c) > 5 || Math.Abs(y - c) > 5);
|
||||
int trees = 0, rocks = 0;
|
||||
for (int attempt = 0; attempt < 4000 && trees < 90; attempt++)
|
||||
{
|
||||
int x = rng.Next(Size), y = rng.Next(Size);
|
||||
if (!Free(x, y)) continue;
|
||||
taken.Add(y * Size + x);
|
||||
layout.Obstacles.Add(new Obstacle { Id = "tree_" + (++trees), IsTree = true, Cells = new List<(int, int)> { (x, y) } });
|
||||
}
|
||||
for (int attempt = 0; attempt < 4000 && rocks < 22; attempt++)
|
||||
{
|
||||
int x = rng.Next(Size - 1), y = rng.Next(Size - 1);
|
||||
bool big = rng.Next(3) == 0; // каждый третий валун -- 2 x 2
|
||||
var cells = big ? new List<(int, int)> { (x, y), (x + 1, y), (x, y + 1), (x + 1, y + 1) } : new List<(int, int)> { (x, y) };
|
||||
bool ok = true;
|
||||
foreach (var cell in cells) if (!Free(cell.Item1, cell.Item2)) { ok = false; break; }
|
||||
if (!ok) continue;
|
||||
foreach (var cell in cells) taken.Add(cell.Item2 * Size + cell.Item1);
|
||||
layout.Obstacles.Add(new Obstacle { Id = "rock_" + (++rocks), IsTree = false, Cells = cells });
|
||||
}
|
||||
foreach (var o in layout.Obstacles) map.AddObstacle(o.Id, o.Cells);
|
||||
|
||||
// Трава -- только украшение: не мешает стройке, прячется под зданием и возвращается, когда здание ушло
|
||||
for (int i = 0; i < 260; i++)
|
||||
{
|
||||
float x = (float)rng.NextDouble() * Size, z = (float)rng.NextDouble() * Size;
|
||||
if (map.KindAt((int)x, (int)z) == CellKind.Ground) layout.Grass.Add(new Vector2(x, z));
|
||||
}
|
||||
return layout;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 31e2f86e3dff430ea8a67cc6f1cb4038
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -66,16 +66,16 @@ public class Barracks : MonoBehaviour, ILeveledBuilding
|
||||
void Refresh()
|
||||
{
|
||||
if (label == null) return;
|
||||
var d = GameProgress.Instance.Data;
|
||||
if (d.training.Count == 0)
|
||||
var training = GameProgress.Instance.Training;
|
||||
if (training.Count == 0)
|
||||
{
|
||||
label.text = "Казармы\n<size=70%>нажмите, чтобы нанять</size>";
|
||||
return;
|
||||
}
|
||||
var o = d.training[0];
|
||||
label.text = "Казармы\n<size=70%>" + GameData.Troops[o.troopIndex].name + " ×" + o.count + " " +
|
||||
var o = training[0];
|
||||
label.text = "Казармы\n<size=70%>" + GameData.Troops[o.Type].name + " ×" + o.Count + " " +
|
||||
GameData.FormatTime(GameProgress.Instance.TrainingSecondsLeft(o)) +
|
||||
(d.training.Count > 1 ? " (+" + (d.training.Count - 1) + ")" : "") + "</size>";
|
||||
(training.Count > 1 ? " (+" + (training.Count - 1) + ")" : "") + "</size>";
|
||||
}
|
||||
|
||||
Vector3 downPos;
|
||||
|
||||
@@ -0,0 +1,60 @@
|
||||
using System.Collections.Generic;
|
||||
using UnityEngine;
|
||||
|
||||
// ГОСПИТАЛЬ -- здание для лечения раненых (регламент 31.10; решения по 8 вопросам Саши от 31.10, п. 7).
|
||||
// - Даёт места для лечения: уровни I-V, 20-60 мест (таблица HospitalConfig, ТЕСТ).
|
||||
// - Считаются самые прокачанные госпитали: второй госпиталь мест не добавляет (регламент про несколько не говорит).
|
||||
// - Раненых хранит и лечит модуль Армии; здание только сообщает число мест через контракт IHospital (HospitalBeds).
|
||||
// - Тап открывает окно госпиталя (App/BuildingWindow): места, кто лечится и ждёт, улучшение.
|
||||
// - Уровень сохраняет модуль Поселения (ILeveledBuilding).
|
||||
// Вешается на копию обычного здания (HospitalBootstrap).
|
||||
public class Hospital : MonoBehaviour, ILeveledBuilding
|
||||
{
|
||||
public static readonly List<Hospital> All = new List<Hospital>();
|
||||
public static int Count => All.Count;
|
||||
|
||||
public int level = 1;
|
||||
public int Level { get => level; set => level = Mathf.Clamp(value, 1, MaxBuildLevel); }
|
||||
|
||||
// Уровней у госпиталя столько, сколько строк мест в таблице (регламент: I-V)
|
||||
public static int MaxBuildLevel => Mathf.Max(1, HospitalConfig.Load().bedsByLevel.Length);
|
||||
|
||||
// Уровень самого прокачанного госпиталя (0 -- госпиталя нет)
|
||||
public static int MaxLevel
|
||||
{
|
||||
get { int m = 0; foreach (var h in All) if (h != null && h.level > m) m = h.level; return m; }
|
||||
}
|
||||
|
||||
// Мест на уровне (1..5) по таблице
|
||||
public static int BedsAt(int lvl)
|
||||
{
|
||||
var beds = HospitalConfig.Load().bedsByLevel;
|
||||
if (lvl <= 0 || beds == null || beds.Length == 0) return 0;
|
||||
return Mathf.Max(0, beds[Mathf.Min(lvl, beds.Length) - 1]);
|
||||
}
|
||||
|
||||
void OnEnable() { if (!All.Contains(this)) All.Add(this); }
|
||||
void OnDisable() { All.Remove(this); }
|
||||
|
||||
Vector3 downPos;
|
||||
|
||||
void OnMouseDown()
|
||||
{
|
||||
downPos = Input.mousePosition;
|
||||
}
|
||||
|
||||
// Тап (а не перетаскивание камеры) -- окно госпиталя
|
||||
void OnMouseUpAsButton()
|
||||
{
|
||||
if (UIBlocker.IsPointerOverUI()) return;
|
||||
if ((Input.mousePosition - downPos).magnitude > 25f) return;
|
||||
BuildingWindow.Open(gameObject);
|
||||
}
|
||||
}
|
||||
|
||||
// Места госпиталя для модуля Армии (контракт IHospital). Регистрирует App/GameModules.
|
||||
// Госпиталя нет -- 0 мест: Армия берёт HospitalConfig.temporaryBeds.
|
||||
public sealed class HospitalBeds : IHospital
|
||||
{
|
||||
public int Beds => Hospital.BedsAt(Hospital.MaxLevel);
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 2f4c537a26bd44b3ae851af08c652a34
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -0,0 +1,65 @@
|
||||
using UnityEngine;
|
||||
|
||||
// Добавляет «Госпиталь» в список стройки САМ при запуске сцены (как Казармы -- BarracksBootstrap).
|
||||
// Срабатывает до восстановления зданий из сохранения (SettlementRestoringEvent), поэтому построенный
|
||||
// госпиталь и его уровень корректно восстанавливаются из save.json.
|
||||
public static class HospitalBootstrap
|
||||
{
|
||||
public const string HospitalName = "Госпиталь";
|
||||
static GameObject runtimeTemplate;
|
||||
|
||||
[RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.AfterSceneLoad)]
|
||||
static void Init()
|
||||
{
|
||||
Ensure();
|
||||
// при каждом новом входе в город (например, возврат с карты мира) -- снова добавить в новый BuildManager
|
||||
UnityEngine.SceneManagement.SceneManager.sceneLoaded += (s, m) => Ensure();
|
||||
}
|
||||
|
||||
public static void Ensure()
|
||||
{
|
||||
var bm = BuildManager.Instance != null ? BuildManager.Instance : Object.FindAnyObjectByType<BuildManager>();
|
||||
if (bm == null || bm.allBuildings == null) return;
|
||||
|
||||
BuildingData template = null;
|
||||
foreach (var b in bm.allBuildings)
|
||||
{
|
||||
if (b == null) continue;
|
||||
if (b.buildingName == HospitalName) return; // уже есть
|
||||
if (template == null && b.prefab != null) template = b;
|
||||
}
|
||||
if (template == null) { Debug.LogWarning("[ГОСПИТАЛЬ] Нет ни одного здания-шаблона в BuildManager"); return; }
|
||||
|
||||
// Префаб-шаблон в памяти: копия обычного здания без сбора ресурсов, с компонентом Hospital
|
||||
if (runtimeTemplate == null)
|
||||
{
|
||||
runtimeTemplate = Object.Instantiate(template.prefab);
|
||||
runtimeTemplate.name = "Hospital";
|
||||
runtimeTemplate.SetActive(false);
|
||||
Object.DontDestroyOnLoad(runtimeTemplate);
|
||||
foreach (var c in runtimeTemplate.GetComponents<ResourceCollector>()) Object.DestroyImmediate(c);
|
||||
foreach (var c in runtimeTemplate.GetComponents<ResourceProducer>()) Object.DestroyImmediate(c);
|
||||
foreach (var c in runtimeTemplate.GetComponents<BuildingUI>()) Object.DestroyImmediate(c);
|
||||
for (int i = runtimeTemplate.transform.childCount - 1; i >= 0; i--)
|
||||
Object.DestroyImmediate(runtimeTemplate.transform.GetChild(i).gameObject); // полоска запаса ресурса
|
||||
var sr = runtimeTemplate.GetComponent<SpriteRenderer>();
|
||||
if (sr != null) sr.color = new Color(0.85f, 0.95f, 1f); // пока нет арта -- отличаем цветом (светло-голубой)
|
||||
runtimeTemplate.AddComponent<Hospital>();
|
||||
}
|
||||
|
||||
var config = HospitalConfig.Load();
|
||||
var data = ScriptableObject.CreateInstance<BuildingData>();
|
||||
data.name = "Data_Hospital_Runtime";
|
||||
data.buildingName = HospitalName;
|
||||
data.icon = template.icon;
|
||||
data.prefab = runtimeTemplate;
|
||||
data.requiredTownHallLevel = Mathf.Max(1, config.requiredTownHallLevel);
|
||||
data.cost = new[]
|
||||
{
|
||||
new ResourceCost { type = ResourceType.Wood, amount = config.buildWood },
|
||||
new ResourceCost { type = ResourceType.Stone, amount = config.buildStone },
|
||||
};
|
||||
bm.allBuildings.Add(data);
|
||||
Debug.Log("[ГОСПИТАЛЬ] Добавлен в список стройки");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 3301bf2246b4444182d1362fe7bffcc5
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -658,85 +658,82 @@ public class GameProgress : MonoBehaviour
|
||||
return string.Join(", ", parts.ToArray());
|
||||
}
|
||||
|
||||
// ОЧЕРЕДЬ ОБУЧЕНИЯ ведёт модуль Армии (решения по 8 вопросам Саши, 31.10, п. 8). Здесь -- только то, что знает
|
||||
// слой приложения: есть ли Казармы и открыт ли тип войск, цена (Экономика), длина очереди от числа Казарм, окна.
|
||||
// Время -- часы игры (GameClock.UnixNowMs): перемотка DEV и офлайн досчитывают обучение так же, как марши.
|
||||
|
||||
public IReadOnlyList<TrainingOrderInfo> Training => Army.Training;
|
||||
|
||||
public void Train(int index, int count)
|
||||
{
|
||||
var def = GameData.Troops[index];
|
||||
if (Barracks.Count == 0) { UIKit.Toast("Сначала постройте Казармы"); return; }
|
||||
if (!TroopUnlocked(index)) { UIKit.Toast("Нужно: " + TroopLockText(index)); return; }
|
||||
if (Data.training.Count >= Barracks.QueueSize) { UIKit.Toast("Очередь обучения заполнена. Больше казарм -- длиннее очередь"); return; }
|
||||
// Воин -- житель города (модуль Населения): берутся свободные жители, резерв не отдаётся
|
||||
var population = Population;
|
||||
if (population != null && population.Recruitable < count)
|
||||
// Очередь и жители (резерв не отдаётся) -- проверяет Армия вместе с Населением
|
||||
if (!Army.CanQueueTraining(index, count, Barracks.QueueSize, out string error)) { UIKit.Toast(error); return; }
|
||||
if (!Pay(def.cost, count)) return;
|
||||
|
||||
long durationMs = (long)(def.secondsPerUnit * 1000.0 * count);
|
||||
if (!Army.TryQueueTraining(index, count, durationMs, Barracks.QueueSize, GameClock.UnixNowMs, out error))
|
||||
{
|
||||
UIKit.Toast(population.Recruitable > 0
|
||||
? "Жителей хватит только на " + population.Recruitable + " воинов"
|
||||
: "Некого нанять: свободных жителей нет (резерв " + population.CivilianReserve + "). Снимите рабочих или стройте Дома");
|
||||
// Заказ не встал -- цену возвращаем целиком
|
||||
var refund = new RewardItem[def.cost.Length];
|
||||
for (int i = 0; i < def.cost.Length; i++) refund[i] = new RewardItem(def.cost[i].type, def.cost[i].amount * count);
|
||||
Grant(refund, 0, false);
|
||||
UIKit.Toast(error);
|
||||
return;
|
||||
}
|
||||
if (!Pay(def.cost, count)) return;
|
||||
bool recruited = population != null && population.TryRecruit(count);
|
||||
|
||||
long start = Data.training.Count > 0 ? Data.training[Data.training.Count - 1].endTicks : Now;
|
||||
if (start < Now) start = Now;
|
||||
long end = start + TimeSpan.FromSeconds(def.secondsPerUnit * count).Ticks;
|
||||
Data.training.Add(new TrainingOrder { troopIndex = index, count = count, startTicks = start, endTicks = end, recruited = recruited });
|
||||
UIKit.Toast("Обучение начато: " + count + " × " + def.name);
|
||||
MarkChanged();
|
||||
}
|
||||
|
||||
public double TrainingSecondsLeft(TrainingOrder o) { return TimeSpan.FromTicks(Math.Max(0, o.endTicks - Now)).TotalSeconds; }
|
||||
public double TrainingSecondsLeft(TrainingOrderInfo o) { return Math.Max(0, o.EndMs - GameClock.UnixNowMs) / 1000.0; }
|
||||
|
||||
public float TrainingProgress(TrainingOrder o)
|
||||
public float TrainingProgress(TrainingOrderInfo o)
|
||||
{
|
||||
long total = o.endTicks - o.startTicks;
|
||||
long total = o.EndMs - o.StartMs;
|
||||
if (total <= 0) return 1f;
|
||||
return Mathf.Clamp01((float)(Now - o.startTicks) / total);
|
||||
return Mathf.Clamp01((float)(GameClock.UnixNowMs - o.StartMs) / total);
|
||||
}
|
||||
|
||||
public int SpeedUpCost
|
||||
{
|
||||
get
|
||||
{
|
||||
if (Data.training.Count == 0) return 0;
|
||||
double secs = TrainingSecondsLeft(Data.training[Data.training.Count - 1]);
|
||||
var queue = Training;
|
||||
if (queue.Count == 0) return 0;
|
||||
double secs = TrainingSecondsLeft(queue[queue.Count - 1]);
|
||||
return Mathf.Max(1, Mathf.CeilToInt((float)secs / 30f)); // 1 кристалл за 30 сек
|
||||
}
|
||||
}
|
||||
|
||||
public void SpeedUpTraining()
|
||||
{
|
||||
if (Data.training.Count == 0) return;
|
||||
if (Training.Count == 0) return;
|
||||
if (!Pay(new[] { new RewardItem(ResourceType.Gems, SpeedUpCost) })) return;
|
||||
foreach (var o in Data.training) o.endTicks = Now;
|
||||
ProcessTraining();
|
||||
Army.FinishAllTraining(GameClock.UnixNowMs);
|
||||
}
|
||||
|
||||
// Раз в секунду: Армия заканчивает заказы обучения и лечение раненых, срок которых наступил (и пока игра была закрыта)
|
||||
void ProcessTraining()
|
||||
{
|
||||
bool any = false;
|
||||
while (Data.training.Count > 0 && Data.training[0].endTicks <= Now)
|
||||
{
|
||||
var o = Data.training[0];
|
||||
Data.training.RemoveAt(0);
|
||||
if (o.recruited && Population != null)
|
||||
{
|
||||
// Люди из Казарм переходят в Армию одним действием: не теряются и не дублируются
|
||||
if (!Population.CompleteTraining(o.troopIndex, o.count))
|
||||
{
|
||||
Debug.LogWarning($"[ВОЙСКА] Армия не приняла {o.count} × {GameData.Troops[o.troopIndex].name} -- новобранцы остаются в Казармах");
|
||||
continue; // воинов не прибавилось -- и в статистику не идёт
|
||||
}
|
||||
}
|
||||
else Army.AddTroops(o.troopIndex, o.count); // старый заказ: людей под него не брали
|
||||
Data.troopsTrained += o.count;
|
||||
Data.dailyTroops += o.count;
|
||||
Data.eventTroopRemainder += o.count;
|
||||
AddEventPoints(Data.eventTroopRemainder / 5);
|
||||
Data.eventTroopRemainder %= 5;
|
||||
UIKit.Toast("Обучено: " + o.count + " × " + GameData.Troops[o.troopIndex].name);
|
||||
any = true;
|
||||
}
|
||||
if (any) MarkChanged();
|
||||
if (!GameServices.TryGet(out IArmy army)) return;
|
||||
long now = GameClock.UnixNowMs;
|
||||
army.ProcessTraining(now);
|
||||
army.ProcessHealing(now);
|
||||
army.ProcessMissing(now);
|
||||
}
|
||||
|
||||
// Заказ закончен (событие Армии, один раз на заказ): статистика заданий и всплывашка
|
||||
public void OnTroopsTrained(TroopsTrainedEvent e)
|
||||
{
|
||||
Data.troopsTrained += e.Count;
|
||||
Data.dailyTroops += e.Count;
|
||||
Data.eventTroopRemainder += e.Count;
|
||||
AddEventPoints(Data.eventTroopRemainder / 5);
|
||||
Data.eventTroopRemainder %= 5;
|
||||
if (e.Type >= 0 && e.Type < GameData.Troops.Count) UIKit.Toast("Обучено: " + e.Count + " × " + GameData.Troops[e.Type].name);
|
||||
MarkChanged();
|
||||
}
|
||||
|
||||
// Потери в бою: убираем процент от каждого типа войск
|
||||
|
||||
@@ -97,7 +97,7 @@ public class ProgressData
|
||||
// из старых сохранений: при первой загрузке его читает App/GameModules, потом оно обнуляется.
|
||||
public int[] troops = new int[4];
|
||||
public bool armyInModule; // войска уже перенесены в модуль Армии
|
||||
public List<TrainingOrder> training = new List<TrainingOrder>();
|
||||
public List<TrainingOrder> training = new List<TrainingOrder>(); // УСТАРЕЛО: очередь у Армии (save.json, "army"); только для переноса старых сохранений
|
||||
|
||||
// --- Бой (кампания) ---
|
||||
public int battleStage = 1;
|
||||
|
||||
@@ -31,6 +31,27 @@ public class TroopsPanel : BasePanel
|
||||
ProfilePanel.KV(army, "Можно нанять из жителей", population.Recruitable.ToString("N0") +
|
||||
" (резерв " + population.CivilianReserve.ToString("N0") + ")");
|
||||
}
|
||||
// Раненые (решения 31.10, п. 7): лечатся в госпитале или ждут места; не воюют, но считаются людьми
|
||||
IArmy hurt = GameServices.Get<IArmy>();
|
||||
if (hurt.WoundedTotal > 0)
|
||||
{
|
||||
int waiting = 0, healingNow = 0;
|
||||
long readyMs = long.MaxValue;
|
||||
for (int t = 0; t < hurt.TypeCount; t++) waiting += hurt.GetWoundedWaiting(t);
|
||||
foreach (var h in hurt.Healing) { healingNow += h.Count; readyMs = System.Math.Min(readyMs, h.EndMs); }
|
||||
string next = readyMs != long.MaxValue
|
||||
? ", ближайшие вылечатся через " + GameData.FormatTime(System.Math.Max(0, readyMs - GameClock.UnixNowMs) / 1000.0)
|
||||
: "";
|
||||
ProfilePanel.KV(army, "Раненые", hurt.WoundedTotal.ToString("N0") + " (лечатся " + healingNow + ", ждут места " + waiting + ")");
|
||||
ProfilePanel.KV(army, "Госпиталь", "мест " + hurt.HospitalBeds + next);
|
||||
}
|
||||
if (hurt.MissingTotal > 0)
|
||||
{
|
||||
long windowEnd = 0;
|
||||
foreach (var m in hurt.Missing) windowEnd = System.Math.Max(windowEnd, m.EndMs);
|
||||
ProfilePanel.KV(army, "Пропали без вести", hurt.MissingTotal.ToString("N0") + " (могут вернуться ещё " +
|
||||
GameData.FormatTime(System.Math.Max(0, windowEnd - GameClock.UnixNowMs) / 1000.0) + ")");
|
||||
}
|
||||
ProfilePanel.KV(army, "Сила войск", GP.TroopsPower.ToString("N0"));
|
||||
ProfilePanel.KV(army, "Сила армии с героем", GP.ArmyPower.ToString("N0"));
|
||||
UIKit.Button(army, "Отправить армию на карте мира", UIKit.Theme.Green, () => OpenPanel("World"), -1, 80, 26);
|
||||
@@ -64,18 +85,19 @@ public class TroopsPanel : BasePanel
|
||||
|
||||
// --- Очередь обучения ---
|
||||
var queue = UIKit.Card(list);
|
||||
ProfilePanel.Header(queue, "Обучение (" + d.training.Count + " / " + Barracks.QueueSize + ") • казарм: " + Barracks.Count);
|
||||
if (d.training.Count == 0)
|
||||
var training = GP.Training;
|
||||
ProfilePanel.Header(queue, "Обучение (" + training.Count + " / " + Barracks.QueueSize + ") • казарм: " + Barracks.Count);
|
||||
if (training.Count == 0)
|
||||
{
|
||||
UIKit.Text(queue, "Никто не обучается. Выберите войска ниже.", 26, UIKit.Theme.TextDim);
|
||||
}
|
||||
else
|
||||
{
|
||||
foreach (var o in d.training)
|
||||
foreach (var o in training)
|
||||
{
|
||||
var def = GameData.Troops[o.troopIndex];
|
||||
var def = GameData.Troops[o.Type];
|
||||
var r = UIKit.Row(queue, 44, 10);
|
||||
var n = UIKit.Text(r, def.name + " × " + o.count, 28);
|
||||
var n = UIKit.Text(r, def.name + " × " + o.Count, 28);
|
||||
UIKit.Size(n, -1, -1, 1);
|
||||
var t = UIKit.Text(r, "", 26, UIKit.Theme.Gold, TextAlignmentOptions.Right);
|
||||
UIKit.Size(t, 180);
|
||||
@@ -112,7 +134,7 @@ public class TroopsPanel : BasePanel
|
||||
foreach (int amount in Amounts)
|
||||
{
|
||||
int a = amount;
|
||||
bool can = Barracks.Count > 0 && GP.CanAfford(def.cost, a) && d.training.Count < Barracks.QueueSize && GP.Recruitable >= a;
|
||||
bool can = Barracks.Count > 0 && GP.CanAfford(def.cost, a) && GP.Training.Count < Barracks.QueueSize && GP.Recruitable >= a;
|
||||
var b = UIKit.Button(btns, "+" + a, can ? UIKit.Theme.Green : UIKit.Theme.Gray, () => GP.Train(idx, a), -1, 80, 30);
|
||||
UIKit.Size(b, -1, 80, 1);
|
||||
}
|
||||
@@ -130,14 +152,14 @@ public class TroopsPanel : BasePanel
|
||||
|
||||
protected override void Tick()
|
||||
{
|
||||
var d = GP.Data;
|
||||
for (int i = 0; i < queueBars.Count && i < d.training.Count; i++)
|
||||
var training = GP.Training;
|
||||
for (int i = 0; i < queueBars.Count && i < training.Count; i++)
|
||||
{
|
||||
var o = d.training[i];
|
||||
var o = training[i];
|
||||
UIKit.SetBar(queueBars[i], GP.TrainingProgress(o));
|
||||
queueTimes[i].text = GameData.FormatTime(GP.TrainingSecondsLeft(o));
|
||||
}
|
||||
if (speedUp != null && d.training.Count > 0)
|
||||
if (speedUp != null && training.Count > 0)
|
||||
UIKit.SetButton(speedUp, "Ускорить всё за " + GP.SpeedUpCost + " кристаллов", true);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -9,6 +9,38 @@ using System.Text;
|
||||
// Один солдат -- в одном месте: либо в городе (troops), либо в походе (marches).
|
||||
// Поход забирает воинов из города и запоминает состав, возвращение раздаёт выживших по тем же типам.
|
||||
// Гарнизон (garrison) -- часть воинов города: они в troops, но в поход не уходят. garrison[i] <= troops[i] всегда.
|
||||
// Очередь обучения (training) -- тоже здесь (решения по 8 вопросам Саши, 31.10, п. 8): заказы, сроки, завершение.
|
||||
// Раненые (решения 31.10, п. 7): ждут места (woundedWaiting) или лечатся (healing) -- не в troops и не в походах.
|
||||
// Числа госпиталя (регламент 31.10, ТЕСТ). В игре -- из таблицы HospitalConfig.
|
||||
public sealed class HospitalRules
|
||||
{
|
||||
public int TemporaryBeds = 5; // мест, пока здания госпиталя нет (решения 01.11, п. 3); после постройки -- штатные, не вместе
|
||||
public int[] HealGameHours = { 4, 4, 6, 8 }; // лечение одного воина: пехота и лучники 4, кавалерия 6, осадные 8 ИГРОВЫХ часов
|
||||
public long GameHourMs = 5 * 60 * 1000; // 1 игровой час = 5 реальных минут
|
||||
// Цена лечения одного воина по типам (решения 01.11, п. 3: 1 / 1 / 2 / 3 золота -- в таблице HospitalConfig); пусто -- без цены
|
||||
public ResourceAmount[][] HealCostPerSoldier = null;
|
||||
|
||||
public static HospitalRules Default => new HospitalRules();
|
||||
|
||||
public long HealMs(int type)
|
||||
{
|
||||
int hours = HealGameHours != null && type >= 0 && type < HealGameHours.Length ? Math.Max(0, HealGameHours[type]) : 4;
|
||||
return hours * GameHourMs;
|
||||
}
|
||||
}
|
||||
|
||||
// Пропавшие без вести (решения 01.11, п. 5). Доля возвращающихся и формула -- НЕ УТВЕРЖДЕНЫ (ТЕСТ, таблица HospitalConfig)
|
||||
public sealed class MissingRules
|
||||
{
|
||||
public int ReturnPercent = 50; // сколько пропавших вернётся (утверждён диапазон 10-90%, формула открыта)
|
||||
public int WoundedPercent = 30; // из вернувшихся -- раненые (утверждено: 70% здоровыми, 30% ранеными)
|
||||
public int WindowGameHours = 6; // окно возвращения после обратного пути, ИГРОВЫХ часов
|
||||
public long GameHourMs = 5 * 60 * 1000;
|
||||
public int MaxGroups = 4; // возвращаются 2-4 группами (меньше, если пропавших мало)
|
||||
|
||||
public static MissingRules Default => new MissingRules();
|
||||
}
|
||||
|
||||
public sealed class ArmyService : IArmy, ISaveParticipant
|
||||
{
|
||||
public const int Types = 4; // пехота, лучники, кавалерия, осадные -- порядок как в GameData.Troops
|
||||
@@ -23,6 +55,51 @@ public sealed class ArmyService : IArmy, ISaveParticipant
|
||||
private readonly int[] garrison = new int[Types];
|
||||
private readonly List<MarchUnits> marches = new List<MarchUnits>();
|
||||
|
||||
private class TrainingOrder
|
||||
{
|
||||
public int id, type, count;
|
||||
public long startMs, endMs;
|
||||
public bool recruited; // под заказ взяты жители (Население). false -- старый заказ, людей не брали
|
||||
}
|
||||
|
||||
private class HealingBatch
|
||||
{
|
||||
public int id, type, count;
|
||||
public long startMs, endMs;
|
||||
}
|
||||
|
||||
private readonly int[] woundedWaiting = new int[Types];
|
||||
private readonly List<HealingBatch> healing = new List<HealingBatch>();
|
||||
private readonly List<HealingInfo> healingView = new List<HealingInfo>();
|
||||
private int nextHealId = 1;
|
||||
private readonly HospitalRules hospital;
|
||||
|
||||
// Пропавшие без вести одного боя: группы возвращения рассчитаны сразу, при постановке (детерминированно)
|
||||
private class MissingEvent
|
||||
{
|
||||
public int id, marchId;
|
||||
public long windowStartMs, endMs;
|
||||
public int[] remaining = new int[Types]; // ещё не вернулись и не списаны
|
||||
public List<MissingGroup> groups = new List<MissingGroup>();
|
||||
}
|
||||
|
||||
private class MissingGroup
|
||||
{
|
||||
public int index;
|
||||
public long timeMs;
|
||||
public int[] healthy = new int[Types], wounded = new int[Types];
|
||||
}
|
||||
|
||||
private readonly List<MissingEvent> missing = new List<MissingEvent>();
|
||||
private readonly List<MissingInfo> missingView = new List<MissingInfo>();
|
||||
private readonly HashSet<int> missingMarches = new HashSet<int>(); // по каким походам пропавшие уже отмечены
|
||||
private int nextMissingId = 1;
|
||||
private readonly MissingRules missingRules;
|
||||
|
||||
private readonly List<TrainingOrder> training = new List<TrainingOrder>();
|
||||
private readonly List<TrainingOrderInfo> trainingView = new List<TrainingOrderInfo>();
|
||||
private int nextOrderId = 1;
|
||||
|
||||
// Секция "army" была в сохранении -- старые войска из progress.json переносить не нужно
|
||||
public bool RestoredFromSave { get; private set; }
|
||||
|
||||
@@ -30,6 +107,21 @@ public sealed class ArmyService : IArmy, ISaveParticipant
|
||||
|
||||
public int TypeCount => Types;
|
||||
|
||||
// Слоты похода: база из таблицы MarchConfig (регламент 31.10: 2, ТЕСТ). Бонус «Военной логистики» -- позже.
|
||||
private readonly int baseMarchSlots;
|
||||
|
||||
public ArmyService(int baseMarchSlots = 2, HospitalRules hospital = null, MissingRules missingRules = null)
|
||||
{
|
||||
this.baseMarchSlots = Math.Max(1, baseMarchSlots);
|
||||
this.hospital = hospital ?? HospitalRules.Default;
|
||||
this.missingRules = missingRules ?? MissingRules.Default;
|
||||
}
|
||||
|
||||
public HospitalRules Hospital => hospital;
|
||||
|
||||
public int MarchSlots => baseMarchSlots;
|
||||
public int ActiveMarches => marches.Count;
|
||||
|
||||
public int GetTroops(int type)
|
||||
{
|
||||
return type >= 0 && type < Types ? troops[type] : 0;
|
||||
@@ -100,6 +192,8 @@ public sealed class ArmyService : IArmy, ISaveParticipant
|
||||
{
|
||||
// Поход с таким номером уже есть: перезапись потеряла бы его воинов
|
||||
if (marches.Exists(m => m.marchId == marchId)) return false;
|
||||
// Все слоты похода заняты. Походы из старых сохранений сверх лимита дойдут, но новых не будет
|
||||
if (marches.Count >= MarchSlots) return false;
|
||||
|
||||
// В поход -- только свободные воины, гарнизон остаётся в городе
|
||||
var free = new int[Types];
|
||||
@@ -139,17 +233,358 @@ public sealed class ArmyService : IArmy, ISaveParticipant
|
||||
// Выжившие точно по типам: бой посчитал потери каждого типа. Больше, чем ушло, вернуться не может.
|
||||
// Правила те же, что у ReturnFromMarch: только известный поход, только один раз.
|
||||
public bool ReturnUnits(int marchId, int[] survivorUnits)
|
||||
{
|
||||
return ReturnUnits(marchId, survivorUnits, null, 0);
|
||||
}
|
||||
|
||||
// Выжившие -- в город, раненые -- в госпиталь (решения 31.10, п. 7). Остальные из ушедших погибли.
|
||||
// Один солдат в одном месте: выжившие + раненые не больше, чем ушло, по каждому типу.
|
||||
public bool ReturnUnits(int marchId, int[] survivorUnits, int[] woundedUnits, long nowMs)
|
||||
{
|
||||
MarchUnits entry = marches.Find(m => m.marchId == marchId);
|
||||
if (entry == null) return false;
|
||||
|
||||
for (int i = 0; i < Types && survivorUnits != null && i < survivorUnits.Length; i++)
|
||||
troops[i] += Math.Max(0, Math.Min(survivorUnits[i], entry.units[i]));
|
||||
bool anyWounded = false;
|
||||
if (woundedUnits != null) ProcessHealing(nowMs); // сначала освободить места, которые освободились раньше
|
||||
for (int i = 0; i < Types; i++)
|
||||
{
|
||||
int alive = survivorUnits != null && i < survivorUnits.Length ? Math.Max(0, Math.Min(survivorUnits[i], entry.units[i])) : 0;
|
||||
int hurt = woundedUnits != null && i < woundedUnits.Length ? Math.Max(0, Math.Min(woundedUnits[i], entry.units[i] - alive)) : 0;
|
||||
troops[i] += alive;
|
||||
woundedWaiting[i] += hurt;
|
||||
if (hurt > 0) anyWounded = true;
|
||||
}
|
||||
marches.Remove(entry);
|
||||
if (anyWounded) FillBeds(nowMs);
|
||||
Changed();
|
||||
return true;
|
||||
}
|
||||
|
||||
// ---------------- Раненые и лечение ----------------
|
||||
|
||||
public int WoundedTotal
|
||||
{
|
||||
get
|
||||
{
|
||||
int n = 0;
|
||||
foreach (var w in woundedWaiting) n += w;
|
||||
foreach (var b in healing) n += b.count;
|
||||
return n;
|
||||
}
|
||||
}
|
||||
|
||||
public int GetAllTroops(int type)
|
||||
{
|
||||
if (type < 0 || type >= Types) return 0;
|
||||
int n = troops[type] + woundedWaiting[type];
|
||||
foreach (var m in marches) n += m.units[type];
|
||||
foreach (var b in healing) if (b.type == type) n += b.count;
|
||||
return n;
|
||||
}
|
||||
|
||||
// ---------------- Пропавшие без вести ----------------
|
||||
|
||||
public int MissingTotal
|
||||
{
|
||||
get { int n = 0; foreach (var e in missing) foreach (var r in e.remaining) n += r; return n; }
|
||||
}
|
||||
|
||||
public IReadOnlyList<MissingInfo> Missing
|
||||
{
|
||||
get
|
||||
{
|
||||
missingView.Clear();
|
||||
foreach (var e in missing)
|
||||
{
|
||||
int n = 0;
|
||||
foreach (var r in e.remaining) n += r;
|
||||
missingView.Add(new MissingInfo { Id = e.id, Count = n, WindowStartMs = e.windowStartMs, EndMs = e.endMs });
|
||||
}
|
||||
return missingView;
|
||||
}
|
||||
}
|
||||
|
||||
public bool MarkMissing(int marchId, int[] missingUnits, long battleMs, long travelMs)
|
||||
{
|
||||
if (missingUnits == null || missingMarches.Contains(marchId)) return false;
|
||||
MarchUnits entry = marches.Find(m => m.marchId == marchId);
|
||||
if (entry == null) return false;
|
||||
|
||||
var e = new MissingEvent { id = nextMissingId++, marchId = marchId };
|
||||
int total = 0;
|
||||
for (int i = 0; i < Types && i < missingUnits.Length; i++)
|
||||
{
|
||||
int n = Math.Max(0, Math.Min(missingUnits[i], entry.units[i]));
|
||||
entry.units[i] -= n; // из похода -- в пропавшие: один солдат в одном месте
|
||||
e.remaining[i] = n;
|
||||
total += n;
|
||||
}
|
||||
if (total == 0) { nextMissingId--; return false; }
|
||||
|
||||
e.windowStartMs = battleMs + Math.Max(0, travelMs);
|
||||
e.endMs = e.windowStartMs + Math.Max(0, missingRules.WindowGameHours) * missingRules.GameHourMs;
|
||||
PlanGroups(e, battleMs);
|
||||
missing.Add(e);
|
||||
missingMarches.Add(marchId);
|
||||
Changed();
|
||||
return true;
|
||||
}
|
||||
|
||||
// Кто вернётся и когда: доля возвращающихся по типам (дробная часть -- бросок), 2-4 группы в окне,
|
||||
// в каждой -- 70% здоровых, 30% раненых (дробная часть -- бросок). Тип войск сохраняется.
|
||||
void PlanGroups(MissingEvent e, long seedTime)
|
||||
{
|
||||
ulong seed = (ulong)e.marchId * 0x9E3779B97F4A7C15UL ^ (ulong)seedTime;
|
||||
int roll = 0;
|
||||
bool Chance(long num, long den) => den > 0 && (long)(Next(seed, roll++) % (ulong)den) < num;
|
||||
|
||||
var back = new int[Types];
|
||||
int returning = 0;
|
||||
for (int i = 0; i < Types; i++)
|
||||
{
|
||||
long num = (long)e.remaining[i] * Math.Max(0, Math.Min(100, missingRules.ReturnPercent));
|
||||
back[i] = (int)(num / 100) + (Chance(num % 100, 100) ? 1 : 0);
|
||||
returning += back[i];
|
||||
}
|
||||
if (returning == 0) return;
|
||||
|
||||
int groups = Math.Max(1, Math.Min(Math.Max(2, missingRules.MaxGroups), returning)); // мало вернувшихся -- групп меньше
|
||||
if (returning >= 2) groups = Math.Max(2, Math.Min(groups, 2 + (int)(Next(seed, roll++) % (ulong)(Math.Max(2, missingRules.MaxGroups) - 1))));
|
||||
long window = Math.Max(1, e.endMs - e.windowStartMs);
|
||||
for (int g = 0; g < groups; g++)
|
||||
e.groups.Add(new MissingGroup { index = g + 1, timeMs = e.windowStartMs + window * (g + 1) / (groups + 1) });
|
||||
|
||||
// Раздаём вернувшихся по группам по очереди, внутри группы -- здоровые и раненые
|
||||
for (int i = 0; i < Types; i++)
|
||||
for (int k = 0; k < back[i]; k++)
|
||||
{
|
||||
var grp = e.groups[(k + i) % groups];
|
||||
if (Chance(Math.Max(0, Math.Min(100, missingRules.WoundedPercent)), 100)) grp.wounded[i]++;
|
||||
else grp.healthy[i]++;
|
||||
}
|
||||
}
|
||||
|
||||
static ulong Next(ulong seed, int n)
|
||||
{
|
||||
ulong x = seed + 0x9E3779B97F4A7C15UL * (ulong)(n + 1);
|
||||
x = (x ^ (x >> 30)) * 0xBF58476D1CE4E5B9UL;
|
||||
x = (x ^ (x >> 27)) * 0x94D049BB133111EBUL;
|
||||
return x ^ (x >> 31);
|
||||
}
|
||||
|
||||
public int ProcessMissing(long nowMs)
|
||||
{
|
||||
int done = 0;
|
||||
bool changed = false;
|
||||
for (int k = missing.Count - 1; k >= 0; k--)
|
||||
{
|
||||
var e = missing[k];
|
||||
e.groups.Sort((a, b) => a.timeMs.CompareTo(b.timeMs));
|
||||
while (e.groups.Count > 0 && e.groups[0].timeMs <= nowMs && e.groups[0].timeMs <= e.endMs)
|
||||
{
|
||||
var g = e.groups[0];
|
||||
e.groups.RemoveAt(0); // группа возвращается один раз
|
||||
int healthy = 0, wounded = 0;
|
||||
bool anyWounded = false;
|
||||
for (int i = 0; i < Types; i++)
|
||||
{
|
||||
int h = Math.Min(g.healthy[i], e.remaining[i]);
|
||||
int w = Math.Min(g.wounded[i], e.remaining[i] - h);
|
||||
e.remaining[i] -= h + w;
|
||||
troops[i] += h; // исходной армии может уже не быть -- в резерв поселения
|
||||
woundedWaiting[i] += w; // раненые -- в госпиталь по обычным правилам
|
||||
healthy += h; wounded += w;
|
||||
if (w > 0) anyWounded = true;
|
||||
}
|
||||
if (anyWounded) { ProcessHealing(g.timeMs); FillBeds(g.timeMs); }
|
||||
done++;
|
||||
changed = true;
|
||||
EventBus.Publish(new MissingReturnedEvent { MissingId = e.id, Group = g.index, Healthy = healthy, Wounded = wounded, TimeMs = g.timeMs });
|
||||
}
|
||||
if (nowMs >= e.endMs)
|
||||
{
|
||||
int left = 0;
|
||||
foreach (var r in e.remaining) left += r;
|
||||
missing.RemoveAt(k); // окно кончилось: кто не вернулся -- списан, места освобождены
|
||||
changed = true;
|
||||
EventBus.Publish(new MissingWrittenOffEvent { MissingId = e.id, Count = left, TimeMs = e.endMs });
|
||||
}
|
||||
}
|
||||
if (changed) Changed();
|
||||
return done;
|
||||
}
|
||||
|
||||
public int GetWoundedWaiting(int type)
|
||||
{
|
||||
return type >= 0 && type < Types ? woundedWaiting[type] : 0;
|
||||
}
|
||||
|
||||
public IReadOnlyList<HealingInfo> Healing
|
||||
{
|
||||
get
|
||||
{
|
||||
healingView.Clear();
|
||||
foreach (var b in healing)
|
||||
healingView.Add(new HealingInfo { Id = b.id, Type = b.type, Count = b.count, StartMs = b.startMs, EndMs = b.endMs });
|
||||
return healingView;
|
||||
}
|
||||
}
|
||||
|
||||
// Места: от здания госпиталя (Поселение), пока его нет -- временные из таблицы
|
||||
public int HospitalBeds => GameServices.TryGet(out IHospital h) && h.Beds > 0 ? h.Beds : Math.Max(0, hospital.TemporaryBeds);
|
||||
|
||||
public int ProcessHealing(long nowMs)
|
||||
{
|
||||
int done = 0;
|
||||
// По времени: самая ранняя группа заканчивает -- на её место в тот же момент ложатся ждущие
|
||||
while (true)
|
||||
{
|
||||
HealingBatch next = null;
|
||||
foreach (var b in healing)
|
||||
if (b.endMs <= nowMs && (next == null || b.endMs < next.endMs || b.endMs == next.endMs && b.id < next.id)) next = b;
|
||||
if (next == null) break;
|
||||
|
||||
healing.Remove(next); // группа вылечена один раз: повторный расчёт её уже не найдёт
|
||||
troops[next.type] += next.count;
|
||||
done++;
|
||||
EventBus.Publish(new SoldiersHealedEvent { BatchId = next.id, Type = next.type, Count = next.count, TimeMs = next.endMs });
|
||||
FillBeds(next.endMs);
|
||||
}
|
||||
FillBeds(nowMs); // мест могло стать больше (госпиталь улучшили)
|
||||
if (done > 0) Changed();
|
||||
return done;
|
||||
}
|
||||
|
||||
// Положить ждущих на свободные места в момент atMs: по типам по порядку, каждая группа -- свой срок лечения.
|
||||
// Цена лечения (если задана) списывается через Экономику целиком; не хватает -- группа ждёт.
|
||||
void FillBeds(long atMs)
|
||||
{
|
||||
int free = HospitalBeds;
|
||||
foreach (var b in healing) free -= b.count;
|
||||
for (int type = 0; type < Types && free > 0; type++)
|
||||
{
|
||||
int n = Math.Min(free, woundedWaiting[type]);
|
||||
if (n <= 0) continue;
|
||||
if (!PayForHealing(type, n)) continue;
|
||||
woundedWaiting[type] -= n;
|
||||
free -= n;
|
||||
healing.Add(new HealingBatch { id = nextHealId++, type = type, count = n, startMs = atMs, endMs = atMs + hospital.HealMs(type) });
|
||||
}
|
||||
}
|
||||
|
||||
bool PayForHealing(int type, int soldiers)
|
||||
{
|
||||
var perSoldier = hospital.HealCostPerSoldier != null && type < hospital.HealCostPerSoldier.Length ? hospital.HealCostPerSoldier[type] : null;
|
||||
if (perSoldier == null || perSoldier.Length == 0) return true; // цена не утверждена -- без цены
|
||||
if (!GameServices.TryGet(out IEconomy economy)) return false;
|
||||
var cost = new List<ResourceAmount>();
|
||||
foreach (var c in perSoldier) if (c.Amount > 0) cost.Add(new ResourceAmount(c.Type, c.Amount * soldiers));
|
||||
return cost.Count == 0 || economy.TrySpend(cost);
|
||||
}
|
||||
|
||||
// ---------------- Очередь обучения ----------------
|
||||
|
||||
public IReadOnlyList<TrainingOrderInfo> Training
|
||||
{
|
||||
get
|
||||
{
|
||||
trainingView.Clear();
|
||||
foreach (var o in training)
|
||||
trainingView.Add(new TrainingOrderInfo { Id = o.id, Type = o.type, Count = o.count, StartMs = o.startMs, EndMs = o.endMs });
|
||||
return trainingView;
|
||||
}
|
||||
}
|
||||
|
||||
public bool CanQueueTraining(int type, int count, int queueSize, out string error)
|
||||
{
|
||||
error = null;
|
||||
if (type < 0 || type >= Types || count <= 0) error = "Неверный заказ";
|
||||
else if (training.Count >= queueSize) error = "Очередь обучения заполнена. Больше казарм -- длиннее очередь";
|
||||
else if (GameServices.TryGet(out IPopulation population) && population.Recruitable < count)
|
||||
error = population.Recruitable > 0
|
||||
? $"Жителей хватит только на {population.Recruitable} воинов"
|
||||
: $"Некого нанять: свободных жителей нет (резерв {population.CivilianReserve}). Снимите рабочих или стройте Дома";
|
||||
return error == null;
|
||||
}
|
||||
|
||||
public bool TryQueueTraining(int type, int count, long durationMs, int queueSize, long nowMs, out string error)
|
||||
{
|
||||
if (!CanQueueTraining(type, count, queueSize, out error)) return false;
|
||||
|
||||
// Воин -- житель города: люди уходят в Казармы сейчас, в Армию -- когда обучатся
|
||||
bool recruited = false;
|
||||
if (GameServices.TryGet(out IPopulation population))
|
||||
{
|
||||
if (!population.TryRecruit(count)) { error = "Некого нанять: жителей не хватает"; return false; }
|
||||
recruited = true;
|
||||
}
|
||||
|
||||
// Заказы идут друг за другом: новый начинается, когда закончится последний
|
||||
long start = training.Count > 0 ? Math.Max(nowMs, training[training.Count - 1].endMs) : nowMs;
|
||||
training.Add(new TrainingOrder
|
||||
{
|
||||
id = nextOrderId++, type = type, count = count,
|
||||
startMs = start, endMs = start + Math.Max(0, durationMs), recruited = recruited
|
||||
});
|
||||
Changed();
|
||||
return true;
|
||||
}
|
||||
|
||||
public int ProcessTraining(long nowMs)
|
||||
{
|
||||
int done = 0;
|
||||
while (training.Count > 0 && training[0].endMs <= nowMs)
|
||||
{
|
||||
TrainingOrder o = training[0];
|
||||
if (o.recruited)
|
||||
{
|
||||
// Новобранцы переходят из Населения в Армию одним действием (Население само зовёт AddTroops).
|
||||
// Населения ещё нет (запуск) -- подождём: заказ остаётся, никто не теряется.
|
||||
if (!GameServices.TryGet(out IPopulation population)) break;
|
||||
if (!population.CompleteTraining(o.type, o.count))
|
||||
{
|
||||
// Население не нашло этих новобранцев (испорченное сохранение): заказ снимается без воинов --
|
||||
// иначе люди появились бы из ниоткуда, а очередь встала бы навсегда
|
||||
training.RemoveAt(0);
|
||||
Changed();
|
||||
continue;
|
||||
}
|
||||
}
|
||||
else AddTroops(o.type, o.count); // старый заказ: людей под него не брали
|
||||
|
||||
training.RemoveAt(0); // заказ закончен один раз: повторный расчёт его уже не найдёт
|
||||
done++;
|
||||
EventBus.Publish(new TroopsTrainedEvent { OrderId = o.id, Type = o.type, Count = o.count, TimeMs = o.endMs });
|
||||
}
|
||||
return done;
|
||||
}
|
||||
|
||||
public int FinishAllTraining(long nowMs)
|
||||
{
|
||||
foreach (var o in training)
|
||||
{
|
||||
o.endMs = Math.Min(o.endMs, nowMs);
|
||||
o.startMs = Math.Min(o.startMs, o.endMs);
|
||||
}
|
||||
return ProcessTraining(nowMs);
|
||||
}
|
||||
|
||||
// Перенос очереди из старого progress.json (её вёл GameProgress). Время уже переведено в мс часов игры.
|
||||
public void ImportLegacyTraining(IEnumerable<(int type, int count, long startMs, long endMs, bool recruited)> orders)
|
||||
{
|
||||
if (orders == null) return;
|
||||
foreach (var o in orders)
|
||||
{
|
||||
if (o.type < 0 || o.type >= Types || o.count <= 0) continue;
|
||||
training.Add(new TrainingOrder
|
||||
{
|
||||
id = nextOrderId++, type = o.type, count = o.count,
|
||||
startMs = o.startMs, endMs = Math.Max(o.startMs, o.endMs), recruited = o.recruited
|
||||
});
|
||||
}
|
||||
Changed();
|
||||
}
|
||||
|
||||
void ClampGarrison()
|
||||
{
|
||||
for (int i = 0; i < Types; i++) garrison[i] = Math.Max(0, Math.Min(garrison[i], troops[i]));
|
||||
@@ -157,7 +592,8 @@ public sealed class ArmyService : IArmy, ISaveParticipant
|
||||
|
||||
void Changed()
|
||||
{
|
||||
EventBus.Publish(new TroopsChangedEvent { AtHome = SoldiersAtHome, InMarches = TroopsInMarches, Garrison = GarrisonTotal });
|
||||
EventBus.Publish(new TroopsChangedEvent { AtHome = SoldiersAtHome, InMarches = TroopsInMarches, Garrison = GarrisonTotal, Wounded = WoundedTotal,
|
||||
Missing = MissingTotal });
|
||||
}
|
||||
|
||||
// ---------------- Перенос из старого progress.json ----------------
|
||||
@@ -189,6 +625,14 @@ public sealed class ArmyService : IArmy, ISaveParticipant
|
||||
// troops=<пехота>,<лучники>,<кавалерия>,<осадные>
|
||||
// garrison=<пехота>,<лучники>,<кавалерия>,<осадные> (из troops; нет строки -- гарнизона нет)
|
||||
// march=<id похода>:<пехота>,<лучники>,<кавалерия>,<осадные>
|
||||
// train=<id>|<тип>|<сколько>|<начало, мс>|<конец, мс>|<люди взяты 1/0> (по порядку очереди)
|
||||
// trainNext=<номер следующего заказа>
|
||||
// wounded=<пехота>,<лучники>,<кавалерия>,<осадные> (ждут места в госпитале)
|
||||
// heal=<id>|<тип>|<сколько>|<начало, мс>|<конец, мс>
|
||||
// healNext=<номер следующей группы лечения>
|
||||
// missing=<id>|<поход>|<окно с, мс>|<конец, мс>|<осталось по типам через ,>
|
||||
// mgroup=<id пропавших>|<номер группы>|<время, мс>|<здоровые по типам>|<раненые по типам> (ещё не вернувшиеся группы)
|
||||
// missingMarch=<поход> (по нему пропавшие уже отмечены) missingNext=<номер>
|
||||
|
||||
public string SaveKey => "army";
|
||||
|
||||
@@ -199,6 +643,34 @@ public sealed class ArmyService : IArmy, ISaveParticipant
|
||||
sb.Append("garrison=").Append(Join(garrison)).Append('\n');
|
||||
foreach (var m in marches)
|
||||
sb.Append("march=").Append(m.marchId.ToString(CultureInfo.InvariantCulture)).Append(':').Append(Join(m.units)).Append('\n');
|
||||
foreach (var o in training)
|
||||
sb.Append("train=").Append(string.Join("|", new[]
|
||||
{
|
||||
N(o.id), N(o.type), N(o.count),
|
||||
o.startMs.ToString(CultureInfo.InvariantCulture), o.endMs.ToString(CultureInfo.InvariantCulture), o.recruited ? "1" : "0"
|
||||
})).Append('\n');
|
||||
sb.Append("trainNext=").Append(N(nextOrderId)).Append('\n');
|
||||
sb.Append("wounded=").Append(Join(woundedWaiting)).Append('\n');
|
||||
foreach (var b in healing)
|
||||
sb.Append("heal=").Append(string.Join("|", new[]
|
||||
{
|
||||
N(b.id), N(b.type), N(b.count), b.startMs.ToString(CultureInfo.InvariantCulture), b.endMs.ToString(CultureInfo.InvariantCulture)
|
||||
})).Append('\n');
|
||||
sb.Append("healNext=").Append(N(nextHealId)).Append('\n');
|
||||
foreach (var e in missing)
|
||||
{
|
||||
sb.Append("missing=").Append(string.Join("|", new[]
|
||||
{
|
||||
N(e.id), N(e.marchId), e.windowStartMs.ToString(CultureInfo.InvariantCulture), e.endMs.ToString(CultureInfo.InvariantCulture), Join(e.remaining)
|
||||
})).Append('\n');
|
||||
foreach (var g in e.groups)
|
||||
sb.Append("mgroup=").Append(string.Join("|", new[]
|
||||
{
|
||||
N(e.id), N(g.index), g.timeMs.ToString(CultureInfo.InvariantCulture), Join(g.healthy), Join(g.wounded)
|
||||
})).Append('\n');
|
||||
}
|
||||
foreach (var id in missingMarches) sb.Append("missingMarch=").Append(N(id)).Append('\n');
|
||||
sb.Append("missingNext=").Append(N(nextMissingId)).Append('\n');
|
||||
return sb.ToString();
|
||||
}
|
||||
|
||||
@@ -207,6 +679,14 @@ public sealed class ArmyService : IArmy, ISaveParticipant
|
||||
Array.Clear(troops, 0, Types);
|
||||
Array.Clear(garrison, 0, Types);
|
||||
marches.Clear();
|
||||
training.Clear();
|
||||
nextOrderId = 1;
|
||||
Array.Clear(woundedWaiting, 0, Types);
|
||||
healing.Clear();
|
||||
nextHealId = 1;
|
||||
missing.Clear();
|
||||
missingMarches.Clear();
|
||||
nextMissingId = 1;
|
||||
RestoredFromSave = true;
|
||||
|
||||
if (!string.IsNullOrEmpty(data))
|
||||
@@ -231,6 +711,75 @@ public sealed class ArmyService : IArmy, ISaveParticipant
|
||||
&& !marches.Exists(x => x.marchId == id)) // один поход -- одна запись
|
||||
marches.Add(new MarchUnits { marchId = id, units = Parse(parts[1]) });
|
||||
}
|
||||
else if (line.StartsWith("train="))
|
||||
{
|
||||
string[] p = line.Substring("train=".Length).Split('|');
|
||||
if (p.Length == 6 && int.TryParse(p[0], NumberStyles.Integer, CultureInfo.InvariantCulture, out int oid)
|
||||
&& int.TryParse(p[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out int type) && type >= 0 && type < Types
|
||||
&& int.TryParse(p[2], NumberStyles.Integer, CultureInfo.InvariantCulture, out int count) && count > 0
|
||||
&& long.TryParse(p[3], NumberStyles.Integer, CultureInfo.InvariantCulture, out long start)
|
||||
&& long.TryParse(p[4], NumberStyles.Integer, CultureInfo.InvariantCulture, out long end)
|
||||
&& !training.Exists(x => x.id == oid)) // один заказ -- одна запись
|
||||
{
|
||||
training.Add(new TrainingOrder { id = oid, type = type, count = count, startMs = start, endMs = end, recruited = p[5] == "1" });
|
||||
nextOrderId = Math.Max(nextOrderId, oid + 1);
|
||||
}
|
||||
}
|
||||
else if (line.StartsWith("wounded="))
|
||||
{
|
||||
int[] w = Parse(line.Substring("wounded=".Length));
|
||||
Array.Copy(w, woundedWaiting, Types);
|
||||
}
|
||||
else if (line.StartsWith("heal="))
|
||||
{
|
||||
string[] p = line.Substring("heal=".Length).Split('|');
|
||||
if (p.Length == 5 && int.TryParse(p[0], NumberStyles.Integer, CultureInfo.InvariantCulture, out int hid)
|
||||
&& int.TryParse(p[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out int htype) && htype >= 0 && htype < Types
|
||||
&& int.TryParse(p[2], NumberStyles.Integer, CultureInfo.InvariantCulture, out int hcount) && hcount > 0
|
||||
&& long.TryParse(p[3], NumberStyles.Integer, CultureInfo.InvariantCulture, out long hstart)
|
||||
&& long.TryParse(p[4], NumberStyles.Integer, CultureInfo.InvariantCulture, out long hend)
|
||||
&& !healing.Exists(x => x.id == hid))
|
||||
{
|
||||
healing.Add(new HealingBatch { id = hid, type = htype, count = hcount, startMs = hstart, endMs = hend });
|
||||
nextHealId = Math.Max(nextHealId, hid + 1);
|
||||
}
|
||||
}
|
||||
else if (line.StartsWith("missing="))
|
||||
{
|
||||
string[] p = line.Substring("missing=".Length).Split('|');
|
||||
if (p.Length == 5 && int.TryParse(p[0], NumberStyles.Integer, CultureInfo.InvariantCulture, out int mid)
|
||||
&& int.TryParse(p[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out int mmarch)
|
||||
&& long.TryParse(p[2], NumberStyles.Integer, CultureInfo.InvariantCulture, out long mstart)
|
||||
&& long.TryParse(p[3], NumberStyles.Integer, CultureInfo.InvariantCulture, out long mend)
|
||||
&& !missing.Exists(x => x.id == mid))
|
||||
{
|
||||
missing.Add(new MissingEvent { id = mid, marchId = mmarch, windowStartMs = mstart, endMs = mend, remaining = Parse(p[4]) });
|
||||
nextMissingId = Math.Max(nextMissingId, mid + 1);
|
||||
}
|
||||
}
|
||||
else if (line.StartsWith("mgroup="))
|
||||
{
|
||||
string[] p = line.Substring("mgroup=".Length).Split('|');
|
||||
MissingEvent owner = null;
|
||||
if (p.Length == 5 && int.TryParse(p[0], NumberStyles.Integer, CultureInfo.InvariantCulture, out int gid))
|
||||
owner = missing.Find(x => x.id == gid); // строки missing= идут раньше своих групп
|
||||
if (owner != null && int.TryParse(p[1], NumberStyles.Integer, CultureInfo.InvariantCulture, out int gidx)
|
||||
&& long.TryParse(p[2], NumberStyles.Integer, CultureInfo.InvariantCulture, out long gtime)
|
||||
&& !owner.groups.Exists(x => x.index == gidx))
|
||||
owner.groups.Add(new MissingGroup { index = gidx, timeMs = gtime, healthy = Parse(p[3]), wounded = Parse(p[4]) });
|
||||
}
|
||||
else if (line.StartsWith("missingMarch=")
|
||||
&& int.TryParse(line.Substring("missingMarch=".Length), NumberStyles.Integer, CultureInfo.InvariantCulture, out int mm))
|
||||
missingMarches.Add(mm);
|
||||
else if (line.StartsWith("missingNext=")
|
||||
&& int.TryParse(line.Substring("missingNext=".Length), NumberStyles.Integer, CultureInfo.InvariantCulture, out int mnext))
|
||||
nextMissingId = Math.Max(nextMissingId, mnext);
|
||||
else if (line.StartsWith("healNext=")
|
||||
&& int.TryParse(line.Substring("healNext=".Length), NumberStyles.Integer, CultureInfo.InvariantCulture, out int hnext))
|
||||
nextHealId = Math.Max(nextHealId, hnext);
|
||||
else if (line.StartsWith("trainNext=")
|
||||
&& int.TryParse(line.Substring("trainNext=".Length), NumberStyles.Integer, CultureInfo.InvariantCulture, out int next))
|
||||
nextOrderId = Math.Max(nextOrderId, next);
|
||||
}
|
||||
}
|
||||
ClampGarrison(); // гарнизон не больше войск, даже если файл правили руками
|
||||
@@ -243,9 +792,19 @@ public sealed class ArmyService : IArmy, ISaveParticipant
|
||||
Array.Clear(troops, 0, Types);
|
||||
Array.Clear(garrison, 0, Types);
|
||||
marches.Clear();
|
||||
training.Clear();
|
||||
nextOrderId = 1;
|
||||
Array.Clear(woundedWaiting, 0, Types);
|
||||
healing.Clear();
|
||||
nextHealId = 1;
|
||||
missing.Clear();
|
||||
missingMarches.Clear();
|
||||
nextMissingId = 1;
|
||||
Changed();
|
||||
}
|
||||
|
||||
static string N(int v) => v.ToString(CultureInfo.InvariantCulture);
|
||||
|
||||
static string Join(int[] values)
|
||||
{
|
||||
var parts = new string[values.Length];
|
||||
|
||||
@@ -6,7 +6,10 @@
|
||||
// итог боя запоминает версию, по которой посчитан.
|
||||
public sealed class BattleRules
|
||||
{
|
||||
public int Version = 2; // 2 -- добавлены голод и усталость
|
||||
public int Version = 8; // 2 -- голод и усталость; 3 -- сила без округления, потери шансом (№12, №13); 4 -- кривая потерь (№14);
|
||||
// 5 -- разгром дальше 5:1 (решения по 8 вопросам Саши, 31.10, п. 5); 6 -- раненые (п. 7);
|
||||
// 7 -- сильная сторона 5:1 -> 10:1 с 11% до 2% (решения по отчёту Саши, 01.11, п. 1);
|
||||
// 8 -- пропавшие без вести (п. 5)
|
||||
|
||||
// Сила одного воина каждого типа. В игре -- из GameData.Troops (там же цена и время обучения).
|
||||
public int[] UnitPower = { 4, 5, 9, 16 };
|
||||
@@ -15,9 +18,30 @@ public sealed class BattleRules
|
||||
public int WallsPercent = 20; // защитникам за стенами
|
||||
public int SiegeVsWallsPercent = 50; // осадным при штурме стен
|
||||
public int SiegeInFieldPercent = -25; // осадным в поле и в обороне
|
||||
public int LoserLossPercent = 50; // потери проигравшего (не окончательная формула)
|
||||
public int RandomPercent = 5; // случайность каждой стороны: от -5% до +5%
|
||||
|
||||
// Кривая потерь (решение №14, регламент 31.10, ТЕСТ): доля выбывших от каждого типа в зависимости от
|
||||
// соотношения итоговых сил (сильная / слабая), в десятых долях процента. Между опорными точками -- плавно
|
||||
// (линейно), без порогов-переключателей.
|
||||
// Разгром (решения 31.10, п. 5): 7:1 -- 92%, 10:1 -- 95%, дальше слабая сторона плавно стремится к WeakLossMaxPermille (99%):
|
||||
// v = max - (max - v_last) * R_last / R -- при 20:1 97%, при 100:1 98,6%; 100% не достигается.
|
||||
// Сильная сторона (решения по отчёту Саши, 01.11, п. 1): 5:1 -- 11%, плавно до 2% при 10:1, дальше 2%.
|
||||
public int[] LossRatioPermille = { 1000, 3000, 5000, 7000, 10000 }; // 1:1, 3:1, 5:1, 7:1, 10:1
|
||||
public int[] StrongLossPermille = { 450, 160, 110, 74, 20 }; // сильная сторона: 45%, 16%, 11%, 7,4%, 2%
|
||||
public int[] WeakLossPermille = { 450, 740, 880, 920, 950 }; // слабая сторона: 45%, 74%, 88%, 92%, 95%
|
||||
public int WeakLossMaxPermille = 990; // верхний предел ожидаемых потерь слабой стороны: 99%
|
||||
|
||||
// Погибшие и раненые (регламент 31.10, ТЕСТ; решения 31.10, п. 7): из выбывших стороны погибает доля,
|
||||
// зависящая от её соотношения сил (своя / чужая), остальные -- раненые. Ориентиры регламента:
|
||||
// разгром 1:5 -- ~70%, поражение 1:2 -- ~45%, равный бой -- ~30%, уверенная победа 3:1 -- ~20%.
|
||||
// Между точками -- плавно (линейно), за крайними -- значения крайних. Округление -- отдельным броском.
|
||||
public int[] DeadRatioPermille = { 200, 500, 1000, 3000 }; // соотношение сил стороны: 1:5, 1:2, 1:1, 3:1
|
||||
public int[] DeadSharePermille = { 700, 450, 300, 200 }; // доля погибших среди выбывших: 70%, 45%, 30%, 20%
|
||||
|
||||
// Пропавшие без вести (решения 01.11, п. 5): доля выбывших, получающих этот статус, в десятых долях процента.
|
||||
// НЕ УТВЕРЖДЕНА командой -- по умолчанию 0 (механика выключена). Остальные выбывшие -- погибшие и раненые, как выше.
|
||||
public int MissingSharePermille = 0;
|
||||
|
||||
// Состояния (утверждено 27.10.2026): сколько силы остаётся. Применяются последовательно: 50% x 80% = 40%
|
||||
public int FamineStrengthPercent = 50; // голод: -50%
|
||||
public int FatigueStrengthPercent = 80; // усталость: -20%
|
||||
|
||||
@@ -1,21 +1,37 @@
|
||||
using System;
|
||||
using System.Numerics;
|
||||
|
||||
// МОДУЛЬ БОЕВОЙ СИСТЕМЫ: урон, потери, исход. Документ: Docs/Modules/Battle.md
|
||||
// Без Unity и без float: этот же код без изменений сможет считать бои на сервере.
|
||||
//
|
||||
// Правила (стартовые числа -- в BattleRules, утверждает команда):
|
||||
// - сила стороны = сумма по типам: воины x сила типа x (100% + контры + осадный бонус) x (100% + бонусы стороны);
|
||||
// Правила (стартовые числа -- в BattleRules; решения №11-13 комплекта требований от 29.10.2026):
|
||||
// - сила стороны = сумма по типам: воины x сила типа x (100% + контры + осадный бонус)
|
||||
// x (100% + бонусы стороны) x состояния (голод, усталость) x (100% + удача);
|
||||
// - контры: пехота сильнее кавалерии, кавалерия сильнее лучников, лучники сильнее пехоты;
|
||||
// бонус типа против врага взвешивается по составу врага;
|
||||
// - осадные: против стен сильнее, в поле слабее; стены усиливают защитников;
|
||||
// - случайность: каждой стороне от -5% до +5%, считается из Seed -- тот же Seed даёт тот же итог;
|
||||
// - удача: каждой стороне от -5% до +5%, ПОСЛЕ всех модификаторов, из Seed -- тот же Seed даёт тот же итог (№12);
|
||||
// - сила считается точной дробью (BigInteger) и округляется один раз -- только для показа (№12);
|
||||
// - побеждает тот, у кого итоговая сила больше; ничья -- защитнику;
|
||||
// - проигравший теряет половину каждого типа; победитель -- до половины, тем больше, чем ровнее был бой.
|
||||
// Это не окончательная формула потерь (план от 27.10.2026): раненых пока нет, все выбывшие -- погибшие.
|
||||
// - потери (№14): доля выбывших каждого типа -- плавная функция соотношения итоговых сил (сильная / слабая)
|
||||
// по опорным точкам BattleRules: 1:1 -- 45% / 45%, 3:1 -- 16% / 74%, 5:1 -- 11% / 88%. Одинаково для PvE, PvP и Круга;
|
||||
// - округление потерь: целая часть гарантирована, дробная -- шанс ещё одной потери,
|
||||
// из отдельного потока случайности (№13). Раненых пока нет, все выбывшие -- погибшие.
|
||||
public sealed class BattleSystem : IBattleSystem
|
||||
{
|
||||
// Точная неотрицательная дробь: сила x100 = N / D
|
||||
struct Fraction
|
||||
{
|
||||
public BigInteger N, D;
|
||||
public long Floor => (long)(N / D);
|
||||
}
|
||||
|
||||
enum Rounding { Roll, Floor, Ceiling } // бой -- бросок по №13; прогноз -- лучший и худший случай
|
||||
|
||||
private readonly BattleRules rules;
|
||||
private readonly int[] power;
|
||||
private readonly int[] lossRatio, strongLoss, weakLoss; // кривая потерь (проверенная копия из правил)
|
||||
private readonly int[] deadRatio, deadShare; // доля погибших среди выбывших (проверенная копия)
|
||||
|
||||
public BattleRules Rules => rules;
|
||||
|
||||
@@ -29,6 +45,71 @@ public sealed class BattleSystem : IBattleSystem
|
||||
for (int i = 0; i < TroopType.Count; i++)
|
||||
power[i] = this.rules.UnitPower != null && i < this.rules.UnitPower.Length && this.rules.UnitPower[i] > 0
|
||||
? this.rules.UnitPower[i] : defaults[i];
|
||||
|
||||
// Кривая из таблицы, если она корректна, иначе -- значения по умолчанию (ошибка в Inspector не ломает бой)
|
||||
var r = this.rules;
|
||||
bool ok = r.LossRatioPermille != null && r.StrongLossPermille != null && r.WeakLossPermille != null
|
||||
&& r.LossRatioPermille.Length > 0
|
||||
&& r.LossRatioPermille.Length == r.StrongLossPermille.Length
|
||||
&& r.LossRatioPermille.Length == r.WeakLossPermille.Length
|
||||
&& r.LossRatioPermille[0] == 1000;
|
||||
for (int i = 0; ok && i < r.LossRatioPermille.Length; i++)
|
||||
{
|
||||
ok = r.StrongLossPermille[i] >= 0 && r.StrongLossPermille[i] <= 1000 && r.WeakLossPermille[i] >= 0 && r.WeakLossPermille[i] <= 1000
|
||||
&& (i == 0 || r.LossRatioPermille[i] > r.LossRatioPermille[i - 1]);
|
||||
}
|
||||
var src = ok ? r : BattleRules.Default;
|
||||
lossRatio = (int[])src.LossRatioPermille.Clone();
|
||||
strongLoss = (int[])src.StrongLossPermille.Clone();
|
||||
weakLoss = (int[])src.WeakLossPermille.Clone();
|
||||
// Доля погибших: та же проверка -- ошибка в таблице не ломает бой
|
||||
bool deadOk = r.DeadRatioPermille != null && r.DeadSharePermille != null && r.DeadRatioPermille.Length > 0
|
||||
&& r.DeadRatioPermille.Length == r.DeadSharePermille.Length;
|
||||
for (int i = 0; deadOk && i < r.DeadRatioPermille.Length; i++)
|
||||
deadOk = r.DeadRatioPermille[i] > 0 && r.DeadSharePermille[i] >= 0 && r.DeadSharePermille[i] <= 1000
|
||||
&& (i == 0 || r.DeadRatioPermille[i] > r.DeadRatioPermille[i - 1]);
|
||||
var deadSrc = deadOk ? r : BattleRules.Default;
|
||||
deadRatio = (int[])deadSrc.DeadRatioPermille.Clone();
|
||||
deadShare = (int[])deadSrc.DeadSharePermille.Clone();
|
||||
|
||||
// Предел не ниже последней точки и не выше 100%
|
||||
weakLossMax = Math.Min(1000, Math.Max(weakLoss[weakLoss.Length - 1], r.WeakLossMaxPermille));
|
||||
}
|
||||
|
||||
private int weakLossMax;
|
||||
|
||||
// Доля выбывших стороны (в десятых долях процента, дробью) при соотношении сил stronger / weaker (решение №14)
|
||||
void LossShare(Fraction weaker, Fraction stronger, bool isWeak, out BigInteger num, out BigInteger den)
|
||||
{
|
||||
int[] values = isWeak ? weakLoss : strongLoss;
|
||||
int last = lossRatio.Length - 1;
|
||||
if (weaker.N.IsZero)
|
||||
{
|
||||
// У слабой стороны нулевая сила: сильная не теряет никого, слабая -- предел разгрома
|
||||
num = isWeak ? weakLossMax : 0;
|
||||
den = 1;
|
||||
return;
|
||||
}
|
||||
|
||||
// Соотношение сил в десятых долях процента: R = 1000 * stronger / weaker = rn / rd
|
||||
BigInteger rn = 1000 * stronger.N * weaker.D;
|
||||
BigInteger rd = stronger.D * weaker.N;
|
||||
if (rn <= lossRatio[0] * rd) { num = values[0]; den = 1; return; }
|
||||
if (rn >= lossRatio[last] * rd)
|
||||
{
|
||||
if (!isWeak) { num = values[last]; den = 1; return; }
|
||||
// Дальше последней точки слабая сторона плавно стремится к пределу: v = max - (max - v_last) * R_last / R
|
||||
num = (BigInteger)weakLossMax * rn - (BigInteger)(weakLossMax - values[last]) * lossRatio[last] * rd;
|
||||
den = rn;
|
||||
return;
|
||||
}
|
||||
|
||||
int i = 0;
|
||||
while (rn >= lossRatio[i + 1] * rd) i++; // lossRatio[i] <= R < lossRatio[i + 1]
|
||||
long span = lossRatio[i + 1] - lossRatio[i];
|
||||
// v = v_i + (v_{i+1} - v_i) * (R - p_i) / span -- точной дробью
|
||||
num = (BigInteger)values[i] * span * rd + (BigInteger)(values[i + 1] - values[i]) * (rn - lossRatio[i] * rd);
|
||||
den = span * rd;
|
||||
}
|
||||
|
||||
// Контра: насколько тип attackerType сильнее против defenderType, в процентах
|
||||
@@ -42,66 +123,88 @@ public sealed class BattleSystem : IBattleSystem
|
||||
|
||||
public BattleOutcome Resolve(BattleRequest request)
|
||||
{
|
||||
return Fight(request, Luck(request.Seed, 1), Luck(request.Seed, 2));
|
||||
return Fight(request, Luck(request.Seed, 1), Luck(request.Seed, 2), Rounding.Roll);
|
||||
}
|
||||
|
||||
// Прогноз: бой при крайних значениях случайности. Итог конкретного боя не раскрывается.
|
||||
// Прогноз (№11): качественный риск и точный шанс победы. Итог конкретного боя не раскрывается.
|
||||
public BattleForecast Forecast(BattleRequest request)
|
||||
{
|
||||
int r = rules.RandomPercent * 10;
|
||||
int r = Math.Max(0, rules.RandomPercent * 10);
|
||||
var f = new BattleForecast
|
||||
{
|
||||
AttackerPowerMin = long.MaxValue, DefenderPowerMin = long.MaxValue,
|
||||
AttackerLossesMin = int.MaxValue
|
||||
};
|
||||
bool anyWin = false, anyLoss = false;
|
||||
foreach (int attLuck in new[] { -r, r })
|
||||
foreach (int defLuck in new[] { -r, r })
|
||||
{
|
||||
BattleOutcome o = Fight(request, attLuck, defLuck);
|
||||
if (o.Victory) anyWin = true; else anyLoss = true;
|
||||
f.AttackerPowerMin = Math.Min(f.AttackerPowerMin, o.AttackerPower);
|
||||
f.AttackerPowerMax = Math.Max(f.AttackerPowerMax, o.AttackerPower);
|
||||
f.DefenderPowerMin = Math.Min(f.DefenderPowerMin, o.DefenderPower);
|
||||
f.DefenderPowerMax = Math.Max(f.DefenderPowerMax, o.DefenderPower);
|
||||
f.AttackerLossesMin = Math.Min(f.AttackerLossesMin, o.AttackerLosses);
|
||||
f.AttackerLossesMax = Math.Max(f.AttackerLossesMax, o.AttackerLosses);
|
||||
BattleOutcome best = Fight(request, attLuck, defLuck, Rounding.Floor);
|
||||
BattleOutcome worst = Fight(request, attLuck, defLuck, Rounding.Ceiling);
|
||||
f.AttackerPowerMin = Math.Min(f.AttackerPowerMin, best.AttackerPower);
|
||||
f.AttackerPowerMax = Math.Max(f.AttackerPowerMax, best.AttackerPower);
|
||||
f.DefenderPowerMin = Math.Min(f.DefenderPowerMin, best.DefenderPower);
|
||||
f.DefenderPowerMax = Math.Max(f.DefenderPowerMax, best.DefenderPower);
|
||||
f.AttackerLossesMin = Math.Min(f.AttackerLossesMin, best.AttackerLosses);
|
||||
f.AttackerLossesMax = Math.Max(f.AttackerLossesMax, worst.AttackerLosses);
|
||||
}
|
||||
f.Chance = !anyLoss ? BattleChance.Advantage : !anyWin ? BattleChance.HighRisk : BattleChance.Uncertain;
|
||||
|
||||
// Шанс победы: все сочетания удачи сторон равновероятны -- считаем, при скольких нападающий сильнее
|
||||
Sides(request, out Fraction att, out Fraction def, out _, out _, out _, out _);
|
||||
BigInteger x = att.N * def.D, y = def.N * att.D; // нападающий побеждает, если x * (1000 + a) > y * (1000 + d)
|
||||
long wins = 0, total = (long)(2 * r + 1) * (2 * r + 1);
|
||||
for (int a = -r; a <= r; a++)
|
||||
{
|
||||
BigInteger t = x * (1000 + a);
|
||||
if (y.IsZero) { if (t > 0) wins += 2 * r + 1; continue; }
|
||||
// нужно y * (1000 + d) < t, то есть 1000 + d <= ceil(t / y) - 1
|
||||
BigInteger dMax = (t + y - 1) / y - 1 - 1000;
|
||||
if (dMax < -r) continue;
|
||||
wins += dMax >= r ? 2 * r + 1 : (long)dMax + r + 1;
|
||||
}
|
||||
f.WinChancePermille = (int)((wins * 1000 + total / 2) / total);
|
||||
f.Chance = wins == total ? BattleChance.Advantage : wins == 0 ? BattleChance.HighRisk : BattleChance.Uncertain;
|
||||
return f;
|
||||
}
|
||||
|
||||
BattleOutcome Fight(BattleRequest request, int attLuckPermille, int defLuckPermille)
|
||||
BattleOutcome Fight(BattleRequest request, int attLuckPermille, int defLuckPermille, Rounding rounding)
|
||||
{
|
||||
int[] att = Units(request.AttackerUnits, request.Attackers);
|
||||
int[] def = Units(request.DefenderUnits, request.Defenders);
|
||||
Sides(request, out Fraction attBase, out Fraction defBase, out int[] att, out int[] def,
|
||||
out int attCondition, out int defCondition);
|
||||
Fraction attPower = WithLuck(attBase, attLuckPermille);
|
||||
Fraction defPower = WithLuck(defBase, defLuckPermille);
|
||||
|
||||
int attCondition = ConditionPercent(request.AttackerConditions);
|
||||
int defCondition = ConditionPercent(request.DefenderConditions);
|
||||
long attPower = SidePower(att, def, attacking: true, request.DefenderFortified, request.AttackerBonusPercent, attCondition, attLuckPermille);
|
||||
long defPower = SidePower(def, att, attacking: false, request.DefenderFortified,
|
||||
request.DefenderBonusPercent + (request.DefenderFortified ? rules.WallsPercent : 0), defCondition, defLuckPermille);
|
||||
bool victory = attPower.N * defPower.D > defPower.N * attPower.D; // ничья -- в пользу защитника
|
||||
|
||||
bool victory = attPower > defPower; // ничья -- в пользу защитника
|
||||
// Потери по кривой (№14): победитель -- сильная сторона, проигравший -- слабая; при ничьей соотношение 1:1
|
||||
Fraction weaker = victory ? defPower : attPower;
|
||||
Fraction stronger = victory ? attPower : defPower;
|
||||
int[] attOut = Losses(att, weaker, stronger, isWeak: !victory, request.Seed, side: 1, rounding);
|
||||
int[] defOut0 = Losses(def, weaker, stronger, isWeak: victory, request.Seed, side: 2, rounding);
|
||||
|
||||
// Потери в процентах: проигравший -- LoserLossPercent; победитель -- то же x (сила проигравшего / сила победителя)
|
||||
long stronger = Math.Max(attPower, defPower);
|
||||
long weaker = Math.Min(attPower, defPower);
|
||||
int[] attDead = Losses(att, weaker, stronger, isLoser: !victory);
|
||||
int[] defDead = Losses(def, weaker, stronger, isLoser: victory);
|
||||
|
||||
// Раненых пока нет: доля раненых и погибших не утверждена (план от 27.10.2026)
|
||||
// Выбывшие: сначала пропавшие без вести (решения 01.11, п. 5), остальные -- погибшие и раненые (решения 31.10, п. 7):
|
||||
// доля погибших -- от соотношения сил своей стороны. Солдат -- ровно в одном статусе
|
||||
int[] attMissing = Missing(attOut, request.Seed, side: 1, rounding);
|
||||
int[] defMissing = Missing(defOut0, request.Seed, side: 2, rounding);
|
||||
int[] attRest = new int[TroopType.Count], defRest = new int[TroopType.Count];
|
||||
for (int i = 0; i < TroopType.Count; i++) { attRest[i] = attOut[i] - attMissing[i]; defRest[i] = defOut0[i] - defMissing[i]; }
|
||||
int[] attDead = Dead(attRest, attPower, defPower, request.Seed, side: 1, rounding);
|
||||
int[] defDead = Dead(defRest, defPower, attPower, request.Seed, side: 2, rounding);
|
||||
int[] attWounded = new int[TroopType.Count];
|
||||
int[] defWounded = new int[TroopType.Count];
|
||||
for (int i = 0; i < TroopType.Count; i++)
|
||||
{
|
||||
attWounded[i] = attRest[i] - attDead[i];
|
||||
defWounded[i] = defRest[i] - defDead[i];
|
||||
}
|
||||
|
||||
var attAlive = new int[TroopType.Count];
|
||||
var defAlive = new int[TroopType.Count];
|
||||
var defOut = new int[TroopType.Count];
|
||||
for (int i = 0; i < TroopType.Count; i++)
|
||||
{
|
||||
attAlive[i] = att[i] - attDead[i] - attWounded[i];
|
||||
defAlive[i] = def[i] - defDead[i] - defWounded[i];
|
||||
defOut[i] = defDead[i] + defWounded[i];
|
||||
attAlive[i] = att[i] - attOut[i];
|
||||
defAlive[i] = def[i] - defOut0[i];
|
||||
defOut[i] = defOut0[i];
|
||||
}
|
||||
|
||||
return new BattleOutcome
|
||||
@@ -109,11 +212,11 @@ public sealed class BattleSystem : IBattleSystem
|
||||
Victory = victory,
|
||||
BattleId = request.Seed,
|
||||
RulesVersion = rules.Version,
|
||||
AttackerLosses = Sum(attDead) + Sum(attWounded),
|
||||
AttackerLosses = Sum(attOut),
|
||||
DefenderLosses = Sum(defOut),
|
||||
Survivors = Sum(attAlive),
|
||||
AttackerPower = attPower,
|
||||
DefenderPower = defPower,
|
||||
AttackerPower = attPower.Floor, // округление -- только для показа
|
||||
DefenderPower = defPower.Floor,
|
||||
AttackerLuckPermille = attLuckPermille,
|
||||
DefenderLuckPermille = defLuckPermille,
|
||||
AttackerConditionPercent = attCondition,
|
||||
@@ -126,73 +229,178 @@ public sealed class BattleSystem : IBattleSystem
|
||||
DefenderDeadUnits = defDead,
|
||||
AttackerWoundedUnits = attWounded,
|
||||
DefenderWoundedUnits = defWounded,
|
||||
AttackerMissingUnits = attMissing,
|
||||
DefenderMissingUnits = defMissing,
|
||||
DefenderLossUnits = defOut
|
||||
};
|
||||
}
|
||||
|
||||
// Сколько силы оставляют состояния стороны, в процентах. Штрафы -- последовательно: голод и усталость -- 40%
|
||||
public int ConditionPercent(BattleCondition conditions)
|
||||
// Силы сторон без удачи (точные дроби) и состав сторон
|
||||
void Sides(BattleRequest request, out Fraction attPower, out Fraction defPower, out int[] att, out int[] def,
|
||||
out int attCondition, out int defCondition)
|
||||
{
|
||||
int percent = 100;
|
||||
if ((conditions & BattleCondition.Famine) != 0) percent = percent * rules.FamineStrengthPercent / 100;
|
||||
if ((conditions & BattleCondition.Fatigue) != 0) percent = percent * rules.FatigueStrengthPercent / 100;
|
||||
return Math.Max(0, percent);
|
||||
att = Units(request.AttackerUnits, request.Attackers);
|
||||
def = Units(request.DefenderUnits, request.Defenders);
|
||||
attPower = SidePower(att, def, attacking: true, request.DefenderFortified, request.AttackerBonusPercent,
|
||||
request.AttackerConditions, out attCondition);
|
||||
defPower = SidePower(def, att, attacking: false, request.DefenderFortified,
|
||||
request.DefenderBonusPercent + (request.DefenderFortified ? rules.WallsPercent : 0),
|
||||
request.DefenderConditions, out defCondition);
|
||||
}
|
||||
|
||||
// Сила стороны в сотых долях (x100), чтобы проценты считались в целых числах.
|
||||
// Порядок: контры и осадные -> бонусы стороны -> состояния (голод, усталость) -> случайность
|
||||
// (порядок бонусов и случайности -- открытый вопрос плана).
|
||||
long SidePower(int[] units, int[] enemy, bool attacking, bool fortified, int bonusPercent, int conditionPercent, int luckPermille)
|
||||
// Сколько силы оставляют состояния стороны, в процентах (для показа). Штрафы -- последовательно: голод и усталость -- 40%
|
||||
public int ConditionPercent(BattleCondition conditions)
|
||||
{
|
||||
ConditionFactor(conditions, out BigInteger num, out BigInteger den);
|
||||
return (int)(num * 100 / den);
|
||||
}
|
||||
|
||||
void ConditionFactor(BattleCondition conditions, out BigInteger num, out BigInteger den)
|
||||
{
|
||||
num = 1; den = 1;
|
||||
if ((conditions & BattleCondition.Famine) != 0) { num *= Math.Max(0, rules.FamineStrengthPercent); den *= 100; }
|
||||
if ((conditions & BattleCondition.Fatigue) != 0) { num *= Math.Max(0, rules.FatigueStrengthPercent); den *= 100; }
|
||||
}
|
||||
|
||||
// Сила стороны x100 точной дробью. Порядок: контры и осадные -> бонусы стороны -> состояния; удача -- в WithLuck.
|
||||
// Контра по составу врага (counterSum / enemyTotal) остаётся дробью -- без промежуточного округления (№12).
|
||||
Fraction SidePower(int[] units, int[] enemy, bool attacking, bool fortified, int bonusPercent,
|
||||
BattleCondition conditions, out int conditionPercent)
|
||||
{
|
||||
int enemyTotal = Sum(enemy);
|
||||
long total = 0;
|
||||
int e = Math.Max(1, enemyTotal);
|
||||
BigInteger raw = 0;
|
||||
for (int i = 0; i < TroopType.Count; i++)
|
||||
{
|
||||
if (units[i] <= 0) continue;
|
||||
|
||||
long counterSum = 0;
|
||||
for (int j = 0; j < TroopType.Count; j++) counterSum += (long)Counter(i, j) * enemy[j];
|
||||
long counterPercent = enemyTotal > 0 ? counterSum / enemyTotal : 0;
|
||||
if (enemyTotal > 0)
|
||||
for (int j = 0; j < TroopType.Count; j++) counterSum += (long)Counter(i, j) * enemy[j];
|
||||
|
||||
int siegePercent = 0;
|
||||
if (i == TroopType.Siege) siegePercent = attacking && fortified ? rules.SiegeVsWallsPercent : rules.SiegeInFieldPercent;
|
||||
|
||||
total += (long)units[i] * power[i] * (100 + counterPercent + siegePercent);
|
||||
// воины x сила x (100 + осадный% + контра%), где контра% = counterSum / e
|
||||
BigInteger term = (BigInteger)units[i] * power[i] * ((100L + siegePercent) * e + counterSum);
|
||||
if (term > 0) raw += term;
|
||||
}
|
||||
total = Math.Max(0, total * (100 + bonusPercent) / 100);
|
||||
total = total * conditionPercent / 100;
|
||||
return total * (1000 + luckPermille) / 1000;
|
||||
|
||||
ConditionFactor(conditions, out BigInteger condNum, out BigInteger condDen);
|
||||
conditionPercent = (int)(condNum * 100 / condDen);
|
||||
return new Fraction
|
||||
{
|
||||
N = raw * Math.Max(0, 100 + bonusPercent) * condNum,
|
||||
D = (BigInteger)e * 100 * condDen
|
||||
};
|
||||
}
|
||||
|
||||
// Случайность стороны в десятых долях процента: от -RandomPercent*10 до +RandomPercent*10.
|
||||
static Fraction WithLuck(Fraction power, int luckPermille)
|
||||
{
|
||||
return new Fraction { N = power.N * (1000 + luckPermille), D = power.D * 1000 };
|
||||
}
|
||||
|
||||
// Удача стороны в десятых долях процента: от -RandomPercent*10 до +RandomPercent*10.
|
||||
// Считается из Seed (SplitMix64) -- одинаково на любой платформе, System.Random для этого не годится.
|
||||
public int Luck(long seed, int side)
|
||||
{
|
||||
int range = rules.RandomPercent * 10;
|
||||
if (range <= 0) return 0;
|
||||
ulong x = (ulong)seed + 0x9E3779B97F4A7C15UL * (ulong)side;
|
||||
x = (x ^ (x >> 30)) * 0xBF58476D1CE4E5B9UL;
|
||||
x = (x ^ (x >> 27)) * 0x94D049BB133111EBUL;
|
||||
x ^= x >> 31;
|
||||
ulong x = Mix((ulong)seed + 0x9E3779B97F4A7C15UL * (ulong)side);
|
||||
return (int)(x % (ulong)(2 * range + 1)) - range;
|
||||
}
|
||||
|
||||
// Потери каждого типа: проигравший -- LoserLossPercent; победитель -- LoserLossPercent x ratioNum / ratioDen.
|
||||
// Округление вниз: одиночный проигравший не гибнет -- открытый вопрос (Battle.md).
|
||||
int[] Losses(int[] units, long ratioNum, long ratioDen, bool isLoser)
|
||||
// Отдельный поток случайности для округления потерь (№13): своя "соль" на каждую сторону и тип войск,
|
||||
// не пересекается с удачей. Возвращает число от 0 до 2^32 - 1.
|
||||
static ulong LossRoll(long seed, int side, int type)
|
||||
{
|
||||
ulong x = Mix(((ulong)seed ^ 0xD1B54A32D192ED03UL) + 0x9E3779B97F4A7C15UL * (ulong)(16 * side + type + 1));
|
||||
return x >> 32;
|
||||
}
|
||||
|
||||
static ulong Mix(ulong x)
|
||||
{
|
||||
x = (x ^ (x >> 30)) * 0xBF58476D1CE4E5B9UL;
|
||||
x = (x ^ (x >> 27)) * 0x94D049BB133111EBUL;
|
||||
return x ^ (x >> 31);
|
||||
}
|
||||
|
||||
// Потери каждого типа (дробью): units x доля выбывших по кривой (№14).
|
||||
// Целая часть гарантирована, дробная -- шанс ещё одной потери (№13).
|
||||
int[] Losses(int[] units, Fraction weaker, Fraction stronger, bool isWeak, long seed, int side, Rounding rounding)
|
||||
{
|
||||
var lost = new int[TroopType.Count];
|
||||
LossShare(weaker, stronger, isWeak, out BigInteger shareNum, out BigInteger shareDen);
|
||||
for (int i = 0; i < TroopType.Count; i++)
|
||||
{
|
||||
if (units[i] <= 0) continue;
|
||||
long l = isLoser
|
||||
? (long)units[i] * rules.LoserLossPercent / 100
|
||||
: ratioDen > 0 ? (long)units[i] * rules.LoserLossPercent * ratioNum / (100 * ratioDen) : 0;
|
||||
lost[i] = (int)Math.Max(0, Math.Min(units[i], l));
|
||||
|
||||
BigInteger num = (BigInteger)units[i] * shareNum;
|
||||
BigInteger den = 1000 * shareDen;
|
||||
|
||||
BigInteger whole = BigInteger.DivRem(num, den, out BigInteger rest);
|
||||
bool extra = !rest.IsZero && (rounding == Rounding.Ceiling
|
||||
|| rounding == Rounding.Roll && (BigInteger)LossRoll(seed, side, i) * den < rest * (BigInteger.One << 32));
|
||||
BigInteger l = whole + (extra ? 1 : 0);
|
||||
lost[i] = (int)BigInteger.Min(units[i], l);
|
||||
}
|
||||
return lost;
|
||||
}
|
||||
|
||||
// Пропавшие без вести среди выбывших каждого типа: доля из правил (не утверждена; 0 -- никого), дробная часть -- бросок
|
||||
// из своего потока. Прогноз: Floor -- меньше пропавших, Ceiling -- больше
|
||||
int[] Missing(int[] outUnits, long seed, int side, Rounding rounding)
|
||||
{
|
||||
var missing = new int[TroopType.Count];
|
||||
int share = Math.Max(0, Math.Min(1000, rules.MissingSharePermille));
|
||||
if (share == 0) return missing;
|
||||
for (int i = 0; i < TroopType.Count; i++)
|
||||
{
|
||||
if (outUnits[i] <= 0) continue;
|
||||
long num = (long)outUnits[i] * share;
|
||||
long whole = num / 1000, rest = num % 1000;
|
||||
bool extra = rest != 0 && (rounding == Rounding.Ceiling
|
||||
|| rounding == Rounding.Roll && (LossRoll(seed, side + 24, i) * 1000UL >> 32) < (ulong)rest);
|
||||
missing[i] = (int)Math.Min(outUnits[i], whole + (extra ? 1 : 0));
|
||||
}
|
||||
return missing;
|
||||
}
|
||||
|
||||
// Погибшие среди выбывших каждого типа: доля по соотношению сил стороны (own / enemy), дробная часть -- бросок
|
||||
// из своего потока (не тот, что у потерь и удачи). Прогноз: Floor -- меньше погибших, Ceiling -- больше.
|
||||
int[] Dead(int[] outUnits, Fraction own, Fraction enemy, long seed, int side, Rounding rounding)
|
||||
{
|
||||
var dead = new int[TroopType.Count];
|
||||
DeadShare(own, enemy, out BigInteger shareNum, out BigInteger shareDen);
|
||||
for (int i = 0; i < TroopType.Count; i++)
|
||||
{
|
||||
if (outUnits[i] <= 0) continue;
|
||||
BigInteger num = (BigInteger)outUnits[i] * shareNum;
|
||||
BigInteger den = 1000 * shareDen;
|
||||
BigInteger whole = BigInteger.DivRem(num, den, out BigInteger rest);
|
||||
bool extra = !rest.IsZero && (rounding == Rounding.Ceiling
|
||||
|| rounding == Rounding.Roll && (BigInteger)LossRoll(seed, side + 8, i) * den < rest * (BigInteger.One << 32));
|
||||
dead[i] = (int)BigInteger.Min(outUnits[i], whole + (extra ? 1 : 0));
|
||||
}
|
||||
return dead;
|
||||
}
|
||||
|
||||
// Доля погибших (в десятых долях процента, дробью) при соотношении сил стороны R = 1000 * own / enemy
|
||||
void DeadShare(Fraction own, Fraction enemy, out BigInteger num, out BigInteger den)
|
||||
{
|
||||
int last = deadRatio.Length - 1;
|
||||
if (enemy.N.IsZero) { num = deadShare[last]; den = 1; return; } // у врага нет силы -- как при самом большом перевесе
|
||||
BigInteger rn = 1000 * own.N * enemy.D;
|
||||
BigInteger rd = own.D * enemy.N;
|
||||
if (rn <= deadRatio[0] * rd) { num = deadShare[0]; den = 1; return; }
|
||||
if (rn >= deadRatio[last] * rd) { num = deadShare[last]; den = 1; return; }
|
||||
int i = 0;
|
||||
while (rn >= deadRatio[i + 1] * rd) i++;
|
||||
long span = deadRatio[i + 1] - deadRatio[i];
|
||||
num = (BigInteger)deadShare[i] * span * rd + (BigInteger)(deadShare[i + 1] - deadShare[i]) * (rn - deadRatio[i] * rd);
|
||||
den = span * rd;
|
||||
}
|
||||
|
||||
static int[] Units(int[] units, int count)
|
||||
{
|
||||
var result = new int[TroopType.Count];
|
||||
|
||||
@@ -86,6 +86,42 @@ public interface IPopulation
|
||||
}
|
||||
|
||||
// ---------------- Армия: войска ----------------
|
||||
// Пропавшие без вести одного боя (решения 01.11, п. 5). Время -- мс часов игры
|
||||
public struct MissingInfo
|
||||
{
|
||||
public int Id;
|
||||
public int Count; // ещё не вернулись и не списаны
|
||||
public long WindowStartMs; // с какого момента могут начать возвращаться (бой + обратный путь)
|
||||
public long EndMs; // конец окна: кто не вернулся -- списан
|
||||
}
|
||||
|
||||
// Раненые на лечении в госпитале: одна группа одного типа, лечится вместе. Время -- мс часов игры
|
||||
public struct HealingInfo
|
||||
{
|
||||
public int Id;
|
||||
public int Type;
|
||||
public int Count;
|
||||
public long StartMs;
|
||||
public long EndMs;
|
||||
}
|
||||
|
||||
// Госпиталь -- здание Поселения (решения 31.10, п. 7): уровень, вместимость, улучшения.
|
||||
// Пока здания нет, контракт не зарегистрирован -- Армия берёт временное число мест из таблицы HospitalConfig.
|
||||
public interface IHospital
|
||||
{
|
||||
int Beds { get; } // мест для лечения: регламент 31.10 -- 20..60 по уровням I..V
|
||||
}
|
||||
|
||||
// Заказ обучения в Казармах. Время -- миллисекунды часов игры (GameClock.UnixNowMs)
|
||||
public struct TrainingOrderInfo
|
||||
{
|
||||
public int Id; // номер заказа -- не повторяется
|
||||
public int Type; // тип войск (TroopType)
|
||||
public int Count;
|
||||
public long StartMs; // когда начнётся (заказы идут друг за другом)
|
||||
public long EndMs; // когда воины будут готовы
|
||||
}
|
||||
|
||||
public interface IArmy
|
||||
{
|
||||
int TypeCount { get; } // типов войск (пехота, лучники, кавалерия, осадные)
|
||||
@@ -102,8 +138,13 @@ public interface IArmy
|
||||
void AddTroops(int type, int count); // обучены / вернулись
|
||||
int LoseFraction(double fraction); // потери в бою: доля от каждого типа; возвращает, сколько погибло
|
||||
|
||||
// Слоты похода (регламент 31.10, раздел 7): сколько походов игрока может идти одновременно.
|
||||
// База 2 (ТЕСТ), технология «Военная логистика» поднимет до 7 -- уровни и цены ещё не утверждены.
|
||||
int MarchSlots { get; }
|
||||
int ActiveMarches { get; } // походов в пути сейчас (у каждого -- свой слот)
|
||||
|
||||
// Забрать свободных воинов в поход (запоминает состав похода).
|
||||
// false -- ничего не взято: не хватает воинов или поход с таким номером уже есть.
|
||||
// false -- ничего не взято: не хватает воинов, нет свободного слота или поход с таким номером уже есть.
|
||||
bool TakeForMarch(int marchId, int count);
|
||||
// Вернуть выживших из похода по тем же типам войск.
|
||||
// Зачисляет только по известному походу и только один раз; false -- такого похода нет, никто не добавлен.
|
||||
@@ -113,6 +154,45 @@ public interface IArmy
|
||||
int[] GetMarchUnits(int marchId);
|
||||
// Вернуть выживших точно по типам (бой посчитал потери каждого типа). Правила те же, что у ReturnFromMarch.
|
||||
bool ReturnUnits(int marchId, int[] survivorUnits);
|
||||
|
||||
// ---- Раненые и лечение (решения по 8 вопросам Саши, 31.10, п. 7): состояние и очередь лечения -- у Армии ----
|
||||
// Бой считает раненых, Армия хранит их и лечит, места -- от госпиталя (IHospital), цену лечения списывает Экономика.
|
||||
// Раненые -- люди: Население считает их вместе с воинами. Лишние раненые ждут места (ТЕСТ, решение Саши 01.11).
|
||||
int WoundedTotal { get; } // раненых всего: ждут места + лечатся
|
||||
int GetAllTroops(int type); // все воины типа: в городе, в походах и раненые (для еды -- решения 01.11, п. 4)
|
||||
|
||||
// ---- Пропавшие без вести (решения 01.11, п. 5) ----
|
||||
// Не воюют и не едят, но занимают места в населении до возвращения или списания.
|
||||
int MissingTotal { get; }
|
||||
IReadOnlyList<MissingInfo> Missing { get; }
|
||||
// Бой посчитал пропавших: забрать их из похода в группу пропавших. battleMs -- конец боя, travelMs -- обратный путь.
|
||||
// Только известный поход и только один раз на поход; больше, чем ушло, не забрать.
|
||||
bool MarkMissing(int marchId, int[] missingUnits, long battleMs, long travelMs);
|
||||
// Вернуть группы, время которых наступило (и офлайн), и списать тех, чьё окно кончилось. Сколько групп вернулось.
|
||||
int ProcessMissing(long nowMs);
|
||||
int GetWoundedWaiting(int type); // ждут места, по типам
|
||||
IReadOnlyList<HealingInfo> Healing { get; } // лечатся сейчас
|
||||
int HospitalBeds { get; } // мест в госпитале сейчас
|
||||
// Вернуть из похода выживших и раненых точно по типам (раненые -- в госпиталь в момент nowMs).
|
||||
// Только известный поход и только один раз; больше, чем ушло, не вернётся.
|
||||
bool ReturnUnits(int marchId, int[] survivorUnits, int[] woundedUnits, long nowMs);
|
||||
// Закончить лечение, срок которого наступил (и офлайн), и положить ждущих на освободившиеся места.
|
||||
// Вылеченные возвращаются в город (SoldiersHealedEvent, один раз на группу). Возвращает, сколько групп вылечено.
|
||||
int ProcessHealing(long nowMs);
|
||||
|
||||
// ---- Очередь обучения (решения по 8 вопросам Саши, 31.10, п. 8): единственный владелец -- Армия ----
|
||||
// Жители для найма -- у Населения (IPopulation: Recruitable, резерв, TryRecruit, CompleteTraining),
|
||||
// размер очереди -- от Казарм (передаёт вызывающий), цену списывает вызывающий через Экономику.
|
||||
IReadOnlyList<TrainingOrderInfo> Training { get; }
|
||||
// Можно ли поставить заказ: очередь не заполнена, жителей хватает. Ничего не меняет; false -- error для игрока.
|
||||
bool CanQueueTraining(int type, int count, int queueSize, out string error);
|
||||
// Поставить заказ в конец очереди, люди уходят из жителей в Казармы. false -- ничего не изменилось.
|
||||
bool TryQueueTraining(int type, int count, long durationMs, int queueSize, long nowMs, out string error);
|
||||
// Закончить заказы, срок которых наступил к nowMs (и пока игра была закрыта): воины переходят в Армию,
|
||||
// каждый заказ -- один раз (TroopsTrainedEvent). Возвращает, сколько заказов закончено.
|
||||
int ProcessTraining(long nowMs);
|
||||
// Ускорение: все заказы заканчиваются в nowMs
|
||||
int FinishAllTraining(long nowMs);
|
||||
}
|
||||
|
||||
// ---------------- Глобальный мир: карта и перемещения ----------------
|
||||
@@ -120,6 +200,103 @@ public interface IWorld
|
||||
{
|
||||
int ActiveMarches { get; }
|
||||
bool TryStartMarch(string targetId, int soldiers, out string error);
|
||||
// Поход «Разведка» (решения 31.10, п. 2): дойти до цели и вернуться -- без боя, сбора и потерь, занимает слот похода
|
||||
bool TryStartScout(string targetId, int soldiers, out string error);
|
||||
// Разведка с отчётом (Разведка М2): дойти, наблюдать время уровня (II / III), отчёт, вернуться
|
||||
bool TryStartRecon(string targetId, int soldiers, int level, out string error);
|
||||
}
|
||||
|
||||
// ---------------- Мир -> Разведка: что где находится (решение №46) ----------------
|
||||
// Координаты и марши ведёт Мир, разведка только читает их через этот контракт -- без прямых ссылок
|
||||
// World <-> Intelligence. Координаты -- милли-единицы карты (1000 = 1 клетка).
|
||||
public struct ArmyOnMap
|
||||
{
|
||||
public string Id; // устойчивый номер армии на карте ("march_12")
|
||||
public string OwnerId; // владелец (LocalPlayer.Id -- свои войска)
|
||||
public int X, Y; // где сейчас
|
||||
public int ToX, ToY; // куда движется
|
||||
public int Soldiers; // точная численность -- разведка показывает игроку только примерную
|
||||
}
|
||||
|
||||
// Цель разведки (ТЗ разведки, раздел 6): что за объект -- от этого время наблюдения
|
||||
public enum ReconTargetKind { None, Settlement, Castle, Camp }
|
||||
|
||||
// Снимок цели разведки от Мира -- то, что увидят разведчики в момент отчёта
|
||||
public struct ReconTarget
|
||||
{
|
||||
public string Id;
|
||||
public string Name;
|
||||
public ReconTargetKind Kind;
|
||||
public int[] Units; // гарнизон по типам (TroopType)
|
||||
public bool Fortified; // защитники за стенами
|
||||
public bool HasHero;
|
||||
public string[] ResourceNames; // что можно взять (имена ResourceType)
|
||||
public int[] ResourceAmounts;
|
||||
}
|
||||
|
||||
public interface IWorldMap
|
||||
{
|
||||
int HalfWidth { get; } // границы карты от центра, милли-единицы
|
||||
int HalfHeight { get; }
|
||||
bool TryGetSettlement(string ownerId, out int x, out int y); // где поселение игрока
|
||||
// Все армии на карте в момент timeMs (в том числе в прошлом -- для расчёта, пока игра была закрыта)
|
||||
void GetArmies(long timeMs, List<ArmyOnMap> result);
|
||||
// Цель разведки: замок, поселение, лагерь (Разведка М2). false -- такой цели нет или её нельзя разведать
|
||||
bool TryGetReconTarget(string targetId, out ReconTarget target);
|
||||
}
|
||||
|
||||
// ---------------- Разведка (Bogatyri.Intelligence): туман войны, наблюдение ----------------
|
||||
public enum MapVisibility
|
||||
{
|
||||
Unexplored, // неизведано
|
||||
Explored, // исследовано: география известна, текущие движения не видны
|
||||
Observed // наблюдается сейчас
|
||||
}
|
||||
|
||||
// Что игрок знает о чужой армии: только приблизительно и только на момент наблюдения
|
||||
public struct KnownContact
|
||||
{
|
||||
public string ArmyId;
|
||||
public bool Identified; // владелец опознан
|
||||
public string OwnerId; // null, пока не опознан
|
||||
public bool Observed; // видна прямо сейчас; false -- последний контакт (устаревшие данные)
|
||||
public int X, Y, ToX, ToY; // где видели последний раз и куда шла
|
||||
public int ApproxMin, ApproxMax; // примерная численность (±20%), одна на событие наблюдения
|
||||
public long LastSeenMs; // когда видели последний раз
|
||||
}
|
||||
|
||||
// Отчёт разведки (ТЗ разведки, раздел 6): сведения на момент операции, без постоянного слежения.
|
||||
// Уровень II -- точное число и типы, герой, укрепления; III -- плюс модификаторы и оценка ресурсов ±15%
|
||||
public struct ReconReport
|
||||
{
|
||||
public string Id; // устойчивый: "recon_<номер похода>"
|
||||
public string TargetId;
|
||||
public string TargetName;
|
||||
public int Level; // 2 или 3
|
||||
public long TimeMs; // когда закончилось наблюдение (по часам игры)
|
||||
public int[] Units; // гарнизон по типам на момент отчёта
|
||||
public bool Fortified;
|
||||
public bool HasHero;
|
||||
public string Modifiers; // уровень III: основные боевые модификаторы защиты
|
||||
public string[] ResourceNames; // уровень III: оценка ресурсов
|
||||
public int[] ResourceMin, ResourceMax;
|
||||
}
|
||||
|
||||
public interface IIntelligence
|
||||
{
|
||||
int ObservationLevel { get; set; } // технология «Обзор»: 0..3 (+10 / +20 / +30% к радиусам)
|
||||
MapVisibility GetVisibility(int x, int y); // по последнему расчёту
|
||||
IReadOnlyList<KnownContact> Contacts { get; }
|
||||
void ObserveUntil(long nowMs); // досчитать наблюдение до момента (в том числе офлайн)
|
||||
|
||||
// ---- М2: целенаправленная разведка ----
|
||||
// Сколько разведчики наблюдают цель (мс часов игры): поселение 2 / 4, замок 3 / 6 игровых часов (уровень II / III).
|
||||
// 0 -- цель нельзя разведать с отчётом
|
||||
long ReconDurationMs(string targetId, int level);
|
||||
// Наблюдение закончено: составить отчёт по снимку цели на этот момент. Один раз на reportId (повтор -- false)
|
||||
bool CompleteRecon(string reportId, string targetId, int level, long timeMs);
|
||||
IReadOnlyList<ReconReport> Reports { get; }
|
||||
bool TryGetLatestReport(string targetId, out ReconReport report);
|
||||
}
|
||||
|
||||
// ---------------- Боевая система: урон, потери, исход ----------------
|
||||
@@ -187,7 +364,8 @@ public struct BattleOutcome
|
||||
public int[] AttackerUnitsBefore, DefenderUnitsBefore;
|
||||
public int[] AttackerSurvivorUnits, DefenderSurvivorUnits;
|
||||
public int[] AttackerDeadUnits, DefenderDeadUnits;
|
||||
public int[] AttackerWoundedUnits, DefenderWoundedUnits; // пока нули: доля раненых не утверждена командой
|
||||
public int[] AttackerWoundedUnits, DefenderWoundedUnits; // раненые (регламент 31.10, решения 31.10, п. 7)
|
||||
public int[] AttackerMissingUnits, DefenderMissingUnits; // пропавшие без вести (решения 01.11, п. 5): выбывшие = погибшие + раненые + пропавшие
|
||||
public int[] DefenderLossUnits; // погибшие + раненые защитника (для старого кода)
|
||||
}
|
||||
|
||||
@@ -202,9 +380,10 @@ public enum BattleChance
|
||||
public struct BattleForecast
|
||||
{
|
||||
public BattleChance Chance;
|
||||
public int WinChancePermille; // шанс победы нападающего в десятых долях процента: 273 = 27,3% (решение №11)
|
||||
public long AttackerPowerMin, AttackerPowerMax; // x100, крайние значения случайности
|
||||
public long DefenderPowerMin, DefenderPowerMax;
|
||||
public int AttackerLossesMin, AttackerLossesMax;
|
||||
public int AttackerLossesMin, AttackerLossesMax; // с учётом округления потерь (решение №13)
|
||||
}
|
||||
|
||||
public interface IBattleSystem
|
||||
|
||||
@@ -62,19 +62,63 @@ public struct TroopsChangedEvent
|
||||
public int AtHome;
|
||||
public int InMarches;
|
||||
public int Garrison; // из AtHome -- в гарнизоне
|
||||
public int Wounded; // раненые: в госпитале или ждут места (не в AtHome)
|
||||
public int Missing; // пропавшие без вести: занимают места в населении, но не едят и не воюют
|
||||
}
|
||||
|
||||
// Пропавшие без вести вернулись (часть группы боя): здоровые -- в город, раненые -- в госпиталь. Один раз на группу
|
||||
public struct MissingReturnedEvent
|
||||
{
|
||||
public int MissingId;
|
||||
public int Group;
|
||||
public int Healthy;
|
||||
public int Wounded;
|
||||
public long TimeMs;
|
||||
}
|
||||
|
||||
// Окно возвращения кончилось: кто не вернулся -- списан, места в населении освобождены
|
||||
public struct MissingWrittenOffEvent
|
||||
{
|
||||
public int MissingId;
|
||||
public int Count;
|
||||
public long TimeMs;
|
||||
}
|
||||
|
||||
// Раненые вылечены и вернулись в город. Один раз на группу лечения (BatchId), TimeMs -- когда закончили
|
||||
public struct SoldiersHealedEvent
|
||||
{
|
||||
public int BatchId;
|
||||
public int Type;
|
||||
public int Count;
|
||||
public long TimeMs;
|
||||
}
|
||||
|
||||
// Заказ обучения закончен: воины уже в Армии. Приходит один раз на заказ (OrderId), TimeMs -- когда был готов
|
||||
public struct TroopsTrainedEvent
|
||||
{
|
||||
public int OrderId;
|
||||
public int Type;
|
||||
public int Count;
|
||||
public long TimeMs;
|
||||
}
|
||||
|
||||
// ---------------- Глобальный мир ----------------
|
||||
// У событий похода -- номер похода и точное время по часам игры (документ 02 комплекта от 29.10.2026):
|
||||
// TimeMs -- когда это случилось, а не когда игра это заметила (после офлайна это разные моменты).
|
||||
public struct MarchStartedEvent
|
||||
{
|
||||
public int MarchId;
|
||||
public long TimeMs; // выступление
|
||||
public string TargetId;
|
||||
public int Soldiers;
|
||||
public bool IsScout; // поход «Разведка»: без боя и добычи
|
||||
}
|
||||
|
||||
public struct MarchBattleResolvedEvent
|
||||
{
|
||||
public int MarchId;
|
||||
public long BattleId; // номер боя (= Seed): по нему бой можно перепроверить
|
||||
public long TimeMs; // приход к цели и бой
|
||||
public string TargetId;
|
||||
public bool Victory;
|
||||
public int Soldiers;
|
||||
@@ -84,10 +128,15 @@ public struct MarchBattleResolvedEvent
|
||||
public struct MarchReturnedEvent
|
||||
{
|
||||
public int MarchId;
|
||||
public long TimeMs; // возвращение домой
|
||||
public bool Victory;
|
||||
public int Survivors;
|
||||
public int Sent; // сколько воинов уходило в поход
|
||||
public bool TargetEmpty; // лагерь уже был разбит: боя не было, вернулись все
|
||||
public bool TargetEmpty; // лагерь уже был разбит / ресурсной точки уже не было: боя и сбора не было, вернулись все
|
||||
public bool IsGather; // поход на ресурсную точку (сбор, а не бой)
|
||||
public bool IsScout; // поход «Разведка»: дошли до цели и вернулись, боя и добычи нет
|
||||
public int Wounded; // раненых привезли домой -- они в госпитале (или ждут места)
|
||||
public int Missing; // пропали без вести в бою -- могут вернуться сами
|
||||
public string TargetName; // куда ходили ("Замок Змея Горыныча", имя соседа)
|
||||
public string LootText; // добыча текстом: "+20 золота, +40 еды" или "нет"
|
||||
}
|
||||
@@ -123,3 +172,53 @@ public struct NewGameStartedEvent { }
|
||||
public struct GameSavedEvent { }
|
||||
// Сохранения сброшены, все модули уже в состоянии новой игры
|
||||
public struct GameResetEvent { }
|
||||
|
||||
// ---------------- Мир -> Разведка ----------------
|
||||
// Мир сейчас продвинет время до ToMs: разведка успевает досчитать наблюдение по армиям, которые ещё на карте
|
||||
// (после продвижения вернувшиеся походы исчезают). Публикует MarchManager перед каждым расчётом мира.
|
||||
public struct WorldAdvancingEvent
|
||||
{
|
||||
public long ToMs;
|
||||
}
|
||||
|
||||
// ---------------- Разведка ----------------
|
||||
// У всех событий -- устойчивый номер события (армия + номер наблюдения) и время по часам игры (ТЗ разведки, раздел 10)
|
||||
public struct ArmySpottedEvent // чужая армия вошла в зону обзора
|
||||
{
|
||||
public string EventId;
|
||||
public string ArmyId;
|
||||
public long TimeMs;
|
||||
public int ApproxMin, ApproxMax;
|
||||
}
|
||||
|
||||
public struct ArmyLostContactEvent // чужая армия вышла из зоны обзора -- остаётся метка последнего контакта
|
||||
{
|
||||
public string EventId;
|
||||
public string ArmyId;
|
||||
public long TimeMs;
|
||||
}
|
||||
|
||||
// Разведка М2: отряд вышел на разведку с отчётом / отчёт готов (ТЗ разведки, раздел 10)
|
||||
public struct ReconStartedEvent
|
||||
{
|
||||
public string EventId; // "recon_<номер похода>"
|
||||
public string TargetId;
|
||||
public int Level;
|
||||
public long TimeMs;
|
||||
}
|
||||
|
||||
public struct ReconCompletedEvent
|
||||
{
|
||||
public string EventId; // = id отчёта
|
||||
public string TargetId;
|
||||
public int Level;
|
||||
public long TimeMs;
|
||||
}
|
||||
|
||||
public struct ArmyIdentifiedEvent // владелец чужой армии опознан
|
||||
{
|
||||
public string EventId;
|
||||
public string ArmyId;
|
||||
public string OwnerId;
|
||||
public long TimeMs;
|
||||
}
|
||||
|
||||
@@ -21,6 +21,10 @@ public static class GameClock
|
||||
|
||||
public static DateTime UtcNow => DateTimeOffset.FromUnixTimeSeconds(UnixNow).UtcDateTime;
|
||||
|
||||
// То же в миллисекундах -- для таймеров, которые идут плавно (обучение войск, марши)
|
||||
public static long UnixNowMs => (RealUnixSource != null ? RealUnixSource() * 1000 : DateTimeOffset.UtcNow.ToUnixTimeMilliseconds())
|
||||
+ offsetSeconds * 1000;
|
||||
|
||||
// Промотать время вперёд (отладка). Модули узнают об этом из GameTimeAdvancedEvent и досчитываются.
|
||||
public static void Advance(long seconds)
|
||||
{
|
||||
|
||||
@@ -0,0 +1,8 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 4b19799fef59420d948583d7bd00e661
|
||||
folderAsset: yes
|
||||
DefaultImporter:
|
||||
externalObjects: {}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -0,0 +1,14 @@
|
||||
{
|
||||
"name": "Bogatyri.Intelligence",
|
||||
"rootNamespace": "",
|
||||
"references": ["Bogatyri.Core"],
|
||||
"includePlatforms": [],
|
||||
"excludePlatforms": [],
|
||||
"allowUnsafeCode": false,
|
||||
"overrideReferences": false,
|
||||
"precompiledReferences": [],
|
||||
"autoReferenced": true,
|
||||
"defineConstraints": [],
|
||||
"versionDefines": [],
|
||||
"noEngineReferences": true
|
||||
}
|
||||
@@ -0,0 +1,7 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 263eeba80895448da32cd4c9816b18f3
|
||||
AssemblyDefinitionImporter:
|
||||
externalObjects: {}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -0,0 +1,471 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Globalization;
|
||||
using System.Text;
|
||||
|
||||
// МОДУЛЬ РАЗВЕДКИ, этап М1: туман войны, источники обзора, чужие армии, последний контакт.
|
||||
// Документ: Docs/Modules/Intelligence.md. ТЗ разведки 31.10.2026, решение №46: отдельная сборка Bogatyri.Intelligence.
|
||||
//
|
||||
// Без Unity. Карту и армии не хранит и не двигает -- читает их у Мира через контракт IWorldMap.
|
||||
// Своё: туман (исследованные клетки), известные контакты, номера событий наблюдения. Чужие данные не меняет.
|
||||
//
|
||||
// Числа -- ТЕСТ, в игре из таблицы IntelligenceConfig.
|
||||
public sealed class IntelligenceRules
|
||||
{
|
||||
public int SettlementRadius = 5000; // обзор своего поселения: 5 клеток
|
||||
public int ArmyRadius = 1000; // обзор обычной армии: 1 клетка
|
||||
public int[] ObservationPercent = { 0, 10, 20, 30 }; // технология «Обзор» I/II/III -- не складывается, заменяет
|
||||
public long LastContactMs = 10 * 60_000; // последний контакт живёт 10 РЕАЛЬНЫХ минут
|
||||
public int ApproxPercent = 20; // примерная численность: ±20%
|
||||
public int IdentifyPercent = 50; // опознание чужого владельца: 50% на событие наблюдения
|
||||
public long SampleStepMs = 10_000; // шаг расчёта, пока игра была закрыта: 10 реальных секунд
|
||||
public long MaxCatchUpMs = 48L * 3_600_000; // офлайн досчитывается не больше чем за 48 часов
|
||||
public int CellSize = 1000; // клетка тумана = клетка карты
|
||||
|
||||
// М2, целенаправленная разведка (ТЗ, раздел 6): сколько разведчики наблюдают цель, ИГРОВЫХ часов (уровень II, III)
|
||||
public int[] ReconSettlementGameHours = { 2, 4 };
|
||||
public int[] ReconCastleGameHours = { 3, 6 };
|
||||
public int[] ReconCampGameHours = { 2, 4 }; // лагеря в ТЗ не названы -- как поселение (ТЕСТ)
|
||||
public long GameHourMs = 5 * 60 * 1000; // 1 игровой час = 5 реальных минут
|
||||
public int ResourceEstimatePercent = 15; // уровень III: ресурсы -- оценочный диапазон ±15%
|
||||
public int MaxReports = 30; // храним последние отчёты
|
||||
|
||||
public static IntelligenceRules Default => new IntelligenceRules();
|
||||
}
|
||||
|
||||
public sealed class IntelligenceService : IIntelligence, ISaveParticipant
|
||||
{
|
||||
// Что игрок знает о чужой армии. Номер наблюдения -- для устойчивых событий и воспроизводимых бросков
|
||||
class Contact
|
||||
{
|
||||
public string armyId;
|
||||
public string ownerId; // настоящий владелец (из Мира) -- игроку показывается только после опознания
|
||||
public bool identified;
|
||||
public bool observed;
|
||||
public int x, y, toX, toY;
|
||||
public int approxMin, approxMax;
|
||||
public long lastSeenMs;
|
||||
public int observation; // сколько раз армия входила в обзор (событие наблюдения)
|
||||
}
|
||||
|
||||
private readonly IntelligenceRules rules;
|
||||
private readonly Func<IWorldMap> worldMap;
|
||||
private readonly string localPlayer;
|
||||
private readonly Dictionary<string, Contact> contacts = new Dictionary<string, Contact>();
|
||||
private readonly List<KnownContact> contactView = new List<KnownContact>();
|
||||
private readonly List<ArmyOnMap> armies = new List<ArmyOnMap>();
|
||||
private readonly List<(int x, int y, int r)> sources = new List<(int, int, int)>();
|
||||
private readonly HashSet<string> seen = new HashSet<string>();
|
||||
private bool[] explored = Array.Empty<bool>();
|
||||
private int gridW, gridH, halfW, halfH;
|
||||
private long lastTickMs;
|
||||
private bool viewDirty = true;
|
||||
|
||||
public IntelligenceService(IntelligenceRules rules = null, Func<IWorldMap> worldMap = null, string localPlayerId = LocalPlayer.Id)
|
||||
{
|
||||
this.rules = rules ?? IntelligenceRules.Default;
|
||||
this.worldMap = worldMap ?? (() => GameServices.TryGet(out IWorldMap m) ? m : null);
|
||||
localPlayer = localPlayerId;
|
||||
}
|
||||
|
||||
public IntelligenceRules Rules => rules;
|
||||
|
||||
// ---------------- Контракт IIntelligence ----------------
|
||||
|
||||
private int observationLevel;
|
||||
public int ObservationLevel
|
||||
{
|
||||
get => observationLevel;
|
||||
set => observationLevel = Math.Max(0, Math.Min(rules.ObservationPercent.Length - 1, value));
|
||||
}
|
||||
|
||||
// Радиус с «Обзором»: процент текущего уровня, дробные радиусы без округления до клеток
|
||||
public int Radius(int baseRadius)
|
||||
{
|
||||
return (int)((long)baseRadius * (100 + rules.ObservationPercent[observationLevel]) / 100);
|
||||
}
|
||||
|
||||
public MapVisibility GetVisibility(int x, int y)
|
||||
{
|
||||
foreach (var s in sources)
|
||||
if (Inside(x, y, s.x, s.y, s.r)) return MapVisibility.Observed;
|
||||
int cell = Cell(x, y);
|
||||
return cell >= 0 && explored[cell] ? MapVisibility.Explored : MapVisibility.Unexplored;
|
||||
}
|
||||
|
||||
public IReadOnlyList<KnownContact> Contacts
|
||||
{
|
||||
get
|
||||
{
|
||||
if (viewDirty)
|
||||
{
|
||||
contactView.Clear();
|
||||
foreach (var c in contacts.Values)
|
||||
contactView.Add(new KnownContact
|
||||
{
|
||||
ArmyId = c.armyId,
|
||||
Identified = c.identified,
|
||||
OwnerId = c.identified ? c.ownerId : null,
|
||||
Observed = c.observed,
|
||||
X = c.x, Y = c.y, ToX = c.toX, ToY = c.toY,
|
||||
ApproxMin = c.approxMin, ApproxMax = c.approxMax,
|
||||
LastSeenMs = c.lastSeenMs
|
||||
});
|
||||
viewDirty = false;
|
||||
}
|
||||
return contactView;
|
||||
}
|
||||
}
|
||||
|
||||
// Наблюдение от прошлого расчёта до nowMs шагами SampleStepMs: армия, прошедшая через обзор,
|
||||
// пока игра была закрыта, тоже будет замечена -- в хронологическом порядке (ТЗ, приёмка 9)
|
||||
public void ObserveUntil(long nowMs)
|
||||
{
|
||||
IWorldMap map = worldMap();
|
||||
if (map == null) return;
|
||||
EnsureGrid(map);
|
||||
|
||||
long from = lastTickMs == 0 ? nowMs : Math.Max(lastTickMs, nowMs - rules.MaxCatchUpMs);
|
||||
if (nowMs < from) return; // время не идёт назад: повторный расчёт ничего не меняет
|
||||
for (long t = from + rules.SampleStepMs; t < nowMs; t += rules.SampleStepMs) Sample(map, t);
|
||||
Sample(map, nowMs);
|
||||
lastTickMs = nowMs;
|
||||
|
||||
// Последний контакт стареет и удаляется через LastContactMs (ТЗ, раздел 2)
|
||||
var expired = new List<string>();
|
||||
foreach (var c in contacts.Values)
|
||||
if (!c.observed && nowMs - c.lastSeenMs >= rules.LastContactMs) expired.Add(c.armyId);
|
||||
foreach (var id in expired) contacts.Remove(id);
|
||||
if (expired.Count > 0) viewDirty = true;
|
||||
}
|
||||
|
||||
void Sample(IWorldMap map, long t)
|
||||
{
|
||||
armies.Clear();
|
||||
map.GetArmies(t, armies);
|
||||
|
||||
// Источники обзора: своё поселение и свои армии (башни и герой-разведчик -- позже)
|
||||
sources.Clear();
|
||||
if (map.TryGetSettlement(localPlayer, out int sx, out int sy)) sources.Add((sx, sy, Radius(rules.SettlementRadius)));
|
||||
foreach (var a in armies)
|
||||
if (a.OwnerId == localPlayer) sources.Add((a.X, a.Y, Radius(rules.ArmyRadius)));
|
||||
foreach (var s in sources) Explore(s.x, s.y, s.r);
|
||||
|
||||
seen.Clear();
|
||||
foreach (var a in armies)
|
||||
{
|
||||
if (a.OwnerId == localPlayer) continue; // свои -- не разведка
|
||||
bool inView = false;
|
||||
foreach (var s in sources) if (Inside(a.X, a.Y, s.x, s.y, s.r)) { inView = true; break; }
|
||||
if (!inView) continue;
|
||||
seen.Add(a.Id);
|
||||
Observe(a, t);
|
||||
}
|
||||
|
||||
// Ушла из обзора (или исчезла с карты) -- контакт потерян, данные больше не обновляются
|
||||
foreach (var c in contacts.Values)
|
||||
{
|
||||
if (!c.observed || seen.Contains(c.armyId)) continue;
|
||||
c.observed = false;
|
||||
viewDirty = true;
|
||||
EventBus.Publish(new ArmyLostContactEvent { EventId = EventId(c), ArmyId = c.armyId, TimeMs = t });
|
||||
}
|
||||
}
|
||||
|
||||
void Observe(ArmyOnMap a, long t)
|
||||
{
|
||||
if (!contacts.TryGetValue(a.Id, out Contact c))
|
||||
{
|
||||
c = new Contact { armyId = a.Id, ownerId = a.OwnerId };
|
||||
contacts[a.Id] = c;
|
||||
}
|
||||
|
||||
if (!c.observed)
|
||||
{
|
||||
// Новое событие наблюдения: примерная численность и бросок опознания -- один раз на событие
|
||||
c.observed = true;
|
||||
c.observation++;
|
||||
int width = Math.Max(1, a.Soldiers * 2 * rules.ApproxPercent / 100); // ±20% -> окно 40%
|
||||
int shift = (int)(Roll(a.Id, c.observation, 1) % (ulong)(width + 1));
|
||||
c.approxMin = Math.Max(1, a.Soldiers - shift); // настоящая численность всегда внутри окна
|
||||
c.approxMax = c.approxMin + width;
|
||||
EventBus.Publish(new ArmySpottedEvent
|
||||
{ EventId = EventId(c), ArmyId = a.Id, TimeMs = t, ApproxMin = c.approxMin, ApproxMax = c.approxMax });
|
||||
|
||||
if (!c.identified && Roll(a.Id, c.observation, 2) % 100 < (ulong)rules.IdentifyPercent)
|
||||
{
|
||||
c.identified = true;
|
||||
EventBus.Publish(new ArmyIdentifiedEvent { EventId = EventId(c), ArmyId = a.Id, OwnerId = a.OwnerId, TimeMs = t });
|
||||
}
|
||||
}
|
||||
|
||||
c.x = a.X; c.y = a.Y; c.toX = a.ToX; c.toY = a.ToY;
|
||||
c.lastSeenMs = t;
|
||||
viewDirty = true;
|
||||
}
|
||||
|
||||
static string EventId(Contact c) => c.armyId + "#" + c.observation.ToString(CultureInfo.InvariantCulture);
|
||||
|
||||
// Детерминированный бросок: армия + номер наблюдения + назначение. Повторный расчёт, загрузка или клик
|
||||
// не перебрасывают -- одно событие наблюдения, один результат (ТЗ, приёмка 5)
|
||||
static ulong Roll(string armyId, int observation, int purpose)
|
||||
{
|
||||
ulong h = 14695981039346656037UL;
|
||||
foreach (char ch in armyId) h = (h ^ ch) * 1099511628211UL;
|
||||
h ^= (ulong)observation * 0x9E3779B97F4A7C15UL + (ulong)purpose;
|
||||
h = (h ^ (h >> 30)) * 0xBF58476D1CE4E5B9UL;
|
||||
h = (h ^ (h >> 27)) * 0x94D049BB133111EBUL;
|
||||
return h ^ (h >> 31);
|
||||
}
|
||||
|
||||
// ---------------- Туман: исследованные клетки ----------------
|
||||
|
||||
void EnsureGrid(IWorldMap map)
|
||||
{
|
||||
if (map.HalfWidth == halfW && map.HalfHeight == halfH && explored.Length > 0) return;
|
||||
halfW = map.HalfWidth;
|
||||
halfH = map.HalfHeight;
|
||||
gridW = Math.Max(1, (2 * halfW + rules.CellSize - 1) / rules.CellSize);
|
||||
gridH = Math.Max(1, (2 * halfH + rules.CellSize - 1) / rules.CellSize);
|
||||
var old = explored;
|
||||
explored = new bool[gridW * gridH];
|
||||
if (old.Length == explored.Length) Array.Copy(old, explored, old.Length);
|
||||
}
|
||||
|
||||
int Cell(int x, int y)
|
||||
{
|
||||
if (gridW == 0) return -1;
|
||||
int cx = (x + halfW) / rules.CellSize, cy = (y + halfH) / rules.CellSize;
|
||||
if (cx < 0 || cy < 0 || cx >= gridW || cy >= gridH) return -1;
|
||||
return cy * gridW + cx;
|
||||
}
|
||||
|
||||
// Исследована клетка, центр которой попал в круг обзора
|
||||
void Explore(int x, int y, int r)
|
||||
{
|
||||
int c = rules.CellSize;
|
||||
for (int cy = Math.Max(0, (y - r + halfH) / c); cy <= Math.Min(gridH - 1, (y + r + halfH) / c); cy++)
|
||||
for (int cx = Math.Max(0, (x - r + halfW) / c); cx <= Math.Min(gridW - 1, (x + r + halfW) / c); cx++)
|
||||
{
|
||||
int px = cx * c + c / 2 - halfW, py = cy * c + c / 2 - halfH;
|
||||
if (Inside(px, py, x, y, r)) explored[cy * gridW + cx] = true;
|
||||
}
|
||||
}
|
||||
|
||||
static bool Inside(int x, int y, int cx, int cy, int r)
|
||||
{
|
||||
long dx = x - cx, dy = y - cy;
|
||||
return dx * dx + dy * dy <= (long)r * r;
|
||||
}
|
||||
|
||||
public int ExploredCells
|
||||
{
|
||||
get { int n = 0; foreach (var e in explored) if (e) n++; return n; }
|
||||
}
|
||||
|
||||
// ---------------- М2: целенаправленная разведка и отчёты ----------------
|
||||
|
||||
private readonly List<ReconReport> reports = new List<ReconReport>();
|
||||
public IReadOnlyList<ReconReport> Reports => reports;
|
||||
|
||||
public long ReconDurationMs(string targetId, int level)
|
||||
{
|
||||
IWorldMap map = worldMap();
|
||||
if (map == null || level < 2 || level > 3 || !map.TryGetReconTarget(targetId, out ReconTarget t)) return 0;
|
||||
int[] hours = t.Kind == ReconTargetKind.Castle ? rules.ReconCastleGameHours
|
||||
: t.Kind == ReconTargetKind.Camp ? rules.ReconCampGameHours
|
||||
: t.Kind == ReconTargetKind.Settlement ? rules.ReconSettlementGameHours : null;
|
||||
if (hours == null || hours.Length < level - 1) return 0;
|
||||
return Math.Max(0, hours[level - 2]) * rules.GameHourMs;
|
||||
}
|
||||
|
||||
// Отчёт -- снимок цели на момент конца наблюдения. Один отчёт на операцию: повтор (загрузка, двойное событие) -- false
|
||||
public bool CompleteRecon(string reportId, string targetId, int level, long timeMs)
|
||||
{
|
||||
if (string.IsNullOrEmpty(reportId) || reports.Exists(r => r.Id == reportId)) return false;
|
||||
IWorldMap map = worldMap();
|
||||
if (map == null || !map.TryGetReconTarget(targetId, out ReconTarget t)) return false;
|
||||
level = Math.Max(2, Math.Min(3, level));
|
||||
|
||||
var report = new ReconReport
|
||||
{
|
||||
Id = reportId, TargetId = targetId, TargetName = t.Name, Level = level, TimeMs = timeMs,
|
||||
Units = t.Units != null ? (int[])t.Units.Clone() : new int[4],
|
||||
Fortified = t.Fortified, HasHero = t.HasHero,
|
||||
Modifiers = "", ResourceNames = Array.Empty<string>(), ResourceMin = Array.Empty<int>(), ResourceMax = Array.Empty<int>()
|
||||
};
|
||||
if (level >= 3)
|
||||
{
|
||||
report.Modifiers = (t.Fortified ? "защитники за стенами" : "бой в поле, стен нет") + (t.HasHero ? ", есть герой" : ", героя нет");
|
||||
int n = t.ResourceNames != null ? t.ResourceNames.Length : 0;
|
||||
report.ResourceNames = new string[n];
|
||||
report.ResourceMin = new int[n];
|
||||
report.ResourceMax = new int[n];
|
||||
for (int i = 0; i < n; i++)
|
||||
{
|
||||
int amount = t.ResourceAmounts != null && i < t.ResourceAmounts.Length ? Math.Max(0, t.ResourceAmounts[i]) : 0;
|
||||
int width = amount * 2 * rules.ResourceEstimatePercent / 100; // ±15% -> окно 30%, настоящее значение внутри
|
||||
int shift = width > 0 ? (int)(Roll(reportId, i, 3) % (ulong)(width + 1)) : 0;
|
||||
report.ResourceNames[i] = t.ResourceNames[i];
|
||||
report.ResourceMin[i] = Math.Max(0, amount - shift);
|
||||
report.ResourceMax[i] = report.ResourceMin[i] + width;
|
||||
}
|
||||
}
|
||||
reports.Add(report);
|
||||
while (reports.Count > Math.Max(1, rules.MaxReports)) reports.RemoveAt(0);
|
||||
EventBus.Publish(new ReconCompletedEvent { EventId = reportId, TargetId = targetId, Level = level, TimeMs = timeMs });
|
||||
return true;
|
||||
}
|
||||
|
||||
public bool TryGetLatestReport(string targetId, out ReconReport report)
|
||||
{
|
||||
for (int i = reports.Count - 1; i >= 0; i--)
|
||||
if (reports[i].TargetId == targetId) { report = reports[i]; return true; }
|
||||
report = default;
|
||||
return false;
|
||||
}
|
||||
|
||||
static string Csv(int[] v)
|
||||
{
|
||||
if (v == null) return "";
|
||||
var parts = new string[v.Length];
|
||||
for (int i = 0; i < v.Length; i++) parts[i] = v[i].ToString(CultureInfo.InvariantCulture);
|
||||
return string.Join(",", parts);
|
||||
}
|
||||
|
||||
static int[] ParseCsv(string s)
|
||||
{
|
||||
if (string.IsNullOrEmpty(s)) return Array.Empty<int>();
|
||||
string[] parts = s.Split(',');
|
||||
var v = new int[parts.Length];
|
||||
for (int i = 0; i < parts.Length; i++) v[i] = I(parts[i]);
|
||||
return v;
|
||||
}
|
||||
|
||||
static string Clean(string s) => (s ?? "").Replace("|", "/").Replace("\n", " ");
|
||||
|
||||
void RestoreReport(string[] p)
|
||||
{
|
||||
if (p.Length < 12 || reports.Exists(r => r.Id == p[0])) return;
|
||||
long.TryParse(p[4], NumberStyles.Integer, CultureInfo.InvariantCulture, out long time);
|
||||
reports.Add(new ReconReport
|
||||
{
|
||||
Id = p[0], TargetId = p[1], TargetName = p[2], Level = I(p[3]), TimeMs = time,
|
||||
Units = ParseCsv(p[5]), Fortified = p[6] == "1", HasHero = p[7] == "1", Modifiers = p[8],
|
||||
ResourceNames = string.IsNullOrEmpty(p[9]) ? Array.Empty<string>() : p[9].Split(','),
|
||||
ResourceMin = ParseCsv(p[10]), ResourceMax = ParseCsv(p[11])
|
||||
});
|
||||
}
|
||||
|
||||
// ---------------- Сохранение (секция "intelligence") ----------------
|
||||
// Простые строки (модуль без Unity):
|
||||
// tick=<мс> obzor=<уровень> grid=<ширина>x<высота>:<клетки 0/1 в hex>
|
||||
// contact=<армия>|<владелец>|<опознан>|<видна>|x|y|toX|toY|min|max|<видели, мс>|<номер наблюдения>
|
||||
// report=<id>|<цель>|<название>|<уровень>|<время, мс>|<войска,..>|<стены 1/0>|<герой 1/0>|<модификаторы>|<ресурсы,..>|<мин,..>|<макс,..>
|
||||
|
||||
public string SaveKey => "intelligence";
|
||||
|
||||
public string Capture()
|
||||
{
|
||||
var sb = new StringBuilder();
|
||||
sb.Append("tick=").Append(lastTickMs.ToString(CultureInfo.InvariantCulture)).Append('\n');
|
||||
sb.Append("obzor=").Append(observationLevel.ToString(CultureInfo.InvariantCulture)).Append('\n');
|
||||
sb.Append("grid=").Append(gridW).Append('x').Append(gridH).Append(':').Append(PackBits(explored)).Append('\n');
|
||||
foreach (var c in contacts.Values)
|
||||
sb.Append("contact=").Append(string.Join("|", new[]
|
||||
{
|
||||
c.armyId, c.ownerId ?? "", c.identified ? "1" : "0", c.observed ? "1" : "0",
|
||||
N(c.x), N(c.y), N(c.toX), N(c.toY), N(c.approxMin), N(c.approxMax),
|
||||
c.lastSeenMs.ToString(CultureInfo.InvariantCulture), N(c.observation)
|
||||
})).Append('\n');
|
||||
foreach (var r in reports)
|
||||
sb.Append("report=").Append(string.Join("|", new[]
|
||||
{
|
||||
Clean(r.Id), Clean(r.TargetId), Clean(r.TargetName), N(r.Level), r.TimeMs.ToString(CultureInfo.InvariantCulture),
|
||||
Csv(r.Units), r.Fortified ? "1" : "0", r.HasHero ? "1" : "0", Clean(r.Modifiers),
|
||||
string.Join(",", r.ResourceNames ?? Array.Empty<string>()), Csv(r.ResourceMin), Csv(r.ResourceMax)
|
||||
})).Append('\n');
|
||||
return sb.ToString();
|
||||
}
|
||||
|
||||
public void Restore(string data)
|
||||
{
|
||||
ResetState();
|
||||
if (string.IsNullOrEmpty(data)) return;
|
||||
foreach (var raw in data.Split('\n'))
|
||||
{
|
||||
string line = raw.Trim();
|
||||
if (line.StartsWith("tick=")) long.TryParse(line.Substring(5), NumberStyles.Integer, CultureInfo.InvariantCulture, out lastTickMs);
|
||||
else if (line.StartsWith("obzor=") && int.TryParse(line.Substring(6), NumberStyles.Integer, CultureInfo.InvariantCulture, out int lvl)) ObservationLevel = lvl;
|
||||
else if (line.StartsWith("grid=")) RestoreGrid(line.Substring(5));
|
||||
else if (line.StartsWith("contact=")) RestoreContact(line.Substring(8).Split('|'));
|
||||
else if (line.StartsWith("report=")) RestoreReport(line.Substring(7).Split('|'));
|
||||
}
|
||||
viewDirty = true;
|
||||
}
|
||||
|
||||
public void ResetState()
|
||||
{
|
||||
contacts.Clear();
|
||||
reports.Clear();
|
||||
explored = Array.Empty<bool>();
|
||||
gridW = gridH = halfW = halfH = 0;
|
||||
lastTickMs = 0;
|
||||
observationLevel = 0;
|
||||
sources.Clear();
|
||||
viewDirty = true;
|
||||
}
|
||||
|
||||
void RestoreGrid(string s)
|
||||
{
|
||||
int x = s.IndexOf('x'), colon = s.IndexOf(':');
|
||||
if (x < 0 || colon < x) return;
|
||||
if (!int.TryParse(s.Substring(0, x), out int w) || !int.TryParse(s.Substring(x + 1, colon - x - 1), out int h)) return;
|
||||
if (w <= 0 || h <= 0) return;
|
||||
gridW = w; gridH = h;
|
||||
explored = UnpackBits(s.Substring(colon + 1), w * h);
|
||||
// halfW/halfH уточнит EnsureGrid при первом расчёте; размер сетки совпадёт -- клетки сохранятся
|
||||
}
|
||||
|
||||
void RestoreContact(string[] p)
|
||||
{
|
||||
if (p.Length < 12) return;
|
||||
var c = new Contact
|
||||
{
|
||||
armyId = p[0], ownerId = p[1].Length > 0 ? p[1] : null,
|
||||
identified = p[2] == "1", observed = p[3] == "1",
|
||||
x = I(p[4]), y = I(p[5]), toX = I(p[6]), toY = I(p[7]),
|
||||
approxMin = I(p[8]), approxMax = I(p[9]),
|
||||
observation = I(p[11])
|
||||
};
|
||||
long.TryParse(p[10], NumberStyles.Integer, CultureInfo.InvariantCulture, out c.lastSeenMs);
|
||||
if (!string.IsNullOrEmpty(c.armyId)) contacts[c.armyId] = c;
|
||||
}
|
||||
|
||||
static string N(int v) => v.ToString(CultureInfo.InvariantCulture);
|
||||
static int I(string s) => int.TryParse(s, NumberStyles.Integer, CultureInfo.InvariantCulture, out int v) ? v : 0;
|
||||
|
||||
static string PackBits(bool[] bits)
|
||||
{
|
||||
var sb = new StringBuilder();
|
||||
for (int i = 0; i < bits.Length; i += 4)
|
||||
{
|
||||
int v = 0;
|
||||
for (int k = 0; k < 4 && i + k < bits.Length; k++) if (bits[i + k]) v |= 1 << k;
|
||||
sb.Append("0123456789abcdef"[v]);
|
||||
}
|
||||
return sb.ToString();
|
||||
}
|
||||
|
||||
static bool[] UnpackBits(string hex, int count)
|
||||
{
|
||||
var bits = new bool[count];
|
||||
for (int i = 0; i < hex.Length && i * 4 < count; i++)
|
||||
{
|
||||
int v = "0123456789abcdef".IndexOf(char.ToLowerInvariant(hex[i]));
|
||||
if (v < 0) continue;
|
||||
for (int k = 0; k < 4 && i * 4 + k < count; k++) bits[i * 4 + k] = (v & (1 << k)) != 0;
|
||||
}
|
||||
return bits;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,2 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 6be01b8e525a455593482d7159414485
|
||||
@@ -12,6 +12,10 @@ public sealed class PopulationRules
|
||||
// Еда в час
|
||||
public double FoodPerCivilianPerHour = 0.1;
|
||||
public double FoodPerSoldierPerHour = 0.2;
|
||||
// Еда воина по типам войск: пехота, лучники, кавалерия, осадные (решения по отчёту Саши, 01.11, п. 4: 0,15 / 0,20 / 0,15 / 0,15).
|
||||
// Раненые едят полную норму своего типа, даже ожидая койку. null -- все воины едят FoodPerSoldierPerHour (как раньше).
|
||||
// Новобранцы в Казармах -- по FoodPerSoldierPerHour (их норма не задана).
|
||||
public double[] FoodPerTroopTypePerHour = null;
|
||||
|
||||
// Прирост +2–3 человека в час, если есть еда
|
||||
public double GrowthPerHour = 2.5;
|
||||
|
||||
@@ -15,7 +15,7 @@ using System.Text;
|
||||
// свободный житель = Civilians - Workers (Idle)
|
||||
// рабочий = Workers (jobs[], только из жителей: SetWorkers берёт не больше свободных)
|
||||
// новобранец = InTraining (TryRecruit забирает только свободных, рабочих не трогает)
|
||||
// воин = Soldiers (хранит Армия; RecruitsTrained убирает новобранцев до зачисления в Армию)
|
||||
// воин = Soldiers (хранит Армия: в городе, в походах и раненые; RecruitsTrained убирает новобранцев до зачисления в Армию)
|
||||
// Total = Civilians + InTraining + Soldiers -- сумма всех групп.
|
||||
// Рабочие места сами не заполняются: только стартовая расстановка (AutoFillAll, один раз), дальше -- игрок.
|
||||
// Найм воина: свободный житель уходит в Казармы (InTraining), после обучения его считает Армия. Резерв не нанять.
|
||||
@@ -79,7 +79,8 @@ public sealed class PopulationService : IPopulation, ISaveParticipant
|
||||
get
|
||||
{
|
||||
if (!GameServices.TryGet(out IArmy army)) return 0;
|
||||
return army.SoldiersAtHome + army.TroopsInMarches;
|
||||
// раненые -- тоже люди (решения 31.10, п. 7); пропавшие без вести занимают места до возвращения (решения 01.11, п. 5)
|
||||
return army.SoldiersAtHome + army.TroopsInMarches + army.WoundedTotal + army.MissingTotal;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -182,7 +183,19 @@ public sealed class PopulationService : IPopulation, ISaveParticipant
|
||||
double FoodPerHourExact(int soldiers)
|
||||
{
|
||||
// Обучающиеся в Казармах едят как воины
|
||||
return civilians * rules.FoodPerCivilianPerHour + (soldiers + inTraining) * rules.FoodPerSoldierPerHour;
|
||||
return civilians * rules.FoodPerCivilianPerHour + SoldiersFood(soldiers) + inTraining * rules.FoodPerSoldierPerHour;
|
||||
}
|
||||
|
||||
// Воины (в городе, в походах и раненые) едят по норме своего типа, если она задана (решения 01.11, п. 4)
|
||||
double SoldiersFood(int soldiers)
|
||||
{
|
||||
var table = rules.FoodPerTroopTypePerHour;
|
||||
int missingNow = GameServices.TryGet(out IArmy a) ? a.MissingTotal : 0; // пропавшие не едят
|
||||
if (table == null || table.Length == 0 || !GameServices.TryGet(out IArmy army)) return Math.Max(0, soldiers - missingNow) * rules.FoodPerSoldierPerHour;
|
||||
double food = 0;
|
||||
for (int t = 0; t < army.TypeCount; t++)
|
||||
food += army.GetAllTroops(t) * (t < table.Length ? table[t] : rules.FoodPerSoldierPerHour);
|
||||
return food;
|
||||
}
|
||||
|
||||
public int GetWorkers(WorkJob job)
|
||||
|
||||
@@ -0,0 +1,8 @@
|
||||
fileFormatVersion: 2
|
||||
guid: bd42162aabdf44f5bc5eff56e8ff9ca6
|
||||
folderAsset: yes
|
||||
DefaultImporter:
|
||||
externalObjects: {}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -0,0 +1,14 @@
|
||||
{
|
||||
"name": "Bogatyri.Settlement.Placement",
|
||||
"rootNamespace": "",
|
||||
"references": [],
|
||||
"includePlatforms": [],
|
||||
"excludePlatforms": [],
|
||||
"allowUnsafeCode": false,
|
||||
"overrideReferences": false,
|
||||
"precompiledReferences": [],
|
||||
"autoReferenced": true,
|
||||
"defineConstraints": [],
|
||||
"versionDefines": [],
|
||||
"noEngineReferences": true
|
||||
}
|
||||
@@ -0,0 +1,7 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 5a79ac8eed504b9eb36740352ba25b73
|
||||
AssemblyDefinitionImporter:
|
||||
externalObjects: {}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -0,0 +1,249 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
|
||||
// РАЗМЕЩЕНИЕ ЗДАНИЙ В 3D-ПОСЕЛЕНИИ (ТЗ «Система строительства поселения» от 04.11.2026, этап I).
|
||||
// Документ: Docs/Modules/Settlement.md, раздел «3D-поселение».
|
||||
//
|
||||
// Без Unity: только клетки, зоны, препятствия и занятость -- те же правила будут на сервере и в тестах.
|
||||
// Отображение (местность, кубы-здания, призрак) -- в слое приложения (Assets/Scripts/City3D).
|
||||
//
|
||||
// Невидимая логическая сетка: клетка CellSize единиц мира. Здание занимает прямоугольник клеток
|
||||
// (его максимальный габарит -- с первого уровня, апгрейд клетки не расширяет). Поворот 0/90/180/270.
|
||||
// Числа -- ТЕСТ, предложение Саши на согласование (ТЗ, раздел 12).
|
||||
namespace Bogatyri.Settlement.Placement
|
||||
{
|
||||
public enum CellKind
|
||||
{
|
||||
Ground, // обычная земля
|
||||
Water, // река -- постоянное препятствие
|
||||
Mountain // гора, скала -- постоянное препятствие
|
||||
}
|
||||
|
||||
// Почему здание нельзя поставить
|
||||
public enum PlaceError
|
||||
{
|
||||
None,
|
||||
OutOfMap, // за краем карты
|
||||
ZoneLocked, // зона ещё не открыта уровнем Ратуши
|
||||
Water, // река
|
||||
Mountain, // гора
|
||||
Obstacle, // дерево или валун -- можно расчистить
|
||||
Occupied, // другое здание
|
||||
TooClose, // нарушен технический отступ до другого здания
|
||||
TooSteep // слишком большой перепад высоты под зданием
|
||||
}
|
||||
|
||||
public sealed class PlacementRules
|
||||
{
|
||||
public float CellSize = 1f; // размер клетки в единицах мира
|
||||
public int GapCells = 1; // технический отступ между основаниями зданий, клеток
|
||||
public int MaxStepMm = 700; // наибольший перепад высоты под зданием (мм); меньше -- фундамент, больше -- нельзя
|
||||
|
||||
public static PlacementRules Default => new PlacementRules();
|
||||
}
|
||||
|
||||
// Здание на карте: прямоугольник клеток. X, Y -- левый нижний угол уже с учётом поворота
|
||||
public struct PlacedRect
|
||||
{
|
||||
public string Id;
|
||||
public string Type;
|
||||
public int X, Y;
|
||||
public int SizeW, SizeH; // габарит без поворота
|
||||
public int Rotation; // 0, 90, 180, 270
|
||||
public int W => Rotation == 90 || Rotation == 270 ? SizeH : SizeW;
|
||||
public int H => Rotation == 90 || Rotation == 270 ? SizeW : SizeH;
|
||||
}
|
||||
|
||||
public sealed class SettlementMap
|
||||
{
|
||||
public readonly int Width, Height;
|
||||
public readonly PlacementRules Rules;
|
||||
|
||||
private readonly CellKind[] kind;
|
||||
private readonly int[] heightMm; // высота земли в центре клетки, мм
|
||||
private readonly int[] zoneLevel; // с какого уровня Ратуши клетка доступна для стройки (0 -- никогда)
|
||||
private readonly Dictionary<int, string> obstacleAt = new Dictionary<int, string>(); // клетка -> id дерева/валуна
|
||||
private readonly Dictionary<string, List<int>> obstacleCells = new Dictionary<string, List<int>>();
|
||||
private readonly HashSet<string> cleared = new HashSet<string>();
|
||||
private readonly Dictionary<string, PlacedRect> buildings = new Dictionary<string, PlacedRect>();
|
||||
|
||||
public SettlementMap(int width, int height, PlacementRules rules = null)
|
||||
{
|
||||
Width = Math.Max(1, width);
|
||||
Height = Math.Max(1, height);
|
||||
Rules = rules ?? PlacementRules.Default;
|
||||
kind = new CellKind[Width * Height];
|
||||
heightMm = new int[Width * Height];
|
||||
zoneLevel = new int[Width * Height];
|
||||
}
|
||||
|
||||
// ---------------- Описание карты (заполняет генератор местности) ----------------
|
||||
|
||||
public bool InMap(int x, int y) => x >= 0 && y >= 0 && x < Width && y < Height;
|
||||
int Index(int x, int y) => y * Width + x;
|
||||
|
||||
public void SetCell(int x, int y, CellKind k, int heightMillimeters, int openAtTownHall)
|
||||
{
|
||||
if (!InMap(x, y)) return;
|
||||
int i = Index(x, y);
|
||||
kind[i] = k;
|
||||
heightMm[i] = heightMillimeters;
|
||||
zoneLevel[i] = Math.Max(0, openAtTownHall);
|
||||
}
|
||||
|
||||
public CellKind KindAt(int x, int y) => InMap(x, y) ? kind[Index(x, y)] : CellKind.Mountain;
|
||||
public int HeightAt(int x, int y) => InMap(x, y) ? heightMm[Index(x, y)] : 0;
|
||||
public int ZoneAt(int x, int y) => InMap(x, y) ? zoneLevel[Index(x, y)] : 0;
|
||||
public bool IsOpen(int x, int y, int townHallLevel) { int z = ZoneAt(x, y); return z > 0 && z <= townHallLevel; }
|
||||
|
||||
// Дерево или валун: занимает клетки, пока его не расчистили. id -- постоянный в пределах поселения
|
||||
public void AddObstacle(string id, IEnumerable<(int x, int y)> cells)
|
||||
{
|
||||
if (string.IsNullOrEmpty(id) || obstacleCells.ContainsKey(id)) return;
|
||||
var list = new List<int>();
|
||||
foreach (var c in cells)
|
||||
{
|
||||
if (!InMap(c.x, c.y)) continue;
|
||||
int i = Index(c.x, c.y);
|
||||
if (obstacleAt.ContainsKey(i)) continue;
|
||||
obstacleAt[i] = id;
|
||||
list.Add(i);
|
||||
}
|
||||
obstacleCells[id] = list;
|
||||
if (cleared.Contains(id)) foreach (int i in list) obstacleAt.Remove(i); // уже расчищен (из сохранения)
|
||||
}
|
||||
|
||||
public string ObstacleAt(int x, int y) => InMap(x, y) && obstacleAt.TryGetValue(Index(x, y), out string id) ? id : null;
|
||||
public bool IsCleared(string obstacleId) => cleared.Contains(obstacleId);
|
||||
public IReadOnlyCollection<string> Cleared => cleared;
|
||||
|
||||
// Расчистка: один раз на объект. true -- только что расчищен (за это одна награда); false -- нет такого или уже
|
||||
public bool ClearObstacle(string obstacleId)
|
||||
{
|
||||
if (string.IsNullOrEmpty(obstacleId) || !obstacleCells.TryGetValue(obstacleId, out var list) || cleared.Contains(obstacleId)) return false;
|
||||
cleared.Add(obstacleId);
|
||||
foreach (int i in list) obstacleAt.Remove(i);
|
||||
return true;
|
||||
}
|
||||
|
||||
// Расчищенные из сохранения -- до или после AddObstacle, порядок не важен
|
||||
public void RestoreCleared(IEnumerable<string> ids)
|
||||
{
|
||||
if (ids == null) return;
|
||||
foreach (var id in ids)
|
||||
{
|
||||
if (string.IsNullOrEmpty(id) || !cleared.Add(id)) continue;
|
||||
if (obstacleCells.TryGetValue(id, out var list)) foreach (int i in list) obstacleAt.Remove(i);
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------- Здания ----------------
|
||||
|
||||
public IReadOnlyCollection<PlacedRect> Buildings => buildings.Values;
|
||||
public bool TryGetBuilding(string id, out PlacedRect rect) => buildings.TryGetValue(id ?? "", out rect);
|
||||
|
||||
public string BuildingAt(int x, int y)
|
||||
{
|
||||
foreach (var b in buildings.Values)
|
||||
if (x >= b.X && y >= b.Y && x < b.X + b.W && y < b.Y + b.H) return b.Id;
|
||||
return null;
|
||||
}
|
||||
|
||||
// Проверить место: прямоугольник sizeW x sizeH с поворотом rotation, левый нижний угол (x, y).
|
||||
// ignoreId -- здание, которое переносят: его прежний след не мешает. foundationMm -- высота фундамента
|
||||
public PlaceError Validate(int x, int y, int sizeW, int sizeH, int rotation, int townHallLevel, string ignoreId, out int foundationMm)
|
||||
{
|
||||
foundationMm = 0;
|
||||
rotation = NormalizeRotation(rotation);
|
||||
int w = rotation == 90 || rotation == 270 ? sizeH : sizeW;
|
||||
int h = rotation == 90 || rotation == 270 ? sizeW : sizeH;
|
||||
if (w <= 0 || h <= 0 || x < 0 || y < 0 || x + w > Width || y + h > Height) return PlaceError.OutOfMap;
|
||||
|
||||
int min = int.MaxValue, max = int.MinValue;
|
||||
for (int cy = y; cy < y + h; cy++)
|
||||
for (int cx = x; cx < x + w; cx++)
|
||||
{
|
||||
int i = Index(cx, cy);
|
||||
if (kind[i] == CellKind.Water) return PlaceError.Water;
|
||||
if (kind[i] == CellKind.Mountain) return PlaceError.Mountain;
|
||||
if (!IsOpen(cx, cy, townHallLevel)) return PlaceError.ZoneLocked;
|
||||
if (obstacleAt.ContainsKey(i)) return PlaceError.Obstacle;
|
||||
min = Math.Min(min, heightMm[i]);
|
||||
max = Math.Max(max, heightMm[i]);
|
||||
}
|
||||
|
||||
int gap = Math.Max(0, Rules.GapCells);
|
||||
foreach (var b in buildings.Values)
|
||||
{
|
||||
if (b.Id == ignoreId) continue;
|
||||
if (Overlap(x, y, w, h, b.X, b.Y, b.W, b.H)) return PlaceError.Occupied;
|
||||
if (Overlap(x - gap, y - gap, w + 2 * gap, h + 2 * gap, b.X, b.Y, b.W, b.H)) return PlaceError.TooClose;
|
||||
}
|
||||
|
||||
if (max - min > Rules.MaxStepMm) return PlaceError.TooSteep;
|
||||
foundationMm = max - min; // небольшой перепад -- площадка под зданием (верх -- по самой высокой клетке)
|
||||
return PlaceError.None;
|
||||
}
|
||||
|
||||
// Поставить новое здание. Место проверяется теми же правилами; false -- ничего не изменилось
|
||||
public PlaceError Place(string id, string type, int x, int y, int sizeW, int sizeH, int rotation, int townHallLevel)
|
||||
{
|
||||
if (string.IsNullOrEmpty(id) || buildings.ContainsKey(id)) return PlaceError.Occupied;
|
||||
PlaceError e = Validate(x, y, sizeW, sizeH, rotation, townHallLevel, null, out _);
|
||||
if (e != PlaceError.None) return e;
|
||||
buildings[id] = new PlacedRect { Id = id, Type = type, X = x, Y = y, SizeW = sizeW, SizeH = sizeH, Rotation = NormalizeRotation(rotation) };
|
||||
return PlaceError.None;
|
||||
}
|
||||
|
||||
// Перенос (ТЗ, раздел 5): то же здание с тем же id -- меняются только позиция и поворот, целиком или никак.
|
||||
// Свой прежний след не мешает. Ошибка -- здание остаётся, где было
|
||||
public PlaceError Move(string id, int x, int y, int rotation, int townHallLevel)
|
||||
{
|
||||
if (!buildings.TryGetValue(id ?? "", out PlacedRect b)) return PlaceError.OutOfMap;
|
||||
PlaceError e = Validate(x, y, b.SizeW, b.SizeH, rotation, townHallLevel, id, out _);
|
||||
if (e != PlaceError.None) return e;
|
||||
b.X = x; b.Y = y; b.Rotation = NormalizeRotation(rotation);
|
||||
buildings[id] = b;
|
||||
return PlaceError.None;
|
||||
}
|
||||
|
||||
// Восстановление из сохранения: без проверки зон (зона могла быть открыта раньше), но без наложений
|
||||
public bool Restore(PlacedRect rect)
|
||||
{
|
||||
if (string.IsNullOrEmpty(rect.Id) || buildings.ContainsKey(rect.Id)) return false;
|
||||
rect.Rotation = NormalizeRotation(rect.Rotation);
|
||||
foreach (var b in buildings.Values)
|
||||
if (Overlap(rect.X, rect.Y, rect.W, rect.H, b.X, b.Y, b.W, b.H)) return false;
|
||||
buildings[rect.Id] = rect;
|
||||
return true;
|
||||
}
|
||||
|
||||
public static int NormalizeRotation(int rotation)
|
||||
{
|
||||
int r = ((rotation % 360) + 360) % 360;
|
||||
return r / 90 * 90;
|
||||
}
|
||||
|
||||
static bool Overlap(int ax, int ay, int aw, int ah, int bx, int by, int bw, int bh)
|
||||
{
|
||||
return ax < bx + bw && bx < ax + aw && ay < by + bh && by < ay + ah;
|
||||
}
|
||||
|
||||
public static string ErrorText(PlaceError e)
|
||||
{
|
||||
switch (e)
|
||||
{
|
||||
case PlaceError.None: return "Можно ставить";
|
||||
case PlaceError.OutOfMap: return "За краем карты";
|
||||
case PlaceError.ZoneLocked: return "Зона не открыта: нужен уровень Ратуши выше";
|
||||
case PlaceError.Water: return "Здесь река";
|
||||
case PlaceError.Mountain: return "Здесь скалы";
|
||||
case PlaceError.Obstacle: return "Мешает дерево или валун -- расчистите";
|
||||
case PlaceError.Occupied: return "Место занято другим зданием";
|
||||
case PlaceError.TooClose: return "Слишком близко к другому зданию";
|
||||
case PlaceError.TooSteep: return "Слишком крутой склон";
|
||||
default: return e.ToString();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 70c26fdf9f764df5977ed79f7457f90e
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -11,7 +11,9 @@
|
||||
"Bogatyri.Battle",
|
||||
"Bogatyri.World.Simulation",
|
||||
"Bogatyri.Chat",
|
||||
"Bogatyri.Circle"
|
||||
"Bogatyri.Circle",
|
||||
"Bogatyri.Intelligence",
|
||||
"Bogatyri.Settlement.Placement"
|
||||
],
|
||||
"includePlatforms": [
|
||||
"Editor"
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,121 @@
|
||||
using System.Collections.Generic;
|
||||
using Bogatyri.Settlement.Placement;
|
||||
using NUnit.Framework;
|
||||
|
||||
// Тесты размещения зданий в 3D-поселении (ТЗ «Система строительства поселения» от 04.11.2026, раздел 11).
|
||||
// Запуск: Window -> General -> Test Runner -> EditMode -> Run All.
|
||||
public class PlacementTests
|
||||
{
|
||||
// Карта 20 x 20: всё открыто с Ратуши 1, кроме правой полосы (x >= 15 -- Ратуша 2);
|
||||
// река по x = 10, скала в (2, 18), дерево "tree_1" в (5, 5), холм справа вверху
|
||||
static SettlementMap Map()
|
||||
{
|
||||
var map = new SettlementMap(20, 20);
|
||||
for (int y = 0; y < 20; y++)
|
||||
for (int x = 0; x < 20; x++)
|
||||
{
|
||||
CellKind k = x == 10 ? CellKind.Water : x == 2 && y == 18 ? CellKind.Mountain : CellKind.Ground;
|
||||
int height = x >= 16 && y >= 16 ? (x - 16) * 500 : 0; // склон: 0,5 м на клетку
|
||||
map.SetCell(x, y, k, height, x >= 15 ? 2 : 1);
|
||||
}
|
||||
map.AddObstacle("tree_1", new[] { (5, 5) });
|
||||
return map;
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Placement_FlatGround_Ok_AndForbiddenPlaces()
|
||||
{
|
||||
var map = Map();
|
||||
Assert.AreEqual(PlaceError.None, map.Place("hall", "Ратуша", 1, 1, 3, 3, 0, 1), "01: ровная земля");
|
||||
Assert.AreEqual(PlaceError.Water, map.Validate(9, 2, 2, 2, 0, 1, null, out _), "02: река");
|
||||
Assert.AreEqual(PlaceError.Mountain, map.Validate(1, 17, 2, 2, 0, 1, null, out _), "02: скала");
|
||||
Assert.AreEqual(PlaceError.Obstacle, map.Validate(4, 4, 2, 2, 0, 1, null, out _), "дерево мешает");
|
||||
Assert.AreEqual(PlaceError.OutOfMap, map.Validate(19, 19, 2, 2, 0, 1, null, out _), "за краем");
|
||||
Assert.AreEqual(PlaceError.ZoneLocked, map.Validate(15, 2, 2, 2, 0, 1, null, out _), "зона Ратуши 2");
|
||||
Assert.AreEqual(PlaceError.None, map.Validate(15, 2, 2, 2, 0, 2, null, out _), "11: Ратуша 2 открыла зону");
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Placement_GapBetweenBuildings()
|
||||
{
|
||||
var map = Map();
|
||||
map.Place("a", "Дом", 1, 1, 2, 2, 0, 1);
|
||||
Assert.AreEqual(PlaceError.Occupied, map.Validate(2, 2, 2, 2, 0, 1, null, out _));
|
||||
Assert.AreEqual(PlaceError.TooClose, map.Validate(3, 1, 2, 2, 0, 1, null, out _), "03: вплотную -- нарушен отступ");
|
||||
Assert.AreEqual(PlaceError.None, map.Validate(4, 1, 2, 2, 0, 1, null, out _), "через клетку -- можно");
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Placement_Rotation_SwapsFootprint()
|
||||
{
|
||||
var map = Map();
|
||||
// 4 x 1 у реки: повёрнутое на 90 -- 1 x 4 -- помещается вдоль реки, без поворота -- упирается в неё
|
||||
Assert.AreEqual(PlaceError.Water, map.Validate(7, 12, 4, 1, 0, 1, null, out _));
|
||||
foreach (int rot in new[] { 90, 270 })
|
||||
Assert.AreEqual(PlaceError.None, map.Validate(9, 12, 4, 1, rot, 1, null, out _), "04: поворот " + rot);
|
||||
Assert.AreEqual(PlaceError.Water, map.Validate(7, 12, 4, 1, 180, 1, null, out _), "04: 180 -- как 0");
|
||||
map.Place("long", "Склад", 9, 12, 4, 1, 90, 1);
|
||||
Assert.IsTrue(map.TryGetBuilding("long", out var b));
|
||||
Assert.AreEqual(1, b.W);
|
||||
Assert.AreEqual(4, b.H);
|
||||
Assert.AreEqual("long", map.BuildingAt(9, 15));
|
||||
Assert.IsNull(map.BuildingAt(10, 12));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Placement_Slope_FoundationOrTooSteep()
|
||||
{
|
||||
var map = Map();
|
||||
Assert.AreEqual(PlaceError.None, map.Validate(16, 16, 2, 2, 0, 2, null, out int f), "небольшой перепад");
|
||||
Assert.AreEqual(500, f, "фундамент 0,5 м");
|
||||
Assert.AreEqual(PlaceError.TooSteep, map.Validate(16, 16, 3, 2, 0, 2, null, out _), "1 м -- слишком круто");
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Placement_Move_IsAtomic_KeepsId()
|
||||
{
|
||||
var map = Map();
|
||||
map.Place("farm", "Ферма", 1, 1, 3, 3, 0, 1);
|
||||
map.Place("mine", "Шахта", 12, 1, 2, 2, 0, 1);
|
||||
|
||||
Assert.AreEqual(PlaceError.None, map.Move("farm", 2, 1, 0, 1), "свой прежний след не мешает");
|
||||
Assert.IsTrue(map.TryGetBuilding("farm", out var moved));
|
||||
Assert.AreEqual(2, moved.X);
|
||||
|
||||
Assert.AreEqual(PlaceError.Water, map.Move("farm", 8, 1, 0, 1), "09: ошибка -- здание на месте");
|
||||
map.TryGetBuilding("farm", out var same);
|
||||
Assert.AreEqual(2, same.X);
|
||||
Assert.AreEqual(2, map.Buildings.Count, "без дублей");
|
||||
|
||||
Assert.AreEqual(PlaceError.None, map.Move("mine", 12, 6, 90, 1), "05: шахту можно переносить и поворачивать");
|
||||
Assert.AreEqual(PlaceError.OutOfMap, map.Move("nope", 1, 1, 0, 1));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Placement_ClearObstacle_OnceOnly_SurvivesReload()
|
||||
{
|
||||
var map = Map();
|
||||
Assert.IsTrue(map.ClearObstacle("tree_1"), "10: расчищено -- одна награда");
|
||||
Assert.IsFalse(map.ClearObstacle("tree_1"), "второй раз -- без награды");
|
||||
Assert.IsNull(map.ObstacleAt(5, 5));
|
||||
Assert.AreEqual(PlaceError.None, map.Validate(4, 4, 2, 2, 0, 1, null, out _));
|
||||
|
||||
// Загрузка: расчищенное не возвращается, даже если отмечено раньше, чем объект добавлен на карту
|
||||
var copy = new SettlementMap(20, 20);
|
||||
for (int y = 0; y < 20; y++) for (int x = 0; x < 20; x++) copy.SetCell(x, y, CellKind.Ground, 0, 1);
|
||||
copy.RestoreCleared(new List<string>(map.Cleared));
|
||||
copy.AddObstacle("tree_1", new[] { (5, 5) });
|
||||
Assert.IsNull(copy.ObstacleAt(5, 5));
|
||||
Assert.IsFalse(copy.ClearObstacle("tree_1"));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Placement_Restore_NoOverlaps()
|
||||
{
|
||||
var map = Map();
|
||||
Assert.IsTrue(map.Restore(new PlacedRect { Id = "a", Type = "Дом", X = 1, Y = 1, SizeW = 2, SizeH = 2, Rotation = 0 }));
|
||||
Assert.IsFalse(map.Restore(new PlacedRect { Id = "b", Type = "Дом", X = 2, Y = 2, SizeW = 2, SizeH = 2, Rotation = 0 }), "12: наложение не восстанавливается");
|
||||
Assert.IsFalse(map.Restore(new PlacedRect { Id = "a", Type = "Дом", X = 6, Y = 6, SizeW = 2, SizeH = 2, Rotation = 0 }), "тот же id -- не дубль");
|
||||
Assert.AreEqual(270, SettlementMap.NormalizeRotation(-90));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 73f551b6ba7242e5bb6a9b8e983be5fe
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -13,10 +13,11 @@ using UnityEngine;
|
||||
// бой -> IBattleSystem (передаётся в WorldSimulation)
|
||||
// сохранение -> сам ISaveParticipant, секция "world"
|
||||
// наружу -> MarchStartedEvent, MarchBattleResolvedEvent, MarchReturnedEvent
|
||||
// разведка -> сам IWorldMap (где армии в момент t), WorldAdvancingEvent перед каждым расчётом
|
||||
//
|
||||
// Точка расширения под мультиплеер: сейчас WorldSimulation крутится прямо здесь.
|
||||
// Позже TryStartMarch будет отправлять запрос на сервер, а походы и их итоги -- приходить с сервера.
|
||||
public class MarchManager : MonoBehaviour, IWorld, ISaveParticipant
|
||||
public class MarchManager : MonoBehaviour, IWorld, IWorldMap, ISaveParticipant
|
||||
{
|
||||
public const string LocalPlayerId = LocalPlayer.Id;
|
||||
|
||||
@@ -26,6 +27,9 @@ public class MarchManager : MonoBehaviour, IWorld, ISaveParticipant
|
||||
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 час" в отладочной панели проматывает и походы.
|
||||
// Миллисекунды берём от настоящих часов, чтобы отряды на карте двигались плавно. В мультиплеере -- время сервера.
|
||||
@@ -35,6 +39,8 @@ public class MarchManager : MonoBehaviour, IWorld, ISaveParticipant
|
||||
private WorldSimulation world;
|
||||
private List<MarchData> pendingMarches; // загружены раньше, чем мир был создан
|
||||
private List<CampState> pendingCamps;
|
||||
private ResourcePointsState pendingPoints;
|
||||
private PatrolState pendingPatrols;
|
||||
|
||||
// Мир создаётся при первом обращении: к этому моменту Боевая система уже зарегистрирована
|
||||
public WorldSimulation World
|
||||
@@ -43,17 +49,29 @@ public class MarchManager : MonoBehaviour, IWorld, ISaveParticipant
|
||||
{
|
||||
if (world == null)
|
||||
{
|
||||
world = new WorldSimulation(WorldMapLayout.CreateDefault(), GameServices.Get<IBattleSystem>());
|
||||
world.AttackerConditions = m => m.ownerId == LocalPlayerId ? PlayerConditions() : BattleCondition.None;
|
||||
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()
|
||||
{
|
||||
@@ -66,6 +84,7 @@ public class MarchManager : MonoBehaviour, IWorld, ISaveParticipant
|
||||
{
|
||||
Instance = this;
|
||||
GameServices.Register<IWorld>(this);
|
||||
GameServices.Register<IWorldMap>(this);
|
||||
SaveRegistry.Register(this);
|
||||
}
|
||||
|
||||
@@ -73,6 +92,7 @@ public class MarchManager : MonoBehaviour, IWorld, ISaveParticipant
|
||||
{
|
||||
if (Instance != this) return;
|
||||
GameServices.Unregister<IWorld>(this);
|
||||
GameServices.Unregister<IWorldMap>(this);
|
||||
SaveRegistry.Unregister(this);
|
||||
}
|
||||
|
||||
@@ -81,20 +101,28 @@ public class MarchManager : MonoBehaviour, IWorld, ISaveParticipant
|
||||
// Без армии и экономики некуда вернуть войско и добычу -- ждём, пока они появятся
|
||||
if (!GameServices.Has<IArmy>() || !GameServices.Has<IEconomy>()) return;
|
||||
|
||||
long now = NowMs;
|
||||
CatchUpPopulationBeforeBattles(now);
|
||||
// Мир досчитывается по событиям, перед каждым шагом Разведка досчитывает наблюдение до него:
|
||||
// походы ещё на карте и их выжившие уже известны (после офлайна обратный путь тоже виден)
|
||||
events.Clear();
|
||||
World.Advance(NowMs, events);
|
||||
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();
|
||||
}
|
||||
|
||||
// Состояние войск игрока сейчас: голод -- из модуля Населения (план от 27.10.2026: проверяется на момент боя).
|
||||
// Бой, прошедший пока игра была закрыта, получает голод на момент входа: истории голода у Населения нет.
|
||||
// Состояние войск игрока сейчас: голод -- из модуля Населения. Для окна атаки (прогноз).
|
||||
// Усталость пока не выставляется -- правила её учёта не утверждены.
|
||||
public static BattleCondition PlayerConditions()
|
||||
{
|
||||
@@ -103,11 +131,104 @@ public class MarchManager : MonoBehaviour, IWorld, ISaveParticipant
|
||||
: 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 => World.Marches.Count;
|
||||
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;
|
||||
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);
|
||||
}
|
||||
|
||||
bool TryStart(string targetId, int soldiers, bool scout, out string error, int reconLevel = 0, long reconHoldMs = 0)
|
||||
{
|
||||
if (!GameServices.TryGet(out IArmy army))
|
||||
{
|
||||
@@ -122,8 +243,16 @@ public class MarchManager : MonoBehaviour, IWorld, ISaveParticipant
|
||||
return false;
|
||||
}
|
||||
|
||||
MarchData march = World.StartMarch(LocalPlayerId, WorldMapLayout.PlayerCityId, targetId, soldiers, NowMs, out error);
|
||||
// Слоты похода (регламент 31.10): база 2, «Военная логистика» -- позже
|
||||
if (army.ActiveMarches >= army.MarchSlots)
|
||||
{
|
||||
error = $"Все слоты похода заняты ({army.ActiveMarches} из {army.MarchSlots}). Дождитесь возвращения войска";
|
||||
return false;
|
||||
}
|
||||
|
||||
MarchData march = World.StartMarch(LocalPlayerId, WorldMapLayout.PlayerCityId, targetId, soldiers, NowMs, out error, scout);
|
||||
if (march == null) return false;
|
||||
if (reconLevel > 0) World.SetRecon(march, reconLevel, reconHoldMs);
|
||||
|
||||
// Отправка целиком или никак: поход существует, только если Армия действительно забрала воинов.
|
||||
// Иначе поход откатывается -- он не должен вернуть домой воинов, которых не забирал.
|
||||
@@ -133,17 +262,37 @@ public class MarchManager : MonoBehaviour, IWorld, ISaveParticipant
|
||||
error = "Не удалось собрать войско в поход";
|
||||
return false;
|
||||
}
|
||||
march.units = army.GetMarchUnits(march.id); // состав похода -- для боя с типами войск
|
||||
// Состав похода -- для боя с типами войск и для скорости: время прихода по средней скорости состава
|
||||
World.AssignUnits(march, army.GetMarchUnits(march.id));
|
||||
if (GameServices.TryGet(out ISaveSystem save)) save.SaveNow();
|
||||
|
||||
Debug.Log($"[ПОХОД] {soldiers} солдат выступили на {World.GetNode(targetId).displayName}");
|
||||
Debug.Log($"[ПОХОД] {soldiers} солдат выступили {(scout ? "в разведку" : "на")} {World.GetNode(targetId).displayName}");
|
||||
OnMarchStarted?.Invoke(march);
|
||||
EventBus.Publish(new MarchStartedEvent { MarchId = march.id, TargetId = targetId, Soldiers = soldiers });
|
||||
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), march.targetNodeId, 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 ? "ПОБЕДА" : "поражение")}. " +
|
||||
@@ -152,6 +301,8 @@ public class MarchManager : MonoBehaviour, IWorld, ISaveParticipant
|
||||
EventBus.Publish(new MarchBattleResolvedEvent
|
||||
{
|
||||
MarchId = march.id,
|
||||
BattleId = march.battleSeed,
|
||||
TimeMs = march.arriveMs,
|
||||
TargetId = march.targetNodeId,
|
||||
Victory = march.victory,
|
||||
Soldiers = march.soldiers,
|
||||
@@ -159,12 +310,29 @@ public class MarchManager : MonoBehaviour, IWorld, ISaveParticipant
|
||||
});
|
||||
}
|
||||
|
||||
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) // бой посчитал потери по типам
|
||||
? army.ReturnUnits(march.id, march.survivorUnits, march.woundedUnits, march.returnMs) // по типам; раненые -- в госпиталь
|
||||
: army.ReturnFromMarch(march.id, march.survivors); // старый поход без состава -- по пропорции
|
||||
|
||||
// Армия не знает этот поход (уже зачислен или испорченное сохранение): ни воинов, ни добычи
|
||||
@@ -188,11 +356,16 @@ public class MarchManager : MonoBehaviour, IWorld, ISaveParticipant
|
||||
EventBus.Publish(new MarchReturnedEvent
|
||||
{
|
||||
MarchId = march.id,
|
||||
TimeMs = march.returnMs,
|
||||
Victory = march.victory,
|
||||
Survivors = march.survivors,
|
||||
Sent = march.soldiers,
|
||||
TargetEmpty = march.targetEmpty,
|
||||
TargetName = World.GetNode(march.targetNodeId)?.displayName ?? "",
|
||||
IsGather = march.gather,
|
||||
IsScout = march.scout,
|
||||
Wounded = Sum(march.woundedUnits),
|
||||
Missing = Sum(march.missingUnits),
|
||||
TargetName = World.TargetName(march),
|
||||
LootText = FormatLoot(march.loot)
|
||||
});
|
||||
}
|
||||
@@ -204,6 +377,8 @@ public class MarchManager : MonoBehaviour, IWorld, ISaveParticipant
|
||||
{
|
||||
public List<MarchData> marches = new List<MarchData>();
|
||||
public List<CampState> camps = new List<CampState>(); // разбитые лагеря и когда они появятся
|
||||
public ResourcePointsState points; // ресурсные точки: запасы, сроки, кто собирает
|
||||
public PatrolState patrols; // патрули-заглушки: когда следующий
|
||||
}
|
||||
|
||||
public string SaveKey => "world";
|
||||
@@ -211,15 +386,22 @@ public class MarchManager : MonoBehaviour, IWorld, ISaveParticipant
|
||||
public string Capture()
|
||||
{
|
||||
var camps = world != null ? world.GetCampStates() : new List<CampState>(pendingCamps ?? new List<CampState>());
|
||||
return JsonUtility.ToJson(new WorldSaveData { marches = GetMarchesForSave(), camps = camps });
|
||||
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;
|
||||
}
|
||||
|
||||
// Новая игра: все походы отменяются (войска сбрасывает Армия вместе с прогрессом), лагеря на месте
|
||||
@@ -227,10 +409,14 @@ public class MarchManager : MonoBehaviour, IWorld, ISaveParticipant
|
||||
{
|
||||
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); // ресурсные точки появятся заново
|
||||
}
|
||||
}
|
||||
|
||||
@@ -246,6 +432,13 @@ public class MarchManager : MonoBehaviour, IWorld, ISaveParticipant
|
||||
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)
|
||||
|
||||
@@ -8,7 +8,8 @@ namespace Bogatyri.World
|
||||
PlayerCity, // город игрока
|
||||
NeighborCity, // соседний город -- другой игрок
|
||||
BossCastle, // Большой замок с боссом в центре карты
|
||||
Camp // PvE-лагерь разбойников: бьётся ради добычи, после победы появляется снова
|
||||
Camp, // PvE-лагерь разбойников: бьётся ради добычи, после победы появляется снова
|
||||
ResourcePoint // ресурсная точка: войско собирает ресурс, точка истощается и исчезает (регламент 31.10)
|
||||
}
|
||||
|
||||
[Serializable]
|
||||
@@ -184,7 +185,7 @@ namespace Bogatyri.World
|
||||
}
|
||||
|
||||
// Случайная точка, не слишком близко к замку и к другим точкам
|
||||
static bool TryFindFreeSpot(DeterministicRandom rng, List<MapNode> nodes, out int x, out int y, int spacing = MinCitySpacing)
|
||||
public static bool TryFindFreeSpot(DeterministicRandom rng, List<MapNode> nodes, out int x, out int y, int spacing = MinCitySpacing)
|
||||
{
|
||||
for (int attempt = 0; attempt < MaxPlacementAttempts; attempt++)
|
||||
{
|
||||
|
||||
@@ -0,0 +1,194 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
|
||||
namespace Bogatyri.World
|
||||
{
|
||||
// ПАТРУЛИ-ЗАГЛУШКИ (Разведка М1, решение команды 31.10.2026). ВРЕМЕННАЯ ТЕСТОВАЯ МЕХАНИКА, а не ИИ соседей:
|
||||
// соседние поселения иногда отправляют отряд к другому городу или лагерю и обратно -- чтобы проверить
|
||||
// обнаружение, примерную численность, опознание владельца и потерю контакта.
|
||||
// Патруль -- обычный поход (MarchData.patrol): Разведка видит его через тот же IWorldMap, что и настоящие армии.
|
||||
// Боя, добычи и разбития лагеря нет, Армия игрока о патрулях не знает.
|
||||
// Когда появится настоящий PvP -- Enabled = false в таблице MarchConfig, система наблюдения не меняется.
|
||||
public sealed class PatrolRules
|
||||
{
|
||||
public bool Enabled = false; // в игре -- из таблицы MarchConfig (там включено для теста)
|
||||
public int MaxActive = 3; // сколько патрулей одновременно на карте
|
||||
public long IntervalMs = 10 * 60_000; // новый патруль -- раз в 10 РЕАЛЬНЫХ минут (если есть свободное место)
|
||||
public int SoldiersMin = 10;
|
||||
public int SoldiersMax = 40;
|
||||
public int NearestSources = 6; // патрули выходят из ближайших к игроку соседних городов -- чтобы их было видно
|
||||
public int NearestTargets = 6; // и идут к одной из ближайших к игроку целей (город или лагерь)
|
||||
public long MaxCatchUpMs = 48L * 3_600_000; // после долгого офлайна досчитываются только последние 48 часов
|
||||
|
||||
public static PatrolRules Default => new PatrolRules();
|
||||
}
|
||||
|
||||
// Состояние патрулей в сохранении мира
|
||||
[Serializable]
|
||||
public class PatrolState
|
||||
{
|
||||
public long nextMs; // когда выйдет следующий патруль
|
||||
public int count; // сколько патрулей уже вышло (номер броска)
|
||||
}
|
||||
|
||||
public sealed partial class WorldSimulation
|
||||
{
|
||||
private PatrolRules patrolRules = PatrolRules.Default;
|
||||
private long patrolNextMs;
|
||||
private int patrolCount;
|
||||
|
||||
public PatrolRules Patrols
|
||||
{
|
||||
get => patrolRules;
|
||||
set => patrolRules = value ?? PatrolRules.Default;
|
||||
}
|
||||
|
||||
public PatrolState GetPatrolState() => new PatrolState { nextMs = patrolNextMs, count = patrolCount };
|
||||
|
||||
public void LoadPatrolState(PatrolState s)
|
||||
{
|
||||
patrolNextMs = s?.nextMs ?? 0;
|
||||
patrolCount = s?.count ?? 0;
|
||||
}
|
||||
|
||||
// Выпустить патрули, которым пора выйти к nowMs (каждый -- со своим временем выхода).
|
||||
// Можно звать много раз: уже вышедшие не повторяются. Выключено -- патрули убираются с карты.
|
||||
public void SpawnPatrolsUntil(long nowMs)
|
||||
{
|
||||
if (!patrolRules.Enabled)
|
||||
{
|
||||
marches.RemoveAll(m => m.patrol);
|
||||
return;
|
||||
}
|
||||
long interval = Math.Max(60_000, patrolRules.IntervalMs);
|
||||
if (patrolNextMs == 0 || nowMs - patrolNextMs > patrolRules.MaxCatchUpMs)
|
||||
patrolNextMs = patrolNextMs == 0 ? nowMs : nowMs - patrolRules.MaxCatchUpMs;
|
||||
|
||||
for (; patrolNextMs <= nowMs; patrolNextMs += interval)
|
||||
{
|
||||
long t = patrolNextMs;
|
||||
int active = 0;
|
||||
foreach (var m in marches) if (m.patrol && m.departMs <= t && m.returnMs > t) active++;
|
||||
if (active >= patrolRules.MaxActive) continue;
|
||||
SpawnPatrol(t);
|
||||
}
|
||||
}
|
||||
|
||||
void SpawnPatrol(long t)
|
||||
{
|
||||
var rng = new DeterministicRandom(pointSeed ^ 0x7A3201 ^ patrolCount * 104729);
|
||||
patrolCount++;
|
||||
|
||||
MapNode home = GetNode(WorldMapLayout.PlayerCityId);
|
||||
var cities = new List<MapNode>();
|
||||
foreach (var n in nodes) if (n.type == MapNodeType.NeighborCity) cities.Add(n);
|
||||
if (cities.Count == 0) return;
|
||||
if (home != null) cities.Sort((a, b) => Dist(a, home).CompareTo(Dist(b, home)));
|
||||
MapNode from = cities[rng.Range(0, Math.Min(Math.Max(1, patrolRules.NearestSources), cities.Count))];
|
||||
|
||||
var targets = new List<MapNode>();
|
||||
foreach (var n in nodes)
|
||||
if (n != from && (n.type == MapNodeType.NeighborCity || n.type == MapNodeType.Camp)) targets.Add(n);
|
||||
if (targets.Count == 0) return;
|
||||
// Цели -- тоже рядом с игроком: путь патруля проходит через его обзор (иначе проверять нечего)
|
||||
MapNode center = home ?? from;
|
||||
targets.Sort((a, b) => Dist(a, center).CompareTo(Dist(b, center)));
|
||||
MapNode to = targets[rng.Range(0, Math.Min(Math.Max(1, patrolRules.NearestTargets), targets.Count))];
|
||||
|
||||
int lo = Math.Max(1, patrolRules.SoldiersMin), hi = Math.Max(lo, patrolRules.SoldiersMax);
|
||||
int soldiers = rng.Range(lo, hi + 1);
|
||||
long travel = TravelTimeMs(from, to, null);
|
||||
marches.Add(new MarchData
|
||||
{
|
||||
id = nextMarchId++,
|
||||
ownerId = from.ownerId,
|
||||
fromNodeId = from.id,
|
||||
targetNodeId = to.id,
|
||||
targetName = to.displayName,
|
||||
soldiers = soldiers,
|
||||
survivors = soldiers,
|
||||
departMs = t,
|
||||
arriveMs = t + travel,
|
||||
returnMs = t + 2 * travel, // боя нет -- всё время пути известно сразу
|
||||
state = MarchState.Outbound,
|
||||
patrol = true
|
||||
});
|
||||
}
|
||||
|
||||
// Продвинуть мир до nowMs по событиям: перед каждым шагом beforeStep(момент) -- Разведка досчитывает
|
||||
// наблюдение до этого момента. Так после офлайна обратный путь войска считается уже после боя
|
||||
// (выжившие известны), а не как "стоят у цели". Итог тот же, что у одного Advance(nowMs).
|
||||
public void AdvanceInSteps(long nowMs, List<WorldEvent> events, Action<long> beforeStep)
|
||||
{
|
||||
SpawnPatrolsUntil(nowMs);
|
||||
long next;
|
||||
while ((next = NextEventMs(nowMs)) >= 0)
|
||||
{
|
||||
beforeStep?.Invoke(next);
|
||||
Advance(next, events);
|
||||
}
|
||||
beforeStep?.Invoke(nowMs);
|
||||
Advance(nowMs, events);
|
||||
}
|
||||
|
||||
// Ближайшее событие мира не позже nowMs (приход, конец сбора, исчезновение точки, возвращение); -1 -- нет
|
||||
public long NextEventMs(long nowMs)
|
||||
{
|
||||
long best = -1;
|
||||
foreach (var m in marches)
|
||||
{
|
||||
long at = m.state == MarchState.Outbound ? m.arriveMs
|
||||
: m.state == MarchState.Gathering ? m.gatherEndMs
|
||||
: m.state == MarchState.Returning ? m.returnMs : long.MaxValue;
|
||||
if (at <= nowMs && (best < 0 || at < best)) best = at;
|
||||
}
|
||||
foreach (var p in points)
|
||||
if (p.active && p.occupiedBy == 0 && p.expireMs <= nowMs && (best < 0 || p.expireMs < best)) best = p.expireMs;
|
||||
return best;
|
||||
}
|
||||
|
||||
static long Dist(MapNode a, MapNode b) => WorldMapLayout.Distance(a, b);
|
||||
|
||||
// Где войско в момент t (Unix мс) -- по времени похода, а не по текущему состоянию:
|
||||
// Разведка досчитывает наблюдение за прошедшие минуты. false -- ещё не вышло или уже дома.
|
||||
// x, y -- позиция, toX, toY -- куда идёт; soldiers -- сколько воинов в этот момент.
|
||||
public bool TryGetPositionAt(MarchData m, long t, out int x, out int y, out int toX, out int toY, out int soldiers)
|
||||
{
|
||||
x = y = toX = toY = soldiers = 0;
|
||||
MapNode home = GetNode(m.fromNodeId), target = GetNode(m.targetNodeId);
|
||||
if (home == null || target == null || t < m.departMs) return false;
|
||||
|
||||
bool resolved = m.state == MarchState.Returning || m.state == MarchState.Finished
|
||||
|| m.state == MarchState.Gathering || m.patrol;
|
||||
if (t < m.arriveMs || !resolved && m.state == MarchState.Outbound && t >= m.arriveMs)
|
||||
{
|
||||
// В пути к цели (или дошли, а мир ещё не посчитал приход -- стоят у цели)
|
||||
Lerp(home, target, m.departMs, m.arriveMs, Math.Min(t, m.arriveMs), out x, out y);
|
||||
toX = target.x; toY = target.y;
|
||||
soldiers = m.soldiers;
|
||||
return true;
|
||||
}
|
||||
|
||||
long backStart = m.gather || m.reconLevel > 0 && m.gatherEndMs > 0 ? m.gatherEndMs : m.arriveMs; // после сбора / наблюдения
|
||||
soldiers = m.state == MarchState.Gathering || m.gather && t < backStart ? m.soldiers : m.survivors;
|
||||
if (soldiers <= 0) return false; // все пали в бою -- армии на карте нет
|
||||
if (m.state == MarchState.Gathering || t < backStart)
|
||||
{
|
||||
x = target.x; y = target.y; toX = target.x; toY = target.y; // стоят на точке и собирают
|
||||
return true;
|
||||
}
|
||||
if (m.returnMs > 0 && t >= m.returnMs) return false; // дома
|
||||
Lerp(target, home, backStart, m.returnMs, t, out x, out y);
|
||||
toX = home.x; toY = home.y;
|
||||
return true;
|
||||
}
|
||||
|
||||
static void Lerp(MapNode a, MapNode b, long start, long end, long t, out int x, out int y)
|
||||
{
|
||||
if (end <= start) { x = b.x; y = b.y; return; }
|
||||
long p = Math.Max(0, Math.Min(end - start, t - start));
|
||||
x = a.x + (int)((long)(b.x - a.x) * p / (end - start));
|
||||
y = a.y + (int)((long)(b.y - a.y) * p / (end - start));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,2 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 8e64d4c94b1549d2815ee0cb278e0ac5
|
||||
@@ -0,0 +1,318 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
|
||||
namespace Bogatyri.World
|
||||
{
|
||||
// Ресурсная точка на карте (регламент 31.10, раздел 7; решение №46: состояние точки ведёт World).
|
||||
// Состояние меняется со временем, поэтому хранится в сохранении, а не строится из seed, как замок и города.
|
||||
[Serializable]
|
||||
public class ResourcePoint
|
||||
{
|
||||
public string id;
|
||||
public int kind; // ResourcePointRules.Resources: 0 дерево, 1 камень, 2 металл, 3 золото
|
||||
public int size; // 0 малая, 1 средняя, 2 крупная
|
||||
public int x;
|
||||
public int y;
|
||||
public int stock; // сколько осталось
|
||||
public int stockMax;
|
||||
public long spawnMs; // появилась (реальное время часов GameClock)
|
||||
public long expireMs; // исчезнет
|
||||
public int occupiedBy; // номер похода, который сейчас собирает (0 -- свободна)
|
||||
public bool active; // false -- истощена или исчезла (остаётся, пока к ней идёт или с неё возвращается войско)
|
||||
}
|
||||
|
||||
// Числа ресурсных точек (регламент 31.10, раздел 7, ТЕСТ). В игре -- из таблицы WorldResourceConfig.
|
||||
public sealed class ResourcePointRules
|
||||
{
|
||||
// Имена ресурсов -- как в ResourceType (Мир про экономику не знает, зачисляет её модуль по имени)
|
||||
public static readonly string[] Resources = { "Wood", "Stone", "Iron", "Gold" };
|
||||
public static readonly string[] KindNames = { "Лес", "Каменоломня", "Рудник", "Золотая жила" };
|
||||
public static readonly string[] SizeNames = { "малая", "средняя", "крупная" };
|
||||
|
||||
// Запас: [ресурс][размер] -- дерево 200/600/1500, камень 150/450/1000, металл 80/250/600, золото 30/100/250
|
||||
public int[][] Stock =
|
||||
{
|
||||
new[] { 200, 600, 1500 },
|
||||
new[] { 150, 450, 1000 },
|
||||
new[] { 80, 250, 600 },
|
||||
new[] { 30, 100, 250 }
|
||||
};
|
||||
// Добыча одного воина за ИГРОВОЙ час, в тысячных долях: 2 / 1,5 / 1 / 0,5
|
||||
public int[] MiningMilliPerGameHour = { 2000, 1500, 1000, 500 };
|
||||
// Груз одного воина: 12 / 10 / 8 / 5. Осадные машины груза не несут (регламент)
|
||||
public int[] CargoPerSoldier = { 12, 10, 8, 5 };
|
||||
// Срок жизни точки в РЕАЛЬНЫХ часах с момента появления: малая 12, средняя 24, крупная 48
|
||||
public int[] LifetimeRealHours = { 12, 24, 48 };
|
||||
// 1 игровой час = 5 реальных минут (регламент 31.10, раздел 2)
|
||||
public long GameHourMs = 5 * 60 * 1000;
|
||||
|
||||
// Не задано регламентом -- ТЕСТ, решает команда:
|
||||
// Сколько точек одновременно на карте: [ресурс][размер] (решения по 8 вопросам Саши, 31.10, п. 6, ТЕСТ).
|
||||
// Всего 24: лес 8, камень 7, металл 5, золото 4; по размерам 12 малых, 8 средних, 4 крупных.
|
||||
// Раскладка размеров по ресурсам документом не задана -- задаётся здесь (в игре -- WorldResourceConfig).
|
||||
public int[][] Count =
|
||||
{
|
||||
new[] { 4, 3, 1 }, // лес 8
|
||||
new[] { 4, 2, 1 }, // камень 7
|
||||
new[] { 2, 2, 1 }, // металл 5
|
||||
new[] { 2, 1, 1 } // золото 4
|
||||
};
|
||||
public int Spacing = 2200; // не ближе 2,2 клетки к другим точкам карты
|
||||
|
||||
public static ResourcePointRules Default => new ResourcePointRules();
|
||||
|
||||
// Сбор с начала startMs: сколько войско унесёт и когда закончит.
|
||||
// Конец -- груз полон, точка истощена или исчезла (expireMs), что раньше.
|
||||
public void Gather(int kind, int[] units, int stock, long startMs, long expireMs, out int amount, out long endMs)
|
||||
{
|
||||
int miners = 0, carriers = 0;
|
||||
for (int i = 0; units != null && i < units.Length; i++)
|
||||
{
|
||||
if (units[i] <= 0) continue;
|
||||
miners += units[i];
|
||||
if (i != TroopType.Siege) carriers += units[i];
|
||||
}
|
||||
long target = Math.Min(Math.Max(0, stock), (long)carriers * CargoPerSoldier[kind]);
|
||||
long rate = (long)miners * MiningMilliPerGameHour[kind]; // тысячных долей за игровой час
|
||||
if (target <= 0 || rate <= 0 || expireMs <= startMs)
|
||||
{
|
||||
amount = 0;
|
||||
endMs = startMs;
|
||||
return;
|
||||
}
|
||||
long full = (target * 1000 * GameHourMs + rate - 1) / rate; // время до полного груза (вверх)
|
||||
if (startMs + full <= expireMs)
|
||||
{
|
||||
amount = (int)target;
|
||||
endMs = startMs + full;
|
||||
}
|
||||
else
|
||||
{
|
||||
endMs = expireMs; // точка исчезла раньше -- уносят, что успели
|
||||
amount = (int)Math.Min(target, rate * (expireMs - startMs) / (1000 * GameHourMs));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Состояние ресурсных точек для сохранения (секция "world")
|
||||
[Serializable]
|
||||
public class ResourcePointsState
|
||||
{
|
||||
public List<ResourcePoint> points = new List<ResourcePoint>();
|
||||
public int nextPointId = 1;
|
||||
public int generation; // сколько точек уже появилось -- для детерминированного места следующей
|
||||
public bool initialized; // первые точки уже выставлены
|
||||
}
|
||||
|
||||
public sealed partial class WorldSimulation
|
||||
{
|
||||
private readonly ResourcePointRules pointRules;
|
||||
private readonly int pointSeed;
|
||||
private readonly List<ResourcePoint> points = new List<ResourcePoint>();
|
||||
private int nextPointId = 1;
|
||||
private int pointGeneration;
|
||||
private bool pointsInitialized;
|
||||
|
||||
public ResourcePointRules PointRules => pointRules;
|
||||
public IReadOnlyList<ResourcePoint> ResourcePoints => points;
|
||||
|
||||
public ResourcePoint GetPoint(string id)
|
||||
{
|
||||
return points.Find(p => p.id == id);
|
||||
}
|
||||
|
||||
// Точки на карте по таблице Count. Первые -- в момент первого расчёта мира; после загрузки сохранения
|
||||
// недостающие добавляются (старое сохранение с 8 точками дополнится до 24, лишние доживут свой срок)
|
||||
void EnsureResourcePoints(long nowMs)
|
||||
{
|
||||
if (pointsInitialized && !pointsTopUp) return;
|
||||
pointsInitialized = true;
|
||||
pointsTopUp = false;
|
||||
SpawnMissingPoints(nowMs);
|
||||
}
|
||||
|
||||
private bool pointsTopUp;
|
||||
|
||||
// Сколько активных точек каждого ресурса и размера не хватает до таблицы -- столько и появляется
|
||||
void SpawnMissingPoints(long nowMs)
|
||||
{
|
||||
for (int kind = 0; kind < ResourcePointRules.Resources.Length; kind++)
|
||||
for (int size = 0; size < 3; size++)
|
||||
{
|
||||
int have = 0;
|
||||
foreach (var p in points) if (p.active && p.kind == kind && p.size == size) have++;
|
||||
for (int k = have; k < PointCount(kind, size); k++)
|
||||
if (SpawnPoint(kind, size, nowMs) == null) return; // карта переполнена -- попробуем при следующем исчезновении
|
||||
}
|
||||
}
|
||||
|
||||
int PointCount(int kind, int size)
|
||||
{
|
||||
var c = pointRules.Count;
|
||||
return c != null && kind < c.Length && c[kind] != null && size < c[kind].Length ? Math.Max(0, c[kind][size]) : 0;
|
||||
}
|
||||
|
||||
// Новая точка этого ресурса и размера в другом месте. Место -- из seed и номера появления (одинаково на сервере)
|
||||
ResourcePoint SpawnPoint(int kind, int size, long nowMs)
|
||||
{
|
||||
pointGeneration++;
|
||||
var rng = new DeterministicRandom(pointSeed ^ 0x2F0E1D ^ pointGeneration * 7919);
|
||||
if (!WorldMapLayout.TryFindFreeSpot(rng, nodes, out int x, out int y, pointRules.Spacing)) return null;
|
||||
|
||||
var p = new ResourcePoint
|
||||
{
|
||||
id = "res_" + nextPointId++,
|
||||
kind = kind,
|
||||
size = size,
|
||||
x = x,
|
||||
y = y,
|
||||
stock = pointRules.Stock[kind][size],
|
||||
stockMax = pointRules.Stock[kind][size],
|
||||
spawnMs = nowMs,
|
||||
expireMs = nowMs + pointRules.LifetimeRealHours[size] * 3_600_000L,
|
||||
active = true
|
||||
};
|
||||
points.Add(p);
|
||||
nodes.Add(ToNode(p));
|
||||
return p;
|
||||
}
|
||||
|
||||
static MapNode ToNode(ResourcePoint p)
|
||||
{
|
||||
return new MapNode
|
||||
{
|
||||
id = p.id,
|
||||
displayName = $"{ResourcePointRules.KindNames[p.kind]} ({ResourcePointRules.SizeNames[p.size]})",
|
||||
type = MapNodeType.ResourcePoint,
|
||||
x = p.x,
|
||||
y = p.y,
|
||||
canBeAttacked = true, // «можно отправить войско»
|
||||
level = p.size + 1
|
||||
};
|
||||
}
|
||||
|
||||
// Точка истощена или исчезла: на её месте больше нечего собирать, новая того же ресурса и размера
|
||||
// появляется в другом месте (если таких точек теперь меньше, чем в таблице)
|
||||
void RetirePoint(ResourcePoint p, long atMs)
|
||||
{
|
||||
if (!p.active) return;
|
||||
p.active = false;
|
||||
p.occupiedBy = 0;
|
||||
SpawnMissingPoints(atMs);
|
||||
}
|
||||
|
||||
// Исчезнувшие точки убираются с карты, когда к ним уже никто не идёт и с них никто не возвращается
|
||||
void PurgeRetiredPoints()
|
||||
{
|
||||
points.RemoveAll(p =>
|
||||
{
|
||||
if (p.active || marches.Exists(m => m.targetNodeId == p.id)) return false;
|
||||
nodes.RemoveAll(n => n.id == p.id);
|
||||
return true;
|
||||
});
|
||||
}
|
||||
|
||||
public bool CanGatherAt(string pointId, long nowMs, out string error)
|
||||
{
|
||||
ResourcePoint p = GetPoint(pointId);
|
||||
if (p == null || !p.active || nowMs >= p.expireMs) { error = "Этой ресурсной точки больше нет"; return false; }
|
||||
if (p.occupiedBy != 0) { error = "Точку уже занимает войско"; return false; }
|
||||
if (marches.Exists(m => m.targetNodeId == pointId && m.state == MarchState.Outbound && m.gather)) // разведка не мешает
|
||||
{
|
||||
error = "К этой точке уже идёт войско";
|
||||
return false;
|
||||
}
|
||||
error = null;
|
||||
return true;
|
||||
}
|
||||
|
||||
// Прогноз сбора для окна отправки: сколько унесут и сколько продлится сбор, если дойдут в arriveMs
|
||||
public void PreviewGather(string pointId, int[] units, long arriveMs, out int amount, out long gatherMs)
|
||||
{
|
||||
ResourcePoint p = GetPoint(pointId);
|
||||
if (p == null) { amount = 0; gatherMs = 0; return; }
|
||||
pointRules.Gather(p.kind, units, p.stock, arriveMs, p.expireMs, out amount, out long endMs);
|
||||
gatherMs = endMs - arriveMs;
|
||||
}
|
||||
|
||||
// Войско дошло до точки: начинает сбор. Точки нет или она занята -- возвращается без добычи
|
||||
void StartGather(MarchData m)
|
||||
{
|
||||
MapNode from = GetNode(m.fromNodeId);
|
||||
MapNode target = GetNode(m.targetNodeId);
|
||||
ResourcePoint p = GetPoint(m.targetNodeId);
|
||||
int[] units = HasUnits(m) ? m.units : new[] { m.soldiers, 0, 0, 0 };
|
||||
|
||||
m.victory = false;
|
||||
m.survivors = m.soldiers; // при сборе боя нет -- все живы
|
||||
m.survivorUnits = HasUnits(m) ? (int[])m.units.Clone() : null;
|
||||
m.loot = new List<RewardEntry>();
|
||||
|
||||
if (p == null || !p.active || p.occupiedBy != 0 || m.arriveMs >= p.expireMs)
|
||||
{
|
||||
m.targetEmpty = true;
|
||||
m.gatherEndMs = m.arriveMs;
|
||||
m.returnMs = m.arriveMs + TravelTimeMs(target, from, units);
|
||||
m.state = MarchState.Returning;
|
||||
return;
|
||||
}
|
||||
|
||||
pointRules.Gather(p.kind, units, p.stock, m.arriveMs, p.expireMs, out int amount, out long endMs);
|
||||
m.cargo = amount;
|
||||
m.gatherEndMs = endMs;
|
||||
m.state = MarchState.Gathering;
|
||||
p.occupiedBy = m.id;
|
||||
}
|
||||
|
||||
// Сбор закончен: груз -- в добычу похода (зачислит Экономика по возвращении), войско идёт домой
|
||||
void FinishGather(MarchData m)
|
||||
{
|
||||
MapNode from = GetNode(m.fromNodeId);
|
||||
MapNode target = GetNode(m.targetNodeId);
|
||||
ResourcePoint p = GetPoint(m.targetNodeId);
|
||||
int[] units = HasUnits(m) ? m.units : null;
|
||||
|
||||
if (p != null)
|
||||
{
|
||||
p.stock = Math.Max(0, p.stock - m.cargo);
|
||||
if (p.occupiedBy == m.id) p.occupiedBy = 0;
|
||||
if (m.cargo > 0) m.loot.Add(new RewardEntry { resource = ResourcePointRules.Resources[p.kind], amount = m.cargo });
|
||||
if (p.stock <= 0 || m.gatherEndMs >= p.expireMs) RetirePoint(p, m.gatherEndMs);
|
||||
}
|
||||
m.returnMs = m.gatherEndMs + TravelTimeMs(target, from, units);
|
||||
m.state = MarchState.Returning;
|
||||
}
|
||||
|
||||
// ---------------- Сохранение ----------------
|
||||
|
||||
public ResourcePointsState GetPointsState()
|
||||
{
|
||||
var state = new ResourcePointsState
|
||||
{
|
||||
nextPointId = nextPointId,
|
||||
generation = pointGeneration,
|
||||
initialized = pointsInitialized
|
||||
};
|
||||
foreach (var p in points) state.points.Add(p);
|
||||
return state;
|
||||
}
|
||||
|
||||
// Загружать ДО походов: поход к точке восстанавливается, только если точка есть на карте
|
||||
public void LoadPointsState(ResourcePointsState state)
|
||||
{
|
||||
nodes.RemoveAll(n => n.type == MapNodeType.ResourcePoint);
|
||||
points.Clear();
|
||||
nextPointId = state?.nextPointId ?? 1;
|
||||
pointGeneration = state?.generation ?? 0;
|
||||
pointsInitialized = state?.initialized ?? false;
|
||||
pointsTopUp = true; // таблица могла измениться -- при следующем расчёте мира добавить недостающие
|
||||
if (state?.points == null) return;
|
||||
foreach (var p in state.points)
|
||||
{
|
||||
if (p == null || p.kind < 0 || p.kind >= ResourcePointRules.Resources.Length || p.size < 0 || p.size > 2) continue;
|
||||
points.Add(p);
|
||||
nodes.Add(ToNode(p));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
fileFormatVersion: 2
|
||||
guid: caa1c535b9b8440c95d48f1928e6b78f
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -1,5 +1,6 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Numerics;
|
||||
|
||||
namespace Bogatyri.World
|
||||
{
|
||||
@@ -7,7 +8,8 @@ namespace Bogatyri.World
|
||||
{
|
||||
Outbound, // идут к цели
|
||||
Returning, // бой прошёл, возвращаются домой
|
||||
Finished // вернулись, солдаты и добыча зачислены
|
||||
Finished, // вернулись, солдаты и добыча зачислены
|
||||
Gathering // стоят на ресурсной точке и собирают (регламент 31.10)
|
||||
}
|
||||
|
||||
// Один поход. Всё время -- абсолютное (Unix-время в миллисекундах), а не "осталось N секунд":
|
||||
@@ -19,15 +21,25 @@ namespace Bogatyri.World
|
||||
public string ownerId;
|
||||
public string fromNodeId;
|
||||
public string targetNodeId;
|
||||
public string targetName; // название цели на момент выступления: истощённая точка может исчезнуть с карты раньше, чем показан итог
|
||||
|
||||
public int soldiers; // сколько ушло
|
||||
public int survivors; // сколько возвращается (известно после боя)
|
||||
public bool victory;
|
||||
public bool targetEmpty; // лагерь уже был разбит, когда войско пришло: боя нет, все возвращаются
|
||||
public bool targetEmpty; // лагерь уже разбит / ресурсная точка исчезла или занята: боя и сбора нет, все возвращаются
|
||||
public bool gather; // поход на ресурсную точку: сбор вместо боя
|
||||
public bool patrol; // патруль-заглушка соседа (Разведка М1): без боя и добычи, Армии игрока не касается
|
||||
public bool scout; // поход «Разведка» (решения 31.10, п. 2): дойти до цели и вернуться, без боя и сбора
|
||||
public int reconLevel; // Разведка М2: 0 -- просто дойти и вернуться; 2 / 3 -- наблюдать reconHoldMs и составить отчёт
|
||||
public long reconHoldMs; // сколько наблюдать цель (мс часов игры): время уровня из модуля Разведки
|
||||
public long gatherEndMs; // когда сбор закончится (груз полон, точка истощена или исчезла)
|
||||
public int cargo; // сколько ресурса несёт войско (известно с начала сбора)
|
||||
public int defenders; // гарнизон цели в момент боя
|
||||
public int defenderLosses; // сколько потерял защитник
|
||||
public int[] units; // состав похода по типам (TroopType); пусто -- старый поход, все считаются пехотой
|
||||
public int[] survivorUnits; // выжившие по типам (известно после боя)
|
||||
public int[] woundedUnits; // раненые по типам: идут домой с войском и ложатся в госпиталь (решения 31.10, п. 7)
|
||||
public int[] missingUnits; // пропавшие без вести по типам: возвращаются сами, группами (решения 01.11, п. 5)
|
||||
|
||||
public long battleSeed; // номер боя: из него случайность сторон. Задаётся при выступлении и сохраняется
|
||||
public long attackerPower; // итог боя: силы сторон x100 и выпавшая случайность (десятые доли процента)
|
||||
@@ -44,21 +56,82 @@ namespace Bogatyri.World
|
||||
public MarchState state;
|
||||
}
|
||||
|
||||
// Скорости маршей (регламент 31.10, раздел 7, ТЕСТ). Физический марш идёт в РЕАЛЬНОМ времени (регламент, раздел 2):
|
||||
// скорость -- единиц карты за 1 реальный час, единица карты = 1 клетка = 1000 милли-единиц координат.
|
||||
// Время мира -- миллисекунды часов GameClock (реальное время + перемотка DEV).
|
||||
//
|
||||
// Смешанное войско (решения по 8 вопросам Саши, 31.10, п. 4) -- средняя скорость по численности с модификаторами:
|
||||
// V = Σ(Nᵢ × Vᵢ × Mᵢ) / ΣNᵢ, общий модификатор войска -- один раз, без промежуточного округления.
|
||||
// Пример: 10 пехоты + 10 кавалерии = (10×8 + 10×12) / 20 = 10 клеток в час; общий бафф +10% -- 11.
|
||||
public sealed class MarchSpeedRules
|
||||
{
|
||||
// Милли-единиц карты за реальный час по типам войск (TroopType): пехота 8, лучники 9, кавалерия 12, осадные 4
|
||||
public int[] SpeedMilliPerHour = { 8000, 9000, 12000, 4000 };
|
||||
|
||||
// Модификатор скорости каждого типа, в процентах: +10 -- быстрее на 10%, -20 -- медленнее.
|
||||
// Позже сюда придут бонусы героев и технологий по типам; сейчас -- 0 (ТЕСТ, можно менять в MarchConfig)
|
||||
public int[] TypeBonusPercent = { 0, 0, 0, 0 };
|
||||
|
||||
// Общий модификатор войска, в процентах -- применяется один раз ко всему войску
|
||||
public int ArmyBonusPercent = 0;
|
||||
|
||||
public static MarchSpeedRules Default => new MarchSpeedRules();
|
||||
|
||||
// Скорость войска как точная дробь num / den (милли-единиц в час). Состав неизвестен (старый поход) -- как у пехоты.
|
||||
void Speed(int[] units, out BigInteger num, out BigInteger den)
|
||||
{
|
||||
num = BigInteger.Zero;
|
||||
long count = 0;
|
||||
for (int i = 0; units != null && i < units.Length && i < SpeedMilliPerHour.Length; i++)
|
||||
{
|
||||
if (units[i] <= 0) continue;
|
||||
num += (BigInteger)units[i] * Math.Max(1, SpeedMilliPerHour[i]) * TypeFactor(i);
|
||||
count += units[i];
|
||||
}
|
||||
if (count == 0)
|
||||
{
|
||||
num = (BigInteger)Math.Max(1, SpeedMilliPerHour[TroopType.Infantry]) * TypeFactor(TroopType.Infantry);
|
||||
count = 1;
|
||||
}
|
||||
num *= Math.Max(1, 100 + ArmyBonusPercent);
|
||||
den = (BigInteger)count * 100 * 100;
|
||||
if (num.IsZero) num = BigInteger.One;
|
||||
}
|
||||
|
||||
int TypeFactor(int type)
|
||||
{
|
||||
int bonus = TypeBonusPercent != null && type < TypeBonusPercent.Length ? TypeBonusPercent[type] : 0;
|
||||
return Math.Max(1, 100 + bonus); // скорость не бывает нулевой или отрицательной
|
||||
}
|
||||
|
||||
// Скорость войска данного состава, милли-единиц за реальный час (округлено вниз -- только для показа)
|
||||
public long SpeedFor(int[] units)
|
||||
{
|
||||
Speed(units, out BigInteger num, out BigInteger den);
|
||||
return Math.Max(1, (long)(num / den));
|
||||
}
|
||||
|
||||
// Время в пути в реальных миллисекундах: расстояние / скорость, одно округление вниз в самом конце
|
||||
public long TravelTimeMs(MapNode from, MapNode to, int[] units)
|
||||
{
|
||||
Speed(units, out BigInteger num, out BigInteger den);
|
||||
return (long)((BigInteger)WorldMapLayout.Distance(from, to) * 3_600_000 * den / num);
|
||||
}
|
||||
}
|
||||
|
||||
public static class MarchRules
|
||||
{
|
||||
// Скорость войска: 400 милли-единиц (0,4 клетки) в секунду.
|
||||
// Ближний сосед (~4 клетки) -- около 10 сек, замок (~10 клеток) -- около 25 сек, край карты -- до минуты.
|
||||
public const int SpeedPerSecond = 400;
|
||||
|
||||
// Время в пути войска без известного состава (как у пехоты) при скоростях по умолчанию.
|
||||
// Для настоящего похода -- WorldSimulation.TravelTimeMs: скорости из таблицы MarchConfig и состав войска.
|
||||
public static long GetTravelTimeMs(MapNode from, MapNode to)
|
||||
{
|
||||
return (long)WorldMapLayout.Distance(from, to) * 1000 / SpeedPerSecond;
|
||||
return MarchSpeedRules.Default.TravelTimeMs(from, to, null);
|
||||
}
|
||||
}
|
||||
|
||||
public static class CampRules
|
||||
{
|
||||
// Разбитый лагерь появляется снова через 30 минут (требует балансировки)
|
||||
// Разбитый лагерь появляется снова через 30 РЕАЛЬНЫХ минут после боя (план от 27.10.2026: "30 реальных минут"). ТЕСТ.
|
||||
public const long RespawnMs = 30L * 60 * 1000;
|
||||
}
|
||||
|
||||
@@ -73,34 +146,62 @@ namespace Bogatyri.World
|
||||
public enum WorldEventType
|
||||
{
|
||||
BattleResolved, // войско дошло, бой прошёл
|
||||
MarchReturned // войско вернулось домой
|
||||
MarchReturned, // войско вернулось домой
|
||||
GatherStarted, // войско дошло до ресурсной точки и начало сбор (или точка исчезла -- targetEmpty)
|
||||
GatherFinished, // сбор закончен, войско идёт домой с грузом
|
||||
ScoutArrived, // разведка дошла до цели: повернула домой или (М2) начала наблюдение (targetEmpty -- цели уже нет)
|
||||
ReconCompleted // М2: наблюдение закончено -- пора составить отчёт, разведчики идут домой
|
||||
}
|
||||
|
||||
public struct WorldEvent
|
||||
{
|
||||
public WorldEventType Type;
|
||||
public MarchData March;
|
||||
public long TimeMs; // когда событие случилось по часам игры (а не когда его заметили)
|
||||
}
|
||||
|
||||
// Состояние мира: карта + походы. Не зависит от Unity -- в мультиплеере этот же код крутится на сервере,
|
||||
// а клиент только показывает то, что он вернул.
|
||||
public sealed class WorldSimulation
|
||||
public sealed partial class WorldSimulation
|
||||
{
|
||||
private readonly List<MapNode> nodes;
|
||||
private readonly IBattleSystem battleSystem;
|
||||
private readonly List<MarchData> marches = new List<MarchData>();
|
||||
private readonly Dictionary<string, long> campRespawn = new Dictionary<string, long>(); // id лагеря -> когда появится
|
||||
private readonly List<MarchData> arrivals = new List<MarchData>();
|
||||
private int nextMarchId = 1;
|
||||
|
||||
public IReadOnlyList<MapNode> Nodes => nodes;
|
||||
public IReadOnlyList<MarchData> Marches => marches;
|
||||
|
||||
// Бой считает модуль Боевой системы -- Мир получает его через контракт, а не знает формулу сам
|
||||
public WorldSimulation(List<MapNode> nodes, IBattleSystem battleSystem)
|
||||
private readonly MarchSpeedRules speeds;
|
||||
public MarchSpeedRules Speeds => speeds;
|
||||
|
||||
// Бой считает модуль Боевой системы -- Мир получает его через контракт, а не знает формулу сам.
|
||||
// Скорости маршей -- из таблицы (в игре MarchConfig), без неё -- значения регламента по умолчанию.
|
||||
public WorldSimulation(List<MapNode> nodes, IBattleSystem battleSystem, MarchSpeedRules speeds = null,
|
||||
ResourcePointRules pointRules = null, int seed = WorldMapLayout.DefaultSeed)
|
||||
{
|
||||
this.nodes = nodes;
|
||||
this.battleSystem = battleSystem;
|
||||
this.speeds = speeds ?? MarchSpeedRules.Default;
|
||||
this.pointRules = pointRules ?? ResourcePointRules.Default;
|
||||
this.pointSeed = seed;
|
||||
}
|
||||
|
||||
// Время в пути войска данного состава (реальные миллисекунды)
|
||||
public long TravelTimeMs(MapNode from, MapNode to, int[] units)
|
||||
{
|
||||
return speeds.TravelTimeMs(from, to, units);
|
||||
}
|
||||
|
||||
// Состав похода стал известен (Армия забрала воинов): время прихода пересчитывается по скорости состава.
|
||||
// Только пока войско в пути и ещё не дошло -- после боя время уже не меняется.
|
||||
public bool AssignUnits(MarchData m, int[] units)
|
||||
{
|
||||
if (m == null || m.state != MarchState.Outbound || !marches.Contains(m)) return false;
|
||||
m.units = units;
|
||||
m.arriveMs = m.departMs + TravelTimeMs(GetNode(m.fromNodeId), GetNode(m.targetNodeId), units);
|
||||
return true;
|
||||
}
|
||||
|
||||
// Состояние войска нападающего на момент боя (голод в его поселении, усталость).
|
||||
@@ -159,19 +260,26 @@ namespace Bogatyri.World
|
||||
|
||||
// ---------------- Походы ----------------
|
||||
|
||||
public MarchData StartMarch(string ownerId, string fromId, string targetId, int soldiers, long nowMs, out string error)
|
||||
// scout -- поход «Разведка»: к любой цели, кроме своего города; без боя, без сбора, разбитый лагерь и занятая точка не мешают
|
||||
public MarchData StartMarch(string ownerId, string fromId, string targetId, int soldiers, long nowMs, out string error, bool scout = false)
|
||||
{
|
||||
MapNode from = GetNode(fromId);
|
||||
MapNode target = GetNode(targetId);
|
||||
|
||||
if (from == null || target == null) { error = "Неизвестная точка на карте"; return null; }
|
||||
if (target == from || !target.canBeAttacked) { error = $"На {target.displayName} нападать нельзя"; return null; }
|
||||
if (target.type == MapNodeType.Camp && IsCampCleared(targetId, nowMs))
|
||||
if (!scout && target.type == MapNodeType.Camp && IsCampCleared(targetId, nowMs))
|
||||
{
|
||||
error = $"{target.displayName} уже разбит. Появится снова через {(CampRespawnInMs(targetId, nowMs) + 59_999) / 60_000} мин";
|
||||
return null;
|
||||
}
|
||||
if (soldiers <= 0) { error = "Нужно отправить хотя бы одного солдата"; return null; }
|
||||
if (target.type == MapNodeType.ResourcePoint && !scout && !CanGatherAt(targetId, nowMs, out error)) return null;
|
||||
if (target.type == MapNodeType.ResourcePoint && scout)
|
||||
{
|
||||
ResourcePoint rp = GetPoint(targetId);
|
||||
if (rp == null || !rp.active || nowMs >= rp.expireMs) { error = "Этой ресурсной точки больше нет"; return null; }
|
||||
}
|
||||
|
||||
var march = new MarchData
|
||||
{
|
||||
@@ -182,8 +290,11 @@ namespace Bogatyri.World
|
||||
soldiers = soldiers,
|
||||
survivors = soldiers,
|
||||
departMs = nowMs,
|
||||
arriveMs = nowMs + MarchRules.GetTravelTimeMs(from, target),
|
||||
state = MarchState.Outbound
|
||||
arriveMs = nowMs + TravelTimeMs(from, target, null), // состав уточнит AssignUnits
|
||||
state = MarchState.Outbound,
|
||||
gather = !scout && target.type == MapNodeType.ResourcePoint,
|
||||
scout = scout,
|
||||
targetName = target.displayName
|
||||
};
|
||||
// Номер боя -- из данных похода: тот же поход всегда даёт тот же бой.
|
||||
// В мультиплеере его выдаёт сервер, иначе клиент мог бы подбирать удачный.
|
||||
@@ -208,27 +319,98 @@ namespace Bogatyri.World
|
||||
// может и дойти, и вернуться -- события придут в правильном порядке.
|
||||
public void Advance(long nowMs, List<WorldEvent> events)
|
||||
{
|
||||
// Бои -- в порядке прихода войск: кто первым дошёл до лагеря, тот его и разбил
|
||||
arrivals.Clear();
|
||||
foreach (var m in marches)
|
||||
if (m.state == MarchState.Outbound && nowMs >= m.arriveMs) arrivals.Add(m);
|
||||
arrivals.Sort((a, b) => a.arriveMs != b.arriveMs ? a.arriveMs.CompareTo(b.arriveMs) : a.id.CompareTo(b.id));
|
||||
foreach (var m in arrivals)
|
||||
{
|
||||
ResolveBattle(m);
|
||||
events.Add(new WorldEvent { Type = WorldEventType.BattleResolved, March = m });
|
||||
}
|
||||
EnsureResourcePoints(nowMs); // первая игра: ресурсные точки появляются на карте
|
||||
SpawnPatrolsUntil(nowMs); // патрули-заглушки соседей (если включены)
|
||||
|
||||
foreach (var m in marches)
|
||||
// События -- строго по времени (документ 02: офлайн в причинно-следственном порядке).
|
||||
// Каждый раз берётся самое раннее: приход к цели (бой или начало сбора), конец сбора,
|
||||
// исчезновение ресурсной точки или возвращение домой. Событие назначает следующее время похода,
|
||||
// поэтому за один вызов поход может дойти, собрать и вернуться. Кто первым дошёл до лагеря или точки --
|
||||
// того и цель. При равном времени: приход, конец сбора, исчезновение точки, возвращение; затем по номеру.
|
||||
while (true)
|
||||
{
|
||||
if (m.state == MarchState.Returning && nowMs >= m.returnMs)
|
||||
MarchData next = null;
|
||||
ResourcePoint expiring = null;
|
||||
long nextMs = 0;
|
||||
int nextKind = int.MaxValue;
|
||||
int nextId = int.MaxValue;
|
||||
foreach (var m in marches)
|
||||
{
|
||||
m.state = MarchState.Finished;
|
||||
events.Add(new WorldEvent { Type = WorldEventType.MarchReturned, March = m });
|
||||
int kind;
|
||||
long at;
|
||||
if (m.state == MarchState.Outbound) { kind = 0; at = m.arriveMs; }
|
||||
else if (m.state == MarchState.Gathering) { kind = 1; at = m.gatherEndMs; }
|
||||
else if (m.state == MarchState.Returning) { kind = 3; at = m.returnMs; }
|
||||
else continue;
|
||||
if (at > nowMs) continue;
|
||||
if (next == null && expiring == null || at < nextMs || at == nextMs && (kind < nextKind || kind == nextKind && m.id < nextId))
|
||||
{
|
||||
next = m; expiring = null; nextMs = at; nextKind = kind; nextId = m.id;
|
||||
}
|
||||
}
|
||||
foreach (var p in points)
|
||||
{
|
||||
// Точка без войска исчезает в срок (с войском -- её срок уже учтён в конце сбора)
|
||||
if (!p.active || p.occupiedBy != 0 || p.expireMs > nowMs) continue;
|
||||
if (next == null && expiring == null || p.expireMs < nextMs || p.expireMs == nextMs && 2 < nextKind)
|
||||
{
|
||||
next = null; expiring = p; nextMs = p.expireMs; nextKind = 2; nextId = int.MaxValue;
|
||||
}
|
||||
}
|
||||
if (next == null && expiring == null) break;
|
||||
|
||||
if (expiring != null)
|
||||
{
|
||||
RetirePoint(expiring, nextMs);
|
||||
}
|
||||
else if (next.patrol)
|
||||
{
|
||||
// Патруль: дошёл -- повернул обратно, вернулся -- исчез. Событий для игрока нет
|
||||
next.state = nextKind == 0 ? MarchState.Returning : MarchState.Finished;
|
||||
}
|
||||
else if (next.scout)
|
||||
{
|
||||
// Разведка: дошла -- повернула домой (Разведка видит всё вокруг войска по пути и у цели), вернулась -- дома
|
||||
if (nextKind == 0)
|
||||
{
|
||||
ArriveScout(next);
|
||||
events.Add(new WorldEvent { Type = WorldEventType.ScoutArrived, March = next, TimeMs = nextMs });
|
||||
}
|
||||
else if (nextKind == 1)
|
||||
{
|
||||
next.state = MarchState.Returning; // наблюдение закончено, обратный путь уже рассчитан
|
||||
events.Add(new WorldEvent { Type = WorldEventType.ReconCompleted, March = next, TimeMs = nextMs });
|
||||
}
|
||||
else
|
||||
{
|
||||
next.state = MarchState.Finished;
|
||||
events.Add(new WorldEvent { Type = WorldEventType.MarchReturned, March = next, TimeMs = nextMs });
|
||||
}
|
||||
}
|
||||
else if (nextKind == 0 && next.gather)
|
||||
{
|
||||
StartGather(next);
|
||||
events.Add(new WorldEvent { Type = WorldEventType.GatherStarted, March = next, TimeMs = nextMs });
|
||||
}
|
||||
else if (nextKind == 0)
|
||||
{
|
||||
ResolveBattle(next);
|
||||
events.Add(new WorldEvent { Type = WorldEventType.BattleResolved, March = next, TimeMs = nextMs });
|
||||
}
|
||||
else if (nextKind == 1)
|
||||
{
|
||||
FinishGather(next);
|
||||
events.Add(new WorldEvent { Type = WorldEventType.GatherFinished, March = next, TimeMs = nextMs });
|
||||
}
|
||||
else
|
||||
{
|
||||
next.state = MarchState.Finished;
|
||||
events.Add(new WorldEvent { Type = WorldEventType.MarchReturned, March = next, TimeMs = nextMs });
|
||||
}
|
||||
}
|
||||
|
||||
marches.RemoveAll(m => m.state == MarchState.Finished);
|
||||
PurgeRetiredPoints();
|
||||
|
||||
// Лагеря, которые уже появились снова, больше не нужно помнить
|
||||
expiredCamps.Clear();
|
||||
@@ -244,7 +426,7 @@ namespace Bogatyri.World
|
||||
MapNode target = GetNode(m.targetNodeId);
|
||||
|
||||
// Обратный путь отсчитывается от момента боя, а не от "сейчас" -- важно для офлайна
|
||||
m.returnMs = m.arriveMs + MarchRules.GetTravelTimeMs(target, from);
|
||||
m.returnMs = m.arriveMs + TravelTimeMs(target, from, HasUnits(m) ? m.units : null);
|
||||
m.state = MarchState.Returning;
|
||||
m.loot = new List<RewardEntry>();
|
||||
|
||||
@@ -280,6 +462,10 @@ namespace Bogatyri.World
|
||||
m.victory = outcome.Victory;
|
||||
m.survivors = outcome.Survivors;
|
||||
m.survivorUnits = HasUnits(m) ? outcome.AttackerSurvivorUnits : null;
|
||||
m.woundedUnits = HasUnits(m) ? outcome.AttackerWoundedUnits : null; // старый поход без состава -- раненые как погибшие
|
||||
m.missingUnits = HasUnits(m) ? outcome.AttackerMissingUnits : null;
|
||||
if (m.survivors > 0) // обратно идут выжившие -- со скоростью своего состава
|
||||
m.returnMs = m.arriveMs + TravelTimeMs(target, from, m.survivorUnits ?? (HasUnits(m) ? m.units : null));
|
||||
m.defenders = target.garrison;
|
||||
m.defenderLosses = outcome.DefenderLosses;
|
||||
// Гарнизон соседа пока не меняется: соседи -- заглушки. Когда они станут реальными игроками,
|
||||
@@ -294,6 +480,47 @@ namespace Bogatyri.World
|
||||
}
|
||||
}
|
||||
|
||||
// Разведка у цели: боя, сбора и потерь нет -- все идут домой тем же составом. Цели уже нет (точка исчезла) --
|
||||
// дошли до места и вернулись физически, без телепортации (решения 31.10, п. 2)
|
||||
void ArriveScout(MarchData m)
|
||||
{
|
||||
MapNode from = GetNode(m.fromNodeId);
|
||||
MapNode target = GetNode(m.targetNodeId);
|
||||
int[] units = HasUnits(m) ? m.units : null;
|
||||
m.returnMs = m.arriveMs + TravelTimeMs(target, from, units);
|
||||
m.state = MarchState.Returning;
|
||||
m.victory = false;
|
||||
m.survivors = m.soldiers;
|
||||
m.survivorUnits = units != null ? (int[])units.Clone() : null;
|
||||
m.loot = new List<RewardEntry>();
|
||||
ResourcePoint p = target.type == MapNodeType.ResourcePoint ? GetPoint(target.id) : null;
|
||||
m.targetEmpty = target.type == MapNodeType.ResourcePoint && (p == null || !p.active);
|
||||
|
||||
// М2: разведчики стоят у цели время наблюдения, потом идут домой (обратный путь -- от конца наблюдения)
|
||||
if (m.reconLevel > 0 && m.reconHoldMs > 0 && !m.targetEmpty)
|
||||
{
|
||||
m.state = MarchState.Gathering;
|
||||
m.gatherEndMs = m.arriveMs + m.reconHoldMs;
|
||||
m.returnMs = m.gatherEndMs + TravelTimeMs(target, from, units);
|
||||
}
|
||||
}
|
||||
|
||||
// Разведка с отчётом (М2): уровень и время наблюдения. Только пока разведчики ещё в пути к цели
|
||||
public bool SetRecon(MarchData m, int level, long holdMs)
|
||||
{
|
||||
if (m == null || !m.scout || m.state != MarchState.Outbound || !marches.Contains(m)) return false;
|
||||
m.reconLevel = level;
|
||||
m.reconHoldMs = Math.Max(0, holdMs);
|
||||
return true;
|
||||
}
|
||||
|
||||
// Название цели похода: запомненное при выступлении (старые походы -- с карты)
|
||||
public string TargetName(MarchData m)
|
||||
{
|
||||
if (!string.IsNullOrEmpty(m.targetName)) return m.targetName;
|
||||
return GetNode(m.targetNodeId)?.displayName ?? "";
|
||||
}
|
||||
|
||||
// Номер боя из данных похода (FNV-1a) -- одинаков на любой платформе
|
||||
public static long BattleSeed(int marchId, long departMs, string targetId)
|
||||
{
|
||||
@@ -328,11 +555,19 @@ namespace Bogatyri.World
|
||||
start = m.departMs;
|
||||
end = m.arriveMs;
|
||||
}
|
||||
else if (m.state == MarchState.Gathering)
|
||||
{
|
||||
// Войско стоит на точке и собирает
|
||||
segmentFrom = target;
|
||||
segmentTo = home;
|
||||
progress = 0;
|
||||
return;
|
||||
}
|
||||
else
|
||||
{
|
||||
segmentFrom = target;
|
||||
segmentTo = home;
|
||||
start = m.arriveMs;
|
||||
start = m.gather || m.reconLevel > 0 && m.gatherEndMs > 0 ? m.gatherEndMs : m.arriveMs; // после сбора / наблюдения -- от его конца
|
||||
end = m.returnMs;
|
||||
}
|
||||
|
||||
|
||||
@@ -31,13 +31,20 @@ public static class MarchReturnPopup
|
||||
showing = true;
|
||||
|
||||
MarchReturnedEvent e = queue.Dequeue();
|
||||
string target = string.IsNullOrEmpty(e.TargetName) ? "поход" : $"Поход на «{e.TargetName}»";
|
||||
string result = e.TargetEmpty ? "лагерь уже был разбит, боя не было"
|
||||
string target = string.IsNullOrEmpty(e.TargetName) ? "поход"
|
||||
: (e.IsScout ? "Разведка" : e.IsGather ? "Сбор" : "Поход на") + $" «{e.TargetName}»";
|
||||
string result = e.IsScout
|
||||
? (e.TargetEmpty ? "цели уже не было" : "<color=#7CD67C>цель разведана</color>")
|
||||
: e.IsGather
|
||||
? (e.TargetEmpty ? "точки уже не было или её заняли, сбора не было" : "<color=#7CD67C>ресурсы собраны</color>")
|
||||
: e.TargetEmpty ? "лагерь уже был разбит, боя не было"
|
||||
: e.Victory ? "<color=#7CD67C>победа</color>" : "<color=#E06A5A>поражение</color>";
|
||||
int lost = Mathf.Max(0, e.Sent - e.Survivors);
|
||||
int dead = Mathf.Max(0, e.Sent - e.Survivors - e.Wounded - e.Missing);
|
||||
|
||||
string text = $"{target}: {result}\n" +
|
||||
$"Вернулись {e.Survivors} из {e.Sent} воинов" + (lost > 0 ? $" (погибли {lost})" : "") + "\n" +
|
||||
$"Вернулись {e.Survivors} из {e.Sent} воинов" + (dead > 0 ? $" (погибли {dead})" : "") + "\n" +
|
||||
(e.Wounded > 0 ? $"Раненых {e.Wounded} -- в госпитале (окно «Войска»)\n" : "") +
|
||||
(e.Missing > 0 ? $"Пропали без вести {e.Missing} -- часть может вернуться сама\n" : "") +
|
||||
$"Добыча: {e.LootText}";
|
||||
|
||||
UIKit.Message("ВОЙСКО ВЕРНУЛОСЬ", text, "ОК", ShowNext);
|
||||
|
||||
@@ -0,0 +1,204 @@
|
||||
using System.Collections.Generic;
|
||||
using Bogatyri.World;
|
||||
using TMPro;
|
||||
using UnityEngine;
|
||||
using UnityEngine.UI;
|
||||
|
||||
// Окно «Армии» (слой приложения): где каждое войско игрока, что делает, состав, груз и сколько ждать.
|
||||
// Регламент 31.10, раздел 7: «Панель армий нужна всем игрокам: местонахождение, действие, состав, груз,
|
||||
// время марша, добычи и ожидаемого возвращения». Данные -- модули Мира (походы) и Армии (дома, гарнизон, слоты).
|
||||
// Документ: Docs/Modules/World.md
|
||||
//
|
||||
// Открыть: ArmiesWindow.Open() -- кнопка «Армии» на карте мира. Таймеры обновляются сами, пока окно открыто.
|
||||
public static class ArmiesWindow
|
||||
{
|
||||
const float ListHeight = 620f;
|
||||
|
||||
static GameObject root;
|
||||
|
||||
public static bool IsOpen => root != null;
|
||||
|
||||
public static void Open()
|
||||
{
|
||||
Close();
|
||||
if (MarchManager.Instance == null) return;
|
||||
RectTransform card = UIKit.Modal("Армии", out root);
|
||||
var view = root.AddComponent<ArmiesView>();
|
||||
view.Build(card);
|
||||
|
||||
var close = UIKit.Button(card, "Закрыть", UIKit.Theme.Gray, Close, -1, 90, 30);
|
||||
UIKit.Size(close, -1, 90);
|
||||
}
|
||||
|
||||
public static void Close()
|
||||
{
|
||||
if (root != null) Object.Destroy(root);
|
||||
root = null;
|
||||
}
|
||||
|
||||
// Живая часть окна: строки походов обновляются 2 раза в секунду, список -- когда походы меняются
|
||||
class ArmiesView : MonoBehaviour
|
||||
{
|
||||
TextMeshProUGUI summary;
|
||||
RectTransform list;
|
||||
readonly List<(int marchId, TextMeshProUGUI text)> rows = new List<(int, TextMeshProUGUI)>();
|
||||
string shownKey;
|
||||
float nextRefresh;
|
||||
|
||||
WorldSimulation World => MarchManager.Instance.World;
|
||||
|
||||
public void Build(RectTransform card)
|
||||
{
|
||||
summary = UIKit.Text(card, "", 30, UIKit.Theme.Text, TextAlignmentOptions.Center);
|
||||
var holder = UIKit.Make("ListHolder", card);
|
||||
UIKit.Size(holder, -1, ListHeight);
|
||||
list = UIKit.ScrollList(holder, out ScrollRect _, 10);
|
||||
Refresh();
|
||||
}
|
||||
|
||||
void Update()
|
||||
{
|
||||
if (Time.unscaledTime < nextRefresh) return;
|
||||
nextRefresh = Time.unscaledTime + 0.5f;
|
||||
Refresh();
|
||||
}
|
||||
|
||||
void Refresh()
|
||||
{
|
||||
long now = MarchManager.NowMs;
|
||||
var mine = new List<MarchData>();
|
||||
foreach (var m in World.Marches)
|
||||
if (m.ownerId == MarchManager.LocalPlayerId) mine.Add(m);
|
||||
|
||||
// Дома: свободные, гарнизон, слоты похода
|
||||
if (GameServices.TryGet(out IArmy army))
|
||||
summary.text = $"Дома свободно: {army.AvailableForMarch} • гарнизон: {army.GarrisonTotal} • " +
|
||||
$"походов: {army.ActiveMarches} из {army.MarchSlots}";
|
||||
|
||||
// Состав списка поменялся -- строим заново, иначе только обновляем тексты
|
||||
string key = string.Join(",", mine.ConvertAll(m => m.id + ":" + (int)m.state));
|
||||
if (key != shownKey)
|
||||
{
|
||||
shownKey = key;
|
||||
UIKit.Clear(list);
|
||||
rows.Clear();
|
||||
if (mine.Count == 0)
|
||||
UIKit.Text(list, "Все войска дома. Отправьте войско: нажмите на цель на карте.", 26, UIKit.Theme.TextDim, TextAlignmentOptions.Center);
|
||||
foreach (var m in mine)
|
||||
{
|
||||
var row = UIKit.Row(list, 200, 16, UIKit.Theme.Card, 16); // крупно -- читается на телефоне
|
||||
UIKit.Icon(row, StateColor(m), StateLetter(m), 96);
|
||||
var text = UIKit.Text(row, "", 28, UIKit.Theme.Text);
|
||||
UIKit.Size(text, -1, 188, 1);
|
||||
rows.Add((m.id, text));
|
||||
}
|
||||
}
|
||||
|
||||
foreach (var (id, text) in rows)
|
||||
{
|
||||
MarchData m = mine.Find(x => x.id == id);
|
||||
if (m != null) text.text = Describe(m, now);
|
||||
}
|
||||
}
|
||||
|
||||
// Четыре строки: куда и что делает, состав, груз, сколько ждать
|
||||
string Describe(MarchData m, long now)
|
||||
{
|
||||
string target = World.TargetName(m);
|
||||
int soldiers = m.state == MarchState.Returning ? m.survivors : m.soldiers;
|
||||
int[] units = m.state == MarchState.Returning && m.survivorUnits != null ? m.survivorUnits : m.units;
|
||||
|
||||
string action;
|
||||
string timer;
|
||||
switch (m.state)
|
||||
{
|
||||
case MarchState.Outbound:
|
||||
action = m.scout ? $"идёт в разведку: <b>{target}</b>"
|
||||
: m.gather ? $"идёт на сбор: <b>{target}</b>" : $"идёт в бой: <b>{target}</b>";
|
||||
timer = $"до цели {Clock(m.arriveMs - now)}, вернётся примерно через {Clock(ExpectedReturn(m) - now)}";
|
||||
break;
|
||||
case MarchState.Gathering:
|
||||
action = m.scout ? $"наблюдает за: <b>{target}</b> (разведка {(m.reconLevel == 3 ? "III" : "II")})" : $"собирает: <b>{target}</b>";
|
||||
timer = $"сбор ещё {Clock(m.gatherEndMs - now)}, вернётся через {Clock(ExpectedReturn(m) - now)}";
|
||||
break;
|
||||
default:
|
||||
action = (m.scout ? "возвращается из разведки: " : m.gather ? "возвращается со сбора: "
|
||||
: m.victory ? "возвращается с победой: " : "возвращается: ") + $"<b>{target}</b>";
|
||||
timer = $"дома через {Clock(m.returnMs - now)}";
|
||||
break;
|
||||
}
|
||||
|
||||
string cargo = m.state == MarchState.Outbound
|
||||
? (m.gather ? "груз: будет известен на точке" : "груз: нет")
|
||||
: "груз: " + MarchManager.FormatLoot(m.state == MarchState.Gathering ? CargoAsLoot(m) : m.loot);
|
||||
|
||||
return $"{action}\n" +
|
||||
$"<color=#C8C8C8>{soldiers} воинов: {UnitsText(units)}</color>\n" +
|
||||
$"<color=#C8C8C8>{cargo}</color>\n" +
|
||||
$"<color=#E8C15A>{timer}</color>";
|
||||
}
|
||||
|
||||
// Когда войско будет дома: после боя -- обратный путь, после сбора -- сбор и обратный путь
|
||||
long ExpectedReturn(MarchData m)
|
||||
{
|
||||
if (m.state == MarchState.Returning) return m.returnMs;
|
||||
MapNode home = World.GetNode(m.fromNodeId);
|
||||
MapNode target = World.GetNode(m.targetNodeId);
|
||||
if (home == null || target == null) return m.returnMs;
|
||||
if (m.state == MarchState.Gathering) return m.gatherEndMs + World.TravelTimeMs(target, home, m.units);
|
||||
long gather = 0;
|
||||
if (m.gather)
|
||||
{
|
||||
World.PreviewGather(m.targetNodeId, m.units, m.arriveMs, out _, out gather);
|
||||
}
|
||||
return m.arriveMs + gather + World.TravelTimeMs(target, home, m.units); // после боя -- если все живы
|
||||
}
|
||||
|
||||
List<RewardEntry> CargoAsLoot(MarchData m)
|
||||
{
|
||||
ResourcePoint p = World.GetPoint(m.targetNodeId);
|
||||
var loot = new List<RewardEntry>();
|
||||
if (p != null && m.cargo > 0) loot.Add(new RewardEntry { resource = ResourcePointRules.Resources[p.kind], amount = m.cargo });
|
||||
return loot;
|
||||
}
|
||||
|
||||
static string UnitsText(int[] u)
|
||||
{
|
||||
if (u == null || u.Length < TroopType.Count) return "состав неизвестен";
|
||||
var parts = new List<string>();
|
||||
if (u[TroopType.Infantry] > 0) parts.Add($"пех. {u[TroopType.Infantry]}");
|
||||
if (u[TroopType.Archers] > 0) parts.Add($"луч. {u[TroopType.Archers]}");
|
||||
if (u[TroopType.Cavalry] > 0) parts.Add($"кав. {u[TroopType.Cavalry]}");
|
||||
if (u[TroopType.Siege] > 0) parts.Add($"осад. {u[TroopType.Siege]}");
|
||||
return parts.Count > 0 ? string.Join(", ", parts) : "никого";
|
||||
}
|
||||
|
||||
// Реальное время: «1 ч 05 мин», меньше часа -- «12:30»
|
||||
static string Clock(long ms)
|
||||
{
|
||||
long sec = System.Math.Max(0, (ms + 999) / 1000);
|
||||
if (sec >= 3600) return $"{sec / 3600} ч {sec / 60 % 60:00} мин";
|
||||
return $"{sec / 60}:{sec % 60:00}";
|
||||
}
|
||||
|
||||
static Color StateColor(MarchData m)
|
||||
{
|
||||
switch (m.state)
|
||||
{
|
||||
case MarchState.Outbound: return m.scout ? new Color(0.45f, 0.45f, 0.55f) : m.gather ? new Color(0.25f, 0.55f, 0.3f) : new Color(0.7f, 0.25f, 0.2f);
|
||||
case MarchState.Gathering: return new Color(0.75f, 0.6f, 0.15f);
|
||||
default: return new Color(0.25f, 0.45f, 0.75f);
|
||||
}
|
||||
}
|
||||
|
||||
static string StateLetter(MarchData m)
|
||||
{
|
||||
switch (m.state)
|
||||
{
|
||||
case MarchState.Outbound: return m.scout ? "Р" : m.gather ? "С" : "Б"; // разведка / на сбор / в бой
|
||||
case MarchState.Gathering: return "Д"; // добыча
|
||||
default: return "В"; // возвращается
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
fileFormatVersion: 2
|
||||
guid: aae71fe15d5b42cabbc00038dab0e9fe
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -0,0 +1,158 @@
|
||||
using System.Collections.Generic;
|
||||
using Bogatyri.World;
|
||||
using TMPro;
|
||||
using UnityEngine;
|
||||
|
||||
// Разведка на карте мира (М1): туман войны и чужие армии. Правил тут нет -- всё знает модуль Разведки (IIntelligence),
|
||||
// здесь только рисуем то, что он вернул.
|
||||
//
|
||||
// Туман: неисследованное -- тёмное, исследованное -- притушено, в зоне обзора -- чисто.
|
||||
// 2.5D (04.11.2026): туман рисуется прямо в текстуре земли -- объекты (города, лагеря, точки) стоят над ней и видны всегда,
|
||||
// как требует решение 31.10, п. 1. hideUnexploredObjects в 3D пока только сильнее затемняет землю.
|
||||
// Чужие армии -- только те, что знает Разведка: в обзоре -- красные, с примерной численностью «~min–max»
|
||||
// и владельцем, если опознан; вышли из обзора -- бледная метка последнего контакта.
|
||||
public class IntelligenceOverlay : MonoBehaviour
|
||||
{
|
||||
static readonly Color ObservedColor = new Color(0.9f, 0.25f, 0.2f);
|
||||
static readonly Color GhostColor = new Color(0.75f, 0.55f, 0.55f); // бледная -- последний контакт
|
||||
static readonly Color GroundColor = new Color(0.3f, 0.42f, 0.25f);
|
||||
static readonly Color FogColor = new Color(0.04f, 0.055f, 0.08f);
|
||||
const float MarkerSize = 0.55f, MarkerHeight = 0.5f;
|
||||
const int CellSize = 1000;
|
||||
|
||||
private Transform mapRoot;
|
||||
private WorldSimulation world;
|
||||
private Texture2D fog;
|
||||
private Color32[] pixels;
|
||||
private int gridW, gridH;
|
||||
private float nextFogRefresh;
|
||||
private Renderer ground;
|
||||
private readonly Dictionary<string, (Renderer sprite, TextMeshPro label)> markers = new Dictionary<string, (Renderer, TextMeshPro)>();
|
||||
private readonly HashSet<string> alive = new HashSet<string>();
|
||||
private readonly List<string> stale = new List<string>();
|
||||
|
||||
public static IntelligenceOverlay Create(Transform mapRoot, WorldSimulation world, Renderer ground)
|
||||
{
|
||||
var go = new GameObject("Intelligence");
|
||||
go.transform.SetParent(mapRoot, false);
|
||||
var overlay = go.AddComponent<IntelligenceOverlay>();
|
||||
overlay.mapRoot = mapRoot;
|
||||
overlay.world = world;
|
||||
overlay.ground = ground;
|
||||
overlay.CreateFog();
|
||||
return overlay;
|
||||
}
|
||||
|
||||
void CreateFog()
|
||||
{
|
||||
gridW = (2 * WorldMapLayout.HalfWidth + CellSize - 1) / CellSize;
|
||||
gridH = (2 * WorldMapLayout.HalfHeight + CellSize - 1) / CellSize;
|
||||
fog = new Texture2D(gridW, gridH, TextureFormat.RGBA32, false)
|
||||
{
|
||||
filterMode = FilterMode.Bilinear, // мягкий край тумана
|
||||
wrapMode = TextureWrapMode.Clamp
|
||||
};
|
||||
pixels = new Color32[gridW * gridH];
|
||||
// 1 пиксель = 1 клетка карты; текстура натянута на всю землю (UV 0..1 -- от левого нижнего угла карты)
|
||||
if (ground != null)
|
||||
{
|
||||
if (ground.sharedMaterial.HasProperty("_BaseMap")) ground.sharedMaterial.SetTexture("_BaseMap", fog);
|
||||
if (ground.sharedMaterial.HasProperty("_MainTex")) ground.sharedMaterial.SetTexture("_MainTex", fog);
|
||||
}
|
||||
RefreshFog();
|
||||
}
|
||||
|
||||
void OnDestroy()
|
||||
{
|
||||
if (fog != null) Destroy(fog);
|
||||
}
|
||||
|
||||
void Update()
|
||||
{
|
||||
if (!GameServices.TryGet(out IIntelligence intel)) return;
|
||||
if (Time.unscaledTime >= nextFogRefresh)
|
||||
{
|
||||
nextFogRefresh = Time.unscaledTime + 0.5f;
|
||||
RefreshFog();
|
||||
}
|
||||
RefreshContacts(intel);
|
||||
}
|
||||
|
||||
void RefreshFog()
|
||||
{
|
||||
if (!GameServices.TryGet(out IIntelligence intel)) return;
|
||||
bool hide = IntelligenceConfig.Load().hideUnexploredObjects;
|
||||
byte unexplored = (byte)(hide ? 250 : 220), explored = 110;
|
||||
for (int cy = 0; cy < gridH; cy++)
|
||||
for (int cx = 0; cx < gridW; cx++)
|
||||
{
|
||||
int x = cx * CellSize + CellSize / 2 - WorldMapLayout.HalfWidth;
|
||||
int y = cy * CellSize + CellSize / 2 - WorldMapLayout.HalfHeight;
|
||||
MapVisibility v = intel.GetVisibility(x, y);
|
||||
byte a = v == MapVisibility.Observed ? (byte)0 : v == MapVisibility.Explored ? explored : unexplored;
|
||||
// трава разных оттенков (пятнами), поверх -- туман
|
||||
Color grass = Color.Lerp(GroundColor, new Color(0.42f, 0.55f, 0.3f), Mathf.PerlinNoise(cx * 0.35f, cy * 0.35f));
|
||||
Color c = Color.Lerp(grass, FogColor, a / 255f);
|
||||
c.a = 1f;
|
||||
pixels[cy * gridW + cx] = c;
|
||||
}
|
||||
fog.SetPixels32(pixels);
|
||||
fog.Apply(false);
|
||||
}
|
||||
|
||||
void RefreshContacts(IIntelligence intel)
|
||||
{
|
||||
long now = MarchManager.NowMs;
|
||||
alive.Clear();
|
||||
foreach (var c in intel.Contacts)
|
||||
{
|
||||
alive.Add(c.ArmyId);
|
||||
if (!markers.TryGetValue(c.ArmyId, out var m))
|
||||
{
|
||||
m = CreateMarker(c.ArmyId);
|
||||
markers[c.ArmyId] = m;
|
||||
}
|
||||
m.sprite.transform.position = new Vector3(c.X / 1000f, MarkerHeight / 2f, c.Y / 1000f);
|
||||
m.label.transform.position = new Vector3(c.X / 1000f, MarkerHeight + 0.8f, c.Y / 1000f);
|
||||
m.sprite.sharedMaterial = Map3D.Mat(c.Observed ? ObservedColor : GhostColor);
|
||||
|
||||
string owner = c.Identified ? OwnerName(c.OwnerId) : "чужая армия";
|
||||
m.label.text = c.Observed
|
||||
? $"{owner}\n~{c.ApproxMin}–{c.ApproxMax} воинов"
|
||||
: $"<color=#BBBBBB>{owner}, ~{c.ApproxMin}–{c.ApproxMax}\nконтакт {Ago(now - c.LastSeenMs)} назад</color>";
|
||||
}
|
||||
|
||||
// Метки армий, которых Разведка больше не знает (контакт устарел)
|
||||
stale.Clear();
|
||||
foreach (var id in markers.Keys) if (!alive.Contains(id)) stale.Add(id);
|
||||
foreach (var id in stale)
|
||||
{
|
||||
Destroy(markers[id].sprite.gameObject);
|
||||
Destroy(markers[id].label.gameObject);
|
||||
markers.Remove(id);
|
||||
}
|
||||
}
|
||||
|
||||
(Renderer, TextMeshPro) CreateMarker(string armyId)
|
||||
{
|
||||
var r = Map3D.Block(mapRoot, "Contact_" + armyId, PrimitiveType.Cube, ObservedColor, Vector3.zero, Vector2.one * MarkerSize, MarkerHeight);
|
||||
r.transform.rotation = Quaternion.Euler(0, 45, 0); // ромб-флажок: не путается со своими кубиками
|
||||
var label = Map3D.Label(mapRoot, "", Vector3.zero, 2.6f);
|
||||
label.gameObject.name = "ContactLabel_" + armyId;
|
||||
return (r, label);
|
||||
}
|
||||
|
||||
// Имя владельца -- по его поселению на карте («npc_3» -> «Велимир»)
|
||||
string OwnerName(string ownerId)
|
||||
{
|
||||
foreach (var n in world.Nodes)
|
||||
if (n.ownerId == ownerId && n.type == MapNodeType.NeighborCity) return n.displayName;
|
||||
return ownerId ?? "?";
|
||||
}
|
||||
|
||||
static string Ago(long ms)
|
||||
{
|
||||
long sec = System.Math.Max(0, ms) / 1000;
|
||||
return sec >= 60 ? $"{sec / 60} мин" : $"{sec} сек";
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,2 @@
|
||||
fileFormatVersion: 2
|
||||
guid: e626c469ca7a45b4ba5ad6b1a52cd5f9
|
||||
@@ -0,0 +1,297 @@
|
||||
using System.Collections.Generic;
|
||||
using TMPro;
|
||||
using UnityEngine;
|
||||
using UnityEngine.Rendering;
|
||||
using UnityEngine.Rendering.Universal;
|
||||
|
||||
// 3D НА ПРИМИТИВАХ: общие помощники для карты мира и 3D-поселения (переход на 2.5D, 04.11.2026).
|
||||
// Материал -- свой, на URP Lit (Resources/Map3D/Map3DLit.mat), цвета кешируются.
|
||||
// Свои простые формы (конус, пирамида, двускатная крыша) -- для деревьев, шатров, крыш.
|
||||
// Подписи (TextMeshPro) поворачиваются к камере (FaceCamera).
|
||||
public static class Map3D
|
||||
{
|
||||
static Material baseMaterial;
|
||||
static readonly Dictionary<Color, Material> materials = new Dictionary<Color, Material>();
|
||||
static Mesh cone, pyramid, roof;
|
||||
|
||||
// ---------------- Материалы ----------------
|
||||
|
||||
public static Material Mat(Color color)
|
||||
{
|
||||
if (baseMaterial == null)
|
||||
{
|
||||
// Свой материал на URP Lit (Resources/Map3D/Map3DLit): материал встроенных примитивов в 2D-проекте --
|
||||
// спрайтовый, без света и без цвета. Нет ассета -- ищем шейдер по имени
|
||||
var asset = Resources.Load<Material>("Map3D/Map3DLit");
|
||||
var shader = Shader.Find("Universal Render Pipeline/Lit");
|
||||
baseMaterial = asset != null ? new Material(asset) : shader != null ? new Material(shader) : null;
|
||||
if (baseMaterial == null)
|
||||
{
|
||||
var probe = GameObject.CreatePrimitive(PrimitiveType.Cube);
|
||||
baseMaterial = new Material(probe.GetComponent<Renderer>().sharedMaterial);
|
||||
Object.Destroy(probe);
|
||||
Debug.LogWarning("[3D] Нет материала Resources/Map3D/Map3DLit и шейдера URP Lit -- 3D будет без света");
|
||||
}
|
||||
materials.Clear();
|
||||
}
|
||||
if (!materials.TryGetValue(color, out var m) || m == null)
|
||||
{
|
||||
m = new Material(baseMaterial);
|
||||
SetColor(m, color);
|
||||
if (m.HasProperty("_Smoothness")) m.SetFloat("_Smoothness", 0.12f); // матовые, без пластикового блеска
|
||||
materials[color] = m;
|
||||
}
|
||||
return m;
|
||||
}
|
||||
|
||||
// URP берёт цвет из _BaseColor, встроенный шейдер -- из _Color: ставим оба
|
||||
public static void SetColor(Material m, Color color)
|
||||
{
|
||||
if (m.HasProperty("_BaseColor")) m.SetColor("_BaseColor", color);
|
||||
if (m.HasProperty("_Color")) m.SetColor("_Color", color);
|
||||
}
|
||||
|
||||
// Материал с текстурой (земля): своя копия, не из кеша
|
||||
public static Material TexturedMat(Texture texture)
|
||||
{
|
||||
var m = new Material(Mat(Color.white));
|
||||
if (m.HasProperty("_BaseMap")) m.SetTexture("_BaseMap", texture);
|
||||
if (m.HasProperty("_MainTex")) m.SetTexture("_MainTex", texture);
|
||||
return m;
|
||||
}
|
||||
|
||||
// ---------------- Простые формы ----------------
|
||||
|
||||
// Объект на земле: основание size.x * size.y (по X и Z), высота height, низ -- на уровне ground.y
|
||||
public static Renderer Block(Transform parent, string name, PrimitiveType type, Color color, Vector3 ground, Vector2 size, float height,
|
||||
bool collider = false)
|
||||
{
|
||||
var go = GameObject.CreatePrimitive(type);
|
||||
go.name = name;
|
||||
if (!collider) Object.Destroy(go.GetComponent<Collider>());
|
||||
go.transform.SetParent(parent, false);
|
||||
// У цилиндра высота -- 2 единицы при масштабе 1
|
||||
float scaleY = type == PrimitiveType.Cylinder || type == PrimitiveType.Capsule ? height / 2f : height;
|
||||
go.transform.localScale = new Vector3(size.x, scaleY, size.y);
|
||||
go.transform.position = ground + Vector3.up * height / 2f;
|
||||
var r = go.GetComponent<Renderer>();
|
||||
r.sharedMaterial = Mat(color);
|
||||
return r;
|
||||
}
|
||||
|
||||
// Своя форма (конус, пирамида, крыша): основание size.x * size.y, высота height, низ -- на ground
|
||||
public static Renderer Shape(Transform parent, string name, Mesh mesh, Color color, Vector3 ground, Vector2 size, float height, float yaw = 0f)
|
||||
{
|
||||
var go = new GameObject(name);
|
||||
go.transform.SetParent(parent, false);
|
||||
go.transform.position = ground;
|
||||
go.transform.rotation = Quaternion.Euler(0, yaw, 0);
|
||||
go.transform.localScale = new Vector3(size.x, height, size.y);
|
||||
go.AddComponent<MeshFilter>().sharedMesh = mesh;
|
||||
var r = go.AddComponent<MeshRenderer>();
|
||||
r.sharedMaterial = Mat(color);
|
||||
return r;
|
||||
}
|
||||
|
||||
// Конус: основание -- круг диаметром 1 на y = 0, вершина -- (0, 1, 0)
|
||||
public static Mesh Cone => cone != null ? cone : cone = BuildCone(10);
|
||||
// Пирамида: основание 1 x 1, вершина -- (0, 1, 0)
|
||||
public static Mesh Pyramid => pyramid != null ? pyramid : pyramid = BuildCone(4, 45f, 0.7071f);
|
||||
// Двускатная крыша: основание 1 x 1, конёк вдоль X на высоте 1
|
||||
public static Mesh Roof => roof != null ? roof : roof = BuildRoof();
|
||||
|
||||
static Mesh BuildCone(int sides, float startDeg = 0f, float radius = 0.5f)
|
||||
{
|
||||
var v = new List<Vector3>();
|
||||
var t = new List<int>();
|
||||
for (int i = 0; i < sides; i++)
|
||||
{
|
||||
float a0 = (startDeg + 360f * i / sides) * Mathf.Deg2Rad, a1 = (startDeg + 360f * (i + 1) / sides) * Mathf.Deg2Rad;
|
||||
Vector3 p0 = new Vector3(Mathf.Cos(a0) * radius, 0, Mathf.Sin(a0) * radius);
|
||||
Vector3 p1 = new Vector3(Mathf.Cos(a1) * radius, 0, Mathf.Sin(a1) * radius);
|
||||
TwoSided(v, t, p0, Vector3.up, p1); // бок -- свои вершины: грани с резкими нормалями
|
||||
TwoSided(v, t, p0, p1, Vector3.zero); // дно
|
||||
}
|
||||
var mesh = new Mesh { name = "Cone" + sides, vertices = v.ToArray(), triangles = t.ToArray() };
|
||||
mesh.RecalculateNormals();
|
||||
mesh.RecalculateBounds();
|
||||
return mesh;
|
||||
}
|
||||
|
||||
// Треугольник с обеих сторон: у каждой стороны свои вершины и своя нормаль
|
||||
static void TwoSided(List<Vector3> v, List<int> t, Vector3 p, Vector3 q, Vector3 r)
|
||||
{
|
||||
int i = v.Count;
|
||||
v.Add(p); v.Add(q); v.Add(r);
|
||||
t.Add(i); t.Add(i + 1); t.Add(i + 2);
|
||||
i = v.Count;
|
||||
v.Add(p); v.Add(r); v.Add(q);
|
||||
t.Add(i); t.Add(i + 1); t.Add(i + 2);
|
||||
}
|
||||
|
||||
static Mesh BuildRoof()
|
||||
{
|
||||
Vector3 a = new Vector3(-0.5f, 0, -0.5f), b = new Vector3(0.5f, 0, -0.5f), c = new Vector3(0.5f, 0, 0.5f), d = new Vector3(-0.5f, 0, 0.5f);
|
||||
Vector3 r0 = new Vector3(-0.5f, 1, 0), r1 = new Vector3(0.5f, 1, 0);
|
||||
var v = new List<Vector3>();
|
||||
var t = new List<int>();
|
||||
void Tri(Vector3 p, Vector3 q, Vector3 r) => TwoSided(v, t, p, q, r);
|
||||
Tri(a, r0, r1); Tri(a, r1, b); // скат к -Z
|
||||
Tri(c, r1, r0); Tri(c, r0, d); // скат к +Z
|
||||
Tri(d, r0, a); Tri(b, r1, c); // торцы
|
||||
Tri(a, b, c); Tri(a, c, d); // дно
|
||||
var mesh = new Mesh { name = "Roof", vertices = v.ToArray(), triangles = t.ToArray() };
|
||||
mesh.RecalculateNormals();
|
||||
mesh.RecalculateBounds();
|
||||
return mesh;
|
||||
}
|
||||
|
||||
// ---------------- Готовые фигуры ----------------
|
||||
|
||||
// Домик: стены w x d (по X и Z), высота стен h, двускатная крыша; поворот yaw
|
||||
public static Transform House(Transform parent, string name, Vector3 ground, float w, float d, float h, Color walls, Color roofColor, float yaw = 0f)
|
||||
{
|
||||
var root = new GameObject(name).transform;
|
||||
root.SetParent(parent, false);
|
||||
root.position = ground;
|
||||
root.rotation = Quaternion.Euler(0, yaw, 0);
|
||||
var body = Block(root, "Walls", PrimitiveType.Cube, walls, ground, new Vector2(w, d), h);
|
||||
body.transform.localPosition = new Vector3(0, h / 2f, 0);
|
||||
body.transform.localRotation = Quaternion.identity;
|
||||
var top = Shape(root, "Roof", Roof, roofColor, ground, new Vector2(w * 1.12f, d * 1.15f), Mathf.Max(0.25f, Mathf.Min(w, d) * 0.55f));
|
||||
top.transform.localPosition = new Vector3(0, h, 0);
|
||||
top.transform.localRotation = Quaternion.identity;
|
||||
return root;
|
||||
}
|
||||
|
||||
static readonly Color Trunk = new Color(0.42f, 0.28f, 0.16f);
|
||||
static readonly Color[] Leaves = { new Color(0.2f, 0.46f, 0.2f), new Color(0.26f, 0.52f, 0.22f), new Color(0.32f, 0.55f, 0.2f) };
|
||||
static readonly Color[] Pine = { new Color(0.12f, 0.36f, 0.22f), new Color(0.16f, 0.4f, 0.24f) };
|
||||
|
||||
// Дерево: ель (конусы) или лиственное (шар). variant -- для разнообразия, scale -- размер
|
||||
public static Transform Tree(Transform parent, string name, Vector3 ground, float scale, int variant)
|
||||
{
|
||||
var root = new GameObject(name).transform;
|
||||
root.SetParent(parent, false);
|
||||
root.position = ground;
|
||||
var trunk = Block(root, "Trunk", PrimitiveType.Cylinder, Trunk, ground, Vector2.one * 0.18f * scale, 0.6f * scale);
|
||||
if (variant % 3 == 0)
|
||||
{
|
||||
var crown = Block(root, "Crown", PrimitiveType.Sphere, Leaves[variant % Leaves.Length], ground + Vector3.up * 0.45f * scale,
|
||||
new Vector2(1.0f, 0.95f) * scale, 1.05f * scale);
|
||||
}
|
||||
else
|
||||
{
|
||||
Color c = Pine[variant % Pine.Length];
|
||||
Shape(root, "Pine1", Cone, c, ground + Vector3.up * 0.35f * scale, Vector2.one * 1.0f * scale, 1.0f * scale);
|
||||
Shape(root, "Pine2", Cone, c, ground + Vector3.up * 0.8f * scale, Vector2.one * 0.72f * scale, 0.85f * scale);
|
||||
}
|
||||
return root;
|
||||
}
|
||||
|
||||
static readonly Color[] Stones = { new Color(0.55f, 0.55f, 0.56f), new Color(0.5f, 0.48f, 0.45f), new Color(0.62f, 0.6f, 0.58f) };
|
||||
|
||||
// Валун: сплюснутый шар, повёрнутый случайно по variant
|
||||
public static Transform Rock(Transform parent, string name, Vector3 ground, float size, int variant)
|
||||
{
|
||||
var root = new GameObject(name).transform;
|
||||
root.SetParent(parent, false);
|
||||
root.position = ground;
|
||||
var r = Block(root, "Stone", PrimitiveType.Sphere, Stones[variant % Stones.Length], ground + Vector3.down * 0.1f * size,
|
||||
new Vector2(size, size * 0.85f), size * 0.65f);
|
||||
r.transform.rotation = Quaternion.Euler(variant * 7 % 20, variant * 53 % 360, 0);
|
||||
if (size > 1.2f)
|
||||
{
|
||||
var small = Block(root, "Stone2", PrimitiveType.Sphere, Stones[(variant + 1) % Stones.Length],
|
||||
ground + new Vector3(size * 0.4f, 0, size * 0.3f), Vector2.one * size * 0.45f, size * 0.35f);
|
||||
}
|
||||
return root;
|
||||
}
|
||||
|
||||
// Флаг на древке
|
||||
public static void Flag(Transform parent, Vector3 ground, float height, Color color)
|
||||
{
|
||||
Block(parent, "Pole", PrimitiveType.Cylinder, new Color(0.35f, 0.25f, 0.15f), ground, Vector2.one * 0.06f, height);
|
||||
var f = Block(parent, "Flag", PrimitiveType.Cube, color, ground + new Vector3(0.22f, height - 0.32f, 0), new Vector2(0.42f, 0.03f), 0.28f);
|
||||
}
|
||||
|
||||
// ---------------- Подписи, свет, рендерер ----------------
|
||||
|
||||
// Подпись над объектом, всегда лицом к камере
|
||||
public static TextMeshPro Label(Transform parent, string text, Vector3 position, float fontSize)
|
||||
{
|
||||
var go = new GameObject("Label");
|
||||
go.transform.SetParent(parent, false);
|
||||
go.transform.position = position;
|
||||
var tmp = go.AddComponent<TextMeshPro>();
|
||||
tmp.text = text;
|
||||
tmp.fontSize = fontSize;
|
||||
tmp.alignment = TextAlignmentOptions.Center;
|
||||
tmp.rectTransform.sizeDelta = new Vector2(6f, 1.6f);
|
||||
tmp.color = Color.white;
|
||||
tmp.outlineWidth = 0.25f;
|
||||
tmp.outlineColor = Color.black;
|
||||
go.AddComponent<FaceCamera>();
|
||||
return tmp;
|
||||
}
|
||||
|
||||
// Камере -- обычный 3D-рендерер URP (добавляет Tools -> Bogatyri -> 3D-город: создать сцену City3D).
|
||||
// Нет его -- остаётся рендерер по умолчанию, и в лог пишется, что делать.
|
||||
public static void UseRenderer3D(Camera cam)
|
||||
{
|
||||
var pipeline = (GraphicsSettings.currentRenderPipeline ?? QualitySettings.renderPipeline) as UniversalRenderPipelineAsset;
|
||||
var data = cam != null ? cam.GetUniversalAdditionalCameraData() : null;
|
||||
if (pipeline == null || data == null) return;
|
||||
var list = pipeline.rendererDataList;
|
||||
for (int i = 0; i < list.Length; i++)
|
||||
if (list[i] is UniversalRendererData) { data.SetRenderer(i); return; }
|
||||
Debug.LogWarning("[3D] В URP нет обычного 3D-рендерера: выполните Tools -> Bogatyri -> 3D-город: создать сцену City3D (он добавится). Без него 3D рисуется без света.");
|
||||
}
|
||||
|
||||
// Солнце, общий свет, небо и дымка вдали (2D-сцены света не имели)
|
||||
public static void SetUpLook(Camera cam, float fogStart, float fogEnd)
|
||||
{
|
||||
Light sun = null;
|
||||
foreach (var l in Object.FindObjectsByType<Light>(FindObjectsSortMode.None))
|
||||
if (l.type == LightType.Directional) { sun = l; break; }
|
||||
if (sun == null)
|
||||
{
|
||||
sun = new GameObject("Sun").AddComponent<Light>();
|
||||
sun.type = LightType.Directional;
|
||||
}
|
||||
sun.color = new Color(1f, 0.95f, 0.85f); // тёплое солнце
|
||||
sun.intensity = 1.25f;
|
||||
sun.shadows = LightShadows.Soft;
|
||||
sun.shadowStrength = 0.65f;
|
||||
sun.transform.rotation = Quaternion.Euler(48f, -35f, 0f);
|
||||
|
||||
RenderSettings.ambientMode = AmbientMode.Trilight; // небо голубое, горизонт светлый, снизу -- тёплая земля
|
||||
RenderSettings.ambientSkyColor = new Color(0.62f, 0.72f, 0.86f);
|
||||
RenderSettings.ambientEquatorColor = new Color(0.55f, 0.6f, 0.58f);
|
||||
RenderSettings.ambientGroundColor = new Color(0.35f, 0.32f, 0.25f);
|
||||
|
||||
Color sky = new Color(0.66f, 0.8f, 0.94f);
|
||||
RenderSettings.fog = true;
|
||||
RenderSettings.fogMode = FogMode.Linear;
|
||||
RenderSettings.fogColor = sky;
|
||||
RenderSettings.fogStartDistance = fogStart;
|
||||
RenderSettings.fogEndDistance = fogEnd;
|
||||
if (cam != null)
|
||||
{
|
||||
cam.clearFlags = CameraClearFlags.SolidColor;
|
||||
cam.backgroundColor = sky;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Подпись поворачивается к камере (наклонный вид 2.5D)
|
||||
public class FaceCamera : MonoBehaviour
|
||||
{
|
||||
static Camera cam;
|
||||
|
||||
void LateUpdate()
|
||||
{
|
||||
if (cam == null) cam = Camera.main;
|
||||
if (cam != null) transform.rotation = cam.transform.rotation;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
fileFormatVersion: 2
|
||||
guid: c36fcaa4cddf4c76ad06c759afc8301e
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -1,15 +1,22 @@
|
||||
using UnityEngine;
|
||||
using UnityEngine.EventSystems;
|
||||
|
||||
// Камера карты мира: перетаскивание (палец/мышь), зум (два пальца/колёсико), границы карты.
|
||||
// Камера карты мира, 2.5D (переход на 3D, 04.11.2026): наклонный вид под фиксированным углом, без вращения.
|
||||
// Перетаскивание (палец/мышь) двигает карту, два пальца/колёсико -- приближение, границы карты.
|
||||
// Отличает "тап" от "перетаскивания": тап -- это касание, при котором палец почти не сдвинулся.
|
||||
// Карта лежит на земле: координаты карты (x, y) -> мир (x, 0, y).
|
||||
[DefaultExecutionOrder(-10)] // считать тап раньше, чем его прочитает WorldMapController
|
||||
[RequireComponent(typeof(Camera))]
|
||||
public class MapCameraController : MonoBehaviour
|
||||
{
|
||||
[Header("Вид")]
|
||||
public float pitch = 55f; // наклон, градусы от горизонта
|
||||
public float yaw = 0f; // север карты -- вверху экрана, как было в 2D
|
||||
public float distance = 18f;
|
||||
|
||||
[Header("Зум")]
|
||||
public float minOrthoSize = 4f;
|
||||
public float maxOrthoSize = 16f;
|
||||
public float minDistance = 7f;
|
||||
public float maxDistance = 42f;
|
||||
public float mouseZoomSpeed = 2f;
|
||||
|
||||
[Header("Тап")]
|
||||
@@ -20,6 +27,7 @@ public class MapCameraController : MonoBehaviour
|
||||
[HideInInspector] public Vector2 mapHalfSize = new Vector2(20f, 14f);
|
||||
|
||||
private Camera cam;
|
||||
private Vector3 target; // точка на земле, на которую смотрит камера
|
||||
private Vector3 lastPointerPosition;
|
||||
private Vector3 pressPosition;
|
||||
private bool isPressed;
|
||||
@@ -31,9 +39,15 @@ public class MapCameraController : MonoBehaviour
|
||||
void Awake()
|
||||
{
|
||||
cam = GetComponent<Camera>();
|
||||
cam.orthographic = false;
|
||||
cam.fieldOfView = 40f;
|
||||
cam.nearClipPlane = 0.3f;
|
||||
cam.farClipPlane = 300f;
|
||||
Map3D.UseRenderer3D(cam);
|
||||
Apply();
|
||||
}
|
||||
|
||||
// Было ли за этот кадр нажатие по карте (не по UI и не перетаскивание)
|
||||
// Было ли за этот кадр нажатие по карте (не по UI и не перетаскивание). Точка -- на земле (x, 0, z)
|
||||
public bool TryGetTap(out Vector3 worldPosition)
|
||||
{
|
||||
worldPosition = tapWorldPosition;
|
||||
@@ -42,8 +56,9 @@ public class MapCameraController : MonoBehaviour
|
||||
|
||||
public void CenterOn(Vector3 worldPosition)
|
||||
{
|
||||
transform.position = new Vector3(worldPosition.x, worldPosition.y, transform.position.z);
|
||||
target = new Vector3(worldPosition.x, 0f, worldPosition.z);
|
||||
ClampToMap();
|
||||
Apply();
|
||||
}
|
||||
|
||||
void Update()
|
||||
@@ -54,12 +69,14 @@ public class MapCameraController : MonoBehaviour
|
||||
{
|
||||
HandlePinch();
|
||||
isPressed = false; // после щипка не засчитываем отпускание как тап
|
||||
Apply();
|
||||
return;
|
||||
}
|
||||
|
||||
HandlePointer();
|
||||
HandleMouseWheel();
|
||||
ClampToMap();
|
||||
Apply();
|
||||
}
|
||||
|
||||
void HandlePointer()
|
||||
@@ -86,10 +103,10 @@ public class MapCameraController : MonoBehaviour
|
||||
|
||||
if (isDragging)
|
||||
{
|
||||
// Сдвигаем камеру ровно на столько, на сколько сдвинулся палец в мире -- карта "прилипает" к пальцу
|
||||
Vector3 previous = cam.ScreenToWorldPoint(lastPointerPosition);
|
||||
Vector3 current = cam.ScreenToWorldPoint(Input.mousePosition);
|
||||
transform.position += previous - current;
|
||||
// Сдвигаем камеру ровно на столько, на сколько сдвинулся палец по земле -- карта "прилипает" к пальцу
|
||||
target += GroundPoint(lastPointerPosition) - GroundPoint(Input.mousePosition);
|
||||
ClampToMap();
|
||||
Apply();
|
||||
}
|
||||
lastPointerPosition = Input.mousePosition;
|
||||
}
|
||||
@@ -99,8 +116,7 @@ public class MapCameraController : MonoBehaviour
|
||||
if (!isDragging)
|
||||
{
|
||||
hasTap = true;
|
||||
tapWorldPosition = cam.ScreenToWorldPoint(Input.mousePosition);
|
||||
tapWorldPosition.z = 0f;
|
||||
tapWorldPosition = GroundPoint(Input.mousePosition);
|
||||
}
|
||||
isPressed = false;
|
||||
isDragging = false;
|
||||
@@ -116,7 +132,7 @@ public class MapCameraController : MonoBehaviour
|
||||
float currentDistance = (a.position - b.position).magnitude;
|
||||
if (currentDistance <= 0.01f) return;
|
||||
|
||||
cam.orthographicSize = Mathf.Clamp(cam.orthographicSize * previousDistance / currentDistance, minOrthoSize, maxOrthoSize);
|
||||
distance = Mathf.Clamp(distance * previousDistance / currentDistance, minDistance, maxDistance);
|
||||
ClampToMap();
|
||||
}
|
||||
|
||||
@@ -124,22 +140,30 @@ public class MapCameraController : MonoBehaviour
|
||||
{
|
||||
float scroll = Input.GetAxis("Mouse ScrollWheel");
|
||||
if (scroll == 0f || IsPointerOverUI()) return;
|
||||
cam.orthographicSize = Mathf.Clamp(cam.orthographicSize - scroll * mouseZoomSpeed * 5f, minOrthoSize, maxOrthoSize);
|
||||
distance = Mathf.Clamp(distance - scroll * mouseZoomSpeed * 10f, minDistance, maxDistance);
|
||||
}
|
||||
|
||||
// Камера не уезжает за край карты (если карта меньше экрана -- центрируем)
|
||||
// Точка, на которую смотрит камера, не уходит за край карты
|
||||
void ClampToMap()
|
||||
{
|
||||
float halfViewHeight = cam.orthographicSize;
|
||||
float halfViewWidth = halfViewHeight * cam.aspect;
|
||||
target.x = Mathf.Clamp(target.x, -mapHalfSize.x, mapHalfSize.x);
|
||||
target.z = Mathf.Clamp(target.z, -mapHalfSize.y, mapHalfSize.y);
|
||||
target.y = 0f;
|
||||
}
|
||||
|
||||
float maxX = Mathf.Max(0f, mapHalfSize.x - halfViewWidth);
|
||||
float maxY = Mathf.Max(0f, mapHalfSize.y - halfViewHeight);
|
||||
void Apply()
|
||||
{
|
||||
Quaternion rot = Quaternion.Euler(pitch, yaw, 0);
|
||||
transform.rotation = rot;
|
||||
transform.position = target - rot * Vector3.forward * distance;
|
||||
}
|
||||
|
||||
Vector3 p = transform.position;
|
||||
p.x = Mathf.Clamp(p.x, -maxX, maxX);
|
||||
p.y = Mathf.Clamp(p.y, -maxY, maxY);
|
||||
transform.position = p;
|
||||
// Точка на земле (y = 0) под экранной точкой
|
||||
Vector3 GroundPoint(Vector3 screen)
|
||||
{
|
||||
Ray ray = cam.ScreenPointToRay(screen);
|
||||
var plane = new Plane(Vector3.up, Vector3.zero);
|
||||
return plane.Raycast(ray, out float t) ? ray.GetPoint(t) : target;
|
||||
}
|
||||
|
||||
static bool IsPointerOverUI()
|
||||
|
||||
@@ -2,7 +2,7 @@ using Bogatyri.World;
|
||||
using TMPro;
|
||||
using UnityEngine;
|
||||
|
||||
// Войско в походе на карте: группа маленьких квадратиков + подпись с числом солдат и таймером.
|
||||
// Войско в походе на карте: группа маленьких кубиков на земле + подпись с числом солдат и таймером (2.5D, 04.11.2026).
|
||||
// Сам ничего не решает -- позицию и состояние берёт из WorldSimulation.
|
||||
public class MarchView : MonoBehaviour
|
||||
{
|
||||
@@ -16,7 +16,7 @@ public class MarchView : MonoBehaviour
|
||||
|
||||
public int MarchId { get; private set; }
|
||||
|
||||
private SpriteRenderer[] squares;
|
||||
private Renderer[] squares;
|
||||
private TextMeshPro label;
|
||||
private GameObject routeLine;
|
||||
private MarchState shownState;
|
||||
@@ -36,12 +36,15 @@ public class MarchView : MonoBehaviour
|
||||
{
|
||||
var go = new GameObject("Label");
|
||||
go.transform.SetParent(transform, false);
|
||||
go.transform.localPosition = new Vector3(0, 0.75f, 0);
|
||||
go.transform.localPosition = new Vector3(0, 1.0f, 0);
|
||||
label = go.AddComponent<TextMeshPro>();
|
||||
label.fontSize = 3f;
|
||||
label.alignment = TextAlignmentOptions.Center;
|
||||
label.rectTransform.sizeDelta = new Vector2(4f, 0.8f);
|
||||
label.sortingOrder = 31;
|
||||
label.rectTransform.sizeDelta = new Vector2(5f, 0.9f);
|
||||
label.color = Color.white;
|
||||
label.outlineWidth = 0.25f;
|
||||
label.outlineColor = Color.black;
|
||||
go.AddComponent<FaceCamera>();
|
||||
}
|
||||
|
||||
// Перестраиваем квадратики, только когда поменялось число солдат (после боя)
|
||||
@@ -54,7 +57,7 @@ public class MarchView : MonoBehaviour
|
||||
|
||||
int count = Mathf.Clamp(soldiers, 1, MaxSquares);
|
||||
int rows = Mathf.CeilToInt(count / (float)SquaresPerRow);
|
||||
squares = new SpriteRenderer[count];
|
||||
squares = new Renderer[count];
|
||||
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
@@ -62,19 +65,19 @@ public class MarchView : MonoBehaviour
|
||||
int row = i / SquaresPerRow;
|
||||
int inThisRow = Mathf.Min(SquaresPerRow, count - row * SquaresPerRow);
|
||||
|
||||
var go = new GameObject("Soldier");
|
||||
var go = GameObject.CreatePrimitive(PrimitiveType.Cube);
|
||||
go.name = "Soldier";
|
||||
Destroy(go.GetComponent<Collider>());
|
||||
go.transform.SetParent(transform, false);
|
||||
go.transform.localPosition = new Vector3(
|
||||
(col - (inThisRow - 1) / 2f) * SquareSpacing,
|
||||
((rows - 1) / 2f - row) * SquareSpacing,
|
||||
0f);
|
||||
SquareSize / 2f,
|
||||
((rows - 1) / 2f - row) * SquareSpacing);
|
||||
go.transform.localScale = Vector3.one * SquareSize;
|
||||
|
||||
var sr = go.AddComponent<SpriteRenderer>();
|
||||
sr.sprite = PrimitiveSprites.Square;
|
||||
sr.color = color;
|
||||
sr.sortingOrder = 30;
|
||||
squares[i] = sr;
|
||||
var r = go.GetComponent<Renderer>();
|
||||
r.sharedMaterial = Map3D.Mat(color);
|
||||
squares[i] = r;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -85,16 +88,15 @@ public class MarchView : MonoBehaviour
|
||||
Vector3 target = WorldMapController.ToWorld(world.GetNode(march.targetNodeId));
|
||||
Vector3 delta = target - home;
|
||||
|
||||
routeLine = new GameObject($"Route_{march.id}");
|
||||
// Тонкая полоса на земле от города до цели
|
||||
routeLine = GameObject.CreatePrimitive(PrimitiveType.Cube);
|
||||
routeLine.name = $"Route_{march.id}";
|
||||
Destroy(routeLine.GetComponent<Collider>());
|
||||
routeLine.transform.SetParent(transform.parent, false);
|
||||
routeLine.transform.position = (home + target) / 2f;
|
||||
routeLine.transform.localScale = new Vector3(delta.magnitude, 0.08f, 1f);
|
||||
routeLine.transform.rotation = Quaternion.Euler(0, 0, Mathf.Atan2(delta.y, delta.x) * Mathf.Rad2Deg);
|
||||
|
||||
var sr = routeLine.AddComponent<SpriteRenderer>();
|
||||
sr.sprite = PrimitiveSprites.Square;
|
||||
sr.color = new Color(1f, 1f, 1f, 0.35f);
|
||||
sr.sortingOrder = -5;
|
||||
routeLine.transform.position = (home + target) / 2f + Vector3.up * 0.02f;
|
||||
routeLine.transform.localScale = new Vector3(delta.magnitude, 0.02f, 0.08f);
|
||||
routeLine.transform.rotation = Quaternion.Euler(0, -Mathf.Atan2(delta.z, delta.x) * Mathf.Rad2Deg, 0);
|
||||
routeLine.GetComponent<Renderer>().sharedMaterial = Map3D.Mat(new Color(0.85f, 0.85f, 0.8f));
|
||||
}
|
||||
|
||||
void OnDestroy()
|
||||
@@ -119,9 +121,16 @@ public class MarchView : MonoBehaviour
|
||||
RebuildSquares(soldiers, returning ? ReturningColor : OutboundColor);
|
||||
}
|
||||
|
||||
long endMs = returning ? march.returnMs : march.arriveMs;
|
||||
int secondsLeft = Mathf.Max(0, Mathf.CeilToInt((endMs - nowMs) / 1000f));
|
||||
string direction = returning ? "домой" : "в бой";
|
||||
label.text = $"{soldiers} сол. {direction} {secondsLeft / 60}:{secondsLeft % 60:00}";
|
||||
bool gathering = march.state == MarchState.Gathering;
|
||||
long endMs = returning ? march.returnMs : gathering ? march.gatherEndMs : march.arriveMs;
|
||||
long secondsLeft = System.Math.Max(0, (endMs - nowMs + 999) / 1000);
|
||||
string direction = returning ? (march.cargo > 0 ? $"домой, груз {march.cargo}" : "домой")
|
||||
: gathering ? (march.scout ? "наблюдает" : $"сбор {march.cargo}")
|
||||
: march.scout ? "разведка" : march.gather ? "на сбор" : "в бой";
|
||||
// Марши идут часами (регламент 31.10) -- «1:05:30», меньше часа -- «12:30»
|
||||
string time = secondsLeft >= 3600
|
||||
? $"{secondsLeft / 3600}:{secondsLeft / 60 % 60:00}:{secondsLeft % 60:00}"
|
||||
: $"{secondsLeft / 60}:{secondsLeft % 60:00}";
|
||||
label.text = $"{soldiers} сол. {direction} {time}";
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,72 @@
|
||||
using System.Collections.Generic;
|
||||
using TMPro;
|
||||
using UnityEngine;
|
||||
|
||||
// Отчёты разведки на экране (Разведка М2): текст отчёта и окно «Отчёты» с последними отчётами.
|
||||
// Сами отчёты хранит модуль Разведки (IIntelligence.Reports) -- здесь только показ.
|
||||
// Сведения -- на момент отчёта: сколько прошло с тех пор, видно в каждом отчёте.
|
||||
public static class ReconReportText
|
||||
{
|
||||
static readonly string[] TroopNames = { "пехота", "лучники", "кавалерия", "осадные" };
|
||||
static readonly Dictionary<string, string> ResourceNames = new Dictionary<string, string>
|
||||
{
|
||||
{ "Food", "еда" }, { "Wood", "дерево" }, { "Stone", "камень" }, { "Iron", "металл" }, { "Gold", "золото" }, { "Gems", "кристаллы" }
|
||||
};
|
||||
|
||||
public static string Format(ReconReport r, long nowMs)
|
||||
{
|
||||
var lines = new List<string>
|
||||
{
|
||||
$"<b>{r.TargetName}</b> — разведка {(r.Level == 3 ? "III" : "II")}, {Ago(nowMs - r.TimeMs)} назад",
|
||||
};
|
||||
int total = 0;
|
||||
var parts = new List<string>();
|
||||
for (int i = 0; r.Units != null && i < r.Units.Length; i++)
|
||||
{
|
||||
total += r.Units[i];
|
||||
if (r.Units[i] > 0) parts.Add($"{TroopNames[i % TroopNames.Length]} {r.Units[i]}");
|
||||
}
|
||||
lines.Add($"Гарнизон: {total}" + (parts.Count > 0 ? $" ({string.Join(", ", parts)})" : ""));
|
||||
lines.Add((r.Fortified ? "Защитники за стенами" : "Стен нет, бой в поле") + (r.HasHero ? ", есть герой" : ", героя нет"));
|
||||
if (r.Level >= 3)
|
||||
{
|
||||
if (!string.IsNullOrEmpty(r.Modifiers)) lines.Add("Защита: " + r.Modifiers);
|
||||
var res = new List<string>();
|
||||
for (int i = 0; r.ResourceNames != null && i < r.ResourceNames.Length; i++)
|
||||
{
|
||||
string name = ResourceNames.TryGetValue(r.ResourceNames[i], out var n) ? n : r.ResourceNames[i];
|
||||
res.Add($"{name} ~{r.ResourceMin[i]}–{r.ResourceMax[i]}");
|
||||
}
|
||||
if (res.Count > 0) lines.Add("Ресурсы (оценка ±15%): " + string.Join(", ", res));
|
||||
}
|
||||
return string.Join("\n", lines);
|
||||
}
|
||||
|
||||
static string Ago(long ms)
|
||||
{
|
||||
long min = System.Math.Max(0, ms) / 60_000;
|
||||
if (min < 1) return "только что";
|
||||
return min < 60 ? $"{min} мин" : $"{min / 60} ч {min % 60} мин";
|
||||
}
|
||||
|
||||
// Окно «Отчёты»: последние отчёты, новые сверху
|
||||
public static void OpenWindow()
|
||||
{
|
||||
var card = UIKit.Modal("ОТЧЁТЫ РАЗВЕДКИ", out GameObject root);
|
||||
if (!GameServices.TryGet(out IIntelligence intel) || intel.Reports.Count == 0)
|
||||
{
|
||||
UIKit.Text(card, "Отчётов пока нет. Нажмите на город, лагерь или замок и отправьте «Разведку II» или «Разведку III».",
|
||||
26, UIKit.Theme.TextDim, TextAlignmentOptions.Center);
|
||||
}
|
||||
else
|
||||
{
|
||||
long now = MarchManager.NowMs;
|
||||
int shown = 0;
|
||||
for (int i = intel.Reports.Count - 1; i >= 0 && shown < 5; i--, shown++)
|
||||
UIKit.Text(card, Format(intel.Reports[i], now), 24, UIKit.Theme.Text, TextAlignmentOptions.Left);
|
||||
if (intel.Reports.Count > 5)
|
||||
UIKit.Text(card, $"И ещё {intel.Reports.Count - 5} более старых", 22, UIKit.Theme.TextDim, TextAlignmentOptions.Center);
|
||||
}
|
||||
UIKit.Button(card, "Закрыть", UIKit.Theme.Gray, () => Object.Destroy(root), -1, 80, 28);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
fileFormatVersion: 2
|
||||
guid: 76599837523e444e87459016c4f367a4
|
||||
MonoImporter:
|
||||
externalObjects: {}
|
||||
serializedVersion: 2
|
||||
defaultReferences: []
|
||||
executionOrder: 0
|
||||
icon: {instanceID: 0}
|
||||
userData:
|
||||
assetBundleName:
|
||||
assetBundleVariant:
|
||||
@@ -48,7 +48,10 @@ public class WorldMapController : MonoBehaviour
|
||||
const float CastleSize = 2.2f;
|
||||
const float CitySize = 1.1f;
|
||||
const float CampSize = 0.8f;
|
||||
const float StartZoom = 8f;
|
||||
const float StartDistance = 18f; // камера 2.5D: расстояние до земли
|
||||
|
||||
// Высота объектов над землёй (2.5D на примитивах, 04.11.2026)
|
||||
const float CastleHeight = 1.4f, CityHeight = 0.9f, CampHeight = 0.5f, PointHeight = 0.45f;
|
||||
|
||||
static readonly Color GroundColor = new Color(0.3f, 0.42f, 0.25f);
|
||||
static readonly Color CastleColor = new Color(0.55f, 0.15f, 0.15f);
|
||||
@@ -63,33 +66,54 @@ public class WorldMapController : MonoBehaviour
|
||||
private readonly List<int> staleMarchIds = new List<int>();
|
||||
private MapNode selectedTarget;
|
||||
|
||||
// Подписи замка и соседей: гарнизон виден только в зоне обзора (решения 31.10, п. 1)
|
||||
private readonly List<(MapNode node, TextMeshPro label)> garrisonLabels = new List<(MapNode, TextMeshPro)>();
|
||||
|
||||
// Лагеря меняют вид: разбит -- серый, с таймером до появления
|
||||
private readonly List<(MapNode node, SpriteRenderer sprite, TextMeshPro label)> campViews = new List<(MapNode, SpriteRenderer, TextMeshPro)>();
|
||||
private readonly List<(MapNode node, Renderer sprite, TextMeshPro label)> campViews = new List<(MapNode, Renderer, TextMeshPro)>();
|
||||
|
||||
// Ресурсные точки появляются и исчезают -- виды создаются и убираются по ходу игры
|
||||
private readonly Dictionary<string, (Renderer sprite, TextMeshPro label)> pointViews = new Dictionary<string, (Renderer, TextMeshPro)>();
|
||||
private readonly List<string> stalePoints = new List<string>();
|
||||
const float PointSize = 0.7f;
|
||||
static readonly Color[] PointColors =
|
||||
{
|
||||
new Color(0.2f, 0.55f, 0.2f), // дерево
|
||||
new Color(0.6f, 0.6f, 0.62f), // камень
|
||||
new Color(0.35f, 0.45f, 0.6f), // металл
|
||||
new Color(0.95f, 0.78f, 0.2f) // золото
|
||||
};
|
||||
static readonly string[] ResourceGenitive = { "дерева", "камня", "металла", "золота" };
|
||||
private float nextCampRefresh;
|
||||
|
||||
// Окно атаки: постоянная часть текста и состояние войска, с которым оно показано
|
||||
private string attackInfoBase;
|
||||
private BattleCondition shownConditions;
|
||||
private bool shownObserved; // цель была в зоне обзора, когда окно атаки открылось
|
||||
private ReconReport? shownReport; // цель вне обзора, но есть отчёт разведки -- гарнизон и прогноз по нему (на момент отчёта)
|
||||
|
||||
WorldSimulation World => MarchManager.Instance.World;
|
||||
|
||||
void Start()
|
||||
{
|
||||
mapRoot = new GameObject("Map").transform;
|
||||
BuildMap();
|
||||
Renderer ground = BuildMap();
|
||||
IntelligenceOverlay.Create(mapRoot, World, ground); // туман на земле и чужие армии (модуль Разведки)
|
||||
SetUpCamera();
|
||||
|
||||
backButton.onClick.AddListener(SceneNavigator.ReturnToCity);
|
||||
if (myCityButton != null) myCityButton.onClick.AddListener(CenterOnMyCity);
|
||||
if (ratingButton != null) ratingButton.onClick.AddListener(ratingPanel.Open);
|
||||
CreateArmiesButton();
|
||||
HookUpComingSoon(worldMapNavButton, "Карта мира");
|
||||
HookUpComingSoon(eventsNavButton, "События");
|
||||
if (circleNavButton != null) circleNavButton.onClick.AddListener(CircleWindow.Open); // модуль Круга
|
||||
HookUpComingSoon(settlementNavButton, "Поселение");
|
||||
sendButton.onClick.AddListener(OnSendPressed);
|
||||
CreateScoutButton();
|
||||
cancelButton.onClick.AddListener(CloseAttackPanel);
|
||||
popupOkButton.onClick.AddListener(ShowNextPopup);
|
||||
soldiersSlider.onValueChanged.AddListener(_ => UpdateSoldiersToSendText());
|
||||
soldiersSlider.onValueChanged.AddListener(_ => { UpdateSoldiersToSendText(); if (attackPanel.activeSelf) RefreshAttackConditions(); });
|
||||
|
||||
attackPanel.SetActive(false);
|
||||
popupPanel.SetActive(false);
|
||||
@@ -104,6 +128,9 @@ public class WorldMapController : MonoBehaviour
|
||||
{
|
||||
if (MarchManager.Instance == null) return;
|
||||
MarchManager.Instance.OnBattleResolved += HandleBattleResolved;
|
||||
MarchManager.Instance.OnGatherStarted += HandleGatherStarted;
|
||||
MarchManager.Instance.OnScoutArrived += HandleScoutArrived;
|
||||
MarchManager.Instance.OnReconCompleted += HandleReconCompleted;
|
||||
MarchManager.Instance.OnMarchReturned += HandleMarchReturned;
|
||||
}
|
||||
|
||||
@@ -111,6 +138,9 @@ public class WorldMapController : MonoBehaviour
|
||||
{
|
||||
if (MarchManager.Instance == null) return;
|
||||
MarchManager.Instance.OnBattleResolved -= HandleBattleResolved;
|
||||
MarchManager.Instance.OnGatherStarted -= HandleGatherStarted;
|
||||
MarchManager.Instance.OnScoutArrived -= HandleScoutArrived;
|
||||
MarchManager.Instance.OnReconCompleted -= HandleReconCompleted;
|
||||
MarchManager.Instance.OnMarchReturned -= HandleMarchReturned;
|
||||
}
|
||||
|
||||
@@ -124,7 +154,88 @@ public class WorldMapController : MonoBehaviour
|
||||
// Воины, а не отряды: "В походе: 1" читалось как один воин
|
||||
int inMarches = 0, garrison = 0;
|
||||
if (GameServices.TryGet(out IArmy army)) { inMarches = army.TroopsInMarches; garrison = army.GarrisonTotal; }
|
||||
soldiersText.text = $"Свободно: {GetSoldiersAtHome()} Гарнизон: {garrison} В походе: {inMarches} (отрядов: {World.Marches.Count})";
|
||||
string slots = army != null ? $"{army.ActiveMarches} из {army.MarchSlots}" : World.Marches.Count.ToString();
|
||||
soldiersText.text = $"Свободно: {GetSoldiersAtHome()} Гарнизон: {garrison} В походе: {inMarches} (отрядов: {slots})";
|
||||
}
|
||||
|
||||
// Кнопка «Армии» -- копия кнопки «Рейтинг» прямо под ней: тот же вид, без правки сцены
|
||||
void CreateArmiesButton()
|
||||
{
|
||||
if (ratingButton == null) return;
|
||||
var copy = Instantiate(ratingButton.gameObject, ratingButton.transform.parent);
|
||||
copy.name = "ArmiesButton";
|
||||
var rt = (RectTransform)copy.transform;
|
||||
var src = (RectTransform)ratingButton.transform;
|
||||
rt.anchoredPosition = src.anchoredPosition - new Vector2(0, src.rect.height + 12);
|
||||
var label = copy.GetComponentInChildren<TMP_Text>();
|
||||
if (label != null) label.text = "Армии";
|
||||
var button = copy.GetComponent<Button>();
|
||||
button.onClick.RemoveAllListeners();
|
||||
button.onClick.AddListener(ArmiesWindow.Open);
|
||||
|
||||
// «Отчёты» -- под «Армиями»: последние отчёты разведки (Разведка М2)
|
||||
var reports = Instantiate(ratingButton.gameObject, ratingButton.transform.parent);
|
||||
reports.name = "ReportsButton";
|
||||
var rrt = (RectTransform)reports.transform;
|
||||
rrt.anchoredPosition = src.anchoredPosition - new Vector2(0, (src.rect.height + 12) * 2);
|
||||
var rl = reports.GetComponentInChildren<TMP_Text>();
|
||||
if (rl != null) rl.text = "Отчёты";
|
||||
var rb = reports.GetComponent<Button>();
|
||||
rb.onClick.RemoveAllListeners();
|
||||
rb.onClick.AddListener(ReconReportText.OpenWindow);
|
||||
}
|
||||
|
||||
// Кнопки разведки в окне атаки -- копии «Отправить». Четыре в ряд: Отмена, Разведка II, Разведка III, Отправить.
|
||||
// Разведка II / III (Разведка М2): наблюдать цель и принести отчёт; у ресурсной точки -- просто «Разведка» (дойти и вернуться)
|
||||
private Button scoutButton, scout3Button;
|
||||
private TMP_Text scoutLabel;
|
||||
|
||||
void CreateScoutButton()
|
||||
{
|
||||
scoutButton = CopyOfSend("ScoutButton", "Разведка II", () => OnScoutPressed(2));
|
||||
scoutLabel = scoutButton.GetComponentInChildren<TMP_Text>();
|
||||
scout3Button = CopyOfSend("Scout3Button", "Разведка III", () => OnScoutPressed(3));
|
||||
|
||||
Place(cancelButton, -330f);
|
||||
Place(scoutButton, -110f);
|
||||
Place(scout3Button, 110f);
|
||||
Place(sendButton, 330f);
|
||||
}
|
||||
|
||||
Button CopyOfSend(string name, string text, UnityEngine.Events.UnityAction onClick)
|
||||
{
|
||||
var copy = Instantiate(sendButton.gameObject, sendButton.transform.parent);
|
||||
copy.name = name;
|
||||
var b = copy.GetComponent<Button>();
|
||||
b.onClick.RemoveAllListeners();
|
||||
b.onClick.AddListener(onClick);
|
||||
var label = copy.GetComponentInChildren<TMP_Text>();
|
||||
if (label != null) label.text = text;
|
||||
return b;
|
||||
}
|
||||
|
||||
static void Place(Button button, float x)
|
||||
{
|
||||
var rt = (RectTransform)button.transform;
|
||||
rt.anchoredPosition = new Vector2(x, rt.anchoredPosition.y);
|
||||
rt.sizeDelta = new Vector2(Mathf.Min(rt.sizeDelta.x, 205f), rt.sizeDelta.y);
|
||||
}
|
||||
|
||||
void OnScoutPressed(int level)
|
||||
{
|
||||
if (selectedTarget == null) return;
|
||||
int soldiers = (int)soldiersSlider.value;
|
||||
bool point = selectedTarget.type == MapNodeType.ResourcePoint;
|
||||
string error;
|
||||
bool ok = point
|
||||
? MarchManager.Instance.TryStartScout(selectedTarget.id, soldiers, out error)
|
||||
: MarchManager.Instance.TryStartRecon(selectedTarget.id, soldiers, level, out error);
|
||||
long hold = !point && GameServices.TryGet(out IIntelligence intel) ? intel.ReconDurationMs(selectedTarget.id, level) : 0;
|
||||
hintText.text = ok
|
||||
? point ? $"Разведка выступила: {soldiers} воинов идут к цели «{selectedTarget.displayName}» и вернутся без боя"
|
||||
: $"Разведка {(level == 3 ? "III" : "II")} выступила к «{selectedTarget.displayName}»: наблюдать {Duration(hold)}, потом отчёт и домой"
|
||||
: "Разведка не начата: " + error;
|
||||
CloseAttackPanel();
|
||||
}
|
||||
|
||||
void HookUpComingSoon(Button button, string sectionName)
|
||||
@@ -135,45 +246,144 @@ public class WorldMapController : MonoBehaviour
|
||||
|
||||
// ---------------- КАРТА ----------------
|
||||
|
||||
void BuildMap()
|
||||
// Карта лежит на земле (2.5D): замок -- стены с башнями, свой город и соседи -- домики на площадке,
|
||||
// лагеря -- шатры с костром, ресурсные точки -- кристаллы цвета ресурса. Подписи висят над объектами.
|
||||
Renderer BuildMap()
|
||||
{
|
||||
float width = WorldMapLayout.HalfWidth / 1000f * 2f;
|
||||
float height = WorldMapLayout.HalfHeight / 1000f * 2f;
|
||||
CreateSprite("Ground", PrimitiveSprites.Square, GroundColor, Vector3.zero, new Vector3(width, height, 1f), -10);
|
||||
Renderer ground = CreateGround(width, height);
|
||||
|
||||
foreach (var node in World.Nodes)
|
||||
{
|
||||
Vector3 pos = ToWorld(node);
|
||||
int seed = node.id.GetHashCode() & 0x7fff;
|
||||
|
||||
switch (node.type)
|
||||
{
|
||||
case MapNodeType.BossCastle:
|
||||
CreateSprite(node.id, PrimitiveSprites.Square, CastleColor, pos, Vector3.one * CastleSize, 0);
|
||||
CreateSprite(node.id + "_Keep", PrimitiveSprites.Square, new Color(0.3f, 0.08f, 0.08f), pos, Vector3.one * CastleSize * 0.5f, 1);
|
||||
CreateLabel(node.displayName, pos + new Vector3(0, CastleSize / 2f + 0.4f, 0), 4f);
|
||||
CreateLabel($"Гарнизон: {node.garrison}", pos - new Vector3(0, CastleSize / 2f + 0.35f, 0), 3f);
|
||||
BuildCastle(node, pos);
|
||||
Map3D.Label(mapRoot, node.displayName, pos + Vector3.up * (CastleHeight * 1.8f + 1.4f), 4f);
|
||||
garrisonLabels.Add((node, Map3D.Label(mapRoot, "", pos + Vector3.up * (CastleHeight * 1.8f + 0.75f), 3f)));
|
||||
break;
|
||||
|
||||
case MapNodeType.PlayerCity:
|
||||
// Белая рамка -- чтобы свой город сразу бросался в глаза
|
||||
CreateSprite(node.id + "_Frame", PrimitiveSprites.Square, Color.white, pos, Vector3.one * (CitySize + 0.25f), 0);
|
||||
CreateSprite(node.id, PrimitiveSprites.Square, PlayerCityColor, pos, Vector3.one * CitySize, 1);
|
||||
CreateLabel(node.displayName, pos - new Vector3(0, CitySize / 2f + 0.35f, 0), 3.2f);
|
||||
// Белая площадка и синие крыши -- чтобы свой город сразу бросался в глаза
|
||||
Map3D.Block(mapRoot, node.id + "_Frame", PrimitiveType.Cube, Color.white, pos, Vector2.one * (CitySize + 0.45f), 0.08f);
|
||||
BuildTown(node.id, pos + Vector3.up * 0.08f, new Color(0.92f, 0.88f, 0.78f), PlayerCityColor, seed, 4);
|
||||
Map3D.Flag(mapRoot, pos + new Vector3(0.55f, 0.08f, 0.55f), 1.5f, new Color(0.95f, 0.8f, 0.2f));
|
||||
Map3D.Label(mapRoot, node.displayName, pos + Vector3.up * (CityHeight + 1.0f), 3.2f);
|
||||
break;
|
||||
|
||||
case MapNodeType.NeighborCity:
|
||||
CreateSprite(node.id, PrimitiveSprites.Square, NeighborCityColor, pos, Vector3.one * CitySize, 0);
|
||||
CreateLabel($"{node.displayName}\nГарнизон: {node.garrison}", pos - new Vector3(0, CitySize / 2f + 0.5f, 0), 2.6f);
|
||||
Map3D.Block(mapRoot, node.id + "_Yard", PrimitiveType.Cube, new Color(0.62f, 0.55f, 0.42f), pos, Vector2.one * (CitySize + 0.25f), 0.05f);
|
||||
BuildTown(node.id, pos + Vector3.up * 0.05f, new Color(0.85f, 0.75f, 0.58f), new Color(0.62f, 0.25f, 0.18f), seed, 3);
|
||||
garrisonLabels.Add((node, Map3D.Label(mapRoot, "", pos + Vector3.up * (CityHeight + 1.05f), 2.6f)));
|
||||
break;
|
||||
|
||||
case MapNodeType.Camp:
|
||||
// Круг, а не квадрат: лагерь не путается с городом
|
||||
var sprite = CreateSprite(node.id, PrimitiveSprites.Circle, CampColor, pos, Vector3.one * CampSize, 0);
|
||||
var label = CreateLabel("", pos - new Vector3(0, CampSize / 2f + 0.5f, 0), 2.3f);
|
||||
// Шатры разбойников с костром; цвет главного шатра -- разбит лагерь или нет
|
||||
var sprite = Map3D.Shape(mapRoot, node.id, Map3D.Cone, CampColor, pos, Vector2.one * CampSize, CampHeight * 1.6f);
|
||||
Map3D.Shape(mapRoot, node.id + "_Tent2", Map3D.Cone, new Color(0.55f, 0.42f, 0.3f), pos + new Vector3(0.45f, 0, -0.25f), Vector2.one * CampSize * 0.6f, CampHeight * 1.1f);
|
||||
Map3D.Block(mapRoot, node.id + "_Fire", PrimitiveType.Cube, new Color(1f, 0.55f, 0.15f), pos + new Vector3(-0.35f, 0, -0.35f), Vector2.one * 0.14f, 0.12f);
|
||||
var label = Map3D.Label(mapRoot, "", pos + Vector3.up * (CampHeight * 1.6f + 0.85f), 2.3f);
|
||||
campViews.Add((node, sprite, label));
|
||||
break;
|
||||
}
|
||||
}
|
||||
BuildScenery(width, height);
|
||||
return ground;
|
||||
}
|
||||
|
||||
// Замок Змея Горыныча: квадрат стен, четыре угловые башни с красными крышами, высокая главная башня
|
||||
void BuildCastle(MapNode node, Vector3 pos)
|
||||
{
|
||||
Color stone = new Color(0.5f, 0.45f, 0.42f), dark = new Color(0.32f, 0.28f, 0.27f), roofRed = new Color(0.6f, 0.12f, 0.1f);
|
||||
float half = CastleSize / 2f, wall = 0.18f, wallH = CastleHeight * 0.55f;
|
||||
Map3D.Block(mapRoot, node.id + "_WallN", PrimitiveType.Cube, stone, pos + new Vector3(0, 0, half - wall / 2), new Vector2(CastleSize, wall), wallH);
|
||||
Map3D.Block(mapRoot, node.id + "_WallS", PrimitiveType.Cube, stone, pos + new Vector3(0, 0, -half + wall / 2), new Vector2(CastleSize, wall), wallH);
|
||||
Map3D.Block(mapRoot, node.id + "_WallE", PrimitiveType.Cube, stone, pos + new Vector3(half - wall / 2, 0, 0), new Vector2(wall, CastleSize), wallH);
|
||||
Map3D.Block(mapRoot, node.id + "_WallW", PrimitiveType.Cube, stone, pos + new Vector3(-half + wall / 2, 0, 0), new Vector2(wall, CastleSize), wallH);
|
||||
foreach (var corner in new[] { new Vector3(1, 0, 1), new Vector3(-1, 0, 1), new Vector3(1, 0, -1), new Vector3(-1, 0, -1) })
|
||||
{
|
||||
Vector3 c = pos + corner * (half - 0.12f);
|
||||
Map3D.Block(mapRoot, node.id + "_Tower", PrimitiveType.Cylinder, stone, c, Vector2.one * 0.42f, CastleHeight);
|
||||
Map3D.Shape(mapRoot, node.id + "_TowerRoof", Map3D.Cone, roofRed, c + Vector3.up * CastleHeight, Vector2.one * 0.55f, 0.5f);
|
||||
}
|
||||
Map3D.Block(mapRoot, node.id + "_Keep", PrimitiveType.Cube, dark, pos, Vector2.one * CastleSize * 0.42f, CastleHeight * 1.8f);
|
||||
Map3D.Shape(mapRoot, node.id + "_KeepRoof", Map3D.Pyramid, roofRed, pos + Vector3.up * CastleHeight * 1.8f, Vector2.one * CastleSize * 0.5f, 0.7f, 45f);
|
||||
Map3D.Flag(mapRoot, pos + Vector3.up * (CastleHeight * 1.8f + 0.6f), 0.6f, new Color(0.15f, 0.55f, 0.2f));
|
||||
}
|
||||
|
||||
// Городок: несколько домиков разного размера на площадке города
|
||||
void BuildTown(string id, Vector3 pos, Color walls, Color roofColor, int seed, int houses)
|
||||
{
|
||||
var rng = new System.Random(seed);
|
||||
Vector3[] spots = { new Vector3(-0.28f, 0, -0.22f), new Vector3(0.28f, 0, -0.2f), new Vector3(-0.2f, 0, 0.3f), new Vector3(0.25f, 0, 0.28f) };
|
||||
for (int i = 0; i < houses && i < spots.Length; i++)
|
||||
{
|
||||
float w = 0.38f + (float)rng.NextDouble() * 0.12f, h = 0.3f + (float)rng.NextDouble() * 0.25f;
|
||||
Map3D.House(mapRoot, id + "_House" + i, pos + spots[i], w, w * 0.8f, h, walls, roofColor, rng.Next(2) * 90f);
|
||||
}
|
||||
}
|
||||
|
||||
// Рощи и камни между объектами -- только украшение (не мешают тапам и походам)
|
||||
void BuildScenery(float width, float height)
|
||||
{
|
||||
var rng = new System.Random(WorldMapLayout.DefaultSeed);
|
||||
int trees = 0;
|
||||
for (int attempt = 0; attempt < 3000 && trees < 170; attempt++)
|
||||
{
|
||||
float x = ((float)rng.NextDouble() - 0.5f) * (width - 1f), z = ((float)rng.NextDouble() - 0.5f) * (height - 1f);
|
||||
if (!FarFromNodes(x, z, 1.7f)) continue;
|
||||
// рощами: рядом с деревом -- ещё 1-2
|
||||
int group = 1 + rng.Next(3);
|
||||
for (int g = 0; g < group; g++)
|
||||
{
|
||||
float gx = x + ((float)rng.NextDouble() - 0.5f) * 1.2f, gz = z + ((float)rng.NextDouble() - 0.5f) * 1.2f;
|
||||
if (!FarFromNodes(gx, gz, 1.4f)) continue;
|
||||
Map3D.Tree(mapRoot, "Tree", new Vector3(gx, 0, gz), 0.55f + (float)rng.NextDouble() * 0.35f, rng.Next(6));
|
||||
trees++;
|
||||
}
|
||||
}
|
||||
for (int i = 0, rocks = 0; i < 600 && rocks < 30; i++)
|
||||
{
|
||||
float x = ((float)rng.NextDouble() - 0.5f) * (width - 1f), z = ((float)rng.NextDouble() - 0.5f) * (height - 1f);
|
||||
if (!FarFromNodes(x, z, 1.5f)) continue;
|
||||
Map3D.Rock(mapRoot, "Rock", new Vector3(x, 0, z), 0.3f + (float)rng.NextDouble() * 0.35f, rng.Next(9));
|
||||
rocks++;
|
||||
}
|
||||
}
|
||||
|
||||
bool FarFromNodes(float x, float z, float distance)
|
||||
{
|
||||
foreach (var n in World.Nodes)
|
||||
{
|
||||
float dx = n.x / 1000f - x, dz = n.y / 1000f - z;
|
||||
if (dx * dx + dz * dz < distance * distance) return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
// Земля -- плоскость с текстурой: её раскрашивает туман (IntelligenceOverlay). UV (0,0) -- левый нижний угол карты
|
||||
Renderer CreateGround(float width, float height)
|
||||
{
|
||||
var mesh = new Mesh { name = "WorldMap_Ground" };
|
||||
float hx = width / 2f, hz = height / 2f;
|
||||
mesh.vertices = new[] { new Vector3(-hx, 0, -hz), new Vector3(-hx, 0, hz), new Vector3(hx, 0, hz), new Vector3(hx, 0, -hz) };
|
||||
mesh.uv = new[] { new Vector2(0, 0), new Vector2(0, 1), new Vector2(1, 1), new Vector2(1, 0) };
|
||||
mesh.triangles = new[] { 0, 1, 2, 0, 2, 3 };
|
||||
mesh.RecalculateNormals();
|
||||
// Земля за краем карты -- тёмная, как неисследованное: камера под наклоном не видит пустого неба
|
||||
Map3D.Block(mapRoot, "OuterLand", PrimitiveType.Cube, new Color(0.12f, 0.16f, 0.13f), new Vector3(0, -0.08f, 0),
|
||||
new Vector2(width + 160f, height + 160f), 0.06f);
|
||||
|
||||
var go = new GameObject("Ground");
|
||||
go.transform.SetParent(mapRoot, false);
|
||||
go.AddComponent<MeshFilter>().sharedMesh = mesh;
|
||||
var r = go.AddComponent<MeshRenderer>();
|
||||
r.sharedMaterial = Map3D.TexturedMat(Texture2D.whiteTexture); // текстуру с туманом даст IntelligenceOverlay
|
||||
return r;
|
||||
}
|
||||
|
||||
void SetUpCamera()
|
||||
@@ -187,7 +397,8 @@ public class WorldMapController : MonoBehaviour
|
||||
}
|
||||
|
||||
mapCamera.mapHalfSize = new Vector2(WorldMapLayout.HalfWidth / 1000f, WorldMapLayout.HalfHeight / 1000f);
|
||||
mapCamera.GetComponent<Camera>().orthographicSize = StartZoom;
|
||||
mapCamera.distance = StartDistance;
|
||||
Map3D.SetUpLook(mapCamera.GetComponent<Camera>(), 22f, 60f); // солнце, небо, дымка вдали (в 2D-сцене света не было)
|
||||
CenterOnMyCity();
|
||||
}
|
||||
|
||||
@@ -197,58 +408,97 @@ public class WorldMapController : MonoBehaviour
|
||||
if (home != null) mapCamera.CenterOn(ToWorld(home));
|
||||
}
|
||||
|
||||
SpriteRenderer CreateSprite(string name, Sprite sprite, Color color, Vector3 position, Vector3 scale, int order)
|
||||
{
|
||||
var go = new GameObject(name);
|
||||
go.transform.SetParent(mapRoot, false);
|
||||
go.transform.position = position;
|
||||
go.transform.localScale = scale;
|
||||
var sr = go.AddComponent<SpriteRenderer>();
|
||||
sr.sprite = sprite;
|
||||
sr.color = color;
|
||||
sr.sortingOrder = order;
|
||||
return sr;
|
||||
}
|
||||
|
||||
TextMeshPro CreateLabel(string text, Vector3 position, float fontSize)
|
||||
{
|
||||
var go = new GameObject("Label");
|
||||
go.transform.SetParent(mapRoot, false);
|
||||
go.transform.position = position;
|
||||
var tmp = go.AddComponent<TextMeshPro>();
|
||||
tmp.text = text;
|
||||
tmp.fontSize = fontSize;
|
||||
tmp.alignment = TextAlignmentOptions.Center;
|
||||
tmp.rectTransform.sizeDelta = new Vector2(6f, 1.2f);
|
||||
tmp.sortingOrder = 10;
|
||||
return tmp;
|
||||
}
|
||||
|
||||
void RefreshCamps()
|
||||
{
|
||||
if (Time.unscaledTime < nextCampRefresh) return;
|
||||
nextCampRefresh = Time.unscaledTime + 1f;
|
||||
|
||||
long now = MarchManager.NowMs;
|
||||
RefreshPoints(now);
|
||||
foreach (var (node, label) in garrisonLabels)
|
||||
{
|
||||
string garrison = GarrisonText(node);
|
||||
label.text = node.type == MapNodeType.BossCastle ? garrison : $"{node.displayName}\n{garrison}";
|
||||
}
|
||||
foreach (var (node, sprite, label) in campViews)
|
||||
{
|
||||
long left = World.CampRespawnInMs(node.id, now);
|
||||
sprite.color = left > 0 ? CampClearedColor : CampColor;
|
||||
label.text = left > 0
|
||||
sprite.sharedMaterial = Map3D.Mat(left > 0 ? new Color(0.4f, 0.4f, 0.4f) : CampColor);
|
||||
label.text = left > 0 // разбил его сам игрок -- это он знает
|
||||
? $"{node.displayName}\n<color=#BBBBBB>разбит, вернётся через {FormatMinutes(left)}</color>"
|
||||
: $"{node.displayName}, ур. {node.level}\nГарнизон: {node.garrison}";
|
||||
: $"{node.displayName}, ур. {node.level}\n{GarrisonText(node)}";
|
||||
}
|
||||
}
|
||||
|
||||
// Ресурсные точки: ромб цвета ресурса, подпись -- запас и сколько осталось жить; занятая -- «идёт сбор»
|
||||
void RefreshPoints(long now)
|
||||
{
|
||||
foreach (var p in World.ResourcePoints)
|
||||
{
|
||||
if (!p.active) continue;
|
||||
if (!pointViews.TryGetValue(p.id, out var view))
|
||||
{
|
||||
MapNode node = World.GetNode(p.id);
|
||||
Vector3 pos = ToWorld(node);
|
||||
// Кристалл цвета ресурса на камне -- не путается с городом и лагерем
|
||||
var holder = new GameObject(p.id).transform; // исчезнет точка -- уберём всё вместе
|
||||
holder.SetParent(mapRoot, false);
|
||||
Map3D.Rock(holder, "Base", pos, PointSize * 0.9f, p.kind + 3);
|
||||
var sprite = Map3D.Shape(holder, "Crystal", Map3D.Pyramid, PointColors[p.kind], pos + Vector3.up * 0.1f, Vector2.one * PointSize * 0.75f, PointHeight * 1.8f, 45f);
|
||||
var label = Map3D.Label(mapRoot, "", pos + Vector3.up * (PointHeight + 0.75f), 2.2f);
|
||||
view = (sprite, label);
|
||||
pointViews[p.id] = view;
|
||||
}
|
||||
string name = World.GetNode(p.id).displayName;
|
||||
view.label.text = p.occupiedBy != 0
|
||||
? $"{name}\n<color=#9BE09B>идёт сбор</color>"
|
||||
: IsObserved(World.GetNode(p.id))
|
||||
? $"{name}\n{p.stock} {ResourceGenitive[p.kind]}, ещё {Duration(System.Math.Max(0, p.expireMs - now))}"
|
||||
: $"{name}\n{UnknownText}";
|
||||
}
|
||||
|
||||
// Исчезнувшие точки -- с карты
|
||||
stalePoints.Clear();
|
||||
foreach (var id in pointViews.Keys)
|
||||
{
|
||||
ResourcePoint p = World.GetPoint(id);
|
||||
if (p == null || !p.active) stalePoints.Add(id);
|
||||
}
|
||||
foreach (var id in stalePoints)
|
||||
{
|
||||
Destroy(pointViews[id].sprite.gameObject);
|
||||
Destroy(pointViews[id].label.gameObject);
|
||||
pointViews.Remove(id);
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------- ЗАКРЫТЫЕ СВЕДЕНИЯ (решения 31.10, п. 1) ----------------
|
||||
// Объекты видны всегда как ориентиры, а их гарнизон, запас и срок -- только пока объект в зоне обзора
|
||||
// (модуль Разведки). Без Разведки (старые сцены, тесты) -- всё видно, как раньше.
|
||||
|
||||
const string UnknownText = "<color=#9A9A9A>неизвестно: вне обзора</color>";
|
||||
|
||||
static bool IsObserved(MapNode node)
|
||||
{
|
||||
return node == null || !GameServices.TryGet(out IIntelligence intel)
|
||||
|| intel.GetVisibility(node.x, node.y) == MapVisibility.Observed;
|
||||
}
|
||||
|
||||
static string GarrisonText(MapNode node)
|
||||
{
|
||||
return IsObserved(node) ? $"Гарнизон: {node.garrison}" : $"Гарнизон: {UnknownText}";
|
||||
}
|
||||
|
||||
static string FormatMinutes(long ms)
|
||||
{
|
||||
long sec = (ms + 999) / 1000;
|
||||
return sec >= 60 ? $"{(sec + 59) / 60} мин" : $"{sec} сек";
|
||||
}
|
||||
|
||||
// Координаты карты (x, y) -> мир на земле (x, 0, y). 1000 милли-единиц = 1 клетка
|
||||
public static Vector3 ToWorld(MapNode node)
|
||||
{
|
||||
return new Vector3(node.x / 1000f, node.y / 1000f, 0f);
|
||||
return new Vector3(node.x / 1000f, 0f, node.y / 1000f);
|
||||
}
|
||||
|
||||
// ---------------- ВЫБОР ЦЕЛИ ----------------
|
||||
@@ -257,6 +507,7 @@ public class WorldMapController : MonoBehaviour
|
||||
{
|
||||
if (attackPanel.activeSelf || popupPanel.activeSelf) return;
|
||||
if (ratingPanel != null && ratingPanel.gameObject.activeSelf) return;
|
||||
if (ArmiesWindow.IsOpen) return;
|
||||
if (!mapCamera.TryGetTap(out Vector3 world)) return;
|
||||
|
||||
MapNode node = FindNodeAt(world);
|
||||
@@ -265,6 +516,8 @@ public class WorldMapController : MonoBehaviour
|
||||
if (node.type == MapNodeType.PlayerCity) hintText.text = "Это твой город. Нажми НАЗАД, чтобы вернуться в него";
|
||||
else if (node.type == MapNodeType.Camp && World.IsCampCleared(node.id, MarchManager.NowMs))
|
||||
hintText.text = $"{node.displayName} уже разбит. Появится снова через {FormatMinutes(World.CampRespawnInMs(node.id, MarchManager.NowMs))}";
|
||||
else if (node.type == MapNodeType.ResourcePoint && World.GetPoint(node.id)?.occupiedBy != 0)
|
||||
hintText.text = $"{node.displayName}: идёт сбор. Войско вернётся само, когда груз будет полон или точка истощится";
|
||||
else if (node.canBeAttacked) OpenAttackPanel(node);
|
||||
}
|
||||
|
||||
@@ -272,11 +525,13 @@ public class WorldMapController : MonoBehaviour
|
||||
{
|
||||
foreach (var node in World.Nodes)
|
||||
{
|
||||
if (node.type == MapNodeType.ResourcePoint && World.GetPoint(node.id)?.active != true) continue; // исчезнувшая точка
|
||||
// Зона нажатия чуть больше самого квадрата -- по мелким городам легче попасть пальцем
|
||||
float size = node.type == MapNodeType.BossCastle ? CastleSize : node.type == MapNodeType.Camp ? CampSize : CitySize;
|
||||
float size = node.type == MapNodeType.BossCastle ? CastleSize : node.type == MapNodeType.Camp ? CampSize
|
||||
: node.type == MapNodeType.ResourcePoint ? PointSize : CitySize;
|
||||
float halfSize = size / 2f + 0.2f;
|
||||
Vector3 pos = ToWorld(node);
|
||||
if (Mathf.Abs(world.x - pos.x) <= halfSize && Mathf.Abs(world.y - pos.y) <= halfSize) return node;
|
||||
if (Mathf.Abs(world.x - pos.x) <= halfSize && Mathf.Abs(world.z - pos.z) <= halfSize) return node;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
@@ -287,8 +542,6 @@ public class WorldMapController : MonoBehaviour
|
||||
{
|
||||
selectedTarget = target;
|
||||
int available = GetSoldiersAtHome();
|
||||
MapNode home = World.GetNode(WorldMapLayout.PlayerCityId);
|
||||
int travelSeconds = Mathf.CeilToInt(MarchRules.GetTravelTimeMs(home, target) / 1000f);
|
||||
|
||||
attackTitleText.text = target.type == MapNodeType.NeighborCity ? $"Город игрока {target.displayName}"
|
||||
: target.type == MapNodeType.Camp ? $"{target.displayName}, ур. {target.level}"
|
||||
@@ -296,10 +549,17 @@ public class WorldMapController : MonoBehaviour
|
||||
attackInfoText.enableAutoSizing = true; // строка состава гарнизона длинная -- текст ужимается, а не вылезает
|
||||
attackInfoText.fontSizeMin = 18;
|
||||
attackInfoText.fontSizeMax = 32;
|
||||
attackInfoBase = $"Гарнизон: {target.garrison} ({UnitsText(WorldMapLayout.GarrisonUnits(target))})\n" +
|
||||
$"Путь в одну сторону: {travelSeconds} сек" +
|
||||
(WorldMapLayout.IsFortified(target) ? ", защитники за стенами\n" : ", бой в поле\n") +
|
||||
$"Награда за победу: {MarchManager.FormatLoot(target.rewards)}";
|
||||
shownObserved = IsObserved(target);
|
||||
shownReport = !shownObserved && GameServices.TryGet(out IIntelligence intelReports) && intelReports.TryGetLatestReport(target.id, out var report)
|
||||
? report : (ReconReport?)null;
|
||||
attackInfoBase = target.type == MapNodeType.ResourcePoint ? PointInfo(target)
|
||||
: (shownObserved
|
||||
? $"Гарнизон: {target.garrison} ({UnitsText(WorldMapLayout.GarrisonUnits(target))})"
|
||||
: shownReport.HasValue
|
||||
? $"Гарнизон по отчёту разведки {Duration(MarchManager.NowMs - shownReport.Value.TimeMs)} назад: {Sum(shownReport.Value.Units)} ({UnitsText(shownReport.Value.Units)})"
|
||||
: "Гарнизон неизвестен: цель вне зоны обзора. Отправьте разведку") +
|
||||
(WorldMapLayout.IsFortified(target) ? ", защитники за стенами\n" : ", бой в поле\n") +
|
||||
$"Награда за победу: {MarchManager.FormatLoot(target.rewards)}";
|
||||
RefreshAttackConditions();
|
||||
|
||||
soldiersSlider.minValue = available > 0 ? 1 : 0;
|
||||
@@ -307,8 +567,18 @@ public class WorldMapController : MonoBehaviour
|
||||
soldiersSlider.wholeNumbers = true;
|
||||
soldiersSlider.value = available;
|
||||
soldiersSlider.interactable = available > 0;
|
||||
sendButton.interactable = available > 0;
|
||||
bool slotFree = !GameServices.TryGet(out IArmy slotsArmy) || slotsArmy.ActiveMarches < slotsArmy.MarchSlots;
|
||||
sendButton.interactable = available > 0 && slotFree;
|
||||
bool pointTarget = target.type == MapNodeType.ResourcePoint;
|
||||
if (scoutButton != null) scoutButton.interactable = available > 0 && slotFree;
|
||||
if (scoutLabel != null) scoutLabel.text = pointTarget ? "Разведка" : "Разведка II";
|
||||
if (scout3Button != null)
|
||||
{
|
||||
scout3Button.gameObject.SetActive(!pointTarget); // у точки отчёта нет -- только дойти и вернуться
|
||||
scout3Button.interactable = available > 0 && slotFree;
|
||||
}
|
||||
UpdateSoldiersToSendText();
|
||||
RefreshAttackConditions(); // путь -- по составу при выбранном числе воинов
|
||||
|
||||
attackPanel.SetActive(true);
|
||||
}
|
||||
@@ -318,12 +588,47 @@ public class WorldMapController : MonoBehaviour
|
||||
void RefreshAttackConditions()
|
||||
{
|
||||
shownConditions = MarchManager.PlayerConditions();
|
||||
attackInfoText.text = attackInfoBase + ConditionsWarning(shownConditions);
|
||||
bool point = selectedTarget != null && selectedTarget.type == MapNodeType.ResourcePoint;
|
||||
attackInfoText.text = attackInfoBase + PathText() + (point ? "" : ConditionsWarning(shownConditions)); // голод -- про бой
|
||||
}
|
||||
|
||||
// Путь в одну сторону -- по скорости состава (регламент 31.10), реальное время; занятые слоты похода
|
||||
string PathText()
|
||||
{
|
||||
if (selectedTarget == null) return "";
|
||||
int[] units = PreviewUnits((int)soldiersSlider.value);
|
||||
MapNode home = World.GetNode(WorldMapLayout.PlayerCityId);
|
||||
string slots = GameServices.TryGet(out IArmy army) && army.ActiveMarches >= army.MarchSlots
|
||||
? $"\n<color=#E06A5A>Все слоты похода заняты ({army.ActiveMarches} из {army.MarchSlots}) -- дождитесь возвращения войска</color>"
|
||||
: "";
|
||||
long path = World.TravelTimeMs(home, selectedTarget, units);
|
||||
// До отправки -- длительность всего задания (регламент 31.10). Для сбора она в прогнозе ниже
|
||||
string total = selectedTarget.type == MapNodeType.ResourcePoint ? "" : $", туда и обратно ~{Duration(path * 2)}";
|
||||
return $"\nПуть в одну сторону: {Duration(path)}{total}" + slots;
|
||||
}
|
||||
|
||||
// 3 900 000 мс -> "1 ч 5 мин"; меньше минуты -- в секундах
|
||||
static string Duration(long ms)
|
||||
{
|
||||
long sec = (ms + 999) / 1000;
|
||||
if (sec < 60) return $"{sec} сек";
|
||||
long min = (sec + 59) / 60;
|
||||
return min < 60 ? $"{min} мин" : min % 60 == 0 ? $"{min / 60} ч" : $"{min / 60} ч {min % 60} мин";
|
||||
}
|
||||
|
||||
// Кого Армия заберёт в поход: свободных воинов по составу (гарнизон остаётся)
|
||||
int[] PreviewUnits(int soldiers)
|
||||
{
|
||||
if (soldiers <= 0 || !GameServices.TryGet(out IArmy army)) return null;
|
||||
var troops = new int[TroopType.Count];
|
||||
for (int i = 0; i < TroopType.Count; i++) troops[i] = army.GetTroops(i) - army.GetGarrison(i);
|
||||
return ArmyMath.TakeProportional(troops, soldiers);
|
||||
}
|
||||
|
||||
void RefreshOpenAttackPanel()
|
||||
{
|
||||
if (!attackPanel.activeSelf || selectedTarget == null) return;
|
||||
if (IsObserved(selectedTarget) != shownObserved) { OpenAttackPanel(selectedTarget); return; } // цель вошла в обзор или вышла
|
||||
if (MarchManager.PlayerConditions() == shownConditions) return;
|
||||
RefreshAttackConditions();
|
||||
UpdateSoldiersToSendText();
|
||||
@@ -346,30 +651,73 @@ public class WorldMapController : MonoBehaviour
|
||||
: "Дома нет солдат";
|
||||
}
|
||||
|
||||
// Ресурсная точка: запас, срок, добыча и груз на воина (регламент 31.10)
|
||||
string PointInfo(MapNode target)
|
||||
{
|
||||
ResourcePoint p = World.GetPoint(target.id);
|
||||
if (p == null) return "Этой точки больше нет";
|
||||
var r = World.PointRules;
|
||||
if (!shownObserved)
|
||||
return "Запас и срок неизвестны: точка вне зоны обзора\n" +
|
||||
$"Воин добывает {r.MiningMilliPerGameHour[p.kind] / 1000f:0.#} в игровой час (5 мин), несёт {r.CargoPerSoldier[p.kind]}; осадные не несут";
|
||||
return $"Запас: {p.stock} {ResourceGenitive[p.kind]}, точка исчезнет через {Duration(System.Math.Max(0, p.expireMs - MarchManager.NowMs))}\n" +
|
||||
$"Воин добывает {r.MiningMilliPerGameHour[p.kind] / 1000f:0.#} в игровой час (5 мин), несёт {r.CargoPerSoldier[p.kind]}; осадные не несут";
|
||||
}
|
||||
|
||||
// Прогноз сбора: сколько унесут и сколько займёт весь поход
|
||||
string GatherPreview(int soldiers)
|
||||
{
|
||||
int[] units = PreviewUnits(soldiers);
|
||||
ResourcePoint p = World.GetPoint(selectedTarget.id);
|
||||
if (units == null || p == null) return "";
|
||||
if (!shownObserved) return "сколько унесут -- неизвестно: точка вне обзора";
|
||||
MapNode home = World.GetNode(WorldMapLayout.PlayerCityId);
|
||||
long path = World.TravelTimeMs(home, selectedTarget, units);
|
||||
World.PreviewGather(p.id, units, MarchManager.NowMs + path, out int amount, out long gatherMs);
|
||||
if (amount <= 0) return "<color=#E06A5A>унесут 0 -- точка исчезнет раньше или некому нести</color>";
|
||||
return $"унесут {amount} {ResourceGenitive[p.kind]}, сбор {Duration(gatherMs)}, весь поход ~{Duration(path * 2 + gatherMs)}";
|
||||
}
|
||||
|
||||
// Ожидаемый исход боя: тот же расчёт, что сделает модуль Боя, с составом, который заберёт Армия
|
||||
string PreviewText(int soldiers)
|
||||
{
|
||||
if (selectedTarget == null || soldiers <= 0) return "";
|
||||
IArmy army = GameServices.Get<IArmy>();
|
||||
var troops = new int[TroopType.Count];
|
||||
for (int i = 0; i < TroopType.Count; i++) troops[i] = army.GetTroops(i) - army.GetGarrison(i); // гарнизон в поход не идёт
|
||||
int[] units = ArmyMath.TakeProportional(troops, soldiers);
|
||||
if (selectedTarget.type == MapNodeType.ResourcePoint) return GatherPreview(soldiers);
|
||||
int[] units = PreviewUnits(soldiers); // гарнизон в поход не идёт
|
||||
if (units == null) return "";
|
||||
if (!shownObserved && !shownReport.HasValue) return "прогноз боя недоступен: гарнизон цели неизвестен";
|
||||
int[] defenders = shownObserved ? WorldMapLayout.GarrisonUnits(selectedTarget) : shownReport.Value.Units; // по отчёту -- на момент отчёта
|
||||
|
||||
// Прогноз с учётом случайности ±5%: показывает риск, а не итог конкретного боя (план от 27.10.2026)
|
||||
BattleForecast f = GameServices.Get<IBattleSystem>().Forecast(new BattleRequest
|
||||
{
|
||||
AttackerUnits = units,
|
||||
DefenderUnits = WorldMapLayout.GarrisonUnits(selectedTarget),
|
||||
Defenders = selectedTarget.garrison,
|
||||
DefenderUnits = defenders,
|
||||
Defenders = Sum(defenders),
|
||||
DefenderFortified = WorldMapLayout.IsFortified(selectedTarget),
|
||||
AttackerConditions = MarchManager.PlayerConditions() // голод сейчас; в бою проверится ещё раз
|
||||
});
|
||||
string chance = f.Chance == BattleChance.Advantage ? "<color=#7CD67C>преимущество</color>"
|
||||
: f.Chance == BattleChance.HighRisk ? "<color=#E06A5A>высокий риск поражения</color>"
|
||||
: "<color=#E8C15A>исход неясен</color>";
|
||||
// Решение №11: качественный риск и рассчитанный шанс победы
|
||||
return $"сила {Range(f.AttackerPowerMin, f.AttackerPowerMax)} против {Range(f.DefenderPowerMin, f.DefenderPowerMax)} -- " +
|
||||
$"{chance}, потери {Range(f.AttackerLossesMin * 100L, f.AttackerLossesMax * 100L)}";
|
||||
$"{chance}, шанс победы {ChanceText(f.WinChancePermille)}, потери {Range(f.AttackerLossesMin * 100L, f.AttackerLossesMax * 100L)}";
|
||||
}
|
||||
|
||||
static int Sum(int[] units)
|
||||
{
|
||||
int n = 0;
|
||||
if (units != null) foreach (var u in units) n += u;
|
||||
return n;
|
||||
}
|
||||
|
||||
// 273 десятых процента -> "27%"; около краёв -- с десятыми, чтобы 99,6% не выглядело как 100%
|
||||
static string ChanceText(int permille)
|
||||
{
|
||||
if (permille > 0 && permille < 10) return "<1%";
|
||||
if (permille > 990 && permille < 1000) return ">99%";
|
||||
return (permille + 5) / 10 + "%";
|
||||
}
|
||||
|
||||
// Диапазон "120-131" (числа x100 -> обычные); одинаковые края -- одно число
|
||||
@@ -436,6 +784,8 @@ public class WorldMapController : MonoBehaviour
|
||||
|
||||
foreach (var march in World.Marches)
|
||||
{
|
||||
// Чужие армии (патрули соседей) рисует IntelligenceOverlay -- только те, что видит Разведка
|
||||
if (march.ownerId != MarchManager.LocalPlayerId) continue;
|
||||
if (!marchViews.TryGetValue(march.id, out MarchView view))
|
||||
{
|
||||
view = MarchView.Create(mapRoot, march);
|
||||
@@ -475,7 +825,7 @@ public class WorldMapController : MonoBehaviour
|
||||
string title = march.victory ? "ПОБЕДА" : "ПОРАЖЕНИЕ";
|
||||
string body = $"{target.displayName}\n" +
|
||||
$"Твоё войско: {march.soldiers}, гарнизон: {march.defenders}\n" +
|
||||
$"Твои потери: {march.soldiers - march.survivors}, потери врага: {march.defenderLosses}\n" +
|
||||
$"Твои потери: {march.soldiers - march.survivors}{WoundedText(march)}, потери врага: {march.defenderLosses}\n" +
|
||||
(march.attackerPower > 0 || march.defenderPower > 0
|
||||
? $"Сила {march.attackerPower / 100} : {march.defenderPower / 100}, " +
|
||||
$"удача {Luck(march.attackerLuck)} / {Luck(march.defenderLuck)}" +
|
||||
@@ -489,8 +839,54 @@ public class WorldMapController : MonoBehaviour
|
||||
EnqueuePopup(title, body);
|
||||
}
|
||||
|
||||
void HandleReconCompleted(MarchData march)
|
||||
{
|
||||
if (GameServices.TryGet(out IIntelligence intel) && intel.TryGetLatestReport(march.targetNodeId, out var report))
|
||||
EnqueuePopup("ОТЧЁТ РАЗВЕДКИ", ReconReportText.Format(report, MarchManager.NowMs) + "\nРазведчики возвращаются домой");
|
||||
}
|
||||
|
||||
void HandleScoutArrived(MarchData march)
|
||||
{
|
||||
if (march.reconLevel > 0 && !march.targetEmpty)
|
||||
{
|
||||
hintText.text = $"Разведка у цели «{World.TargetName(march)}»: наблюдает {Duration(march.gatherEndMs - march.arriveMs)}";
|
||||
return;
|
||||
}
|
||||
string target = World.TargetName(march);
|
||||
hintText.text = march.targetEmpty
|
||||
? $"Разведка: «{target}» уже нет, войско возвращается"
|
||||
: $"Разведка дошла до цели «{target}» и возвращается домой";
|
||||
}
|
||||
|
||||
// «(из них ранены 12 -- придут в госпиталь)»: раненые идут домой с войском
|
||||
static string WoundedText(MarchData march)
|
||||
{
|
||||
int w = 0, missing = 0;
|
||||
if (march.woundedUnits != null) foreach (var u in march.woundedUnits) w += u;
|
||||
if (march.missingUnits != null) foreach (var u in march.missingUnits) missing += u;
|
||||
string text = w > 0 ? $"ранены {w} -- придут в госпиталь" : "";
|
||||
if (missing > 0) text += (text.Length > 0 ? ", " : "") + $"пропали {missing}";
|
||||
return text.Length > 0 ? $" ({text})" : "";
|
||||
}
|
||||
|
||||
void HandleGatherStarted(MarchData march)
|
||||
{
|
||||
string target = World.TargetName(march);
|
||||
if (march.targetEmpty)
|
||||
EnqueuePopup("ТОЧКИ НЕТ", $"{target} исчезла или занята\nСбора не было, домой идут все {march.soldiers} воинов");
|
||||
else
|
||||
hintText.text = $"Войско начало сбор: {target}, унесёт {march.cargo}";
|
||||
}
|
||||
|
||||
void HandleMarchReturned(MarchData march)
|
||||
{
|
||||
if (march.scout)
|
||||
{
|
||||
EnqueuePopup("РАЗВЕДКА ВЕРНУЛАСЬ", $"{World.TargetName(march)}: " +
|
||||
(march.targetEmpty ? "цели уже не было" : "цель разведана") +
|
||||
$"\nВ город вернулись все {march.survivors} воинов, боя не было");
|
||||
return;
|
||||
}
|
||||
string body = $"В город вернулись {march.survivors} солдат\n" +
|
||||
$"Добыча: {MarchManager.FormatLoot(march.loot)}";
|
||||
EnqueuePopup("ВОЙСКО ДОМА", body);
|
||||
|
||||
+72
-1
@@ -15,6 +15,7 @@
|
||||
| `SoldiersAtHome` | Всего воинов в городе (вместе с гарнизоном). |
|
||||
| `TroopsInMarches` | Воинов в походах. |
|
||||
| `GarrisonTotal`, `GetGarrison(type)` | Сколько воинов в гарнизоне — всего и по типам. |
|
||||
| `MarchSlots`, `ActiveMarches` | Слоты похода (регламент 31.10): сколько походов может идти одновременно (база 2 из `MarchConfig`, «Военная логистика» — до 7, позже) и сколько идёт сейчас. `TakeForMarch` отказывает, если все слоты заняты. Походы из старых сохранений сверх лимита дойдут, новых не будет. |
|
||||
| `AvailableForMarch` | Свободные воины: в городе минус гарнизон. Только их можно отправить в поход. |
|
||||
| `SetGarrison(count)` | Назначить гарнизон: набирается по составу армии в городе (30 пехоты и 10 лучников, гарнизон 8 → 6 пехоты и 2 лучника). Не больше, чем воинов в городе; возвращает, сколько назначено. |
|
||||
| `AddTroops(type, count)` | Добавить воинов (обучение в Казармах). |
|
||||
@@ -23,9 +24,66 @@
|
||||
| `ReturnFromMarch(marchId, survivors)` | Вернуть выживших по тем же типам (пропорционально). `false` — поход неизвестен, никто не добавлен. |
|
||||
| `GetMarchUnits(marchId)` | Состав похода по типам — для боя с типами войск. |
|
||||
| `ReturnUnits(marchId, survivorUnits)` | Вернуть выживших точно по типам, как посчитал бой. Больше, чем ушло, не вернётся. `false` — поход неизвестен. |
|
||||
| `WoundedTotal`, `GetWoundedWaiting(type)`, `Healing`, `HospitalBeds` | Раненые всего; ждут места по типам; группы на лечении (`HealingInfo`); мест в госпитале сейчас. |
|
||||
| `ReturnUnits(marchId, survivorUnits, woundedUnits, nowMs)` | Выжившие — в город, раненые — в госпиталь в момент `nowMs`. Только известный поход, один раз. |
|
||||
| `ProcessHealing(nowMs)` | Закончить лечение по сроку (и офлайн), положить ждущих на освободившиеся места; `SoldiersHealedEvent` — один раз на группу. |
|
||||
| `Training` | Очередь обучения: заказы (`TrainingOrderInfo`: номер, тип, сколько, начало и конец в мс часов игры). |
|
||||
| `CanQueueTraining(type, count, queueSize, out error)` | Можно ли поставить заказ: очередь не заполнена, жителей хватает (Население). Ничего не меняет. |
|
||||
| `TryQueueTraining(type, count, durationMs, queueSize, nowMs, out error)` | Поставить заказ в конец очереди; люди уходят из жителей в Казармы (`IPopulation.TryRecruit`). `false` — ничего не изменилось. |
|
||||
| `ProcessTraining(nowMs)` | Закончить заказы, срок которых наступил (и офлайн): воины переходят в Армию через `IPopulation.CompleteTraining`, каждый заказ — один раз. |
|
||||
| `FinishAllTraining(nowMs)` | Ускорение: все заказы готовы сейчас. |
|
||||
|
||||
Получить: `GameServices.Get<IArmy>()`. Регистрирует `App/GameModules`. `GameProgress` (обучение, кампания, арена, сила армии) и панели работают с войсками только через этот контракт.
|
||||
|
||||
## Раненые и госпиталь
|
||||
|
||||
Решения по 8 вопросам Саши от 31.10, п. 7, регламент 31.10. **Раненых хранит и лечит Армия.**
|
||||
|
||||
| Кто | Что делает |
|
||||
| --- | --- |
|
||||
| Бой | Делит выбывших на погибших и раненых (Battle.md). |
|
||||
| Мир | Раненые идут домой вместе с войском (`MarchData.woundedUnits`). |
|
||||
| Армия | Принимает раненых при возвращении, кладёт в госпиталь, лечит, возвращает в город. Сохраняет. |
|
||||
| Население | Считает раненых людьми: `Soldiers` = в городе + в походах + раненые. Погибшие уходят из людей, вылеченные — не новые люди. |
|
||||
| Город | Здание «Госпиталь» (`Meta/Build/Hospital.cs`): уровни I–V, места 20 / 30 / 40 / 50 / 60 (`HospitalConfig.bedsByLevel`, ТЕСТ), считается самый прокачанный госпиталь. Места — Армии через `IHospital.Beds`. Без госпиталя — 5 временных мест (`temporaryBeds`, решения 01.11, п. 3); после постройки — штатные, не вместе с временными. |
|
||||
| Экономика | Цена лечения — `IEconomy.TrySpend` целиком: золото за воина 1 / 1 / 2 / 3 (пехота, лучники, кавалерия, осадные; решения 01.11, п. 3). Нет золота — раненые ждут. |
|
||||
|
||||
- Таблица `Assets/Resources/HospitalConfig.asset` (ТЕСТ): `bedsByLevel` 20…60, `temporaryBeds` 5 (без госпиталя), постройка — Ратуша 1, 250 дерева, 150 камня, `healGameHours` 4 / 4 / 6 / 8 игровых часа (пехота, лучники, кавалерия, осадные; 1 игровой час = 5 реальных минут), цена за воина `healGoldPerSoldier` 1 / 1 / 2 / 3, `healFoodPerSoldier` 0. Цена улучшения госпиталя II–V не утверждена — пока общая цена улучшения зданий.
|
||||
- Раненые ложатся на места по типам по порядку; каждая группа лечится своё время и возвращается в город целиком.
|
||||
- **Мест не хватает — лишние ждут** (ТЕСТ, решение Саши 01.11; регламент не задаёт). Место освободилось — ждущие ложатся в тот же момент, в том числе пока игра закрыта.
|
||||
- Не хватает ресурсов на лечение — группа ждёт, ничего не списано.
|
||||
- Повторное возвращение похода или повторный расчёт никого не создают и не лечат дважды.
|
||||
- Окно «Войска»: раненые (лечатся / ждут места), мест в госпитале, когда вылечатся ближайшие. Окно возвращения и итог боя на карте показывают, сколько ранено.
|
||||
- Окно госпиталя (тап по зданию): мест, кто лечится и сколько осталось, кто ждёт места, улучшение до V уровня (цена — общая цена улучшения из `EconomyConfig`).
|
||||
- Госпиталь улучшили — ждущие ложатся сразу (в течение секунды).
|
||||
- **Дальше:** герои — отдельная очередь лечения (регламент), когда появятся герои.
|
||||
|
||||
## Пропавшие без вести
|
||||
|
||||
Решения по отчёту Саши от 01.11, п. 5.
|
||||
- Бой отделяет часть выбывших в статус «пропал без вести» (`BattleOutcome.AttackerMissingUnits`): солдат ровно в одном статусе — погиб, ранен или пропал. Доля — `BattleConfig.missingSharePermille`, **не утверждена: 0, механика выключена**. Для проверки — например 150 (15%).
|
||||
- При бое Мир передаёт пропавших Армии (`MarkMissing`): они уходят из похода в отдельную группу. Один раз на поход.
|
||||
- Пропавшие не воюют и не едят, но занимают места в населении до возвращения или списания.
|
||||
- Окно возвращения открывается после обратного пути от места боя (бой + время пути домой) и длится до 6 игровых часов. Возвращаются 2–4 группами (меньше, если пропавших мало); тип войск сохраняется; из вернувшихся 70% здоровы, 30% ранены (раненые — в госпиталь по обычным правилам). Исходной армии может уже не быть — здоровые идут в город.
|
||||
- Сколько вернётся — `HospitalConfig.missingReturnPercent`, **ТЕСТ 50%** (утверждён диапазон 10–90%, формула не утверждена). Остальные в конце окна списываются (`MissingWrittenOffEvent`), места освобождаются.
|
||||
- Кто и когда вернётся, решается сразу при бое (детерминированно); группы сохраняются, вернувшаяся группа удаляется — повторная загрузка или расчёт не возвращают её второй раз.
|
||||
- Сохранение: `missing=`, `mgroup=`, `missingMarch=`, `missingNext=`. Окно «Войска» показывает пропавших и сколько ещё могут вернуться; окна итога боя — сколько пропало.
|
||||
|
||||
## Очередь обучения
|
||||
|
||||
Решения по 8 вопросам Саши от 31.10, п. 8: **единственный владелец очереди — Армия.** Раньше её вёл `GameProgress` (`progress.json`, время по настоящим часам) — перенесено.
|
||||
|
||||
| Кто | Что делает |
|
||||
| --- | --- |
|
||||
| Армия | Заказы по порядку (новый начинается, когда закончится последний), сроки, завершение — один раз на заказ (`TroopsTrainedEvent`), сохранение. |
|
||||
| Население | Свободные жители и резерв (`Recruitable`, `CivilianReserve`), уход людей в Казармы (`TryRecruit`) и переход в воины (`CompleteTraining`). |
|
||||
| Слой приложения (`GameProgress`) | Есть ли Казармы и открыт ли тип войск, длина очереди (`Barracks.QueueSize`), цена — через Экономику (если заказ не встал — цена возвращается), окна, статистика заданий по `TroopsTrainedEvent`. |
|
||||
|
||||
- Время — часы игры (`GameClock.UnixNowMs`): перемотка «DEV +1 час» и офлайн досчитывают обучение так же, как марши. Раньше обучение шло по настоящим часам и перемотки не замечало.
|
||||
- Повторный расчёт или загрузка не обучают заказ второй раз: он удаляется из очереди в момент завершения.
|
||||
- Население не нашло новобранцев заказа (испорченное сохранение) — заказ снимается без воинов: люди не появляются из ниоткуда, очередь не встаёт.
|
||||
- **Перенос старой очереди:** после загрузки `App/GameModules` один раз переносит заказы из `progress.json` (`Data.training`) в Армию с тем же оставшимся временем и признаком «люди взяты». Из `progress.json` они удаляются только после записи `save.json`.
|
||||
|
||||
## Правило «один солдат в одном месте»
|
||||
|
||||
Воин либо в городе, либо в походе. Поход забирает воинов из города и запоминает состав, возвращение раздаёт выживших по тем же типам. Тест `ArmyService_MarchNeverCreatesOrLosesSoldiers` проверяет, что «дома + в походах» всегда равно общему числу.
|
||||
@@ -50,6 +108,7 @@
|
||||
## События
|
||||
|
||||
- **Публикует:** `TroopsChangedEvent` (воинов в городе, из них в гарнизоне, и в походах) — при обучении, потерях, походе, возвращении, загрузке, сбросе. По нему `App/GameModules` перерисовывает панели HUD.
|
||||
- **Публикует:** `TroopsTrainedEvent` (номер заказа, тип, сколько, когда были готовы) — один раз на заказ. По нему `GameProgress` ведёт статистику заданий и показывает «Обучено».
|
||||
- **Слушает:** ничего.
|
||||
|
||||
## Сохранение
|
||||
@@ -60,11 +119,16 @@
|
||||
troops=<пехота>,<лучники>,<кавалерия>,<осадные>
|
||||
garrison=<пехота>,<лучники>,<кавалерия>,<осадные> (часть troops)
|
||||
march=<id похода>:<пехота>,<лучники>,<кавалерия>,<осадные>
|
||||
train=<номер>|<тип>|<сколько>|<начало, мс>|<конец, мс>|<люди взяты 1/0> (по порядку очереди)
|
||||
trainNext=<номер следующего заказа>
|
||||
wounded=<пехота>,<лучники>,<кавалерия>,<осадные> (ждут места в госпитале)
|
||||
heal=<номер>|<тип>|<сколько>|<начало, мс>|<конец, мс>
|
||||
healNext=<номер следующей группы лечения>
|
||||
```
|
||||
|
||||
Старое сохранение без строки `garrison` читается: гарнизона нет.
|
||||
|
||||
Сброс (`ResetState`): войск, гарнизона и походов нет.
|
||||
Сброс (`ResetState`): войск, гарнизона, походов, заказов обучения и раненых нет.
|
||||
|
||||
**Перенос из старых сохранений:**
|
||||
- Раньше войска лежали в `progress.json`: `troops` хранил `GameProgress`, `sashaMarchUnits` — мост `ArmyBridge`.
|
||||
@@ -95,6 +159,13 @@ march=<id похода>:<пехота>,<лучники>,<кавалерия>,<о
|
||||
|
||||
| Дата | Кто | Что |
|
||||
| --- | --- | --- |
|
||||
| 04.11.2026 | Claude | Пропавшие без вести (решения 01.11, п. 5): `MissingTotal`, `Missing`, `MarkMissing`, `ProcessMissing`, события `MissingReturnedEvent`, `MissingWrittenOffEvent`; возвращение 2–4 группами в окне 6 игровых часов после обратного пути, 70/30, списание остальных; сохранение. Доля пропавших в бою и процент возврата не утверждены (0 и 50% в таблицах). |
|
||||
| 04.11.2026 | Claude | `IArmy.GetAllTroops(type)` — все воины типа: в городе, в походах и раненые (для еды по типам, решения 01.11, п. 4). |
|
||||
| 04.11.2026 | Claude | Решения по отчёту Саши от 01.11, п. 3: 5 временных мест до постройки госпиталя, цена лечения 1 / 1 / 2 / 3 золота за воина. |
|
||||
| 01.11.2026 | Claude | Здание «Госпиталь» в городе: уровни I–V, 20–60 мест, окно с ранеными и улучшением; места Армии — через `IHospital` (`HospitalBeds`). Без госпиталя мест нет (`temporaryBeds` = 0). Тест `Hospital_BedsFromBuilding_UpgradeFreesWaiting`. |
|
||||
| 01.11.2026 | Claude | Решения 31.10, п. 7: раненые и лечение у Армии — `WoundedTotal`, `Healing`, `HospitalBeds`, `ReturnUnits(…, woundedUnits, nowMs)`, `ProcessHealing`, `SoldiersHealedEvent`; места от `IHospital` (пока нет здания — `HospitalConfig.temporaryBeds`), лишние ждут, цена через Экономику (не утверждена). Сохранение `wounded=`, `heal=`. Тесты: места и сроки, однократность, люди в Населении, сохранение и цена. |
|
||||
| 01.11.2026 | Claude | Решения 31.10, п. 8: очередь обучения перенесена из `GameProgress` в Армию (`Training`, `CanQueueTraining`, `TryQueueTraining`, `ProcessTraining`, `FinishAllTraining`, `TroopsTrainedEvent`, строки `train=` в сохранении), время — часы игры, перенос старой очереди из `progress.json`. Изменены `GameProgress`, `TroopsPanel`, `Barracks`, `BuildingWindow` (код Вальдемара, с разрешения команды). Тесты: порядок и однократность, лимит и ускорение, люди из Населения и обратно, сохранение и перенос. |
|
||||
| 31.10.2026 | Claude | Слоты похода: `MarchSlots`, `ActiveMarches`; `ArmyService(baseMarchSlots)`, база 2 из таблицы `MarchConfig`; `TakeForMarch` отказывает при занятых слотах. Тест `ArmyService_MarchSlots`. |
|
||||
| 28.10.2026 | Claude | По ревью 27.10.2026 (п. 2.1–2.2): `ReturnFromMarch` и `ReturnUnits` возвращают `bool` и зачисляют только по известному походу и только один раз; `TakeForMarch` отклоняет повторный номер похода; дубликаты походов в сохранении пропускаются. Тесты: неизвестный поход, повторное возвращение, повторный номер. |
|
||||
| 27.10.2026 | Claude | Гарнизон города: `GarrisonTotal`, `GetGarrison`, `AvailableForMarch`, `SetGarrison`; в поход уходят только свободные; строка `garrison=` в сохранении; поле `Garrison` в `TroopsChangedEvent`; карточка «Гарнизон города» в окне «Войска». Тест «один солдат в одном месте» с гарнизоном. |
|
||||
| 27.10.2026 | Claude | `GetMarchUnits` и `ReturnUnits`: бой с типами войск получает состав похода, выжившие возвращаются точно по типам. |
|
||||
|
||||
+35
-28
@@ -28,14 +28,15 @@
|
||||
| `AttackerLuckPermille`, `DefenderLuckPermille` | Выпавшая случайность сторон в десятых долях процента: +23 = +2,3%. |
|
||||
| `AttackerConditionPercent`, `DefenderConditionPercent` | Сколько силы оставили состояния: 100 — без штрафов, 50 — голод, 40 — голод и усталость. |
|
||||
| `AttackerLosses`, `DefenderLosses`, `Survivors` | Выбывшие (погибшие + раненые) и выжившие атакующие — всего. |
|
||||
| `…UnitsBefore`, `…SurvivorUnits`, `…DeadUnits`, `…WoundedUnits` | По типам войск и **для обеих сторон**: до боя, выжившие, погибшие, раненые. По каждому типу: до = выжившие + погибшие + раненые. Раненых пока нет (нули): доля не утверждена. |
|
||||
| `…UnitsBefore`, `…SurvivorUnits`, `…DeadUnits`, `…WoundedUnits` | По типам войск и **для обеих сторон**: до боя, выжившие, погибшие, раненые. По каждому типу: до = выжившие + погибшие + раненые. Доля погибших среди выбывших — от соотношения сил своей стороны (см. «Погибшие и раненые»). |
|
||||
| `DefenderLossUnits` | Выбывшие защитники по типам — для старого кода. |
|
||||
|
||||
| `BattleForecast` | Что это |
|
||||
| --- | --- |
|
||||
| `Chance` | `Advantage` — победа при любой случайности, `Uncertain` — решает случайность, `HighRisk` — поражение при любой случайности. |
|
||||
| `WinChancePermille` | Шанс победы нападающего в десятых долях процента (решение №11). Точный: перебираются все 101 × 101 равновероятных сочетаний удачи сторон. |
|
||||
| `AttackerPowerMin/Max`, `DefenderPowerMin/Max` | Сила сторон при крайних значениях случайности. |
|
||||
| `AttackerLossesMin/Max` | Потери атакующего: от лучшего случая до худшего. |
|
||||
| `AttackerLossesMin/Max` | Потери атакующего: от лучшего случая до худшего, с учётом округления потерь (№13). |
|
||||
|
||||
Регистрирует `App/GameModules`: числа боя — из таблицы `BattleConfig`, сила воина каждого типа — из `GameData.Troops` (4 / 5 / 9 / 16). Мир получает модуль при создании симуляции, не через реестр — так симуляцию можно запустить на сервере.
|
||||
|
||||
@@ -54,34 +55,38 @@
|
||||
| Контры, +25% | Пехота сильнее кавалерии, кавалерия сильнее лучников, лучники сильнее пехоты. Бонус взвешивается по составу врага: против армии, где кавалерии 20%, пехота получает +5%. |
|
||||
| Осадные | Против стен +50%, в поле −25%. |
|
||||
| Стены | Защитники за стенами сильнее на 20%. |
|
||||
| Случайность, ±5% | Каждой стороне от −5% до +5% (с шагом 0,1%), отдельно. Считается из номера боя (`Seed`, алгоритм SplitMix64) — одинаково на любой платформе. Применяется последней: после контр, стен и бонусов. |
|
||||
| Удача, ±5% | Решение №12. Каждой стороне от −5% до +5% (с шагом 0,1%), отдельно. Считается из номера боя (`Seed`, алгоритм SplitMix64) — одинаково на любой платформе. Применяется после всех модификаторов. Не прокачивается. |
|
||||
| Без промежуточного округления | Решение №12. Сила считается точной дробью (`BigInteger`): контра по составу врага, бонусы, голод и удача не округляются по дороге. Округляется один раз — только число для показа. Пример: 3 пехоты против 1 кавалерии и 2 пехоты — сила 13,00 (раньше 12,96). |
|
||||
| Голод, −50% | Утверждено 27.10.2026. Сила голодной стороны ×50%. Проверяется на момент боя. Действует и на нападающих, и на защитников. |
|
||||
| Усталость, −20% | Утверждено 27.10.2026. Сила ×80%. Правило уже в модуле, но **пока никто её не выставляет**: не утверждено, как учитывать смешивание свежих и уставших войск. |
|
||||
| Голод и усталость вместе | Последовательно: 50% × 80% = **40%** силы (а не 30%). |
|
||||
| Порядок | Контры и осадные → бонусы стороны → состояния (голод, усталость) → случайность. |
|
||||
| Исход | Побеждает тот, у кого итоговая сила больше; ничья — защитнику. |
|
||||
| Потери проигравшего | Половина каждого типа. |
|
||||
| Потери победителя | Половина × (сила проигравшего / сила победителя): чем ровнее бой, тем больше потерь, но не больше половины. |
|
||||
| Потери (решение №14, регламент 31.10) | Доля выбывших каждого типа зависит от соотношения итоговых сил (сильная / слабая). Опорные точки (ТЕСТ): **1:1 — 45% / 45%**, **3:1 — 16% / 74%**, **5:1 — 11% / 88%**. Между точками — плавно (линейно по соотношению), без порогов. Одинаково для PvE, PvP и Круга. Разгром (решения по 8 вопросам Саши, 31.10, п. 5): **7:1 — 92%**, **10:1 — 95%** у слабой стороны, дальше плавно к пределу 99% (`v = 99% − 4% × 10 / R`: 20:1 — 97%, 100:1 — 98,6%), 100% не достигается. Небольшая армия всё равно может погибнуть целиком из-за округления шансом (№13). Сильная сторона (решения по отчёту Саши, 01.11, п. 1): 5:1 — 11%, плавно до **2% при 10:1**, дальше 2%. Точки — в `BattleConfig` (`lossRatioPermille`, `strongLossPermille`, `weakLossPermille`, предел `weakLossMaxPermille`). |
|
||||
| Округление потерь | Решение №13. Целая часть гарантирована, дробная — шанс ещё одной потери. Бросок — из отдельного потока случайности (своя «соль» на сторону и тип войск, не пересекается с удачей), воспроизводим по номеру боя. Одиночка-проигравший (потеря 0,5) гибнет примерно в половине боёв; 3 проигравших (1,5) теряют 1 или 2. |
|
||||
|
||||
Примеры (замок Змея Горыныча, гарнизон 20: пехота 8, лучники 6, кавалерия 4, осадные 2, за стенами):
|
||||
|
||||
| Атакующие | Сила | Исход | Вернутся |
|
||||
| Атакующие | Исход | Вернутся (в среднем) | Враг теряет из 20 |
|
||||
| --- | --- | --- | --- |
|
||||
| 30 пехоты | 126 против 155 | поражение | 15 |
|
||||
| 40 пехоты | 168 против 155 | победа | 22 |
|
||||
| 30 смешанных (12 / 8 / 6 / 4) | 248 против 154 | победа | — |
|
||||
| 30 пехоты | поражение | 15,5 | 8,3 |
|
||||
| 40 пехоты | победа в 97% боёв | 22,5 | 9,2 |
|
||||
| 30 смешанных (12 / 8 / 6 / 4) | победа | 19,1 | 10,8 |
|
||||
| 78 смешанных | победа | 67,7 | 16,4 |
|
||||
|
||||
**Прогноз с учётом случайности** (тот же замок, 10 000 боёв с разными номерами):
|
||||
|
||||
| Атакующие | Прогноз | Сила | Потери | Побед на деле |
|
||||
| Атакующие | Прогноз | Шанс победы | Сила | Потери |
|
||||
| --- | --- | --- | --- | --- |
|
||||
| 30 пехоты | высокий риск поражения | 119–132 против 147–163 | 15 | 0% |
|
||||
| 36 пехоты | исход неясен | 143–158 против 147–163 | 16–18 | 27% |
|
||||
| 40 пехоты | исход неясен | 159–176 против 147–163 | 16–20 | 97% |
|
||||
| 45 пехоты | преимущество | 179–198 против 147–163 | 16–20 | 100% |
|
||||
| 30 смешанных (12 / 8 / 6 / 4) | преимущество | 235–260 против 146–162 | 7–9 | 100% |
|
||||
| 30 пехоты | высокий риск поражения | 0% | 119–132 против 147–163 | 14–16 |
|
||||
| 36 пехоты | исход неясен | 26,5% | 143–158 против 147–163 | 16–18 |
|
||||
| 40 пехоты | исход неясен | 97,4% | 159–176 против 147–163 | 16–19 |
|
||||
| 45 пехоты | преимущество | 100% | 179–198 против 147–163 | 18–20 |
|
||||
| 30 смешанных (12 / 8 / 6 / 4) | преимущество | 100% | 236–260 против 147–162 | 9–14 |
|
||||
|
||||
Бой без состава (старые походы, `Attackers` и `Defenders` числами) считается так, будто все — пехота. Без стен 30 против 20 — по-прежнему победа и 20 вернувшихся.
|
||||
Шанс проверен тестом `Battle_WinChance_MatchesRealBattles`: совпадает с долей побед в 20 000 настоящих боёв с точностью ±2%.
|
||||
|
||||
Бой без состава (старые походы, `Attackers` и `Defenders` числами) считается так, будто все — пехота. Без стен 30 против 20 (1,5:1) — победа, возвращаются 18–19.
|
||||
|
||||
## События
|
||||
|
||||
@@ -94,22 +99,18 @@
|
||||
## Решения и план
|
||||
|
||||
- **Сделано 28.10.2026 (этап 2 плана):** числа — в таблицу `BattleConfig` с версией; итог боя симметричный для обеих сторон; случайность ±5% из номера боя; прогноз «преимущество / исход неясен / высокий риск поражения».
|
||||
- **Открыто: прогноз.** «Исход неясен» охватывает и 27%, и 97% побед (таблица выше). Показывать ли игроку шанс победы в процентах — решает команда (посчитать его можно точно).
|
||||
- **Решено комплектом 29.10.2026 и сделано 30.10.2026:** шанс победы в прогнозе (№11), сила без промежуточного округления (№12), округление потерь шансом (№13), голод на момент боя по истории голода Населения.
|
||||
- **Сделано 28.10.2026: голод в бою.** Голод игрока берётся из модуля Населения (`IPopulation.IsStarving`) в момент боя. Пример: 40 пехоты берут замок Змея Горыныча (168 против 155), голодные — нет (84 против 155). Числа — `famineStrengthPercent` и `fatigueStrengthPercent` в `BattleConfig` (версия правил 2).
|
||||
- **Ограничение голода в офлайне:** если бой прошёл, пока игра была закрыта, берётся голод на момент входа в игру — истории голода у модуля Населения нет. Точно — когда бои будет считать сервер или Население будет хранить, когда начался и кончился голод (договориться с экономикой).
|
||||
- **Голод в офлайн-бою:** Население хранит историю голода (`IPopulation.WasStarvingAt`, 48 часов, точность — шаг расчёта 10 минут). Перед боем, прошедшим в прошлом, мир просит Население досчитать время, затем спрашивает голод на момент прихода войска.
|
||||
- **Голод гарнизона** пока не нужен: на город игрока никто не нападает. Правило защитника уже есть (`DefenderConditions`).
|
||||
- **Открыто: порядок бонусов и случайности.** Сейчас случайность применяется последней, после бонусов стороны.
|
||||
- **Порядок бонусов и случайности** решён (№12): удача — после всех модификаторов.
|
||||
- **Номер боя в мультиплеере** должен выдавать сервер: иначе клиент мог бы подбирать удачный.
|
||||
- **Командный план и ревью от 27.10.2026** (`Bogatyri_Plan_razrabotki.docx`, `Bogatyri_Battle_Army_Review_27-10-2026.docx`): случайность ±5% каждой стороне (воспроизводимая), прогноз риска вместо точного итога, потери от соотношения сил, раненые и погибшие, голод −50%, усталость −20%, числа — в настройки. Делается на этапе 2 плана.
|
||||
- **Открыто: малые отряды и округление.** Потери округляются вниз по каждому типу, поэтому одиночный проигравший не гибнет никогда. Проверено 28.10.2026:
|
||||
|
||||
| Бой | Исход | Потери атакующего | Потери защитника |
|
||||
| --- | --- | --- | --- |
|
||||
| 1 против 1 | ничья, защитнику | 0 | 0 |
|
||||
| 1 против 10 | поражение | 0 | 0 |
|
||||
| 10 против 1 | победа | 0 | 0 |
|
||||
|
||||
Варианты: округлять потери проигравшего вверх; или воспроизводимая случайность для остатка (одиночка гибнет с шансом 50%). Решает команда, тест `Battle_EdgeCases_OutcomeAndArithmetic` правило не фиксирует.
|
||||
- **Малые отряды** решены (№13): одиночка-проигравший гибнет с шансом по дробной части потерь.
|
||||
- **Сделано 31.10.2026: кривая потерь (№14)** по опорным точкам регламента 31.10.
|
||||
- **Сделано 01.11.2026: разгром дальше 5:1** по решениям 31.10, п. 5. Потери сильной стороны после 5:1 — решены 01.11 (до 2% при 10:1).
|
||||
- **Сделано 01.11.2026: погибшие и раненые** (регламент 31.10, решения по 8 вопросам Саши, п. 7). Из выбывших стороны погибает доля по её соотношению сил (своя / чужая): **1:5 — 70%**, **1:2 — 45%**, **1:1 — 30%**, **3:1 и выше — 20%**, между точками плавно; остальные — раненые. Дробная часть — бросок из отдельного потока (не удачи и не потерь). Точки — `BattleConfig` (`deadRatioPermille`, `deadSharePermille`). Версия правил 6. Раненых хранит и лечит Армия (Army.md).
|
||||
- **Открыто:** «пропавшие без вести» (регламент) — отдельно не считаются.
|
||||
|
||||
- **Утвердить формулу** (контры, стены, осадные, потери) или поправить числа в `BattleSystem.cs`.
|
||||
- **Бонус героя** пока не передаётся в поход: `GameProgress.ArmyBonus` и сила героя в слое приложения. Нужен способ передать их в `AttackerBonusPercent` — например, через новый контракт или поле похода.
|
||||
@@ -120,6 +121,12 @@
|
||||
|
||||
| Дата | Кто | Что |
|
||||
| --- | --- | --- |
|
||||
| 04.11.2026 | Claude | Пропавшие без вести (решения 01.11, п. 5): из выбывших сначала отделяются пропавшие (`MissingSharePermille`, не утверждено — 0), остальные делятся на погибших и раненых. `BattleOutcome.AttackerMissingUnits` / `DefenderMissingUnits`. Версия правил 8. |
|
||||
| 04.11.2026 | Claude | Решения по отчёту Саши от 01.11, п. 1: потери сильной стороны 5:1 → 10:1 плавно с 11% до 2%, дальше 2% (`strongLossPermille` 450 / 160 / 110 / 74 / 20). Версия правил 7. |
|
||||
| 01.11.2026 | Claude | Раненые (решения 31.10, п. 7): выбывшие делятся на погибших и раненых по соотношению сил стороны — 70% / 45% / 30% / 20% погибших при 1:5 / 1:2 / 1:1 / 3:1. Таблица в `BattleConfig`, версия правил 6, тест `Battle_DeadAndWounded_ShareBySideRatio`. |
|
||||
| 01.11.2026 | Claude | Разгром дальше 5:1 (решения 31.10, п. 5): точки 7:1 — 92% и 10:1 — 95%, дальше слабая сторона плавно стремится к 99% (`weakLossMaxPermille`). Версия правил 5. Тест кривой продлён до 30:1. |
|
||||
| 31.10.2026 | Claude | Кривая потерь (решение №14, регламент 31.10): доля выбывших от соотношения итоговых сил по опорным точкам 1:1 — 45% / 45%, 3:1 — 16% / 74%, 5:1 — 11% / 88%, между ними плавно; вместо «проигравший 50%». Точки в `BattleConfig`, неверная таблица — значения по умолчанию. Версия правил 4. Тест `Battle_LossCurve_ControlPointsAndSmoothness`; тесты округления пересчитаны под кривую. |
|
||||
| 30.10.2026 | Claude | Комплект требований 29.10, решения №11–13: точный шанс победы в прогнозе (`BattleForecast.WinChancePermille`); сила — точной дробью без промежуточного округления; потери — целая часть гарантирована, дробная — шанс из отдельного потока случайности. Версия правил 3. Тесты: шанс совпадает с настоящими боями, сила без округления, округление потерь. |
|
||||
| 28.10.2026 | Claude | Голод и усталость: `BattleCondition` (флаги), `BattleRequest.AttackerConditions` / `DefenderConditions`, `BattleOutcome.…ConditionPercent`; голод −50%, усталость −20%, вместе 40% (последовательно); числа в `BattleConfig` и `BattleRules` (версия 2). Тесты: штрафы, голод переворачивает бой у нападающего и у защитника, прогноз с голодом. |
|
||||
| 28.10.2026 | Claude | Этап 2 плана: числа боя — в таблицу `BattleConfig` (`Assets/Resources/BattleConfig.asset`) и `BattleRules` с версией; случайность ±5% каждой стороне из `BattleRequest.Seed`; `Forecast` — прогноз риска; `BattleOutcome` симметричный: до боя, выжившие, погибшие, раненые (пока нули) по типам у обеих сторон, номер боя, версия правил, удача сторон. Тесты: случайность воспроизводима и в пределах ±5%, прогноз не противоречит бою, итог сходится по типам, правила из таблицы. |
|
||||
| 28.10.2026 | Claude | Тест крайних случаев (ревью, п. 2.4): 1×1, 1×10, 10×1, 0×0, пустая сторона, смешанный состав, бонусы −100%, −500%, +100000%, бой числом. Проверяются исход и арифметика (нет отрицательных, выжившие + погибшие = ушедшие). Правило округления потерь — открытый вопрос. |
|
||||
|
||||
+14
-1
@@ -33,7 +33,10 @@
|
||||
| `ILeveledBuilding` | Здания с уровнем (`ResourceCollector`) | Уровень здания — его сохраняет Поселение. |
|
||||
| `IPopulation` | Население (`PopulationService`) | Жители, рабочие по профессиям, воины, предел жилья, расход еды и прирост в час, голод и его история (`WasStarvingAt`), найм воинов из жителей; `Tick` — досчитать до момента. |
|
||||
| `IArmy` | Армия (`ArmyService`) | Войска по типам, в городе и в походах; обучение, потери; забрать в поход, вернуть выживших. |
|
||||
| `IWorld` | Мир (`MarchManager`) | Сколько походов в пути; начать поход. |
|
||||
| `IWorld` | Мир (`MarchManager`) | Сколько походов в пути; начать поход; начать поход «Разведка» (`TryStartScout`). |
|
||||
| `IWorldMap` | Мир (`MarchManager`) | Для Разведки: границы карты, где поселение, все армии в момент времени (`ArmyOnMap`). |
|
||||
| `IIntelligence` | Разведка (`IntelligenceService`) | Туман (`GetVisibility`), «Обзор», известные чужие армии (`KnownContact`), `ObserveUntil`. |
|
||||
| `IHospital` | Город — здание «Госпиталь» (`HospitalBeds`, регистрирует `App/GameModules`) | Мест для лечения (`Beds`) по уровню самого прокачанного госпиталя; 0 — госпиталя нет. |
|
||||
| `IBattleSystem` | Бой (`BattleSystem`) | Посчитать исход боя по `BattleRequest`: состав сторон по типам, стены, бонусы. |
|
||||
| `IChat` | Чат (`ChatService`) | История каналов, можно ли писать в канал, отправка сообщения от локального игрока. |
|
||||
| `ICircle` | Круг (`CircleService`) | Круг игрока, список Кругов; основать, вступить, выйти. |
|
||||
@@ -58,8 +61,18 @@
|
||||
|
||||
| Дата | Кто | Что |
|
||||
| --- | --- | --- |
|
||||
| 04.11.2026 | Claude | Разведка М2: `ReconTargetKind`, `ReconTarget`, `ReconReport`; `IWorldMap.TryGetReconTarget`; `IIntelligence.ReconDurationMs/CompleteRecon/Reports/TryGetLatestReport`; `IWorld.TryStartRecon`; события `ReconStartedEvent`, `ReconCompletedEvent`. |
|
||||
| 04.11.2026 | Claude | Пропавшие без вести: `MissingInfo`, `IArmy.MissingTotal/Missing/MarkMissing/ProcessMissing`, `BattleOutcome.*MissingUnits`, события `MissingReturnedEvent`, `MissingWrittenOffEvent`, поля `Missing` у `TroopsChangedEvent` и `MarchReturnedEvent`. |
|
||||
| 01.11.2026 | Claude | Раненые (решения 31.10, п. 7): `IHospital`, `HealingInfo`; `IArmy`: `WoundedTotal`, `GetWoundedWaiting`, `Healing`, `HospitalBeds`, `ReturnUnits(…, woundedUnits, nowMs)`, `ProcessHealing`; события `SoldiersHealedEvent`, `TroopsChangedEvent.Wounded`, `MarchReturnedEvent.Wounded`. |
|
||||
| 01.11.2026 | Claude | `IArmy`: очередь обучения (`Training`, `CanQueueTraining`, `TryQueueTraining`, `ProcessTraining`, `FinishAllTraining`), `TrainingOrderInfo`, событие `TroopsTrainedEvent`; `GameClock.UnixNowMs` (решения 31.10, п. 8). |
|
||||
| 01.11.2026 | Claude | `IWorld.TryStartScout`; `IsScout` у `MarchStartedEvent` и `MarchReturnedEvent` (решения 31.10, п. 2). |
|
||||
| 31.10.2026 | Claude | Разведка М1: контракты `IWorldMap`, `IIntelligence` (`ArmyOnMap`, `MapVisibility`, `KnownContact`), события `WorldAdvancingEvent`, `ArmySpottedEvent`, `ArmyIdentifiedEvent`, `ArmyLostContactEvent`. |
|
||||
| 31.10.2026 | Claude | `IPopulation.CompleteTraining(type, n)` — передача новобранцев в Армию одним действием. |
|
||||
| 31.10.2026 | Claude | `IPopulation.Workforce` — все жители (ограничения «40% всех людей» больше нет), `CivilianReserve` — по уровню Ратуши. Население — самостоятельный модуль. |
|
||||
| 31.10.2026 | Claude | `MarchReturnedEvent.IsGather` — поход на ресурсную точку. |
|
||||
| 31.10.2026 | Claude | `IArmy.MarchSlots`, `IArmy.ActiveMarches` — слоты похода. |
|
||||
| 30.10.2026 | Claude | События похода: `TimeMs` (когда случилось по часам игры) у `MarchStartedEvent`, `MarchBattleResolvedEvent`, `MarchReturnedEvent`; `BattleId` у `MarchBattleResolvedEvent`. |
|
||||
| 30.10.2026 | Claude | `BattleForecast.WinChancePermille` — шанс победы (решение №11). |
|
||||
| 28.10.2026 | Claude | `IPopulation`: `WasStarvingAt` (история голода для боя), найм — `CivilianReserve`, `Recruitable`, `InTraining`, `TryRecruit`, `RecruitsTrained`. |
|
||||
| 28.10.2026 | Claude | Бой: `BattleCondition` (голод, усталость), `BattleRequest.AttackerConditions` / `DefenderConditions`, `BattleOutcome.AttackerConditionPercent` / `DefenderConditionPercent`. |
|
||||
| 28.10.2026 | Claude | Бой: `BattleRequest.Seed`; `BattleOutcome` — номер боя, версия правил, удача сторон, состав до боя, выжившие, погибшие и раненые по типам у обеих сторон; `IBattleSystem.Forecast`, `BattleForecast`, `BattleChance`. |
|
||||
|
||||
@@ -0,0 +1,140 @@
|
||||
# Разведка
|
||||
|
||||
Туман войны, источники обзора, чужие армии и последний контакт. Этап М1 по ТЗ разведки от 31.10.2026, решение №46: отдельный модуль.
|
||||
|
||||
- **Сборка:** `Bogatyri.Intelligence` (без Unity: тот же код будет считать видимость на сервере).
|
||||
- **Папка:** `Assets/Scripts/Modules/Intelligence`.
|
||||
- **Зависит от:** только ядра. Карту и армии читает у Мира через контракт `IWorldMap`, отряды — их часть. Сам Мир о Разведке не знает: прямых ссылок между World и Intelligence нет.
|
||||
- **Отвечает:** Саша (решение №46).
|
||||
|
||||
## Что умеет М1
|
||||
|
||||
| | |
|
||||
| --- | --- |
|
||||
| Туман | Три состояния клетки: **не исследовано**, **исследовано** (было в обзоре), **видно сейчас**. Клетка = клетка карты (1000 милли-единиц). |
|
||||
| Источники обзора | Своё поселение — 5 клеток, своя армия в походе — 1 клетка. Башни и герой-разведчик — позже (числа в правилах уже есть). |
|
||||
| «Обзор» I/II/III | +10 / +20 / +30% к радиусам. Уровни **не складываются** — действует текущий. Пока нет дерева технологий, уровень для теста задаётся в таблице. |
|
||||
| Чужие армии | Видны, только пока они в обзоре. Примерная численность ±20%, владелец — после опознания. |
|
||||
| Событие наблюдения | Армия вошла в обзор. На событие — **один** бросок численности и **один** бросок опознания (50%). Повторный расчёт, загрузка или нажатие не перебрасывают. Вышла и вошла снова — новое событие. |
|
||||
| Последний контакт | Армия вышла из обзора — остаётся бледная метка с последними данными. Данные больше не обновляются. Метка живёт 10 **реальных** минут. |
|
||||
| Офлайн | Наблюдение досчитывается шагами по 10 реальных секунд, не больше 48 часов. Армия, прошедшая через обзор, пока игра была закрыта, тоже будет замечена — события в порядке времени. |
|
||||
|
||||
Примерная численность: окно шириной 40% от настоящей численности, сдвинутое случайно так, чтобы настоящая численность всегда была внутри. Пример: 50 воинов → «~42–62».
|
||||
|
||||
## Контракт `IIntelligence`
|
||||
|
||||
| Член | Что делает |
|
||||
| --- | --- |
|
||||
| `ObservationLevel` | Уровень «Обзора» 0..3. |
|
||||
| `GetVisibility(x, y)` | `Unexplored` / `Explored` / `Observed` для точки карты — по последнему расчёту. |
|
||||
| `Contacts` | Известные чужие армии (`KnownContact`): где, куда идёт, `~ApproxMin–ApproxMax`, опознан ли и чей (`OwnerId` — только после опознания), видна ли сейчас, когда видели. |
|
||||
| `ObserveUntil(nowMs)` | Досчитать наблюдение до момента. Зовёт `App/GameModules` по `WorldAdvancingEvent`. |
|
||||
|
||||
## Что берёт у Мира: `IWorldMap`
|
||||
|
||||
Реализует `MarchManager` (модуль Мира).
|
||||
|
||||
| Член | Что это |
|
||||
| --- | --- |
|
||||
| `HalfWidth`, `HalfHeight` | Границы карты от центра. |
|
||||
| `TryGetSettlement(ownerId, …)` | Где поселение игрока. |
|
||||
| `GetArmies(timeMs, …)` | Все армии на карте в момент `timeMs` (`ArmyOnMap`: id, владелец, где, куда, сколько воинов). Позиция считается по времени похода, поэтому можно спросить и о прошедших минутах. |
|
||||
|
||||
## События
|
||||
|
||||
**Публикует** (у всех — `EventId` = «армия#номер наблюдения» и `TimeMs` по часам игры):
|
||||
- `ArmySpottedEvent` — чужая армия вошла в обзор, с примерной численностью;
|
||||
- `ArmyIdentifiedEvent` — владелец опознан;
|
||||
- `ArmyLostContactEvent` — армия вышла из обзора.
|
||||
|
||||
**Слушает:** ничего напрямую. `WorldAdvancingEvent` (публикует Мир перед каждым расчётом) связан с `ObserveUntil` в `App/GameModules`.
|
||||
|
||||
## М2: целенаправленная разведка и отчёты (сделано 04.11.2026)
|
||||
|
||||
ТЗ разведки, раздел 6. Отряд физически идёт к цели маршем Мира, стоит и наблюдает, отчёт фиксируется на конец наблюдения, затем отряд идёт домой. Постоянного слежения нет: старый отчёт не обновляется.
|
||||
|
||||
| Цель | Уровень II | Уровень III |
|
||||
| --- | --- | --- |
|
||||
| Поселение (соседний город) | 2 игровых часа | 4 |
|
||||
| Замок | 3 | 6 |
|
||||
| Лагерь (в ТЗ не назван — как поселение, ТЕСТ) | 2 | 4 |
|
||||
| Вражеская армия (1 / 2 ч) | **ещё нет** — движущаяся цель, позже | |
|
||||
|
||||
1 игровой час = 5 реальных минут.
|
||||
|
||||
- **Уровень I** — обычное наблюдение (М1): примерная численность в зоне обзора.
|
||||
- **Уровень II** — точное число и типы войск, есть ли герой, стены.
|
||||
- **Уровень III** — то же плюс защита (стены, герой) и ресурсы цели: оценка ±15% (окно, в котором точно лежит настоящее значение; бросок — по id отчёта).
|
||||
- Время наблюдения даёт Разведка (`ReconDurationMs`), Мир держит отряд у цели (`MarchData.reconLevel`, `reconHoldMs`, состояние «наблюдает») и сообщает `WorldEventType.ReconCompleted`; Разведка составляет отчёт по снимку цели от Мира (`IWorldMap.TryGetReconTarget`) — **один раз на операцию** (id `recon_<номер похода>`), повтор после загрузки ничего не создаёт.
|
||||
- События: `ReconStartedEvent`, `ReconCompletedEvent`. Отчёты сохраняются (`report=`), хранятся последние 30.
|
||||
- Числа — в `IntelligenceRules` (`ReconSettlementGameHours`, `ReconCastleGameHours`, `ReconCampGameHours`, `ResourceEstimatePercent`).
|
||||
|
||||
**На карте:** в окне атаки — «Разведка II» и «Разведка III» (у ресурсной точки — просто «Разведка»: дойти и вернуться). Отряд у цели подписан «наблюдает». По окончании — окно «ОТЧЁТ РАЗВЕДКИ». Кнопка «Отчёты» под «Армиями» — последние отчёты. Если цель вне обзора, но есть отчёт, окно атаки показывает гарнизон «по отчёту N мин назад» и прогноз боя по нему.
|
||||
|
||||
## Патрули-заглушки (временно)
|
||||
|
||||
Решение команды 31.10.2026: для проверки М1 соседние поселения иногда отправляют тестовые отряды к другим городам и лагерям. **Это временная тестовая механика, а не ИИ соседей.**
|
||||
|
||||
- Патрули — обычные походы Мира (`MarchData.patrol`): Разведка видит их через тот же `IWorldMap`, что и настоящие армии. Когда появится PvP, их выключают в таблице — Разведка не меняется.
|
||||
- Боя, добычи и разбития лагеря нет. Армия игрока, окна итогов и события похода их не касаются.
|
||||
- Выходят из ближайших к игроку соседних городов и идут к ближайшим к игроку целям — чтобы проходили через обзор.
|
||||
- Выпускаются по расписанию из seed карты: тот же расчёт после офлайна даёт те же патрули. Сохраняются в секции `world`.
|
||||
- Таблица `MarchConfig`: `patrolsEnabled` (вкл/выкл), `patrolMaxActive` 3, `patrolIntervalMinutes` 10 реальных минут, `patrolSoldiersMin/Max` 10–40.
|
||||
|
||||
## Карта мира
|
||||
|
||||
`WorldMap/IntelligenceOverlay.cs` рисует то, что вернула Разведка:
|
||||
- туман: не исследовано — тёмное, исследовано — притушено, в обзоре — чисто;
|
||||
- чужая армия в обзоре — красный ромб, подпись «чужая армия / ~42–62 воинов» или имя владельца, если опознан;
|
||||
- последний контакт — бледный ромб «контакт N мин назад».
|
||||
|
||||
Свои походы рисуются как раньше (`MarchView`). Чужие походы `WorldMapController` сам не рисует — только через Разведку.
|
||||
|
||||
**Что видно вне обзора** (решения по 8 вопросам Саши от 31.10, п. 1 — «Объекты видны, туман — для армий»):
|
||||
- города, замок, лагеря и ресурсные точки видны всегда — как ориентиры, туман затемняет только землю;
|
||||
- закрытые сведения — только пока объект в зоне обзора: гарнизон (на карте и в окне атаки), запас и срок ресурсной точки. Вне обзора — «неизвестно: вне обзора»;
|
||||
- поэтому вне обзора нет и прогноза: ни шанса победы, ни «сколько унесут». Напасть или пойти на сбор можно;
|
||||
- то, что игрок знает сам, видно всегда: лагерь разбит им и когда появится, на точке идёт его сбор;
|
||||
- `IntelligenceConfig.hideUnexploredObjects` (выключено) закрывает неисследованное вместе с объектами — полное скрытие для М1 не требуется, переключатель оставлен (тап по скрытому объекту при нём работает).
|
||||
|
||||
## Таблица `IntelligenceConfig`
|
||||
|
||||
`Assets/Resources/IntelligenceConfig.asset`, числа — ТЕСТ: `settlementRadius` 5, `armyRadius` 1 (клеток), `observationPercent` 10/20/30, `testObservationLevel` (только для теста), `lastContactMinutes` 10, `approxPercent` 20, `identifyPercent` 50, `sampleStepSeconds` 10, `hideUnexploredObjects`.
|
||||
|
||||
## Сохранение
|
||||
|
||||
Секция `"intelligence"`, простые строки (модуль без Unity):
|
||||
- `tick=<мс>` — до какого момента посчитано наблюдение;
|
||||
- `obzor=<уровень>`;
|
||||
- `grid=<ширина>x<высота>:<hex>` — исследованные клетки, по биту на клетку;
|
||||
- `contact=<армия>|<владелец>|<опознан>|<видна>|x|y|toX|toY|min|max|<видели>|<номер наблюдения>`.
|
||||
|
||||
Сброс (`ResetState`): туман закрыт, контактов нет, «Обзор» 0.
|
||||
|
||||
## Файлы
|
||||
|
||||
| Файл | Что это |
|
||||
| --- | --- |
|
||||
| `IntelligenceService.cs` | `IntelligenceRules` (числа) и `IntelligenceService` (`IIntelligence`, `ISaveParticipant`). |
|
||||
| `Bogatyri.Intelligence.asmdef` | Сборка: только ядро, без Unity. |
|
||||
|
||||
Вне модуля: `App/IntelligenceConfig.cs` (таблица), `WorldMap/IntelligenceOverlay.cs` (рисование), `World/Simulation/WorldSimulation.Patrols.cs` (патрули и позиция армии в момент времени — часть Мира).
|
||||
|
||||
## Тесты
|
||||
|
||||
`ModuleTests`: вход и выход из обзора, последний контакт и его устаревание, свои армии как источники, «Обзор» заменяет уровень, туман «исследовано» остаётся, офлайн-проход через обзор, воспроизводимые броски и ~50% опознаний, новое событие при повторном входе, сохранение и загрузка без повторного обнаружения; патрули без боёв и событий, выключение, воспроизводимость и сохранение, позиция по времени, патрули замечаются Разведкой.
|
||||
|
||||
## Решения и план
|
||||
|
||||
- М2–М4 по ТЗ: башни, герой-разведчик, разведка поселений, отчёты — следующими этапами.
|
||||
|
||||
## Журнал изменений
|
||||
|
||||
| Дата | Кто | Что |
|
||||
| --- | --- | --- |
|
||||
| 04.11.2026 | Claude | М2: целенаправленная разведка поселений, замка и лагерей с отчётами уровней II и III (`ReconDurationMs`, `CompleteRecon`, `Reports`, `TryGetLatestReport`, `ReconStartedEvent` / `ReconCompletedEvent`, сохранение `report=`); на карте — кнопки «Разведка II/III», окно отчёта, «Отчёты», прогноз по отчёту. Разведка армий — позже. |
|
||||
| 04.11.2026 | Claude | 2.5D: туман рисуется в текстуре земли (объекты стоят над ней и видны всегда), метки чужих армий — ромбы-кубы с подписью к камере. `hideUnexploredObjects` в 3D пока только сильнее затемняет землю. |
|
||||
| 01.11.2026 | Claude | Поход «Разведка» (решения 31.10, п. 2) — команда Мира; что войско увидит, показывает Разведка. См. World.md. |
|
||||
| 01.11.2026 | Claude | Решения 31.10, п. 1: объекты видны всегда, а гарнизоны, запас и срок точек, прогноз боя и сбора — только в зоне обзора (`WorldMapController`). |
|
||||
| 31.10.2026 | Claude | Исправлено: после перезапуска или перемотки обратный путь войска не открывал туман (до расчёта боя Разведка считала, что войско стоит у цели). Мир досчитывается по событиям (`WorldSimulation.AdvanceInSteps`), Разведка — до каждого из них. Туман темнее. |
|
||||
| 31.10.2026 | Claude | Модуль создан: этап М1 — туман, источники обзора, «Обзор», чужие армии, примерная численность, опознание, последний контакт, офлайн-наблюдение, сохранение. Патрули-заглушки соседей для проверки (выключаются в `MarchConfig`). |
|
||||
@@ -31,7 +31,7 @@
|
||||
| `Civilians`, `Workers`, `Idle` | Жители, из них на работе и остальные. |
|
||||
| `Workforce`, `FreeWorkers` | Сколько могут работать; сколько из них без работы. |
|
||||
| `GetWorkers(job)`, `SetWorkers(job, n)` | Рабочие профессии; поставить n (в пределах мест и свободных). |
|
||||
| `Soldiers` | Воины — из модуля Армии. |
|
||||
| `Soldiers` | Воины — из модуля Армии: в городе, в походах и раненые (решения 31.10, п. 7: раненые — тоже люди). |
|
||||
| `HousingCap` | Предел населения. |
|
||||
| `FoodPerHour`, `GrowthPerHour` | Расход еды и прирост в час сейчас. |
|
||||
| `IsStarving` | Еды не хватило на последний расчёт. |
|
||||
@@ -106,12 +106,16 @@
|
||||
- п. 8, норма еды на солдата -- сейчас 0.2 еды в час реального времени, игрового календаря нет. Предложение: не вводить; если нужен «игровой месяц» -- 1 месяц = 1 сутки, норма ≈ 5 еды. Решает Дима.
|
||||
- **Этап 5:** найм воина забирает человека из жителей (гражданский резерв — решение от 19.10.2026) — сделано 28.10.2026. Цену воина в ресурсах (`EconomyConfig`, раздел «Солдат»: 15 еды, 5 металла, 5 золота) Казармы пока не используют — у них своя цена в `GameData.Troops`.
|
||||
- **Схема модулей:** Население — самостоятельный модуль (регламент 28.10 и 31.10.2026). Перенос внутрь Поселения от 28.10 был ошибкой и откатан 31.10.
|
||||
- **Открыто (регламент 31.10, ждёт решения):** нормы еды для четырёх групп (гражданские и рабочие, новобранцы, солдаты, раненые); переход экономики на игровое время (1 игровой час = 5 реальных минут) и единицы офлайна (48 ч) и истории голода; кто считает предел жилья и рабочие места (по регламенту — Поселение); недоступен ли резерв и для работы; перенос очереди найма из `GameProgress` в Армию (с Сашей).
|
||||
- **Открыто (регламент 31.10, ждёт решения):** нормы еды для четырёх групп (гражданские и рабочие, новобранцы, солдаты, раненые); переход экономики на игровое время (1 игровой час = 5 реальных минут) и единицы офлайна (48 ч) и истории голода; кто считает предел жилья и рабочие места (по регламенту — Поселение); недоступен ли резерв и для работы.
|
||||
|
||||
## Журнал изменений
|
||||
|
||||
| Дата | Кто | Что |
|
||||
| --- | --- | --- |
|
||||
| 04.11.2026 | Claude (Саша) | Пропавшие без вести (решения 01.11, п. 5) занимают места в населении (`Soldiers` включает `IArmy.MissingTotal`), но не едят. |
|
||||
| 04.11.2026 | Claude (Саша) | Решения по отчёту Саши от 01.11, п. 4: воины едят по норме типа — пехота 0,15, лучники 0,20, кавалерия 0,15, осадные 0,15 в час (`PopulationRules.FoodPerTroopTypePerHour`, `EconomyConfig.population.foodPerTroopTypePerHour`); раненые — полную норму своего типа, даже ожидая койку (`IArmy.GetAllTroops`). Новобранцы — по `foodPerSoldierPerHour`. Без таблицы — как раньше (тесты Населения не менялись). Час — тот же, что у остальной еды (переход еды на игровые часы — открытый вопрос). |
|
||||
| 01.11.2026 | Claude (Саша) | Раненые считаются людьми: `Soldiers` = в городе + в походах + `IArmy.WoundedTotal` (решения 31.10, п. 7). Погибшие уходят из людей, вылеченные не появляются заново. Еда раненых — как у воинов (нормы четырёх групп — открытый вопрос). |
|
||||
| 01.11.2026 | Claude (Саша) | Очередь обучения перенесена в Армию (решения 31.10, п. 8). Население по-прежнему отдаёт жителей (`TryRecruit`) и принимает новобранцев в воины (`CompleteTraining`) — его код не менялся, зовёт их теперь Армия. `RecruitsTrained` больше никто не вызывает. |
|
||||
| 31.10.2026 | Claude | `CompleteTraining`: новобранцы переходят в Армию одним действием с откатом, если Армия не приняла. Заказ обучения помечает, брали ли под него людей (`TrainingOrder.recruited`); старые заказы — по-старому. Интеграционные тесты с настоящей Армией: переход без потерь, отказ Армии, повтор, нет Армии, часть заказа. |
|
||||
| 31.10.2026 | Claude | Автозаполнение новых мест убрано (`AutoFill` удалён, `App/CitySync` больше не ставит рабочих после стройки и улучшения), осталась только стартовая расстановка один раз. При загрузке рабочих не больше, чем жителей. Тесты: группы людей не пересекаются и в сумме дают всех, рабочих не больше свободных, новые места пустые, стартовая расстановка один раз. |
|
||||
| 31.10.2026 | Claude | По регламенту 31.10: Население снова самостоятельный модуль (`Modules/Population`, сборка `Bogatyri.Population`); убрано ограничение «40% всех людей» — работать может любой житель, первая расстановка — 120 рабочих; резерв по уровню Ратуши 10/20/30 (ТЕСТ, `civilianReserveByTownHallLevel` вместо `civilianReserve`); при голоде добыча кроме еды ×0.5 (ТЕСТ). Тесты. |
|
||||
|
||||
+24
-2
@@ -1,6 +1,6 @@
|
||||
# Модульная система «Богатырей»
|
||||
|
||||
Игра собрана из десяти модулей вокруг общего **Игрового ядра** (регламент 31.10.2026; модуль Разведки — в ветке Саши `feature/intelligence-m1`, на схеме появится с ней). Модули общаются только через контракты и события ядра и не управляют внутренним кодом друг друга. Это правило проверяет сам Unity: каждый модуль — отдельная сборка (`.asmdef`), которая видит только ядро, поэтому прямое обращение к соседнему модулю не скомпилируется.
|
||||
Игра собрана из десяти модулей вокруг общего **Игрового ядра** (регламент 31.10.2026). Модули общаются только через контракты и события ядра и не управляют внутренним кодом друг друга. Это правило проверяет сам Unity: каждый модуль — отдельная сборка (`.asmdef`), которая видит только ядро, поэтому прямое обращение к соседнему модулю не скомпилируется.
|
||||
|
||||
```
|
||||
┌─────────────────────────────────────────┐
|
||||
@@ -54,7 +54,7 @@ App/GameModules — точка сборки: регистрирует модул
|
||||
| Кто | Модули |
|
||||
| --- | --- |
|
||||
| Валдемар (экономика) | Экономика, Население |
|
||||
| Саша (война и карта) | Армия, Боевая система, Глобальный мир, Круг, Чат |
|
||||
| Саша (война и карта) | Армия, Боевая система, Глобальный мир, Круг, Чат, Разведка |
|
||||
| Общее | Ядро, Поселение, Сохранения |
|
||||
|
||||
| Модуль | Сборка | Папка | Документ |
|
||||
@@ -69,6 +69,7 @@ App/GameModules — точка сборки: регистрирует модул
|
||||
| Сохранения | `Bogatyri.Save` | `Assets/Scripts/Modules/Save` | [Save.md](Save.md) |
|
||||
| Чат | `Bogatyri.Chat` (без Unity) | `Assets/Scripts/Modules/Chat` | [Chat.md](Chat.md) |
|
||||
| Круг | `Bogatyri.Circle` (без Unity) | `Assets/Scripts/Modules/Circle` | [Circle.md](Circle.md) |
|
||||
| Разведка | `Bogatyri.Intelligence` (без Unity) | `Assets/Scripts/Modules/Intelligence` | [Intelligence.md](Intelligence.md) |
|
||||
|
||||
## Правила
|
||||
|
||||
@@ -104,8 +105,29 @@ EditMode-тесты: `Assets/Scripts/Modules/Tests/ModuleTests.cs`. Запуск
|
||||
|
||||
| Дата | Кто | Что |
|
||||
| --- | --- | --- |
|
||||
| 04.11.2026 | Claude | Разведка М2: разведка поселений, замка и лагерей с отчётами II и III. Обновлены Intelligence, World, Core. |
|
||||
| 04.11.2026 | Claude | Пропавшие без вести (решения 01.11, п. 5; доля не утверждена — выключено). Обновлены Army, Battle, Population, World, Core. |
|
||||
| 04.11.2026 | Claude | Еда воинов и раненых по типам (решения 01.11, п. 4). Обновлены Population, Army. |
|
||||
| 04.11.2026 | Claude | Карта мира в 2.5D на примитивах. Обновлены World, Intelligence. |
|
||||
| 04.11.2026 | Claude | 3D-поселение, этап I — прототип на примитивах (ТЗ от 04.11). Обновлён Settlement. |
|
||||
| 04.11.2026 | Claude | Решения по отчёту Саши от 01.11: потери сильной стороны до 2% при 10:1, 5 временных мест госпиталя, цена лечения 1 / 1 / 2 / 3 золота. Обновлены Battle, Army. |
|
||||
| 01.11.2026 | Claude | Здание «Госпиталь» (решения 31.10, п. 7). Обновлены Army, Core, Settlement. |
|
||||
| 01.11.2026 | Claude | Решения 31.10, п. 7: раненые и госпиталь (логика; здание — следующий шаг). Обновлены Battle, Army, Population, World, Core, Settlement. |
|
||||
| 01.11.2026 | Claude | Решения 31.10, п. 8: очередь обучения — у Армии. Обновлены Army, Core, Population. |
|
||||
| 01.11.2026 | Claude | Решения 31.10, п. 2: поход «Разведка». Обновлены World, Core, Intelligence. |
|
||||
| 01.11.2026 | Claude | Решения 31.10, п. 6: 24 ресурсные точки. Обновлён World. |
|
||||
| 01.11.2026 | Claude | Решения 31.10, п. 5: разгром дальше 5:1 (92% / 95% / до 99%). Обновлён Battle. |
|
||||
| 01.11.2026 | Claude | Решения 31.10, п. 4: средняя скорость смешанного войска. Обновлён World. |
|
||||
| 01.11.2026 | Claude | Решения по 8 вопросам Саши (31.10), п. 1: гарнизоны и запасы точек видны только в зоне обзора. Обновлён Intelligence. |
|
||||
| 31.10.2026 | Claude | Окна зданий: подписи над зданиями убраны, у каждого здания (добывающие, Дом, Склад, Амбар, Ратуша, Кристалл) своё окно по тапу — состояние, добыча и склад, улучшение и его цена. Казармы тоже получили окно и уровни (открывают новые войска вместе с Ратушей; уровни 1/2/3/5 — ТЕСТ). Ратуша улучшается кнопкой в окне, а не тапом. Обновлён Settlement. |
|
||||
| 31.10.2026 | Claude | По регламенту 31.10: откат — Население снова самостоятельный модуль (`Modules/Population`, `Bogatyri.Population`), схема и «Кто отвечает» как у Саши. Работать может любой житель (без «40%»), резерв по уровню Ратуши 10/20/30, голод режет добычу кроме еды вдвое. Обновлены Population, Settlement, Economy, Core. |
|
||||
| 31.10.2026 | Claude | Модуль Разведки, этап М1 ([Intelligence.md](Intelligence.md)): туман, обзор, чужие армии, последний контакт. Патрули-заглушки соседей для проверки. Обновлены World, Core, Save. |
|
||||
| 31.10.2026 | Claude | Панель армий на карте мира (регламент 31.10). Обновлён World. |
|
||||
| 31.10.2026 | Claude | Ресурсные точки на карте мира по регламенту 31.10 (наша часть по решению №46: состояние точки и сбор; зачисление — Экономика через `IEconomy`). Обновлены World, Save, Core. |
|
||||
| 31.10.2026 | Claude | Скорости маршей по типам и слоты похода по регламенту 31.10 (таблица `MarchConfig`). Обновлены World, Army, Core. |
|
||||
| 31.10.2026 | Claude | Кривая потерь боя по регламенту 31.10 (решение №14). Обновлён Battle. |
|
||||
| 30.10.2026 | Claude | Мир по документу 02: события строго по времени после офлайна, время и номер боя в событиях похода, единицы у таймеров; тесты «Готово, когда» (порядок, двойная доставка, таймеры, 0/1 солдат). Обновлены World, Core. |
|
||||
| 30.10.2026 | Claude | Бой по решениям №11–13 комплекта 29.10: шанс победы, сила без промежуточного округления, округление потерь шансом; голод в офлайн-бою по истории Населения. Обновлены Battle, World, Core. |
|
||||
| 28.10.2026 | Claude | Население стало частью Поселения, как на схеме Димы: `Settlement/Population`, сборка `Bogatyri.Settlement.Population`. Найм воинов из свободных жителей с гражданским резервом, история голода для боя. Обновлены Settlement, Population, Core. |
|
||||
| 28.10.2026 | Claude | Схема модулей обновлена: десять модулей (добавлено Население), «Не путать» (Поселение и Население, Армия и Боевая система), кто за что отвечает. |
|
||||
| 28.10.2026 | Claude | Голод в бою (−50%) и правило усталости (−20%, вместе 40%). Обновлены Battle, World, Core. |
|
||||
|
||||
@@ -34,7 +34,8 @@ SaveRegistry.Register(myModule); // при запуске модуля
|
||||
| --- | --- |
|
||||
| `economy` | Экономика |
|
||||
| `settlement` | Поселение |
|
||||
| `world` | Глобальный мир (походы и разбитые лагеря) |
|
||||
| `world` | Глобальный мир (походы, разбитые лагеря, ресурсные точки, патрули-заглушки) |
|
||||
| `intelligence` | Разведка (простые строки: `tick=…`, `obzor=…`, `grid=…`, `contact=…`) |
|
||||
| `circle` | Круг (простые строки, не JSON — модуль без Unity) |
|
||||
| `army` | Армия (простые строки: `troops=…`, `march=…`) |
|
||||
| `population` | Население (простые строки: `civilians=…`, `jobs=…`, `lastTick=…` и др.) |
|
||||
@@ -106,6 +107,8 @@ SaveRegistry.Register(myModule); // при запуске модуля
|
||||
|
||||
| Дата | Кто | Что |
|
||||
| --- | --- | --- |
|
||||
| 31.10.2026 | Claude | Секция `intelligence` (Разведка М1); в `world` — состояние патрулей-заглушек `patrols`. |
|
||||
| 31.10.2026 | Claude | Секция `world`: ресурсные точки (`points`: запасы, сроки, кто собирает). Старые сохранения без точек читаются — точки появятся при первом расчёте мира. |
|
||||
| 27.10.2026 | Claude | Секция `world`: добавлен список разбитых лагерей `camps`. |
|
||||
| 27.10.2026 | Claude | Новая секция `production`; в секции `economy` — список `capacities` (лимиты склада). |
|
||||
| 26.10.2026 | Claude | Новая секция `population` (модуль Населения). `GameBootstrap` публикует `NewGameStartedEvent`, если файла нет. |
|
||||
|
||||
@@ -69,6 +69,30 @@
|
||||
|
||||
В слое приложения остаются `BuildMenuUi.cs`, `Meta/Build/*` (Казармы, `BuildModeController`).
|
||||
|
||||
## 3D-поселение (ТЗ «Система строительства поселения» от 04.11.2026)
|
||||
|
||||
Переход на 3D (2.5D: наклонная камера без вращения) идёт **отдельной сценой** `Assets/Scenes/City3D.unity`. Старый 2D-город (MVP1) работает как раньше, пока 3D его не догонит. Создать сцену: **Tools → Bogatyri → 3D-город: создать сцену City3D**, затем Play.
|
||||
|
||||
**Этап I — прототип на примитивах (сделан 04.11.2026):**
|
||||
- Правила места — без Unity, сборка `Bogatyri.Settlement.Placement` (`SettlementMap`), тесты `PlacementTests` (сценарии ТЗ 01–05, 09–12).
|
||||
- Невидимая сетка; клетка 1 единица мира.
|
||||
- Здание — прямоугольник клеток с максимальным габаритом с первого уровня, поворот 0/90/180/270.
|
||||
- Проверки: край карты, зона по уровню Ратуши, река и скалы (постоянные), деревья и валуны (расчищаются), другие здания, технический отступ 1 клетка, перепад высоты под зданием до 0,7 м (больше — «слишком круто», меньше — фундамент).
|
||||
- Перенос — то же здание с тем же id, целиком или никак.
|
||||
- Расчистка — один раз на объект.
|
||||
- Сцена (`Assets/Scripts/City3D`): местность 48 × 48 с холмами, река, скалы, 90 деревьев, 22 валуна, трава.
|
||||
- Сетка, открытая зона и следующая зона видны только в режиме стройки и редактирования.
|
||||
- Новое здание: кнопка типа → куб-призрак тянется пальцем, зелёный или красный с причиной, «Повернуть 90°», «Поставить» / «Отмена».
|
||||
- Перенос: «Переместить» в меню здания или режим «Редактировать»; «Подтвердить» / «Отмена» возвращает на последнее подтверждённое место.
|
||||
- Трава прячется под зданием и возвращается, когда его перенесли.
|
||||
- Камера: перетаскивание, два пальца / колесо, границы карты; при открытии зоны плавно отходит.
|
||||
- Ратуша −/+ — **только для теста** зон.
|
||||
- Рендер: в URP добавлен второй рендерер — обычный 3D (`Assets/Settings/Renderer3D.asset`), его использует только камера City3D. 2D-сцены не тронуты.
|
||||
|
||||
**Предложения на согласование (ТЗ, раздел 12), ТЕСТ:** клетка 1 м; отступ 1 клетка; перепад до 0,7 м; зоны — квадраты от центра 16 / 24 / 32 / 40 / 48 клеток для Ратуши 1–5; габариты: Ратуша 4×4, Дом 2×2, Ферма 3×3, Лесопилка и Каменоломня 3×2, Шахта 2×2, Склад и Амбар 2×3, Казармы и Госпиталь 3×3.
|
||||
|
||||
**Дальше:** этап II — стройка через модуль Поселения (цена, таймер по реальному времени, события, сохранение позиции, поворота и id), перенос живых зданий без сброса производства / обучения / лечения; этап III — награда за расчистку, сохранение расчищенного, автодороги, зоны от настоящей Ратуши; этап IV — телефон. Кнопки — временные (IMGUI), окна — с Володей.
|
||||
|
||||
## Решения и план
|
||||
|
||||
- **Решение команды от 19.10.2026 (этап 2):** Ратуша даёт базовую вместимость жителей, новое здание «Дом» — дополнительные места.
|
||||
@@ -82,6 +106,9 @@
|
||||
|
||||
| Дата | Кто | Что |
|
||||
| --- | --- | --- |
|
||||
| 04.11.2026 | Claude (Саша) | 3D-поселение, этап I (ТЗ от 04.11): правила места `Bogatyri.Settlement.Placement` + тесты, сцена City3D на примитивах (местность, зоны, призрак, поворот, перенос, расчистка, камера), 3D-рендерер для её камеры. Ветка `feature/3d-settlement`. |
|
||||
| 01.11.2026 | Claude (Саша) | Новое здание «Госпиталь» в списке стройки (`Meta/Build/HospitalBootstrap.cs`, как Казармы): уровни I–V сохраняются как у остальных (`ILeveledBuilding`), тап — окно госпиталя. Места — в `HospitalConfig`. Арта нет: копия обычного здания светло-голубого цвета. |
|
||||
| 01.11.2026 | Claude (Саша) | Для госпиталя (решения 31.10, п. 7) в ядре есть контракт `IHospital.Beds` — его будет регистрировать здание госпиталя (уровни I–V, 20–60 мест). Здания пока нет. |
|
||||
| 31.10.2026 | Claude | Ратуша: тап больше не улучшает сразу, а открывает окно Ратуши (событие `TownHall.Tapped`, окно — `App/BuildingWindow`). Улучшение — кнопкой в окне, с ценой и тем, что откроется. |
|
||||
| 31.10.2026 | Claude | Казармы стали уровневым зданием (`ILeveledBuilding`, уровень сохраняется как у остальных). Тап открывает окно Казарм: очередь обучения, какие войска открыты и что нужно для остальных, улучшение, кнопка «Нанять войска». Войско открывается, когда хватает и уровня Ратуши, и уровня Казарм; считаются самые прокачанные Казармы, каждые Казармы по-прежнему дают +1 место в очереди. Уровни Казарм: пехота 1, лучники 2, конница 3, осадные 5 (`EconomyConfig`, `soldier.requiredBarracksLevel`) — **ТЕСТ, согласовать с Димой**; цена улучшения общая, тоже не утверждена. |
|
||||
| 31.10.2026 | Claude | Откат: Население снова самостоятельный модуль (`Modules/Population`), из Поселения убрано. |
|
||||
|
||||
+81
-3
@@ -14,6 +14,11 @@
|
||||
| --- | --- |
|
||||
| `ActiveMarches` | Сколько походов в пути. |
|
||||
| `TryStartMarch(targetId, soldiers, out error)` | Отправить войско на цель. |
|
||||
| `TryStartScout(targetId, soldiers, out error)` | Поход «Разведка»: дойти до цели и вернуться — без боя, сбора и потерь. |
|
||||
|
||||
`MarchManager` реализует и `IWorldMap` — для Разведки: границы карты, где поселение, где все армии в момент времени (`WorldSimulation.TryGetPositionAt`). `ActiveMarches` считает только походы игрока.
|
||||
|
||||
**Патрули-заглушки** (Разведка М1, временно): соседи иногда отправляют отряды к городам и лагерям и обратно. Без боя и добычи, Армия о них не знает. Включаются в `MarchConfig` (`patrolsEnabled` и др.), см. [Intelligence.md](Intelligence.md).
|
||||
|
||||
Получить: `GameServices.Get<IWorld>()`. Интерфейсу карты (`WorldMapController`) можно обращаться к `MarchManager.Instance` и его C#-событиям: там полные данные похода.
|
||||
|
||||
@@ -21,10 +26,16 @@
|
||||
|
||||
**Публикует:**
|
||||
|
||||
- `MarchStartedEvent` — войско выступило;
|
||||
- `MarchBattleResolvedEvent` — бой у цели прошёл;
|
||||
У всех событий похода — номер похода и `TimeMs`: когда это случилось по часам игры, а не когда игра это заметила (после офлайна это разные моменты; документ 02).
|
||||
|
||||
- `MarchStartedEvent` — войско выступило (`TimeMs` = выступление);
|
||||
- `MarchBattleResolvedEvent` — бой у цели прошёл (`TimeMs` = приход, `BattleId` = номер боя);
|
||||
- `MarchReturnedEvent` — войско вернулось, солдаты и добыча зачислены. Поля: `MarchId`, `Victory`, `Survivors`, `Sent`, `TargetEmpty` (лагерь уже был разбит, боя не было), `TargetName`, `LootText`.
|
||||
|
||||
- `WorldAdvancingEvent` — мир сейчас продвинется до `ToMs` (перед каждым расчётом): Разведка успевает досчитать наблюдение, пока вернувшиеся походы ещё на карте.
|
||||
|
||||
У патрулей-заглушек событий нет.
|
||||
|
||||
**Слушает:** ничего.
|
||||
|
||||
По этим событиям `App/GameModules`:
|
||||
@@ -49,6 +60,7 @@
|
||||
| `MarchManager.cs` | Ведёт походы, реализует `IWorld` и `ISaveParticipant`. Создаётся сам при запуске игры. |
|
||||
| `Simulation/WorldMapLayout.cs` | Карта: замок, город игрока, 20 соседей и 12 лагерей из seed. |
|
||||
| `Simulation/WorldSimulation.cs` | Походы: старт, бой по прибытии, возвращение. Бой получает через `IBattleSystem`. |
|
||||
| `Simulation/WorldSimulation.Patrols.cs` | Патрули-заглушки соседей (`PatrolRules`, `PatrolState`) и позиция армии в момент времени (`TryGetPositionAt`). |
|
||||
|
||||
**Бой с типами войск:**
|
||||
- у похода есть состав по типам (`MarchData.units`, берётся у Армии при выступлении) и выжившие по типам (`survivorUnits`);
|
||||
@@ -75,10 +87,62 @@
|
||||
|
||||
**Номер боя:** при выступлении поход получает `battleSeed` (из номера похода, времени выступления и цели) и хранит его в сохранении. Тот же поход всегда даёт тот же бой. После боя в походе запоминаются силы сторон и выпавшая случайность (`attackerPower`, `defenderPower`, `attackerLuck`, `defenderLuck`). Окно итога боя на карте показывает «Сила 356 : 160, удача −3,1% / +3,2%» (твоя / врага); текст окна ужимается, чтобы не уходить под кнопку OK. Окно атаки показывает прогноз риска и диапазоны силы и потерь.
|
||||
|
||||
**Голод в бою:** перед боем мир спрашивает состояние войска нападающего (`WorldSimulation.AttackerConditions`). `MarchManager` отвечает по модулю Населения: город голодает — войско бьётся на 50% силы. Мир сам голод не считает. Если бой прошёл, пока игра была закрыта, берётся голод на момент входа (истории голода нет). Окно атаки предупреждает: «Голод: войско слабее, сила 50%. Накормите город до боя», прогноз учитывает голод. Если голод начался или кончился, пока окно атаки открыто, предупреждение и прогноз обновляются сами. Окно итога боя пишет «голод: сила 50%». В походе запоминается `attackerConditions` и `attackerConditionPercent`.
|
||||
**Голод в бою:** перед боем мир спрашивает состояние войска нападающего (`WorldSimulation.AttackerConditions`). `MarchManager` отвечает по модулю Населения: город голодает — войско бьётся на 50% силы. Мир сам голод не считает. Голод берётся на момент прихода войска: `IPopulation.WasStarvingAt(время боя)`. Перед боем, прошедшим пока игра была закрыта, `MarchManager` просит Население досчитать время (`IPopulation.Tick`) — офлайн обрабатывается в причинно-следственном порядке (документ 02). Окно атаки показывает шанс победы (решение №11) и предупреждает: «Голод: войско слабее, сила 50%. Накормите город до боя», прогноз учитывает голод. Если голод начался или кончился, пока окно атаки открыто, предупреждение и прогноз обновляются сами. Окно итога боя пишет «голод: сила 50%». В походе запоминается `attackerConditions` и `attackerConditionPercent`.
|
||||
|
||||
**Время** походов — по `GameClock`: кнопки «+1 час» / «+10 часов» в отладочной панели проматывают и походы.
|
||||
|
||||
**Ресурсные точки (регламент 31.10, раздел 7; решение №46)**
|
||||
|
||||
Состояние точки ведёт Мир: запас, появление, истощение, конец экспедиции. Зачисление добычи и складские лимиты — Экономика: груз приходит как добыча похода (`MarchData.loot`) и зачисляется через `IEconomy` по возвращении, как трофеи боя. Числа — таблица `Assets/Resources/WorldResourceConfig.asset` (ТЕСТ).
|
||||
|
||||
| Ресурс | Запас: малая / средняя / крупная | Добыча воина за игровой час | Груз на воина |
|
||||
| --- | --- | --- | --- |
|
||||
| Дерево (Лес) | 200 / 600 / 1500 | 2 | 12 |
|
||||
| Камень (Каменоломня) | 150 / 450 / 1000 | 1,5 | 10 |
|
||||
| Металл (Рудник) | 80 / 250 / 600 | 1 | 8 |
|
||||
| Золото (Золотая жила) | 30 / 100 / 250 | 0,5 | 5 |
|
||||
|
||||
- **Срок жизни** — 12 / 24 / 48 реальных часов с момента появления. 1 игровой час = 5 реальных минут.
|
||||
- **Сбор:** дошли до точки → войско стоит и собирает (`MarchState.Gathering`). Сбор кончается, когда груз полон, запас истощён или точка исчезла — что раньше; затем физический возврат с грузом. Всё известно в момент прихода, поэтому работает и при закрытой игре. Пример: 10 пехотинцев на Лес — 120 дерева за 30 реальных минут.
|
||||
- **Осадные машины груза не несут** (регламент); добывают наравне с остальными.
|
||||
- **Одна точка — одно войско.** Пока к точке идёт или на ней стоит войско, отправить другое нельзя.
|
||||
- **Точка исчезла до прихода** — возврат без добычи (окно «ТОЧКИ НЕТ»). Исчезла во время сбора — уносят, что успели.
|
||||
- **Истощённая или исчезнувшая точка** заменяется новой того же ресурса в другом месте (место и размер — из seed и номера появления, одинаково на сервере). Убирается с карты, когда к ней уже никто не идёт.
|
||||
- **На карте** — ромб цвета ресурса с подписью «запас, сколько осталось жить» или «идёт сбор». Окно отправки показывает запас, добычу и груз на воина, путь и прогноз «унесут N за T, весь поход ~X».
|
||||
- **Сколько точек** (решения по 8 вопросам Саши от 31.10, п. 6, ТЕСТ тестового участка): **24** — лес 8, камень 7, металл 5, золото 4; по размерам 12 малых, 8 средних, 4 крупных. Раскладка по ресурсам (документ её не задаёт, задана так): лес 4/3/1, камень 4/2/1, металл 2/2/1, золото 2/1/1 — `WorldResourceConfig` (`woodCount`, `stoneCount`, `metalCount`, `goldCount`). Исчезла точка — появляется точка того же ресурса и размера в другом месте, раскладка не плывёт. Старое сохранение дополняется до таблицы при загрузке.
|
||||
- На одной точке собирает только одна экспедиция: пока к точке идёт или на ней стоит войско, другое туда не отправить.
|
||||
- Точек еды нет (еда — с ферм). Синие кристаллы — отдельная механика, не в этой сетке.
|
||||
- **Открыто:** предел добычи на точку («скорость с пределом на точку»).
|
||||
- **Позже:** нападение на занятую точку (бой в поле, победитель забирает до 50% накопленного) — когда появятся другие игроки; досрочный отзыв — технология «Связь Волхвов»; переполнение склада при возвращении (5 минут на разгрузку) — вместе с Экономикой.
|
||||
|
||||
**Панель армий** (регламент 31.10, раздел 7: «нужна всем игрокам»): кнопка «Армии» на карте мира, под «Рейтингом» — окно `WorldMap/ArmiesWindow.cs`. Вверху — дома свободно, гарнизон, походов N из M. По каждому войску игрока: куда и что делает (идёт в бой / идёт на сбор / собирает / возвращается), состав по типам, груз, сколько до цели или до конца сбора и когда будет дома. Таймеры обновляются сами, пока окно открыто. До отправки окно атаки показывает длительность всего задания: для боя «туда и обратно ~X», для сбора «весь поход ~X».
|
||||
|
||||
**Поход «Разведка»** (решения по 8 вопросам Саши от 31.10, п. 2): кнопка «Разведка» в окне атаки, между «Отмена» и «Отправить».
|
||||
- Цель — любая, кроме своего города: замок, сосед, лагерь (и разбитый), ресурсная точка (и занятая).
|
||||
- Занимает обычный слот похода; воинов забирает Армия, как для боя.
|
||||
- У цели боя, сбора и потерь нет: войско поворачивает домой тем же составом (`WorldEventType.ScoutArrived`) и идёт обратно по времени, без телепортации. Цели уже нет (точка исчезла) — дошли до места и вернулись (`targetEmpty`).
|
||||
- Лагерь не разбивается, точка не занимается и не мешает чужому сбору.
|
||||
- Что войско увидит по пути и у цели — показывает Разведка (обзор армии 1 клетка): гарнизон цели, чужие армии. Отчёты и шпионаж — М2–М4.
|
||||
- Окно «ВОЙСКО ВЕРНУЛОСЬ»: «Разведка «…»: цель разведана». В событиях — `MarchStartedEvent.IsScout`, `MarchReturnedEvent.IsScout`.
|
||||
|
||||
**Армии в пути проходят друг через друга** (решения по 8 вопросам Саши от 31.10, п. 3): встреча маршрутов, даже в одной точке в один момент, — не столкновение, не остановка и не перехват. Бой — только у выбранной цели. Так же и с патрулями-заглушками. Команды «Перехватить» нет. Тест `World_ArmiesPassThroughEachOther_NoBattleOnTheWay`.
|
||||
|
||||
**Порядок событий** (документ 02: офлайн — в причинно-следственном порядке): `WorldSimulation.Advance` каждый раз берёт самое раннее событие — приход к цели (бой или начало сбора), конец сбора, исчезновение ресурсной точки или возвращение. Бой назначает время возвращения, поэтому за один вызов поход может и сразиться, и вернуться. При равном времени — бой раньше возвращения, затем по номеру похода. Раньше за один вызов сначала шли все бои, потом все возвращения — войско, вернувшееся раньше чужого боя, попадало в события после него. Повторный вызов с тем же временем ничего не создаёт заново.
|
||||
|
||||
**Таймеры и единицы** (документ 02: у каждого параметра — единицы):
|
||||
|
||||
| Таймер | Значение | Единицы | Статус |
|
||||
| --- | --- | --- | --- |
|
||||
| Скорость войска (`MarchConfig`, регламент 31.10) | пехота 8, лучники 9, кавалерия 12, осадные 4 клетки | за 1 реальный час | ТЕСТ |
|
||||
| Время в пути | пехота: ближняя цель ~53 мин, замок ~65 мин, дальняя ~3 ч 12 мин; осадные — вдвое дольше пехоты | реальных минут/часов | ТЕСТ |
|
||||
| Появление разбитого лагеря (`CampRules.RespawnMs`) | 30 | реальных минут после боя | ТЕСТ (план 27.10: «30 реальных минут») |
|
||||
|
||||
Все таймеры мира — в миллисекундах часов `GameClock` (реальное время + перемотка DEV). Регламент 31.10: 1 игровой час = 5 реальных минут, но **физический марш идёт в реальном времени** — поэтому таймеры мира остаются реальными.
|
||||
|
||||
**Скорость марша** (регламент 31.10, раздел 7): у каждого типа своя скорость, таблица `Assets/Resources/MarchConfig.asset` (клеток карты за реальный час; 1 клетка = 1000 единиц координат). Смешанное войско идёт со **средней скоростью по численности** (решения по 8 вопросам Саши от 31.10, п. 4): `V = Σ(Nᵢ × Vᵢ × Mᵢ) / ΣNᵢ`, где `Mᵢ` — модификатор типа, а общий модификатор войска применяется один раз. Промежуточного округления нет: время пути считается точной дробью и округляется один раз в конце. Пример: 10 пехоты + 10 кавалерии = 10 клеток в час, с общим +10% — 11. Модификаторы в `MarchConfig`: `typeSpeedBonusPercent` (по типам) и `armySpeedBonusPercent` (всё войско), сейчас 0 — сюда придут бонусы героев и технологий. Совместные рейды нескольких армий (средняя скорость + штраф координации 0 / −5 / −10 / −15%) — когда появятся рейды. Время прихода пересчитывается, когда Армия забрала воинов (`WorldSimulation.AssignUnits`); обратно идут выжившие — со скоростью своего состава (погибли осадные — войско возвращается быстрее). Окно атаки показывает путь по составу при выбранном числе воинов. Бонусы героя (+15%) и технологии (+20%) — когда появятся герои и технологии.
|
||||
|
||||
**Слоты похода**: база 2 (`MarchConfig.baseMarchSlots`, ТЕСТ), «Военная логистика» поднимет до 7 — уровни и цены не утверждены. Слоты ведёт модуль Армии (`IArmy.MarchSlots`, `ActiveMarches`). При занятых слотах окно атаки пишет «Все слоты похода заняты», кнопка «В поход» неактивна; верхняя строка карты — «отрядов: 1 из 2».
|
||||
|
||||
В слое приложения остаются `WorldMap/WorldMapController.cs`, `MarchView.cs`, `MapCameraController.cs`, `SceneNavigator.cs`.
|
||||
|
||||
**В игре одна карта мира** — сцена WorldMap. Открывается кнопкой «БОЙ» и кнопкой «МИР» в городе (`UIPanelManager.Open("World")` ведёт в эту сцену).
|
||||
@@ -94,6 +158,20 @@
|
||||
|
||||
| Дата | Кто | Что |
|
||||
| --- | --- | --- |
|
||||
| 04.11.2026 | Claude | Разведка М2: `IWorld.TryStartRecon`, `MarchData.reconLevel` / `reconHoldMs`, отряд наблюдает у цели (`Gathering`) и идёт домой от конца наблюдения, `WorldEventType.ReconCompleted`; `IWorldMap.TryGetReconTarget` — снимок цели для отчёта. |
|
||||
| 04.11.2026 | Claude | `MarchData.missingUnits`: при бое пропавшие передаются Армии (`MarkMissing`); `MarchReturnedEvent.Missing`. |
|
||||
| 04.11.2026 | Claude | Карта мира в 2.5D на примитивах: карта лежит на земле (X/Z), замок — стена с башней, города — кубы, лагеря — цилиндры, точки — ромбы, отряды — кубики с полосой маршрута; подписи смотрят в камеру; наклонная перспективная камера (`MapCameraController`: перетаскивание, щипок, тап, границы); солнце в сцене; камера — 3D-рендерер URP (`Map3D.UseRenderer3D`). Логика, окна и кнопки не менялись. Ветка `feature/3d-settlement`. |
|
||||
| 01.11.2026 | Claude | Раненые (решения 31.10, п. 7): `MarchData.woundedUnits` — идут домой с войском, при возвращении Армия кладёт их в госпиталь; `MarchReturnedEvent.Wounded`; итог боя на карте показывает раненых. |
|
||||
| 01.11.2026 | Claude | Решения 31.10, п. 2: поход «Разведка» (`IWorld.TryStartScout`, `MarchData.scout`, `WorldEventType.ScoutArrived`), кнопка в окне атаки, тексты в окне армий, на отряде и в окне возвращения. |
|
||||
| 01.11.2026 | Claude | Решения 31.10, п. 3: армии в пути проходят друг через друга — правило записано, тест на одну точку в один момент. |
|
||||
| 01.11.2026 | Claude | Решения 31.10, п. 6: 24 ресурсные точки (лес 8, камень 7, металл 5, золото 4; размеры 12 / 8 / 4), число по ресурсу и размеру — в `WorldResourceConfig`; новая точка — того же размера; старые сохранения дополняются. |
|
||||
| 01.11.2026 | Claude | Решения 31.10, п. 4: скорость смешанного войска — средняя по численности с модификаторами (вместо «по самому медленному»), без промежуточного округления. `MarchConfig`: `mixedUsesSlowest` убран, добавлены `typeSpeedBonusPercent`, `armySpeedBonusPercent`. |
|
||||
| 31.10.2026 | Claude | Для Разведки М1: `IWorldMap` (армии на карте в момент времени), `WorldAdvancingEvent`, патрули-заглушки соседей (`MarchData.patrol`, сохранение `patrols`, таблица `MarchConfig`). |
|
||||
| 31.10.2026 | Claude | Панель армий (`WorldMap/ArmiesWindow.cs`, кнопка «Армии» на карте мира): местонахождение и действие каждого войска, состав, груз, время до цели / конца сбора / возвращения. В окне атаки — длительность всего задания для боя. |
|
||||
| 31.10.2026 | Claude | Ресурсные точки (регламент 31.10, раздел 7): `ResourcePoint`, `ResourcePointRules`, `WorldSimulation.Points.cs` — появление, сбор (`MarchState.Gathering`), истощение, исчезновение, замена новой точкой; события `GatherStarted`, `GatherFinished`; сохранение в секции `world`; таблица `WorldResourceConfig`; на карте — ромбы точек, окно отправки с прогнозом сбора, подпись отряда «сбор». Тесты: появление, сбор и груз, истощение и новая точка, осадные без груза, точка исчезла до прихода и во время сбора, одна точка — одно войско, сохранение посреди сбора. |
|
||||
| 31.10.2026 | Claude | Скорости маршей по типам (регламент 31.10: 8 / 9 / 12 / 4 клетки за реальный час, таблица `MarchConfig`), войско — по самому медленному типу, обратно — по составу выживших; `WorldSimulation.TravelTimeMs`, `AssignUnits`, `MarchSpeedRules`; слоты похода (база 2) в окне атаки и верхней строке. Тесты: скорости по типам, смешанное войско, обратный путь; старые тесты переведены на часовые марши. |
|
||||
| 30.10.2026 | Claude | События строго по времени после офлайна (раньше — сначала все бои, потом все возвращения); `TimeMs` у событий похода и `WorldEvent`, `BattleId` у события боя; таблица таймеров с единицами. Тесты: порядок после офлайна, повторный вызов без дублей, границы таймеров, 0 и 1 солдат. |
|
||||
| 30.10.2026 | Claude | Голод на момент боя — по истории голода Населения (`WasStarvingAt`), перед офлайн-боем Население досчитывает время. Окно атаки: шанс победы в процентах. |
|
||||
| 28.10.2026 | Claude | Голод в момент боя ослабляет войско игрока (−50%): `WorldSimulation.AttackerConditions`, `MarchManager.PlayerConditions`; предупреждение в окне атаки, строка в итоге боя. Тест: голод в момент боя — поражение. |
|
||||
| 28.10.2026 | Claude | Номер боя у похода (`battleSeed`), силы и удача сторон в итоге; прогноз риска в окне атаки, удача в окне итога боя. Тест: тот же поход — тот же бой. |
|
||||
| 28.10.2026 | Claude | По ревью 27.10.2026: отправка с проверкой и откатом (`CancelMarch`), возвращение по неизвестному походу ничего не зачисляет. Тест отмены похода. |
|
||||
|
||||
Reference in New Issue
Block a user