itemgen | C# Online Compiler

itemgen by NewfOnDahLoose

using System;
using System.Collections.Generic;
using System.Linq;

// Define the different rarities
public enum Rarity
{
    Common,
    Rare,
    Epic,
    Godly
}

// Define the different item slots
public enum ItemSlot
{
    Head,
    Shoulder,
    Chest,
    Legs,
    Feet,
    Ring1,
    Ring2,
    Amulet,
    MainHand,
    OffHand
}

// Class to hold stat ranges based on rarity
public class StatRange
{
    public int Min { get; set; }
    public int Max { get; set; }

    public StatRange(int min, int max)
    {
        Min = min;
        Max = max;
    }
}

// Class representing a single stat
public class ItemStat
{
    public int Value { get; set; }

    public ItemStat(int value)
    {
        Value = value;
    }

    public override string ToString()
    {
        return Value.ToString();
    }
}

// Class representing an item
public class Item
{
    public string Name { get; set; }
    public Rarity Rarity { get; set; }
    public ItemSlot Slot { get; set; }
    public List<ItemStat> Stats { get; set; }
    public int IlvlAverage { get; set; }

    public Item(string name, Rarity rarity, ItemSlot slot, List<ItemStat> stats, int ilvlAverage)
    {
        Name = name;
        Rarity = rarity;
        Slot = slot;
        Stats = stats;
        IlvlAverage = ilvlAverage;
    }

    public override string ToString()
    {
        string statsStr = string.Join(", ", Stats);
        return $"Name: {Name}, Rarity: {Rarity}, Slot: {Slot}, Stats: [{statsStr}], ilvl Average: {IlvlAverage}";
    }
}

// Factory class to create items
public class ItemFactory
{
    private static readonly Dictionary<Rarity, StatRange> rarityStatRanges = new Dictionary<Rarity, StatRange>
    {
        { Rarity.Common, new StatRange(1, 600) },
        { Rarity.Rare, new StatRange(601, 800) },
        { Rarity.Epic, new StatRange(801, 999) },
        { Rarity.Godly, new StatRange(1000, 1000) }
    };

    private static readonly int NumberOfStats = 6;

    private Random _random;

    public ItemFactory()
    {
        _random = new Random();
    }

    // Method to generate a random rarity based on probabilities
    public Rarity GenerateRandomRarity()
    {
        // Define rarity probabilities
        // Adjust these probabilities as needed
        double commonProb = 0.6;
        double rareProb = 0.25;
        double epicProb = 0.1;
        double godlyProb = 0.05;

        double roll = _random.NextDouble();
        if (roll < commonProb)
            return Rarity.Common;
        else if (roll < commonProb + rareProb)
            return Rarity.Rare;
        else if (roll < commonProb + rareProb + epicProb)
            return Rarity.Epic;
        else
            return Rarity.Godly;
    }

    // Method to create an item based on rarity and slot
    public Item CreateItem(Rarity rarity, ItemSlot slot)
    {
        var statRange = rarityStatRanges[rarity];
        List<ItemStat> stats = new List<ItemStat>();
        int total = 0;

        for (int i = 0; i < NumberOfStats; i++)
        {
            int statValue = GenerateStatValue(statRange);
            stats.Add(new ItemStat(statValue));
            total += statValue;
        }

        int ilvlAverage = total / NumberOfStats;
        string itemName = GenerateItemName(rarity, slot);

        return new Item(itemName, rarity, slot, stats, ilvlAverage);
    }

    // Helper method to generate a single stat value
    private int GenerateStatValue(StatRange range)
    {
        if (range.Min == range.Max)
            return range.Max;
        return _random.Next(range.Min, range.Max + 1);
    }

    // Helper method to generate a simple item name based on rarity and slot
    private string GenerateItemName(Rarity rarity, ItemSlot slot)
    {
        return $"{rarity} {slot} Item";
    }

    // Method to generate items for all slots
    public List<Item> OpenChest()
    {
        List<Item> chestItems = new List<Item>();

        foreach (ItemSlot slot in Enum.GetValues(typeof(ItemSlot)))
        {
            Rarity rarity = GenerateRandomRarity();
            Item item = CreateItem(rarity, slot);
            chestItems.Add(item);
        }

        return chestItems;
    }
}

