/// <summary>
/// Подготовка дополнительных сервисов
/// </summary>
private void RegisterAuxServices(IServiceCollection serviceCollection)
{
var dice = new LinearDice(123);
serviceCollection.AddSingleton <IDice>(factory => dice);
var decisionSourceMock = new Mock <DecisionSource>(dice).As <IDecisionSource>();
decisionSourceMock.CallBase = true;
var decisionSource = decisionSourceMock.Object;
serviceCollection.AddSingleton(factory => decisionSource);
serviceCollection.AddSingleton(factory => CreateActUsageRandomSource(dice));
serviceCollection.AddSingleton <IPerkResolver, PerkResolver>();
RegisterActUsageServices(serviceCollection);
serviceCollection.AddSingleton <IPropFactory, PropFactory>();
serviceCollection.AddSingleton <IDropResolver, DropResolver>();
serviceCollection.AddSingleton <IDropResolverRandomSource, DropResolverRandomSource>();
serviceCollection.AddSingleton(factory => CreateSurvivalRandomSource());
serviceCollection.AddSingleton <IEquipmentDurableService, EquipmentDurableService>();
serviceCollection.AddSingleton <IEquipmentDurableServiceRandomSource, EquipmentDurableServiceRandomSource>();
serviceCollection.AddSingleton <IUserTimeProvider, UserTimeProvider>();
}
public void Create_DifferentDiceSeed_GenerateUniqueDiseases([Values(1, 2, 3, 4, 5)] int diceSeed, [Values(1, 10, 100)] int count)
{
// ARRANGE
var dice = new LinearDice(diceSeed);
var generator = new DiseaseGenerator(dice);
// ACT
var resultDiseases = new List <IDisease>();
for (var i = 0; i < count; i++)
{
var disease = generator.Create();
if (disease != null)
{
resultDiseases.Add(disease);
Console.WriteLine($"{disease.Name.Secondary?.Ru} {disease.Name.PrimaryPrefix?.Ru}{disease.Name.Primary?.Ru} {disease.Name.Subject?.Ru}");
}
}
// ASSERT
foreach (var disease in resultDiseases)
{
resultDiseases.Should().NotContain(x => x != disease && x.Name == disease.Name);
}
}
/// <summary>
/// Подготовка дополнительных сервисов
/// </summary>
private void RegisterAuxServices()
{
var dice = new LinearDice(123);
Container.Register <IDice>(factory => dice, new PerContainerLifetime());
var decisionSourceMock = new Mock <DecisionSource>(dice).As <IDecisionSource>();
decisionSourceMock.CallBase = true;
var decisionSource = decisionSourceMock.Object;
Container.Register(factory => decisionSource, new PerContainerLifetime());
Container.Register(factory => CreateActUsageRandomSource(dice), new PerContainerLifetime());
Container.Register <IPerkResolver, PerkResolver>(new PerContainerLifetime());
Container.Register <ITacticalActUsageService, TacticalActUsageService>(new PerContainerLifetime());
Container.Register <IPropFactory, PropFactory>(new PerContainerLifetime());
Container.Register <IDropResolver, DropResolver>(new PerContainerLifetime());
Container.Register <IDropResolverRandomSource, DropResolverRandomSource>(new PerContainerLifetime());
Container.Register(factory => CreateSurvivalRandomSource(), new PerContainerLifetime());
Container.Register <IEquipmentDurableService, EquipmentDurableService>(new PerContainerLifetime());
Container.Register <IEquipmentDurableServiceRandomSource, EquipmentDurableServiceRandomSource>(new PerContainerLifetime());
}
public async Task GenerateRegionAsyncTest()
{
var dice = new LinearDice();
var schemeService = CreateSchemeService();
var generator = new WorldGenerator(dice, schemeService);
var result = await generator.GenerateGlobeAsync();
var region = generator.GenerateRegionAsync(result.Globe, result.Globe.Localities.First().Cell);
}
public async Task GenerateAsync_FixedDice_NoExceptions()
{
var dice = new LinearDice(1);
var schemeService = CreateSchemeService();
var generator = new WorldGenerator(dice, schemeService);
var result = await generator.GenerateGlobeAsync();
//TODO Вынести в отдельное приложение.
// Суть приложения - генерировать мир и просматривать результат и историю генерации.
//result.Globe.Save(@"c:\worldgen");
result.Should().NotBeNull();
}
public void RollTargetLocality_AllInOneRealm_AlwaysFound()
{
var realm = new Realm();
var localities = new List <Locality>(Enumerable.Range(1, 10).Select(index => new Locality {
Name = $"{index}", Owner = realm
}));
var dice = new LinearDice(1);
for (var i = 0; i < 100; i++)
{
var targetLocality = TransportHelper.RollTargetLocality(localities, dice, realm, localities.First());
targetLocality.Should().NotBeNull();
}
}
public async Task Create_DifferentMapsRealDice_NoExceptions(int diceSeed)
{
// ARRANGE
var linearDice = new LinearDice(diceSeed);
var gaussDice = new GaussDice(diceSeed);
var randomSource = new RoomGeneratorRandomSource(linearDice, gaussDice);
var roomGenerator = new RoomGenerator(randomSource);
var mapFactory = new RoomMapFactory(roomGenerator);
var botPlayer = CreateBotPlayer();
var generator = CreateGenerator(botPlayer, mapFactory);
var sectorScheme = CreateSectorScheme();
// ACT
await generator.GenerateDungeonAsync(sectorScheme).ConfigureAwait(false);
}
/// <summary>
/// Создаёт кость и фиксирует зерно рандома.
/// Если Зерно рандома не задано, то оно выбирается случайно.
/// </summary>
/// <returns> Экземпляр кости на основе выбранного или указанного ерна рандома. </returns>
private LinearDice CreateRandomSeedAndLinearDice()
{
LinearDice dice;
if (DiceSeed == null)
{
var diceSeedFact = new Random().Next(int.MaxValue);
DiceSeed = diceSeedFact;
dice = new LinearDice(diceSeedFact);
}
else
{
dice = new LinearDice(DiceSeed.Value);
}
return(dice);
}
public async Task GenerateRegionAsync_StartProvince_RegionHasStartNode()
{
// ARRANGE
var dice = new LinearDice(1); // Для тестов указываем кость с фиксированным зурном рандома.
var schemeService = CreateSchemeService();
var generator = new WorldGenerator(dice, schemeService);
var result = await generator.GenerateGlobeAsync();
// ACT
var region = await generator.GenerateRegionAsync(result.Globe, result.Globe.StartProvince);
// ASSERT
region.RegionNodes.Should().ContainSingle(x => x.IsStart, "В стартовой провинции должен быть один стартовый узел.");
}
public void Create_RealRoomRandom_NoExceptions(int diceSeed)
{
// ARRANGE
var leanerDice = new LinearDice(diceSeed);
var gaussDice = new GaussDice(diceSeed);
var randomSource = new RoomGeneratorRandomSource(leanerDice, gaussDice);
var roomGenerator = new RoomGenerator(randomSource);
var factory = new RoomMapFactory(roomGenerator);
var sectorScheme = CreateSectorScheme();
// ACT
Func <Task> act = async() =>
{
var map = await factory.CreateAsync(sectorScheme);
};
// ARRANGE
act.Should().NotThrow();
}
public async Task Create_RealRoomRandom_NoExceptions(int diceSeed)
{
// ARRANGE
var leanerDice = new LinearDice(diceSeed);
var gaussDice = new GaussDice(diceSeed);
var randomSource = new RoomGeneratorRandomSource(leanerDice, gaussDice);
var roomGenerator = new RoomGenerator(randomSource);
var factory = new RoomMapFactory(roomGenerator);
var sectorScheme = CreateSectorScheme();
var sectorFactoryOptions = new SectorMapFactoryOptions(sectorScheme.MapGeneratorOptions);
// ACT
Func <Task> act = async() =>
{
await factory.CreateAsync(sectorFactoryOptions).ConfigureAwait(false);
};
// ARRANGE
await act.Should().NotThrowAsync().ConfigureAwait(false);
}
public async Task Create_RealRoomRandom_NoOverlapNodesAsync()
{
// ARRANGE
var linearDice = new LinearDice(3245);
var gaussDice = new GaussDice(3245);
var randomSource = new RoomGeneratorRandomSource(linearDice, gaussDice);
var roomGenerator = new RoomGenerator(randomSource);
var factory = new RoomMapFactory(roomGenerator);
var sectorScheme = CreateSectorScheme();
// ACT
var map = await factory.CreateAsync(sectorScheme);
// ARRANGE
var hexNodes = map.Nodes.Cast <HexNode>().ToArray();
foreach (var node in hexNodes)
{
var sameNode = hexNodes.Where(x => x != node && x.OffsetX == node.OffsetX && x.OffsetY == node.OffsetY);
sameNode.Should().BeEmpty();
}
}
public async Task GenerateAsync_ShowHistory()
{
var dice = new LinearDice();
var schemeService = CreateSchemeService();
var generator = new WorldGenerator(dice, schemeService);
var result = await generator.GenerateGlobeAsync();
var historyText = string.Empty;
var iterationHistory = result.History.Items.GroupBy(x => x.Iteration).OrderBy(x => x.Key);
foreach (var iterationHistoryGroup in iterationHistory)
{
historyText += $"{iterationHistoryGroup.Key} iteration" + Environment.NewLine;
foreach (var historyItem in iterationHistoryGroup)
{
historyText += historyItem.Event + Environment.NewLine;
}
}
Console.WriteLine(historyText);
}
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());
}
/// <summary>
/// Подготовка дополнительных сервисов
/// </summary>
private void RegisterAuxServices(IServiceRegistry container)
{
var dice = new LinearDice();
container.Register <IDice>(factory => dice, LightInjectWrapper.CreateSingleton());
}
/// <summary>
/// Подготовка дополнительных сервисов
/// </summary>
private void RegisterAuxServices(IServiceRegistry container)
{
var dice = new LinearDice();
container.Register <IDice>(factory => dice, new PerContainerLifetime());
}
public async Task CreateMonsters_AlwaysMaxRarityRolls_MaxHighRarityMonstersAsync()
{
var schemeDict = new Dictionary <string, IMonsterScheme>
{
{ "regular", CreateMonsterScheme("regular") },
{ "rare", CreateMonsterScheme("rare") },
{ "champion", CreateMonsterScheme("champion") }
};
var schemeServiceMock = new Mock <ISchemeService>();
schemeServiceMock.Setup(x => x.GetScheme <IMonsterScheme>(It.IsAny <string>()))
.Returns <string>(sid => schemeDict[sid]);
var schemeService = schemeServiceMock.Object;
var dice = new LinearDice(3121);
var randomSourceMock = new Mock <MonsterGeneratorRandomSource>(dice).As <IMonsterGeneratorRandomSource>();
randomSourceMock.CallBase = true;
randomSourceMock.Setup(x => x.RollRarity()).Returns(2);
randomSourceMock.Setup(x => x.RollRegionCount(It.IsAny <int>(), It.IsAny <int>())).Returns(20);
var randomSource = randomSourceMock.Object;
var actorList = new List <IActor>();
var actorManagerMock = new Mock <IActorManager>();
actorManagerMock.Setup(x => x.Add(It.IsAny <IActor>())).Callback <IActor>(a => actorList.Add(a));
actorManagerMock.SetupGet(x => x.Items).Returns(actorList);
var actorManager = actorManagerMock.Object;
var propContainerManagerMock = new Mock <IStaticObjectManager>();
var propContainerManager = propContainerManagerMock.Object;
propContainerManagerMock.SetupGet(x => x.Items).Returns(Array.Empty <IStaticObject>());
var taskSourceMock = new Mock <IActorTaskSource <ISectorTaskSourceContext> >();
var taskSource = taskSourceMock.Object;
var monsterFactory = new MonsterPersonFactory();
var monsterGenerator = new MonsterGenerator(schemeService,
monsterFactory,
randomSource,
taskSource);
var map = await SquareMapFactory.CreateAsync(20).ConfigureAwait(false);
var sectorMock = new Mock <ISector>();
sectorMock.SetupGet(x => x.ActorManager).Returns(actorManager);
sectorMock.SetupGet(x => x.StaticObjectManager).Returns(propContainerManager);
sectorMock.SetupGet(x => x.Map).Returns(map);
var sector = sectorMock.Object;
var monsterRegions = new List <MapRegion>
{
new MapRegion(1, map.Nodes.ToArray())
};
var sectorScheme = new TestSectorSubScheme
{
RegularMonsterSids = new[] { "regular" },
RareMonsterSids = new[] { "rare" },
ChampionMonsterSids = new[] { "champion" }
};
// ACT
monsterGenerator.CreateMonsters(sector,
monsterRegions,
sectorScheme);
// ASSERT
var championCount = actorManager.Items.Count(x => ((MonsterPerson)x.Person).Scheme.Sid == "champion");
championCount.Should().Be(1);
var rareCount = actorManager.Items.Count(x => ((MonsterPerson)x.Person).Scheme.Sid == "rare");
rareCount.Should().Be(10);
}
