public void TakeDamage(double value)
{
if (value <= 0d)
{
return;
}
var evaChance = _stats.GetEVAChance(CurrentLevel);
RollingEvasion(this, ref evaChance);
var attackEvaded = RHelper.RollPercentage((int)evaChance);
if (attackEvaded && _stats.EVAType == EVAType.Dodge)
{
AttackDodged(this, value);
DodgedAttack = true;
return;
}
BlockedDamage = attackEvaded;
var reduction = attackEvaded ? 2d : 1d;
if (attackEvaded)
{
AttackBlocked(this, ref value, ref reduction);
}
value /= reduction;
TakeTrueDamage(value);
}
public void GeneratePack(int x, int y)
{
var pack = new MobPack(_model.Map)
{
Position = new Point(x, y)
};
var enemyCount = _model.Party.FrontRow.Count - RHelper.Roll(0, 1);
if (enemyCount == 0)
{
++enemyCount;
}
var xpReward = 0;
// 25% Chance to get a group of enemies with the same race
var raceGroup = RHelper.RollPercentage(25) ? _model.RaceFactory.GetRandomTemplate() : null;
for (var i = 0; i < enemyCount; ++i)
{
var strengthRoll = RHelper.Roll(0, 99);
var strength = strengthRoll < 60
? MobPackStrength.Equal
: strengthRoll < 90
? MobPackStrength.Stronger
: strengthRoll < 98
? MobPackStrength.Challenging
: MobPackStrength.Elite;
xpReward += GenerateEnemy(pack, raceGroup, strength);
}
pack.XPReward = xpReward;
switch (pack.Strength)
{
case MobPackStrength.Equal:
pack.SightRadius = 25;
break;
case MobPackStrength.Stronger:
pack.SightRadius = 20;
break;
case MobPackStrength.Challenging:
pack.SightRadius = 10;
break;
case MobPackStrength.Elite:
pack.SightRadius = 5;
break;
}
_packs.Add(pack);
}
public Digger(int row, int col, int digGoal, IRMap map)
{
_row = row;
_col = col;
_digGoal = digGoal;
_map = map;
_digged = 0;
_darkDigger = RHelper.RollPercentage(25);
_doubleCombatBonus = RHelper.RollPercentage(10);
_combatBonus = (ulong)RHelper.Roll(0, 23);
}
public static IStats GetRandomBaseStats()
{
var stats = new Stats();
var hp = stats[Stat.HP];
hp[StatType.Base] = RHelper.Roll(75, 200);
hp[StatType.Growth] = RHelper.Roll(5, 25);
stats[BaseStat.MP][StatType.Base] = 200d;
for (var stat = Stat.AD; stat <= Stat.CHA; ++stat)
{
var s = stats[stat];
s[StatType.Base] = RHelper.Roll(20, 80);
s[StatType.Growth] = RHelper.Roll(1, 20);
}
stats.EVAType = RHelper.RollPercentage(10) ? EVAType.Block : EVAType.Dodge;
if (stats.EVAType == EVAType.Dodge)
{
stats[BaseStat.EVA][StatType.Base] = 2d;
stats[BaseStat.EVA][StatType.Growth] = RHelper.Roll(1, 8);
}
else
{
stats[BaseStat.EVA][StatType.Base] = RHelper.Roll(20, 80);
stats[BaseStat.EVA][StatType.Growth] = RHelper.Roll(0, 1);
}
var spd = stats[BaseStat.SPD];
spd[StatType.Base] = 100d;
spd[StatType.Growth] = RHelper.Roll(5, 10);
spd[StatType.Multiplier] = 0.0255d;
for (var stat = Stat.FIR; stat <= Stat.LGT; ++stat)
{
stats[stat][StatType.Base] = RHelper.Roll(50, 200);
}
for (var stat = Stat.PSN; stat <= Stat.SIL; ++stat)
{
stats[stat][StatType.Base] = RHelper.Roll(0, 30);
}
stats.XPMultiplier = RHelper.Roll(80, 120) / 100d;
return(stats);
}
public override void SpellEffect(ICharacter caster, ICharacter target)
{
var damage = (3.75 * aAD * (aARC / 100) - 1.25 * dDEF) * (100 / dARC);
DealDamage(damage);
for (var i = Stat.HP; i <= Stat.SIL; ++i)
{
var stat = target.Stats[i];
var battleMod = stat[StatType.BattleMod];
if (battleMod > 1 && RHelper.RollPercentage(40))
{
BuffStat(caster, i, battleMod - 1);
stat[StatType.BattleMod] = 1;
}
}
}
public void AddEnemy(ICharacter enemy, MobPackStrength strength = MobPackStrength.Stronger,
double convertBonus = 1.2)
{
_enemies.Add(enemy);
SetConvertBonus(enemy, convertBonus);
SetStrength(enemy, strength);
var coreCount = RHelper.RollPercentage(10) ? 2 : 1;
if (RHelper.RollPercentage(20))
{
IntactCoreCount += coreCount;
}
else
{
UnstableCoreCount += coreCount;
}
}
protected override void OnAttacking(ICharacter attacker, ICharacter target, ISpell spell, ref double damage, ref double modifier)
{
var drunkCounter = GetVar(attacker, "drunk_turnCounter") - 1;
SetVar(attacker, "drunk_turnCounter", drunkCounter);
if (attacker.Race == "Beerman")
{
damage *= 1.25d;
}
else if (RHelper.RollPercentage(25))
{
damage = 0d;
}
if (drunkCounter > 0)
{
return;
}
RemoveFrom(attacker);
}
public bool Generate(int row, int col, Direction direction)
{
Width = RHelper.Roll(MinWidth, MaxWidth);
Height = RHelper.Roll(MinHeight, MaxHeight);
if (!CheckAvailableSpace(row, col, direction))
{
return(false);
}
GenerateImpl(row, col, direction);
if (!_spawningEnabled || !RHelper.RollPercentage(_spawnChance))
{
return(true);
}
var topRow = row;
var leftCol = col;
GetTopLeftCorner(ref topRow, ref leftCol, direction);
var maxRow = topRow + Height;
var maxCol = leftCol + Width;
int spawnRow;
int spawnCol;
do
{
spawnRow = RHelper.Roll(topRow, maxRow);
spawnCol = RHelper.Roll(leftCol, maxCol);
} while (!Map[spawnRow, spawnCol].Is(RCell.Walkable));
_packManager.GeneratePack(spawnCol, spawnRow);
return(true);
}
public bool TryToApplyDebuf(DebuffResistance type, int successChance)
{
var resistance = GetTotalStat(type) * 3;
return(RHelper.RollPercentage((int)(successChance - resistance)));
}
protected bool RollPercentage(double chance)
{
return(RHelper.RollPercentage((int)chance));
}