private void ValidateCharacterClassLevelUpBonus(MagusTtkCharacterClassDefinitionDto characterClassDefinition, MagusTtkCharacterClassLevelUpStats levelUpBonus)
{
if (levelUpBonus == null)
{
throw new ArgumentNullException(nameof(levelUpBonus));
}
if ((levelUpBonus.FreeHm < 1) || (levelUpBonus.FreeHm > 3))
{
throw new ArgumentException($"FreeHm value '{levelUpBonus.FreeHm}' in level up bonus of character class '{characterClassDefinition.Code}' is out of range. Valid values are 1-3.");
}
if ((levelUpBonus.TE < 0) || (levelUpBonus.TE > 3))
{
throw new ArgumentException($"TE value '{levelUpBonus.TE}' in level up bonus of character class '{characterClassDefinition.Code}' is out of range. Valid values are 0-3.");
}
if ((levelUpBonus.VE < 0) || (levelUpBonus.VE > 3))
{
throw new ArgumentException($"VE value '{levelUpBonus.VE}' in level up bonus of character class '{characterClassDefinition.Code}' is out of range. Valid values are 0-3.");
}
if ((levelUpBonus.CE < 0) || (levelUpBonus.CE > 3))
{
throw new ArgumentException($"CE value '{levelUpBonus.CE}' in level up bonus of character class '{characterClassDefinition.Code}' is out of range. Valid values are 0-3.");
}
if ((levelUpBonus.KE < 0) || (levelUpBonus.KE > 3))
{
throw new ArgumentException($"KE value '{levelUpBonus.KE}' in level up bonus of character class '{characterClassDefinition.Code}' is out of range. Valid values are 0-3.");
}
if ((levelUpBonus.Fp < 1) || (levelUpBonus.Fp > 3))
{
throw new ArgumentException($"Fp value '{levelUpBonus.Fp}' in level up bonus of character class '{characterClassDefinition.Code}' is out of range. Valid values are 1-3.");
}
if ((levelUpBonus.Kp < 2) || (levelUpBonus.Kp > 10))
{
throw new ArgumentException($"Kp value '{levelUpBonus.Kp}' in level up bonus of character class '{characterClassDefinition.Code}' is out of range. Valid values are 2-10.");
}
if ((levelUpBonus.Pp < 0) || (levelUpBonus.Pp > 5))
{
throw new ArgumentException($"Pp value '{levelUpBonus.Pp}' in level up bonus of character class '{characterClassDefinition.Code}' is out of range. Valid values are 0-5.");
}
if ((levelUpBonus.Mp < 0) || (levelUpBonus.Mp > 5))
{
throw new ArgumentException($"Mp value '{levelUpBonus.Mp}' in level up bonus of character class '{characterClassDefinition.Code}' is out of range. Valid values are 0-5.");
}
if (levelUpBonus.Sp != 15)
{
throw new ArgumentException($"Sp value '{levelUpBonus.Sp}' in level up bonus of character class '{characterClassDefinition.Code}' must equal to 15.");
}
var sumSpCost = levelUpBonus.CalculateSpCostSum();
if (sumSpCost != 45)
{
throw new ArgumentException($"Sum Sp cost '{sumSpCost}' of level up bonus of character class '{characterClassDefinition.Code}' must equal to 45.");
}
}
private async Task ValidateCharacterClassAbilities(MagusTtkCharacterClassDefinitionDto characterClassDefinition, Dictionary <string, int> classAbilities, IReadOnlyRepository <AbilityDefinition> abilityRepo, CancellationToken cancellationToken = default)
{
if (characterClassDefinition == null)
{
throw new ArgumentNullException(nameof(characterClassDefinition));
}
if (classAbilities == null)
{
throw new ArgumentNullException(nameof(classAbilities));
}
if (abilityRepo == null)
{
throw new ArgumentNullException(nameof(abilityRepo));
}
int expectedAbilityCount = await abilityRepo.Count(null, cancellationToken);
// ha nem a várt darabszámú tulajdonság alap érték lenne megadva
if (classAbilities.Count != expectedAbilityCount)
{
throw new ArgumentException($"Character class definition '{characterClassDefinition.Code}' has {classAbilities.Count} ability base value definitions, but should have {expectedAbilityCount}.");
}
int abilityValueSum = 0;
// leellenőrizzük, h minden tulajdonságra legyen megadva a kaszt specifikus alap érték
foreach (var ability in await abilityRepo.All(null, cancellationToken))
{
if (!classAbilities.TryGetValue(ability.Code, out var classAbilityBaseValue))
{
throw new ArgumentException($"Ability base of '{ability.Code}' is missing from character class definition '{characterClassDefinition.Code}'.");
}
if ((classAbilityBaseValue < 6) || (classAbilityBaseValue > 10))
{
throw new ArgumentOutOfRangeException($"Value '{classAbilityBaseValue}' of class ability '{ability.Code}' in character class definition '{characterClassDefinition.Code}' is out of range. Valid values are > 5 and < 11.");
}
abilityValueSum += classAbilityBaseValue;
}
// leellenőrizzük, hogy a class definícióban tényleg 80 tulajdonság pontot osztottak-e szét
if (abilityValueSum != 80)
{
throw new ArgumentOutOfRangeException($"Sum of class ability base values '{abilityValueSum}' in character class definition '{characterClassDefinition.Code}' must equal to 80.");
}
}
private async Task <MagusTtkCharacterSkills> GetValidatedCharacterClassSkills(MagusTtkCharacterClassDefinitionDto characterClassDefinition, SkillLevelDto[] classSkills, IReadOnlyRepository <MagusTtkSkillDefinition> skillDefinitionRepo, CancellationToken cancellationToken = default)
{
if (characterClassDefinition == null)
{
throw new ArgumentNullException(nameof(characterClassDefinition));
}
if (classSkills == null)
{
throw new ArgumentNullException(nameof(classSkills));
}
if (skillDefinitionRepo == null)
{
throw new ArgumentNullException(nameof(skillDefinitionRepo));
}
//HashSet<string> codeHashes = new HashSet<string>();
List <SkillLevel> skillLevelList = new List <SkillLevel>(classSkills.Length);
foreach (var classSkill in classSkills)
{
// karakter kaszt definíciónál engedélyezett, h egy specializációt támogató képzettség (mintpl. Fegyverhasználat, vagy Nyelvisemeret, ...) többször is hozzá legyen adva
//// ha nem tudja hozzáadni, akkor már volt ilyen kóddal
//if (!codeHashes.Add(kvp.Code))
// throw new ArgumentException($"Skill '{kvp.Key}' of character class definition '{characterClassDefinition.Code}' is a duplicate.");
// ha nem létezik ilyen kódú képzettség
if (!await skillDefinitionRepo.TryGetByCode(classSkill.Code, out var skillDefinition, cancellationToken))
{
// lehet, hogy specializált képzettség, úgyhogy megpróbáljuk aszerint parse-olni
int firstIndex = classSkill.Code.IndexOf('(');
if (firstIndex < 0)
{
throw new ArgumentException($"Skill '{classSkill.Code}' in character class definition '{characterClassDefinition.Code}' is unknown.");
}
var key = classSkill.Code.Substring(0, firstIndex).Trim();
var spec = classSkill.Code.Substring(firstIndex + 1).Trim().TrimEnd(')');
if (!await skillDefinitionRepo.TryGetByCode(key, out skillDefinition, cancellationToken))
{
throw new ArgumentException($"Skill '{key}' in character class definition '{characterClassDefinition.Code}' is unknown.");
}
if (!skillDefinition.RequiresSpecialization)
{
throw new ArgumentException($"Skill '{key}' was found with specialization '{spec}' in character class definition '{characterClassDefinition.Code}', but skill does not require specialization according to its definition.");
}
// if the specialization is not valid
if (!skillDefinition.SupportsUniqueSpecialization && !skillDefinition.Specializations.Contains(spec))
{
throw new ArgumentException($"Specialization '{spec}' of skill '{key}' in character class definition '{characterClassDefinition.Code}' is invalid.");
}
classSkill.Specialization = spec;
}
// ha van specializáció megadva
if (!string.IsNullOrWhiteSpace(classSkill.Specialization))
{
// de a skill nem specializálható
if (!skillDefinition.RequiresSpecialization)
{
throw new ArgumentException($"Skill '{classSkill.Code}' was found with specialization '{classSkill.Specialization}' in character class definition '{characterClassDefinition.Code}', but skill does not require specialization according to its definition.");
}
// if the specialization is not valid
if (!skillDefinition.SupportsUniqueSpecialization && !skillDefinition.Specializations.Contains(classSkill.Specialization))
{
throw new ArgumentException($"Specialization '{classSkill.Specialization}' of skill '{classSkill.Code}' in character class definition '{characterClassDefinition.Code}' is invalid.");
}
}
//if (!Enum.TryParse<MagusTtkCharacterSkillLevelsEnum>(classSkill.Level, out var enumValue))
// throw new ArgumentException($"Could not parse '{classSkill.Level}' as a {nameof(MagusTtkCharacterSkillLevelsEnum)} value in skill '{classSkill.Code}' in character class definition '{characterClassDefinition.Code}'.");
skillLevelList.Add(new SkillLevel()
{
Definition = skillDefinition,
Level = classSkill.Level,
Specialization = classSkill.Specialization
});
}
var skills = new MagusTtkCharacterSkills();
skills.Initialize(skillLevelList);
return(skills);
}
private async Task <List <TalentDefinition> > GetValidatedCharacterClassTalents(MagusTtkCharacterClassDefinitionDto characterClassDefinition, List <TalentDefinition> classTalents, IReadOnlyRepository <TalentDefinition> talentDefinitionRepo, CancellationToken cancellationToken = default)
{
if (characterClassDefinition == null)
{
throw new ArgumentNullException(nameof(characterClassDefinition));
}
if (classTalents == null)
{
throw new ArgumentNullException(nameof(classTalents));
}
if (talentDefinitionRepo == null)
{
throw new ArgumentNullException(nameof(talentDefinitionRepo));
}
// ha nem a várt darabszámú adottság lenne megadva
if (classTalents.Count != 4)
{
throw new ArgumentException($"Character class definition '{characterClassDefinition.Code}' has {classTalents.Count} talents, but should have 4.");
}
HashSet <string> codeHashes = new HashSet <string>();
List <TalentDefinition> talentDefinitionList = new List <TalentDefinition>(classTalents.Count);
foreach (var classTalent in classTalents)
{
// ha nem tudja hozzáadni, akkor már volt ilyen kóddal
if (!codeHashes.Add(classTalent.Code))
{
throw new ArgumentException($"Talent '{classTalent.Code}' of character class definition '{characterClassDefinition.Code}' is a duplicate.");
}
// ha nem létezik ilyen kódú adottság
if (!await talentDefinitionRepo.TryGetByCode(classTalent.Code, out var talentDefinition, cancellationToken))
{
throw new ArgumentException($"Talent '{classTalent.Code}' in character class definition '{characterClassDefinition.Code}' is unknown.");
}
talentDefinitionList.Add(talentDefinition);
}
return(talentDefinitionList);
}
