private static bool IsHasTransitionToNextLevel(ISectorNode sectorNode, ISectorSubScheme x)
{
return(sectorNode.SectorScheme.TransSectorSids
.Where(x => x != null).Select(x => x !)
.Select(trans => trans.SectorLevelSid)
.Contains(x.Sid));
}
/// <summary>
/// Возвращает генератор карты.
/// </summary>
/// <param name="sectorNode">
/// Схема сектора, на основе которой будет принято решение,
/// какой генератор карты использовать.
/// </param>
/// <returns> Возвращает фабрику карт для сектора. </returns>
public IMapFactory GetMapFactory(ISectorNode sectorNode)
{
if (sectorNode is null)
{
throw new System.ArgumentNullException(nameof(sectorNode));
}
var sectorScheme = sectorNode.SectorScheme;
if (sectorScheme.MapGeneratorOptions == null)
{
//TODO Прописать для всех схем конкретный генератор.
// После явного прописывания здесь нужно будет выбрасывать исключение.
return(RoomMapFactory);
}
switch (sectorScheme.MapGeneratorOptions.MapGenerator)
{
case SchemeSectorMapGenerator.Room:
return(RoomMapFactory);
case SchemeSectorMapGenerator.CellularAutomaton:
return(CellularAutomatonMapFactory);
//TODO Прописать для всех схем конкретный генератор.
// После явного прописывания здесь нужно будет выбрасывать исключение.
default:
return(RoomMapFactory);
}
}
private static void HandleMoveCommand(IServiceScope serviceScope, ISectorUiState uiState,
ISectorNode playerActorSectorNode, string inputText)
{
var components = inputText.Split(' ');
var x = int.Parse(components[1], CultureInfo.InvariantCulture);
var y = int.Parse(components[2], CultureInfo.InvariantCulture);
var offsetCoords = new OffsetCoords(x, y);
ISectorMap map = playerActorSectorNode.Sector.Map;
var targetNode = map.Nodes.OfType <HexNode>()
.SingleOrDefault(node => node.OffsetCoords == offsetCoords);
var command = serviceScope.ServiceProvider.GetRequiredService <MoveCommand>();
uiState.SelectedViewModel = new NodeViewModel {
Node = targetNode
};
if (command.CanExecute())
{
command.Execute();
}
else
{
Console.WriteLine(UiResource.CommandCantExecuteMessage);
}
}
private void CreateNextSectorNodes(ISectorNode sectorNode, IBiome biom)
{
var nextSectorLevels = biom.LocationScheme.SectorLevels
.Where(x => sectorNode.SectorScheme.TransSectorSids.Select(trans => trans.SectorLevelSid)
.Contains(x.Sid));
foreach (var nextSectorLevelScheme in nextSectorLevels)
{
var nextSectorNode = new SectorNode(biom, nextSectorLevelScheme);
biom.AddNode(nextSectorNode);
biom.AddEdge(sectorNode, nextSectorNode);
}
// Если в секторе есть переход в другой биом, то
// Генерируем новый биом, стартовый узел и организуем связь с текущим узлом.
if (sectorNode.SectorScheme.TransSectorSids.Any(x => x.SectorLevelSid is null))
{
var nextBiomeCount = NEXT_BIOME_COUNT;
for (var nextBiomeIndex = 0; nextBiomeIndex < nextBiomeCount; nextBiomeIndex++)
{
var nextSectorNode = RollAndBindBiome();
// Организуем связь между двумя биомами.
biom.AddEdge(sectorNode, nextSectorNode);
var nextBiom = nextSectorNode.Biome;
nextBiom.AddEdge(sectorNode, nextSectorNode);
}
}
}
public IResourceDepositData GetDepositData(ISectorNode sectorNode)
{
if (sectorNode is null)
{
throw new System.ArgumentNullException(nameof(sectorNode));
}
// Алгоритм.
// Первое, что делаем, это проверяем, не является ли узел стартовым. То есть еще ничего нет.
// В этом случае задаём случайные стартовые ресурсы.
// Если не стартовый, тогда собираем данные с соседних, уже сгенерированных узлов.
// Для каждого ресурса из соседних получаем усреднённое значение.
// Затем, для каждого ресурса либо снижаем долю, либо увеличиваем.
if (!_map.Any())
{
var data = CreateStartResourceData();
_map[sectorNode] = data;
return(data);
}
else
{
var data = CalcCurrentResouceData(sectorNode);
_map[sectorNode] = data;
return(data);
}
}
private static void HandleMoveCommand(
IServiceScope serviceScope,
ISectorUiState uiState,
ICommandPool commandManager,
ISectorNode playerActorSectorNode,
string inputText)
{
var components = inputText.Split(' ');
var x = int.Parse(components[1], CultureInfo.InvariantCulture);
var y = int.Parse(components[2], CultureInfo.InvariantCulture);
var offsetCoords = new OffsetCoords(x, y);
ISectorMap map = playerActorSectorNode.Sector.Map;
var targetNode = map.Nodes.OfType <HexNode>()
.SingleOrDefault(node => node.OffsetCoords == offsetCoords);
var command = serviceScope.ServiceProvider.GetRequiredService <MoveCommand>();
uiState.SelectedViewModel = new NodeViewModel {
Node = targetNode
};
PushCommandToExecution(commandManager, command);
}
private async Task ExpandGlobeInternalAsync(IGlobe globe, ISectorNode sectorNode)
{
await _biomeInitializer.MaterializeLevelAsync(sectorNode).ConfigureAwait(false);
// Фиксируем новый узел, как известную, материализованную часть мира.
// Далее этот узел будет обрабатываться при каждом изменении мира.
globe.AddSectorNode(sectorNode);
}
private static void PrintLocationName(ISectorNode playerActorSectorNode)
{
var locationScheme = playerActorSectorNode.Biome.LocationScheme;
var scheme = playerActorSectorNode.SectorScheme;
var sectorName = $"{locationScheme.Name} {scheme.Name}".Trim();
Console.WriteLine($"Current Level: {sectorName}");
}
private static void SelectActor(ISectorUiState uiState, ISectorNode playerActorSectorNode, int targetId)
{
var actorManager = playerActorSectorNode.Sector.ActorManager;
var targetObject = actorManager.Items.SingleOrDefault(x => x.Id == targetId);
uiState.SelectedViewModel = new ActorViewModel {
Actor = targetObject
};
}
private async Task GenerateStaticObjectsAsync(
ISector sector,
ISectorSubScheme sectorScheme,
ISectorNode sectorNode)
{
var resourceDepositData = _resourceMaterializationMap.GetDepositData(sectorNode);
var context = new StaticObjectGenerationContext(sector, sectorScheme, resourceDepositData);
await _staticObstaclesGenerator.CreateAsync(context).ConfigureAwait(false);
}
private static void SelectStaticObject(ISectorUiState uiState, ISectorNode playerActorSectorNode, int targetId)
{
var entitiesManager = playerActorSectorNode.Sector.StaticObjectManager;
var targetObject = entitiesManager.Items.SingleOrDefault(x => x.Id == targetId);
uiState.SelectedViewModel = new StaticObjectViewModel {
StaticObject = targetObject
};
}
private static void HandleLookCommand(ISectorUiState uiState, ISectorNode playerActorSectorNode)
{
var nextMoveNodes = playerActorSectorNode.Sector.Map.GetNext(uiState.ActiveActor.Actor.Node);
var actorFow = uiState.ActiveActor.Actor.Person.GetModule <IFowData>();
var fowNodes = actorFow.GetSectorFowData(playerActorSectorNode.Sector)
.Nodes.Where(x => x.State == SectorMapNodeFowState.Observing)
.Select(x => x.Node);
var fowNodesAll = actorFow.GetSectorFowData(playerActorSectorNode.Sector)
.Nodes.Where(x =>
x.State == SectorMapNodeFowState.Explored || x.State == SectorMapNodeFowState.Observing)
.Select(x => x.Node);
Console.WriteLine($"{UiResource.NodesLabel}:");
Console.WriteLine();
foreach (var node in fowNodes)
{
Console.Write(node);
if (nextMoveNodes.Contains(node))
{
Console.Write($" {UiResource.NextNodeMarker}");
}
if (playerActorSectorNode.Sector.Map.Transitions.TryGetValue(node, out var _))
{
Console.Write($" {UiResource.TransitionNodeMarker}");
}
var undiscoveredNodes = playerActorSectorNode.Sector.Map.GetNext(node)
.Where(x => !fowNodesAll.Contains(x));
if (undiscoveredNodes.Any())
{
Console.Write($" {UiResource.UndiscaveredNodeMarker}");
}
var monsterInNode =
playerActorSectorNode.Sector.ActorManager.Items.SingleOrDefault(x => x.Node == node);
if (monsterInNode != null && monsterInNode != uiState.ActiveActor.Actor)
{
Console.Write(
$" {UiResource.MonsterNodeMarker} {monsterInNode.Person.Id}:{monsterInNode.Person}");
}
var staticObjectInNode =
playerActorSectorNode.Sector.StaticObjectManager.Items.SingleOrDefault(x => x.Node == node);
if (staticObjectInNode != null)
{
Console.Write(
$" {UiResource.StaticObjectNodeMarker} {staticObjectInNode.Id}:{staticObjectInNode.Purpose}");
}
Console.WriteLine();
}
}
private bool IsActorInSector(ISectorNode node)
{
var sector = node.Sector;
if (sector is null)
{
throw new InvalidOperationException();
}
return(sector.ActorManager.Items.Any(x => x.Person == MainPerson));
}
private void InitServices()
{
SectorNode = _humanPlayer.SectorNode;
_staticObjectManager = SectorNode.Sector.StaticObjectManager;
_staticObjectManager.Added += StaticObjectManager_Added;
_staticObjectManager.Removed += StaticObjectManager_Removed;
SectorNode.Sector.TrasitionUsed += Sector_HumanGroupExit;
}
public void AddSectorNode(ISectorNode sectorNode)
{
if (sectorNode is null)
{
throw new ArgumentNullException(nameof(sectorNode));
}
_sectorNodes.Add(sectorNode);
sectorNode.Sector.TrasitionUsed += Sector_TrasitionUsed;
sectorNode.Sector.ActorManager.Removed += ActorManager_Removed;
}
private IResourceDepositData CalcCurrentResouceData(ISectorNode sectorNode)
{
var neighborNodes = sectorNode.Biome.GetNext(sectorNode);
var items = CalcAverageResourceByNeightbors(neighborNodes);
items = AddNewResourceIfNeed(items);
var data = new ResourceDepositData(items);
return(data);
}
public async Task <ISector> GenerateAsync(ISectorNode sectorNode)
{
var transitions = MapFactoryHelper.CreateTransitions(sectorNode).ToArray();
var map = await SquareMapFactory.CreateAsync(transitions.Count() + 1);
CreateTransitions(transitions, map);
var locationScheme = sectorNode.Biome.LocationScheme;
var sector = _sectorFactory.Create(map, locationScheme);
return(sector);
}
/// <summary>
/// Создание переходов на основе схемы.
/// </summary>
/// <param name="sectorNode"> Схема сектора. </param>
/// <returns> Набор объектов переходов. </returns>
public static IEnumerable <RoomTransition> CreateTransitions(ISectorNode sectorNode)
{
if (sectorNode is null)
{
throw new ArgumentNullException(nameof(sectorNode));
}
if (sectorNode.State != SectorNodeState.SchemeKnown)
{
throw new ArgumentException("Узел сектора должен быть материализован", nameof(sectorNode));
}
var next = sectorNode.Biome.GetNext(sectorNode);
return(next.Select(node => new RoomTransition(node as ISectorNode)));
}
/// <summary>
/// Создание переходов на основе схемы.
/// </summary>
/// <param name="sectorNode"> Схема сектора. </param>
/// <returns> Набор объектов переходов. </returns>
public static IEnumerable <SectorTransition> CreateTransitions(ISectorNode sectorNode)
{
if (sectorNode is null)
{
throw new ArgumentNullException(nameof(sectorNode));
}
if (sectorNode.State != SectorNodeState.SchemeKnown)
{
throw new ArgumentException($"Sector node {sectorNode} is not materialized.", nameof(sectorNode));
}
var nextSectorNodes = sectorNode.Biome.GetNext(sectorNode);
return(nextSectorNodes.Select(node => new SectorTransition(node as ISectorNode)));
}
private static string GetVisualString(ISectorNode currentNode, ISectorNode nextNode, IResourceDepositData currentResource, IResourceDepositData nextResource)
{
var str = new StringBuilder($" {currentNode.GetHashCode()}{ResourceToString(currentResource)}-->{nextNode.GetHashCode()}{ResourceToString(nextResource)};");
if (currentResource.Items.Any())
{
var currentResColor = ResourceToStyle(currentResource);
str.AppendLine($" style {currentNode.GetHashCode()} fill:{ColorTranslator.ToHtml(currentResColor)}");
}
if (nextResource.Items.Any())
{
var nextResColor = ResourceToStyle(nextResource);
str.AppendLine($" style {nextNode.GetHashCode()} fill:{ColorTranslator.ToHtml(nextResColor)}");
}
return(str.ToString());
}
public async Task <ISector> GenerateAsync(ISectorNode sectorNode)
{
var sectorFactoryOptions = new SectorMapFactoryOptions(sectorNode.SectorScheme.MapGeneratorOptions);
var map = await _mapFactory.CreateAsync(sectorFactoryOptions);
var actorManager = new ActorManager();
var staticObjectManager = new StaticObjectManager();
var sector = new Sector(map,
actorManager,
staticObjectManager,
_dropResolver,
_schemeService,
_equipmentDurableService);
return(sector);
}
public Task ExpandGlobeAsync(IGlobe globe, ISectorNode sectorNode)
{
if (globe is null)
{
throw new ArgumentNullException(nameof(globe));
}
if (sectorNode is null)
{
throw new ArgumentNullException(nameof(sectorNode));
}
if (sectorNode.State == SectorNodeState.SectorMaterialized)
{
throw new InvalidOperationException("В этом случае такой узел должен уже быть использован.");
}
return(ExpandGlobeInternalAsync(globe, sectorNode));
}
/// <summary>
/// Создаёт экземпляр сектора подземелий с указанными параметрами.
/// </summary>
/// <param name="sectorNode"> Схема генерации сектора. </param>
/// <returns> Возвращает экземпляр сектора. </returns>
public async Task <ISector> GenerateAsync(ISectorNode sectorNode)
{
if (sectorNode is null)
{
throw new ArgumentNullException(nameof(sectorNode));
}
var mapFactory = _mapFactorySelector.GetMapFactory(sectorNode);
var transitions = MapFactoryHelper.CreateTransitions(sectorNode);
var mapGeneratorOptions = sectorNode.SectorScheme.MapGeneratorOptions;
if (mapGeneratorOptions is null)
{
throw new InvalidOperationException();
}
var sectorFactoryOptions = new SectorMapFactoryOptions(mapGeneratorOptions, transitions);
var map = await mapFactory.CreateAsync(sectorFactoryOptions).ConfigureAwait(false);
var locationScheme = sectorNode.Biome.LocationScheme;
var sector = _sectorFactory.Create(map, locationScheme);
DefineDiseases(sector);
var gameObjectRegions = map.Regions.Where(x => !x.IsStart).ToArray();
var sectorScheme = sectorNode.SectorScheme;
await GenerateStaticObjectsAsync(sector, sectorScheme, sectorNode).ConfigureAwait(false);
var monsterRegions = gameObjectRegions.ToArray();
_monsterGenerator.CreateMonsters(sector,
monsterRegions,
sectorScheme);
return(sector);
}
/// <summary>
/// Создаёт экземпляр сектора подземелий с указанными параметрами.
/// </summary>
/// <param name="sectorNode"> Схема генерации сектора. </param>
/// <returns> Возвращает экземпляр сектора. </returns>
public async Task <ISector> GenerateAsync(ISectorNode sectorNode)
{
if (sectorNode is null)
{
throw new ArgumentNullException(nameof(sectorNode));
}
var mapFactory = _mapFactorySelector.GetMapFactory(sectorNode);
var transitions = MapFactoryHelper.CreateTransitions(sectorNode);
var sectorFactoryOptions = new SectorMapFactoryOptions(sectorNode.SectorScheme.MapGeneratorOptions, transitions);
var map = await mapFactory.CreateAsync(sectorFactoryOptions).ConfigureAwait(false);
var locationScheme = sectorNode.Biome.LocationScheme;
var sector = _sectorFactory.Create(map, locationScheme);
DefineDiseases(sector);
var gameObjectRegions = map.Regions.Where(x => !x.IsStart).ToArray();
var sectorScheme = sectorNode.SectorScheme;
var resourceDepositData = _resourceMaterializationMap.GetDepositData(sectorNode);
var staticObjectgenerationContext = new StaticObjectGenerationContext(sector, sectorScheme, resourceDepositData);
await _staticObstaclesGenerator.CreateAsync(staticObjectgenerationContext).ConfigureAwait(false);
var monsterRegions = gameObjectRegions.ToArray();
_monsterGenerator.CreateMonsters(sector,
_botPlayer,
monsterRegions,
sectorScheme);
return(sector);
}
private static void HandleAttackCommand(string inputText, IServiceScope serviceScope, ISectorUiState uiState,
ISectorNode playerActorSectorNode, ICommandPool commandManager)
{
var components = inputText.Split(' ');
var targetId = int.Parse(components[1], CultureInfo.InvariantCulture);
if (components.Length == 3)
{
var targetMarker = components[2].ToUpper(CultureInfo.InvariantCulture);
switch (targetMarker)
{
case "A":
SelectActor(uiState, playerActorSectorNode, targetId);
break;
case "S":
SelectStaticObject(uiState, playerActorSectorNode, targetId);
break;
default:
SelectActor(uiState, playerActorSectorNode, targetId);
break;
}
}
else
{
SelectActor(uiState, playerActorSectorNode, targetId);
}
var acts = uiState.ActiveActor.Actor.Person.GetModule <ICombatActModule>().GetCurrentCombatActs();
uiState.TacticalAct = acts
.OrderBy(x => x.Equipment is null)
.First(x => x.Constrains is null);
var command = serviceScope.ServiceProvider.GetRequiredService <AttackCommand>();
PushCommandToExecution(commandManager, command);
}
public async Task MaterializeLevelAsync(ISectorNode sectorNode)
{
if (sectorNode is null)
{
throw new ArgumentNullException(nameof(sectorNode));
}
if (sectorNode.State != SectorNodeState.SchemeKnown)
{
throw new InvalidOperationException();
}
var biom = sectorNode.Biome;
// Важно генерировать соседние узлы до начала генерации сектора,
// чтобы знать переходы из сектора.
CreateNextSectorNodes(sectorNode, biom);
var sector = await _sectorGenerator.GenerateAsync(sectorNode).ConfigureAwait(false);
sectorNode.MaterializeSector(sector);
}
public async System.Threading.Tasks.Task GetDepositDataTestAsync()
{
var sectorGeneratorMock = new Mock <ISectorGenerator>();
sectorGeneratorMock.Setup(x => x.GenerateAsync(It.IsAny <ISectorNode>()))
.Returns <ISectorNode>(scheme =>
{
return(Task.Run(() =>
{
var sectorMock = new Mock <ISector>();
var sector = sectorMock.Object;
return sector;
}));
});
var sectorGenerator = sectorGeneratorMock.Object;
var locationSchemes = CreateBiomSchemes();
var schemeRoundCounter = 0;
var rollerMock = new Mock <IBiomeSchemeRoller>();
rollerMock.Setup(x => x.Roll()).Returns(() =>
{
schemeRoundCounter++;
if (schemeRoundCounter >= locationSchemes.Length)
{
schemeRoundCounter = 0;
}
var scheme = locationSchemes[schemeRoundCounter];
return(scheme);
});
var roller = rollerMock.Object;
var introScheme = locationSchemes.Single(x => x.Sid == "intro");
var biomService = new BiomeInitializer(sectorGenerator, roller);
var dice = new LinearDice();
var resourceMaterializationMap = new ResourceMaterializationMap(dice);
var resultStringBuilder = new StringBuilder();
resultStringBuilder.AppendLine("graph TD;");
// ACT
var biom = await biomService.InitBiomeAsync(introScheme).ConfigureAwait(false);
var introNode = biom.Sectors.Single(x => x.State == SectorNodeState.SectorMaterialized);
var currentResource = resourceMaterializationMap.GetDepositData(introNode);
ISectorNode currentNode = introNode;
var iteration = 0;
const int ITERATION_MAX = 100;
var openList = new List <NodeInfo>();
var nextNodes1 = currentNode.Biome.GetNext(currentNode)
.OfType <SectorNode>()
.Where(x => x.State != SectorNodeState.SectorMaterialized)
.Select(x => new NodeInfo {
Current = x, Parent = introNode, ParentResource = currentResource
});
openList.AddRange(nextNodes1);
while (iteration < ITERATION_MAX)
{
var nextNode = openList[0];
openList.RemoveAt(0);
await biomService.MaterializeLevelAsync(nextNode.Current).ConfigureAwait(false);
var nextResource = resourceMaterializationMap.GetDepositData(nextNode.Current);
resultStringBuilder.AppendLine(GetVisualString(nextNode.Parent, nextNode.Current, nextNode.ParentResource, nextResource));
var nextNodes2 = nextNode.Current.Biome.GetNext(nextNode.Current)
.OfType <SectorNode>()
.Where(x => x.State != SectorNodeState.SectorMaterialized)
.Select(x => new NodeInfo {
Current = x, Parent = nextNode.Current, ParentResource = nextResource
});
openList.AddRange(nextNodes2);
iteration++;
}
Console.Write(resultStringBuilder.ToString());
}
public void BindSectorNode(ISectorNode sectorNode)
{
SectorNode = sectorNode;
}
public Task ExpandAsync(ISectorNode sectorNode)
{
return(MaterializeLevelAsync(sectorNode));
}
/// <inheritdoc />
public IMapFactory GetMapFactory(ISectorNode sectorNode)
{
return(_mapFactory);
}
