private async Task <DungeonModel> GenerateDungeonAsync(DungeonOptionModel optionModel, int optionId)
{
var dungeon = await GenerateDungeonAsync(optionModel);
dungeon.DungeonOptionId = optionId;
return(dungeon);
}
public DungeonNoCorridor GetNCDungeon(DungeonOptionModel optionModel = null)
{
var helperService = _scope.ServiceProvider.GetService <IDungeonHelper>();
if (optionModel is null)
{
optionModel = new DungeonOptionModel
{
DungeonName = "UT Dungeon",
Created = DateTime.UtcNow,
ItemsRarity = 1,
DeadEnd = true,
DungeonDifficulty = 1,
DungeonSize = 25,
MonsterType = "any",
PartyLevel = 4,
PartySize = 4,
TrapPercent = 20,
RoamingPercent = 0,
TreasureValue = 1,
RoomDensity = 10,
RoomSize = 20,
Corridor = false
};
}
helperService.Init(optionModel);
return(new DungeonNoCorridor(800, 800, 15, 15, helperService));
}
public async void CanCreateDungeonOption()
{
using var env = new TestEnvironment();
var service = env.GetService <IDungeonService>();
var optionsModel = new DungeonOptionModel
{
DungeonName = "UT Dungeon",
Created = DateTime.UtcNow,
ItemsRarity = 1,
DeadEnd = true,
DungeonDifficulty = 1,
DungeonSize = 25,
MonsterType = "any",
PartyLevel = 4,
PartySize = 4,
TrapPercent = 20,
RoamingPercent = 0,
TreasureValue = 1,
RoomDensity = 10,
RoomSize = 20,
Corridor = false,
UserId = 1
};
var source = new CancellationTokenSource();
var token = source.Token;
var result = await service.CreateDungeonOptionAsync(optionsModel, token);
result.ShouldBeGreaterThan(0);
}
private async Task <DungeonModel> UpdateExistingDungeonAsync(DungeonOptionModel optionModel, DungeonOptionModel existingDungeonOption, DungeonModel oldDungeon, CancellationToken cancellationToken)
{
var dungeon = await GenerateDungeonAsync(optionModel, existingDungeonOption.Id);
dungeon.Id = oldDungeon.Id;
dungeon.Level = oldDungeon.Level;
await UpdateDungeonAsync(dungeon, cancellationToken);
return(dungeon);
}
private static void ValidateModel(DungeonOptionModel model)
{
if (string.IsNullOrWhiteSpace(model.DungeonName))
{
throw new ServiceException(Resources.Error.Required);
}
if (model.UserId == 0)
{
throw new ServiceException(Resources.Error.Required);
}
}
public async Task <DungeonModel> GenerateDungeonAsync(DungeonOptionModel model)
{
try
{
ValidateModel(model);
_dungeonHelper.Init(model);
var dungeonOptions = new DungeonOptionsModel
{
Size = model.DungeonSize,
RoomDensity = model.RoomDensity,
RoomSizePercent = model.RoomSize,
TrapPercent = model.TrapPercent,
HasDeadEnds = model.DeadEnd,
RoamingPercent = model.RoamingPercent
};
if (model.Corridor)
{
var dungeon = new Generator.Dungeon(dungeonOptions, _dungeonHelper);
dungeon.Generate();
return(await Task.FromResult(
new DungeonModel()
{
DungeonTiles = JsonSerializer.Serialize(dungeon.DungeonTiles),
RoomDescription = JsonSerializer.Serialize(dungeon.RoomDescription),
TrapDescription = JsonSerializer.Serialize(dungeon.TrapDescription),
RoamingMonsterDescription = JsonSerializer.Serialize(dungeon.RoamingMonsterDescription),
DungeonOptionId = model.Id
}
));
}
else
{
var dungeonNoCorridor = new DungeonNoCorridor(dungeonOptions.Width, dungeonOptions.Height, model.DungeonSize, model.RoomSize, _dungeonHelper);
dungeonNoCorridor.Generate();
return(await Task.FromResult(
new DungeonModel()
{
DungeonTiles = JsonSerializer.Serialize(dungeonNoCorridor.DungeonTiles),
RoomDescription = JsonSerializer.Serialize(dungeonNoCorridor.RoomDescription),
DungeonOptionId = model.Id,
TrapDescription = "[]",
RoamingMonsterDescription = "[]"
}
));
}
}
catch (Exception ex)
{
_logger.LogError("Error: " + ex.Message);
throw;
}
}
private async Task <DungeonModel> CreateOptionAndAddDungeonToItAsync(DungeonOptionModel optionModel, CancellationToken cancellationToken)
{
await CreateDungeonOptionAsync(optionModel, cancellationToken);
var created = await GetDungeonOptionByNameAsync(optionModel.DungeonName, optionModel.UserId, cancellationToken);
var dungeon = await GenerateDungeonAsync(optionModel, created.Id);
dungeon.Level = 1;
var id = await AddDungeonAsync(dungeon, cancellationToken);
dungeon.Id = id;
return(dungeon);
}
public async Task <int> CreateDungeonOptionAsync(DungeonOptionModel dungeonOption, CancellationToken cancellationToken)
{
try
{
ValidateModel(dungeonOption);
var option = await _dungeonOptionRepository.AddDungeonOptionAsync(_mapper.Map <DungeonOption>(dungeonOption), cancellationToken);
return(option.Id);
}
catch (Exception ex)
{
_logger.LogError(ex, $"Create dungeon option failed.");
throw;
}
}
private async Task <DungeonModel> AddDungeonToExistingOptionAsync(DungeonOptionModel optionModel, int level, CancellationToken cancellationToken)
{
var existingDungeons = await ListUserDungeonsByNameAsync(optionModel.DungeonName, optionModel.UserId, cancellationToken);
var dungeon = await GenerateDungeonAsync(optionModel, optionModel.Id);
dungeon.Level = level;
if (existingDungeons.Any(d => d.Level == level))
{
dungeon.Id = existingDungeons.First(dm => dm.Level == level).Id;
await UpdateDungeonAsync(dungeon, cancellationToken);
}
else
{
dungeon.Id = await AddDungeonAsync(dungeon, cancellationToken);
}
return(dungeon);
}
public async void CanCreateOrUpdateDungeon()
{
using var env = new TestEnvironment();
var service = env.GetService <IDungeonService>();
var source = new CancellationTokenSource();
var token = source.Token;
var optionsModel = new DungeonOptionModel
{
DungeonName = "UT Dungeon",
Created = DateTime.UtcNow,
ItemsRarity = 1,
DeadEnd = true,
DungeonDifficulty = 1,
DungeonSize = 25,
MonsterType = "any",
PartyLevel = 4,
PartySize = 4,
TrapPercent = 20,
RoamingPercent = 0,
TreasureValue = 1,
RoomDensity = 10,
RoomSize = 20,
Corridor = false,
UserId = 1
};
var result = await service.CreateOrUpdateDungeonAsync(optionsModel, false, 1, token);
result.ShouldNotBeNull();
var existingDungeonOption = (await service.GetAllDungeonOptionsForUserAsync(optionsModel.UserId, token)).First();
var dungeonCount = (await service.ListUserDungeonsByNameAsync(existingDungeonOption.DungeonName, optionsModel.UserId, token)).Count;
result = await service.CreateOrUpdateDungeonAsync(existingDungeonOption, true, 2, token);
var newDungeonCount = (await service.ListUserDungeonsByNameAsync(existingDungeonOption.DungeonName, optionsModel.UserId, token)).Count;
result.ShouldNotBeNull();
result.Level.ShouldBe(2);
newDungeonCount.ShouldBeGreaterThan(dungeonCount);
}
public async Task <DungeonModel> CreateOrUpdateDungeonAsync(DungeonOptionModel optionModel, bool addDungeon, int level, CancellationToken cancellationToken)
{
try
{
ValidateModel(optionModel);
if (addDungeon)
{
return(await AddDungeonToExistingOptionAsync(optionModel, level, cancellationToken));
}
var existingDungeonOption = await GetDungeonOptionByNameAsync(optionModel.DungeonName, optionModel.UserId, cancellationToken);
if (existingDungeonOption is null)
{
return(await CreateOptionAndAddDungeonToItAsync(optionModel, cancellationToken));
}
else // regenerate
{
var existingDungeons = await ListUserDungeonsByNameAsync(optionModel.DungeonName, optionModel.UserId, cancellationToken);
var oldDungeon = existingDungeons.FirstOrDefault();
if (oldDungeon is not null)
{
return(await UpdateExistingDungeonAsync(optionModel, existingDungeonOption, oldDungeon, cancellationToken));
}
else
{
optionModel.Id = existingDungeonOption.Id;
return(await AddDungeonToExistingOptionAsync(optionModel, level, cancellationToken));
}
}
}
catch (Exception ex)
{
_logger.LogError(ex, "Error creating dungeon.");
throw;
}
}
private async Task SeedDungeons(CancellationToken token)
{
var dungeonOption = new DungeonOption()
{
UserId = 1,
DungeonName = "Test1",
Created = DateTime.UtcNow,
ItemsRarity = 1,
DeadEnd = true,
DungeonDifficulty = 1,
DungeonSize = 20,
MonsterType = "any",
PartyLevel = 4,
PartySize = 4,
TrapPercent = 20,
RoamingPercent = 10,
TreasureValue = 1,
RoomDensity = 10,
RoomSize = 20,
Corridor = true
};
_context.DungeonOptions.Add(dungeonOption);
await _context.SaveChangesAsync(token);
var model = new DungeonOptionModel()
{
DungeonName = dungeonOption.DungeonName,
Created = dungeonOption.Created,
ItemsRarity = dungeonOption.ItemsRarity,
DeadEnd = dungeonOption.DeadEnd,
DungeonDifficulty = dungeonOption.DungeonDifficulty,
DungeonSize = dungeonOption.DungeonSize,
MonsterType = dungeonOption.MonsterType,
PartyLevel = dungeonOption.PartyLevel,
PartySize = dungeonOption.PartySize,
TrapPercent = dungeonOption.TrapPercent,
RoamingPercent = dungeonOption.RoamingPercent,
TreasureValue = dungeonOption.TreasureValue,
RoomDensity = dungeonOption.RoomDensity,
RoomSize = dungeonOption.RoomSize,
Corridor = dungeonOption.Corridor,
Id = dungeonOption.Id,
UserId = dungeonOption.UserId
};
var sd = await _dungeonService.GenerateDungeonAsync(model);
sd.Level = 1;
await _dungeonService.AddDungeonAsync(sd, token);
dungeonOption = new DungeonOption()
{
UserId = 1,
DungeonName = "Test2",
Created = DateTime.UtcNow,
ItemsRarity = 1,
DeadEnd = true,
DungeonDifficulty = 1,
DungeonSize = 25,
MonsterType = "any",
PartyLevel = 4,
PartySize = 4,
TrapPercent = 20,
RoamingPercent = 0,
TreasureValue = 1,
RoomDensity = 10,
RoomSize = 20,
Corridor = false
};
_context.DungeonOptions.Add(dungeonOption);
await _context.SaveChangesAsync(token);
model = new DungeonOptionModel()
{
DungeonName = dungeonOption.DungeonName,
Created = dungeonOption.Created,
ItemsRarity = dungeonOption.ItemsRarity,
DeadEnd = dungeonOption.DeadEnd,
DungeonDifficulty = dungeonOption.DungeonDifficulty,
DungeonSize = dungeonOption.DungeonSize,
MonsterType = dungeonOption.MonsterType,
PartyLevel = dungeonOption.PartyLevel,
PartySize = dungeonOption.PartySize,
TrapPercent = dungeonOption.TrapPercent,
RoamingPercent = dungeonOption.RoamingPercent,
TreasureValue = dungeonOption.TreasureValue,
RoomDensity = dungeonOption.RoomDensity,
RoomSize = dungeonOption.RoomSize,
Corridor = dungeonOption.Corridor,
Id = dungeonOption.Id,
UserId = dungeonOption.UserId
};
sd = await _dungeonService.GenerateDungeonAsync(model);
sd.Level = 1;
await _dungeonService.AddDungeonAsync(sd, token);
}
private static string[] GetMonsters(DungeonOptionModel model)
{
return model.MonsterType.Split(',');
}