// Class to represent a player’s inventory
public class Inventory
{
    public Dictionary<ItemSlot, Item> EquippedItems { get; set; }

    public Inventory()
    {
        EquippedItems = new Dictionary<ItemSlot, Item>();
        // Initialize all slots with null (no item equipped)
        foreach (ItemSlot slot in Enum.GetValues(typeof(ItemSlot)))
        {
            EquippedItems[slot] = null;
        }
    }

    // Method to equip multiple items
    public void EquipItems(List<Item> items)
    {
        foreach (var item in items)
        {
            EquipItem(item);
        }
    }

    // Method to equip a single item with ilvlAverage comparison
    public void EquipItem(Item newItem)
    {
        if (newItem.Slot == ItemSlot.Ring1 || newItem.Slot == ItemSlot.Ring2)
        {
            EquipRing(newItem);
        }
        else
        {
            EquipSlot(newItem);
        }
    }

    // Helper method to equip non-ring items
    private void EquipSlot(Item newItem)
    {
        if (EquippedItems[newItem.Slot] == null)
        {
            // No item equipped in this slot
            EquippedItems[newItem.Slot] = newItem;
            Console.WriteLine($"Equipped {newItem.Name} to {newItem.Slot} (ilvl: {newItem.IlvlAverage})");
        }
        else
        {
            // Compare ilvlAverage
            if (newItem.IlvlAverage > EquippedItems[newItem.Slot].IlvlAverage)
            {
                Console.WriteLine($"Replaced {EquippedItems[newItem.Slot].Name} with {newItem.Name} in {newItem.Slot}");
                EquippedItems[newItem.Slot] = newItem;
            }
            else
            {
                Console.WriteLine($"Kept existing {EquippedItems[newItem.Slot].Name} in {newItem.Slot} over {newItem.Name}");
            }
        }
    }

    // Helper method to equip ring items
    private void EquipRing(Item newRing)
    {
        // Check Ring1
        var ring1 = EquippedItems[ItemSlot.Ring1];
        var ring2 = EquippedItems[ItemSlot.Ring2];

        if (ring1 == null)
        {
            EquippedItems[ItemSlot.Ring1] = newRing;
            Console.WriteLine($"Equipped {newRing.Name} to Ring1 (ilvl: {newRing.IlvlAverage})");
            return;
        }

        if (ring2 == null)
        {
            EquippedItems[ItemSlot.Ring2] = newRing;
            Console.WriteLine($"Equipped {newRing.Name} to Ring2 (ilvl: {newRing.IlvlAverage})");
            return;
        }

        // Both rings are equipped; compare ilvlAverage
        if (newRing.IlvlAverage > ring1.IlvlAverage && newRing.IlvlAverage > ring2.IlvlAverage)
        {
            // Replace the lower ilvl ring
            if (ring1.IlvlAverage <= ring2.IlvlAverage)
            {
                Console.WriteLine($"Replaced {ring1.Name} with {newRing.Name} in Ring1");
                EquippedItems[ItemSlot.Ring1] = newRing;
            }
            else
            {
                Console.WriteLine($"Replaced {ring2.Name} with {newRing.Name} in Ring2");
                EquippedItems[ItemSlot.Ring2] = newRing;
            }
        }
        else if (newRing.IlvlAverage > ring1.IlvlAverage)
        {
            Console.WriteLine($"Replaced {ring1.Name} with {newRing.Name} in Ring1");
            EquippedItems[ItemSlot.Ring1] = newRing;
        }
        else if (newRing.IlvlAverage > ring2.IlvlAverage)
        {
            Console.WriteLine($"Replaced {ring2.Name} with {newRing.Name} in Ring2");
            EquippedItems[ItemSlot.Ring2] = newRing;
        }
        else
        {
            Console.WriteLine($"Kept existing rings over {newRing.Name}");
        }
    }

    // Method to display equipped items
    public void DisplayEquippedItems()
    {
        foreach (var slot in EquippedItems)
        {
            if (slot.Value != null)
            {
                Console.WriteLine($"{slot.Key}: {slot.Value.Name} (Rarity: {slot.Value.Rarity}, ilvl: {slot.Value.IlvlAverage})");
            }
            else
            {
                Console.WriteLine($"{slot.Key}: None");
            }
        }
    }

