private static void AddStatToDict(Dictionary <SkillStatType, float> bonusDict,
SkillStatType targetStatType,
PersonRuleLevel level,
PersonRuleDirection direction)
{
bonusDict.TryGetValue(targetStatType, out var value);
var q = level switch
{
PersonRuleLevel.Lesser => 0.1f,
PersonRuleLevel.Normal => 0.3f,
PersonRuleLevel.Grand => 0.5f,
PersonRuleLevel.None => throw new NotSupportedException(),
PersonRuleLevel.Absolute => throw new NotSupportedException(),
_ => throw new NotSupportedException($"Неизветный уровень угрозы выживания {level}.")
};
switch (direction)
{
case PersonRuleDirection.Positive:
// Бонус изначально расчитывается, как положительный. Ничего не делаем.
break;
case PersonRuleDirection.Negative:
q *= -1;
break;
default:
throw new NotSupportedException($"Неизветный уровень угрозы выживания {direction}.");
}
value += q;
bonusDict[targetStatType] = value;
}
private void ProcessPositiveRule(ConsumeCommonRuleType type, PersonRuleLevel ruleLevel)
{
switch (type)
{
case ConsumeCommonRuleType.Satiety:
RestoreStat(SurvivalStatType.Satiety, ruleLevel);
break;
case ConsumeCommonRuleType.Thirst:
RestoreStat(SurvivalStatType.Hydration, ruleLevel);
break;
case ConsumeCommonRuleType.Health:
RestoreStat(SurvivalStatType.Health, ruleLevel);
break;
case ConsumeCommonRuleType.Intoxication:
RiseStat(SurvivalStatType.Intoxication, ruleLevel);
break;
case ConsumeCommonRuleType.Undefined:
default:
throw new ArgumentOutOfRangeException(nameof(type), $"Значение {type} не поддерживается.");
}
}
private void BonusToHealth(PersonRuleLevel level, PersonRuleDirection direction)
{
var hpStat = Survival.Stats.SingleOrDefault(x => x.Type == SurvivalStatType.Health);
if (hpStat != null)
{
var bonus = 0;
switch (level)
{
case PersonRuleLevel.Lesser:
bonus = 1;
break;
case PersonRuleLevel.Normal:
bonus = 3;
break;
case PersonRuleLevel.Grand:
bonus = 5;
break;
case PersonRuleLevel.Absolute:
bonus = 10;
break;
}
if (direction == PersonRuleDirection.Negative)
{
bonus *= -1;
}
hpStat.ChangeStatRange(hpStat.Range.Min, hpStat.Range.Max + bonus);
}
}
/// <summary>
/// Помещает в список бонус на ХП.
/// </summary>
/// <param name="level"> Уровень бонуса. </param>
/// <param name="direction"> Направление бонуса. </param>
/// <param name="bonuses">
/// Аккумулирующий список бонусов.
/// Отмечен ref, чтобы показать, что изменяется внутри метода.
/// </param>
private void BonusToHealth(PersonRuleLevel level, PersonRuleDirection direction,
ref List <SurvivalStatBonus> bonuses)
{
const SurvivalStatType HP_STAT_TYPE = SurvivalStatType.Health;
var hpStat = Stats.SingleOrDefault(x => x.Type == HP_STAT_TYPE);
if (hpStat != null)
{
var bonus = 0;
bonus = GetBonusByLevel(level);
if (direction == PersonRuleDirection.Negative)
{
bonus *= -1;
}
var currentBonus = bonuses.SingleOrDefault(x => x.SurvivalStatType == HP_STAT_TYPE);
if (currentBonus == null)
{
currentBonus = new SurvivalStatBonus(HP_STAT_TYPE);
bonuses.Add(currentBonus);
}
currentBonus.ValueBonus += bonus;
}
}
/// <summary>
/// Расчёт нового модификатора эффективности в зависимости от правила.
/// </summary>
/// <param name="currentModifierValue"> Текущие значение модификатора. </param>
/// <param name="level"> Уровень правила. </param>
/// <returns> Возвращает новое значение модификатора эффективности. </returns>
public static int CalcEfficientByRuleLevel(int currentModifierValue, PersonRuleLevel level)
{
switch (level)
{
case PersonRuleLevel.Lesser:
currentModifierValue++;
break;
case PersonRuleLevel.Normal:
currentModifierValue += 3;
break;
case PersonRuleLevel.Grand:
currentModifierValue += 5;
break;
case PersonRuleLevel.Absolute:
currentModifierValue += 10;
break;
default:
throw new NotSupportedException("Этот уровень правила не обрабатывается.");
}
return(currentModifierValue);
}
public PersonRule(EquipCommonRuleType type, PersonRuleLevel level,
PersonRuleDirection direction = PersonRuleDirection.Positive)
{
Type = type;
Level = level;
Direction = direction;
}
private void RiseIntoxicationLevel(PersonRuleLevel level)
{
var survivalModule = Person.GetModuleSafe <ISurvivalModule>();
if (survivalModule is null)
{
return;
}
switch (level)
{
case PersonRuleLevel.Lesser:
survivalModule.RestoreStat(SurvivalStatType.Intoxication,
PropMetrics.INTOXICATION_RISE_LESSER_VALUE + 1);
break;
case PersonRuleLevel.Normal:
survivalModule.RestoreStat(SurvivalStatType.Intoxication,
PropMetrics.INTOXICATION_RISE_NORMAL_VALUE + 1);
break;
case PersonRuleLevel.Grand:
survivalModule.RestoreStat(SurvivalStatType.Intoxication,
PropMetrics.INTOXICATION_RISE_GRAND_VALUE + 1);
break;
default:
throw new InvalidOperationException($"Неизвестный уровень влияния правила {level}.");
}
}
private void DecreaseSurvivalStatInner(SurvivalStatType statType, PersonRuleLevel level)
{
switch (level)
{
case PersonRuleLevel.Lesser:
Person.Survival.DecreaseStat(statType,
PropMetrics.SurvivalLesserRestoreValue - 1);
break;
case PersonRuleLevel.Normal:
Person.Survival.DecreaseStat(statType,
PropMetrics.SurvivalNormalRestoreValue - 1);
break;
case PersonRuleLevel.Grand:
Person.Survival.DecreaseStat(statType,
PropMetrics.SurvivalGrandRestoreValue - 1);
break;
case PersonRuleLevel.None:
throw new NotSupportedException();
case PersonRuleLevel.Absolute:
throw new NotSupportedException();
default:
throw new InvalidOperationException($"Неизвестный уровень влияния правила {level}.");
}
}
private static int GetLevelDiff(PersonRuleLevel level, PersonRuleLevel baseLevel)
{
var a = GetArmorModifierByLevel(level);
var b = GetArmorModifierByLevel(baseLevel);
return(a - b);
}
private void RestoreHp(PersonRuleLevel level)
{
var survivalModule = Person.GetModuleSafe <ISurvivalModule>();
if (survivalModule is null)
{
return;
}
switch (level)
{
case PersonRuleLevel.Lesser:
survivalModule.RestoreStat(SurvivalStatType.Health, PropMetrics.HpLesserRestoreValue);
break;
case PersonRuleLevel.Normal:
survivalModule.RestoreStat(SurvivalStatType.Health, PropMetrics.HpNormalRestoreValue);
break;
case PersonRuleLevel.Grand:
survivalModule.RestoreStat(SurvivalStatType.Health, PropMetrics.HpGrandRestoreValue);
break;
default:
throw new InvalidOperationException($"Неизвестный уровень влияния правила {level}.");
}
}
private static int GetBonusByLevel(PersonRuleLevel level)
{
return(level switch
{
PersonRuleLevel.Lesser => 1,
PersonRuleLevel.Normal => 3,
PersonRuleLevel.Grand => 5,
PersonRuleLevel.Absolute => 10,
PersonRuleLevel.None => throw new InvalidOperationException("Unknown rule level."),
_ => throw new InvalidOperationException($"The rule level {level} is not supported.")
});
/// <summary>
/// Рассчитывает минимальное значение броска D6, необходимого для пробития указанной обороны.
/// </summary>
/// <param name="level"> Уровень обороны, для которой вычисляется нижный порог броска D6. </param>
/// <returns> Минимальный погод броска D6. </returns>
private static int CalcSuccessToHitRollInner(PersonRuleLevel level)
{
return(level switch
{
PersonRuleLevel.None => 2,
PersonRuleLevel.Lesser => 4,
PersonRuleLevel.Normal => 5,
PersonRuleLevel.Grand => 6,
PersonRuleLevel.Absolute => 8,
_ => throw new ArgumentException($"Неизвестное значение {level}.", nameof(level))
});
private static int GetArmorModifierByLevel(PersonRuleLevel level)
{
return(level switch
{
PersonRuleLevel.None => 0,
PersonRuleLevel.Lesser => 1,
PersonRuleLevel.Normal => 2,
PersonRuleLevel.Grand => 3,
PersonRuleLevel.Absolute => 5,
_ => throw new ArgumentException($"Неизвестное значение уровня {level}.", nameof(level))
});
public void CalcEfficientByRuleLevel_AllKnownLevels_NotThrowException(int currentModifier,
PersonRuleLevel level)
{
// ACT
Action act = () =>
{
var _ = RuleCalculations.CalcEfficientByRuleLevel(currentModifier, level);
};
// ASSERT
act.Should().NotThrow <NotSupportedException>();
}
public ConsumeCommonRule(ConsumeCommonRuleType type,
PersonRuleLevel level,
PersonRuleDirection direction = PersonRuleDirection.Positive)
{
Type = type;
Level = level;
Direction = direction;
if (Direction == 0)
{
Direction = PersonRuleDirection.Positive;
}
}
/// <summary>
/// Помещает в список бонус на ХП.
/// </summary>
/// <param name="level"> Уровень бонуса. </param>
/// <param name="direction"> Направление бонуса. </param>
/// <param name="bonuses">
/// Аккумулирующий список бонусов.
/// Отмечен ref, чтобы показать, что изменяется внутри метода.
/// </param>
private void BonusToHealth(PersonRuleLevel level, PersonRuleDirection direction,
ref List <SurvivalStatBonus> bonuses)
{
const SurvivalStatType HP_STAT_TYPE = SurvivalStatType.Health;
var hpStat = Stats.SingleOrDefault(x => x.Type == HP_STAT_TYPE);
if (hpStat != null)
{
var bonus = 0;
switch (level)
{
case PersonRuleLevel.Lesser:
bonus = 1;
break;
case PersonRuleLevel.Normal:
bonus = 3;
break;
case PersonRuleLevel.Grand:
bonus = 5;
break;
case PersonRuleLevel.Absolute:
bonus = 10;
break;
case PersonRuleLevel.None:
throw new InvalidOperationException("Неопределённое правило.");
default:
throw new InvalidOperationException($"Правило {level} не обрабатывается.");
}
if (direction == PersonRuleDirection.Negative)
{
bonus *= -1;
}
var currentBonus = bonuses.SingleOrDefault(x => x.SurvivalStatType == HP_STAT_TYPE);
if (currentBonus == null)
{
currentBonus = new SurvivalStatBonus(HP_STAT_TYPE);
bonuses.Add(currentBonus);
}
currentBonus.ValueBonus += bonus;
}
}
private void DecreaseStat(SurvivalStatType statType, PersonRuleLevel level)
{
switch (statType)
{
case SurvivalStatType.Satiety:
case SurvivalStatType.Hydration:
case SurvivalStatType.Intoxication:
DecreaseSurvivalStatInner(statType, level);
break;
case SurvivalStatType.Health:
DecreaseHp(level);
break;
}
}
private void DecreaseStat(SurvivalStatType statType, PersonRuleLevel level)
{
switch (statType)
{
case SurvivalStatType.Satiety:
DecreaseSurvivalStatInner(SurvivalStatType.Satiety, level);
break;
case SurvivalStatType.Water:
DecreaseSurvivalStatInner(SurvivalStatType.Water, level);
break;
case SurvivalStatType.Health:
DecreaseHp(level);
break;
}
}
private static void AddStatToDict(Dictionary <CombatStatType, float> bonusDict,
CombatStatType targetStatType,
PersonRuleLevel level,
PersonRuleDirection direction)
{
bonusDict.TryGetValue(targetStatType, out float value);
float q;
switch (level)
{
case PersonRuleLevel.Lesser:
q = 0.1f;
break;
case PersonRuleLevel.Normal:
q = 0.3f;
break;
case PersonRuleLevel.Grand:
q = 0.5f;
break;
default:
throw new NotSupportedException($"Неизветный уровень угрозы выживания {level}.");
}
switch (direction)
{
case PersonRuleDirection.Positive:
// Бонус изначально расчитывается, как положительный. Ничего не делаем.
break;
case PersonRuleDirection.Negative:
q *= -1;
break;
default:
throw new NotSupportedException($"Неизветный уровень угрозы выживания {direction}.");
}
value += q;
bonusDict[targetStatType] = value;
}
private static void BonusToDownPass(
SurvivalStatType statType,
PersonRuleLevel level,
PersonRuleDirection direction,
ref List <SurvivalStatBonus> bonuses)
{
var currentBonusValue = 0;
var directionQuaff = direction == PersonRuleDirection.Negative ? -1 : 1;
switch (level)
{
case PersonRuleLevel.Lesser:
currentBonusValue = 1 * directionQuaff;
break;
case PersonRuleLevel.Normal:
currentBonusValue = 2 * directionQuaff;
break;
case PersonRuleLevel.Grand:
currentBonusValue = 5 * directionQuaff;
break;
case PersonRuleLevel.Absolute:
currentBonusValue = 10 * directionQuaff;
break;
case PersonRuleLevel.None:
Debug.Fail("Предположительно, это ошибка.");
break;
default:
Debug.Fail("Предположительно, это ошибка.");
break;
}
var currentBonus = new SurvivalStatBonus(statType)
{
DownPassBonus = currentBonusValue
};
bonuses.Add(currentBonus);
}
/// <summary>
/// Помещает в список бонус на ХП.
/// </summary>
/// <param name="level"> Уровень бонуса. </param>
/// <param name="direction"> Направление бонуса. </param>
/// <param name="bonuses"> Аккумулирующий список бонусов.
/// Отмечен ref, чтобы показать, что изменяется внутри метода. </param>
private void BonusToHealth(PersonRuleLevel level, PersonRuleDirection direction,
ref List <SurvivalStatBonus> bonuses)
{
const SurvivalStatType hpStatType = SurvivalStatType.Health;
var hpStat = Survival.Stats.SingleOrDefault(x => x.Type == hpStatType);
if (hpStat != null)
{
var bonus = 0;
switch (level)
{
case PersonRuleLevel.Lesser:
bonus = 1;
break;
case PersonRuleLevel.Normal:
bonus = 3;
break;
case PersonRuleLevel.Grand:
bonus = 5;
break;
case PersonRuleLevel.Absolute:
bonus = 10;
break;
}
if (direction == PersonRuleDirection.Negative)
{
bonus *= -1;
}
var currentBonus = bonuses.SingleOrDefault(x => x.SurvivalStatType == hpStatType);
if (currentBonus == null)
{
currentBonus = new SurvivalStatBonus(hpStatType);
bonuses.Add(currentBonus);
}
currentBonus.ValueBonus += bonus;
}
}
private void RiseIntoxicationLevel(PersonRuleLevel level)
{
switch (level)
{
case PersonRuleLevel.Lesser:
Person.Survival?.RestoreStat(SurvivalStatType.Intoxication,
PropMetrics.INTOXICATION_RISE_LESSER_VALUE + 1);
break;
case PersonRuleLevel.Normal:
Person.Survival?.RestoreStat(SurvivalStatType.Intoxication,
PropMetrics.INTOXICATION_RISE_NORMAL_VALUE + 1);
break;
case PersonRuleLevel.Grand:
Person.Survival?.RestoreStat(SurvivalStatType.Intoxication,
PropMetrics.INTOXICATION_RISE_GRAND_VALUE + 1);
break;
default:
throw new InvalidOperationException($"Неизвестный уровень влияния правила {level}.");
}
}
private static int GetArmorModifierByLevel(PersonRuleLevel level)
{
switch (level)
{
case PersonRuleLevel.None:
return(0);
case PersonRuleLevel.Lesser:
return(1);
case PersonRuleLevel.Normal:
return(2);
case PersonRuleLevel.Grand:
return(3);
case PersonRuleLevel.Absolute:
return(5);
default:
throw new ArgumentException($"Неизвестное значение уровня {level}.", nameof(level));
}
}
/// <summary>
/// Рассчитывает минимальное значение броска D6, необходимого для пробития указанной обороны.
/// </summary>
/// <param name="level"> Уровень обороны, для которой вычисляется нижный порог броска D6. </param>
/// <returns> Минимальный погод броска D6. </returns>
private static int CalcSuccessToHitRollInner(PersonRuleLevel level)
{
switch (level)
{
case PersonRuleLevel.None:
return(2);
case PersonRuleLevel.Lesser:
return(4);
case PersonRuleLevel.Normal:
return(5);
case PersonRuleLevel.Grand:
return(6);
case PersonRuleLevel.Absolute:
return(8);
default:
throw new ArgumentException($"Неизвестное значение {level}.", nameof(level));
}
}
private void DecreaseHp(PersonRuleLevel level)
{
switch (level)
{
case PersonRuleLevel.Lesser:
Person.Survival.DecreaseStat(SurvivalStatType.Health,
PropMetrics.HpLesserRestoreValue);
break;
case PersonRuleLevel.Normal:
Person.Survival.DecreaseStat(SurvivalStatType.Health,
PropMetrics.HpNormalRestoreValue);
break;
case PersonRuleLevel.Grand:
Person.Survival.DecreaseStat(SurvivalStatType.Health,
PropMetrics.HpGrandRestoreValue);
break;
default:
throw new InvalidOperationException($"Неизвестный уровень влияния правила {level}.");
}
}
public PersonDefenceItem(DefenceType type, PersonRuleLevel level)
{
Type = type;
Level = level;
}
public MonsterDefenceItemSubScheme(DefenceType type, PersonRuleLevel level)
{
Type = type;
Level = level;
}
public EffectRule(RollEffectType?rollType, PersonRuleLevel level)
{
RollType = rollType;
Level = level;
}
public PersonArmorItem(ImpactType impact, PersonRuleLevel absorbtionLevel, int armorRank)
{
Impact = impact;
AbsorbtionLevel = absorbtionLevel;
ArmorRank = armorRank;
}
/// <summary>
/// Метод введён специально для повышения уровня интоксикации.
/// Так как глупо выглядит ResToreStat для повышения интоксикации.
/// Просто семантически более удобная обёртка.
/// </summary>
/// <param name="statType"> Характеристика, повышаемая методом. </param>
/// <param name="level"> Уровень увеличения. </param>
private void RiseStat(SurvivalStatType statType, PersonRuleLevel level)
{
RestoreStat(statType, level);
}
