private void PerformAdditionalValidation(List <WildlifeReportTyped> typedRows)
{
MethodLogger.LogEntry(_logger, _enableMethodLog, _methodLogHeader);
foreach (var typedRow in typedRows)
{
var errors = new Dictionary <string, List <string> >();
var submissionRow = _submissionRows[(decimal)typedRow.RowNum];
if (typedRow.AccidentDate != null && typedRow.AccidentDate > DateTime.Now)
{
errors.AddItem(Fields.AccidentDate, "Cannot be a future date.");
}
ValidateHighwayUniqueAgainstServiceArea(typedRow.HighwayUnique, errors);
if (!ValidateGpsCoordsRange(typedRow.Longitude, typedRow.Latitude))
{
errors.AddItem($"{Fields.Longitude}/{Fields.Latitude}", "Invalid range of GPS coordinates.");
}
if (errors.Count > 0)
{
SetErrorDetail(submissionRow, errors, _statusService.FileConflictionError);
}
}
}
private void PerformAdditionalValidation(List <WorkReportTyped> typedRows)
{
MethodLogger.LogEntry(_logger, _enableMethodLog, _methodLogHeader);
foreach (var typedRow in typedRows)
{
var errors = new Dictionary <string, List <string> >();
var submissionRow = _submissionRows[(decimal)typedRow.RowNum];
if (typedRow.StartDate != null && typedRow.EndDate < typedRow.StartDate)
{
errors.AddItem("StartDate", "Start Date cannot be greater than End Date");
}
if (typedRow.StartDate != null && typedRow.StartDate > DateTime.Now)
{
errors.AddItem(Fields.StartDate, "Cannot be a future date.");
}
if (typedRow.EndDate != null && typedRow.EndDate > DateTime.Now)
{
errors.AddItem(Fields.EndDate, "Cannot be a future date.");
}
ValidateHighwayUniqueAgainstServiceArea(typedRow.HighwayUnique, errors);
if (typedRow.SpatialData == SpatialData.Gps)
{
PerformGpsPointValidation(typedRow, errors);
PerformGpsLineValidation(typedRow, errors);
PerformGpsEitherLineOrPointValidation(typedRow);
}
if (typedRow.SpatialData == SpatialData.Lrs)
{
PerformOffsetPointValidation(typedRow, errors);
PerformOffsetLineValidation(typedRow, errors);
PerformOffsetEitherLineOrPointValidation(typedRow);
}
if (!ValidateGpsCoordsRange(typedRow.StartLongitude, typedRow.StartLatitude))
{
errors.AddItem($"{Fields.StartLongitude}/{Fields.StartLatitude}", "Invalid range of GPS coordinates.");
}
if (!ValidateGpsCoordsRange(typedRow.EndLongitude, typedRow.EndLatitude))
{
errors.AddItem($"{Fields.EndLongitude}/{Fields.EndLatitude}", "Invalid range of GPS coordinates.");
}
if (errors.Count > 0)
{
SetErrorDetail(submissionRow, errors, _statusService.FileConflictionError);
}
}
}
private void CopyCalculatedFieldsFormUntypedRow(List <RockfallReportTyped> typedRows, List <RockfallReportCsvDto> untypedRows)
{
MethodLogger.LogEntry(_logger, _enableMethodLog, _methodLogHeader);
foreach (var typedRow in typedRows)
{
var untypedRow = untypedRows.First(x => x.RowNum == typedRow.RowNum);
typedRow.SpatialData = untypedRow.SpatialData;
typedRow.RowId = untypedRow.RowId;
}
}
private void PerformAdditionalValidation(List <RockfallReportTyped> typedRows)
{
MethodLogger.LogEntry(_logger, _enableMethodLog, _methodLogHeader);
foreach (var typedRow in typedRows)
{
var errors = new Dictionary <string, List <string> >();
var submissionRow = _submissionRows[(decimal)typedRow.RowNum];
if (typedRow.StartOffset != null && typedRow.EndOffset < typedRow.StartOffset)
{
errors.AddItem(Fields.StartOffset, "Start Offset cannot be greater than End Offset");
}
if (typedRow.DitchVolume == DitchVolume.Threshold)
{
_validator.Validate(Entities.RockfallReportOtherDitchVolume, Fields.OtherDitchVolume, typedRow.OtherDitchVolume, errors);
}
if (typedRow.TravelledLanesVolume == DitchVolume.Threshold)
{
_validator.Validate(Entities.RockfallReportOtherTravelledLanesVolume, Fields.OtherTravelledLanesVolume, typedRow.OtherTravelledLanesVolume, errors);
}
if (typedRow.ReportDate != null && typedRow.ReportDate > DateTime.Now)
{
errors.AddItem(Fields.ReportDate, "Cannot be a future date.");
}
if (typedRow.EstimatedRockfallDate != null && typedRow.EstimatedRockfallDate > DateTime.Now)
{
errors.AddItem(Fields.EstimatedRockfallDate, "Report Date cannot be a future date.");
}
ValidateHighwayUniqueAgainstServiceArea(typedRow.HighwayUnique, errors);
if (!ValidateGpsCoordsRange(typedRow.StartLongitude, typedRow.StartLatitude))
{
errors.AddItem($"{Fields.StartLongitude}/{Fields.StartLatitude}", "Invalid range of GPS coordinates.");
}
if (!ValidateGpsCoordsRange(typedRow.EndLongitude, typedRow.EndLatitude))
{
errors.AddItem($"{Fields.EndLongitude}/{Fields.EndLatitude}", "Invalid range of GPS coordinates.");
}
if (errors.Count > 0)
{
SetErrorDetail(submissionRow, errors, _statusService.FileConflictionError);
}
}
}
private void CopyCalculatedFieldsFormUntypedRow(List <WorkReportTyped> typedRows, List <WorkReportCsvDto> untypedRows)
{
MethodLogger.LogEntry(_logger, _enableMethodLog, _methodLogHeader);
foreach (var typedRow in typedRows)
{
var untypedRow = untypedRows.First(x => x.RowNum == typedRow.RowNum);
typedRow.FeatureType = untypedRow.FeatureType;
typedRow.SpatialData = untypedRow.SpatialData;
typedRow.RowId = untypedRow.RowId;
typedRow.SpThresholdLevel = untypedRow.SpThresholdLevel;
}
}
private List <RockfallReportGeometry> PerformSpatialValidationAndConversionBatchAsync(List <RockfallReportTyped> typedRows)
{
MethodLogger.LogEntry(_logger, _enableMethodLog, _methodLogHeader, $"Total Record: {typedRows.Count}");
//grouping the rows
var groups = new List <List <RockfallReportTyped> >();
var currentGroup = new List <RockfallReportTyped>();
var count = 0;
foreach (var typedRow in typedRows)
{
currentGroup.Add(typedRow);
count++;
if (count % 10 == 0)
{
groups.Add(currentGroup);
currentGroup = new List <RockfallReportTyped>();
}
}
if (currentGroup.Count > 0)
{
groups.Add(currentGroup);
}
var geometries = new ConcurrentBag <RockfallReportGeometry>();
var progress = 0;
foreach (var group in groups)
{
var tasklist = new List <Task>();
foreach (var row in group)
{
tasklist.Add(Task.Run(async() => geometries.Add(await PerformSpatialValidationAndConversionAsync(row))));
}
Task.WaitAll(tasklist.ToArray());
progress += 10;
if (progress % 500 == 0)
{
_logger.LogInformation($"{_methodLogHeader} PerformSpatialValidationAndConversionAsync {progress}");
}
}
return(geometries.ToList());
}
private (List <WildlifeReportCsvDto> untypedRows, string headers) ParseRowsUnTyped(Dictionary <string, List <string> > errors)
{
MethodLogger.LogEntry(_logger, _enableMethodLog, _methodLogHeader);
using TextReader textReader = new StreamReader(new MemoryStream(_submission.DigitalRepresentation), Encoding.UTF8);
using var csv = new CsvReader(textReader, CultureInfo.InvariantCulture);
CsvHelperUtils.Config(errors, csv, false);
csv.Configuration.RegisterClassMap <WildlifeReportCsvDtoMap>();
var rows = GetRecords(csv);
return(rows, string.Join(',', csv.Context.HeaderRecord).Replace("\"", ""));
}
private (decimal rowNum, List <RockfallReportTyped> rows) ParseRowsTyped(string text, Dictionary <string, List <string> > errors)
{
MethodLogger.LogEntry(_logger, _enableMethodLog, _methodLogHeader);
using var stringReader = new StringReader(text);
using var csv = new CsvReader(stringReader, CultureInfo.InvariantCulture);
CsvHelperUtils.Config(errors, csv, false);
csv.Configuration.RegisterClassMap <RockfallReportDtoMap>();
var rows = new List <RockfallReportTyped>();
var rowNum = 0M;
while (csv.Read())
{
try
{
var row = csv.GetRecord <RockfallReportTyped>();
row.HighwayUnique = row.HighwayUnique.ToTrimAndUppercase();
//rockfall requires Y/N fields to be set to Uppercase, see HMCR-643
row.HeavyPrecip = row.HeavyPrecip.ToTrimAndUppercase();
row.FreezeThaw = row.FreezeThaw.ToTrimAndUppercase();
row.DitchSnowIce = row.DitchSnowIce.ToTrimAndUppercase();
row.VehicleDamage = row.VehicleDamage.ToTrimAndUppercase();
rows.Add(row);
rowNum = (decimal)row.RowNum;
row.ServiceArea = _serviceArea.ConvertToServiceAreaNumber(row.ServiceArea);
}
catch (CsvHelper.TypeConversion.TypeConverterException ex)
{
_logger.LogError(ex.ToString());
rowNum = GetRowNum(csv.Context.RawRecord);
LogRowParseException(rowNum, ex.ToString(), csv.Context);
errors.AddItem("Parse Error", $"Exception while parsing the text [{ex.Text}]");
return(rowNum, null);
}
catch (Exception ex)
{
_logger.LogError(ex.ToString());
rowNum = GetRowNum(csv.Context.RawRecord);
LogRowParseException(rowNum, ex.ToString(), csv.Context);
errors.AddItem("Parse Error", $"Exception while parsing");
return(rowNum, null);
}
}
return(0, rows);
}
private (decimal rowNum, List <RockfallReportTyped> rows) ParseRowsTyped(string text, Dictionary <string, List <string> > errors)
{
MethodLogger.LogEntry(_logger, _enableMethodLog, _methodLogHeader);
using var stringReader = new StringReader(text);
using var csv = new CsvReader(stringReader, CultureInfo.InvariantCulture);
CsvHelperUtils.Config(errors, csv, false);
csv.Configuration.RegisterClassMap <RockfallReportDtoMap>();
var rows = new List <RockfallReportTyped>();
var rowNum = 0M;
while (csv.Read())
{
try
{
var row = csv.GetRecord <RockfallReportTyped>();
rows.Add(row);
rowNum = (decimal)row.RowNum;
row.ServiceArea = _serviceArea.ConvertToServiceAreaNumber(row.ServiceArea);
}
catch (CsvHelper.TypeConversion.TypeConverterException ex)
{
_logger.LogError(ex.ToString());
rowNum = GetRowNum(csv.Context.RawRecord);
LogRowParseException(rowNum, ex.ToString(), csv.Context);
errors.AddItem("Parse Error", $"Exception while parsing the text [{ex.Text}]");
return(rowNum, null);
}
catch (Exception ex)
{
_logger.LogError(ex.ToString());
rowNum = GetRowNum(csv.Context.RawRecord);
LogRowParseException(rowNum, ex.ToString(), csv.Context);
errors.AddItem("Parse Error", $"Exception while parsing");
return(rowNum, null);
}
}
return(0, rows);
}
private (List <RockfallReportCsvDto> untypedRows, string headers) ParseRowsUnTyped(Dictionary <string, List <string> > errors)
{
MethodLogger.LogEntry(_logger, _enableMethodLog, _methodLogHeader);
using TextReader textReader = new StreamReader(new MemoryStream(_submission.DigitalRepresentation), Encoding.UTF8);
using var csv = new CsvReader(textReader, CultureInfo.InvariantCulture);
CsvHelperUtils.Config(errors, csv, false);
csv.Configuration.RegisterClassMap <RockfallReportCsvDtoMap>();
var rows = csv.GetRecords <RockfallReportCsvDto>().ToList();
for (var i = 0; i < rows.Count; i++)
{
rows[i].RowNum = i + 2;
rows[i].ServiceArea = _serviceArea.ConvertToServiceAreaString(rows[i].ServiceArea);
}
return(rows, string.Join(',', csv.Context.HeaderRecord).Replace("\"", ""));
}
private static void LogRequest(IRestRequest request, IRestResponse response, long durationMs, RestClient _restClient)
{
var requestToLog = new
{
resource = request.Resource,
// Parameters are custom anonymous objects in order to have the parameter type as a nice string
// otherwise it will just show the enum value
parameters = request.Parameters.ConvertAll(parameter => new
{
name = parameter.Name,
value = parameter.Value,
type = parameter.Type.ToString()
}),
// ToString() here to have the method as a nice string otherwise it will just show the enum value
method = request.Method.ToString(),
// This will generate the actual Uri used in the request
uri = _restClient.BuildUri(request),
};
var responseToLog = new
{
statusCode = response.StatusCode,
content = response.Content,
headers = response.Headers,
// The Uri that actually responded (could be different from the requestUri if a redirection occurred)
responseUri = response.ResponseUri,
errorMessage = response.ErrorMessage,
};
MethodLogger.SaveLogToFile(string.Format("Request completed in {0} ms", durationMs));
MethodLogger.SaveLogToFile(string.Format("Request: {0}", JsonConvert.SerializeObject(requestToLog).ToString().Replace("\\\"", "\"")));
MethodLogger.SaveLogToFile(string.Format("Response: {0}", JsonConvert.SerializeObject(responseToLog).ToString().Replace("\\\"", "\"")));
//Log4netLogger<string>.LogInfo(string.Format("Request completed in {0} ms", durationMs));
//Log4netLogger<string>.LogInfo(string.Format("Request: {0}", JsonConvert.SerializeObject(requestToLog).ToString().Replace("\\\"", "\"")));
//Log4netLogger<string>.LogInfo(string.Format("Response: {0}", JsonConvert.SerializeObject(responseToLog).ToString().Replace("\\\"", "\"")));
}
public static bool Prefix(CharacterInspectionScreen __instance, InputCommands.Id command)
{
switch (command)
{
// Handle 'E' for 'Export'
case InputCommands.Id.RotateCCW:
SaveCharacter();
break;
}
return(true);
void SaveCharacter()
{
var rulesetEntityService = ServiceRepository.GetService <IRulesetEntityService>();
using (var logger = new MethodLogger("CharacterInspectionScreen_HandleInput"))
{
var heroCharacter = __instance.InspectedCharacter.RulesetCharacterHero;
// record current name, etc..
var name = heroCharacter.Name;
var builtin = heroCharacter.BuiltIn;
var guid = heroCharacter.Guid;
// record current conditions, powers, spells and attunements
var conditions = heroCharacter.ConditionsByCategory.ToList();
var powers = heroCharacter.PowersUsedByMe.ToList();
var spells = heroCharacter.SpellsCastByMe.ToList();
var inventoryItems = new List <RulesetItem>();
heroCharacter.CharacterInventory.EnumerateAllItems(inventoryItems);
var attunedItems = inventoryItems.Select(i => new { Item = i, Name = i.AttunedToCharacter }).ToList();
// record item guids
var heroItemGuids = heroCharacter.Items.Select(i => new { Item = i, i.Guid }).ToList();
var inventoryItemGuids = inventoryItems.Select(i => new { Item = i, i.Guid }).ToList();
try
{
// TODO: update to use convention = name-nnn.sav
// TODO: then need UI to allow user to change name on export
// For now just add EX-
heroCharacter.Name = "EX-" + name;
heroCharacter.BuiltIn = false;
// remove active conditions (or filter out during serialization)
heroCharacter.ConditionsByCategory.Clear();
// remove spells and effects (or filter out during serialization)
heroCharacter.PowersUsedByMe.Clear();
heroCharacter.SpellsCastByMe.Clear();
// remove attunement, attuned items don't work well in the character inspection screen out of game
foreach (var item in attunedItems)
{
item.Item.AttunedToCharacter = string.Empty;
}
// clear guids
AccessTools.Field(heroCharacter.GetType(), "guid").SetValue(heroCharacter, 0UL);
foreach (var item in heroItemGuids)
{
AccessTools.Field(item.Item.GetType(), "guid").SetValue(item.Item, 0UL);
}
foreach (var item in inventoryItemGuids)
{
AccessTools.Field(item.Item.GetType(), "guid").SetValue(item.Item, 0UL);
}
ServiceRepository
.GetService <ICharacterPoolService>()
.SaveCharacter(heroCharacter, true);
}
finally
{
// TODO: check these things are really restored
// restore original values
heroCharacter.Name = name;
heroCharacter.BuiltIn = builtin;
// restore conditions
foreach (var kvp in conditions)
{
heroCharacter.ConditionsByCategory.Add(kvp.Key, kvp.Value);
}
// restore active spells and effects
heroCharacter.PowersUsedByMe.AddRange(powers);
heroCharacter.SpellsCastByMe.AddRange(spells);
// restore attunement
foreach (var item in attunedItems)
{
item.Item.AttunedToCharacter = item.Name;
}
// restore guids
AccessTools.Field(heroCharacter.GetType(), "guid").SetValue(heroCharacter, guid);
foreach (var item in heroItemGuids)
{
AccessTools.Field(item.Item.GetType(), "guid").SetValue(item.Item, item.Guid);
}
foreach (var item in inventoryItemGuids)
{
AccessTools.Field(item.Item.GetType(), "guid").SetValue(item.Item, item.Guid);
}
}
}
}
}
// ENTRY POINT IF YOU NEED SAFE DATABASE ACCESS
internal static void ModAfterDBReady()
{
using (var logger = new MethodLogger(nameof(ModAfterDBReady)))
{
ShowNames(DatabaseHelper.CharacterRaceDefinitions.Dwarf);
ShowNames(DatabaseHelper.CharacterRaceDefinitions.DwarfHill);
ShowNames(DatabaseHelper.CharacterRaceDefinitions.DwarfSnow);
ShowNames(DatabaseHelper.CharacterRaceDefinitions.Elf);
ShowNames(DatabaseHelper.CharacterRaceDefinitions.ElfHigh);
ShowNames(DatabaseHelper.CharacterRaceDefinitions.ElfSylvan);
ShowNames(DatabaseHelper.CharacterRaceDefinitions.HalfElf);
ShowNames(DatabaseHelper.CharacterRaceDefinitions.Halfling);
ShowNames(DatabaseHelper.CharacterRaceDefinitions.HalflingIsland);
ShowNames(DatabaseHelper.CharacterRaceDefinitions.HalflingMarsh);
ShowNames(DatabaseHelper.CharacterRaceDefinitions.Human);
void ShowNames(CharacterRaceDefinition race)
{
Log($"Race: {race.Name} -----------------------");
Log("Male");
race.RacePresentation.MaleNameOptions.ForEach(n => Log(n));
Log("Female");
race.RacePresentation.FemaleNameOptions.ForEach(n => Log(n));
}
//logger.Log("Getting dbs");
//var databases = (Dictionary<Type, object>)AccessTools
// .Field(typeof(DatabaseRepository), "databases")
// .GetValue(null);
//var path = Path.Combine(Directory.GetCurrentDirectory(), "Dump.text");
//logger.Log($"Folder={path}");
//File.WriteAllText(path, string.Join(Environment.NewLine, databases.Select(kvp => kvp.Key.FullName)));
//logger.Log("Dump complete");
/*
* var longsword = Helpers.GetWeapons().Where(w => w.Name.Contains("Longsword")).FirstOrDefault();
*
* if (longsword != null)
* {
* //longsword.DumpDefinition();
*
* //Log($"ACM: {longsword.ComputeAttackDamageEnhancement(true, null)}");
* //Log($"ACM: {longsword.ComputeAttackHitEnhancement(true, null)}");
*
* var defender = longsword.Clone("longsword defender", "17dee48b08434bc88b1b5297eddf5bab");
*
* foreach(var ef in defender.WeaponDescription.EffectDescription.EffectForms)
* {
* ef.DamageForm.DamageBonusTrends.Add(new RuleDefinitions.TrendInfo
* {
*
* });
* }
*
* //defender.DumpDefinition();
* }
*
* logger.Log("Just testing");
*/
//Helpers.DumpDefinition(DatabaseHelper.FeatureDefinitionDamageAffinitys.DamageAffinityBludgeoningResistance);
//Helpers.DumpMonstersWithFeatureDefinition(DatabaseHelper.FeatureDefinitionDamageAffinitys.DamageAffinityBludgeoningResistance, true);
//Helpers.DumpDefinition(DatabaseHelper.FeatureDefinitionDamageAffinitys.DamageAffinityColdResistance);
//Helpers.DumpMonstersWithFeatureDefinition(DatabaseHelper.FeatureDefinitionDamageAffinitys.DamageAffinityColdResistance, true);
//Helpers.DumpDefinition(DatabaseHelper.FeatureDefinitionDamageAffinitys.DamageAffinityContagionFleshRotForce);
//Helpers.DumpMonstersWithFeatureDefinition(DatabaseHelper.FeatureDefinitionDamageAffinitys.DamageAffinityContagionFleshRotForce, true);
//var frfClone = DatabaseHelper.FeatureDefinitionDamageAffinitys.DamageAffinityContagionFleshRotForce.Clone("MyFleshRotForce");
//Helpers.DumpDefinition(frfClone);
//var coldResistantMonsters = Helpers.GetMonstersWithFeatureDefinition(DatabaseHelper.FeatureDefinitionDamageAffinitys.DamageAffinityColdResistance, true);
//// TODO: create new ones / modify existing ones?
//DatabaseRepository.GetDatabase<FeatureDefinitionDamageAffinity>().Add(new FeatureDefinitionDamageAffinityEx
//{
// // TODO: populate - unfortunately some/most fields are read only -- need to use reflection or Harmony to set them
// // Name = "PsionicBlast"
// // etc
//});
// maybe this is something like what you want
//FeatureDefinitionDamageAffinity_ModulateSustainedDamage_ExtraProperties.Apply();
// Or this
//FeatureDefinitionDamageAffinity_ModulateSustainedDamage.Apply();
//var boots = DatabaseHelper.FeatureDefinitionMovementAffinitys.MovementAffinitySixLeaguesBoots;
//boots.SetSpeedAddBase(false);
//boots.SetBaseSpeedMultiplicativeModifier(1f);
//var tome = DatabaseHelper.ItemDefinitions.Tome_Of_Understanding;
//tome.SetField("isUsableDevice", true);
//var bread = DatabaseHelper.ItemDefinitions.DwarfBread;
//bread.SlotsWhereActive.Clear();
//bread.SlotsWhereActive.Add("UtilitySlot");
//bread.SlotTypes.Clear();
//bread.SlotTypes.AddRange(new string[] { "UtilitySlot", "ContainerSlot" });
//DatabaseRepository.GetDatabase<ItemDefinition>().ForEach(item => item.SetInDungeonEditor(true));
//DatabaseRepository.GetDatabase<MonsterDefinition>().ForEach(item => item.SetInDungeonEditor(true));
//var orcJav = DatabaseHelper.ItemDefinitions.Orc_Javelin;
//var orcJavForms = orcJav.WeaponDescription.EffectDescription.EffectForms;
//if (!orcJavForms.Any())
//{
// orcJavForms.Add(new EffectForm
// {
// DamageForm = new DamageForm
// {
// DiceNumber = 1,
// DieType = RuleDefinitions.DieType.D8,
// DamageType = "DamagePiercing"
// }
// });
//}
//orcJav.SetCanBeStacked(true);
//orcJav.SetStackSize(5);
//var ogreJav = DatabaseHelper.ItemDefinitions.Ogre_Javelin;
//var ogreJavForms = ogreJav.WeaponDescription.EffectDescription.EffectForms;
//if (!ogreJavForms.Any())
//{
// ogreJavForms.Add(new EffectForm
// {
// DamageForm = new DamageForm
// {
// DiceNumber = 1,
// DieType = RuleDefinitions.DieType.D10,
// DamageType = "DamagePiercing"
// }
// });
//}
//ogreJav.SetCanBeStacked(true);
//ogreJav.SetStackSize(5);
//DatabaseRepository.GetDatabase<ItemDefinition>().ForEach(item =>
//{
// if (!item.ForceEquip) // COTF is the only item that has to be equipped
// {
// item.SetForceEquipSlot(string.Empty);
// }
//});
//DatabaseHelper.LootPackDefinitions.
//var chest = DatabaseHelper.LootPackDefinitions.CONJURATION_TheSuperEgo_Mansion_OptionalQuest_LootQuest_Chest_01;
//var list = chest.ItemOccurencesList;
//foreach(var i in list)
//{
// Log($"{i.ItemDefinition.Name}, {i.DiceNumber}, {i.DiceType}");
//}
//list.Add(Create(DatabaseHelper.ItemDefinitions.Enchanted_Longsword_Dragonblade));
//list.Add(Create(DatabaseHelper.ItemDefinitions.MantleOfSpellResistance));
//list.Add(Create(DatabaseHelper.ItemDefinitions.CloakOfDisplacement));
//list.Add(Create(DatabaseHelper.ItemDefinitions.ShieldPlus3));
//list.Add(Create(DatabaseHelper.ItemDefinitions.ScrollGreaterInvisibility));
//list.Add(Create(DatabaseHelper.ItemDefinitions.ScrollGreaterInvisibility));
//list.Add(Create(DatabaseHelper.ItemDefinitions.ScrollGreaterInvisibility));
//foreach (var i in list)
//{
// Log($"{i.ItemDefinition.Name}, {i.DiceNumber}, {i.DiceType}");
//}
//ItemOccurence Create(ItemDefinition definition)
//{
// var item = new ItemOccurence
// {
// DiceNumber = 1,
// DiceType = RuleDefinitions.DieType.D1
// };
// item.SetItemDefinition(definition);
// return item;
//}
//try
//{
// var definition = new DivineHumanFeatureDefinitionCastSpellBuilder(
// DatabaseHelper.FeatureDefinitionCastSpells.CastSpellElfHigh, // clone original
// "DivineHumanSpells", // new name
// "4b61816bfbd04601b07ddba281ec7d5c") // new guid
// .AddToDB(); // add to database
// // assign
// DatabaseHelper.CharacterRaceDefinitions.Human.FeatureUnlocks.Add(new FeatureUnlockByLevel(definition, 1));
//}
//catch (Exception ex)
//{
// Error(ex);
// throw;
//}
}
}
