public static StatHolder getRandomStatsByLevel(IStatHolder statsToFill, byte level)
{
var statsToAccrue = 0;
for (byte i = 0; i++ <= level;)
{
statsToAccrue += RegionConstants.GetConstants(ConstantType.STAT_POINTS_PER_LEVEL)[i];
}
while (statsToAccrue > 0)
{
switch (RngUtil.intRange(0, 3))
{
case (0):
statsToFill.AddToStat <Strength>(1);
break;
case (1):
statsToFill.AddToStat <Dexterity>(1);
break;
case (2):
statsToFill.AddToStat <Instinct>(1);
break;
case (3):
statsToFill.AddToStat <Stamina>(1);
break;
}
statsToAccrue--;
}
statsToFill.SetStat <CurrHealth>(statsToFill.GetStat <MaxHealth>());
return((StatHolder)statsToFill);
}
public int GetAttackDamage()
{
var minDamage = (int)GetStat(new MinDamage());
var maxDamage = (int)GetStat(new MaxDamage());
return(RngUtil.intRange(minDamage, maxDamage));
}
public async Task <(string username, string password, int userId)> CreateUserAsync()
{
var username = $"user.{RngUtil.GetRandomHexString(16)}@test.ca";
var password = RngUtil.GetRandomHexString(32);
var userId = await CreateUserAsync(username, password);
return(username, password, userId);
}
public void GenerateTest()
{
const int MIN = 100;
const int MAX = 999;
for (int i = 0; i < 1000; i++)
{
Assert.InRange(RngUtil.GetRandom(MIN, MAX), MIN, MAX);
}
}
public void AddStats()
{
Rank = (byte)RngUtil.intMax(2);
Duration = new byte[] { 5, 12, 35 }[Rank];
StatBonuses = new Dictionary <Type, StatBonus>
{
{ typeof(Strength), StatBonus.New(0, -0.6f) },
{ typeof(Dexterity), StatBonus.New(0, -0.6f) },
{ typeof(Instinct), StatBonus.New(0, -0.6f) },
{ typeof(Stamina), StatBonus.New(0, -0.6f) },
{ typeof(MaxHealth), StatBonus.New(0, -0.6f) }
};
StatBonuses.ForEach(x => x.Value.Flip());
}
private void DeployBots(Fight fight)
{
const string METHODNAME = "DeployBots";
try
{
byte level = (byte)RngUtil.intRange(fight.getLowestLevel(), fight.getHighestLevel());
// while (!fight.isFull)
// {
var bot = _NPCFactory.createFightBot(level);
bot.joinQueue(fight);
//Bots.TryAdd(bot.ObjectId, bot);
Log.DebugFormat("{0} - {1} shoving {2} into a queue {3}", CLASSNAME, METHODNAME, bot, fight);
// }
}
catch (Exception e)
{
DebugUtils.Logp(DebugUtils.Level.ERROR, CLASSNAME, METHODNAME, String.Format("e.MSG: {0}\n e.Stack: {1}", e.Message, e.StackTrace));
}
}
public int ProcessOutcome(SpellEnvironment env, MoveOutcome outcome)
{
const string METHODNAME = "ProcessOutcome";
var attacker = env.Character;
var target = env.Target;
var attackerStats = attacker.Stats;
var damage = (int)attackerStats.GetStat(new Damage(), target); //calculates rng damage (minDmg <= dmg <= maxDmg) and applies target negation
switch (outcome)
{
case (MoveOutcome.Hit):
//HIT CHANCE VS TARGET'S DODGE CHANCE
if (attackerStats.GetStat(new HitChance(), target) > RngUtil.hundredRoll())
{
//CRIT CHANCE VS TARGET'S ANTI-CRIT CHANCE, if fails then HIT
damage = attackerStats.GetStat(
new CriticalHitChance(), target) > RngUtil.hundredRoll() ? applyOutcome(attacker, target, MoveOutcome.Crit, damage)
: applyOutcome(attacker, target, MoveOutcome.Hit, damage);
}
else
{
//IF HIT 'MISSES' ITS A DODGE
damage = applyOutcome(attacker, target, MoveOutcome.Dodge, damage);
}
break;
case (MoveOutcome.Block):
damage = applyOutcome(attacker, target,
attacker.Stats.GetStat(new CriticalHitChance(), target) * 0.2f > RngUtil.hundredRoll() ? MoveOutcome.BlockCrit
: MoveOutcome.Block,
damage);
break;
}
return(damage);
}
public static List <HitSpot> getRandomBlock()
{
var option = blockOptions[RngUtil.intRange(0, 4)];
return(option.Select(c => (HitSpot)((int)char.GetNumericValue(c))).ToList());
}
public static HitSpot getRandomHit()
{
return((HitSpot)RngUtil.intRange(0, 4));
}
public float Calculate(Environment env)
{
return(RngUtil.intRange((int)_min.Calculate(env), (int)_max.Calculate(env)));
}
