Ejemplo n.º 1
0
        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++;
            }
        }
Ejemplo n.º 2
0
        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++;
            }
        }
Ejemplo n.º 3
0
        public void BuildVariances(WeaponProfile weapon)
        {
            int bestVariance    = (int)Math.Round(weapon.BestDamageVariance * 100);
            int worstVariance   = (int)Math.Round(weapon.WorstDamageVariance * 100);
            int numberOfEntries = DetermineNumberOfEntries(bestVariance, worstVariance);

            weapon.Variances = new ChanceEntry[numberOfEntries];

            int numOfRolls = 100000;

            DistributeVarianceEntries(weapon, 0, numberOfEntries, numOfRolls, eRandomFormula.favorMid);
            VarianceDistributionRounding(weapon, numberOfEntries);

            ProcesVarianceEntries(weapon, bestVariance, worstVariance, 0, numberOfEntries, numOfRolls);

            int   entryCounter = 0;
            float totalChance  = 0;

            for (int i = 0; i < numberOfEntries; i++)
            {
                entryCounter++;
                totalChance += weapon.Variances[i].Chance;
                if (DebugLevel > 1)
                {
                    Console.WriteLine($"Entry {entryCounter} Chance: {weapon.Variances[i].Chance}% - Variance = {weapon.Variances[i].Value / 100.0f} - Example max damage 325 skill {weapon.WeaponName.ToLower()}: {weapon.DamageTier[4]*(1.0f-(weapon.Variances[i].Value / 100.0f))}-{weapon.DamageTier[4]}");
                }
            }

            if (DebugLevel > 1)
            {
                Console.WriteLine($"Total Chance: {totalChance}%");
            }

            //if (totalChance != 100.0f)
            //{
            //    if (DebugLevel > 0)
            //        Console.WriteLine($"Retrying due to total chance: {totalChance}%");
            //    BuildVariances(weapon);
            //    return;
            //}
            //if (totalChance < 100.0f)
            //{
            //    float difference = 100.0f - totalChance;
            //    weapon.Variances[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 < numberOfEntries; i++)
            //    {
            //        totalChance += weapon.Variances[i].Chance;
            //    }
            //    if (DebugLevel > 1)
            //        Console.WriteLine($"New Total Chance: {totalChance}%");
            //}
        }
Ejemplo n.º 4
0
 public void ProcesVarianceEntries(WeaponProfile weapon, int bestVariance, int worstVariance, int startEntry, int numberOfEntriesToProcess, int numOfRolls)
 {
     for (int i = startEntry; i < startEntry + numberOfEntriesToProcess; i++)
     {
         weapon.Variances[i].Chance /= (numOfRolls / 100);
         if (i == startEntry)
         {
             weapon.Variances[i].Value = worstVariance;
         }
         else if (i == numberOfEntriesToProcess - 1)
         {
             weapon.Variances[i].Value = bestVariance;
         }
         else
         {
             weapon.Variances[i].Value = (int)Math.Round((((bestVariance - worstVariance) / ((float)numberOfEntriesToProcess - 1)) * (i - startEntry)) + worstVariance);
         }
     }
 }
Ejemplo n.º 5
0
        public void ProcessDamageBonusEntries(WeaponProfile weapon, int tier, int minBonus, int maxBonus, int wieldDificulty, int startEntry, int numberOfEntriesToProcess, int numOfRolls)
        {
            for (int i = startEntry; i < startEntry + numberOfEntriesToProcess; i++)
            {
                weapon.Tiers[tier].Bonus[i].Chance /= (numOfRolls / 100);
                if (i == startEntry)
                {
                    weapon.Tiers[tier].Bonus[i].Value = minBonus;
                }
                else if (i == numberOfEntriesToProcess - 1)
                {
                    weapon.Tiers[tier].Bonus[i].Value = maxBonus;
                }
                else
                {
                    weapon.Tiers[tier].Bonus[i].Value = (int)Math.Round((((maxBonus - minBonus) / ((float)numberOfEntriesToProcess - 1)) * (i - startEntry)) + minBonus);
                }

                weapon.Tiers[tier].wieldDifficulty[i] = wieldDificulty;
            }
        }
