public static int getRandomNumber(int minInclusive, int maxInclusive, eRandomFormula formula, double favorValue, double favorStrength, double favorModifier = 0)
{
int numbersAmount = maxInclusive - minInclusive;
switch (formula)
{
case eRandomFormula.favorSpecificValue:
{
favorValue = favorValue + (numbersAmount * favorModifier);
favorValue = Math.Min(favorValue, maxInclusive);
favorValue = Math.Max(favorValue, minInclusive);
return(getRandomNumberWithFavoredValue(minInclusive, maxInclusive, favorValue, favorStrength));
}
case eRandomFormula.favorLow:
{
favorValue = minInclusive + (numbersAmount * favorModifier);
favorValue = Math.Min(favorValue, maxInclusive);
favorValue = Math.Max(favorValue, minInclusive);
return(getRandomNumberWithFavoredValue(minInclusive, maxInclusive, favorValue, favorStrength));
}
case eRandomFormula.favorMid:
{
int midValue = (int)Math.Round(((double)(maxInclusive - minInclusive) / 2)) + minInclusive;
favorValue = midValue + (numbersAmount * favorModifier);
favorValue = Math.Min(favorValue, maxInclusive);
favorValue = Math.Max(favorValue, minInclusive);
return(getRandomNumberWithFavoredValue(minInclusive, maxInclusive, favorValue, favorStrength));
}
case eRandomFormula.favorHigh:
{
favorValue = maxInclusive - (numbersAmount * favorModifier);
favorValue = Math.Min(favorValue, maxInclusive);
favorValue = Math.Max(favorValue, minInclusive);
return(getRandomNumberWithFavoredValue(minInclusive, maxInclusive, favorValue, favorStrength));
}
default:
case eRandomFormula.equalDistribution:
{
return(RandomUtil.Standard.Next(minInclusive, maxInclusive + 1));
}
}
}
public static double getRandomDouble(double minInclusive, double maxInclusive, eRandomFormula formula, double favorStrength, double favorModifier = 0)
{
double decimalPlaces = 1000;
int minInt = (int)Math.Round(minInclusive * decimalPlaces);
int maxInt = (int)Math.Round(maxInclusive * decimalPlaces);
int randomInt = getRandomNumber(minInt, maxInt, formula, favorStrength, favorModifier);
double returnValue = randomInt / decimalPlaces;
returnValue = Math.Min(returnValue, maxInclusive);
returnValue = Math.Max(returnValue, minInclusive);
return(returnValue);
}
public static double getRandomDouble(double maxInclusive, eRandomFormula formula, double favorStrength, double favorModifier = 0)
{
return(getRandomDouble(0, maxInclusive, formula, favorStrength, favorModifier));
}
public static int getRandomNumber(int minInclusive, int maxInclusive, eRandomFormula formula, double favorStrength, double favorModifier = 0)
{
return(getRandomNumber(minInclusive, maxInclusive, formula, 0, favorStrength, favorModifier));
}
public static int getRandomNumberExclusive(int maxExclusive, eRandomFormula formula, double favorValue, double favorStrength, double favorModifier = 0)
{
return(getRandomNumber(0, maxExclusive - 1, formula, favorValue, favorStrength, favorModifier));
}
public void DistributeDamageBonusEntries(int tier, WeaponProfile weapon, int startEntry, int numberOfEntriesToProcess, int numOfRolls, eRandomFormula distribution)
{
for (int i = 0; i < numOfRolls; i++)
{
int roll = Utils.getRandomNumber(startEntry, startEntry + numberOfEntriesToProcess - 1, distribution, 2, 0);
weapon.Tiers[tier].Bonus[roll].Chance++;
}
}
public void BuildArmorTier(ArmorProfile armor, Tier tier, ArmorBonus armorBonus, int wieldDifficulty, eRandomFormula distribution)
{
int minArmor = armor.MinArmorTier[(int)armorBonus];
int maxArmor = armor.MaxArmorTier[(int)armorBonus];
int numberOfEntries = ((maxArmor - minArmor) / 10) + 1;// DetermineNumberOfEntries(minArmor, maxArmor);
//if (maxArmor <= 30)
// numberOfEntries *= 2;
armor.Tiers[(int)tier].Bonus = new ChanceEntry[numberOfEntries];
armor.Tiers[(int)tier].wieldDifficulty = new int[numberOfEntries];
int numOfRolls = 100000;
DistributeArmorBonusEntries((int)tier, armor, 0, numberOfEntries, numOfRolls, distribution);
ArmorBonusDistributionRounding((int)tier, armor, numberOfEntries);
ProcessArmorBonusEntries(armor, (int)tier, minArmor, maxArmor, wieldDifficulty, 0, numberOfEntries, numOfRolls);
float totalChance = 0;
int entryCounter = 0;
for (int i = 0; i < numberOfEntries; i++)
{
entryCounter++;
totalChance += armor.Tiers[(int)tier].Bonus[i].Chance;
if (DebugLevel > 1)
{
Console.WriteLine($"Entry {entryCounter} Chance: {armor.Tiers[(int)tier].Bonus[i].Chance}% - ArmorBonus += {armor.Tiers[(int)tier].Bonus[i].Value}");
}
}
if (DebugLevel > 1)
{
Console.WriteLine($"Total Chance: {totalChance}%");
}
}
public void BuildWeaponTier(WeaponProfile weapon, Tier tier, MinDamage minDamageTierA, MaxDamage maxDamageTierA, int wieldDifficultyA, eRandomFormula distributionA, MinDamage minDamageTierB = MinDamage.Invalid, MaxDamage maxDamageTierB = MaxDamage.Invalid, int wieldDifficultyB = -1, eRandomFormula distributionB = eRandomFormula.favorMid, MinDamage minDamageTierC = MinDamage.Invalid, MaxDamage maxDamageTierC = MaxDamage.Invalid, int wieldDifficultyC = -1, eRandomFormula distributionC = eRandomFormula.favorMid)
{
int totalNumberOfEntries = 0;
int numOfRollsDivider = 1;
int minDamageA = minDamageTierA == MinDamage.Zero ? 0 : weapon.DamageTier[(int)minDamageTierA - 1] + 1;
int maxDamageA = maxDamageTierA == MaxDamage.Zero ? 0 : weapon.DamageTier[(int)maxDamageTierA - 1];
int minDamageB = 0;
int maxDamageB = 0;
int minDamageC = 0;
int maxDamageC = 0;
int numberOfEntriesA = DetermineNumberOfEntries(minDamageA, maxDamageA);
int numberOfEntriesB = 0;
if (minDamageTierB != MinDamage.Invalid && maxDamageTierB != MaxDamage.Invalid)
{
minDamageB = minDamageTierB == MinDamage.Zero ? 0 : weapon.DamageTier[(int)minDamageTierB - 1] + 1;
maxDamageB = maxDamageTierB == MaxDamage.Zero ? 0 : weapon.DamageTier[(int)maxDamageTierB - 1];
numberOfEntriesB = DetermineNumberOfEntries(minDamageB, maxDamageB);
numOfRollsDivider++;
}
int numberOfEntriesC = 0;
if (minDamageTierC != MinDamage.Invalid && maxDamageTierC != MaxDamage.Invalid)
{
minDamageC = minDamageTierC == MinDamage.Zero ? 0 : weapon.DamageTier[(int)minDamageTierC - 1] + 1;
maxDamageC = maxDamageTierC == MaxDamage.Zero ? 0 : weapon.DamageTier[(int)maxDamageTierC - 1];
numberOfEntriesC = DetermineNumberOfEntries(minDamageC, maxDamageC);
numOfRollsDivider++;
}
totalNumberOfEntries = numberOfEntriesA + numberOfEntriesB + numberOfEntriesC;
weapon.Tiers[(int)tier].Bonus = new ChanceEntry[totalNumberOfEntries];
weapon.Tiers[(int)tier].wieldDifficulty = new int[totalNumberOfEntries];
int numOfRolls = 100000;
DistributeDamageBonusEntries((int)tier, weapon, 0, numberOfEntriesA, numOfRolls / numOfRollsDivider, distributionA);
if (numberOfEntriesB > 0)
{
DistributeDamageBonusEntries((int)tier, weapon, numberOfEntriesA, numberOfEntriesB, numOfRolls / numOfRollsDivider, distributionB);
}
if (numberOfEntriesC > 0)
{
DistributeDamageBonusEntries((int)tier, weapon, numberOfEntriesA + numberOfEntriesB, numberOfEntriesC, numOfRolls / numOfRollsDivider, distributionC);
}
DamageBonusDistributionRounding((int)tier, weapon, totalNumberOfEntries);
ProcessDamageBonusEntries(weapon, (int)tier, minDamageA, maxDamageA, wieldDifficultyA, 0, numberOfEntriesA, numOfRolls);
if (numberOfEntriesB > 0)
{
ProcessDamageBonusEntries(weapon, (int)tier, minDamageB, maxDamageB, wieldDifficultyB, numberOfEntriesA, numberOfEntriesB, numOfRolls);
}
if (numberOfEntriesC > 0)
{
ProcessDamageBonusEntries(weapon, (int)tier, minDamageC, maxDamageC, wieldDifficultyC, numberOfEntriesA + numberOfEntriesB, numberOfEntriesC, numOfRolls);
}
float totalChance = 0;
int entryCounter = 0;
for (int i = 0; i < totalNumberOfEntries; i++)
{
entryCounter++;
totalChance += weapon.Tiers[(int)tier].Bonus[i].Chance;
if (DebugLevel > 1)
{
Console.WriteLine($"Entry {entryCounter} Chance: {weapon.Tiers[(int)tier].Bonus[i].Chance}% - Damage += {weapon.Tiers[(int)tier].Bonus[i].Value} WieldDifficulty = {weapon.Tiers[(int)tier].wieldDifficulty[i]}");
}
}
if (DebugLevel > 1)
{
Console.WriteLine($"Total Chance: {totalChance}%");
}
//if (totalChance != 100.0f)
//{
// if (DebugLevel > 0)
// Console.WriteLine($"Retrying due to total chance: {totalChance}%");
// BuildTier(weapon, tier, minDamageTierA, maxDamageTierA, wieldDifficultyA, distributionA, minDamageTierB, maxDamageTierB, wieldDifficultyB, distributionB, minDamageTierC, maxDamageTierC, wieldDifficultyC, distributionC);
// return;
//}
//if (totalChance < 100.0f)
//{
// float difference = 100.0f - totalChance;
// weapon.Tiers[(int)tier].damageBonus[0].Chance += difference;
// if (DebugLevel > 0)
// Console.WriteLine($"Added {difference.ToString("0.000000")}% to Entry 1 to make the total chance 100%.");
// totalChance = 0;
// for (int i = 0; i < totalNumberOfEntries; i++)
// {
// totalChance += weapon.Tiers[(int)tier].damageBonus[i].Chance;
// }
// if (DebugLevel > 1)
// Console.WriteLine($"New Total Chance: {totalChance}%");
//}
}
public void DistributeVarianceEntries(WeaponProfile weapon, int startEntry, int numberOfEntriesToProcess, int numOfRolls, eRandomFormula distribution)
{
for (int i = 0; i < numOfRolls; i++)
{
int roll = Utils.getRandomNumber(startEntry, startEntry + numberOfEntriesToProcess - 1, distribution, 2, 0);
weapon.Variances[roll].Chance++;
}
}
