715 lines
26 KiB
C#
715 lines
26 KiB
C#
using Kryz.CharacterStats.Examples;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
|
|
public class EquippableItemGenerator : MonoBehaviour
|
|
{
|
|
[Header("Generation Settings")]
|
|
public int minStatRolls = 2;
|
|
public int maxStatRolls = 6;
|
|
public float baseStatValue = 10f;
|
|
public float statVariance = 0.3f; // 30% variance
|
|
public float percentStatBaseValue = 0.05f; // 5% base for percent stats
|
|
|
|
// Add this field to your EquippableItemGenerator class
|
|
[Header("Path Mapping")]
|
|
private Dictionary<Sprite, string> spritePathMap = new Dictionary<Sprite, string>();
|
|
|
|
[Header("Stat Roll Weights by Equipment Type")]
|
|
//[SerializeField] private StatWeights armorWeights = new StatWeights();
|
|
//[SerializeField] private StatWeights weaponWeights = new StatWeights();
|
|
|
|
public List<Sprite> HelmetIcons = new List<Sprite>();
|
|
public List<Sprite> ShoulderIcons = new List<Sprite>();
|
|
public List<Sprite> ChestIcons = new List<Sprite>();
|
|
public List<Sprite> BeltIcons = new List<Sprite>();
|
|
public List<Sprite> LegsIcons = new List<Sprite>();
|
|
public List<Sprite> BracersIcons = new List<Sprite>();
|
|
public List<Sprite> GlovesIcons = new List<Sprite>();
|
|
public List<Sprite> BootsIcons = new List<Sprite>();
|
|
public List<Sprite> StaffIcons = new List<Sprite>();
|
|
public List<Sprite> SpearIcons = new List<Sprite>();
|
|
public List<Sprite> ScytheIcons = new List<Sprite>();
|
|
public List<Sprite> HammerIcons = new List<Sprite>();
|
|
public List<Sprite> BowIcons = new List<Sprite>();
|
|
public List<Sprite> CrossbowIcons = new List<Sprite>();
|
|
public List<Sprite> AxeIcons = new List<Sprite>();
|
|
public List<Sprite> SwordIcons = new List<Sprite>();
|
|
public List<Sprite> ShieldIcons = new List<Sprite>();
|
|
public List<Sprite> DaggerIcons = new List<Sprite>();
|
|
public List<Sprite> BookIcons = new List<Sprite>();
|
|
|
|
public enum ItemTier
|
|
{
|
|
Common,
|
|
Uncommon,
|
|
Rare,
|
|
Epic,
|
|
Legendary
|
|
}
|
|
|
|
#region Singleton
|
|
private static EquippableItemGenerator _instance;
|
|
|
|
// Public reference to the singleton instance
|
|
public static EquippableItemGenerator Instance
|
|
{
|
|
get
|
|
{
|
|
// If the instance doesn't exist, try to find it in the scene
|
|
if (_instance == null)
|
|
{
|
|
_instance = FindObjectOfType<EquippableItemGenerator>();
|
|
}
|
|
return _instance;
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
private void Awake()
|
|
{
|
|
UpdateListsFromResources();
|
|
}
|
|
|
|
[ContextMenu("Update Lists From Resources")]
|
|
private void UpdateListsFromResources()
|
|
{
|
|
// Clear existing mappings
|
|
if (spritePathMap == null)
|
|
spritePathMap = new Dictionary<Sprite, string>();
|
|
spritePathMap.Clear();
|
|
|
|
// Armor pieces
|
|
HelmetIcons.Clear();
|
|
Sprite[] helmetSprites = Resources.LoadAll<Sprite>("Armor/Helmets");
|
|
foreach (Sprite sprite in helmetSprites)
|
|
{
|
|
HelmetIcons.Add(sprite);
|
|
spritePathMap[sprite] = $"Armor/Helmets/{sprite.name}";
|
|
}
|
|
|
|
ShoulderIcons.Clear();
|
|
Sprite[] shoulderSprites = Resources.LoadAll<Sprite>("Armor/Shoulders");
|
|
foreach (Sprite sprite in shoulderSprites)
|
|
{
|
|
ShoulderIcons.Add(sprite);
|
|
spritePathMap[sprite] = $"Armor/Shoulders/{sprite.name}";
|
|
}
|
|
|
|
ChestIcons.Clear();
|
|
Sprite[] chestSprites = Resources.LoadAll<Sprite>("Armor/Chests");
|
|
foreach (Sprite sprite in chestSprites)
|
|
{
|
|
ChestIcons.Add(sprite);
|
|
spritePathMap[sprite] = $"Armor/Chests/{sprite.name}";
|
|
}
|
|
|
|
BeltIcons.Clear();
|
|
Sprite[] beltSprites = Resources.LoadAll<Sprite>("Armor/Belts");
|
|
foreach (Sprite sprite in beltSprites)
|
|
{
|
|
BeltIcons.Add(sprite);
|
|
spritePathMap[sprite] = $"Armor/Belts/{sprite.name}";
|
|
}
|
|
|
|
LegsIcons.Clear();
|
|
Sprite[] legsSprites = Resources.LoadAll<Sprite>("Armor/Legs");
|
|
foreach (Sprite sprite in legsSprites)
|
|
{
|
|
LegsIcons.Add(sprite);
|
|
spritePathMap[sprite] = $"Armor/Legs/{sprite.name}";
|
|
}
|
|
|
|
BracersIcons.Clear();
|
|
Sprite[] bracersSprites = Resources.LoadAll<Sprite>("Armor/Bracers");
|
|
foreach (Sprite sprite in bracersSprites)
|
|
{
|
|
BracersIcons.Add(sprite);
|
|
spritePathMap[sprite] = $"Armor/Bracers/{sprite.name}";
|
|
}
|
|
|
|
GlovesIcons.Clear();
|
|
Sprite[] glovesSprites = Resources.LoadAll<Sprite>("Armor/Gloves");
|
|
foreach (Sprite sprite in glovesSprites)
|
|
{
|
|
GlovesIcons.Add(sprite);
|
|
spritePathMap[sprite] = $"Armor/Gloves/{sprite.name}";
|
|
}
|
|
|
|
BootsIcons.Clear();
|
|
Sprite[] bootsSprites = Resources.LoadAll<Sprite>("Armor/Boots");
|
|
foreach (Sprite sprite in bootsSprites)
|
|
{
|
|
BootsIcons.Add(sprite);
|
|
spritePathMap[sprite] = $"Armor/Boots/{sprite.name}";
|
|
}
|
|
|
|
// Two-handed weapons
|
|
StaffIcons.Clear();
|
|
Sprite[] staffSprites = Resources.LoadAll<Sprite>("Weapons/Staffs");
|
|
foreach (Sprite sprite in staffSprites)
|
|
{
|
|
StaffIcons.Add(sprite);
|
|
spritePathMap[sprite] = $"Weapons/Staffs/{sprite.name}";
|
|
}
|
|
|
|
SpearIcons.Clear();
|
|
Sprite[] spearSprites = Resources.LoadAll<Sprite>("Weapons/Spears");
|
|
foreach (Sprite sprite in spearSprites)
|
|
{
|
|
SpearIcons.Add(sprite);
|
|
spritePathMap[sprite] = $"Weapons/Spears/{sprite.name}";
|
|
}
|
|
|
|
ScytheIcons.Clear();
|
|
Sprite[] scytheSprites = Resources.LoadAll<Sprite>("Weapons/Scythes");
|
|
foreach (Sprite sprite in scytheSprites)
|
|
{
|
|
ScytheIcons.Add(sprite);
|
|
spritePathMap[sprite] = $"Weapons/Scythes/{sprite.name}";
|
|
}
|
|
|
|
HammerIcons.Clear();
|
|
Sprite[] hammerSprites = Resources.LoadAll<Sprite>("Weapons/Hammers");
|
|
foreach (Sprite sprite in hammerSprites)
|
|
{
|
|
HammerIcons.Add(sprite);
|
|
spritePathMap[sprite] = $"Weapons/Hammers/{sprite.name}";
|
|
}
|
|
|
|
BowIcons.Clear();
|
|
Sprite[] bowSprites = Resources.LoadAll<Sprite>("Weapons/Bows");
|
|
foreach (Sprite sprite in bowSprites)
|
|
{
|
|
BowIcons.Add(sprite);
|
|
spritePathMap[sprite] = $"Weapons/Bows/{sprite.name}";
|
|
}
|
|
|
|
CrossbowIcons.Clear();
|
|
Sprite[] crossbowSprites = Resources.LoadAll<Sprite>("Weapons/Crossbows");
|
|
foreach (Sprite sprite in crossbowSprites)
|
|
{
|
|
CrossbowIcons.Add(sprite);
|
|
spritePathMap[sprite] = $"Weapons/Crossbows/{sprite.name}";
|
|
}
|
|
|
|
AxeIcons.Clear();
|
|
Sprite[] axeSprites = Resources.LoadAll<Sprite>("Weapons/Axes");
|
|
foreach (Sprite sprite in axeSprites)
|
|
{
|
|
AxeIcons.Add(sprite);
|
|
spritePathMap[sprite] = $"Weapons/Axes/{sprite.name}";
|
|
}
|
|
|
|
// One-handed weapons
|
|
SwordIcons.Clear();
|
|
Sprite[] swordSprites = Resources.LoadAll<Sprite>("Weapons/Swords");
|
|
foreach (Sprite sprite in swordSprites)
|
|
{
|
|
SwordIcons.Add(sprite);
|
|
spritePathMap[sprite] = $"Weapons/Swords/{sprite.name}";
|
|
}
|
|
|
|
ShieldIcons.Clear();
|
|
Sprite[] shieldSprites = Resources.LoadAll<Sprite>("Weapons/Shields");
|
|
foreach (Sprite sprite in shieldSprites)
|
|
{
|
|
ShieldIcons.Add(sprite);
|
|
spritePathMap[sprite] = $"Weapons/Shields/{sprite.name}";
|
|
}
|
|
|
|
DaggerIcons.Clear();
|
|
Sprite[] daggerSprites = Resources.LoadAll<Sprite>("Weapons/Daggers");
|
|
foreach (Sprite sprite in daggerSprites)
|
|
{
|
|
DaggerIcons.Add(sprite);
|
|
spritePathMap[sprite] = $"Weapons/Daggers/{sprite.name}";
|
|
}
|
|
|
|
BookIcons.Clear();
|
|
Sprite[] bookSprites = Resources.LoadAll<Sprite>("Weapons/Books");
|
|
foreach (Sprite sprite in bookSprites)
|
|
{
|
|
BookIcons.Add(sprite);
|
|
spritePathMap[sprite] = $"Weapons/Books/{sprite.name}";
|
|
}
|
|
|
|
Debug.Log($"Updated all icon lists from Resources folders. Loaded {spritePathMap.Count} sprites with paths.");
|
|
}
|
|
|
|
public EquippableItemInstance GenerateEquippableItemInstance()
|
|
{
|
|
EquippableItemInstance generatedItem = new EquippableItemInstance();
|
|
|
|
//Do stuff
|
|
|
|
return generatedItem;
|
|
}
|
|
|
|
[ContextMenu("Generate Random Item To Inventory")]
|
|
private void TestGenerateItemToInventory()
|
|
{
|
|
EquipmentType typeToGenerate = (EquipmentType)Random.Range(0, 10);
|
|
if (typeToGenerate == EquipmentType.Weapon1 || typeToGenerate == EquipmentType.Weapon2)
|
|
{
|
|
WeaponType weaponType = (WeaponType)Random.Range(0, 11);
|
|
Inventory.Instance.AddItem(GenerateWeapon(weaponType, (ItemTier)Random.Range(0, 5), 1));
|
|
}
|
|
else
|
|
{
|
|
Inventory.Instance.AddItem(GenerateEquippableItemInstance(typeToGenerate, (ItemTier)Random.Range(0, 5), 1));
|
|
}
|
|
}
|
|
|
|
public EquippableItemInstance GenerateEquippableItemInstance(EquipmentType equipmentType, ItemTier tier = ItemTier.Common, int playerLevel = 1)
|
|
{
|
|
EquippableItemInstance item = new EquippableItemInstance();
|
|
|
|
// Set basic properties
|
|
item.EquipmentType = equipmentType;
|
|
item.ItemName = GenerateItemName(equipmentType, tier);
|
|
item.Icon = GetRandomIcon(equipmentType, item);
|
|
Debug.Log("Generated: " + item.ItemName + " icon " + item.Icon.name);
|
|
|
|
// Set weapon type if it's a weapon
|
|
if (equipmentType == EquipmentType.Weapon1 || equipmentType == EquipmentType.Weapon2)
|
|
{
|
|
item.WeaponType = GetRandomWeaponType();
|
|
}
|
|
|
|
// Generate stats based on tier and level
|
|
GenerateStatsForItem(item, tier, playerLevel);
|
|
Debug.Log("Generated: " + item.ItemName + " icon " + item.Icon.name);
|
|
return item;
|
|
}
|
|
|
|
// Generate weapon by weapon type (recommended approach)
|
|
public EquippableItemInstance GenerateWeapon(WeaponType weaponType, ItemTier tier = ItemTier.Common, int playerLevel = 1)
|
|
{
|
|
EquippableItemInstance item = new EquippableItemInstance();
|
|
|
|
// All weapons use Weapon1 as default - the equipment system handles slot assignment
|
|
item.EquipmentType = EquipmentType.Weapon1;
|
|
item.WeaponType = weaponType;
|
|
item.ItemName = GenerateWeaponName(weaponType, tier);
|
|
item.Icon = GetWeaponIcon(weaponType, item);
|
|
Debug.Log("Generated: " + item.ItemName + " icon " + item.Icon.name);
|
|
|
|
GenerateStatsForItem(item, tier, playerLevel);
|
|
|
|
Debug.Log("Generated: " + item.ItemName + " icon " + item.Icon.name);
|
|
|
|
return item;
|
|
}
|
|
|
|
// Alternative: Let caller specify which slot they want
|
|
public EquippableItemInstance GenerateWeapon(WeaponType weaponType, EquipmentType weaponSlot, ItemTier tier = ItemTier.Common, int playerLevel = 1)
|
|
{
|
|
if (weaponSlot != EquipmentType.Weapon1 && weaponSlot != EquipmentType.Weapon2)
|
|
weaponSlot = EquipmentType.Weapon1; // Default fallback
|
|
|
|
EquippableItemInstance item = new EquippableItemInstance();
|
|
|
|
item.EquipmentType = weaponSlot;
|
|
item.WeaponType = weaponType;
|
|
item.ItemName = GenerateWeaponName(weaponType, tier);
|
|
item.Icon = GetWeaponIcon(weaponType, item);
|
|
|
|
GenerateStatsForItem(item, tier, playerLevel);
|
|
|
|
return item;
|
|
}
|
|
|
|
private void GenerateStatsForItem(EquippableItemInstance item, ItemTier tier, int playerLevel)
|
|
{
|
|
// Determine number of stats based on tier
|
|
int statCount = GetStatCountForTier(tier);
|
|
float levelMultiplier = 1f + (playerLevel - 1) * 0.1f; // 10% increase per level
|
|
float tierMultiplier = GetTierMultiplier(tier);
|
|
|
|
// Get appropriate stat weights
|
|
//StatWeights weights = item.IsWeapon ? weaponWeights : armorWeights;
|
|
|
|
// Roll stats
|
|
HashSet<string> rolledStats = new HashSet<string>();
|
|
for (int i = 0; i < statCount; i++)
|
|
{
|
|
//RollRandomStat(item, weights, rolledStats, levelMultiplier * tierMultiplier);
|
|
}
|
|
}
|
|
|
|
private int GetStatCountForTier(ItemTier tier)
|
|
{
|
|
return tier switch
|
|
{
|
|
ItemTier.Common => Random.Range(1, 3),
|
|
ItemTier.Uncommon => Random.Range(2, 4),
|
|
ItemTier.Rare => Random.Range(3, 5),
|
|
ItemTier.Epic => Random.Range(4, 6),
|
|
ItemTier.Legendary => Random.Range(5, 7),
|
|
_ => 2
|
|
};
|
|
}
|
|
|
|
private float GetTierMultiplier(ItemTier tier)
|
|
{
|
|
return tier switch
|
|
{
|
|
ItemTier.Common => 1f,
|
|
ItemTier.Uncommon => 1.3f,
|
|
ItemTier.Rare => 1.7f,
|
|
ItemTier.Epic => 2.2f,
|
|
ItemTier.Legendary => 3f,
|
|
_ => 1f
|
|
};
|
|
}
|
|
|
|
private void RollRandomStat(EquippableItemInstance item, /*StatWeights weights*/ HashSet<string> rolledStats, float multiplier)
|
|
{
|
|
// Create weighted list of available stats
|
|
List<(string stat, float weight)> availableStats = new List<(string, float)>();
|
|
|
|
/* // Add damage stats if not already rolled
|
|
if (!rolledStats.Contains("AttackDamage"))
|
|
availableStats.Add(("AttackDamage", weights.attackDamage));
|
|
if (!rolledStats.Contains("SpellDamage"))
|
|
availableStats.Add(("SpellDamage", weights.spellDamage));
|
|
if (!rolledStats.Contains("CritChance"))
|
|
availableStats.Add(("CritChance", weights.critChance));
|
|
if (!rolledStats.Contains("CritDamage"))
|
|
availableStats.Add(("CritDamage", weights.critDamage));
|
|
|
|
// Add defensive stats
|
|
if (!rolledStats.Contains("MaxHealth"))
|
|
availableStats.Add(("MaxHealth", weights.maxHealth));
|
|
if (!rolledStats.Contains("Armor"))
|
|
availableStats.Add(("Armor", weights.armor));
|
|
if (!rolledStats.Contains("MagicResistance"))
|
|
availableStats.Add(("MagicResistance", weights.magicResistance));
|
|
if (!rolledStats.Contains("DodgeChance"))
|
|
availableStats.Add(("DodgeChance", weights.dodgeChance));
|
|
if (!rolledStats.Contains("BlockChance"))
|
|
availableStats.Add(("BlockChance", weights.blockChance));
|
|
if (!rolledStats.Contains("BlockEffectiveness"))
|
|
availableStats.Add(("BlockEffectiveness", weights.blockEffectiveness));
|
|
|
|
// Add resource stats
|
|
if (!rolledStats.Contains("HealthRegen"))
|
|
availableStats.Add(("HealthRegen", weights.healthRegen));
|
|
if (!rolledStats.Contains("MaxMana"))
|
|
availableStats.Add(("MaxMana", weights.maxMana));
|
|
if (!rolledStats.Contains("ManaRegen"))
|
|
availableStats.Add(("ManaRegen", weights.manaRegen));
|
|
|
|
// Add utility stats
|
|
if (!rolledStats.Contains("AttackSpeed"))
|
|
availableStats.Add(("AttackSpeed", weights.attackSpeed));
|
|
if (!rolledStats.Contains("AreaEffectiveness"))
|
|
availableStats.Add(("AreaEffectiveness", weights.areaEffectiveness));
|
|
if (!rolledStats.Contains("CooldownReduction"))
|
|
availableStats.Add(("CooldownReduction", weights.cooldownReduction));
|
|
if (!rolledStats.Contains("MovementSpeed"))
|
|
availableStats.Add(("MovementSpeed", weights.movementSpeed));
|
|
if (!rolledStats.Contains("ReputationGain"))
|
|
availableStats.Add(("ReputationGain", weights.reputationGain));
|
|
if (!rolledStats.Contains("GoldCostReduction"))
|
|
availableStats.Add(("GoldCostReduction", weights.goldCostReduction));*/
|
|
|
|
if (availableStats.Count == 0) return;
|
|
|
|
// Weighted random selection
|
|
string selectedStat = SelectWeightedRandom(availableStats);
|
|
rolledStats.Add(selectedStat);
|
|
|
|
// Apply the stat
|
|
ApplyStatToItem(item, selectedStat, multiplier);
|
|
}
|
|
|
|
private string SelectWeightedRandom(List<(string stat, float weight)> weightedStats)
|
|
{
|
|
float totalWeight = 0f;
|
|
foreach (var stat in weightedStats)
|
|
totalWeight += stat.weight;
|
|
|
|
float randomValue = Random.Range(0f, totalWeight);
|
|
float currentWeight = 0f;
|
|
|
|
foreach (var stat in weightedStats)
|
|
{
|
|
currentWeight += stat.weight;
|
|
if (randomValue <= currentWeight)
|
|
return stat.stat;
|
|
}
|
|
|
|
return weightedStats[0].stat; // Fallback
|
|
}
|
|
|
|
private void ApplyStatToItem(EquippableItemInstance item, string statName, float multiplier)
|
|
{
|
|
// Decide between flat or percent bonus (roughly 60% flat, 40% percent)
|
|
bool usePercent = Random.value < 0.4f;
|
|
|
|
switch (statName)
|
|
{
|
|
case "AttackDamage":
|
|
if (usePercent)
|
|
item.AttackDamagePercentBonus = GeneratePercentStat(multiplier);
|
|
else
|
|
item.AttackDamageBonus = GenerateFlatStat(multiplier);
|
|
break;
|
|
|
|
case "SpellDamage":
|
|
if (usePercent)
|
|
item.SpellDamagePercentBonus = GeneratePercentStat(multiplier);
|
|
else
|
|
item.SpellDamageBonus = GenerateFlatStat(multiplier);
|
|
break;
|
|
|
|
case "CritChance":
|
|
if (usePercent)
|
|
item.CritChancePercentBonus = GeneratePercentStat(multiplier * 0.3f); // Lower values for crit
|
|
else
|
|
item.CritChanceBonus = Mathf.RoundToInt(GenerateFlatStat(multiplier * 0.5f));
|
|
break;
|
|
|
|
case "CritDamage":
|
|
if (usePercent)
|
|
item.CritDamagePercentBonus = GeneratePercentStat(multiplier * 0.5f);
|
|
else
|
|
item.CritDamageBonus = Mathf.RoundToInt(GenerateFlatStat(multiplier * 0.8f));
|
|
break;
|
|
|
|
case "MaxHealth":
|
|
if (usePercent)
|
|
item.MaxHealthPercentBonus = GeneratePercentStat(multiplier);
|
|
else
|
|
item.MaxHealthBonus = Mathf.RoundToInt(GenerateFlatStat(multiplier * 5f)); // Health gets higher flat values
|
|
break;
|
|
|
|
case "Armor":
|
|
if (usePercent)
|
|
item.ArmorPercentBonus = GeneratePercentStat(multiplier);
|
|
else
|
|
item.ArmorBonus = Mathf.RoundToInt(GenerateFlatStat(multiplier));
|
|
break;
|
|
|
|
case "MagicResistance":
|
|
if (usePercent)
|
|
item.MagicResistancePercentBonus = GeneratePercentStat(multiplier);
|
|
else
|
|
item.MagicResistanceBonus = Mathf.RoundToInt(GenerateFlatStat(multiplier));
|
|
break;
|
|
|
|
case "DodgeChance":
|
|
item.DodgeChancePercentBonus = GeneratePercentStat(multiplier * 0.4f); // Always percent
|
|
break;
|
|
|
|
case "BlockChance":
|
|
item.BlockChancePercentBonus = GeneratePercentStat(multiplier * 0.4f); // Always percent
|
|
break;
|
|
|
|
case "BlockEffectiveness":
|
|
item.BlockEffectivenessPercentBonus = GeneratePercentStat(multiplier * 0.6f); // Always percent
|
|
break;
|
|
|
|
case "AttackSpeed":
|
|
item.AttackSpeedPercentBonus = GeneratePercentStat(multiplier * 0.6f); // Always percent
|
|
break;
|
|
|
|
case "HealthRegen":
|
|
if (usePercent)
|
|
item.HealthRegenPercentBonus = GeneratePercentStat(multiplier);
|
|
else
|
|
item.HealthRegenBonus = Mathf.RoundToInt(GenerateFlatStat(multiplier * 2f));
|
|
break;
|
|
|
|
case "MaxMana":
|
|
if (usePercent)
|
|
item.MaxManaPercentBonus = GeneratePercentStat(multiplier);
|
|
else
|
|
item.MaxManaBonus = Mathf.RoundToInt(GenerateFlatStat(multiplier * 3f));
|
|
break;
|
|
|
|
case "ManaRegen":
|
|
if (usePercent)
|
|
item.ManaRegenPercentBonus = GeneratePercentStat(multiplier);
|
|
else
|
|
item.ManaRegenBonus = Mathf.RoundToInt(GenerateFlatStat(multiplier * 2f));
|
|
break;
|
|
|
|
case "AreaEffectiveness":
|
|
item.AreaEffectivenessPercentBonus = GeneratePercentStat(multiplier * 0.5f); // Always percent
|
|
break;
|
|
|
|
case "CooldownReduction":
|
|
item.CooldownReductionPercentBonus = GeneratePercentStat(multiplier * 0.4f); // Always percent
|
|
break;
|
|
|
|
case "MovementSpeed":
|
|
item.MovementSpeedPercentBonus = GeneratePercentStat(multiplier * 0.3f); // Always percent
|
|
break;
|
|
|
|
case "ReputationGain":
|
|
item.ReputationGainIncreasePercentBonus = GeneratePercentStat(multiplier * 0.6f); // Always percent
|
|
break;
|
|
|
|
case "GoldCostReduction":
|
|
item.GoldCostReductionPercentBonus = GeneratePercentStat(multiplier * 0.5f); // Always percent
|
|
break;
|
|
}
|
|
}
|
|
|
|
private int GenerateFlatStat(float multiplier)
|
|
{
|
|
float baseValue = baseStatValue * multiplier;
|
|
float variance = baseValue * statVariance;
|
|
float finalValue = Random.Range(baseValue - variance, baseValue + variance);
|
|
return Mathf.Max(1, Mathf.RoundToInt(finalValue));
|
|
}
|
|
|
|
private float GeneratePercentStat(float multiplier)
|
|
{
|
|
float baseValue = percentStatBaseValue * multiplier;
|
|
float variance = baseValue * statVariance;
|
|
float finalValue = Random.Range(baseValue - variance, baseValue + variance);
|
|
return Mathf.Max(0.01f, Mathf.Round(finalValue * 1000f) / 1000f); // Round to 3 decimal places
|
|
}
|
|
|
|
private string GenerateItemName(EquipmentType equipmentType, ItemTier tier)
|
|
{
|
|
string[] tierPrefixes = tier switch
|
|
{
|
|
ItemTier.Common => new[] { "", "Simple", "Basic" },
|
|
ItemTier.Uncommon => new[] { "Fine", "Quality", "Enhanced" },
|
|
ItemTier.Rare => new[] { "Superior", "Masterwork", "Refined" },
|
|
ItemTier.Epic => new[] { "Exceptional", "Legendary", "Mythic" },
|
|
ItemTier.Legendary => new[] { "Divine", "Ancient", "Celestial" },
|
|
_ => new[] { "" }
|
|
};
|
|
|
|
string prefix = tierPrefixes[Random.Range(0, tierPrefixes.Length)];
|
|
string baseName = equipmentType.ToString();
|
|
|
|
return string.IsNullOrEmpty(prefix) ? baseName : $"{prefix} {baseName}";
|
|
}
|
|
|
|
private string GenerateWeaponName(WeaponType weaponType, ItemTier tier)
|
|
{
|
|
string[] tierPrefixes = tier switch
|
|
{
|
|
ItemTier.Common => new[] { "", "Simple", "Basic" },
|
|
ItemTier.Uncommon => new[] { "Fine", "Quality", "Enhanced" },
|
|
ItemTier.Rare => new[] { "Superior", "Masterwork", "Refined" },
|
|
ItemTier.Epic => new[] { "Exceptional", "Legendary", "Mythic" },
|
|
ItemTier.Legendary => new[] { "Divine", "Ancient", "Celestial" },
|
|
_ => new[] { "" }
|
|
};
|
|
|
|
string prefix = tierPrefixes[Random.Range(0, tierPrefixes.Length)];
|
|
string baseName = weaponType.ToString();
|
|
|
|
return string.IsNullOrEmpty(prefix) ? baseName : $"{prefix} {baseName}";
|
|
}
|
|
|
|
// Update your icon selection methods to store the path
|
|
private Sprite GetRandomIcon(EquipmentType equipmentType, EquippableItemInstance item)
|
|
{
|
|
List<Sprite> iconList = equipmentType switch
|
|
{
|
|
EquipmentType.Helmet => HelmetIcons,
|
|
EquipmentType.Shoulder => ShoulderIcons,
|
|
EquipmentType.Chest => ChestIcons,
|
|
EquipmentType.Belt => BeltIcons,
|
|
EquipmentType.Legs => LegsIcons,
|
|
EquipmentType.Bracers => BracersIcons,
|
|
EquipmentType.Gloves => GlovesIcons,
|
|
EquipmentType.Boots => BootsIcons,
|
|
EquipmentType.Weapon1 => null, // Will be handled by weapon type
|
|
EquipmentType.Weapon2 => null, // Will be handled by weapon type
|
|
_ => null
|
|
};
|
|
|
|
if (iconList != null && iconList.Count > 0)
|
|
{
|
|
Sprite selectedSprite = iconList[Random.Range(0, iconList.Count)];
|
|
|
|
// Store the path in the item
|
|
if (spritePathMap.TryGetValue(selectedSprite, out string path))
|
|
{
|
|
item.IconPath = path;
|
|
}
|
|
|
|
return selectedSprite;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private Sprite GetWeaponIcon(WeaponType weaponType, EquippableItemInstance item)
|
|
{
|
|
List<Sprite> iconList = weaponType switch
|
|
{
|
|
WeaponType.Staff => StaffIcons,
|
|
WeaponType.Spear => SpearIcons,
|
|
WeaponType.Scythe => ScytheIcons,
|
|
WeaponType.Hammer => HammerIcons,
|
|
WeaponType.Bow => BowIcons,
|
|
WeaponType.Crossbow => CrossbowIcons,
|
|
WeaponType.Axe => AxeIcons,
|
|
WeaponType.Sword => SwordIcons,
|
|
WeaponType.Shield => ShieldIcons,
|
|
WeaponType.Dagger => DaggerIcons,
|
|
WeaponType.Book => BookIcons,
|
|
_ => SwordIcons
|
|
};
|
|
|
|
if (iconList != null && iconList.Count > 0)
|
|
{
|
|
Sprite selectedSprite = iconList[Random.Range(0, iconList.Count)];
|
|
|
|
// Store the path in the item
|
|
if (spritePathMap.TryGetValue(selectedSprite, out string path))
|
|
{
|
|
item.IconPath = path;
|
|
}
|
|
|
|
return selectedSprite;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private WeaponType GetRandomWeaponType()
|
|
{
|
|
// Return any weapon type
|
|
System.Array allTypes = System.Enum.GetValues(typeof(WeaponType));
|
|
return (WeaponType)allTypes.GetValue(Random.Range(0, allTypes.Length));
|
|
}
|
|
|
|
private void GenerateHelmet(EquippableItemInstance item)
|
|
{
|
|
|
|
}
|
|
|
|
private void RollDamageStats(EquippableItemInstance item)
|
|
{
|
|
int addedDamageStats = 0;
|
|
}
|
|
private void RollOffensiveStats(EquippableItemInstance item)
|
|
{
|
|
int addedOffensiveStats = 0;
|
|
|
|
}
|
|
private void RollDefensiveStats(EquippableItemInstance item)
|
|
{
|
|
int addedDefensiveStats = 0;
|
|
}
|
|
private void RollResourceStats(EquippableItemInstance item)
|
|
{
|
|
int addedResourceStats = 0;
|
|
}
|
|
private void RollControlStats(EquippableItemInstance item)
|
|
{
|
|
int addedControlStats = 0;
|
|
}
|
|
} |