    // Method to calculate the overall average item level
    public double GetOverallIlvlAverage()
    {
        var equippedItems = EquippedItems.Values.Where(item => item != null);
        if (!equippedItems.Any())
            return 0;

        return equippedItems.Average(item => item.IlvlAverage);
    }

    // Method to check if a full godly set is equipped
    public bool HasFullGodlySet()
    {
        foreach (ItemSlot slot in Enum.GetValues(typeof(ItemSlot)))
        {
            if (EquippedItems[slot] == null || EquippedItems[slot].Rarity != Rarity.Godly)
                return false;
        }
        return true;
    }
}

public class Program
{
    public static void Main()
    {
        ItemFactory factory = new ItemFactory();
        Inventory playerInventory = new Inventory();
        int numberOfChests = 10;
        bool fullGodlySetObtained = false;

        for (int i = 1; i <= numberOfChests; i++)
        {
            Console.WriteLine($"Opening Chest {i}...");
            List<Item> chestItems = factory.OpenChest();

            // Display items obtained from the chest
            foreach (var item in chestItems)
            {
                Console.WriteLine($" - {item}");
            }

            // Equip the items
            Console.WriteLine("Equipping items from the chest...");
            playerInventory.EquipItems(chestItems);

            // Check for full godly set
            if (playerInventory.HasFullGodlySet())
            {
                Console.WriteLine("Congratulations! You have equipped a full set of Godly items!");
                fullGodlySetObtained = true;
                break;
            }

            Console.WriteLine("-----------------------------");
        }

        if (!fullGodlySetObtained)
        {
            Console.WriteLine("You did not obtain a full set of Godly items after opening all chests.");
        }

        Console.WriteLine("\nFinal Equipped Items:");
        playerInventory.DisplayEquippedItems();

        // Calculate and display the overall average item level
        double overallIlvl = playerInventory.GetOverallIlvlAverage();
        Console.WriteLine($"\nOverall Average Item Level: {overallIlvl:F2}");
    }
}

​x
 