Ejemplo n.º 6
0
 public void BuildWeapon(WeaponProfile weapon)
 {
     if (weapon.WeaponName == "DaggerMS")
     {
         BuildWeaponTier(weapon, Tier.Tier1, MinDamage.Zero, MaxDamage.Tier1, 0, eRandomFormula.favorMid);
         BuildWeaponTier(weapon, Tier.Tier2, MinDamage.Zero, MaxDamage.Tier1, 0, eRandomFormula.favorMid);
         BuildWeaponTier(weapon, Tier.Tier3, MinDamage.Zero, MaxDamage.Tier1, 0, eRandomFormula.favorHigh);
         BuildWeaponTier(weapon, Tier.Tier4, MinDamage.Zero, MaxDamage.Tier1, 0, eRandomFormula.favorHigh);
         BuildWeaponTier(weapon, Tier.Tier5, MinDamage.Zero, MaxDamage.Tier1, 0, eRandomFormula.favorHigh);
         BuildWeaponTier(weapon, Tier.Tier6, MinDamage.Zero, MaxDamage.Tier1, 0, eRandomFormula.favorHigh);
         BuildWeaponTier(weapon, Tier.Tier7, MinDamage.Zero, MaxDamage.Tier1, 0, eRandomFormula.favorHigh);
         BuildWeaponTier(weapon, Tier.Tier8, MinDamage.Zero, MaxDamage.Tier1, 0, eRandomFormula.favorHigh);
         BuildVariances(weapon);
     }
     //else if (weapon.WeaponName == "SwordMS")
     //{
     //    BuildWeaponTier(weapon, Tier.Tier1, MinDamage.Zero, MaxDamage.Tier1, 0, eRandomFormula.favorMid);
     //    BuildWeaponTier(weapon, Tier.Tier2, MinDamage.Zero, MaxDamage.Tier1, 0, eRandomFormula.favorMid);
     //    BuildWeaponTier(weapon, Tier.Tier3, MinDamage.Zero, MaxDamage.Tier1, 0, eRandomFormula.favorHigh);
     //    BuildWeaponTier(weapon, Tier.Tier4, MinDamage.Zero, MaxDamage.Tier1, 0, eRandomFormula.favorHigh);
     //    BuildWeaponTier(weapon, Tier.Tier5, MinDamage.Zero, MaxDamage.Tier1, 0, eRandomFormula.favorHigh);
     //    BuildWeaponTier(weapon, Tier.Tier6, MinDamage.Zero, MaxDamage.Tier1, 0, eRandomFormula.favorHigh); //disable this line and enable the ones below for more than 6 tiers
     //    //BuildWeaponTier(weapon, Tier.Tier6, MinDamage.Zero, MaxDamage.Tier1, 0, eRandomFormula.favorHigh, MinDamage.Tier1, MaxDamage.Tier6, 370, eRandomFormula.favorLow, MinDamage.Tier6, MaxDamage.Tier7, 400, eRandomFormula.favorLow);
     //    //BuildWeaponTier(weapon, Tier.Tier7, MinDamage.Tier6, MaxDamage.Tier7, 400, eRandomFormula.favorMid, MinDamage.Tier7, MaxDamage.Tier8, 420, eRandomFormula.favorLow);
     //    //BuildWeaponTier(weapon, Tier.Tier8, MinDamage.Tier6, MaxDamage.Tier7, 400, eRandomFormula.favorHigh, MinDamage.Tier7, MaxDamage.Tier8, 420, eRandomFormula.favorLow);
     //    BuildVariances(weapon);
     //}
     else
     {
         BuildWeaponTier(weapon, Tier.Tier1, MinDamage.Zero, MaxDamage.Tier1, 0, eRandomFormula.favorMid);
         BuildWeaponTier(weapon, Tier.Tier2, MinDamage.Zero, MaxDamage.Tier1, 0, eRandomFormula.favorMid, MinDamage.Tier1, MaxDamage.Tier2, 250, eRandomFormula.favorMid);
         BuildWeaponTier(weapon, Tier.Tier3, MinDamage.Tier1, MaxDamage.Tier2, 250, eRandomFormula.favorHigh, MinDamage.Tier2, MaxDamage.Tier3, 300, eRandomFormula.favorLow);
         BuildWeaponTier(weapon, Tier.Tier4, MinDamage.Tier2, MaxDamage.Tier3, 300, eRandomFormula.favorLow, MinDamage.Tier3, MaxDamage.Tier4, 325, eRandomFormula.favorLow);
         BuildWeaponTier(weapon, Tier.Tier5, MinDamage.Tier3, MaxDamage.Tier4, 325, eRandomFormula.favorLow, MinDamage.Tier4, MaxDamage.Tier5, 350, eRandomFormula.favorLow);
         BuildWeaponTier(weapon, Tier.Tier6, MinDamage.Tier4, MaxDamage.Tier5, 350, eRandomFormula.favorLow, MinDamage.Tier5, MaxDamage.Tier6, 370, eRandomFormula.favorLow, MinDamage.Tier6, MaxDamage.Tier7, 400, eRandomFormula.favorLow);
         BuildWeaponTier(weapon, Tier.Tier7, MinDamage.Tier6, MaxDamage.Tier7, 400, eRandomFormula.favorMid, MinDamage.Tier7, MaxDamage.Tier8, 420, eRandomFormula.favorLow);
         BuildWeaponTier(weapon, Tier.Tier8, MinDamage.Tier6, MaxDamage.Tier7, 400, eRandomFormula.favorHigh, MinDamage.Tier7, MaxDamage.Tier8, 420, eRandomFormula.favorLow);
         BuildVariances(weapon);
     }
 }
