protected override void OnGameStart(Game game, IGameStarter gameStarterObject)
{
base.OnGameStart(game, gameStarterObject);
if (game.GameType is Campaign)
{
/*
* CampaignEvents.OnGameLoadedEvent.AddNonSerializedListener(this, _ =>
* {
* var settingsProvider = this.GetServiceProvider()?.GetRequiredService<BaseSettingsProvider>();
* settingsProvider?.OnGameStarted(game);
* });
* CampaignEvents.OnNewGameCreatedEvent.AddNonSerializedListener(this, _ =>
* {
* var settingsProvider = this.GetServiceProvider()?.GetRequiredService<BaseSettingsProvider>();
* settingsProvider?.OnGameStarted(game);
* });
*/
var settingsProvider = GenericServiceProvider.GetService <BaseSettingsProvider>();
settingsProvider?.OnGameStarted(game);
var gameStarter = (CampaignGameStarter)gameStarterObject;
gameStarter.AddBehavior(GenericServiceProvider.GetService <PerSaveCampaignBehavior>());
}
}
public DefaultSettingsProvider(IBUTRLogger <DefaultSettingsProvider> logger)
{
_logger = logger;
var globalSettingsContainers = (GenericServiceProvider.GetService <IEnumerable <IGlobalSettingsContainer> >() ??
Enumerable.Empty <IGlobalSettingsContainer>()).ToList();
var perSaveSettingsContainers = (GenericServiceProvider.GetService <IEnumerable <IPerSaveSettingsContainer> >() ??
Enumerable.Empty <IPerSaveSettingsContainer>()).ToList();
var perCampaignSettingsContainers = (GenericServiceProvider.GetService <IEnumerable <IPerCampaignSettingsContainer> >() ??
Enumerable.Empty <IPerCampaignSettingsContainer>()).ToList();
foreach (var globalSettingsContainer in globalSettingsContainers)
{
logger.LogInformation("Found Global container {type}.", globalSettingsContainer.GetType());
}
foreach (var perSaveSettingsContainer in perSaveSettingsContainers)
{
logger.LogInformation("Found PerSave container {type}.", perSaveSettingsContainer.GetType());
}
foreach (var perCampaignSettingsContainer in perCampaignSettingsContainers)
{
logger.LogInformation("Found Campaign container {type}.", perCampaignSettingsContainer.GetType());
}
_settingsContainers = Enumerable.Empty <ISettingsContainer>()
.Concat(globalSettingsContainers)
.Concat(perSaveSettingsContainers)
.ToList();
}
public SettingsBase?GetSettings(string id)
{
if (GenericServiceProvider.GetService <BaseSettingsProvider>() is { } settingsProvider)
{
var baseSettings = settingsProvider.GetSettings(id);
if (baseSettings is MBOv1GlobalSettingsWrapper {
Object : SettingsBase settings
})
public override MCMv3BaseSettings?GetSettings(string id)
{
if (GenericServiceProvider.GetService <BaseSettingsProvider>() is { } settingsProvider)
{
var baseSettings = settingsProvider?.GetSettings(id);
if (baseSettings is MCMv3GlobalSettingsWrapper {
Object : MCMv3BaseSettings settings
})
public void Resolve_Test()
{
var implementations = GenericServiceProvider.GetService <IEnumerable <ISettingsFormat> >()?.ToList() ?? new List <ISettingsFormat>();
Assert.True(implementations.Any(i => i is MemorySettingsFormat), "MemorySettingsFormat missing");
Assert.True(implementations.Any(i => i is JsonSettingsFormat), "JsonSettingsFormat missing");
Assert.True(implementations.Any(i => i is XmlSettingsFormat), "XmlSettingsFormat missing");
}
public async Task Cleanup()
{
Logger.LogInformation("Started cleanup!");
TrainingRoomDbContext context = GenericServiceProvider.GetService <TrainingRoomDbContext>();
await context.Database.EnsureDeletedAsync();
await GenericServiceProvider.DisposeAsync();
Logger.LogInformation("Finished cleanup!");
}
public override void OnGameEnd(Game game)
{
base.OnGameEnd(game);
if (game.GameType is Campaign)
{
var settingsProvider = GenericServiceProvider.GetService <BaseSettingsProvider>();
settingsProvider?.OnGameEnded(game);
}
}
public static IEnumerable <SettingsPropertyGroupDefinition> GetUnsortedSettingPropertyGroups(this BaseSettings settings)
{
if (settings is IFluentSettings fluentSettings)
{
return(fluentSettings.SettingPropertyGroups);
}
var discoverers = GenericServiceProvider.GetService <IEnumerable <ISettingsPropertyDiscoverer> >() ?? Enumerable.Empty <ISettingsPropertyDiscoverer>();
var discoverer = discoverers.FirstOrDefault(x => x.DiscoveryTypes.Any(y => y == settings.DiscoveryType));
return(SettingsUtils.GetSettingsPropertyGroups(settings.SubGroupDelimiter, discoverer?.GetProperties(settings) ?? Enumerable.Empty <ISettingsPropertyDefinition>()));
}
/// <inheritdoc/>
protected override void RegisterSettings(FluentPerCampaignSettings?perCampaignSettings)
{
if (perCampaignSettings is null)
{
return;
}
var directoryPath = Path.Combine(RootFolder, Campaign.Current.UniqueGameId, perCampaignSettings.FolderName, perCampaignSettings.SubFolder);
var settingsFormats = GenericServiceProvider.GetService <IEnumerable <ISettingsFormat> >() ?? Enumerable.Empty <ISettingsFormat>();
var settingsFormat = settingsFormats.FirstOrDefault(x => x.FormatTypes.Any(y => y == perCampaignSettings.FormatType));
settingsFormat?.Load(perCampaignSettings, directoryPath, perCampaignSettings.Id);
}
protected override void RegisterSettings(GlobalSettings?settings)
{
if (settings is null || LoadedSettings.ContainsKey(settings.Id))
{
return;
}
LoadedSettings.Add(settings.Id, settings);
var directoryPath = Path.Combine(RootFolder, settings.FolderName, settings.SubFolder);
var settingsFormats = GenericServiceProvider.GetService <IEnumerable <ISettingsFormat> >() ?? Enumerable.Empty <ISettingsFormat>();
var settingsFormat = settingsFormats.FirstOrDefault(x => x.FormatTypes.Any(y => y == settings.FormatType));
settingsFormat?.Load(settings, directoryPath, settings.Id);
}
/// <inheritdoc/>
public override bool SaveSettings(BaseSettings settings)
{
if (settings is not PerCampaignSettings campaignSettings)
{
return(false);
}
var directoryPath = Path.Combine(RootFolder, Campaign.Current.UniqueGameId, campaignSettings.FolderName, campaignSettings.SubFolder);
var settingsFormats = GenericServiceProvider.GetService <IEnumerable <ISettingsFormat> >() ?? Enumerable.Empty <ISettingsFormat>();
var settingsFormat = settingsFormats.FirstOrDefault(x => x.FormatTypes.Any(y => y == campaignSettings.FormatType));
settingsFormat?.Save(campaignSettings, directoryPath, campaignSettings.Id);
return(true);
}
/// <inheritdoc/>
public override bool SaveSettings(BaseSettings settings)
{
var behavior = GenericServiceProvider.GetService <PerSaveCampaignBehavior>();
if (behavior is null)
{
return(false);
}
if (settings is not PerSaveSettings || !LoadedSettings.ContainsKey(settings.Id))
{
return(false);
}
return(behavior.SaveSettings((PerSaveSettings)settings));
}
/// <inheritdoc/>
protected override void RegisterSettings(PerSaveSettings?perSaveSettings)
{
var behavior = GenericServiceProvider.GetService <PerSaveCampaignBehavior>();
if (behavior is null)
{
return;
}
if (perSaveSettings is null)
{
return;
}
LoadedSettings.Add(perSaveSettings.Id, perSaveSettings);
behavior.LoadSettings(perSaveSettings);
}
public async Task Initialize()
{
IServiceCollection serviceCollection = new ServiceCollection();
serviceCollection.AddLogging(builder => builder.AddConsole());
serviceCollection.AddAutoMapper(Assembly.GetAssembly(typeof(TrainingRoomStartupExtensions)));
#region Database
// NOTE: to verify if the test works in memory use code below..
//serviceCollection.AddOptions();
//serviceCollection.Configure<DbConfiguration>(dbConfig =>
//{
// //InMemory by default
// dbConfig.UseLazyLoading = true;
// dbConfig.ConnectionString = "";
// dbConfig.DbProvider = "";
//});
//serviceCollection.AddSingleton<IFactory<TrainingRoomDbContext>, TrainingRoomDatabaseFactory>();
//serviceCollection.AddTransient<TrainingRoomDbContext>(p => p.GetService<IFactory<TrainingRoomDbContext>>().Create());
SqliteConnection = new SqliteConnection("Data Source=:memory:");
SqliteConnection.Open();
serviceCollection.AddDbContext <TrainingRoomDbContext>(optionsBuilder =>
{
optionsBuilder.UseSqlite(SqliteConnection);
optionsBuilder.EnableSensitiveDataLogging();
});
#endregion Database
#region Validators
serviceCollection.AddTransient <IEntityValidator <TrainingRoom>, TrainingRoomValidator>();
serviceCollection.AddTransient <IEntityValidator <TrainingSession>, TrainingSessionValidator>();
serviceCollection.AddTransient <IEntityValidator <TrainingRoomSettings>, TrainingRoomSettingsValidator>();
#endregion Validators
#region Repositories
serviceCollection.AddTransient <IRepository <TrainingRoom>, Repository <TrainingRoom, TrainingRoomDbContext> >();
serviceCollection.AddTransient <ITrainingSessionRepository, TrainingSessionRepository>();
serviceCollection.AddTransient <IRepository <TrainingRoomSettings>, Repository <TrainingRoomSettings, TrainingRoomDbContext> >();
#endregion Repositories
#region Services
serviceCollection.AddTransient <ITrainingRoomService, Application.Services.TrainingRoomService>();
serviceCollection.AddTransient <ITrainingSessionService, Application.Services.TrainingSessionService>();
UserId = Guid.NewGuid();
const string username = "******";
serviceCollection.AddSingleton <IUserService, UserServiceMock>(p => new UserServiceMock(UserId, username));
#endregion Services
GenericServiceProvider = serviceCollection.BuildServiceProvider().ToGenericServiceProvider();
Logger = GenericServiceProvider.GetService <ILogger <TrainingSessionServiceTests> >();
Logger.LogInformation("Started initialization!");
TrainingSessionService = GenericServiceProvider.GetService <ITrainingSessionService>();
TrainingRoomDbContext context = GenericServiceProvider.GetService <TrainingRoomDbContext>();
await context.Database.EnsureCreatedAsync();
ITrainingRoomService trainingRoomService = GenericServiceProvider.GetService <ITrainingRoomService>();
IUserService userService = GenericServiceProvider.GetService <IUserService>();
TrainingRoomDto trainingRoomDto = new TrainingRoomDto()
{
Id = Guid.NewGuid(),
Name = "Cool room",
OwnerId = UserId,
Owner = await userService.FindUserAsync(UserId),
Generation = 0,
TrainingRoomSettings = new TrainingRoomSettingsDto()
{
Id = Guid.NewGuid(),
OrganismCount = (uint)OrganismCount,
InputCount = 2,
OutputCount = 1,
SpeciesExcessGeneWeight = 1,
SpeciesDisjointGeneWeight = 1,
SpeciesAverageWeightDiffWeight = 0.4,
Threshold = 3,
AddConnectionChance = 0.05,
AddNodeChance = 0.03,
CrossOverChance = 0.75,
InterSpeciesChance = 0.001,
MutationChance = 1,
MutateWeightChance = 0.8,
WeightReassignChance = 0.1,
TopAmountToSurvive = 0.5,
EnableConnectionChance = 0.25,
Seed = 1,
MaxStagnantTime = 15,
ChampionCloneMinSpeciesSize = 5
},
AuthorizedTrainers = new List <TrainerDto>(),
TrainingSessions = new List <TrainingSessionDto>()
};
(bool success, Guid id) = await trainingRoomService.CreateAsync(trainingRoomDto);
Logger.LogInformation($"Created a training room: {success} id: {id}");
TrainingRoomId = id;
Logger.LogInformation("Finished initialization!");
}
public static ISettingsBuilder?Create(string id, string displayName) => GenericServiceProvider.GetService <ISettingsBuilderFactory>()?.Create(id, displayName);