using System;
using System.Collections.Generic;
using System.Linq;
​
// Define the different rarities
public enum Rarity
{
    Common,
    Rare,
    Epic,
    Godly
}
​
// Define the different item slots
public enum ItemSlot
{
    Head,
    Shoulder,
    Chest,
    Legs,
    Feet,
    Ring1,
    Ring2,
    Amulet,
    MainHand,
    OffHand
}
​
// Class to hold stat ranges based on rarity
public class StatRange
{
    public int Min { get; set; }
    public int Max { get; set; }
​
    public StatRange(int min, int max)
    {
        Min = min;
        Max = max;
    }
}
​
// Class representing a single stat
public class ItemStat
{
    public int Value { get; set; }
​
    public ItemStat(int value)
    {
        Value = value;
    }
​
    public override string ToString()
    {
        return Value.ToString();
    }
}
​
// Class representing an item
public class Item
{
    public string Name { get; set; }
    public Rarity Rarity { get; set; }
    public ItemSlot Slot { get; set; }
    public List<ItemStat> Stats { get; set; }
    public int IlvlAverage { get; set; }
​
    public Item(string name, Rarity rarity, ItemSlot slot, List<ItemStat> stats, int ilvlAverage)
    {
        Name = name;
        Rarity = rarity;
        Slot = slot;
        Stats = stats;
        IlvlAverage = ilvlAverage;
    }
​
    public override string ToString()
    {
        string statsStr = string.Join(", ", Stats);
        return $"Name: {Name}, Rarity: {Rarity}, Slot: {Slot}, Stats: [{statsStr}], ilvl Average: {IlvlAverage}";
    }
}
​
// Factory class to create items
public class ItemFactory
{
    private static readonly Dictionary<Rarity, StatRange> rarityStatRanges = new Dictionary<Rarity, StatRange>
    {
        { Rarity.Common, new StatRange(1, 600) },
        { Rarity.Rare, new StatRange(601, 800) },
        { Rarity.Epic, new StatRange(801, 999) },
        { Rarity.Godly, new StatRange(1000, 1000) }
    };
​
    private static readonly int NumberOfStats = 6;
​
    private Random _random;
​
    public ItemFactory()
    {
        _random = new Random();
    }
​
    // Method to generate a random rarity based on probabilities
    public Rarity GenerateRandomRarity()
    {
        // Define rarity probabilities
        // Adjust these probabilities as needed
        double commonProb = 0.6;
        double rareProb = 0.25;
        double epicProb = 0.1;
        double godlyProb = 0.05;
​
        double roll = _random.NextDouble();
        if (roll < commonProb)
            return Rarity.Common;
        else if (roll < commonProb + rareProb)
            return Rarity.Rare;
        else if (roll < commonProb + rareProb + epicProb)
            return Rarity.Epic;
        else
            return Rarity.Godly;
    }
​
    // Method to create an item based on rarity and slot
    public Item CreateItem(Rarity rarity, ItemSlot slot)
    {
        var statRange = rarityStatRanges[rarity];
        List<ItemStat> stats = new List<ItemStat>();
        int total = 0;
​
        for (int i = 0; i < NumberOfStats; i++)
        {
            int statValue = GenerateStatValue(statRange);
            stats.Add(new ItemStat(statValue));
            total += statValue;
        }
​
        int ilvlAverage = total / NumberOfStats;
        string itemName = GenerateItemName(rarity, slot);
​
        return new Item(itemName, rarity, slot, stats, ilvlAverage);
    }
​
    // Helper method to generate a single stat value
    private int GenerateStatValue(StatRange range)
    {
        if (range.Min == range.Max)
            return range.Max;
        return _random.Next(range.Min, range.Max + 1);
    }
​
    // Helper method to generate a simple item name based on rarity and slot
    private string GenerateItemName(Rarity rarity, ItemSlot slot)
    {
        return $"{rarity} {slot} Item";
    }
​
    // Method to generate items for all slots
    public List<Item> OpenChest()
    {
        List<Item> chestItems = new List<Item>();
​
        foreach (ItemSlot slot in Enum.GetValues(typeof(ItemSlot)))
        {
            Rarity rarity = GenerateRandomRarity();
            Item item = CreateItem(rarity, slot);
            chestItems.Add(item);
        }
​
        return chestItems;
    }
}
​
// Class to represent a player’s inventory
public class Inventory
{
    public Dictionary<ItemSlot, Item> EquippedItems { get; set; }
​
    public Inventory()
    {
        EquippedItems = new Dictionary<ItemSlot, Item>();
        // Initialize all slots with null (no item equipped)
        foreach (ItemSlot slot in Enum.GetValues(typeof(ItemSlot)))
        {
            EquippedItems[slot] = null;
        }
    }
​
    // Method to equip multiple items
    public void EquipItems(List<Item> items)
    {
        foreach (var item in items)
        {
            EquipItem(item);
        }
    }
​
    // Method to equip a single item with ilvlAverage comparison
    public void EquipItem(Item newItem)
    {
        if (newItem.Slot == ItemSlot.Ring1 || newItem.Slot == ItemSlot.Ring2)
        {
            EquipRing(newItem);
        }
        else
        {
            EquipSlot(newItem);
        }
    }
​
    // Helper method to equip non-ring items
    private void EquipSlot(Item newItem)
    {
        if (EquippedItems[newItem.Slot] == null)
        {
            // No item equipped in this slot
            EquippedItems[newItem.Slot] = newItem;
            Console.WriteLine($"Equipped {newItem.Name} to {newItem.Slot} (ilvl: {newItem.IlvlAverage})");
        }
        else
        {
            // Compare ilvlAverage
            if (newItem.IlvlAverage > EquippedItems[newItem.Slot].IlvlAverage)
            {
                Console.WriteLine($"Replaced {EquippedItems[newItem.Slot].Name} with {newItem.Name} in {newItem.Slot}");
                EquippedItems[newItem.Slot] = newItem;
            }
            else
            {
                Console.WriteLine($"Kept existing {EquippedItems[newItem.Slot].Name} in {newItem.Slot} over {newItem.Name}");
            }
        }
    }
​
    // Helper method to equip ring items
    private void EquipRing(Item newRing)
    {
        // Check Ring1
        var ring1 = EquippedItems[ItemSlot.Ring1];
        var ring2 = EquippedItems[ItemSlot.Ring2];
​
        if (ring1 == null)
        {
            EquippedItems[ItemSlot.Ring1] = newRing;
            Console.WriteLine($"Equipped {newRing.Name} to Ring1 (ilvl: {newRing.IlvlAverage})");
            return;
        }
​
        if (ring2 == null)
        {
            EquippedItems[ItemSlot.Ring2] = newRing;
            Console.WriteLine($"Equipped {newRing.Name} to Ring2 (ilvl: {newRing.IlvlAverage})");
            return;
        }
​
        // Both rings are equipped; compare ilvlAverage
        if (newRing.IlvlAverage > ring1.IlvlAverage && newRing.IlvlAverage > ring2.IlvlAverage)
        {
            // Replace the lower ilvl ring
            if (ring1.IlvlAverage <= ring2.IlvlAverage)
            {
                Console.WriteLine($"Replaced {ring1.Name} with {newRing.Name} in Ring1");
                EquippedItems[ItemSlot.Ring1] = newRing;
            }
            else
            {
                Console.WriteLine($"Replaced {ring2.Name} with {newRing.Name} in Ring2");
                EquippedItems[ItemSlot.Ring2] = newRing;
            }
        }
        else if (newRing.IlvlAverage > ring1.IlvlAverage)
        {
            Console.WriteLine($"Replaced {ring1.Name} with {newRing.Name} in Ring1");
            EquippedItems[ItemSlot.Ring1] = newRing;
        }
        else if (newRing.IlvlAverage > ring2.IlvlAverage)
        {
            Console.WriteLine($"Replaced {ring2.Name} with {newRing.Name} in Ring2");
            EquippedItems[ItemSlot.Ring2] = newRing;
        }
        else
        {
            Console.WriteLine($"Kept existing rings over {newRing.Name}");
        }
    }
​
    // Method to display equipped items
    public void DisplayEquippedItems()
    {
        foreach (var slot in EquippedItems)
        {
            if (slot.Value != null)
            {
                Console.WriteLine($"{slot.Key}: {slot.Value.Name} (Rarity: {slot.Value.Rarity}, ilvl: {slot.Value.IlvlAverage})");
            }
            else
            {
                Console.WriteLine($"{slot.Key}: None");
            }
        }
    }
​
    // Method to calculate the overall average item level
    public double GetOverallIlvlAverage()
    {
        var equippedItems = EquippedItems.Values.Where(item => item != null);
        if (!equippedItems.Any())
            return 0;
​
        return equippedItems.Average(item => item.IlvlAverage);
    }
​
    // Method to check if a full godly set is equipped
    public bool HasFullGodlySet()
    {
        foreach (ItemSlot slot in Enum.GetValues(typeof(ItemSlot)))
        {
            if (EquippedItems[slot] == null || EquippedItems[slot].Rarity != Rarity.Godly)
                return false;
        }
        return true;
    }
}
​
public class Program
{
    public static void Main()
    {
        ItemFactory factory = new ItemFactory();
        Inventory playerInventory = new Inventory();
        int numberOfChests = 10;
        bool fullGodlySetObtained = false;
​
        for (int i = 1; i <= numberOfChests; i++)
        {
            Console.WriteLine($"Opening Chest {i}...");
            List<Item> chestItems = factory.OpenChest();
​
            // Display items obtained from the chest
            foreach (var item in chestItems)
            {
                Console.WriteLine($" - {item}");
            }
​
            // Equip the items
            Console.WriteLine("Equipping items from the chest...");
            playerInventory.EquipItems(chestItems);
​
            // Check for full godly set
            if (playerInventory.HasFullGodlySet())
            {
                Console.WriteLine("Congratulations! You have equipped a full set of Godly items!");
                fullGodlySetObtained = true;
                break;
            }
​
            Console.WriteLine("-----------------------------");
        }
​
        if (!fullGodlySetObtained)
        {
            Console.WriteLine("You did not obtain a full set of Godly items after opening all chests.");
        }
​
        Console.WriteLine("\nFinal Equipped Items:");
        playerInventory.DisplayEquippedItems();
​
        // Calculate and display the overall average item level
        double overallIlvl = playerInventory.GetOverallIlvlAverage();
        Console.WriteLine($"\nOverall Average Item Level: {overallIlvl:F2}");
    }
}
​

Въведи продукт

Cached Result
Last Run:	9:25:23 am
Compile:	0.116s
Execute:	0.01s
Memory:	32kb
CPU:	0.016s

View IL Code