Ejemplo n.º 7
0
        public void WriteFile(WeaponProfile weapon, int maxLootTier = 6)
        {
            string convertedWeaponName = weapon.WeaponName.ToLower();

            if (convertedWeaponName == "daggerms")
            {
                convertedWeaponName = "dagger_ms";
            }
            else if (convertedWeaponName == "macejitte")
            {
                convertedWeaponName = "mace_jitte";
            }
            else if (convertedWeaponName == "swordms")
            {
                convertedWeaponName = "sword_ms";
            }

            string filename = $".\\ACEmulator Mutations\\MeleeWeapons\\Damage_WieldDifficulty_DamageVariance\\Infiltration\\{convertedWeaponName}.txt";

            StreamWriter outputFile = new StreamWriter(new FileStream(filename, FileMode.Create, FileAccess.Write));

            if (outputFile == null)
            {
                Console.WriteLine($"Unable to open {filename}.");
                return;
            }

            Console.WriteLine($"Writing {filename}.");

            int mutationCounter = 0;

            maxLootTier = Math.Min(weapon.Tiers.Length, maxLootTier);
            for (int i = 0; i < maxLootTier; i++)
            {
                // Damage and wield requirements
                mutationCounter++;
                outputFile.WriteLine($"{weapon.WeaponName} Mutation #{mutationCounter}:");
                outputFile.WriteLine();
                outputFile.Write("Tier Chances: ");
                for (int tier = 0; tier < maxLootTier; tier++)
                {
                    outputFile.Write(i == tier ? 1 : 0);
                    if (tier + 1 < maxLootTier)
                    {
                        outputFile.Write(", ");
                    }
                    else
                    {
                        outputFile.Write("\n");
                    }
                }
                //outputFile.WriteLine($"Tier Chances: {(i == 0 ? 1 : 0)}, {(i == 1 ? 1 : 0)}, {(i == 2 ? 1 : 0)}, {(i == 3 ? 1 : 0)}, {(i == 4 ? 1 : 0)}, {(i == 5 ? 1 : 0)}, {(i == 6 ? 1 : 0)}, {(i == 7 ? 1 : 0)}");
                outputFile.WriteLine();

                for (int j = 0; j < weapon.Tiers[i].Bonus.Length; j++)
                {
                    outputFile.WriteLine($"    - Chance: {weapon.Tiers[i].Bonus[j].Chance}%:");
                    outputFile.WriteLine($"        Damage += {weapon.Tiers[i].Bonus[j].Value}");
                    if (weapon.Tiers[i].wieldDifficulty[j] > 0)
                    {
                        outputFile.WriteLine($"        WieldRequirements = {weapon.Tiers[i].WieldRequirements}");
                        outputFile.WriteLine($"        WieldSkillType = { weapon.Tiers[i].WieldSkillType}");
                        outputFile.WriteLine($"        WieldDifficulty = { weapon.Tiers[i].wieldDifficulty[j]}");
                    }
                    //if (j < weapon.Tiers[i].damageBonus.Length - 1 || i < weapon.Tiers.Length - 1)
                    outputFile.WriteLine();
                }

                outputFile.Flush();
            }

            // Variance
            mutationCounter++;
            outputFile.WriteLine($"{weapon.WeaponName} Mutation #{mutationCounter}:");
            outputFile.WriteLine();
            outputFile.Write("Tier Chances: ");
            for (int tier = 0; tier < maxLootTier; tier++)
            {
                outputFile.Write(1);
                if (tier + 1 < maxLootTier)
                {
                    outputFile.Write(", ");
                }
                else
                {
                    outputFile.Write("\n");
                }
            }
            //outputFile.WriteLine($"Tier chances: 1, 1, 1, 1, 1, 1, 1, 1");
            outputFile.WriteLine();

            for (int i = 0; i < weapon.Variances.Length; i++)
            {
                outputFile.WriteLine($"    - Chance: {weapon.Variances[i].Chance}%:");
                outputFile.WriteLine($"        DamageVariance = {weapon.Variances[i].Value / 100.0f}");

                if (i < weapon.Variances.Length - 1)
                {
                    outputFile.WriteLine();
                }
            }

            outputFile.Close();
        }
Ejemplo n.º 8
0
        public void DamageBonusDistributionRounding(int tier, WeaponProfile weapon, int totalNumberOfEntries)
        {
            //Let's do some rounding so it looks better!
            float freeAmount = 0;

            for (int i = 0; i < totalNumberOfEntries; i++)
            {
                if (weapon.Tiers[tier].Bonus[i].Chance > 10000)
                {
                    freeAmount += weapon.Tiers[tier].Bonus[i].Chance % 1000;
                    weapon.Tiers[tier].Bonus[i].Chance = (float)Math.Floor(weapon.Tiers[tier].Bonus[i].Chance / 1000) * 1000;
                }
                else
                {
                    freeAmount += weapon.Tiers[tier].Bonus[i].Chance % 100;
                    weapon.Tiers[tier].Bonus[i].Chance = (float)Math.Floor(weapon.Tiers[tier].Bonus[i].Chance / 100) * 100;

                    if ((weapon.Tiers[tier].Bonus[i].Chance - 100) % 1000 == 0)
                    {
                        weapon.Tiers[tier].Bonus[i].Chance -= 100;
                        freeAmount += 100;
                    }
                }
            }

            while (freeAmount >= 1000)
            {
                int roll = Utils.getRandomNumber(0, totalNumberOfEntries - 1, eRandomFormula.equalDistribution, 2, 0);

                weapon.Tiers[tier].Bonus[roll].Chance += 1000;
                freeAmount -= 1000;
            }

            int fails         = 0;
            int fails2        = 0;
            int failThreshold = 10000;

            while (freeAmount >= 100)
            {
                int roll = Utils.getRandomNumber(0, totalNumberOfEntries - 1, eRandomFormula.equalDistribution, 2, 0);

                if (weapon.Tiers[tier].Bonus[roll].Chance <3000 || fails> failThreshold * 10)
                {
                    if ((weapon.Tiers[tier].Bonus[roll].Chance + 100) % 1000 == 0 || fails2 > failThreshold)
                    {
                        weapon.Tiers[tier].Bonus[roll].Chance += 100;
                        freeAmount -= 100;
                        fails       = 0;
                        fails2      = 0;
                        continue;
                    }
                }

                fails++;
                fails2++;
            }

            while (freeAmount >= 10)
            {
                int roll = Utils.getRandomNumber(0, totalNumberOfEntries - 1, eRandomFormula.equalDistribution, 2, 0);

                weapon.Tiers[tier].Bonus[roll].Chance += freeAmount;
                freeAmount -= freeAmount;
            }

            for (int i = 0; i < totalNumberOfEntries; i++)
            {
                if (weapon.Tiers[(int)tier].Bonus[i].Chance % 100 == 99) // Fixes 1/3 + 1/3 + 1/3 turning into 0.99999 instead of 1.0
                {
                    weapon.Tiers[(int)tier].Bonus[i].Chance++;
                }
            }

            if (DebugLevel > 0 && freeAmount > 0)
            {
                Console.WriteLine($"Unused freeAmount: {freeAmount}");
            }
        }
Ejemplo n.º 9
0
        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}%");
            //}
        }
Ejemplo n.º 10
0
        public void BuildScripts()
        {
            Console.WriteLine($"Creating ACEmulator Mutation Scripts...");

            Armor  = new ArmorProfile("Armor");
            Shield = new ArmorProfile("Shield");

            //Armor.SetArmorTiers(  25, 50, 75, 100, 125, 150, 160, 170);
            //Shield.SetArmorTiers( 20, 40, 60,  80, 100, 120, 130, 140);

            // The last 2 tiers are made up for forward compatibility with loot tiers 7 and 8
            //Armor.SetMinArmorTiers(10,  40,  70,  90, 100, 100, 110, 120);
            //Armor.SetMaxArmorTiers(70, 100, 130, 150, 160, 160, 170, 180);

            //Shield.SetMinArmorTiers(10, 20, 30,  40,  50,  60, 70,  80);
            //Shield.SetMaxArmorTiers(50, 80, 90, 100, 110, 120, 130, 140);

            // Adjusted for better low tier balance?
            //Armor.SetMinArmorTiers(0,  10,  40,  70,  90, 100, 110, 120);
            //Armor.SetMaxArmorTiers(30, 70, 100, 130, 150, 160, 170, 180);

            //Shield.SetMinArmorTiers(0,  10, 30,  40,  50,  60,  70,  80);
            //Shield.SetMaxArmorTiers(20, 50, 80, 100, 110, 120, 130, 140);

            //BuildArmor(Armor);
            //BuildArmor(Shield);

            //WriteFile(Armor, 6);
            //WriteFile(Shield, 6);

            //Axe = new WeaponProfile("Axe", 0.40f, 0.50f);
            //Dagger = new WeaponProfile("Dagger", 0.30f, 0.75f);
            //Mace = new WeaponProfile("Mace", 0.25f, 0.50f);
            //Spear = new WeaponProfile("Spear", 0.45f, 0.75f);
            //Staff = new WeaponProfile("Staff", 0.25f, 0.50f);
            //Sword = new WeaponProfile("Sword", 0.40f, 0.50f);
            //Unarmed = new WeaponProfile("Unarmed", 0.50f, 0.75f);
            //Thrown = new WeaponProfile("Thrown", 0.40f, 0.50f);

            //DaggerMS = new WeaponProfile("DaggerMS", 0.71f, 0.75f);
            //SwordMS = new WeaponProfile("SwordMS", 0.40f, 0.50f);
            //MaceJitte = new WeaponProfile("MaceJitte", 0.25f, 0.50f);

            AxeTwoHanded   = new WeaponProfile("two_handed_axe", 0.40f, 0.50f);
            SpearTwoHanded = new WeaponProfile("two_handed_spear", 0.25f, 0.50f);
            SwordTwoHanded = new WeaponProfile("two_handed_sword", 0.40f, 0.50f);

            //// The last tier is made up for forward compatibility with loot tiers 7 and 8
            //Axe.SetDamageTiers(8, 17, 21, 25, 27, 31, 35, 39);
            //Dagger.SetDamageTiers(5, 7, 9, 11, 13, 17, 19, 21);
            ////Dagger.SetDamageTiers(3, 6, 9, 12, 14, 16, 18, 20);
            //Mace.SetDamageTiers(8, 16, 20, 24, 26, 28, 32, 36);
            //Spear.SetDamageTiers(7, 14, 16, 18, 22, 26, 30, 34);
            //Staff.SetDamageTiers(5, 7, 9, 11, 13, 17, 19, 21);
            //Sword.SetDamageTiers(10, 20, 25, 30, 35, 40, 45, 50);
            //Unarmed.SetDamageTiers(4, 7, 9, 12, 16, 18, 22, 24);
            //Thrown.SetDamageTiers(6, 8, 12, 16, 20, 24, 28, 32);

            //DaggerMS.SetDamageTiers(3, 0, 0, 0, 0, 0, 0, 0);
            //SwordMS.SetDamageTiers(5, 0, 0, 0, 0, 0, 0, 0);
            ////SwordMS.SetDamageTiers(9, 6, 8, 10, 13, 15, 18, 20);
            //MaceJitte.SetDamageTiers(8, 16, 20, 24, 26, 28, 32, 36);

            AxeTwoHanded.SetDamageTiers(3, 6, 7, 8, 9, 10, 12, 14);
            SpearTwoHanded.SetDamageTiers(3, 6, 7, 8, 9, 10, 12, 14);
            SwordTwoHanded.SetDamageTiers(4, 7, 8, 10, 11, 13, 15, 17);

            //BuildWeapon(Axe);
            //BuildWeapon(Dagger);
            //BuildWeapon(Mace);
            //BuildWeapon(Spear);
            //BuildWeapon(Staff);
            //BuildWeapon(Sword);
            //BuildWeapon(Unarmed);
            //BuildWeapon(Thrown);

            //BuildWeapon(DaggerMS);
            //BuildWeapon(SwordMS);
            //BuildWeapon(MaceJitte);

            BuildWeapon(AxeTwoHanded);
            BuildWeapon(SpearTwoHanded);
            BuildWeapon(SwordTwoHanded);

            //WriteFile(Axe, 6);
            //WriteFile(Dagger, 6);
            //WriteFile(Mace, 6);
            //WriteFile(Spear, 6);
            //WriteFile(Staff, 6);
            //WriteFile(Sword, 6);
            //WriteFile(Unarmed, 6);
            //WriteFile(Thrown, 6);

            //WriteFile(DaggerMS, 6);
            //WriteFile(SwordMS, 6);
            //WriteFile(MaceJitte, 6);

            WriteFile(AxeTwoHanded, 6);
            WriteFile(SpearTwoHanded, 6);
            WriteFile(SwordTwoHanded, 6);
        }