RVAMP | C# Online Compiler

RVAMP by Sincitys

using UnityEngine;
using UnityEngine.EventSystems;

public class ClickDebug : MonoBehaviour
{
    void Update()
    {
        // Don't process clicks if over UI
        if (EventSystem.current.IsPointerOverGameObject())
        {
            return;
        }

        if (Input.GetMouseButtonDown(0)) // Left mouse button
        {
            Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
            RaycastHit hit;

            if (Physics.Raycast(ray, out hit))
            {
                Debug.Log($"Hit object: {hit.collider.gameObject.name} on layer: {LayerMask.LayerToName(hit.collider.gameObject.layer)}");

                // Check for ItemPickup
                ItemPickup itemPickup = hit.collider.GetComponent<ItemPickup>();
                if (itemPickup != null)
                {
                    Debug.Log($"Found ItemPickup: {itemPickup.item.itemName}");
                }
                else
                {
                    // Check for ResourceNode
                    ResourceNode resourceNode = hit.collider.GetComponent<ResourceNode>();
                    if (resourceNode != null)
                    {
                        Debug.Log($"Found ResourceNode: {resourceNode.nodeName}");
                    }
                    else
                    {
                        Debug.Log("No interactable component on this object");
                    }
                }
            }
        }
    }
}
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.EventSystems;

public class ClickIndicator : MonoBehaviour
{
    public GameObject clickMarkerPrefab;
    public Canvas canvas;
    public float markerLifetime = 0.5f;
    public LayerMask clickableLayers;
    public LayerMask groundLayer;

    private Camera mainCamera;

    private void Start()
    {
        mainCamera = Camera.main;
        if (canvas == null)
        {
            Debug.LogError("Canvas is not assigned in ClickIndicator script!");
        }
    }

    private void Update()
    {
        if (Input.GetMouseButtonDown(0))
        {
            if (EventSystem.current != null && EventSystem.current.IsPointerOverGameObject())
            {
                return;
            }

            Ray ray = mainCamera.ScreenPointToRay(Input.mousePosition);
            RaycastHit hit;

            if (Physics.Raycast(ray, out hit, Mathf.Infinity, clickableLayers))
            {
                // If we hit a clickable object, don't show marker
                return;
            }

            // Check if we hit the ground
            if (Physics.Raycast(ray, out hit, Mathf.Infinity, groundLayer))
            {
                CreateClickMarker(hit.point);
            }
        }
    }

    private void CreateClickMarker(Vector3 worldPosition)
    {
        GameObject marker = Instantiate(clickMarkerPrefab, canvas.transform);
        
        Vector2 screenPoint = mainCamera.WorldToScreenPoint(worldPosition);
        RectTransformUtility.ScreenPointToLocalPointInRectangle(
            canvas.GetComponent<RectTransform>(),
            screenPoint,
            canvas.worldCamera,
            out Vector2 localPoint
        );

        RectTransform markerRect = marker.GetComponent<RectTransform>();
        markerRect.localPosition = localPoint;
        Destroy(marker, markerLifetime);
    }
}
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.EventSystems;

public class ClickToMove : MonoBehaviour
{
    [Header("Movement Settings")]
    private NavMeshAgent navMeshAgent;
    public GameObject destinationMarkerPrefab;
    private GameObject destinationMarker;
    public float interactionRange = 1f;

    [Header("Layer Settings")]
    public LayerMask clickableLayers;
    public LayerMask groundLayer;

    private ResourceNode targetResourceNode;
    private Woodcutting woodcuttingSkill;
    private Mining miningSkill;
    private CombatHandler combatHandler;
    private bool isMovingToDestination = false;
    private bool isContextMenuMove = false;

    private void Start() //test
    {
        navMeshAgent = GetComponent<NavMeshAgent>();
        woodcuttingSkill = GetComponent<Woodcutting>();
        miningSkill = GetComponent<Mining>();
        combatHandler = GetComponent<CombatHandler>();
        InitializeDestinationMarker();

        Debug.Log($"ClickToMove initialized. NavMeshAgent: {navMeshAgent != null}, Ground Layer: {LayerMask.LayerToName(groundLayer)}");
    }

    private void InitializeDestinationMarker()
    {
        if (destinationMarkerPrefab != null)
        {
            destinationMarker = Instantiate(destinationMarkerPrefab);
            destinationMarker.SetActive(false);
        }
    }

    private void Update()
    {
        if (EventSystem.current != null && EventSystem.current.IsPointerOverGameObject())
            return;

        if (combatHandler != null && combatHandler.InCombat)
        {
            HideDestinationMarker();
            return;
        }

        if (Input.GetMouseButtonDown(0))
            HandleMouseClick();

        if (targetResourceNode != null)
            CheckResourceProximity();

        CheckDestinationReached();
    }

private void HandleMouseClick()
{
    Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
    RaycastHit hit;

    // First check for interactable objects
    if (Physics.Raycast(ray, out hit, Mathf.Infinity, clickableLayers))
    {
        Debug.Log($"Clicked on object: {hit.collider.gameObject.name} on layer: {LayerMask.LayerToName(hit.collider.gameObject.layer)}");
        
        // Don't stop movement for WorldInteractable objects since they handle their own interactions
        WorldInteractable interactable = hit.collider.GetComponent<WorldInteractable>();
        if (interactable != null)
        {
            return;
        }

        StopMovementAndActions();
        ResourceNode resourceNode = hit.collider.GetComponent<ResourceNode>();
        if (resourceNode != null)
        {
            targetResourceNode = resourceNode;
            MoveToPosition(hit.point);
            return;
        }
    }

    // Then check for ground movement
    if (Physics.Raycast(ray, out hit, Mathf.Infinity, groundLayer))
    {
        Debug.Log($"Clicked on ground at position: {hit.point}");
        StopMovementAndActions();
        targetResourceNode = null;
        MoveToPosition(hit.point);
    }
}

private void MoveToPosition(Vector3 position)
{
    if (navMeshAgent == null) 
    {
        Debug.LogError("NavMeshAgent is null!");
        return;
    }

    // Sample a valid position on the NavMesh
    if (NavMesh.SamplePosition(position, out NavMeshHit navHit, 2f, NavMesh.AllAreas))
    {
        Debug.Log($"Moving to position: {navHit.position}");
        
        // Set stopping distance based on whether we're moving to a resource or just walking
        navMeshAgent.stoppingDistance = targetResourceNode != null ? interactionRange : 0.1f;
        
        navMeshAgent.SetDestination(navHit.position);
        isMovingToDestination = true;

        // Show destination marker
        if (destinationMarker != null)
        {
            destinationMarker.transform.position = navHit.position + new Vector3(0, 0.1f, 0); // Slight offset to prevent z-fighting
            destinationMarker.SetActive(true);
        }
    }
    else
    {
        Debug.LogWarning("Could not find valid NavMesh position!");
    }
}

private void CheckResourceProximity()
{
    if (targetResourceNode == null || !targetResourceNode.IsValidForGathering()) 
    {
        StopMovementAndActions();
        return;
    }

    float distanceToResource = Vector3.Distance(transform.position, targetResourceNode.transform.position);
    if (distanceToResource <= interactionRange)
    {
        navMeshAgent.isStopped = true;
        AttemptGather();
        HideDestinationMarker();
    }
}

private void CheckDestinationReached()
{
    if (!isMovingToDestination || navMeshAgent.pathStatus == NavMeshPathStatus.PathInvalid)
        return;

    if (!navMeshAgent.pathPending)
    {
        if (navMeshAgent.remainingDistance <= navMeshAgent.stoppingDistance)
        {
            if (!navMeshAgent.hasPath || navMeshAgent.velocity.sqrMagnitude == 0f)
            {
                isMovingToDestination = false;
                HideDestinationMarker();
            }
        }
    }
}

    private void AttemptGather()
    {
        if (targetResourceNode is ChoppableTree && woodcuttingSkill != null)
        {
            woodcuttingSkill.SetTarget(targetResourceNode);
        }
        else if (targetResourceNode is MineableRock && miningSkill != null)
        {
            miningSkill.SetTarget(targetResourceNode);
        }
    }

    public void StopMovementAndActions()
    {
        if (navMeshAgent != null)
        {
            navMeshAgent.ResetPath();
        }
        
        targetResourceNode = null;
        HideDestinationMarker();
        woodcuttingSkill?.StopAction();
        miningSkill?.StopAction();
    }

    private void HideDestinationMarker()
    {
        if (destinationMarker != null)
            destinationMarker.SetActive(false);
        isMovingToDestination = false;
    }

    public void MoveToTarget(Vector3 targetPosition, bool fromContextMenu = false)
    {
        StopMovementAndActions();
        isContextMenuMove = fromContextMenu;
        MoveToPosition(targetPosition);
    }

    private void OnDrawGizmosSelected()
    {
        // Visualize the interaction range
        Gizmos.color = Color.yellow;
        Gizmos.DrawWireSphere(transform.position, interactionRange);
    }

    public bool IsGatheringInProgress()
    {
        return (woodcuttingSkill != null && woodcuttingSkill.IsPerformingAction) ||
               (miningSkill != null && miningSkill.IsPerformingAction);
    }
}
using UnityEngine;

[System.Serializable]
public class CombatBonuses
{
    // Attack Bonuses
    public int stabAttack;
    public int slashAttack;
    public int crushAttack;
    public int spellweavingAttack;
    public int rangeAttack;

    // Defense Bonuses
    public int stabDefense;
    public int slashDefense;
    public int crushDefense;
    public int spellweavingDefense;
    public int rangeDefense;

    // Other Combat Bonuses
    public int mightBonus;          // Previously strengthBonus
    public int rangeStrengthBonus;
    public int spellweavingDamage;
    public int divinityBonus;

    // Combat Properties
    public float attackSpeed = 2.4f;  // Base attack speed in seconds
    public AttackStyle attackStyle;   // The weapon's attack style

    public CombatBonuses()
    {
        // Initialize all values to 0
        ResetBonuses();
    }

    public void ResetBonuses()
    {
        stabAttack = 0;
        slashAttack = 0;
        crushAttack = 0;
        spellweavingAttack = 0;
        rangeAttack = 0;

        stabDefense = 0;
        slashDefense = 0;
        crushDefense = 0;
        spellweavingDefense = 0;
        rangeDefense = 0;

        mightBonus = 0;
        rangeStrengthBonus = 0;
        spellweavingDamage = 0;
        divinityBonus = 0;
    }

    // Get the attack bonus for a specific style
    public int GetAttackBonus(AttackStyle style)
    {
        return style switch
        {
            AttackStyle.Stab => stabAttack,
            AttackStyle.Slash => slashAttack,
            AttackStyle.Crush => crushAttack,
            AttackStyle.Spellweaving => spellweavingAttack,
            AttackStyle.Range => rangeAttack,
            _ => 0
        };
    }

    // Get the defense bonus for a specific style
    public int GetDefenseBonus(AttackStyle style)
    {
        return style switch
        {
            AttackStyle.Stab => stabDefense,
            AttackStyle.Slash => slashDefense,
            AttackStyle.Crush => crushDefense,
            AttackStyle.Spellweaving => spellweavingDefense,
            AttackStyle.Range => rangeDefense,
            _ => 0
        };
    }
}

// Attack styles enum
public enum AttackStyle
{
    None,
    Stab,
    Slash,
    Crush,
    Spellweaving,
    Range
}

// Training styles enum for combat skills
public enum CombatTrainingStyle
{
    Precision,    // Previously Attack
    Might,        // Previously Strength
    Fortitude,    // Previously Defence
    Balanced     // Trains both primary and Fortitude
}
using UnityEngine;

public static class CombatCalculator
{
    private const float MIN_PLAYER_HIT = 10f;
    private const float COMBAT_TRIANGLE_BONUS = 1.5f;
    private const float COMBAT_TRIANGLE_PENALTY = 0.6f;

    public static float CalculateAccuracy(ICombatant attacker, ICombatant defender, WeaponAttackStyle style)
    {
        float attackerRoll = CalculateAttackRoll(attacker, style);
        float defenderRoll = CalculateDefenceRoll(defender, attacker.GetCurrentCombatStyle());
        
        float triangleMultiplier = GetCombatTriangleMultiplier(
            attacker.GetCurrentCombatStyle(), 
            defender.GetCurrentCombatStyle()
        );
        
        float finalAccuracy = (attackerRoll * triangleMultiplier) / 
            (attackerRoll * triangleMultiplier + defenderRoll);
            
        return Mathf.Clamp01(finalAccuracy);
    }

    private static float CalculateAttackRoll(ICombatant attacker, WeaponAttackStyle style)
    {
        CombatStats stats = attacker.Stats;
        float effectiveLevel = stats.GetAttackSkillLevel(style.attackStyle);
        float equipmentBonus = stats.combatBonuses.GetAttackBonus(style.attackStyle);
        
        return effectiveLevel * (1 + equipmentBonus/100f) * style.accuracyModifier;
    }

    private static float CalculateDefenceRoll(ICombatant defender, AttackStyle attackStyle)
    {
        CombatStats stats = defender.Stats;
        float fortitudeLevel = stats.Fortitude;
        float defenseBonus = stats.GetDefenseBonus(attackStyle);
        
        return fortitudeLevel * (1 + defenseBonus/100f);
    }

    public static int CalculateDamage(ICombatant attacker, bool isPlayerAttacking)
    {
        int maxHit = attacker.Stats.CalculateMaxHit(attacker.GetCurrentCombatStyle());
        float randomFactor = Random.value;

        if (isPlayerAttacking)
        {
            return Mathf.Max(
                (int)MIN_PLAYER_HIT, 
                Mathf.FloorToInt(MIN_PLAYER_HIT + (maxHit - MIN_PLAYER_HIT) * randomFactor)
            );
        }

        return Mathf.FloorToInt(maxHit * randomFactor);
    }

    private static float GetCombatTriangleMultiplier(AttackStyle attackerStyle, AttackStyle defenderStyle)
    {
        if ((attackerStyle == AttackStyle.Spellweaving && defenderStyle == AttackStyle.Range) ||
            (attackerStyle == AttackStyle.Range && defenderStyle == AttackStyle.Stab) ||
            (attackerStyle == AttackStyle.Stab && defenderStyle == AttackStyle.Spellweaving))
        {
            return COMBAT_TRIANGLE_BONUS;
        }
        
        if ((attackerStyle == AttackStyle.Range && defenderStyle == AttackStyle.Spellweaving) ||
            (attackerStyle == AttackStyle.Stab && defenderStyle == AttackStyle.Range) ||
            (attackerStyle == AttackStyle.Spellweaving && defenderStyle == AttackStyle.Stab))
        {
            return COMBAT_TRIANGLE_PENALTY;
        }
        
        return 1f;
    }
}
using UnityEngine;

[CreateAssetMenu(fileName = "New Combat Config", menuName = "Combat/Combat Configuration")]
public class CombatConfig : ScriptableObject
{
   [System.Serializable]
   public class WeaponStyle
   {
       public string styleName;
       public AttackStyle attackStyle;
       public CombatTrainingStyle trainingStyle;
       public bool splitXPWithFortitude;
       [Range(0f, 2f)]
       public float accuracyModifier = 1f;
       [Range(0f, 2f)]
       public float damageModifier = 1f;
       [Range(1f, 10f)]
       public float experienceMultiplier = 4f;
   }

   [Header("Primary Combat Configuration")]
   public WeaponStyle primaryStyle;
   public float baseAttackInterval = 2.4f;
   public float weaponSpeedModifier = 1f;

   [Header("Combat Experience Settings")]
   public float vitalityXPMultiplier = 1.33f;
   public float vitalityXPPerDamage = 50.54f;

   [Header("Combat Triangle Settings")]
   public float strongAgainstMultiplier = 1.5f;
   public float weakAgainstMultiplier = 0.6f;

   [Header("Base Combat Settings")]
   public int minimumHit = 10;
   public float baseRegenRate = 0.01f;
   public float maxAccuracy = 0.99f;

   public float GetAttackInterval() => baseAttackInterval * weaponSpeedModifier;

   public float CalculateVitalityXP(float damageDealt, AttackStyle style)
   {
       float xpMultiplier = style switch
       {
           AttackStyle.Stab or AttackStyle.Slash or AttackStyle.Crush => 0.25f,
           AttackStyle.Range => 0.333f,
           AttackStyle.Spellweaving => 1f,
           _ => 0f
       };

       return damageDealt * vitalityXPPerDamage * xpMultiplier;
   }

   public float GetCombatTriangleMultiplier(AttackStyle attackerStyle, AttackStyle defenderStyle)
   {
       if ((attackerStyle == AttackStyle.Spellweaving && defenderStyle == AttackStyle.Range) ||
           (attackerStyle == AttackStyle.Range && defenderStyle == AttackStyle.Stab) ||
           (attackerStyle == AttackStyle.Stab && defenderStyle == AttackStyle.Spellweaving))
       {
           return strongAgainstMultiplier;
       }
       
       if ((attackerStyle == AttackStyle.Range && defenderStyle == AttackStyle.Spellweaving) ||
           (attackerStyle == AttackStyle.Stab && defenderStyle == AttackStyle.Range) ||
           (attackerStyle == AttackStyle.Spellweaving && defenderStyle == AttackStyle.Stab))
       {
           return weakAgainstMultiplier;
       }
       
       return 1f;
   }

   public int CalculateMaxHit(int skillLevel, int equipmentBonus, AttackStyle style)
   {
       return style switch
       {
           AttackStyle.Stab or AttackStyle.Slash or AttackStyle.Crush or AttackStyle.Range =>
               Mathf.FloorToInt(0.5f + (skillLevel * (equipmentBonus + 64)) / 640f),
           
           AttackStyle.Spellweaving =>
               Mathf.FloorToInt(10 * (1 + equipmentBonus / 100f)),
           
           _ => minimumHit
       };
   }
}
using UnityEngine;

[CreateAssetMenu(fileName = "New Combat Equipment", menuName = "Combat/Equipment")]
public class CombatEquipment : Item
{
    [Header("Combat Requirements")]
    public int requiredLevel = 1;
    public int requiredDivinity = 1;

    [Header("Combat Stats")]
    public CombatBonuses bonuses = new CombatBonuses();

    [Header("Equipment Properties")]
    public GameObject equipmentModel;

    [Header("Combat Style")]
    public AttackStyle defaultAttackStyle = AttackStyle.None;
    public CombatTrainingStyle defaultTrainingStyle = CombatTrainingStyle.Precision;
    public bool splitXPWithFortitude = false;

    private void OnValidate()
    {
        itemType = ItemType.Equipment;
        ValidateRequirements();
    }

    private void ValidateRequirements()
    {
        if (requiredLevel < 1) requiredLevel = 1;
        if (requiredDivinity < 1) requiredDivinity = 1;
    }

    public bool CheckRequirements(PlayerSkills skills)
    {
        if (skills == null) return false;

        string requiredSkill = defaultAttackStyle switch
        {
            AttackStyle.Stab or AttackStyle.Slash or AttackStyle.Crush => "Precision",
            AttackStyle.Range => "Range",
            AttackStyle.Spellweaving => "Spellweaving",
            _ => ""
        };

        if (!string.IsNullOrEmpty(requiredSkill))
        {
            var skill = skills.GetSkill(requiredSkill);
            if (skill == null || skill.CurrentLevel < requiredLevel)
                return false;
        }

        if (requiredDivinity > 1)
        {
            var divinity = skills.GetSkill("Divinity");
            if (divinity == null || divinity.CurrentLevel < requiredDivinity)
                return false;
        }

        return true;
    }
}
using UnityEngine;

public static class CombatExperience
{
    public static void AwardCombatExperience(ICombatant attacker, int damage, CombatWeaponData weapon)
    {
        if (damage <= 0) return;
        
        PlayerSkills skills = (attacker as MonoBehaviour)?.GetComponent<PlayerSkills>();
        if (skills == null) return;

        float baseXP = damage * weapon.experienceMultiplier;
        
        // Award combat skill XP
        switch (weapon.attackStyle)
        {
            case AttackStyle.Stab or AttackStyle.Slash:
                skills.AddExperience("Precision", weapon.splitXPWithFortitude ? baseXP * 0.5f : baseXP);
                break;

            case AttackStyle.Crush:
                skills.AddExperience("Might", weapon.splitXPWithFortitude ? baseXP * 0.5f : baseXP);
                break;

            case AttackStyle.Range:
                skills.AddExperience("Range", weapon.splitXPWithFortitude ? baseXP * 0.5f : baseXP);
                break;

            case AttackStyle.Spellweaving:
                skills.AddExperience("Spellweaving", weapon.splitXPWithFortitude ? baseXP * 0.5f : baseXP);
                break;
        }

        // Award Fortitude XP if applicable
        if (weapon.splitXPWithFortitude)
        {
            skills.AddExperience("Fortitude", baseXP * 0.5f);
        }

        // Calculate and award Vitality XP
        float vitalityXP = CalculateVitalityXP(damage, weapon.attackStyle);
        skills.AddExperience("Vitality", vitalityXP);
    }

    private static float CalculateVitalityXP(float damage, AttackStyle style)
    {
        float baseXP = damage * 50.54f;

        return style switch
        {
            AttackStyle.Stab or AttackStyle.Slash or AttackStyle.Crush => baseXP * 0.25f,
            AttackStyle.Range => baseXP * 0.333f,
            AttackStyle.Spellweaving => baseXP,
            _ => 0f
        };
    }
}
using UnityEngine;
using System.Collections;

public class CombatHandler : MonoBehaviour
{
    [Header("Combat Settings")]
    public float attackRange = 2f;
    public float rotationSpeed = 10f;
    private ICombatant attacker;
    private ICombatant target;
    private float nextAttackTime;
    private bool inCombat;
    private ClickToMove movementController;
    private Animator animator;
    private RegenerationManager regenManager;

    [Header("Combat Animations")]
    [SerializeField] private string attackAnimationTrigger = "PlayerAttack";
    [SerializeField] private string inCombatBoolParam = "IsInCombat";
    [SerializeField] private string weaponTypeParam = "WeaponType";
    [SerializeField] private string attackStyleParam = "AttackStyle";
    [SerializeField] private float attackAnimationDuration = 0.8f;

    [Header("Combat Effects")]
    public ParticleSystem hitEffect;
    public AudioClip[] hitSounds;
    public AudioClip[] missSounds;
    private AudioSource audioSource;

    public bool InCombat => inCombat;
    public ICombatant CurrentTarget => target;

    private void Start()
    {
        InitializeComponents();
        ValidateAnimator();
    }

    private void InitializeComponents()
    {
        attacker = GetComponent<ICombatant>();
        movementController = GetComponent<ClickToMove>();
        animator = GetComponent<Animator>();
        audioSource = gameObject.AddComponent<AudioSource>();
        regenManager = GetComponent<RegenerationManager>();
        
        if (attacker == null)
        {
            Debug.LogError("No ICombatant implementation found on GameObject!");
            enabled = false;
        }
    }

    private void ValidateAnimator()
    {
        if (animator != null)
        {
            bool hasAttackTrigger = false;
            bool hasInCombatBool = false;
            bool hasWeaponType = false;
            bool hasAttackStyle = false;

            foreach (AnimatorControllerParameter param in animator.parameters)
            {
                switch (param.name)
                {
                    case var name when name == attackAnimationTrigger:
                        hasAttackTrigger = true;
                        break;
                    case var name when name == inCombatBoolParam:
                        hasInCombatBool = true;
                        break;
                    case var name when name == weaponTypeParam:
                        hasWeaponType = true;
                        break;
                    case var name when name == attackStyleParam:
                        hasAttackStyle = true;
                        break;
                }
            }

            if (!hasAttackTrigger) Debug.LogError($"Missing animation parameter: {attackAnimationTrigger}");
            if (!hasInCombatBool) Debug.LogError($"Missing animation parameter: {inCombatBoolParam}");
            if (!hasWeaponType) Debug.LogError($"Missing animation parameter: {weaponTypeParam}");
            if (!hasAttackStyle) Debug.LogError($"Missing animation parameter: {attackStyleParam}");
        }
        else
        {
            Debug.LogError("No Animator component found on GameObject!");
        }
    }

    private void Update()
    {
        if (!inCombat || target == null) return;

        float distanceToTarget = Vector3.Distance(transform.position, target.transform.position);
        if (distanceToTarget > attackRange)
        {
            RequestMoveToTarget();
            return;
        }
        else if (movementController != null)
        {
            movementController.StopMovementAndActions();
        }

        FaceTarget();

        if (Time.time >= nextAttackTime)
        {
            StartCoroutine(PerformAttackSequence());
        }
    }

    private void UpdateAnimatorWeaponType(WeaponData weapon)
    {
        if (animator != null && weapon != null)
        {
            animator.SetInteger(weaponTypeParam, (int)weapon.weaponType);
            animator.SetInteger(attackStyleParam, (int)weapon.defaultAttackStyle);
        }
    }

    private void RequestMoveToTarget()
    {
        if (target == null || movementController == null) return;
        movementController.MoveToTarget(target.transform.position);
    }

    private void FaceTarget()
    {
        if (target == null) return;

        Vector3 direction = (target.transform.position - transform.position).normalized;
        Quaternion lookRotation = Quaternion.LookRotation(new Vector3(direction.x, 0, direction.z));
        transform.rotation = Quaternion.Slerp(transform.rotation, lookRotation, Time.deltaTime * rotationSpeed);
    }

    private IEnumerator PerformAttackSequence()
    {
        if (target == null || !target.IsAlive)
        {
            StopCombat();
            yield break;
        }

        // Trigger attack animation
        if (animator != null)
        {
            animator.SetTrigger(attackAnimationTrigger);
        }

        yield return new WaitForSeconds(attackAnimationDuration);

        if (target != null && target.IsAlive)
        {
            attacker.Attack(target);
        }

        nextAttackTime = Time.time + attacker.GetAttackSpeed();
    }

    public void StartCombat(ICombatant newTarget)
    {
        if (newTarget == null || !newTarget.IsAlive)
        {
            Debug.LogWarning("Attempted to start combat with invalid target");
            return;
        }

        target = newTarget;
        inCombat = true;
        nextAttackTime = Time.time;

        // Pause regeneration when entering combat
        if (regenManager != null)
        {
            regenManager.PauseRegeneration(1.0f);
        }

        if (animator != null)
        {
            animator.SetBool(inCombatBoolParam, true);
            
            // Update weapon type and attack style if available
            if (attacker is PlayerCombatant playerCombatant)
            {
                var equipment = FindFirstObjectByType<EquipmentManager>();
                var weapon = equipment?.GetEquippedItem(EquipmentSlot.MainHand) as WeaponData;
                if (weapon != null)
                {
                    animator.SetInteger(weaponTypeParam, (int)weapon.weaponType);
                    animator.SetInteger(attackStyleParam, (int)weapon.defaultAttackStyle);
                }
            }
        }
        
        EnhancedChatbox.Instance?.AddMessage($"Engaging in combat with {newTarget.GetDisplayName()}");
    }

    public void StopCombat()
    {
        target = null;
        inCombat = false;
        
        // Resume normal regeneration when leaving combat
        if (regenManager != null)
        {
            regenManager.StartRegeneration();
        }
        
        if (animator != null)
        {
            animator.ResetTrigger(attackAnimationTrigger);
            animator.SetBool(inCombatBoolParam, false);
            animator.SetInteger(weaponTypeParam, 0);
            animator.SetInteger(attackStyleParam, 0);
        }
    }

    public void PlayHitEffect(Vector3 position)
    {
        if (hitEffect != null)
        {
            ParticleSystem effect = Instantiate(hitEffect, position, Quaternion.identity);
            Destroy(effect.gameObject, effect.main.duration);
        }
    }

    public void PlayCombatSound(bool isHit)
    {
        if (audioSource == null) return;

        AudioClip[] clips = isHit ? hitSounds : missSounds;
        if (clips != null && clips.Length > 0)
        {
            AudioClip clip = clips[Random.Range(0, clips.Length)];
            audioSource.PlayOneShot(clip);
        }
    }

    #if UNITY_EDITOR
    private void OnValidate()
    {
        // Ensure animation parameter names are not empty
        if (string.IsNullOrEmpty(attackAnimationTrigger))
            attackAnimationTrigger = "PlayerAttack";
        if (string.IsNullOrEmpty(inCombatBoolParam))
            inCombatBoolParam = "IsInCombat";
        if (string.IsNullOrEmpty(weaponTypeParam))
            weaponTypeParam = "WeaponType";
        if (string.IsNullOrEmpty(attackStyleParam))
            attackStyleParam = "AttackStyle";
    }
    #endif
}
using UnityEngine;
using UnityEngine.UI;
using TMPro;

public class CombatPanel : MonoBehaviour
{
    [Header("Main References")]
    [SerializeField] private EquipmentManager equipmentManager;
    [SerializeField] private PlayerSkills playerSkills;
    
    [Header("Panel Elements")]
    [SerializeField] private TextMeshProUGUI combatLevelText;
    [SerializeField] private TextMeshProUGUI currentWeaponText;
    [SerializeField] private TextMeshProUGUI attackStyleText;
    
    [Header("Combat Style UI")]
    [SerializeField] private GameObject styleToggleContainer;
    [SerializeField] private Toggle precisionToggle;
    [SerializeField] private Toggle mightToggle;
    [SerializeField] private Toggle fortitudeToggle;
    
    [Header("Combat Stats Display")]
    [SerializeField] private TextMeshProUGUI attackBonusText;
    [SerializeField] private TextMeshProUGUI strengthBonusText;
    [SerializeField] private TextMeshProUGUI defenseBonusText;

    private WeaponData currentWeapon;
    private CombatTrainingStyle currentTrainingStyle;

private void Start()
{
    InitializeReferences();
    SetupEventListeners();
    
    // Register with EquipmentUI
    var equipmentUI = GetComponentInParent<EquipmentUI>();
    if (equipmentUI != null)
    {
        equipmentUI.SetCombatPanel(this);
    }
    
    UpdateUI();
}

    private void InitializeReferences()
    {
        if (equipmentManager == null)
            equipmentManager = EquipmentManager.Instance;
            
        if (playerSkills == null)
            playerSkills = FindFirstObjectByType<PlayerSkills>();

        // Initialize toggles
        SetupToggleGroup();
    }

    private void SetupEventListeners()
    {
        if (equipmentManager != null)
        {
            equipmentManager.OnEquipmentChanged += HandleEquipmentChanged;
        }

        // Setup style toggle listeners
        SetupStyleToggles();
    }

    private void SetupToggleGroup()
    {
        // Make sure only one toggle can be active at a time
        ToggleGroup group = styleToggleContainer.GetComponent<ToggleGroup>();
        if (group == null)
            group = styleToggleContainer.AddComponent<ToggleGroup>();

        precisionToggle.group = group;
        mightToggle.group = group;
        fortitudeToggle.group = group;
    }

    private void SetupStyleToggles()
    {
        precisionToggle.onValueChanged.AddListener((isOn) => {
            if (isOn) UpdateTrainingStyle(CombatTrainingStyle.Precision);
        });

        mightToggle.onValueChanged.AddListener((isOn) => {
            if (isOn) UpdateTrainingStyle(CombatTrainingStyle.Might);
        });

        fortitudeToggle.onValueChanged.AddListener((isOn) => {
            if (isOn) UpdateTrainingStyle(CombatTrainingStyle.Fortitude);
        });
    }

    private void HandleEquipmentChanged(EquipmentSlot slot, Item item)
    {
        if (slot == EquipmentSlot.MainHand)
        {
            currentWeapon = item as WeaponData;
            UpdateUI();
            UpdateAvailableStyles();
        }
    }

    private void UpdateTrainingStyle(CombatTrainingStyle newStyle)
    {
        currentTrainingStyle = newStyle;
        if (currentWeapon != null)
        {
            // Update the weapon's training style
            // This will need to be implemented in WeaponData
            UpdateUI();
        }
    }

    private void UpdateAvailableStyles()
    {
        if (currentWeapon == null)
        {
            // Disable all style toggles for unarmed
            precisionToggle.gameObject.SetActive(false);
            mightToggle.gameObject.SetActive(false);
            fortitudeToggle.gameObject.SetActive(false);
            return;
        }

        // Enable/disable toggles based on weapon's available styles
        bool canTrainPrecision = currentWeapon.defaultAttackStyle == AttackStyle.Stab || 
                                currentWeapon.defaultAttackStyle == AttackStyle.Slash;
        bool canTrainMight = currentWeapon.defaultAttackStyle == AttackStyle.Crush;
        bool canTrainFortitude = true; // Fortitude can always be trained

        precisionToggle.gameObject.SetActive(canTrainPrecision);
        mightToggle.gameObject.SetActive(canTrainMight);
        fortitudeToggle.gameObject.SetActive(canTrainFortitude);

        // Set default toggle based on weapon type
        if (canTrainPrecision) precisionToggle.isOn = true;
        else if (canTrainMight) mightToggle.isOn = true;
        else fortitudeToggle.isOn = true;
    }

    public void UpdateUI()
    {
        if (playerSkills != null)
        {
            int combatLevel = playerSkills.CalculateCombatLevel();
            combatLevelText.text = $"Combat Level: {combatLevel}";
        }

        if (currentWeapon != null)
        {
            currentWeaponText.text = currentWeapon.itemName;
            attackStyleText.text = $"Style: {currentWeapon.defaultAttackStyle}";
            
            // Update combat bonuses
            attackBonusText.text = $"Attack: +{currentWeapon.bonuses.GetAttackBonus(currentWeapon.defaultAttackStyle)}";
            strengthBonusText.text = $"Might: +{currentWeapon.bonuses.mightBonus}";
            defenseBonusText.text = $"Fortitude: +{currentWeapon.bonuses.GetDefenseBonus(currentWeapon.defaultAttackStyle)}";
        }
        else
        {
            currentWeaponText.text = "Unarmed";
            attackStyleText.text = "Style: Punch";
            attackBonusText.text = "Attack: +0";
            strengthBonusText.text = "Might: +0";
            defenseBonusText.text = "Fortitude: +0";
        }
    }

    private void OnDestroy()
    {
        if (equipmentManager != null)
        {
            equipmentManager.OnEquipmentChanged -= HandleEquipmentChanged;
        }
    }
}
using UnityEngine;

public enum CombatSkill
{
    Precision,
    Might,
    Fortitude,
    Range,
    Spellweaving,
    Divinity,
    RangeAndFortitude,
    SpellweavingAndFortitude
}
using UnityEngine;
using System.Collections.Generic;

public class CombatStats
{
   public int Vitality { get; private set; }
   public int MaxVitality { get; private set; }
   public int Precision { get; private set; }
   public int Might { get; private set; }
   public int Fortitude { get; private set; }
   public int Range { get; private set; }
   public int Spellweaving { get; private set; }
   public int Divinity { get; private set; }

   public CombatBonuses combatBonuses = new CombatBonuses();

   public bool IsAlive => Vitality > 0;

   public CombatStats(int vitality = 100, int precision = 1, int might = 1, 
                     int fortitude = 1, int range = 1, int spellweaving = 1, int divinity = 1)
   {
       MaxVitality = vitality;
       Vitality = vitality;
       Precision = precision;
       Might = might; 
       Fortitude = fortitude;
       Range = range;
       Spellweaving = spellweaving;
       Divinity = divinity;
   }

   public int CombatLevel => 
       Mathf.Min(240, (Fortitude + Vitality + (Divinity / 2) + 
       Mathf.Max(Mathf.Max(Precision + Might, Range), Spellweaving)) / 5);

   public int GetDefenseBonus(AttackStyle style) => combatBonuses.GetDefenseBonus(style);

   public int CalculateMaxHit(AttackStyle style)
   {
       return style switch
       {
           AttackStyle.Stab or AttackStyle.Slash or AttackStyle.Crush => 
               Mathf.FloorToInt(0.5f + (Might * (combatBonuses.mightBonus + 64)) / 640f),
           
           AttackStyle.Range => 
               Mathf.FloorToInt(0.5f + (Range * (combatBonuses.rangeStrengthBonus + 64)) / 640f),
           
           AttackStyle.Spellweaving => 
               Mathf.FloorToInt(10 * (1 + combatBonuses.spellweavingDamage / 100f)),
           
           _ => 0
       };
   }

   public float CalculateHitChance(AttackStyle style, CombatStats targetStats)
   {
       float effectiveAccuracy = GetAttackSkillLevel(style) + combatBonuses.GetAttackBonus(style);
       float effectiveFortitude = targetStats.Fortitude + targetStats.GetDefenseBonus(style);
       
       return effectiveAccuracy / (effectiveAccuracy + effectiveFortitude);
   }

   public int GetAttackSkillLevel(AttackStyle style)
   {
       return style switch
       {
           AttackStyle.Stab or AttackStyle.Slash or AttackStyle.Crush => Precision,
           AttackStyle.Range => Range,
           AttackStyle.Spellweaving => Spellweaving,
           _ => 1
       };
   }

   public float CalculateVitalityXP(float damage, AttackStyle style)
   {
       float baseXP = damage * 50.54f;
       return style switch
       {
           AttackStyle.Stab or AttackStyle.Slash or AttackStyle.Crush => baseXP * 0.25f,
           AttackStyle.Range => baseXP * 0.333f,
           AttackStyle.Spellweaving => baseXP,
           _ => 0f
       };
   }

   public float GetBaseRegen() => MaxVitality * 0.01f;

   public void ModifyVitality(int amount)
   {
       Vitality = Mathf.Clamp(Vitality + amount, 0, MaxVitality);
   }
}
using UnityEngine;
using System.Collections.Generic;
public enum CombatStyle
{
    Melee,
    Ranged,
    Magic
}
using UnityEngine;
using UnityEngine.UI;
using TMPro;

public class CombatUI : MonoBehaviour
{
    [Header("UI References")]
    public RectTransform combatPanel;
    public TextMeshProUGUI combatLevelText;
    public TextMeshProUGUI weaponNameText;
    public TextMeshProUGUI attackStyleText;
    public TextMeshProUGUI trainingStyleText;

    [Header("Training Style Controls")]
    public Button cycleTrainingButton;
    public Image trainingStyleIcon;

    [Header("Combat Stats")]
    public TextMeshProUGUI attackBonusText;
    public TextMeshProUGUI strengthBonusText;
    public TextMeshProUGUI defenseBonusText;

    private PlayerSkills playerSkills;
    private EquipmentManager equipmentManager;
    private WeaponData currentWeapon;
    private int currentTrainingStyleIndex = 0;

    private void Start()
    {
        InitializeReferences();
        SetupEventListeners();
        UpdateUI();
    }

    private void InitializeReferences()
    {
        playerSkills = FindFirstObjectByType<PlayerSkills>();
        equipmentManager = EquipmentManager.Instance;

        if (cycleTrainingButton != null)
        {
            cycleTrainingButton.onClick.AddListener(CycleTrainingStyle);
        }
    }

    private void SetupEventListeners()
    {
        if (equipmentManager != null)
        {
            equipmentManager.OnEquipmentChanged += HandleEquipmentChanged;
        }
    }

    private void HandleEquipmentChanged(EquipmentSlot slot, Item item)
    {
        if (slot == EquipmentSlot.MainHand)
        {
            currentWeapon = item as WeaponData;
            currentTrainingStyleIndex = 0; // Reset training style when weapon changes
            UpdateUI();
        }
    }

    public void UpdateUI()
    {
        if (playerSkills == null || equipmentManager == null) return;

        // Update combat level
        int combatLevel = playerSkills.CalculateCombatLevel();
        combatLevelText.text = $"Combat Level: {combatLevel}";

        // Update weapon info
        if (currentWeapon != null)
        {
            weaponNameText.text = currentWeapon.itemName;
            attackStyleText.text = $"Attack Style: {currentWeapon.defaultAttackStyle}";
            
            var currentStyle = currentWeapon.availableTrainingStyles[currentTrainingStyleIndex];
            trainingStyleText.text = $"Training: {currentStyle}";

            // Update combat stats
            UpdateCombatStats();
        }
        else
        {
            weaponNameText.text = "Unarmed";
            attackStyleText.text = "Attack Style: Punch";
            trainingStyleText.text = "Training: Precision";
        }
    }

    private void UpdateCombatStats()
    {
        if (currentWeapon == null) return;

        // Get total bonuses from equipment
        var bonuses = currentWeapon.bonuses;
        
        attackBonusText.text = $"Attack Bonus: +{bonuses.GetAttackBonus(currentWeapon.defaultAttackStyle)}";
        
        switch (currentWeapon.defaultAttackStyle)
        {
            case AttackStyle.Spellweaving:
                strengthBonusText.text = $"Magic Damage: +{bonuses.spellweavingDamage}%";
                break;
            case AttackStyle.Range:
                strengthBonusText.text = $"Range Strength: +{bonuses.rangeStrengthBonus}";
                break;
            default:
                strengthBonusText.text = $"Might Bonus: +{bonuses.mightBonus}";
                break;
        }

        defenseBonusText.text = $"Defense Bonus: +{bonuses.GetDefenseBonus(currentWeapon.defaultAttackStyle)}";
    }

    public void CycleTrainingStyle()
    {
        if (currentWeapon == null || currentWeapon.availableTrainingStyles.Length <= 1) return;

        currentTrainingStyleIndex = (currentTrainingStyleIndex + 1) % currentWeapon.availableTrainingStyles.Length;
        UpdateUI();
    }

    private void OnDestroy()
    {
        if (equipmentManager != null)
        {
            equipmentManager.OnEquipmentChanged -= HandleEquipmentChanged;
        }
    }
}
using UnityEngine;
using System.Collections.Generic;

[CreateAssetMenu(fileName = "New Weapon", menuName = "Combat/Weapon")]
public class CombatWeapon : ScriptableObject
{
    public string weaponName;
    public WeaponType weaponType;
    public AttackStyle defaultAttackStyle;  // Changed from combatStyle
    public int attackBonus;
    public int strengthBonus;
    public float attackSpeed = 2.4f;
    public int requiredLevel;
    public EquipmentSlot equipSlot = EquipmentSlot.MainHand;

    public float GetDPS(CombatStats stats)
    {
        float accuracy = CalculateAccuracy(stats);
        float avgDamage = CalculateAverageDamage(stats);
        return (accuracy * avgDamage) / attackSpeed;
    }

    private float CalculateAccuracy(CombatStats stats)
    {
        // Use new stat names
        float effectiveLevel = stats.GetAttackSkillLevel(defaultAttackStyle);
        return (effectiveLevel * (1 + attackBonus/100f));
    }

    private float CalculateAverageDamage(CombatStats stats)
    {
        float baseDamage = 0;
        switch (defaultAttackStyle)
        {
            case AttackStyle.Stab:
            case AttackStyle.Slash:
            case AttackStyle.Crush:
                baseDamage = stats.Might * (1 + strengthBonus/100f);
                break;
            case AttackStyle.Range:
                baseDamage = stats.Range * (1 + strengthBonus/100f);
                break;
            case AttackStyle.Spellweaving:
                baseDamage = stats.Spellweaving * (1 + strengthBonus/100f);
                break;
        }
        return baseDamage;
    }
}
using UnityEngine;

[CreateAssetMenu(fileName = "New Weapon", menuName = "Combat/Weapon Data")]
public class CombatWeaponData : CombatEquipment
{
    [Header("Weapon Specific")]
    public WeaponType weaponType;
    public AttackStyle attackStyle;
    public CombatTrainingStyle trainingStyle;
    public float attackSpeed = 2.4f;
    public float baseAccuracy = 1f;
    public WeaponAttackStyle[] availableAttackStyles;

    [Header("Experience")]
    public float experienceMultiplier = 4f;
}
using UnityEngine;
using UnityEngine.UI;
using TMPro;
using System.Collections;
using System.Collections.Generic;
using System.Linq;

public class ContextMenu : MonoBehaviour
{
    public static ContextMenu Instance { get; private set; }
    
   [Header("UI References")]
    public GameObject menuPanel;
    public GameObject optionPrefab;
    public RectTransform menuContainer;
    
    [Header("Menu Settings")]
    public float minWidth = 100f;
    public float maxWidth = 300f;
    public float optionHeight = 25f;
    public float horizontalPadding = 20f;
    public float verticalPadding = 10f;
    public float verticalSpacing = 2f;

    [Header("Visual Settings")]
    public Color defaultTextColor = Color.white;
    public Color hoverTextColor = Color.grey;
    public int canvasSortingOrder = 31074;

    private List<GameObject> currentOptions = new List<GameObject>();
    private RectTransform panelRect;
    private Canvas menuCanvas;
    private float showTime;
    private bool IsVisible => menuPanel != null && menuPanel.activeSelf;
public Vector2 CurrentPosition => panelRect != null ? panelRect.position : Vector2.zero;
public int CurrentSortingOrder => menuCanvas != null ? menuCanvas.sortingOrder : 0;

    private void Awake()
    {
        if (Instance == null)
        {
            Instance = this;
            DontDestroyOnLoad(gameObject);
            InitializeCanvas();
        }
        else
        {
            Destroy(gameObject);
        }
    }
private void Update()
{
    if (menuPanel.activeSelf && Input.GetMouseButtonDown(0))
    {
        if (!IsClickingMenuItem())
        {
            HideMenu();
        }
    }
}
private void InitializeCanvas()
{
    menuCanvas = GetComponent<Canvas>();
    if (menuCanvas == null)
    {
        menuCanvas = gameObject.AddComponent<Canvas>();
    }
    
    // Ensure GraphicRaycaster exists and is enabled
    var raycaster = GetComponent<GraphicRaycaster>();
    if (raycaster == null)
    {
        raycaster = gameObject.AddComponent<GraphicRaycaster>();
    }
    raycaster.enabled = true;

    menuCanvas.renderMode = RenderMode.ScreenSpaceOverlay;
    menuCanvas.sortingOrder = 31074; // Set higher than current UI (-31073)
    menuCanvas.overrideSorting = true; // Make sure this is true
    
    panelRect = menuPanel.GetComponent<RectTransform>();
    
    // Add BlockRaycasts component to prevent click-through
    var blocker = menuPanel.GetComponent<CanvasGroup>();
    if (blocker == null)
    {
        blocker = menuPanel.AddComponent<CanvasGroup>();
    }
    blocker.blocksRaycasts = true;
    blocker.interactable = true;
    blocker.alpha = 1;

    menuPanel.SetActive(false);

    Debug.Log($"Context Menu initialized - Canvas Sort Order: {menuCanvas.sortingOrder}");
}

    public void ShowMenu(Vector2 screenPosition, List<ContextMenuOption> options)
    {
        if (menuPanel == null)
        {
            Debug.LogError("Menu Panel is not assigned!");
            return;
        }

        Debug.Log($"ShowMenu called with {options.Count} options at {screenPosition}");
        
        showTime = Time.time;
        ClearOptions();

        // Ensure proper sorting order and canvas setup
        if (menuCanvas != null)
        {
            menuCanvas.overrideSorting = true;
            menuCanvas.sortingOrder = canvasSortingOrder;
            Debug.Log($"Set canvas sorting order to {menuCanvas.sortingOrder}");
        }

        // Calculate maximum text width first
        float maxTextWidth = 0;
        foreach (var option in options)
        {
            GameObject optionObj = CreateOptionObject(option);
            
            // Calculate width needed for this option
            TMP_Text text = optionObj.GetComponentInChildren<TMP_Text>();
            if (text != null)
            {
                // Force text layout update
                text.ForceMeshUpdate();
                float textWidth = text.preferredWidth;
                maxTextWidth = Mathf.Max(maxTextWidth, textWidth);
            }
        }

        // Calculate final menu width (constrained between minWidth and maxWidth)
        float totalWidth = Mathf.Clamp(maxTextWidth + (horizontalPadding * 2), minWidth, maxWidth);
        float menuHeight = optionHeight * options.Count + (verticalSpacing * (options.Count - 1));

        // Update menu container size
        if (menuContainer != null)
        {
            menuContainer.sizeDelta = new Vector2(totalWidth, menuHeight);
        }

        // Update all option widths to match menu width
        for (int i = 0; i < currentOptions.Count; i++)
        {
            RectTransform rect = currentOptions[i].GetComponent<RectTransform>();
            if (rect != null)
            {
                rect.sizeDelta = new Vector2(totalWidth - (horizontalPadding * 2), optionHeight);
                rect.anchoredPosition = new Vector2(0, -i * (optionHeight + verticalSpacing));
            }

            // Update text component alignment and margins
            TMP_Text text = currentOptions[i].GetComponentInChildren<TMP_Text>();
            if (text != null)
            {
                text.margin = new Vector4(horizontalPadding, 0, horizontalPadding, 0);
                text.alignment = TextAlignmentOptions.Left;
            }
        }

        // Calculate screen bounds-aware position
        Vector2 adjustedPosition = screenPosition;
        Vector2 screenSize = new Vector2(Screen.width, Screen.height);
        
        // Adjust for right edge
        if (adjustedPosition.x + totalWidth > screenSize.x)
            adjustedPosition.x = screenSize.x - totalWidth;
        
        // Adjust for left edge
        if (adjustedPosition.x < 0)
            adjustedPosition.x = 0;
        
        // Adjust for bottom edge
        if (adjustedPosition.y + menuHeight > screenSize.y)
            adjustedPosition.y = screenSize.y - menuHeight;
        
        // Adjust for top edge
        if (adjustedPosition.y < 0)
            adjustedPosition.y = 0;

        // Set menu position and size
        panelRect.position = adjustedPosition;
        panelRect.sizeDelta = new Vector2(totalWidth, menuHeight);
        
        // Ensure proper hierarchy
        menuPanel.transform.SetAsLastSibling();
        
        // Show the menu
        menuPanel.SetActive(true);

        // Validate final position
        StartCoroutine(ValidateMenuPosition());

        Debug.Log($"Menu shown at {adjustedPosition}, Size: {totalWidth}x{menuHeight}");
    }
private IEnumerator ValidateMenuPosition()
{
    // Wait one frame for layout to update
    yield return null;

    // Get screen bounds of menu
    Vector3[] corners = new Vector3[4];
    panelRect.GetWorldCorners(corners);
    
    bool isPartiallyOffscreen = false;
    foreach (Vector3 corner in corners)
    {
        Vector2 screenPoint = RectTransformUtility.WorldToScreenPoint(null, corner);
        if (screenPoint.x < 0 || screenPoint.x > Screen.width ||
            screenPoint.y < 0 || screenPoint.y > Screen.height)
        {
            isPartiallyOffscreen = true;
            Debug.LogWarning($"Menu is partially offscreen at position {panelRect.position}");
            break;
        }
    }

    // Log final position validation
    if (!isPartiallyOffscreen)
    {
        Debug.Log("Menu position validated - fully on screen");
    }
}

    private void ValidateTransform()
{
    RectTransform rect = GetComponent<RectTransform>();
    if (rect.localPosition.z != 0)
    {
        Debug.LogWarning("ContextMenu Z position is not 0, this might cause layering issues");
        rect.localPosition = new Vector3(rect.localPosition.x, rect.localPosition.y, 0);
    }
}
private void ValidateEventSystem()
{
    var raycaster = GetComponentInParent<GraphicRaycaster>();
    if (raycaster == null || !raycaster.enabled)
    {
        Debug.LogError("GraphicRaycaster missing or disabled in ContextMenu hierarchy");
    }
}
public void ForceToFront()
{
    Canvas canvas = GetComponentInParent<Canvas>();
    if (canvas != null)
    {
        // Find highest sorting order in scene
        int highestOrder = FindObjectsByType<Canvas>(FindObjectsSortMode.None)
            .Max(c => c.sortingOrder);
        
        // Set our order higher
        canvas.sortingOrder = highestOrder + 1;
        Debug.Log($"Force context menu to front: {canvas.sortingOrder}");
    }
}

    private GameObject CreateOptionObject(ContextMenuOption option)
    {
        GameObject optionObj = Instantiate(optionPrefab, menuContainer);
        currentOptions.Add(optionObj);

        RectTransform rect = optionObj.GetComponent<RectTransform>();
        rect.localScale = Vector3.one;

        Button button = optionObj.GetComponent<Button>();
        TMP_Text text = optionObj.GetComponentInChildren<TMP_Text>();
        
        if (text != null)
        {
            text.text = option.Text;
            text.color = defaultTextColor;
            
            // Set text style
            text.textWrappingMode = TextWrappingModes.NoWrap;
            text.overflowMode = TextOverflowModes.Ellipsis;
            text.margin = new Vector4(horizontalPadding, 0, horizontalPadding, 0);
            text.alignment = TextAlignmentOptions.Left;
        }

        if (button != null)
        {
            button.onClick.RemoveAllListeners();
            button.onClick.AddListener(() => {
                HideMenu();
                option.Action?.Invoke();
            });

            // Optional: Add hover color change
            var colors = button.colors;
            colors.normalColor = Color.clear;
            colors.highlightedColor = new Color(1, 1, 1, 0.1f);
            button.colors = colors;
        }

        return optionObj;
    }

    private void ClearOptions()
    {
        foreach (var option in currentOptions)
        {
            Destroy(option);
        }
        currentOptions.Clear();
    }


private Vector2 ClampMenuPosition(Vector2 position, int optionCount)
{
    Vector2 screenSize = new Vector2(Screen.width, Screen.height);
    float totalWidth = menuContainer.sizeDelta.x; // Use the current menu width
    float menuHeight = optionHeight * optionCount;

    position.x = Mathf.Clamp(position.x, 0, screenSize.x - totalWidth);
    
    if (position.y - menuHeight < 0)
    {
        position.y += menuHeight;
    }
    
    if (position.y > screenSize.y)
    {
        position.y = screenSize.y;
    }

    return position;
}

    public void HideMenu()
    {
        if (Time.time - showTime < 0.1f) return;
        ClearOptions();
        menuPanel.SetActive(false);
    }

public bool IsClickingMenuItem()
{
    if (!menuPanel.activeSelf) return false;
    
    return RectTransformUtility.RectangleContainsScreenPoint(
        panelRect,
        Input.mousePosition,
        null
    );
}
    #if UNITY_EDITOR
void OnDrawGizmos()
{
    if (!menuPanel || !menuPanel.activeSelf) return;
    
    // Draw bounds
    RectTransform rect = menuPanel.GetComponent<RectTransform>();
    Vector3[] corners = new Vector3[4];
    rect.GetWorldCorners(corners);
    
    Gizmos.color = Color.yellow;
    for (int i = 0; i < 4; i++)
        Gizmos.DrawLine(corners[i], corners[(i + 1) % 4]);
        
    // Draw sorting order text
    UnityEditor.Handles.Label(corners[0], 
        $"Sort Order: {menuCanvas.sortingOrder}");
}
#endif
}
// ContextMenuOption.cs
public class ContextMenuOption
{
    public string Text { get; set; }
    public System.Action Action { get; set; }

    public ContextMenuOption(string text, System.Action action)
    {
        Text = text;
        Action = action;
    }
}
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.EventSystems;
using TMPro;

public class ContextMenuValidator : MonoBehaviour
{
    public void ValidateSetup()
    {
        var contextMenu = GetComponent<ContextMenu>();
        if (contextMenu == null)
        {
            Debug.LogError("Missing ContextMenu component!");
            return;
        }

        var canvas = GetComponent<Canvas>();
        if (canvas == null)
        {
            Debug.LogError("Missing Canvas component!");
            return;
        }

        if (canvas.renderMode != RenderMode.ScreenSpaceOverlay)
        {
            Debug.LogWarning($"Canvas render mode is {canvas.renderMode}, should be ScreenSpaceOverlay");
        }

        if (canvas.sortingOrder < 100)
        {
            Debug.LogWarning($"Canvas sorting order is {canvas.sortingOrder}, should be at least 100");
        }

        var raycaster = GetComponent<GraphicRaycaster>();
        if (raycaster == null)
        {
            Debug.LogError("Missing GraphicRaycaster component!");
        }

        if (contextMenu.menuPanel == null)
        {
            Debug.LogError("MenuPanel reference is missing!");
        }
        else
        {
            var panelCanvas = contextMenu.menuPanel.GetComponent<CanvasGroup>();
            if (panelCanvas == null)
            {
                Debug.LogWarning("MenuPanel should have a CanvasGroup component for proper interaction");
            }
        }

        if (contextMenu.optionPrefab == null)
        {
            Debug.LogError("Option prefab reference is missing!");
        }
        else
        {
            ValidateOptionPrefab(contextMenu.optionPrefab);
        }

        // Check EventSystem
        var eventSystem = FindFirstObjectByType<EventSystem>();
        if (eventSystem == null)
        {
            Debug.LogError("No EventSystem found in scene!");
        }
    }

    private void ValidateOptionPrefab(GameObject prefab)
    {
        var button = prefab.GetComponent<Button>();
        if (button == null)
        {
            Debug.LogError("Option prefab missing Button component!");
        }

        var text = prefab.GetComponentInChildren<TMP_Text>();
        if (text == null)
        {
            Debug.LogError("Option prefab missing TMP_Text component!");
        }
    }
}
using UnityEngine;

public class CursorManager : MonoBehaviour
{
    public static CursorManager Instance { get; private set; }

    [Header("Cursor Textures")]
    public Texture2D defaultCursor;
    public Texture2D interactiveCursor;
    public Texture2D combatCursor;
    public Texture2D harvestCursor;

    private void Awake()
    {
        if (Instance == null)
        {
            Instance = this;
            DontDestroyOnLoad(gameObject);
        }
        else
        {
            Destroy(gameObject);
        }
    }

    private void Start()
    {
        // Set default cursor
        SetDefaultCursor();
    }

    public void SetDefaultCursor()
    {
        Cursor.SetCursor(defaultCursor, Vector2.zero, CursorMode.Auto);
    }
}
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.EventSystems;

public class DragDropHandler : MonoBehaviour, IBeginDragHandler, IDragHandler, IEndDragHandler
{
    private RectTransform draggedIcon;
    private Canvas canvas;
    private CanvasGroup canvasGroup;
    private Vector2 originalPosition;
    private Transform originalParent;
    private int originalSlotIndex;
    private InventoryUI inventoryUI;
    private InventorySlotUI originalSlot;
    private GameObject draggedItemGO;

    private void Start()
    {
        // Get references
        canvas = GetComponentInParent<Canvas>();
        if (canvas == null)
            canvas = FindFirstObjectByType<Canvas>();
            
        inventoryUI = FindFirstObjectByType<InventoryUI>();
        originalSlot = GetComponentInParent<InventorySlotUI>();
    }

    public void OnBeginDrag(PointerEventData eventData)
    {
        if (originalSlot == null || originalSlot.itemIcon == null || !originalSlot.itemIcon.enabled)
            return;

        // Create a temporary icon for dragging
        draggedItemGO = new GameObject("DraggedItem");
        draggedIcon = draggedItemGO.AddComponent<RectTransform>();
        var image = draggedItemGO.AddComponent<Image>();
        
        // Copy the item icon properties
        image.sprite = originalSlot.itemIcon.sprite;
        image.raycastTarget = false;
        draggedIcon.sizeDelta = originalSlot.itemIcon.rectTransform.sizeDelta;
        
        // Set up the dragged icon
        draggedItemGO.transform.SetParent(canvas.transform);
        draggedItemGO.transform.SetAsLastSibling();
        
        // Store original values
        originalSlotIndex = originalSlot.slotIndex;
        
        // Make the original icon semi-transparent
        originalSlot.itemIcon.color = new Color(1, 1, 1, 0.5f);

        Debug.Log($"Started dragging item from slot {originalSlotIndex}");
    }

    public void OnDrag(PointerEventData eventData)
    {
        if (draggedIcon != null)
        {
            if (RectTransformUtility.ScreenPointToLocalPointInRectangle(
                canvas.GetComponent<RectTransform>(),
                eventData.position,
                eventData.pressEventCamera,
                out Vector2 localPoint))
            {
                draggedIcon.localPosition = localPoint;
            }
        }
    }

    public void OnEndDrag(PointerEventData eventData)
    {
        if (draggedItemGO != null)
        {
            Destroy(draggedItemGO);
        }

        // Restore original icon opacity
        if (originalSlot != null && originalSlot.itemIcon != null)
        {
            originalSlot.itemIcon.color = Color.white;
        }

        // Get the target slot
        InventorySlotUI targetSlot = null;
        if (eventData.pointerEnter != null)
        {
            targetSlot = eventData.pointerEnter.GetComponent<InventorySlotUI>();
            if (targetSlot == null)
            {
                targetSlot = eventData.pointerEnter.GetComponentInParent<InventorySlotUI>();
            }
        }

        if (targetSlot != null && originalSlotIndex >= 0 && targetSlot.slotIndex != originalSlotIndex)
        {
            Debug.Log($"Swapping items between slots {originalSlotIndex} and {targetSlot.slotIndex}");
            inventoryUI.SwapItems(originalSlotIndex, targetSlot.slotIndex);
        }
        else
        {
            Debug.Log($"No valid target slot found or same slot");
        }
    }
}
using UnityEngine;

public class DroppedItem : MonoBehaviour 
{
    public Item item { get; private set; }
    public int quantity { get; private set; }
    private float despawnTime;
    private MeshRenderer meshRenderer;

    public void Initialize(Item _item, int _quantity, float lifetime)
    {
        item = _item;
        quantity = _quantity;
        despawnTime = Time.time + lifetime;
        SetupVisuals();
        SetupCollider();
    }

private void SetupVisuals()
{
    // Create a simple cube to represent the item
    GameObject visual = GameObject.CreatePrimitive(PrimitiveType.Cube);
    visual.transform.SetParent(transform);
    visual.transform.localPosition = Vector3.zero;
    visual.transform.localScale = new Vector3(0.5f, 0.5f, 0.5f);

    meshRenderer = visual.GetComponent<MeshRenderer>();
    if (meshRenderer && item.itemIcon)
    {
        Material mat = new Material(Shader.Find("Standard"));
        mat.mainTexture = item.itemIcon.texture;
        meshRenderer.material = mat;
    }
}
private void SpawnDroppedItem(Vector3 position)
{
    GameObject player = GameObject.FindGameObjectWithTag("Player");
    if (player != null)
    {
        // Calculate position in front of player
        Vector3 dropPos = player.transform.position + 
            (player.transform.forward * 1f) + // 1 unit in front
            Vector3.up * 0.1f; // Slight elevation to prevent ground clipping

        GameObject droppedObj = new GameObject($"Dropped_{item.itemName}");
        droppedObj.transform.position = dropPos;
        
        var itemComponent = droppedObj.AddComponent<DroppedItem>();
        itemComponent.Initialize(item, 1, 180f);

        Debug.Log($"Spawned dropped item: {item.itemName} at {dropPos}");
    }
}

    private void SetupCollider()
    {
        BoxCollider col = gameObject.AddComponent<BoxCollider>();
        col.isTrigger = true;
        col.size = new Vector3(1f, 1f, 1f);

        Rigidbody rb = gameObject.AddComponent<Rigidbody>();
        rb.isKinematic = true;
    }

    private void OnTriggerEnter(Collider other)
    {
        if (other.CompareTag("Player"))
        {
            if (Inventory.Instance.AddItem(item, quantity))
            {
                EnhancedChatbox.Instance?.AddMessage($"Picked up: {item.itemName}");
                Destroy(gameObject);
            }
            else
            {
                EnhancedChatbox.Instance?.AddMessage("Inventory is full!");
            }
        }
    }

    private void Update()
    {
        if (Time.time >= despawnTime)
        {
            Destroy(gameObject);
        }
    }
}
using UnityEngine;
using TMPro;
using System.Collections.Generic;

public class EnhancedChatbox : MonoBehaviour
{
    public static EnhancedChatbox Instance { get; private set; }

    [System.Serializable]
    public class MessageStyle
    {
        public string prefix = "";
        public Color textColor = Color.white;
        public float displayDuration = 5f;
        public bool isBold = false;
        public bool isPermanent = false;
    }

    [Header("UI References")]
    public TMP_Text chatText;
    public int maxMessages = 20;

    [Header("Message Styles")]
    public MessageStyle defaultStyle;
    public MessageStyle levelUpStyle;
    public MessageStyle systemStyle;

    private Queue<ChatMessage> messageQueue = new Queue<ChatMessage>();

    private class ChatMessage
    {
        public string text;
        public MessageType type;
        public float timestamp;
        public bool isPermanent;

        public ChatMessage(string text, MessageType type, bool isPermanent = false)
        {
            this.text = text;
            this.type = type;
            this.timestamp = Time.time;
            this.isPermanent = isPermanent;
        }
    }

    public enum MessageType
    {
        Default,
        LevelUp,
        System
    }

    private void Awake()
    {
        if (Instance == null)
        {
            Instance = this;
        }
        else
        {
            Destroy(gameObject);
        }
    }

    private void Start()
    {
        AddMessage("Welcome to RVAMP!", MessageType.System, true);
    }

    public void AddMessage(string message, MessageType type = MessageType.Default, bool isPermanent = false)
    {
        if (messageQueue.Count >= maxMessages)
        {
            RemoveOldestNonPermanentMessage();
        }

        messageQueue.Enqueue(new ChatMessage(message, type, isPermanent));
        UpdateChatDisplay();
    }

    private void RemoveOldestNonPermanentMessage()
    {
        var tempQueue = new Queue<ChatMessage>();
        bool removed = false;

        while (messageQueue.Count > 0)
        {
            var message = messageQueue.Dequeue();
            if (!message.isPermanent && !removed)
            {
                removed = true;
                continue;
            }
            tempQueue.Enqueue(message);
        }

        messageQueue = tempQueue;
    }

    private void UpdateChatDisplay()
    {
        System.Text.StringBuilder sb = new System.Text.StringBuilder();
        foreach (var message in messageQueue)
        {
            string formattedMessage = FormatMessage(message);
            sb.AppendLine(formattedMessage);
        }
        chatText.text = sb.ToString();
    }

    private string FormatMessage(ChatMessage message)
    {
        MessageStyle style = GetStyleForType(message.type);
        string formattedText = message.text;

        if (style.isBold)
        {
            formattedText = $"<b>{formattedText}</b>";
        }

        if (!string.IsNullOrEmpty(style.prefix))
        {
            formattedText = $"{style.prefix}{formattedText}";
        }

        return $"<color=#{ColorUtility.ToHtmlStringRGB(style.textColor)}>{formattedText}</color>";
    }

    private MessageStyle GetStyleForType(MessageType type)
    {
        return type switch
        {
            MessageType.LevelUp => levelUpStyle,
            MessageType.System => systemStyle,
            _ => defaultStyle
        };
    }
}
using UnityEngine;
using System.Collections.Generic;
using System.Linq;
using System.Collections;

public class EquipmentManager : MonoBehaviour
{
    public static EquipmentManager Instance { get; private set; }
    
    [Header("Equipment Setup")]
    public Transform equipmentContainer;
    
    [Header("Mount Points")]
    public Transform rightHandMount;    // MainHand items
    public Transform leftHandMount;     // OffHand items
    public Transform backMount;         // Back items
    public Transform headMount;         // Head items
    public Transform chestMount;        // Body armor
    public Transform legsMount;         // Leg armor
    public Transform glovesMount;       // Glove items
    public Transform bootsMount;        // Boot items
    public Transform quiverMount;       // Quiver items

    [Header("Equipment Offsets")]
    [SerializeField] private Vector3 mainHandPositionOffset = Vector3.zero;
    [SerializeField] private Vector3 mainHandRotationOffset = new Vector3(0, 90, 0);
    [SerializeField] private Vector3 mainHandScale = Vector3.one;
    
    [SerializeField] private Vector3 offHandPositionOffset = Vector3.zero;
    [SerializeField] private Vector3 offHandRotationOffset = new Vector3(0, 90, 0);
    [SerializeField] private Vector3 offHandScale = Vector3.one;

    [SerializeField] private Vector3 backPositionOffset = Vector3.zero;
    [SerializeField] private Vector3 backRotationOffset = Vector3.zero;
    [SerializeField] private Vector3 backScale = Vector3.one;

    [SerializeField] private Vector3 armorPositionOffset = Vector3.zero;
    [SerializeField] private Vector3 armorRotationOffset = Vector3.zero;
    [SerializeField] private Vector3 armorScale = Vector3.one;

    [Header("Animation")]
    [SerializeField] private Animator playerAnimator;

    private Dictionary<EquipmentSlot, Item> equippedItems = new Dictionary<EquipmentSlot, Item>();
    private Dictionary<EquipmentSlot, GameObject> equippedModels = new Dictionary<EquipmentSlot, GameObject>();
    private EquipmentUI equipmentUI;
    private Animator characterAnimator;

    public System.Action<EquipmentSlot, Item> OnEquipmentChanged;

    private void Awake()
    {
        if (Instance == null)
        {
            Instance = this;
            DontDestroyOnLoad(gameObject);
        }
        else
        {
            Destroy(gameObject);
        }

        InitializeSlots();
    }

    private void Start()
    {
        equipmentUI = FindFirstObjectByType<EquipmentUI>();
        playerAnimator = GetComponent<Animator>();
        
        if (equipmentUI == null)
            Debug.LogWarning("EquipmentUI not found in scene");

        ValidateMountPoints();
    }

    private void ValidateMountPoints()
    {
        if (rightHandMount == null) Debug.LogError("Right hand mount point is missing!");
        if (leftHandMount == null) Debug.LogError("Left hand mount point is missing!");
        if (backMount == null) Debug.LogError("Back mount point is missing!");
        // Add validation for other mount points as needed
    }
        private void ValidateEquipmentUI()
    {
        var equipmentUI = FindFirstObjectByType<EquipmentUI>();
        if (equipmentUI != null)
        {
            equipmentUI.ValidateAllSlots();
        }
    }

    private void InitializeSlots()
    {
        equippedItems.Clear();
        equippedModels.Clear();
        
        foreach (EquipmentSlot slot in System.Enum.GetValues(typeof(EquipmentSlot)))
        {
            if (slot != EquipmentSlot.None)
            {
                equippedItems[slot] = null;
                equippedModels[slot] = null;
            }
        }
    }

    private Transform GetMountPointForSlot(EquipmentSlot slot)
    {
        return slot switch
        {
            EquipmentSlot.MainHand => rightHandMount,
            EquipmentSlot.OffHand => leftHandMount,
            EquipmentSlot.Back => backMount,
            EquipmentSlot.Head => headMount,
            EquipmentSlot.Chest => chestMount,
            EquipmentSlot.Legs => legsMount,
            EquipmentSlot.Gloves => glovesMount,
            EquipmentSlot.Boots => bootsMount,
            EquipmentSlot.Quiver => quiverMount,
            _ => null
        };
    }

    private Vector3 GetPositionOffsetForSlot(EquipmentSlot slot)
    {
        return slot switch
        {
            EquipmentSlot.MainHand => mainHandPositionOffset,
            EquipmentSlot.OffHand => offHandPositionOffset,
            EquipmentSlot.Back => backPositionOffset,
            EquipmentSlot.Head or EquipmentSlot.Chest or EquipmentSlot.Legs 
                or EquipmentSlot.Gloves or EquipmentSlot.Boots => armorPositionOffset,
            _ => Vector3.zero
        };
    }

    private Vector3 GetRotationOffsetForSlot(EquipmentSlot slot)
    {
        return slot switch
        {
            EquipmentSlot.MainHand => mainHandRotationOffset,
            EquipmentSlot.OffHand => offHandRotationOffset,
            EquipmentSlot.Back => backRotationOffset,
            EquipmentSlot.Head or EquipmentSlot.Chest or EquipmentSlot.Legs 
                or EquipmentSlot.Gloves or EquipmentSlot.Boots => armorRotationOffset,
            _ => Vector3.zero
        };
    }

    private Vector3 GetScaleForSlot(EquipmentSlot slot)
    {
        return slot switch
        {
            EquipmentSlot.MainHand => mainHandScale,
            EquipmentSlot.OffHand => offHandScale,
            EquipmentSlot.Back => backScale,
            EquipmentSlot.Head or EquipmentSlot.Chest or EquipmentSlot.Legs 
                or EquipmentSlot.Gloves or EquipmentSlot.Boots => armorScale,
            _ => Vector3.one
        };
    }

    public bool EquipItem(Item item)
    {
        if (item == null || item.equipSlot == EquipmentSlot.None) return false;

        try
        {
            if (item is CombatEquipment combatEquip)
            {
                string requiredSkill = combatEquip.defaultAttackStyle switch
                {
                    AttackStyle.Stab or AttackStyle.Slash or AttackStyle.Crush => "Precision",
                    AttackStyle.Range => "Range",
                    AttackStyle.Spellweaving => "Spellweaving",
                    _ => ""
                };

                if (!string.IsNullOrEmpty(requiredSkill))
                {
                    PlayerSkills playerSkills = FindFirstObjectByType<PlayerSkills>();
                    Skill skill = playerSkills?.GetSkill(requiredSkill);
                    if (skill == null || skill.CurrentLevel < combatEquip.requiredLevel)
                    {
                        EnhancedChatbox.Instance?.AddMessage(
                            $"You need {combatEquip.requiredLevel} {requiredSkill} to equip this item.");
                        return false;
                    }
                }
            }

            if (equippedItems.ContainsKey(item.equipSlot) && equippedItems[item.equipSlot] != null)
            {
                UnequipItem(item.equipSlot);
            }

            // Handle visual equipment model
            if (item is CombatEquipment equipment && equipment.equipmentModel != null)
            {
                Transform mountPoint = GetMountPointForSlot(item.equipSlot);
                if (mountPoint != null)
                {
                    if (equippedModels.ContainsKey(item.equipSlot) && equippedModels[item.equipSlot] != null)
                    {
                        Destroy(equippedModels[item.equipSlot]);
                    }

                    GameObject model = Instantiate(equipment.equipmentModel, mountPoint);
                    model.transform.localPosition = GetPositionOffsetForSlot(item.equipSlot);
                    model.transform.localRotation = Quaternion.Euler(GetRotationOffsetForSlot(item.equipSlot));
                    model.transform.localScale = GetScaleForSlot(item.equipSlot);
                    
                    equippedModels[item.equipSlot] = model;
                }
            }

            equippedItems[item.equipSlot] = item;
            OnEquipmentChanged?.Invoke(item.equipSlot, item);

            if (item is WeaponData weapon && playerAnimator != null)
            {
                playerAnimator.SetInteger("WeaponType", (int)weapon.weaponType);
                playerAnimator.SetInteger("AttackStyle", (int)weapon.defaultAttackStyle);
            }

            if (equipmentUI != null)
            {
                equipmentUI.UpdateEquipmentSlot(item.equipSlot, item);
                StartCoroutine(ValidateUIAfterEquip(item.equipSlot));
            }

            return true;
        }
        catch (System.Exception e)
        {
            Debug.LogError($"Error equipping item: {e.Message}\n{e.StackTrace}");
            return false;
        }
    }

public Item UnequipItem(EquipmentSlot slot)
{
    if (!equippedItems.ContainsKey(slot))
        return null;

    Item item = equippedItems[slot];
    if (item != null)
    {
        Debug.Log($"Unequipping {item.itemName} from slot {slot}");
        
        // Store the item before clearing equipment
        Item unequippedItem = item;
        
        // Remove the visual model
        if (equippedModels.ContainsKey(slot) && equippedModels[slot] != null)
        {
            Destroy(equippedModels[slot]);
            equippedModels[slot] = null;
        }

        // Clear equipment slot
        equippedItems[slot] = null;
        
        // Notify of equipment change
        OnEquipmentChanged?.Invoke(slot, null);
        
        // Reset animator if it was a weapon
        if (characterAnimator != null && slot == EquipmentSlot.MainHand)
        {
            characterAnimator.SetInteger("WeaponType", 0);
            characterAnimator.SetInteger("CombatStyle", 0);
        }

        // Return to inventory
        if (Inventory.Instance != null)
        {
            bool added = Inventory.Instance.AddItem(unequippedItem, 1);
            if (!added)
            {
                Debug.LogWarning($"Failed to add unequipped item {unequippedItem.itemName} to inventory");
                return null;
            }
            else
            {
                Debug.Log($"Successfully returned {unequippedItem.itemName} to inventory");
            }
        }

        // Update UI
        if (equipmentUI != null)
        {
            equipmentUI.UpdateEquipmentSlot(slot, null);
        }

        return unequippedItem;
    }
    return null;
}
private IEnumerator ValidateUIAfterEquip(EquipmentSlot slot) // Uses non-generic IEnumerator
{
    // Wait for one frame to ensure all UI updates have processed
    yield return null;
    
    // Validate the specific slot
    if (equipmentUI != null)
    {
        // Force a UI refresh
        equipmentUI.UpdateEquipmentSlot(slot, equippedItems[slot]);
        
        // Optional: Validate all slots to ensure consistency
        equipmentUI.ValidateAllSlots();
    }
    
    // Log the current state
    var equippedItem = equippedItems[slot];
    Debug.Log($"Post-equip validation - Slot: {slot}, Item: {equippedItem?.itemName ?? "null"}, " +
              $"Has Icon: {equippedItem?.itemIcon != null}, UI Found: {equipmentUI != null}");
}

// Add this helper method to validate equipment state
public void ValidateEquipmentState()
{
    Debug.Log("=== Equipment State Validation ===");
    foreach (var kvp in equippedItems)
    {
        var slot = kvp.Key;
        var item = kvp.Value;
        Debug.Log($"Slot {slot}: {(item != null ? $"{item.itemName} (Icon: {item.itemIcon != null})" : "empty")}");
        
        if (item != null && item.itemIcon == null)
        {
            Debug.LogError($"Item {item.itemName} in slot {slot} has no icon!");
        }
    }
}
    private void UpdateAnimatorWeaponType(WeaponData weapon)
    {
        if (characterAnimator != null && weapon != null)
        {
            characterAnimator.SetInteger("WeaponType", (int)weapon.weaponType);
            characterAnimator.SetInteger("AttackStyle", (int)weapon.defaultAttackStyle);
        }
    }

    // Update equipment handling to use new attack styles:
public void HandleEquipmentChanged(EquipmentSlot slot, Item item)
{
    if (item is WeaponData weapon)
    {
        UpdateAnimatorWeaponType(weapon);
    }
    
    OnEquipmentChanged?.Invoke(slot, item);
}

private void HandleWeaponEquip(WeaponData weapon)
{
    if (characterAnimator != null)
    {
        characterAnimator.SetInteger("WeaponType", (int)weapon.weaponType);
        characterAnimator.SetInteger("AttackStyle", (int)weapon.defaultAttackStyle);
    }
}
    private void HandleWeaponChange(WeaponData weapon)
    {
        if (playerAnimator != null)
        {
            playerAnimator.SetInteger("WeaponType", (int)weapon.weaponType);
            playerAnimator.SetInteger("AttackStyle", (int)weapon.defaultAttackStyle);
        }
    }

    public Item GetEquippedItem(EquipmentSlot slot)
    {
        return equippedItems.TryGetValue(slot, out Item item) ? item : null;
    }

    public bool HasItemEquipped(ItemType itemType)
    {
        return equippedItems.Values.Any(item => item != null && item.itemType == itemType);
    }

    public bool HasSpecificItemEquipped(Item item)
    {
        return equippedItems.Values.Contains(item);
    }

    public Dictionary<EquipmentSlot, Item> GetAllEquippedItems()
    {
        return new Dictionary<EquipmentSlot, Item>(equippedItems);
    }

    public float GetTotalMightBonus()
    {
        return equippedItems.Values
            .Where(item => item is CombatEquipment)
            .Sum(item => ((CombatEquipment)item).bonuses.mightBonus);
    }

    public float GetTotalFortitudeBonus()
    {
        return equippedItems.Values
            .Where(item => item is CombatEquipment)
            .Sum(item => ((CombatEquipment)item).bonuses.GetDefenseBonus(AttackStyle.None));
    }

    public float GetTotalPrecisionBonus()
    {
        return equippedItems.Values
            .Where(item => item is CombatEquipment)
            .Sum(item => ((CombatEquipment)item).bonuses.GetAttackBonus(AttackStyle.Stab));
    }

    public void LogEquipmentPositions()
    {
        foreach (var kvp in equippedModels)
        {
            if (kvp.Value != null)
            {
                Debug.Log($"Equipment in slot {kvp.Key}: " +
                    $"Position = {kvp.Value.transform.localPosition}, " +
                    $"Rotation = {kvp.Value.transform.localRotation.eulerAngles}, " +
                    $"Scale = {kvp.Value.transform.localScale}");
            }
        }
    }
}
using UnityEngine;

#if UNITY_EDITOR
using UnityEditor;

public class EquipmentPositionAdjuster : MonoBehaviour
{
    [Header("Equipment Transform")]
    public Vector3 positionOffset;
    public Vector3 rotationOffset;
    public Vector3 scale = Vector3.one;

    [Header("Equipment Type")]
    public EquipmentSlot slotType = EquipmentSlot.MainHand;

    [Header("Adjustment Speed")]
    public float positionStep = 0.1f;
    public float rotationStep = 5f;
    public float scaleStep = 0.1f;

    private Transform targetEquipment;

    void Update()
    {
        if (targetEquipment == null)
        {
            string mountPointName = slotType switch
            {
                EquipmentSlot.MainHand => "RightHandMount",
                EquipmentSlot.OffHand => "LeftHandMount",
                EquipmentSlot.Back => "BackMount",
                _ => ""
            };

            if (!string.IsNullOrEmpty(mountPointName))
            {
                var mountPoint = GameObject.Find(mountPointName);
                if (mountPoint != null && mountPoint.transform.childCount > 0)
                {
                    targetEquipment = mountPoint.transform.GetChild(0);
                }
            }
        }

        if (targetEquipment != null)
        {
            targetEquipment.localPosition = positionOffset;
            targetEquipment.localRotation = Quaternion.Euler(rotationOffset);
            targetEquipment.localScale = scale;
        }
    }

    public void CopyValuesToEquipmentManager()
    {
        var equipManager = FindFirstObjectByType<EquipmentManager>();
        if (equipManager != null)
        {
            SerializedObject serializedObject = new SerializedObject(equipManager);

            // Determine which property to modify based on slot type
            string positionProperty = slotType switch
            {
                EquipmentSlot.MainHand => "mainHandPositionOffset",
                EquipmentSlot.OffHand => "offHandPositionOffset",
                EquipmentSlot.Back => "backPositionOffset",
                _ => ""
            };

            string rotationProperty = slotType switch
            {
                EquipmentSlot.MainHand => "mainHandRotationOffset",
                EquipmentSlot.OffHand => "offHandRotationOffset",
                EquipmentSlot.Back => "backRotationOffset",
                _ => ""
            };

            string scaleProperty = slotType switch
            {
                EquipmentSlot.MainHand => "mainHandScale",
                EquipmentSlot.OffHand => "offHandScale",
                EquipmentSlot.Back => "backScale",
                _ => ""
            };

            if (!string.IsNullOrEmpty(positionProperty))
            {
                var positionProp = serializedObject.FindProperty(positionProperty);
                var rotationProp = serializedObject.FindProperty(rotationProperty);
                var scaleProp = serializedObject.FindProperty(scaleProperty);

                if (positionProp != null) positionProp.vector3Value = positionOffset;
                if (rotationProp != null) rotationProp.vector3Value = rotationOffset;
                if (scaleProp != null) scaleProp.vector3Value = scale;

                serializedObject.ApplyModifiedProperties();
                Debug.Log($"Copied values to EquipmentManager for slot {slotType}");
            }
        }
    }
}

[CustomEditor(typeof(EquipmentPositionAdjuster))]
public class EquipmentPositionAdjusterEditor : Editor
{
    public override void OnInspectorGUI()
    {
        DrawDefaultInspector();

        EquipmentPositionAdjuster adjuster = (EquipmentPositionAdjuster)target;

        if (GUILayout.Button("Copy Values to EquipmentManager"))
        {
            adjuster.CopyValuesToEquipmentManager();
        }

        EditorGUILayout.HelpBox(
            "1. Select the slot type you want to adjust\n" +
            "2. Adjust values in play mode to see real-time changes\n" +
            "3. Click 'Copy Values' when satisfied to save to EquipmentManager",
            MessageType.Info);
    }
}
#endif
public enum EquipmentSlot
{
    None,
    Head,
    Necklace,
    Back,
    Chest,
    MainHand,
    OffHand,
    Ring1,
    Ring2,
    Gloves,
    Legs,
    Boots,
    Quiver
}
using UnityEngine;
using UnityEngine.UI;
using TMPro;
using UnityEngine.EventSystems;

// Renamed from EquipmentSlot to EquipmentSlotComponent
public class EquipmentSlotComponent : MonoBehaviour
{
    [Header("Slot Configuration")]
    public EquipmentSlot slotType;          // Uses the enum EquipmentSlot
    public string displayName;              // Name shown on the slot
    
    [Header("UI Components")]
    public Image slotBackground;
    public Image itemIcon;
    public TextMeshProUGUI slotNameText;
    public TextMeshProUGUI requirementText;
    public GameObject highlightEffect;
    public Sprite emptySlotSprite;

    private void Awake()
    {
        ValidateComponents();
        InitializeSlot();
    }
    public void Initialize(EquipmentSlot type, string displayName)
{
    slotType = type;
    
    if (slotNameText != null)
        slotNameText.text = displayName;
    
    if (itemIcon != null)
        itemIcon.enabled = false;
        
    if (highlightEffect != null)
        highlightEffect.SetActive(false);
        
    if (requirementText != null)
        requirementText.text = "";
}

    private void ValidateComponents()
    {
        // Auto-find components if not assigned
        if (slotBackground == null)
            slotBackground = GetComponent<Image>();
            
        if (itemIcon == null)
            itemIcon = transform.Find("ItemIcon")?.GetComponent<Image>();
            
        if (slotNameText == null)
            slotNameText = transform.Find("SlotName")?.GetComponent<TextMeshProUGUI>();
            
        if (requirementText == null)
            requirementText = transform.Find("RequirementText")?.GetComponent<TextMeshProUGUI>();

        // Add required components
        if (GetComponent<Button>() == null)
            gameObject.AddComponent<Button>();
    }

    private void InitializeSlot()
    {
        // Set initial state
        if (slotNameText != null)
            slotNameText.text = displayName;

        if (itemIcon != null)
        {
            itemIcon.enabled = false;
            itemIcon.sprite = null;
        }

        if (requirementText != null)
            requirementText.text = "";

        if (highlightEffect != null)
            highlightEffect.SetActive(false);

        if (slotBackground != null && emptySlotSprite != null)
            slotBackground.sprite = emptySlotSprite;

        Debug.Log($"Initialized equipment slot: {displayName} ({slotType})");
    }

public void UpdateSlot(Item item)
{
    if (item != null)
    {
        if (itemIcon != null)
        {
            itemIcon.sprite = item.itemIcon;
            itemIcon.enabled = true;
            itemIcon.color = Color.white;
        }

        if (requirementText != null && item is CombatEquipment combatEquip)
        {
            requirementText.text = $"Req: {combatEquip.requiredLevel} {combatEquip.defaultAttackStyle}";
            requirementText.enabled = true;
        }
    }
    else
    {
        ClearSlot();
    }
}

    public void ClearSlot()
    {
        Debug.Log($"Clearing slot {slotType}");
        if (itemIcon != null)
        {
            itemIcon.sprite = null;
            itemIcon.enabled = false;
        }

        if (requirementText != null)
        {
            requirementText.text = "";
            requirementText.enabled = false;
        }

        if (highlightEffect != null)
        {
            highlightEffect.SetActive(false);
        }
    }

    #if UNITY_EDITOR
    private void OnValidate()
    {
        // Auto-update display name if not set
        if (string.IsNullOrEmpty(displayName))
        {
            displayName = slotType.ToString();
        }
    }
    #endif
}
using UnityEngine;
using UnityEngine.UI;
using TMPro;
using System.Collections;
using System.Collections.Generic;
using System.Linq;

public class EquipmentUI : MonoBehaviour
{
    [Header("Required References")]
    [SerializeField] private RectTransform slotsContainer;
    [SerializeField] private GameObject equipmentSlotPrefab;

    [Header("Combat Panel")]
    [SerializeField] private GameObject combatPanelPrefab;
    [SerializeField] private Transform combatPanelContainer;

    [Header("Equipment Stats")]
    [SerializeField] private TextMeshProUGUI attackBonusText;
    [SerializeField] private TextMeshProUGUI strengthBonusText;
    [SerializeField] private TextMeshProUGUI defenceBonusText;
    [SerializeField] private TextMeshProUGUI combatStyleText;

    [Header("Layout Settings")]
    [SerializeField] private float slotSpacing = 10f;
    [SerializeField] private Vector2 slotSize = new Vector2(60, 60);

    private Dictionary<EquipmentSlot, EquipmentSlotComponent> equipmentSlots = new Dictionary<EquipmentSlot, EquipmentSlotComponent>();
    private GridLayoutGroup gridLayout;
    private EquipmentManager equipmentManager;
    private EnhancedChatbox chatbox;
    private bool isInitialized = false;

    private CombatPanel combatPanel;

    private readonly Dictionary<EquipmentSlot, string> slotNames = new Dictionary<EquipmentSlot, string>()
    {
        { EquipmentSlot.Head, "Head" },
        { EquipmentSlot.Necklace, "Necklace" },
        { EquipmentSlot.Back, "Back" },
        { EquipmentSlot.Chest, "Chest" },
        { EquipmentSlot.MainHand, "Main Hand" },
        { EquipmentSlot.OffHand, "Off Hand" },
        { EquipmentSlot.Ring1, "Ring" },
        { EquipmentSlot.Ring2, "Specialty" },
        { EquipmentSlot.Gloves, "Hands" },
        { EquipmentSlot.Legs, "Legs" },
        { EquipmentSlot.Boots, "Feet" },
        { EquipmentSlot.Quiver, "Ammo" }
    };

    private void Awake()
    {
        if (slotsContainer == null)
        {
            slotsContainer = transform.Find("SlotsContainer") as RectTransform;
        }
    }


    private void OnEnable()
    {
        if (!isInitialized)
        {
            EnsureInitialized();
        }
    }

public void EnsureInitialized()
{
    if (isInitialized) return;

    if (!ValidateReferences())
    {
        Debug.LogError($"EquipmentUI on {gameObject.name}: Missing required references!");
        return;
    }

    InitializeImmediate();
}
private void InitializeImmediate()
{
    try
    {
        InitializeLayout();
        CreateEquipmentSlots();
        InitializeCombatPanel(); // Add this line
        
        equipmentManager = EquipmentManager.Instance;
        chatbox = EnhancedChatbox.Instance;

        if (equipmentManager != null)
        {
            equipmentManager.OnEquipmentChanged += HandleEquipmentChanged;
            UpdateAllSlots();
        }

        isInitialized = true;
        Debug.Log($"EquipmentUI initialized successfully on {gameObject.name}");
    }
    catch (System.Exception e)
    {
        Debug.LogError($"Error initializing EquipmentUI: {e.Message}\n{e.StackTrace}");
    }
}

private void InitializeCombatPanel()
{
    if (combatPanelPrefab != null && combatPanelContainer != null)
    {
        GameObject panelObj = Instantiate(combatPanelPrefab, combatPanelContainer);
        combatPanel = panelObj.GetComponent<CombatPanel>();
        
        if (combatPanel != null)
        {
            combatPanel.UpdateUI();
        }
        else
        {
            Debug.LogError("CombatPanel component not found on prefab!");
        }
    }
}

    private bool ValidateReferences()
    {
        if (slotsContainer == null)
        {
            Debug.LogError($"EquipmentUI on {gameObject.name}: SlotsContainer is null!");
            return false;
        }

        if (equipmentSlotPrefab == null)
        {
            Debug.LogError($"EquipmentUI on {gameObject.name}: EquipmentSlotPrefab is null!");
            return false;
        }

        return true;
    }

    private IEnumerator InitializeCoroutine()
    {
        yield return null; // Wait a frame

        try
        {
            InitializeLayout();
            CreateEquipmentSlots();
            
            equipmentManager = EquipmentManager.Instance;
            chatbox = EnhancedChatbox.Instance;

            if (equipmentManager != null)
            {
                equipmentManager.OnEquipmentChanged += HandleEquipmentChanged;
                UpdateAllSlots(); // Update initial state
            }

            isInitialized = true;
            Debug.Log($"EquipmentUI initialized successfully on {gameObject.name}");
        }
        catch (System.Exception e)
        {
            Debug.LogError($"Error initializing EquipmentUI: {e.Message}\n{e.StackTrace}");
        }
    }

    private void InitializeLayout()
    {
        if (slotsContainer == null)
        {
            throw new System.NullReferenceException("SlotsContainer is null during InitializeLayout");
        }

        // Remove any existing layout
        var existingLayout = slotsContainer.GetComponent<GridLayoutGroup>();
        if (existingLayout != null)
        {
            DestroyImmediate(existingLayout);
        }

        // Add new layout
        gridLayout = slotsContainer.gameObject.AddComponent<GridLayoutGroup>();
        gridLayout.cellSize = slotSize;
        gridLayout.spacing = new Vector2(slotSpacing, slotSpacing);
        gridLayout.constraint = GridLayoutGroup.Constraint.FixedColumnCount;
        gridLayout.constraintCount = 3;
        
        var fitter = slotsContainer.gameObject.AddComponent<ContentSizeFitter>();
        fitter.horizontalFit = ContentSizeFitter.FitMode.PreferredSize;
        fitter.verticalFit = ContentSizeFitter.FitMode.PreferredSize;

        if (combatPanel != null)
        {
            combatPanel.UpdateUI();
        }
    }

    private void CreateEquipmentSlots()
    {
        // Clear existing slots
        foreach (Transform child in slotsContainer)
        {
            Destroy(child.gameObject);
        }
        equipmentSlots.Clear();

        // Define slot layout
        var slotLayout = new[]
        {
            EquipmentSlot.None,
            EquipmentSlot.Head,
            EquipmentSlot.None,
            
            EquipmentSlot.Back,
            EquipmentSlot.Necklace,
            EquipmentSlot.Quiver,
            
            EquipmentSlot.MainHand,
            EquipmentSlot.Chest,
            EquipmentSlot.OffHand,
            
            EquipmentSlot.Gloves,
            EquipmentSlot.Legs,
            EquipmentSlot.Ring1,
            
            EquipmentSlot.None,
            EquipmentSlot.Boots,
            EquipmentSlot.Ring2
        };

        foreach (var slotType in slotLayout)
        {
            if (slotType == EquipmentSlot.None)
            {
                CreateEmptySpacer();
                continue;
            }

            GameObject slotObj = Instantiate(equipmentSlotPrefab, slotsContainer);
            var slotComponent = slotObj.GetComponent<EquipmentSlotComponent>();
            
            if (slotComponent != null)
            {
                string displayName = slotNames.TryGetValue(slotType, out string name) ? name : "Equipment";
                slotComponent.Initialize(slotType, displayName);
                equipmentSlots[slotType] = slotComponent;

                // Add click handler
                Button button = slotObj.GetComponent<Button>();
                if (button != null)
                {
                    var slotTypeCopy = slotType; // Prevent closure issues
                    button.onClick.AddListener(() => HandleSlotClick(slotTypeCopy));
                }
            }
        }
    }

    private void CreateEmptySpacer()
    {
        GameObject spacer = new GameObject("Spacer");
        spacer.transform.SetParent(slotsContainer, false);
        
        RectTransform rt = spacer.AddComponent<RectTransform>();
        rt.sizeDelta = slotSize;
    }

    private void HandleSlotClick(EquipmentSlot slot)
    {
        if (equipmentManager == null) return;

        var equippedItem = equipmentManager.GetEquippedItem(slot);
        if (equippedItem != null)
        {
            if (Inventory.Instance != null && !Inventory.Instance.IsFull())
            {
                // Clear UI first
                if (equipmentSlots.TryGetValue(slot, out var slotComponent))
                {
                    slotComponent.ClearSlot();
                }
                
                equipmentManager.UnequipItem(slot);
                chatbox?.AddMessage($"Unequipped {equippedItem.itemName}");
            }
            else
            {
                chatbox?.AddMessage("Not enough inventory space to unequip item.");
            }
        }
    }

    private void HandleEquipmentChanged(EquipmentSlot slot, Item item)
    {
        UpdateEquipmentSlot(slot, item);
        UpdateBonusDisplay();
        if (combatPanel != null)
        {
            combatPanel.UpdateUI();
        }
    }
        public void SetCombatPanel(CombatPanel panel)
    {
        combatPanel = panel;
        if (combatPanel != null)
        {
            combatPanel.UpdateUI();
        }
    }

    public void UpdateEquipmentSlot(EquipmentSlot slot, Item item)
    {
        Debug.Log($"UpdateEquipmentSlot called for {slot} with item: {item?.itemName ?? "null"}");
        
        if (equipmentSlots.TryGetValue(slot, out var slotComponent))
        {
            try
            {
                if (slotComponent == null)
                {
                    Debug.LogError($"Slot component is null for slot {slot}");
                    return;
                }

                // Update the slot's visual elements
                slotComponent.UpdateSlot(item);
                
                // Update combat panel if weapon changed
                if (slot == EquipmentSlot.MainHand && combatPanel != null)
                {
                    combatPanel.UpdateUI();
                }
                
                // Force layout refresh
                LayoutRebuilder.ForceRebuildLayoutImmediate(slotComponent.GetComponent<RectTransform>());
            }
            catch (System.Exception e)
            {
                Debug.LogError($"Error updating equipment slot {slot}: {e.Message}\n{e.StackTrace}");
            }
        }
        else
        {
            Debug.LogError($"No slot component found for equipment slot: {slot}");
        }
    }

    // Add this method to validate all equipment slots
    public void ValidateAllSlots()
    {
        foreach (var kvp in equipmentSlots)
        {
            var slot = kvp.Key;
            var component = kvp.Value;
            
            if (component == null)
            {
                Debug.LogError($"Null component found for slot {slot}");
                continue;
            }

            if (component.itemIcon == null)
            {
                Debug.LogError($"Null itemIcon reference in slot {slot}");
            }

            // Force update from current equipment
            var equippedItem = EquipmentManager.Instance?.GetEquippedItem(slot);
            if (equippedItem != null)
            {
                UpdateEquipmentSlot(slot, equippedItem);
            }
        }
    }


private void UpdateBonusDisplay()
{
    if (equipmentManager == null) return;

    int totalAttack = 0;
    int totalMight = 0;
    int totalFortitude = 0;
    AttackStyle? mainhandStyle = null;

    var equippedItems = equipmentManager.GetAllEquippedItems();
    foreach (var kvp in equippedItems)
    {
        if (kvp.Value is CombatEquipment combatEquip)
        {
            var bonuses = combatEquip.bonuses;
            totalAttack += bonuses.GetAttackBonus(combatEquip.defaultAttackStyle);
            totalMight += bonuses.mightBonus;
            totalFortitude += bonuses.GetDefenseBonus(combatEquip.defaultAttackStyle);

            if (kvp.Key == EquipmentSlot.MainHand)
            {
                mainhandStyle = combatEquip.defaultAttackStyle;
            }
        }
    }

    if (attackBonusText != null)
        attackBonusText.text = $"Attack: +{totalAttack}";
    
    if (strengthBonusText != null)
        strengthBonusText.text = $"Might: +{totalMight}";
    
    if (defenceBonusText != null)
        defenceBonusText.text = $"Fortitude: +{totalFortitude}";
    
    if (combatStyleText != null)
        combatStyleText.text = $"Style: {mainhandStyle?.ToString() ?? "None"}";
}

    private void UpdateAllSlots()
    {
        if (equipmentManager == null) return;

        foreach (var slot in equipmentSlots)
        {
            var item = equipmentManager.GetEquippedItem(slot.Key);
            slot.Value.UpdateSlot(item);
        }

        UpdateBonusDisplay();
    }

    private void OnDestroy()
    {
        if (equipmentManager != null)
        {
            equipmentManager.OnEquipmentChanged -= HandleEquipmentChanged;
        }
    }

    #if UNITY_EDITOR
    private void OnValidate()
    {
        if (!Application.isPlaying) return;

        if (enabled && (slotsContainer == null || equipmentSlotPrefab == null))
        {
            Debug.LogWarning("EquipmentUI: Missing required references!");
        }
    }
    #endif
}
using UnityEngine;
using System;

public static class ExperienceTable
{
    private static readonly double[] xpTable;
    public const int MAX_LEVEL = 300;
    public const int MAX_VIRTUAL_LEVEL = 500;
    private const double BASE_XP = 83; 
    private const double INITIAL_SCALE = 1.065; // Early level scaling (1-50)
    private const double MID_SCALE = 1.085;    // Mid level scaling (50-99)
    private const double HIGH_SCALE = 1.095;   // High level scaling (99-300)
    private const double VIRTUAL_SCALE = 1.0;  // Virtual level scaling (301-500)
    
    // Milestone levels where scaling changes
    private const int MEDIUM_MILESTONE = 50;
    private const int HIGH_MILESTONE = 99;
    private const double TARGET_MAX_XP = 1_000_000_000; // 1 billion XP target for level 300
    private const double VIRTUAL_TARGET_XP = 2_000_000_000; // 2 billion XP for virtual level 500

    static ExperienceTable()
    {
        xpTable = new double[MAX_VIRTUAL_LEVEL + 1];
        GenerateXPTable();
    }

    private static void GenerateXPTable()
    {
        xpTable[1] = 0; // Level 1 starts at 0 XP
        double xp = 0;

        // Early levels (1-50) - Gentle curve for new players
        for (int level = 1; level < MEDIUM_MILESTONE; level++)
        {
            xp += BASE_XP * Math.Pow(INITIAL_SCALE, level - 1);
            xpTable[level + 1] = Math.Floor(xp);
        }

        // Mid levels (50-99) - Steeper curve
        for (int level = MEDIUM_MILESTONE; level < HIGH_MILESTONE; level++)
        {
            double multiplier = 1.0 + (level - MEDIUM_MILESTONE) * 0.015;
            xp += BASE_XP * Math.Pow(MID_SCALE, level - 1) * multiplier;
            xpTable[level + 1] = Math.Floor(xp);
        }

        // High levels (99-300) - Long-term achievement curve
        double remainingLevels = MAX_LEVEL - HIGH_MILESTONE;
        double xpAt99 = xpTable[HIGH_MILESTONE];
        double remainingXP = TARGET_MAX_XP - xpAt99;
        
        for (int level = HIGH_MILESTONE; level < MAX_LEVEL; level++)
        {
            double progressionRatio = (level - HIGH_MILESTONE) / remainingLevels;
            double scaledMultiplier = Math.Pow(HIGH_SCALE, progressionRatio * 2);
            double levelXP = (remainingXP / remainingLevels) * scaledMultiplier;
            
            xp += levelXP;
            xpTable[level + 1] = Math.Floor(xp);
        }

        // Virtual levels (301-500)
        double virtualStartXP = TARGET_MAX_XP;
        double virtualRemainingXP = VIRTUAL_TARGET_XP - virtualStartXP;
        
        for (int level = MAX_LEVEL; level < MAX_VIRTUAL_LEVEL; level++)
        {
            xp = virtualStartXP + (virtualRemainingXP * Math.Pow((level - MAX_LEVEL) / (double)(MAX_VIRTUAL_LEVEL - MAX_LEVEL), VIRTUAL_SCALE));
            xpTable[level + 1] = Math.Floor(xp);
        }

        LogMilestones();
    }

    // Combat level calculation based on the new formula
    public static int CalculateCombatLevel(int fortitude, int vitality, int divinity, int highestCombatSkill)
    {
        double combatLevel = (fortitude + vitality + (divinity / 2.0) + highestCombatSkill) / 5.0;
        return Math.Min(240, (int)Math.Floor(combatLevel));
    }

    // Vitality XP calculations
    public static float CalculateVitalityXP(float damageDealt, AttackStyle style)
    {
        float baseXP = damageDealt * 50.54f;
        return style switch
        {
            AttackStyle.Stab or AttackStyle.Slash or AttackStyle.Crush => baseXP * 0.25f,
            AttackStyle.Range => baseXP * 0.333f,
            AttackStyle.Spellweaving => baseXP,
            _ => 0f
        };
    }

    private static void LogMilestones()
    {
        Debug.Log("=== XP Table Milestones ===");
        int[] milestones = { 2, 10, 25, 50, 75, 99, 150, 200, 250, 300, 400, 500 };
        
        foreach (int level in milestones)
        {
            if (level > MAX_VIRTUAL_LEVEL) break;
            
            double xpForLevel = xpTable[level];
            double xpForPrevious = xpTable[level - 1];
            double xpDifference = xpForLevel - xpForPrevious;
            
            Debug.Log($"Level {level,-3}: {FormatXP(xpForLevel),-10} XP " +
                     $"(+{FormatXP(xpDifference)} from previous)");
            
            if (level == 99 || level == 150 || level == 200 || level == 250 || level == 300 || level == 500)
            {
                Debug.Log($"Percentage of max XP: {(xpForLevel / VIRTUAL_TARGET_XP * 100):F2}%");
            }
        }
    }

    public static string FormatXP(double xp)
    {
        if (xp >= 1_000_000_000)
            return $"{xp / 1_000_000_000:N2}B";
        if (xp >= 1_000_000)
            return $"{xp / 1_000_000:N2}M";
        if (xp >= 1_000)
            return $"{xp / 1_000:N2}K";
        return $"{xp:N0}";
    }

    public static int GetLevel(double xp)
    {
        for (int level = 1; level < xpTable.Length; level++)
        {
            if (xp < xpTable[level]) return level - 1;
        }
        return MAX_VIRTUAL_LEVEL;
    }

    public static double GetXPForLevel(int level)
    {
        if (level <= 0) return 0;
        if (level > MAX_VIRTUAL_LEVEL) return xpTable[MAX_VIRTUAL_LEVEL];
        return xpTable[level];
    }

    public static double GetXPToNextLevel(int currentLevel, double currentXP)
    {
        if (currentLevel >= MAX_VIRTUAL_LEVEL) return 0;
        return xpTable[currentLevel + 1] - currentXP;
    }

    public static float GetProgressToNextLevel(double currentXP)
    {
        int currentLevel = GetLevel(currentXP);
        if (currentLevel >= MAX_VIRTUAL_LEVEL) return 1f;

        double levelStartXP = GetXPForLevel(currentLevel);
        double levelEndXP = GetXPForLevel(currentLevel + 1);
        return (float)((currentXP - levelStartXP) / (levelEndXP - levelStartXP));
    }

    public static string GetXPRateInfo(int currentLevel, double xpPerAction, double actionsPerHour)
    {
        double xpPerHour = xpPerAction * actionsPerHour;
        double xpToNextLevel = GetXPToNextLevel(currentLevel, GetXPForLevel(currentLevel));
        double hoursToNextLevel = xpToNextLevel / xpPerHour;

        return $"XP Rate: {FormatXP(xpPerHour)}/hr\n" +
               $"Time to level: {(hoursToNextLevel >= 1 ? $"{hoursToNextLevel:F1} hours" : $"{hoursToNextLevel * 60:F0} minutes")}";
    }
}
using UnityEngine;

public interface ICombatant
{
    CombatStats Stats { get; }
    bool IsAlive => Stats.Vitality > 0;
    Transform transform { get; }
    void TakeDamage(int damage, AttackStyle style);
    void Attack(ICombatant target);
    float GetAttackSpeed();
    AttackStyle GetCurrentCombatStyle();
    string GetDisplayName();
}
using UnityEngine;

[RequireComponent(typeof(Collider))]
public class InteractiveObject : MonoBehaviour
{
    [Header("Highlight Settings")]
    public Color hoverColor = new Color(1f, 1f, 1f, 0.3f);
    public float outlineWidth = 0.02f;
    
    private Material originalMaterial;
    private Material highlightMaterial;
    private Renderer objectRenderer;
    private bool isHovered = false;

    private void Start()
    {
        objectRenderer = GetComponent<Renderer>();
        if (objectRenderer != null)
        {
            // Store the original material
            originalMaterial = objectRenderer.material;
            
            // Create highlight material
            highlightMaterial = new Material(Shader.Find("Standard"));
            highlightMaterial.color = hoverColor;
        }
    }
    public void SetupInteractiveObject(GameObject obj)
{
    // Add required components
    var collider = obj.GetComponent<Collider>() ?? obj.AddComponent<BoxCollider>();
    var worldInteractable = obj.GetComponent<WorldInteractable>() ?? obj.AddComponent<WorldInteractable>();
    var interactive = obj.GetComponent<InteractiveObject>() ?? obj.AddComponent<InteractiveObject>();

    // Configure the components
    collider.isTrigger = true; // Optional, depends on your needs
    worldInteractable.objectName = obj.name;
    
    // Make sure there's a renderer for the highlight effect
    var renderer = obj.GetComponent<Renderer>();
    if (renderer == null)
    {
        Debug.LogWarning($"Object {obj.name} needs a Renderer for highlight effects to work");
    }
}

    private void OnMouseEnter()
    {
        if (objectRenderer != null && !isHovered)
        {
            // Change cursor
            Cursor.SetCursor(CursorManager.Instance.interactiveCursor, Vector2.zero, CursorMode.Auto);
            
            // Add outline effect
            Material[] materials = objectRenderer.materials;
            System.Array.Resize(ref materials, materials.Length + 1);
            materials[materials.Length - 1] = highlightMaterial;
            objectRenderer.materials = materials;
            
            isHovered = true;
        }
    }

    private void OnMouseExit()
    {
        if (objectRenderer != null && isHovered)
        {
            // Reset cursor
            Cursor.SetCursor(null, Vector2.zero, CursorMode.Auto);
            
            // Remove outline effect
            Material[] materials = objectRenderer.materials;
            System.Array.Resize(ref materials, materials.Length - 1);
            objectRenderer.materials = materials;
            
            isHovered = false;
        }
    }

    private void OnDestroy()
    {
        if (highlightMaterial != null)
        {
            Destroy(highlightMaterial);
        }
    }
}
using UnityEngine;
using System.Collections.Generic;

public class Inventory : MonoBehaviour
{
    public static Inventory Instance { get; private set; }

    private InventoryUI inventoryUI;
    public int maxSlots = 32;
    public List<InventorySlot> slots = new List<InventorySlot>();
    public event System.Action OnInventoryChanged;

    private void Awake()
    {
        if (Instance == null)
        {
            Instance = this;
            DontDestroyOnLoad(gameObject);
        }
        else
        {
            Destroy(gameObject);
        }
    }

    private void Start()
    {
        InitializeInventory();
        FindInventoryUI();
    }
private void FindInventoryUI()
{
    if (inventoryUI == null)
    {
        inventoryUI = FindFirstObjectByType<InventoryUI>();
        if (inventoryUI == null)
        {
            Debug.LogError("InventoryUI not found! Please ensure it exists in the scene.");
        }
        else
        {
            Debug.Log("Successfully found InventoryUI reference");
        }
    }
}

    private void InitializeInventory()
    {
        slots.Clear();
        for (int i = 0; i < maxSlots; i++)
        {
            slots.Add(new InventorySlot());
        }
    }

    public bool AddItem(Item item, int quantity)
    {
        if (item == null)
        {
            Debug.LogError("Attempted to add null item to inventory!");
            return false;
        }

        Debug.Log($"Attempting to add {quantity}x {item.itemName} to inventory");

        bool added = false;
        if (item.isStackable)
        {
            // Try to stack with existing items
            foreach (var slot in slots)
            {
                if (slot.Item == item && slot.Quantity < item.maxStack)
                {
                    int availableSpace = item.maxStack - slot.Quantity;
                    int addQuantity = Mathf.Min(quantity, availableSpace);

                    slot.AddQuantity(addQuantity);
                    quantity -= addQuantity;
                    added = true;

                    if (quantity <= 0)
                    {
                        NotifyInventoryChanged();
                        return true;
                    }
                }
            }
        }
    

        // If we still have quantity to add or item isn't stackable
        foreach (var slot in slots)
        {
            if (slot.IsEmpty)
            {
                slot.SetSlot(item, quantity);
                Debug.Log($"Added {item.itemName} to empty slot");
                NotifyInventoryChanged();
                return true;
            }
        }

        if (!added)
        {
            EnhancedChatbox.Instance?.AddMessage("Inventory is full!", EnhancedChatbox.MessageType.System);
        }
        return added;
    }

    // Add this method for manual UI refresh
public void ForceUIUpdate()
{
    Debug.Log("Forcing inventory UI update");
    if (inventoryUI == null)
    {
        inventoryUI = FindFirstObjectByType<InventoryUI>();
    }
    if (inventoryUI != null)
    {
        inventoryUI.UpdateUI();
    }
}


    public int GetItemCount(Item item)
    {
        int total = 0;
        foreach (var slot in slots)
        {
            if (slot.Item == item)
            {
                total += slot.Quantity;
            }
        }
        return total;
    }

    public bool HasItem(Item item, int quantity = 1)
    {
        return GetItemCount(item) >= quantity;
    }

    public void RemoveItem(Item item, int quantity)
    {
        int remainingToRemove = quantity;

        foreach (var slot in slots)
        {
            if (slot.Item == item)
            {
                if (slot.Quantity >= remainingToRemove)
                {
                    slot.AddQuantity(-remainingToRemove);
                    if (slot.Quantity <= 0)
                    {
                        slot.ClearSlot();
                    }
                    NotifyInventoryChanged();
                    return;
                }
                else
                {
                    remainingToRemove -= slot.Quantity;
                    slot.ClearSlot();
                }
            }
        }

        NotifyInventoryChanged();
    }

    public bool IsFull()
    {
        return !slots.Exists(slot => slot.IsEmpty);
    }

    private void NotifyInventoryChanged()
    {
        Debug.Log("Inventory changed, notifying listeners");
        OnInventoryChanged?.Invoke();

        if (inventoryUI == null)
        {
            FindInventoryUI();
        }

        if (inventoryUI != null)
        {
            Debug.Log("Updating InventoryUI after change");
            inventoryUI.UpdateUI();
        }
        else
        {
            Debug.LogError("InventoryUI still not found during notification!");
            // Try one last time to find it using a different method
            var ui = GameObject.FindObjectOfType<InventoryUI>();
            if (ui != null)
            {
                inventoryUI = ui;
                inventoryUI.UpdateUI();
                Debug.Log("Found InventoryUI using alternative method");
            }
        }
    }

    public Tool GetToolOfType(ToolType toolType)
    {
        foreach (var slot in slots)
        {
            if (slot.Item is Tool tool && tool.toolType == toolType)
            {
                return tool;
            }
        }
        return null;
    }
}
using UnityEngine;
using UnityEngine.EventSystems;
using System.Collections.Generic;

public class InventoryItemUI : MonoBehaviour, IPointerClickHandler
{
    public Item item { get; private set; }
    private InventorySlot slot;
    private Inventory inventory;

    public void Initialize(Item newItem, InventorySlot newSlot)
    {
        item = newItem;
        slot = newSlot;
        inventory = FindFirstObjectByType<Inventory>();
    }

    public void OnPointerClick(PointerEventData eventData)
    {
        if (item == null) return;

        if (eventData.button == PointerEventData.InputButton.Left)
        {
            HandleLeftClick();
        }
        else if (eventData.button == PointerEventData.InputButton.Right)
        {
            ShowContextMenu();
        }
    }

    private void HandleLeftClick()
    {
        if (item == null) return;

        // Handle based on item type
        if (item.CanEquip)
        {
            EquipItem();
        }
        else if (item.CanConsume)
        {
            ConsumeItem();
        }
        else if (item.itemType == ItemType.Resource)
        {
            // For resources, show examine info
            ExamineItem();
        }
        else
        {
            // Default to examine for unknown types
            ExamineItem();
        }
    }

    private void ShowContextMenu()
    {
        if (item == null || ContextMenu.Instance == null) return;

        List<ContextMenuOption> options = new List<ContextMenuOption>();

        // Add options based on item type
        if (item.CanEquip)
        {
            options.Add(new ContextMenuOption("Equip", EquipItem));
        }

        if (item.CanConsume)
        {
            options.Add(new ContextMenuOption("Use", ConsumeItem));
        }

        // Always add examine and drop options
        options.Add(new ContextMenuOption("Examine", ExamineItem));
        options.Add(new ContextMenuOption("Drop", DropItem));

        ContextMenu.Instance.ShowMenu(Input.mousePosition, options);
    }

    private void EquipItem()
    {
        if (item == null) return;

        Debug.Log($"Attempting to equip: {item.itemName}");
        bool equipped = false;

        try
        {
            if (item is CombatEquipment || item.CanEquip)
            {
                equipped = EquipmentManager.Instance.EquipItem(item);
            }

            if (equipped)
            {
                inventory.RemoveItem(item, 1);
                EnhancedChatbox.Instance?.AddMessage($"Equipped {item.itemName}");
                Debug.Log($"Successfully equipped {item.itemName}");
            }
            else
            {
                EnhancedChatbox.Instance?.AddMessage($"Cannot equip {item.itemName}");
                Debug.Log($"Failed to equip {item.itemName}");
            }
        }
        catch (System.Exception e)
        {
            Debug.LogError($"Error equipping item: {e.Message}\n{e.StackTrace}");
            EnhancedChatbox.Instance?.AddMessage("Error equipping item");
        }
    }

    private void ConsumeItem()
    {
        if (item == null || !item.CanConsume) return;

        Debug.Log($"Using item: {item.itemName}");
        inventory.RemoveItem(item, 1);
        EnhancedChatbox.Instance?.AddMessage($"You used {item.itemName}.");
    }

    private void ExamineItem()
    {
        if (item == null) return;
        EnhancedChatbox.Instance?.AddMessage($"It's a {item.itemName}. {item.description}");
    }

    private void DropItem()
    {
        if (item == null) return;

        GameObject player = GameObject.FindGameObjectWithTag("Player");
        if (player != null)
        {
            Vector3 dropPos = player.transform.position - player.transform.forward;
            SpawnDroppedItem(dropPos);
            inventory.RemoveItem(item, 1);
            EnhancedChatbox.Instance?.AddMessage($"You dropped {item.itemName}");
        }
    }

    private void SpawnDroppedItem(Vector3 position)
    {
        GameObject droppedObj = new GameObject($"Dropped_{item.itemName}");
        droppedObj.transform.position = position;
        
        var itemComponent = droppedObj.AddComponent<DroppedItem>();
        itemComponent.Initialize(item, 1, 180f); // 3 minute despawn timer

        Debug.Log($"Spawned dropped item: {item.itemName} at {position}");
    }
}
using UnityEngine;

[System.Serializable]
public class InventorySlot
{
    [SerializeField] private Item _item;
    [SerializeField] private int _quantity;

    public Item Item => _item;
    public int Quantity => _quantity;

    public bool IsEmpty => _item == null;

    public InventorySlot()
    {
        ClearSlot();
    }

    public InventorySlot(Item item, int quantity)
    {
        SetSlot(item, quantity);
    }

public void SetSlot(Item item, int quantity)
{
    Debug.Log($"Setting slot with item: {item?.itemName ?? "null"} x{quantity}");
    _item = item;
    _quantity = Mathf.Max(0, quantity);

    // If quantity is 0, clear the slot
    if (_quantity == 0)
    {
        ClearSlot();
    }
}

    public void ClearSlot()
    {
        _item = null;
        _quantity = 0;
    }

    public void AddQuantity(int amount)
    {
        _quantity = Mathf.Max(0, _quantity + amount);
        if (_quantity == 0) _item = null;
    }

    public bool CanAddItem(Item item, int amount)
    {
        return IsEmpty || (_item == item && _item.isStackable);
    }
}
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.EventSystems;
using TMPro;
using System.Collections.Generic;

public class InventorySlotUI : MonoBehaviour, IPointerClickHandler
{
    public Image itemIcon;
    public TMP_Text quantityText;
    public int slotIndex;
    
    private Item _currentItem;
    private int _currentQuantity;
    private Inventory inventoryRef;
    private EquipmentManager equipmentManager;
        public Item CurrentItem => _currentItem;
    public int CurrentQuantity => _currentQuantity;

    private void Start()
    {
        // Get references
        inventoryRef = Inventory.Instance;
        if (inventoryRef == null)
        {
            Debug.LogError("Inventory Instance not found!");
        }

        equipmentManager = EquipmentManager.Instance;
        if (equipmentManager == null)
        {
            Debug.LogError("EquipmentManager Instance not found!");
        }
    }

    public void OnPointerClick(PointerEventData eventData)
    {
        if (_currentItem == null) return;

        if (eventData.button == PointerEventData.InputButton.Left)
        {
            HandleLeftClick();
        }
        else if (eventData.button == PointerEventData.InputButton.Right)
        {
            ShowContextMenu();
            eventData.Use();
        }
    }

    private void HandleLeftClick()
    {
        if (_currentItem == null) return;

        if (_currentItem.CanEquip)
        {
            HandleEquip();
        }
        else if (_currentItem.CanConsume)
        {
            HandleConsume();
        }
    }

private void ShowContextMenu()
{
    if (_currentItem == null || ContextMenu.Instance == null)
    {
        Debug.LogWarning("Cannot show context menu: " + 
            (_currentItem == null ? "No item selected" : "ContextMenu not found in scene"));
        return;
    }

    List<ContextMenuOption> options = new List<ContextMenuOption>();

    if (_currentItem.CanEquip)
    {
        options.Add(new ContextMenuOption("Equip", () => HandleEquip()));
    }

    if (_currentItem.CanConsume)
    {
        options.Add(new ContextMenuOption("Use", () => HandleConsume()));
    }

    options.Add(new ContextMenuOption("Drop", () => HandleDrop()));
    options.Add(new ContextMenuOption("Examine", () => HandleExamine()));

    ContextMenu.Instance.ShowMenu(Input.mousePosition, options);
}

public void HandleEquip()
{
    if (_currentItem == null || equipmentManager == null)
    {
        Debug.LogWarning($"Cannot equip - Item: {_currentItem != null}, EquipManager: {equipmentManager != null}");
        return;
    }

    if (!_currentItem.CanEquip)
    {
        Debug.LogWarning($"Item {_currentItem.itemName} cannot be equipped");
        return;
    }

    Debug.Log($"Attempting to equip {_currentItem.itemName}");
    
    // Store item reference before removing from inventory
    Item itemToEquip = _currentItem;
    
    // Remove from inventory first
    inventoryRef.RemoveItem(_currentItem, 1);
    
    // Then equip the item
    bool equipped = equipmentManager.EquipItem(itemToEquip);

    if (equipped)
    {
        EnhancedChatbox.Instance?.AddMessage($"Equipped {itemToEquip.itemName}");
        ContextMenu.Instance?.HideMenu();
    }
    else
    {
        // If equipping fails, add the item back to inventory
        inventoryRef.AddItem(itemToEquip, 1);
        EnhancedChatbox.Instance?.AddMessage($"Cannot equip {itemToEquip.itemName}");
    }
}
    private void HandleConsume()
    {
        if (_currentItem == null || !_currentItem.CanConsume) return;

        Debug.Log($"Using {_currentItem.itemName}");
        inventoryRef.RemoveItem(_currentItem, 1);
        EnhancedChatbox.Instance?.AddMessage($"You used {_currentItem.itemName}");
    }

    private void HandleDrop()
    {
        if (_currentItem == null) return;

        GameObject player = GameObject.FindGameObjectWithTag("Player");
        if (player != null)
        {
            Vector3 dropPos = player.transform.position - player.transform.forward;
            SpawnDroppedItem(dropPos);
            inventoryRef.RemoveItem(_currentItem, 1);
            EnhancedChatbox.Instance?.AddMessage($"Dropped {_currentItem.itemName}");
        }
    }

    private void HandleExamine()
    {
        if (_currentItem == null) return;
        EnhancedChatbox.Instance?.AddMessage($"It's a {_currentItem.itemName}. {_currentItem.description}");
    }

    public void UpdateSlotUI(Item item, int quantity)
    {
        Debug.Log($"Updating slot {slotIndex} UI with item: {item?.itemName ?? "null"} x{quantity}");
        _currentItem = item;
        _currentQuantity = quantity;

        if (itemIcon == null)
        {
            Debug.LogError($"ItemIcon is null on slot {slotIndex}");
            return;
        }

        if (item != null)
        {
            if (item.itemIcon == null)
            {
                Debug.LogError($"Item {item.itemName} has no icon sprite assigned!");
                return;
            }

            // Set and enable the icon with full opacity
            itemIcon.sprite = item.itemIcon;
            itemIcon.enabled = true;
            itemIcon.color = Color.white;
            
            // Update quantity text
            if (quantityText != null)
            {
                quantityText.text = item.isStackable && quantity > 1 ? quantity.ToString() : "";
                quantityText.enabled = item.isStackable && quantity > 1;
            }
            
            Debug.Log($"Updated slot {slotIndex} with {item.itemName}, sprite: {(item.itemIcon != null)}, enabled: {itemIcon.enabled}");
        }
        else
        {
            // Clear the slot
            itemIcon.sprite = null;
            itemIcon.enabled = false;
            if (quantityText != null)
            {
                quantityText.text = "";
                quantityText.enabled = false;
            }
            
            Debug.Log($"Cleared slot {slotIndex}");
        }
    }

    private void SpawnDroppedItem(Vector3 position)
    {
        GameObject droppedObj = new GameObject($"Dropped_{_currentItem.itemName}");
        droppedObj.transform.position = position;
        
        var itemComponent = droppedObj.AddComponent<DroppedItem>();
        itemComponent.Initialize(_currentItem, 1, 180f); // 3 minute despawn
    }
}
using UnityEngine;
using System.Collections.Generic;

public class InventoryUI : MonoBehaviour
{
    public GameObject slotPrefab;
    public Transform slotParent;
    private Inventory inventory;
    private InventorySlotUI[] slotUIs;

        private void Awake()
    {
        // Ensure this component isn't destroyed when loading new scenes
        DontDestroyOnLoad(gameObject);
    }
       private void Start()
    {
        Debug.Log("InventoryUI starting initialization");
        inventory = Inventory.Instance;
        if (inventory == null)
        {
            Debug.LogError("Inventory instance not found!");
            return;
        }
        InitializeSlots();
        UpdateUI();
    }

    private void InitializeSlots()
    {
        // Clear existing slots
        foreach (Transform child in slotParent)
        {
            Destroy(child.gameObject);
        }

        slotUIs = new InventorySlotUI[inventory.slots.Count];

        // Create slots to match inventory capacity
        for (int i = 0; i < inventory.slots.Count; i++)
        {
            GameObject newSlot = Instantiate(slotPrefab, slotParent);
            InventorySlotUI slotUI = newSlot.GetComponent<InventorySlotUI>();
            if (slotUI != null)
            {
                slotUI.slotIndex = i;
                slotUIs[i] = slotUI;
            }
        }
    }
public void ValidateSlots()
{
    Debug.Log("Validating inventory slots...");
    foreach (var slotUI in slotUIs)
    {
        if (slotUI == null)
        {
            Debug.LogError("Found null slot UI!");
            continue;
        }

        if (slotUI.itemIcon == null)
        {
            Debug.LogError($"Slot {slotUI.slotIndex} has null itemIcon reference!");
            continue;
        }

        var currentItem = slotUI.CurrentItem;
        if (currentItem != null)
        {
            Debug.Log($"Slot {slotUI.slotIndex}: Item={currentItem.itemName}, " +
                     $"Icon Enabled={slotUI.itemIcon.enabled}, " +
                     $"Has Sprite={slotUI.itemIcon.sprite != null}");
        }
    }
}

    public void UpdateUI()
    {
        if (inventory == null)
        {
            Debug.LogError("Cannot update UI - Inventory reference is null!");
            inventory = Inventory.Instance;
            if (inventory == null) return;
        }

        Debug.Log("Updating Inventory UI");
        if (slotUIs == null || slotUIs.Length != inventory.slots.Count)
        {
            Debug.Log("Reinitializing slots due to mismatch");
            InitializeSlots();
        }

        foreach (var slotUI in slotUIs)
        {
            if (slotUI != null)
            {
                int index = System.Array.IndexOf(slotUIs, slotUI);
                var slot = inventory.slots[index];
                slotUI.UpdateSlotUI(slot.Item, slot.Quantity);
            }
        }
    }

        public void SwapItems(int slotIndexA, int slotIndexB)
    {
        if (slotIndexA == slotIndexB) return;
        if (slotIndexA < 0 || slotIndexB < 0 || 
            slotIndexA >= inventory.slots.Count || 
            slotIndexB >= inventory.slots.Count)
        {
            Debug.LogWarning("Invalid slot indices for swap operation");
            return;
        }

        // Swap the items in the inventory
        var tempSlot = inventory.slots[slotIndexA];
        inventory.slots[slotIndexA] = inventory.slots[slotIndexB];
        inventory.slots[slotIndexB] = tempSlot;

        // Update only the affected slots
        slotUIs[slotIndexA].UpdateSlotUI(inventory.slots[slotIndexA].Item, inventory.slots[slotIndexA].Quantity);
        slotUIs[slotIndexB].UpdateSlotUI(inventory.slots[slotIndexB].Item, inventory.slots[slotIndexB].Quantity);

        Debug.Log($"Swapped items in slots {slotIndexA} and {slotIndexB}");
    }
}

public interface ISkill
{
    string SkillName { get; }
    int CurrentLevel { get; }
    double CurrentXP { get; }
    void AddExperience(double xp);
    bool HasRequirement(int level);
}
using UnityEngine;

[CreateAssetMenu(fileName = "New Item", menuName = "Inventory/Item")]
public class Item : ScriptableObject
{
    public string itemName;
    public Sprite itemIcon;
    public ItemType itemType = ItemType.Default;
    public bool isStackable = false;
    public int maxStack = 1;
    public string description;
    public int baseValue;
    public ToolType toolType;

    // Equipment properties
    public EquipmentSlot equipSlot = EquipmentSlot.None;
    public int armorValue;
    public int damageValue;

    public bool CanEquip => itemType == ItemType.Equipment || itemType == ItemType.Tool;
    public bool CanConsume => itemType == ItemType.Consumable;
    public bool IsGatheringTool => itemType == ItemType.Tool;
}
using UnityEngine;
using System.Collections.Generic;
public class ItemDatabase : MonoBehaviour
{
    public static ItemDatabase Instance { get; private set; }

    [Header("Resources")]
    public List<Item> ores;
    public List<Item> logs;
    public List<Item> gems;
    public List<Item> tools;

    private Dictionary<string, Item> itemDictionary = new Dictionary<string, Item>();

    private void Awake()
    {
        if (Instance == null)
        {
            Instance = this;
            DontDestroyOnLoad(gameObject);
            InitializeDatabase();
        }
        else
        {
            Destroy(gameObject);
        }
    }

    private void InitializeDatabase()
    {
        AddItemsToDictionary(ores);
        AddItemsToDictionary(logs);
        AddItemsToDictionary(gems);
        AddItemsToDictionary(tools);
    }

    private void AddItemsToDictionary(List<Item> items)
    {
        foreach (var item in items)
        {
            if (!itemDictionary.ContainsKey(item.itemName))
            {
                itemDictionary[item.itemName] = item;
            }
        }
    }

    public Item GetItem(string itemName)
    {
        if (itemDictionary.TryGetValue(itemName, out Item item))
        {
            return item;
        }
        Debug.LogWarning($"Item not found in database: {itemName}");
        return null;
    }
}
using UnityEngine;

[RequireComponent(typeof(ItemPickup))]
public class ItemHighlight : MonoBehaviour
{
    private Material originalMaterial;
    private MeshRenderer meshRenderer;
    private ItemPickup itemPickup;
    private Color highlightColor = new Color(1f, 0.8f, 0.2f, 1f); // Golden highlight
    private Color normalColor = Color.white;
    private bool isHighlighted = false;

    [SerializeField] private float highlightDistance = 5f; // Distance at which the item starts highlighting

    void Start()
    {
        meshRenderer = GetComponent<MeshRenderer>();
        itemPickup = GetComponent<ItemPickup>();
        
        if (meshRenderer != null)
        {
            originalMaterial = new Material(meshRenderer.material); // Create a new instance of the material
            meshRenderer.material = originalMaterial; // Assign the new instance
        }
    }

    void Update()
    {
        if (meshRenderer != null)
        {
            if (IsPlayerNearby())
            {
                if (!isHighlighted)
                {
                    isHighlighted = true;
                }
                float pulse = (Mathf.Sin(Time.time * 4f) + 1f) * 0.5f;
                meshRenderer.material.color = Color.Lerp(normalColor, highlightColor, pulse);
            }
            else
            {
                if (isHighlighted)
                {
                    isHighlighted = false;
                    meshRenderer.material.color = normalColor;
                }
            }
        }
    }

    bool IsPlayerNearby()
    {
        GameObject player = GameObject.FindGameObjectWithTag("Player");
        if (player != null)
        {
            float distance = Vector3.Distance(transform.position, player.transform.position);
            return distance <= highlightDistance;
        }
        return false;
    }

    void OnDestroy()
    {
        if (originalMaterial != null)
        {
            Destroy(originalMaterial); // Clean up the material instance
        }
    }
}
using UnityEngine;
using UnityEngine.AI;
using System.Collections;
using System.Linq;

[RequireComponent(typeof(Collider))]
public class ItemPickup : MonoBehaviour
{
    public Item item;
    public int quantity = 1;
    public float pickupRange = 3f;

    private GameObject player;
    private Inventory playerInventory;
    private NavMeshAgent playerAgent;
    private bool isInitialized = false;
    private bool isMovingToItem = false;
    private WorldInteractable worldInteractable;

    private void Start()
    {
        StartCoroutine(InitializePickup());
        SetupInteraction();
    }

private void SetupInteraction()
{
    worldInteractable = gameObject.AddComponent<WorldInteractable>();
    worldInteractable.objectName = item.itemName;
    
    // Add pickup option with high priority
    worldInteractable.AddCustomOption($"Pick up {item.itemName}" + (quantity > 1 ? $" x{quantity}" : ""), 
        () => {
            var clickToMove = FindFirstObjectByType<ClickToMove>();
            if (clickToMove != null)
            {
                clickToMove.MoveToTarget(transform.position);
                isMovingToItem = true;
            }
        }, 
        () => item != null && !isMovingToItem,
        100);

    // Add examine option with item description
    worldInteractable.examineText = item.description;
}

    private IEnumerator InitializePickup()
    {
        while (!isInitialized)
        {
            if (FindPlayer())
            {
                isInitialized = true;
                playerAgent = player.GetComponent<NavMeshAgent>();
                yield break;
            }
            yield return new WaitForSeconds(0.5f);
        }
    }
        private bool FindPlayer()
    {
        player = GameObject.FindGameObjectWithTag("Player");
        if (player != null)
        {
            playerInventory = player.GetComponent<Inventory>();
            if (playerInventory != null)
            {
                Debug.Log("Player and Inventory found successfully.");
                return true;
            }
            else
            {
                Debug.LogWarning("Player found, but it doesn't have an Inventory component!");
                Debug.Log("Components on player: " + string.Join(", ", player.GetComponents<Component>().Select(c => c.GetType().Name)));
                
                // Try to find Inventory in children
                playerInventory = player.GetComponentInChildren<Inventory>();
                if (playerInventory != null)
                {
                    Debug.Log("Inventory found in child object.");
                    return true;
                }
            }
        }
        else
        {
            Debug.LogWarning("Player not found. Will retry.");
        }
        return false;
    }

    private void Update()
    {
        if (!isInitialized)
            return;

        if (isMovingToItem)
        {
            float distance = Vector3.Distance(transform.position, player.transform.position);
            if (distance <= pickupRange)
            {
                AttemptPickup();
                isMovingToItem = false;
            }
        }
    }

    private void HandleItemClick()
    {
        float distance = Vector3.Distance(transform.position, player.transform.position);
        if (distance <= pickupRange)
        {
            AttemptPickup();
        }
        else
        {
            MovePlayerToItem();
        }
    }

    private void MovePlayerToItem()
    {
        if (playerAgent != null)
        {
            playerAgent.SetDestination(transform.position);
            isMovingToItem = true;
            Debug.Log($"Moving to item: {item.itemName}");
        }
        else
        {
            Debug.LogWarning("Player NavMeshAgent not found. Cannot move to item.");
        }
    }

    private void AttemptPickup()
    {
        Debug.Log($"Attempting pickup of {item.itemName}");
        if (playerInventory != null)
        {
            if (playerInventory.AddItem(item, quantity))
            {
                EnhancedChatbox.Instance?.AddMessage($"Picked up: {item.itemName}");
                Debug.Log($"Successfully picked up {item.itemName}");
                Destroy(gameObject);
            }
            else
            {
                EnhancedChatbox.Instance?.AddMessage("Inventory is full!");
                Debug.Log($"Pickup failed: Inventory full. Item: {item.itemName}");
            }
        }
        else
        {
            Debug.LogError("PlayerInventory is still null! Reinitializing...");
            StartCoroutine(InitializePickup());
        }
    }
}
public enum ItemType
{
    Default,
    Equipment,
    Consumable,
    Resource,
    Tool
}
using UnityEngine;

public class LevelingSystem : MonoBehaviour
{
    public int currentLevel = 1;       // Player's current level
    public int maxLevel = 300;        // Maximum level
    public int currentXP = 0;         // Current experience points
    public int xpToNextLevel = 100;   // XP required for next level

    public float xpGrowthFactor = 1.2f; // Growth factor for XP required per level

    public delegate void OnLevelChange(int level, int currentXP, int xpToNextLevel);
    public event OnLevelChange OnLevelChangeEvent;

    void Start()
    {
        // Initialize with level 1
        NotifyUI();
    }

    public void AddExperience(int xp)
    {
        if (currentLevel >= maxLevel)
        {
            
            Debug.Log("Max level reached!");
            return;
        }

        currentXP += xp;

        while (currentXP >= xpToNextLevel && currentLevel < maxLevel)
        {
            LevelUp();
        }

        NotifyUI();
    }

    private void LevelUp()
    {
        currentXP -= xpToNextLevel;  // Carry over extra XP
        currentLevel++;              // Increase level
        xpToNextLevel = Mathf.FloorToInt(xpToNextLevel * xpGrowthFactor); // Increase XP requirement

        Debug.Log($"Level Up! Current Level: {currentLevel}, XP for Next Level: {xpToNextLevel}");
    }

    private void NotifyUI()
    {
        // Notify listeners (e.g., UIManager)
        OnLevelChangeEvent?.Invoke(currentLevel, currentXP, xpToNextLevel);
    }
}
using UnityEngine;
using System.Collections;

public class MineableRock : ResourceNode
{
    [Header("Mining Specific")]
    public OreType oreType;
    public int gemChance = 5; // Percentage chance to find gems

    [Header("Mining Effects")]
    public ParticleSystem miningParticles;
    public GameObject depleteEffect;
    private Material originalMaterial;

    protected override void Initialize()
    {
        base.Initialize();
        requiredToolType = ToolType.Pickaxe;
        SetGatheringEffect(miningParticles); // Use a method to set the gathering effect
        Debug.Log($"[Rock-{oreType}] Initialized with requiredToolType: {requiredToolType}");
    }

public override bool Gather(Tool tool)
{
    Debug.Log($"[Rock-{oreType}] Attempting to gather with tool: {(tool != null ? tool.itemName : "null")}");
    
    if (tool == null || tool.toolType != ToolType.Pickaxe)
    {
        Debug.Log($"[Rock-{oreType}] Invalid tool for mining");
        return false;
    }

    if (!HasResources() || IsRespawning)
    {
        Debug.Log($"[Rock-{oreType}] No resources or is respawning");
        return false;
    }

    if (!base.Gather(tool))
    {
        Debug.Log($"[Rock-{oreType}] Base gather failed");
        return false;
    }

    CheckForGems(tool);
    return true;
}

    // Add this method to maintain compatibility with the Mining class
    public bool Mine(Tool tool)
    {
        return Gather(tool);
    }

    private void CheckForGems(Tool tool)
    {
        float bonusChance = gemChance;
        if (tool != null)
        {
            bonusChance *= tool.GetEfficiencyMultiplier(1);
        }

        if (Random.value < bonusChance / 100f)
        {
            // Implement gem drop logic here
            Debug.Log("Found a gem!");
            // You might want to add a gem item to the bonusItems list or handle it separately
            // For example: SpawnBonus(new BonusItem { item = gemItem, chance = 1f });
        }
    }

    protected override IEnumerator FadeOut()
    {
        if (depleteEffect != null)
        {
            Instantiate(depleteEffect, transform.position, Quaternion.identity);
        }

        // Implement the fade out logic here instead of calling the base method
        float duration = 1f;
        float elapsed = 0;

        while (elapsed < duration)
        {
            elapsed += Time.deltaTime;
            if (resourceRenderer != null && resourceRenderer.material != null)
            {
                Color newColor = resourceRenderer.material.color;
                newColor.a = 1 - (elapsed / duration);
                resourceRenderer.material.color = newColor;
            }
            yield return null;
        }

        resourceRenderer.enabled = false;
        resourceCollider.enabled = false;
    }

    protected override IEnumerator FadeIn()
    {
        resourceRenderer.enabled = true;
        resourceCollider.enabled = true;

        float duration = 1f;
        float elapsed = 0;

        while (elapsed < duration)
        {
            elapsed += Time.deltaTime;
            if (resourceRenderer != null && resourceRenderer.material != null)
            {
                Color newColor = resourceRenderer.material.color;
                newColor.a = elapsed / duration;
                resourceRenderer.material.color = newColor;
            }
            yield return null;
        }
    }
}
using UnityEngine;

public class Mining : BaseSkillAction
{
    [Header("Mining Specific")]
    public ParticleSystem miningParticles;
    private MineableRock currentRock;

    protected override void Start()
    {
        base.Start();
        requiredSkillName = "Mining";
        requiredToolType = ToolType.Pickaxe;
        Debug.Log("[Mining] Initialized mining skill action.");
    }

    public override void SetTarget(ResourceNode target)
    {
        if (target is MineableRock rock)
        {
            base.SetTarget(target);
            currentRock = rock;
            Debug.Log($"[Mining] Targeting rock: {rock.name}");
        }
        else
        {
            Debug.LogError("[Mining] Invalid target type. Expected MineableRock.");
            currentRock = null;
        }
    }

    protected override string GetAnimationTrigger() => "isMining";

    protected virtual void PlayMiningEffect()
    {
        if (miningParticles != null)
        {
            miningParticles.Play();
            Debug.Log("Playing mining particles effect.");
        }
    }

protected override bool ProcessAction()
{
    Debug.Log($"[Mining] Processing action with target: {currentTarget?.name}");
    
    if (currentTarget != null && currentTarget.IsRespawning)
    {
        Debug.Log($"[{requiredSkillName}] Cannot gather - resource is respawning");
        StopAction();
        return false;
    }

    if (currentRock == null)
    {
        Debug.Log("[Mining] Current rock is null, attempting to set from target");
        currentRock = currentTarget as MineableRock;
        if (currentRock == null)
        {
            Debug.Log("[Mining] Failed to set current rock from target");
            StopAction();
            return false;
        }
    }

    if (!currentRock.HasResources())
    {
        Debug.Log("[Mining] Rock depleted!");
        StopAction();
        return false;
    }

    Tool currentPickaxe = inventory.GetToolOfType(requiredToolType) as Tool;
    if (currentPickaxe == null)
    {
        Debug.Log("[Mining] No pickaxe found in inventory!");
        NotifyPlayer("You need a pickaxe to mine.");
        StopAction();
        return false;
    }

    if (currentRock.Gather(currentPickaxe))
    {
        Debug.Log("[Mining] Successfully mined rock.");
        PlayMiningEffect();
        inventory.AddItem(currentRock.primaryResource, 1);
        playerSkills.AddExperience(requiredSkillName, currentRock.baseXP);
        return true;
    }

    Debug.Log("[Mining] Failed to mine rock.");
    StopAction();
    return false;
}

    public override void StopAction()
    {
        base.StopAction();
        currentRock = null;
        SetAnimationState(false);
    }
}
using UnityEngine;

public class MusicTrigger : MonoBehaviour
{
    public AudioSource musicSource;
    public AudioClip areaMusic;

    void Start()
    {
        // Set the MusicTrigger to ignore raycasts
        gameObject.layer = LayerMask.NameToLayer("Ignore Raycast");
    }

    private void OnTriggerEnter(Collider other)
    {
        if (other.CompareTag("Player"))
        {
            if (musicSource != null && areaMusic != null)
            {
                musicSource.clip = areaMusic;
                musicSource.Play();
            }
            else
            {
                Debug.LogWarning("MusicSource or AreaMusic not assigned.");
            }
        }
    }
}
public enum OreType
{
    Copper,
    Tin,
    Iron,
    Coal,
    Mithril,
    Adamant,
    Rune
}
using UnityEngine;
using UnityEngine.AI;
using TMPro;

public class PlayerAnimationController : MonoBehaviour
{
    private Animator animator;
    public TMP_Text runButtonText; // Assign in Inspector
    private NavMeshAgent navMeshAgent;
    public bool isRunning = false; // Toggle state for running

    private void Start()
    {
        animator = GetComponent<Animator>();
        navMeshAgent = GetComponent<NavMeshAgent>();

        if (animator == null)
        {
            Debug.LogError("Animator not found! Ensure an Animator is attached to the player.");
        }

        if (navMeshAgent == null)
        {
            Debug.LogError("NavMeshAgent not found! Ensure a NavMeshAgent is attached to the player.");
        }

        UpdateAgentSpeed(); // Initialize NavMeshAgent speed
    }

    private void Update()
    {
        HandleMovementAnimations();
    }

private void HandleMovementAnimations()
{
    // Get the current speed of the NavMeshAgent
    float speed = navMeshAgent.velocity.magnitude;

    // Determine if the player is moving
    bool isMoving = speed > 0.1f; // Adjust threshold if needed
    animator.SetBool("isWalking", isMoving);

    // Set Speed parameter for blending
    animator.SetFloat("Speed", speed);

    // Explicitly handle idle state
    if (!navMeshAgent.pathPending && navMeshAgent.remainingDistance <= navMeshAgent.stoppingDistance)
    {
        isMoving = false;
        animator.SetBool("isWalking", false); // Ensure idle animation triggers
        animator.SetFloat("Speed", 0);       // Reset speed to zero
    }
}

    // Method to toggle running
public void ToggleRun()
{
    isRunning = !isRunning; // Toggle running state
    UpdateAgentSpeed();
        // Update Animator parameter
    animator.SetBool("isRunning", isRunning);

    if (runButtonText != null)
    {
        runButtonText.text = isRunning ? "Walk" : "Run"; // Update button text
    }
}

    private void UpdateAgentSpeed()
    {
        navMeshAgent.speed = isRunning ? 6f : 3.5f; // Adjust speed for running or walking
        Debug.Log($"Running toggled: {isRunning}, NavMeshAgent Speed: {navMeshAgent.speed}");
    }
}
using UnityEngine;
using System.Collections;
using Random = UnityEngine.Random;

public class PlayerCombatant : MonoBehaviour, ICombatant
{    
    private CombatStats stats;
    private PlayerSkills playerSkills;
    private EquipmentManager equipmentManager;
    private RegenerationManager regenManager;

    public CombatStats Stats => stats;
    public bool IsAlive => Stats.Vitality > 0;
    Transform ICombatant.transform => transform;

    private void Awake()
    {
        playerSkills = GetComponent<PlayerSkills>();
        equipmentManager = GetComponent<EquipmentManager>();
        regenManager = GetComponent<RegenerationManager>();
        InitializeStats();
    }

    private void InitializeStats()
    {
        stats = new CombatStats(
            vitality: GetSkillLevel("Vitality"),
            precision: GetSkillLevel("Precision"),
            might: GetSkillLevel("Might"),
            fortitude: GetSkillLevel("Fortitude"),
            range: GetSkillLevel("Range"),
            spellweaving: GetSkillLevel("Spellweaving"),
            divinity: GetSkillLevel("Divinity")
        );

        Debug.Log($"Initialized player combat stats: " +
                 $"Vitality={stats.Vitality}, " +
                 $"Precision={stats.Precision}, " +
                 $"Might={stats.Might}, " +
                 $"Fortitude={stats.Fortitude}");

        // Initialize regeneration
        if (regenManager != null)
        {
            regenManager.StartRegeneration();
        }
    }

    private int GetSkillLevel(string skillName)
    {
        var skill = playerSkills?.GetSkill(skillName);
        return skill?.CurrentLevel ?? 1;
    }

    public AttackStyle GetCurrentCombatStyle()
    {
        var weapon = equipmentManager?.GetEquippedItem(EquipmentSlot.MainHand) as WeaponData;
        return weapon?.defaultAttackStyle ?? AttackStyle.Stab;
    }

    public void Attack(ICombatant target)
    {
        if (!IsAlive || target == null || !target.IsAlive) return;

        // Pause regeneration when attacking
        if (regenManager != null)
        {
            regenManager.PauseRegeneration(2.0f); // Pause regen for 2 seconds after attacking
        }

        var weapon = equipmentManager?.GetEquippedItem(EquipmentSlot.MainHand) as CombatWeaponData;
        if (weapon == null)
        {
            PerformUnarmedAttack(target);
            return;
        }

        float accuracy = CombatCalculator.CalculateAccuracy(this, target, weapon.availableAttackStyles[0]);
        
        if (Random.value < accuracy)
        {
            int damage = CalculateDamage(target, weapon);
            target.TakeDamage(damage, weapon.attackStyle);
            CombatExperience.AwardCombatExperience(this, damage, weapon);
            Debug.Log($"Hit {target.GetDisplayName()} for {damage} damage!");
        }
        else
        {
            Debug.Log($"Missed attack against {target.GetDisplayName()}!");
        }
    }

    private void PerformUnarmedAttack(ICombatant target)
    {
        // Basic unarmed combat using Precision skill
        float accuracy = (float)GetSkillLevel("Precision") / 
                        (GetSkillLevel("Precision") + target.Stats.Fortitude);
        
        if (Random.value < accuracy)
        {
            int damage = Mathf.Max(1, GetSkillLevel("Might") / 10);
            target.TakeDamage(damage, AttackStyle.Crush);
            Debug.Log($"Unarmed hit for {damage} damage!");
        }
    }

    private int CalculateDamage(ICombatant target, CombatWeaponData weapon)
    {
        // Implement new damage formula based on weapon style
        return weapon.attackStyle switch
        {
            AttackStyle.Stab or AttackStyle.Slash or AttackStyle.Crush =>
                Mathf.FloorToInt(0.5f + (stats.Might * (weapon.bonuses.mightBonus + 64)) / 640f),
            
            AttackStyle.Range =>
                Mathf.FloorToInt(0.5f + (stats.Range * (weapon.bonuses.rangeStrengthBonus + 64)) / 640f),
            
            AttackStyle.Spellweaving =>
                Mathf.FloorToInt(10 * (1 + weapon.bonuses.spellweavingDamage / 100f)),
            
            _ => 1
        };
    }

    public void TakeDamage(int damage, AttackStyle style)
    {
        if (!IsAlive) return;

        // Pause regeneration when taking damage
        if (regenManager != null)
        {
            regenManager.PauseRegeneration(3.0f); // Pause regen for 3 seconds after taking damage
        }

        float defenceBonus = equipmentManager?.GetTotalFortitudeBonus() ?? 0;
        int reducedDamage = Mathf.Max(1, (int)(damage * (1 - defenceBonus/100)));
        stats.ModifyVitality(-reducedDamage);

        Debug.Log($"Player took {reducedDamage} damage! Vitality: {stats.Vitality}/{stats.MaxVitality}");

        if (!stats.IsAlive)
        {
            StartCoroutine(HandleDeath());
        }
    }

    private IEnumerator HandleDeath()
    {
        // Stop regeneration on death
        if (regenManager != null)
        {
            regenManager.StopRegeneration();
        }

        if (TryGetComponent<Animator>(out var animator))
        {
            animator.SetTrigger("Death");
            yield return new WaitForSeconds(2f);
        }
        // Additional death logic here
    }

    public float GetAttackSpeed()
    {
        var weapon = equipmentManager?.GetEquippedItem(EquipmentSlot.MainHand) as CombatWeaponData;
        return weapon?.attackSpeed ?? 2.4f;
    }

    public string GetDisplayName() => "Player";
}
using UnityEngine;

public class PlayerController : MonoBehaviour
{
    private ResourceNode currentResourceTarget;
    public static PlayerController Instance { get; private set; }

    private void Awake()
    {
        if (Instance == null)
        {
            Instance = this;
        }
        else
        {
            Destroy(gameObject);
        }
    }

    public void SetResourceTarget(ResourceNode target)
{
    if (currentResourceTarget != null)
    {
        currentResourceTarget.OnRespawnStarted -= HandleResourceRespawn;
    }

    currentResourceTarget = target;

    if (currentResourceTarget != null)
    {
        currentResourceTarget.OnRespawnStarted += HandleResourceRespawn;
    }
}

private void HandleResourceRespawn(ResourceNode resource)
{
    StopCurrentAction();
    currentResourceTarget = null;
}
    
    public void StopCurrentAction()
    {
    Woodcutting woodcutting = FindFirstObjectByType<Woodcutting>();
    if (woodcutting != null && woodcutting.IsPerformingAction)
    {
        woodcutting.StopAction();
    }
    
    // Update to FindFirstObjectByType
    Mining mining = FindFirstObjectByType<Mining>();
    if (mining != null && mining.IsPerformingAction)
    {
        mining.StopAction();
    }
}

}
using UnityEngine;
using System.Collections.Generic;
using System.Linq;

public class PlayerSkills : MonoBehaviour
{
    [System.Serializable]
    public class SkillData
    {
        public string skillName;
        [HideInInspector] public Skill skill;
        public double startingXP = 0; // Added this field
    }

    [Header("UI References")]
    [SerializeField] private UIManager uiManager;
    [SerializeField] private SkillsUI skillsUI;

    [Header("Skills Configuration")]
    [SerializeField] private List<SkillData> skillDataList = new List<SkillData>(); // Add this back

    [Header("Combat Skills")]
[SerializeField] private List<SkillData> combatSkills = new List<SkillData>
{
    new SkillData { skillName = "Vitality", startingXP = ExperienceTable.GetXPForLevel(10) }, // Starts at level 10
    new SkillData { skillName = "Precision" }, // Previously Attack
    new SkillData { skillName = "Might" },     // Previously Strength
    new SkillData { skillName = "Fortitude" }, // Previously Defence
    new SkillData { skillName = "Range" },     // Previously Ranged
    new SkillData { skillName = "Spellweaving" }, // Previously Magic
    new SkillData { skillName = "Divinity" }   // New skill
};

    [Header("Gathering Skills")]
    [SerializeField] private List<SkillData> gatheringSkills = new List<SkillData>
    {
        new SkillData { skillName = "Woodcutting" },
        new SkillData { skillName = "Mining" },
        //new SkillData { skillName = "Firemaking" }
        //new SkillData { skillName = "Fishing" }
        //new SkillData { skillName = "Smithing" }
        // Add other gathering skills...
    };

    private List<Skill> skills = new List<Skill>();
    public IReadOnlyList<Skill> Skills => skills;

    private void Awake()
    {
        if (uiManager == null)
        {
            uiManager = FindFirstObjectByType<UIManager>();
            Debug.Log($"UIManager assigned in Awake: {uiManager != null}");
        }

        if (skillsUI == null)
        {
            skillsUI = FindFirstObjectByType<SkillsUI>();
            Debug.Log($"SkillsUI assigned in Awake: {skillsUI != null}");
        }
    }

    private void Start()
    {
        Debug.Log("PlayerSkills.Start invoked.");
        InitializeSkills();
        InitializeReferences();
        SetupUICallbacks();
        Debug.Log($"Initialized and subscribed to {skills.Count} skills.");
    }

    private void InitializeSkills()
    {
        Debug.Log("Initializing skills...");
        skills.Clear();

        // Combine all skills into skillDataList
        skillDataList.Clear();
        skillDataList.AddRange(combatSkills);
        skillDataList.AddRange(gatheringSkills);

        foreach (var skillData in skillDataList)
        {
            InitializeSkill(skillData);
        }

        Debug.Log($"Total skills initialized: {skills.Count}");
    }

    private void InitializeSkill(SkillData skillData)
    {
        if (!string.IsNullOrEmpty(skillData.skillName))
        {
            Skill newSkill = new Skill(skillData.skillName);
            if (skillData.startingXP > 0)
            {
                newSkill.AddExperience(skillData.startingXP);
            }
            Debug.Log($"Created skill: {newSkill.SkillName} at level {newSkill.CurrentLevel}");
            skills.Add(newSkill);
            skillData.skill = newSkill;
        }
        else
        {
            Debug.LogError("Skill name is empty in SkillData. Skipping this entry.");
        }
    }
    private void InitializeReferences()
    {
        if (uiManager == null)
        {
            uiManager = FindFirstObjectByType<UIManager>();
            Debug.Log($"UIManager assigned: {uiManager != null}");
        }

        if (skillsUI == null)
        {
            skillsUI = FindFirstObjectByType<SkillsUI>();
            Debug.Log($"SkillsUI assigned: {skillsUI != null}");
        }

        ValidateReferences();
    }

    private void ValidateReferences()
    {
        if (uiManager == null)
        {
            Debug.LogError("UIManager reference is missing!");
        }

        if (skillsUI == null)
        {
            Debug.LogError("SkillsUI reference is missing!");
        }
    }

private void SetupUICallbacks()
{
    if (uiManager == null)
    {
        Debug.LogError("UIManager not found! Cannot set up UI callbacks.");
        return;
    }

    if (skillsUI == null)
    {
        Debug.LogError("SkillsUI not found! Cannot set up UI callbacks.");
        return;
    }

    Debug.Log($"Setting up UI callbacks for {skills.Count} skills.");
    foreach (var skill in skills)
    {
        if (skill != null)
        {
            // Create local variable to avoid closure issues
            var currentSkill = skill;

            // Clear existing subscribers
            currentSkill.ClearSubscribers();

            // Subscribe to XP gained event
            currentSkill.OnXPGained += (skillName, level, xp, nextLevel) =>
            {
                Debug.Log($"[PlayerSkills] XP gained callback for {skillName}: Level={level}, XP={xp}");
                if (uiManager != null)
                {
                    uiManager.UpdateSkillUI(skillName, level, (int)xp, (int)nextLevel);
                }
            };

            // Subscribe to level up event
            currentSkill.OnLevelUp += (skillName, level) =>
            {
                Debug.Log($"[PlayerSkills] Level up callback for {skillName}: Level={level}");
                var chatbox = EnhancedChatbox.Instance;
                if (chatbox != null)
                {
                    chatbox.AddMessage($"Congratulations! Your {skillName} level is now {level}!", 
                        EnhancedChatbox.MessageType.LevelUp);
                }
            };

            Debug.Log($"[PlayerSkills] Subscribed to events for {currentSkill.SkillName}");
        }
        else
        {
            Debug.LogWarning("Encountered a null skill while setting up callbacks");
        }
    }
}
public void AddExperience(string skillName, double xp)
{
    Debug.Log($"Adding {xp} XP to {skillName}");
    var skill = GetSkill(skillName);
    if (skill != null)
    {
        // Check if we need to re-initialize callbacks
        if (!skill.HasSubscribers())
        {
            Debug.LogWarning($"[PlayerSkills] Missing subscribers for {skillName}, re-initializing callbacks");
            SetupUICallbacks();
        }
        skill.AddExperience(xp);
    }
    else
    {
        Debug.LogError($"Skill not found: {skillName}");
        Debug.LogError($"Available skills: {string.Join(", ", skills.Select(s => s.SkillName))}");
    }
}

public int CalculateCombatLevel()
{
    Skill fortitude = GetSkill("Fortitude");
    Skill vitality = GetSkill("Vitality");
    Skill divinity = GetSkill("Divinity");
    
    // Get combat style levels
    int meleeLevel = Mathf.Max(
        GetSkill("Precision")?.CurrentLevel ?? 1,
        GetSkill("Might")?.CurrentLevel ?? 1
    );
    int rangeLevel = GetSkill("Range")?.CurrentLevel ?? 1;
    int spellweavingLevel = GetSkill("Spellweaving")?.CurrentLevel ?? 1;

    // Find highest combat style level
    int highestCombatStyle = Mathf.Max(meleeLevel, rangeLevel, spellweavingLevel);

    // Calculate combat level using the new formula
    float combatLevel = (
        (fortitude?.CurrentLevel ?? 1) + 
        (vitality?.CurrentLevel ?? 10) + 
        ((divinity?.CurrentLevel ?? 1) / 2f) + 
        highestCombatStyle
    ) / 5f;

    return Mathf.FloorToInt(combatLevel);
}

// Add this method to allow manual refresh of callbacks
public void RefreshCallbacks()
{
    Debug.Log("[PlayerSkills] Manually refreshing callbacks");
    SetupUICallbacks();
}

    private void HandleXPGained(string name, int level, double xp, double nextLevel)
    {
        Debug.Log($"XP gained callback triggered for {name} - Level: {level}, XP: {xp}");

        if (uiManager != null)
        {
            uiManager.UpdateSkillUI(name, level, (int)xp, (int)nextLevel);
        }
        else
        {
            Debug.LogError("UIManager is null. Cannot update UI.");
        }
    }

    private void HandleLevelUp(string name, int level)
    {
        Debug.Log($"Level up callback triggered for {name} - New Level: {level}");

        // Notify the player
        EnhancedChatbox.Instance?.AddMessage(
            $"Congratulations! Your {name} level is now {level}!",
            EnhancedChatbox.MessageType.LevelUp
        );
    }

    private void OnDestroy()
    {
        Debug.Log("Unsubscribing from skill events.");
        foreach (var skill in skills)
        {
            if (skill != null)
            {
                skill.OnXPGained -= HandleXPGained;
                skill.OnLevelUp -= HandleLevelUp;
            }
        }
    }

    public Skill GetSkill(string skillName)
    {
        return skills.FirstOrDefault(s =>
            string.Equals(s.SkillName, skillName, System.StringComparison.OrdinalIgnoreCase));
    }

    public int GetTotalLevel()
    {
        return skills.Sum(skill => skill.CurrentLevel);
    }

#if UNITY_EDITOR
    private void OnValidate()
    {
        Debug.Log("Validating SkillDataList...");
        foreach (var data in skillDataList)
        {
            Debug.Log($"SkillData: {data.skillName}");
        }

        var duplicates = skillDataList
            .GroupBy(x => x.skillName)
            .Where(g => g.Count() > 1)
            .Select(g => g.Key)
            .ToList();

        if (duplicates.Any())
        {
            Debug.LogError($"Duplicate skill names found: {string.Join(", ", duplicates)}");
        }
    }
#endif
}

using UnityEngine;
using System.Collections;

public class RegenerationManager : MonoBehaviour
{
    [Header("Regeneration Settings")]
    public float baseRegenRate = 0.01f; // 1% per second
    public float regenTickInterval = 0.6f; // Regenerate every 0.6 seconds

    private CombatStats combatStats;
    private bool isRegenerating = true;
    private Coroutine regenCoroutine;

    private void Start()
    {
        // Get reference to player's combat stats
        combatStats = GetComponent<PlayerCombatant>()?.Stats;
        if (combatStats == null)
        {
            Debug.LogError("RegenerationManager: No CombatStats found!");
            return;
        }

        StartRegeneration();
    }

    public void StartRegeneration()
    {
        if (!isRegenerating)
        {
            isRegenerating = true;
            if (regenCoroutine == null)
            {
                regenCoroutine = StartCoroutine(RegenerationRoutine());
            }
        }
    }

    public void StopRegeneration()
    {
        isRegenerating = false;
        if (regenCoroutine != null)
        {
            StopCoroutine(regenCoroutine);
            regenCoroutine = null;
        }
    }

    private IEnumerator RegenerationRoutine()
    {
        WaitForSeconds wait = new WaitForSeconds(regenTickInterval);

        while (isRegenerating)
        {
            if (combatStats != null && combatStats.Vitality < combatStats.MaxVitality)
            {
                // Calculate regen amount
                float regenAmount = combatStats.MaxVitality * baseRegenRate * regenTickInterval;
                
                // Apply regeneration
                combatStats.ModifyVitality(Mathf.CeilToInt(regenAmount));
                
                Debug.Log($"Regenerated {regenAmount:F1} Vitality. Current: {combatStats.Vitality}/{combatStats.MaxVitality}");
            }

            yield return wait;
        }
    }

    // Call this when player takes damage or enters combat
    public void PauseRegeneration(float duration)
    {
        StopRegeneration();
        StartCoroutine(ResumeRegenerationAfterDelay(duration));
    }

    private IEnumerator ResumeRegenerationAfterDelay(float delay)
    {
        yield return new WaitForSeconds(delay);
        StartRegeneration();
    }
}
using UnityEngine;
using System.Collections;
using System.Collections.Generic;

public abstract class ResourceNode : MonoBehaviour
{
    [System.Serializable]
    public class BonusItem
    {
        public Item item;
        public float chance;
    }

    [Header("Basic Properties")]
    public string nodeName;
    public int requiredLevel = 1;
    public float baseGatherTime = 3f;
    public int baseXP = 25;
    public Item primaryResource;
    public ToolType requiredToolType;
    
    [Header("Resource Settings")]
    public int resourcesRemaining;
    public int maxResources = 5;
    public float respawnTime = 30f;
    public float depletionChance = 0.2f;

    [Header("Bonus Items")]
    public List<BonusItem> bonusItems = new List<BonusItem>();

    [Header("Effects")]
    protected ParticleSystem gatheringEffect;

     public bool IsRespawning => isRespawning;
    protected bool isRespawning = false;
    protected Renderer resourceRenderer;
    protected WorldInteractable worldInteractable;
    protected Collider resourceCollider;
    public event System.Action<ResourceNode> OnRespawnStarted;
    public event System.Action<ResourceNode> OnRespawnCompleted;

    protected virtual void Start()
    {
        Initialize();
        SetupInteraction();
        Debug.Log($"[{nodeName}] Initialized with requiredToolType: {requiredToolType}");
    }

    protected virtual void Initialize()
    {
        resourceRenderer = GetComponent<Renderer>();
        resourceCollider = GetComponent<Collider>();
        resourcesRemaining = maxResources;
        Debug.Log($"[{nodeName}] Resources: {resourcesRemaining}/{maxResources}");
    }

    public virtual bool CanGather(ISkill skill)
    {
        if (isRespawning || resourcesRemaining <= 0)
        {
            Debug.Log($"[{nodeName}] Cannot gather: isRespawning={isRespawning}, resourcesRemaining={resourcesRemaining}");
            return false;
        }

        if (skill != null && skill.CurrentLevel < requiredLevel)
        {
            Debug.Log($"[{nodeName}] Skill level too low. Required: {requiredLevel}, Current: {skill.CurrentLevel}");
            return false;
        }

        return true;
    }

public virtual bool Gather(Tool tool)
{
    Debug.Log($"[{nodeName}] Attempting to gather with tool: {(tool != null ? tool.itemName : "null")}");
    
    if (!CanGather(null))
    {
        Debug.Log($"[{nodeName}] Cannot gather - basic checks failed");
        return false;
    }
    
    if (tool == null)
    {
        Debug.Log($"[{nodeName}] No tool provided for gathering");
        return false;
    }

    if (tool.toolType != requiredToolType)
    {
        Debug.Log($"[{nodeName}] Incorrect tool type. Required: {requiredToolType}, Used: {tool.toolType}");
        return false;
    }

    resourcesRemaining--;
    Debug.Log($"[{nodeName}] Gathered successfully. Resources remaining: {resourcesRemaining}");

    if (gatheringEffect != null)
    {
        gatheringEffect.Play();
    }

    // Handle bonus items
    foreach (var bonus in bonusItems)
    {
        if (Random.value < bonus.chance)
        {
            SpawnBonus(bonus);
        }
    }

    if (resourcesRemaining <= 0 || (Random.value < depletionChance))
    {
        StartCoroutine(RespawnResource());
    }

    return true;
}

    public bool HasResources()
{
    return resourcesRemaining > 0 && !isRespawning;
}

    protected virtual void SpawnBonus(BonusItem bonus)
    {
        if (Inventory.Instance != null)
        {
            bool added = Inventory.Instance.AddItem(bonus.item, 1);
            Debug.Log($"[{nodeName}] Added bonus item {bonus.item.itemName} to inventory: {added}");
        }
    }

    protected virtual IEnumerator RespawnResource()
    {
        Debug.Log($"[{nodeName}] Starting respawn sequence");
        isRespawning = true;
        
        // Notify listeners that respawning has started
        OnRespawnStarted?.Invoke(this);

        yield return StartCoroutine(FadeOut());

        Debug.Log($"[{nodeName}] Waiting {respawnTime} seconds to respawn");
        yield return new WaitForSeconds(respawnTime);

        yield return StartCoroutine(FadeIn());

        resourcesRemaining = maxResources;
        isRespawning = false;
        
        // Notify listeners that respawning has completed
        OnRespawnCompleted?.Invoke(this);
        
        Debug.Log($"[{nodeName}] Respawn complete. Resources reset to {maxResources}");
    }

    protected abstract IEnumerator FadeOut();
    protected abstract IEnumerator FadeIn();

    protected void SetGatheringEffect(ParticleSystem effect)
    {
        gatheringEffect = effect;
    }
    protected virtual void SetupInteraction()
    {
        worldInteractable = gameObject.AddComponent<WorldInteractable>();
        worldInteractable.objectName = nodeName;

        // Add the appropriate gathering action based on resource type
        if (this is ChoppableTree)
        {
            worldInteractable.AddCustomOption($"Chop {nodeName}", 
                AttemptGather, 
                () => CanGather(null), // Convert method to Func<bool>
                200);
        }
        else if (this is MineableRock)
        {
            worldInteractable.AddCustomOption($"Mine {nodeName}", 
                AttemptGather, 
                () => CanGather(null), // Convert method to Func<bool>
                200);
        }

        // Subscribe to respawn events to update interaction availability
        OnRespawnStarted += (node) => worldInteractable.enabled = false;
        OnRespawnCompleted += (node) => worldInteractable.enabled = true;
    }

    public bool IsValidForGathering()
{
    return !isRespawning && resourcesRemaining > 0;
}
    private void AttemptGather()
    {
        var player = GameObject.FindGameObjectWithTag("Player");
        if (player != null)
        {
            if (this is ChoppableTree)
            {
                var woodcutting = player.GetComponent<Woodcutting>();
                if (woodcutting != null)
                    woodcutting.SetTarget(this);
            }
            else if (this is MineableRock)
            {
                var mining = player.GetComponent<Mining>();
                if (mining != null)
                    mining.SetTarget(this);
            }
        }
    }
}
using UnityEngine;

public class RuneScapeCamera : MonoBehaviour
{
    public Transform target;
    public float distance = 10f;
    public float minDistance = 5f;
    public float maxDistance = 20f;
    public float zoomSpeed = 2f;
    public float rotationSpeed = 100f;
    public float orbitSpeed = 50f;
    public float heightOffset = 2f;
    public float minVerticalAngle = -30f;
    public float maxVerticalAngle = 60f;
    public float groundClearance = 1f; // Minimum distance to keep from ground
    
    private float currentRotation = 0f;
    private float currentVerticalRotation = 45f;
    private float smoothedVerticalRotation;
    private const float groundCheckRadius = 0.3f; // Radius for ground checking

    void LateUpdate()
    {
        if (target == null) return;

        // Handle orbital movement with arrow keys
        if (Input.GetKey(KeyCode.LeftArrow)) // Orbit left
        {
            currentRotation += orbitSpeed * Time.deltaTime;
        }
        if (Input.GetKey(KeyCode.RightArrow)) // Orbit right
        {
            currentRotation -= orbitSpeed * Time.deltaTime;
        }

        // Store previous vertical rotation for ground check
        float previousVerticalRotation = currentVerticalRotation;

        if (Input.GetKey(KeyCode.UpArrow)) // Orbit up
        {
            currentVerticalRotation -= orbitSpeed * Time.deltaTime;
        }
        if (Input.GetKey(KeyCode.DownArrow)) // Orbit down
        {
            currentVerticalRotation += orbitSpeed * Time.deltaTime;
        }

        // Middle mouse rotation
        if (Input.GetMouseButton(2))
        {
            float mouseX = Input.GetAxis("Mouse X") * rotationSpeed * Time.deltaTime;
            float mouseY = Input.GetAxis("Mouse Y") * rotationSpeed * Time.deltaTime;

            currentRotation -= mouseX;
            currentVerticalRotation = Mathf.Clamp(currentVerticalRotation + mouseY, minVerticalAngle, maxVerticalAngle);
        }

        // Basic angle clamping
        currentVerticalRotation = Mathf.Clamp(currentVerticalRotation, minVerticalAngle, maxVerticalAngle);

        // Zoom with mouse wheel
        float scroll = Input.GetAxis("Mouse ScrollWheel") * zoomSpeed;
        distance = Mathf.Clamp(distance - scroll, minDistance, maxDistance);

        // Calculate desired camera position
        Vector3 targetPos = target.position + Vector3.up * heightOffset;
        
        // Check if new camera position would be too close to ground
        Vector3 rotation = new Vector3(currentVerticalRotation, currentRotation, 0);
        Vector3 negDistance = new Vector3(0.0f, 0.0f, -distance);
        Quaternion rot = Quaternion.Euler(rotation);
        Vector3 desiredPosition = rot * negDistance + targetPos;

        // Ground check using spherecast
        RaycastHit hit;
        Vector3 directionToCamera = (desiredPosition - targetPos).normalized;
        if (Physics.SphereCast(targetPos, groundCheckRadius, directionToCamera, out hit, distance))
        {
            float distanceToGround = hit.distance;
            if (distanceToGround < groundClearance)
            {
                // Revert vertical rotation if too close to ground
                currentVerticalRotation = previousVerticalRotation;
                rotation = new Vector3(currentVerticalRotation, currentRotation, 0);
                rot = Quaternion.Euler(rotation);
                desiredPosition = rot * negDistance + targetPos;
            }
        }

        // Update camera transform
        transform.rotation = rot;
        transform.position = desiredPosition;
    }

    // Helper method to reset camera position behind player
    public void ResetCamera()
    {
        if (target != null)
        {
            currentRotation = target.eulerAngles.y;
            currentVerticalRotation = 45f;
        }
    }

    // Optionally visualize the ground check radius in the editor
    private void OnDrawGizmosSelected()
    {
        if (target != null)
        {
            Gizmos.color = Color.yellow;
            Gizmos.DrawWireSphere(transform.position, groundCheckRadius);
        }
    }
}
using UnityEngine;
using UnityEngine.UI;

public class SidebarButton : MonoBehaviour
{
    public GameObject targetPanel;
    private Button button;
    private bool initialized = false;

    private void OnEnable()
    {
        if (!initialized)
        {
            Initialize();
        }
    }

    private void Initialize()
    {
        button = GetComponent<Button>();
        if (button == null)
        {
            Debug.LogError($"No Button component found on {gameObject.name}!");
            return;
        }

        if (targetPanel == null)
        {
            Debug.LogError($"No target panel assigned for {gameObject.name}!");
            return;
        }

        // Add listener programmatically
        button.onClick.RemoveAllListeners(); // Clear any existing listeners
        button.onClick.AddListener(OnButtonClick);
        
        // Make sure the panel starts hidden
        if (targetPanel != null)
        {
            targetPanel.SetActive(false);
        }

        initialized = true;
        Debug.Log($"SidebarButton initialized for {gameObject.name}");
    }

public void OnButtonClick()
{
    if (targetPanel == null || UIManager.Instance == null)
    {
        Debug.LogError($"Missing references on {gameObject.name}!");
        return;
    }

    // First activate the panel
    targetPanel.SetActive(true);

    // Then initialize if needed
    var equipmentUI = targetPanel.GetComponent<EquipmentUI>();
    if (equipmentUI != null)
    {
        equipmentUI.EnsureInitialized();
    }

    // Finally toggle through UI Manager
    UIManager.Instance.TogglePanel(targetPanel);
}
}
using UnityEngine;
using UnityEngine.UI;
using System.Collections.Generic;

public class SidebarUI : MonoBehaviour
{
    [System.Serializable]
    public class SidebarButton
    {
        public string name;
        public Sprite icon;
        public GameObject associatedPanel;
    }

    public List<SidebarButton> sidebarButtons;
    public GameObject buttonPrefab;
    public Transform buttonContainer;
    
    private GameObject activePanel;

    private void Start()
    {
        InitializeSidebar();
    }

    private void InitializeSidebar()
    {
        foreach (var buttonData in sidebarButtons)
        {
            GameObject buttonObj = Instantiate(buttonPrefab, buttonContainer);
            Button button = buttonObj.GetComponent<Button>();
            Image icon = buttonObj.GetComponentInChildren<Image>();

            // Set up button
            icon.sprite = buttonData.icon;
            
            // Set up click handler
            button.onClick.AddListener(() => OnSidebarButtonClicked(buttonData));

            // Initially hide all panels
            if (buttonData.associatedPanel != null)
            {
                buttonData.associatedPanel.SetActive(false);
            }
        }
    }

    private void OnSidebarButtonClicked(SidebarButton buttonData)
    {
        // Hide currently active panel
        if (activePanel != null)
        {
            activePanel.SetActive(false);
        }

        // Show new panel if it's different from the current one
        if (activePanel != buttonData.associatedPanel)
        {
            buttonData.associatedPanel.SetActive(true);
            activePanel = buttonData.associatedPanel;
        }
        else
        {
            activePanel = null;
        }
    }
}
using UnityEngine;
using System;

[System.Serializable]
public class Skill : ISkill
{
    public string skillName;
    private double currentXP;
    private int cachedLevel = 1;
    
    public string SkillName => skillName;
    public int CurrentLevel => GetCurrentLevel();
    public double CurrentXP => currentXP;
    public double XPToNextLevel => ExperienceTable.GetXPToNextLevel(CurrentLevel, currentXP);

    public event Action<string, int, double, double> OnXPGained;
    public event Action<string, int> OnLevelUp;

    public Skill(string name)
    {
        skillName = name;
        currentXP = 0;
    }

    public void InitializeUI()
    {
        OnXPGained?.Invoke(skillName, CurrentLevel, currentXP, XPToNextLevel);
    }

public void AddExperience(double xp)
{
    if (xp <= 0) 
    {
        Debug.LogWarning($"[{skillName}] Attempted to add invalid XP amount: {xp}");
        return;
    }
    
    double oldXP = currentXP;
    int oldLevel = CurrentLevel;
    
    currentXP = Math.Min(currentXP + xp, ExperienceTable.GetXPForLevel(ExperienceTable.MAX_LEVEL));
    int newLevel = GetCurrentLevel();

    Debug.Log($"[{skillName}] Added {xp} XP. Old XP: {oldXP}, New XP: {currentXP}");
    
    // Check for level up
    if (newLevel > oldLevel)
    {
        Debug.Log($"[{skillName}] Level Up! {oldLevel} -> {newLevel}");
        if (OnLevelUp != null)
        {
            OnLevelUp.Invoke(skillName, newLevel);
        }
        else
        {
            Debug.LogWarning($"[{skillName}] OnLevelUp has no subscribers!");
        }
    }

    // Trigger XP update
    if (OnXPGained != null)
    {
        Debug.Log($"[{skillName}] Triggering XP update. Level={CurrentLevel}, XP={currentXP}, NextLevel={XPToNextLevel}");
        OnXPGained.Invoke(skillName, CurrentLevel, currentXP, XPToNextLevel);
    }
    else
    {
        Debug.LogWarning($"[{skillName}] OnXPGained has no subscribers! Requesting callback refresh.");
        var playerSkills = UnityEngine.Object.FindFirstObjectByType<PlayerSkills>();
        if (playerSkills != null)
        {
            playerSkills.RefreshCallbacks();
        }
    }
}
    public bool HasSubscribers()
    {
        return OnXPGained != null;
    }
    public void ClearSubscribers()
    {
        OnXPGained = null;
        OnLevelUp = null;
        Debug.Log($"[{skillName}] Cleared event subscribers");
    }
    private int GetCurrentLevel()
    {
        cachedLevel = ExperienceTable.GetLevel(currentXP);
        return cachedLevel;
    }

    public bool HasRequirement(int level) => CurrentLevel >= level;

    public string GetSkillInfo()
    {
        return $"{skillName} - Level: {CurrentLevel} - XP: {ExperienceTable.FormatXP(currentXP)} " +
               $"- Next Level: {ExperienceTable.FormatXP(XPToNextLevel)} XP remaining";
    }
}
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.EventSystems;
using TMPro;

public class SkillEntryUI : MonoBehaviour, IPointerEnterHandler, IPointerExitHandler
{
    [Header("UI Components")]
    public Image skillIcon;
    public TextMeshProUGUI skillNameText;
    public TextMeshProUGUI levelText;
    public TextMeshProUGUI xpText;
    public Slider xpProgressBar;
    public GameObject tooltipPanel;
    public TextMeshProUGUI tooltipText;

    public void UpdateDisplay(string skillName, int level, double currentXP, double xpToNextLevel)
    {
        if (skillNameText != null)
            skillNameText.text = skillName;

        if (levelText != null)
            levelText.text = $"Level {level}";

        if (xpText != null)
        {
            if (level >= ExperienceTable.MAX_LEVEL)
                xpText.text = ExperienceTable.FormatXP(currentXP);
            else
                xpText.text = $"{currentXP:N0} / {(currentXP + xpToNextLevel):N0} XP";
        }

        if (xpProgressBar != null)
            xpProgressBar.value = ExperienceTable.GetProgressToNextLevel(currentXP);

        UpdateTooltip(skillName, level, currentXP, xpToNextLevel);
    }

private void UpdateTooltip(string skillName, int level, double currentXP, double xpToNextLevel)
{
    if (tooltipText == null) return;

    string tooltipString = $"{skillName}\n";
    tooltipString += $"Level: {level}";
    
    if (level < ExperienceTable.MAX_LEVEL)
    {
        double totalXPForLevel = currentXP + xpToNextLevel;
        double percentage = totalXPForLevel > 0 ? (currentXP / totalXPForLevel) * 100 : 0;
        
        tooltipString += $"\nXP: {ExperienceTable.FormatXP(currentXP)}";
        tooltipString += $"\nNext Level: {ExperienceTable.FormatXP(xpToNextLevel)} XP remaining";
        tooltipString += $"\nProgress: {percentage:F1}%";
    }
    else
    {
        tooltipString += $"\nMax Level!\nTotal XP: {ExperienceTable.FormatXP(currentXP)}";
    }

    tooltipText.text = tooltipString;
}

    public void OnPointerEnter(PointerEventData eventData)
    {
        if (tooltipPanel != null)
            tooltipPanel.SetActive(true);
    }

    public void OnPointerExit(PointerEventData eventData)
    {
        if (tooltipPanel != null)
            tooltipPanel.SetActive(false);
    }
}
using UnityEngine;

public class SkillsAudioManager : MonoBehaviour
{
    private AudioSource audioSource;

    private void Awake()
    {
        audioSource = GetComponent<AudioSource>();
        if (audioSource == null)
        {
            audioSource = gameObject.AddComponent<AudioSource>();
        }
    }

    public void PlaySkillSound(AudioClip clip)
    {
        if (audioSource != null && clip != null)
        {
            audioSource.PlayOneShot(clip);
        }
    }
}
using UnityEngine;

[CreateAssetMenu(fileName = "New Skill", menuName = "Skills/Skill Data")]
public class SkillData : ScriptableObject
{
    [Header("Basic Info")]
    public string skillName;
    public Sprite skillIcon;
    [TextArea(3, 5)]
    public string description;

    [Header("Skill Settings")]
    public int startingLevel = 1;
    public int maxLevel = 99;
    public float experienceMultiplier = 1f;

    [Header("Tool Requirements")]
    public ItemType[] allowedTools;
    public int minimumToolLevel = 1;
}
using UnityEngine;
using UnityEngine.UI;
using TMPro;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;

public class SkillsUI : MonoBehaviour
{
    [System.Serializable]
    public class SkillIconData
    {
        public string skillName;
        public Sprite icon;
        [TextArea(2,3)]
        public string description;
    }

    [Header("References")]
    public GameObject skillEntryPrefab;
    public Transform skillsContainer;
    public TextMeshProUGUI totalLevelText;

    [Header("Visual Settings")]
    public Color normalColor = Color.white;
    public Color maxLevelColor = Color.yellow;
    public Color virtualLevelColor = new Color(0.7f, 0.7f, 1f);

    [Header("Skill Icons")]
    public List<SkillIconData> skillIcons = new List<SkillIconData>();

    private Dictionary<string, SkillEntryUI> skillEntries = new Dictionary<string, SkillEntryUI>();
    private PlayerSkills cachedPlayerSkills;

    private void Start()
    {
        Debug.Log("SkillsUI Starting...");
        InitializeReferences();
        StartCoroutine(DelayedInitialization());
    }

    private void InitializeReferences()
    {
        if (cachedPlayerSkills == null)
        {
            cachedPlayerSkills = FindFirstObjectByType<PlayerSkills>();
            if (cachedPlayerSkills == null)
            {
                Debug.LogError("PlayerSkills reference not found!");
                return;
            }
            Debug.Log($"Found PlayerSkills reference");
        }

        if (skillEntryPrefab == null || skillsContainer == null)
        {
            Debug.LogError($"Missing critical references - Prefab: {skillEntryPrefab != null}, Container: {skillsContainer != null}");
        }
    }

    private IEnumerator DelayedInitialization()
    {
        yield return new WaitForSeconds(0.1f); // Small delay
        InitializeSkills();
    }

    private void InitializeSkills()
    {
        ClearContainer();
        
        if (cachedPlayerSkills != null)
        {
            var skills = cachedPlayerSkills.Skills.ToList();
            Debug.Log($"Initializing {skills.Count} skills");
            
            foreach (var skill in skills)
            {
                CreateSkillEntry(skill.SkillName);
            }
            UpdateTotalLevel();
        }
        else
        {
            Debug.LogError("Cannot initialize skills - PlayerSkills reference is null");
        }
    }

    private void ClearContainer()
    {
        if (skillsContainer != null)
        {
            foreach (Transform child in skillsContainer)
            {
                Destroy(child.gameObject);
            }
            skillEntries.Clear();
            Debug.Log("Cleared existing skill entries");
        }
    }

    private void CreateSkillEntry(string skillName)
    {
        if (string.IsNullOrEmpty(skillName) || skillEntryPrefab == null || skillsContainer == null)
        {
            Debug.LogError($"Cannot create skill entry - missing references for {skillName}");
            return;
        }

        try
        {
            GameObject entryObj = Instantiate(skillEntryPrefab, skillsContainer);
            if (entryObj == null)
            {
                Debug.LogError($"Failed to instantiate skill entry prefab for {skillName}");
                return;
            }

            SkillEntryUI entryUI = entryObj.GetComponent<SkillEntryUI>();
            if (entryUI == null)
            {
                Debug.LogError($"SkillEntryUI component missing on prefab for {skillName}");
                Destroy(entryObj);
                return;
            }

            var iconData = skillIcons.FirstOrDefault(x => 
                string.Equals(x.skillName, skillName, StringComparison.OrdinalIgnoreCase));

            if (iconData != null && iconData.icon != null && entryUI.skillIcon != null)
            {
                entryUI.skillIcon.sprite = iconData.icon;
                entryUI.skillIcon.enabled = true;
                Debug.Log($"Set icon for {skillName}");
            }
            else
            {
                if (entryUI.skillIcon != null)
                {
                    entryUI.skillIcon.enabled = false;
                }
                Debug.LogWarning($"No icon data found for {skillName}");
            }

            if (cachedPlayerSkills != null)
            {
                var skill = cachedPlayerSkills.GetSkill(skillName);
                if (skill != null)
                {
                    skillEntries[skillName] = entryUI;
                    entryUI.UpdateDisplay(skillName, skill.CurrentLevel, skill.CurrentXP, skill.XPToNextLevel);
                    Debug.Log($"Successfully created entry for {skillName}");
                }
                else
                {
                    Debug.LogError($"Failed to get skill data for {skillName}");
                }
            }
        }
        catch (System.Exception e)
        {
            Debug.LogError($"Error creating skill entry for {skillName}: {e.Message}\n{e.StackTrace}");
        }
    }

    public void UpdateSkillDisplay(string skillName, int level, double currentXP, double xpToNextLevel)
    {
        try
        {
            Debug.Log($"Updating display for {skillName} - Level: {level}, Current XP: {currentXP}, Next Level: {xpToNextLevel}");
            
            if (!skillEntries.ContainsKey(skillName))
            {
                Debug.LogWarning($"No existing entry for {skillName}, creating new one");
                CreateSkillEntry(skillName);
                return;
            }

            if (skillEntries.TryGetValue(skillName, out SkillEntryUI entry))
            {
                if (entry != null)
                {
                    entry.UpdateDisplay(skillName, level, currentXP, xpToNextLevel);
                    Debug.Log($"Successfully updated UI for {skillName}");
                }
                else
                {
                    Debug.LogError($"Entry UI is null for {skillName}, recreating entry");
                    skillEntries.Remove(skillName);
                    CreateSkillEntry(skillName);
                }
            }

            UpdateTotalLevel();
        }
        catch (System.Exception e)
        {
            Debug.LogError($"Error updating skill display for {skillName}: {e.Message}\n{e.StackTrace}");
        }
    }

    private void UpdateTotalLevel()
    {
        if (cachedPlayerSkills != null && totalLevelText != null)
        {
            int total = cachedPlayerSkills.GetTotalLevel();
            int maxedSkills = cachedPlayerSkills.Skills.Count(s => s.CurrentLevel >= ExperienceTable.MAX_LEVEL);
            
            string levelText = $"Total Level: {total}";
            if (maxedSkills > 0)
            {
                levelText += $" ({maxedSkills} maxed)";
            }
            totalLevelText.text = levelText;
            Debug.Log($"Updated total level display: {levelText}");
        }
    }

    public void RefreshUI()
    {
        Debug.Log("Refreshing all skill displays");
        if (cachedPlayerSkills != null)
        {
            foreach (var skill in cachedPlayerSkills.Skills)
            {
                UpdateSkillDisplay(
                    skill.SkillName,
                    skill.CurrentLevel,
                    skill.CurrentXP,
                    skill.XPToNextLevel
                );
            }
        }
        else
        {
            Debug.LogError("Cannot refresh UI - PlayerSkills reference is null");
        }
    }
}
using UnityEngine;

[CreateAssetMenu(fileName = "New Tool", menuName = "RVAMP/Items/Tool")]
public class Tool : Item
{
    [Header("Tool Properties")]
    // Remove the duplicate toolType declaration
    public float toolEfficiency = 1f;
    public int requiredLevel = 1;
    public int tier = 1;

    public float GetEfficiencyMultiplier(int skillLevel)
    {
        // Base efficiency is 1.0
        float baseMultiplier = 1f;
        
        // Tool tier adds 10% per tier
        float tierBonus = tier * 0.1f;
        
        // Skill level adds 1% per level
        float skillBonus = skillLevel * 0.01f;
        
        // Tool efficiency is a direct multiplier
        return (baseMultiplier + tierBonus + skillBonus) * toolEfficiency;
    }
}
public enum ToolType
{
    None,
    Axe,
    Pickaxe,
    FishingRod,
    Shovel,
    Hammer
}
public enum TreeType
{
    Normal,
    Oak,
    Willow,
    Maple,
    Yew,
    Magic
}
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.EventSystems;

public class UIDebugHelper : MonoBehaviour
{
    public Canvas targetCanvas;
    public GameObject contextMenuPanel;
    public RectTransform menuContainer;
    public EventSystem eventSystem;

    [Header("Debug Options")]
    public bool showDebugVisuals = true;
    public Color debugColor = Color.yellow;
    
    private void OnGUI()
    {
        if (!showDebugVisuals) return;

        GUILayout.BeginArea(new Rect(10, 10, 300, 500));
        GUILayout.Label("=== UI Debug Info ===");
        
        if (targetCanvas != null)
        {
            GUILayout.Label($"Canvas Mode: {targetCanvas.renderMode}");
            GUILayout.Label($"Sort Order: {targetCanvas.sortingOrder}");
            GUILayout.Label($"Pixel Perfect: {targetCanvas.pixelPerfect}");
            GUILayout.Label($"Scale Factor: {targetCanvas.scaleFactor}");
        }
        else
        {
            GUILayout.Label("No Canvas assigned!");
        }

        if (contextMenuPanel != null)
        {
            var rect = contextMenuPanel.GetComponent<RectTransform>();
            GUILayout.Label($"Menu Active: {contextMenuPanel.activeSelf}");
            GUILayout.Label($"Menu Position: {rect.position}");
            GUILayout.Label($"Menu Size: {rect.sizeDelta}");
            GUILayout.Label($"Menu Scale: {rect.localScale}");
            
            var canvasGroup = contextMenuPanel.GetComponent<CanvasGroup>();
            if (canvasGroup != null)
            {
                GUILayout.Label($"Alpha: {canvasGroup.alpha}");
                GUILayout.Label($"Interactable: {canvasGroup.interactable}");
                GUILayout.Label($"Blocks Raycasts: {canvasGroup.blocksRaycasts}");
            }
        }
        else
        {
            GUILayout.Label("No Context Menu Panel assigned!");
        }

        if (eventSystem != null)
        {
            GUILayout.Label($"EventSystem enabled: {eventSystem.enabled}");
            GUILayout.Label($"Current Selected: {eventSystem.currentSelectedGameObject?.name ?? "none"}");
            GUILayout.Label($"Mouse Position: {Input.mousePosition}");
            GUILayout.Label($"Over UI: {eventSystem.IsPointerOverGameObject()}");
        }
        else
        {
            GUILayout.Label("No EventSystem found!");
        }

        GUILayout.EndArea();
    }

  private void OnDrawGizmos()
    {
        if (!showDebugVisuals || contextMenuPanel == null) return;

        var rect = contextMenuPanel.GetComponent<RectTransform>();
        var corners = new Vector3[4];
        rect.GetWorldCorners(corners);
        
        Gizmos.color = debugColor;
        for (int i = 0; i < 4; i++)
        {
            Gizmos.DrawLine(corners[i], corners[(i + 1) % 4]);
        }
    }

    [UnityEngine.ContextMenu("Fix Common Issues")]
    public void FixCommonIssues()
    {
        if (targetCanvas != null)
        {
            targetCanvas.renderMode = RenderMode.ScreenSpaceOverlay;
            targetCanvas.sortingOrder = 100;
        }

        if (contextMenuPanel != null)
        {
            var rect = contextMenuPanel.GetComponent<RectTransform>();
            rect.localScale = Vector3.one;
            
            var canvasGroup = contextMenuPanel.GetComponent<CanvasGroup>();
            if (canvasGroup != null)
            {
                canvasGroup.alpha = 1;
                canvasGroup.interactable = true;
                canvasGroup.blocksRaycasts = true;
            }
        }

        if (eventSystem == null)
        {
            eventSystem = FindFirstObjectByType<EventSystem>();
            if (eventSystem == null)
            {
                var eventSystemObj = new GameObject("EventSystem");
                eventSystem = eventSystemObj.AddComponent<EventSystem>();
                eventSystemObj.AddComponent<StandaloneInputModule>();
            }
        }
    }
}
using UnityEngine;
using UnityEngine.UI;
using System.Collections.Generic;

public class UIManager : MonoBehaviour
{
    public static UIManager Instance { get; private set; }

    [Header("Panel References")]
    public GameObject inventoryPanel;
    public GameObject equipmentPanel;
    public GameObject skillsPanel;
    public GameObject settingsPanel;

    [Header("Skills UI Reference")]
    public SkillsUI skillsUI;

    private GameObject currentActivePanel;

    private void Awake()
    {
        if (Instance == null)
        {
            Instance = this;
        }
        else
        {
            Destroy(gameObject);
        }
    }

    private void Start()
    {
        HideAllPanels();
        
        if (skillsUI == null)
        {
            skillsUI = skillsPanel?.GetComponent<SkillsUI>();
        }
    }

        public void ToggleSkillsPanel()
    {
        if (skillsPanel != null)
        {
            bool isActive = !skillsPanel.activeSelf;
            skillsPanel.SetActive(isActive);
            
            if (isActive && skillsUI != null)
            {
                skillsUI.RefreshUI();
            }
        }
    }

    public void TogglePanel(GameObject panel)
    {
        if (currentActivePanel == panel)
        {
            panel.SetActive(false);
            currentActivePanel = null;
        }
        else
        {
            if (currentActivePanel != null)
            {
                currentActivePanel.SetActive(false);
            }
            panel.SetActive(true);
            currentActivePanel = panel;
        }
    }

public void UpdateSkillUI(string skillName, int level, int currentXP, int xpToNextLevel)
{
    Debug.Log($"UIManager.UpdateSkillUI called for {skillName}");
    if (skillsUI == null)
    {
        Debug.LogError("SkillsUI reference is null in UIManager!");
        return;
    }
    skillsUI.UpdateSkillDisplay(skillName, level, currentXP, xpToNextLevel);
}
    public void OpenSkillGuide(string skillName)
{
    Debug.Log($"Opening skill guide for {skillName}");
    // Add logic to open the skill guide UI
}

    public void HideAllPanels()
    {
        if (inventoryPanel) inventoryPanel.SetActive(false);
        if (equipmentPanel) equipmentPanel.SetActive(false);
        if (skillsPanel) skillsPanel.SetActive(false);
        if (settingsPanel) settingsPanel.SetActive(false);
        currentActivePanel = null;
    }
}
using UnityEngine;
using System.Collections.Generic;

public class VisibleEquipmentManager : MonoBehaviour 
{
    [System.Serializable]
    public class EquipmentSocket 
    {
        public EquipmentSlot slot;
        public Transform mountPoint;
        [Header("Equipment Positioning")]
        public Vector3 positionOffset = new Vector3(0, 0, 0);
        public Vector3 rotationOffset = new Vector3(0, -90, 0);
        public Vector3 scale = Vector3.one;
    }

    [Header("Equipment Setup")]
    public List<EquipmentSocket> equipmentSockets;
    private Dictionary<EquipmentSlot, GameObject> equippedModels = new Dictionary<EquipmentSlot, GameObject>();

    private void Start()
    {
        // Subscribe to equipment change events
        var equipmentManager = EquipmentManager.Instance;
        if (equipmentManager != null)
        {
            equipmentManager.OnEquipmentChanged += HandleEquipmentChanged;
        }
    }

    private void HandleEquipmentChanged(EquipmentSlot slot, Item item)
    {
        Debug.Log($"Handling equipment change for slot {slot}");
        
        // Remove existing model
        if (equippedModels.TryGetValue(slot, out GameObject existingModel))
        {
            Destroy(existingModel);
            equippedModels.Remove(slot);
        }

        // Handle new equipment
        if (item != null && item is CombatEquipment combatEquip)
        {
            var socket = equipmentSockets.Find(s => s.slot == slot);
            if (socket != null && socket.mountPoint != null && combatEquip.equipmentModel != null)
            {
                try
                {
                    GameObject model = Instantiate(combatEquip.equipmentModel, socket.mountPoint);
                    model.transform.localPosition = socket.positionOffset;
                    model.transform.localRotation = Quaternion.Euler(socket.rotationOffset);
                    model.transform.localScale = socket.scale;
                    
                    equippedModels[slot] = model;
                    Debug.Log($"Successfully created visual model for {item.itemName}");
                }
                catch (System.Exception e)
                {
                    Debug.LogError($"Error creating equipment model: {e.Message}");
                }
            }
            else
            {
                Debug.LogWarning($"Missing socket configuration for {slot} or equipment model for {item.itemName}");
            }
        }
    }

    private void OnDestroy()
    {
        if (EquipmentManager.Instance != null)
        {
            EquipmentManager.Instance.OnEquipmentChanged -= HandleEquipmentChanged;
        }
    }
}
using UnityEngine;

[System.Serializable]
public class WeaponAttackStyle
{
    public string styleName;
    public AttackStyle attackStyle;           // Stab, Slash, etc.
    public CombatTrainingStyle trainingStyle; // Precision, Might, etc.
    public bool splitXPWithFortitude;         // Whether to split XP with Fortitude
    public float accuracyModifier = 1f;       // Affects hit chance
    public float damageModifier = 1f;         // Affects max hit
    public float experienceMultiplier = 4f;   // Standard RS multiplier
    
    // Helper method to determine combat style
    public CombatStyle GetCombatStyle()
    {
        return attackStyle switch
        {
            AttackStyle.Stab or AttackStyle.Slash or AttackStyle.Crush => CombatStyle.Melee,
            AttackStyle.Range => CombatStyle.Ranged,
            AttackStyle.Spellweaving => CombatStyle.Magic,
            _ => CombatStyle.Melee
        };
    }
}
using UnityEngine;

[CreateAssetMenu(fileName = "New Weapon", menuName = "Combat/Weapon")]
public class WeaponData : CombatEquipment
{
    [Header("Weapon Properties")]
    public WeaponType weaponType;
    public CombatConfig combatConfig;

    [Header("Attack Properties")]
    public float baseAttackSpeed = 2.4f;
    public bool hasSpecialAttack;
    [Range(0, 100)]
    public int specialAttackCost = 50;

    [Header("Combat Training")]
    public CombatTrainingStyle primaryTrainingStyle; // Add this field
    public CombatTrainingStyle[] availableTrainingStyles;
    public bool allowFortitudeTraining = true;
    public float accuracyModifier = 1f;
    public float damageModifier = 1f;

    

    private void OnEnable()
    {
        itemType = ItemType.Equipment;
        equipSlot = EquipmentSlot.MainHand;
        SetupCombatConfig();
    }

    private void SetupCombatConfig()
    {
        if (combatConfig == null)
        {
            combatConfig = CreateInstance<CombatConfig>();
            combatConfig.baseAttackInterval = baseAttackSpeed;
            combatConfig.primaryStyle.attackStyle = defaultAttackStyle;
            combatConfig.primaryStyle.trainingStyle = primaryTrainingStyle;
            combatConfig.primaryStyle.splitXPWithFortitude = allowFortitudeTraining;
        }
    }

    public int CalculateMaxHit(PlayerSkills skills)
    {
        if (skills == null) return 0;

        switch (defaultAttackStyle)
        {
            case AttackStyle.Stab:
            case AttackStyle.Slash:
            case AttackStyle.Crush:
                var mightSkill = skills.GetSkill("Might");
                if (mightSkill == null) return 0;
                return Mathf.FloorToInt(0.5f + (mightSkill.CurrentLevel * (bonuses.mightBonus + 64)) / 640f);

            case AttackStyle.Range:
                var rangeSkill = skills.GetSkill("Range");
                if (rangeSkill == null) return 0;
                return Mathf.FloorToInt(0.5f + (rangeSkill.CurrentLevel * (bonuses.rangeStrengthBonus + 64)) / 640f);

            case AttackStyle.Spellweaving:
                int baseSpellDamage = 10;
                return Mathf.FloorToInt(baseSpellDamage * (1 + bonuses.spellweavingDamage / 100f));

            default:
                return 0;
        }
    }

    public float CalculateHitChance(PlayerSkills skills, CombatStats targetStats)
    {
        if (skills == null || targetStats == null) return 0f;

        var attackSkill = GetAttackSkill(skills);
        if (attackSkill == null) return 0f;

        float effectiveAccuracy = attackSkill.CurrentLevel + bonuses.GetAttackBonus(defaultAttackStyle);
        float effectiveFortitude = targetStats.Fortitude + targetStats.GetDefenseBonus(defaultAttackStyle);

        return effectiveAccuracy / (effectiveAccuracy + effectiveFortitude);
    }

    private Skill GetAttackSkill(PlayerSkills skills)
    {
        return defaultAttackStyle switch
        {
            AttackStyle.Stab or AttackStyle.Slash or AttackStyle.Crush => skills.GetSkill("Precision"),
            AttackStyle.Range => skills.GetSkill("Range"),
            AttackStyle.Spellweaving => skills.GetSkill("Spellweaving"),
            _ => null
        };
    }

    public int RollDamage(int maxHit)
    {
        float randomFactor = Random.value;
        return Mathf.Max(10, Mathf.FloorToInt(10 + (maxHit - 10) * randomFactor));
    }
}
using UnityEngine;
using System.Collections.Generic;
public enum WeaponType
{
    Unarmed,
    Sword,
    Dagger,
    Mace,
    Bow,
    Crossbow,
    Staff,
    Wand
}
using UnityEngine;

public class Woodcutting : BaseSkillAction
{
    [Header("Woodcutting Specific")]
    public ParticleSystem woodchipsEffect;
    private ChoppableTree currentTree;

    protected override void Start()
    {
        base.Start();
        requiredSkillName = "Woodcutting";
        requiredToolType = ToolType.Axe;
        Debug.Log("[Woodcutting] Initialized woodcutting skill action.");
    }

    public override void SetTarget(ResourceNode target)
    {
        if (target is ChoppableTree tree)
        {
            base.SetTarget(target);
            currentTree = tree;
            Debug.Log($"[Woodcutting] Targeting tree: {tree.name}");
        }
        else
        {
            Debug.LogError("[Woodcutting] Invalid target type. Expected ChoppableTree.");
            currentTree = null;
        }
    }

    protected override string GetAnimationTrigger() => "isChopping";

    protected virtual void PlayWoodchipsEffect()
    {
        if (woodchipsEffect != null)
        {
            woodchipsEffect.Play();
            Debug.Log("Playing woodchips effect.");
        }
    }

    protected override bool ProcessAction()
    {
        if (currentTarget != null && currentTarget.IsRespawning)
        {
            Debug.Log($"[{requiredSkillName}] Cannot gather - resource is respawning");
            StopAction();
            return false;
        }

        if (currentTree == null || !currentTree.HasResources())
        {
            Debug.Log("[Woodcutting] No tree target or tree depleted!");
            StopAction();
            return false;
        }

        Tool currentAxe = inventory.GetToolOfType(requiredToolType) as Tool;
        if (currentAxe == null)
        {
            Debug.Log("[Woodcutting] No axe found in inventory!");
            NotifyPlayer("You need an axe to chop wood.");
            StopAction();
            return false;
        }

        if (currentTree.Gather(currentAxe))
        {
            Debug.Log("[Woodcutting] Successfully chopped wood from tree.");
            PlayWoodchipsEffect();
            inventory.AddItem(currentTree.primaryResource, 1);
            playerSkills.AddExperience(requiredSkillName, currentTree.baseXP);
            return true;
        }

        Debug.Log("[Woodcutting] Failed to chop wood.");
        StopAction();
        return false;
    }

    public override void StopAction()
    {
        base.StopAction();
        currentTree = null;
        SetAnimationState(false);
    }
}
using UnityEngine;
using UnityEngine.EventSystems;
using System;
using System.Collections.Generic;

public class WorldInteractable : MonoBehaviour
{
    public string objectName = "Object";
    public string examineText;

    private List<ContextMenuOption> orderedOptions = new List<ContextMenuOption>();
    private Dictionary<string, (Action action, Func<bool> condition)> customOptions = 
        new Dictionary<string, (Action, Func<bool>)>();

    void Start()
    {
        InitializeDefaultOptions();
    }

private void InitializeDefaultOptions()
{
    // Add Walk Here as a standard option (except for inventory items)
    if (!gameObject.GetComponent<InventoryItemUI>())
    {
        AddCustomOption("Walk here", () => {
            var clickToMove = FindFirstObjectByType<ClickToMove>();
            if (clickToMove != null)
            {
                Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
                if (Physics.Raycast(ray, out RaycastHit hit, Mathf.Infinity, LayerMask.GetMask("Ground", "Terrain")))
                {
                    if (UnityEngine.AI.NavMesh.SamplePosition(hit.point, out UnityEngine.AI.NavMeshHit navHit, 2f, UnityEngine.AI.NavMesh.AllAreas))
                    {
                        clickToMove.MoveToTarget(navHit.position);
                    }
                }
            }
        }, null, 900);
    }

    // Add Examine as a standard option (except for ground)
    if (gameObject.layer != LayerMask.NameToLayer("Ground"))
    {
        AddCustomOption("Examine", () => {
            string displayText = !string.IsNullOrEmpty(examineText) 
                ? examineText 
                : $"You examine the {objectName}.";
            EnhancedChatbox.Instance?.AddMessage(displayText);
        }, null, 950);
    }
}

    public void AddCustomOption(string optionName, Action action, Func<bool> condition = null, int priority = 0)
    {
        // Store the option with its condition
        customOptions[optionName] = (action, condition ?? (() => true));
        
        // Create and insert the option in priority order
        var option = new ContextMenuOption(optionName, action);
        
        // Find the correct position to insert based on priority
        int insertIndex = 0;
        while (insertIndex < orderedOptions.Count && 
               GetOptionPriority(orderedOptions[insertIndex].Text) <= priority)
        {
            insertIndex++;
        }
        
        orderedOptions.Insert(insertIndex, option);
    }

private int GetOptionPriority(string optionName)
{
    // Define priorities for different types of actions
    switch (optionName.ToLower())
    {
        case var s when s.StartsWith("attack"): return 0;
        case var s when s.StartsWith("pick up"): return 100;
        case var s when s.StartsWith("chop"): return 200;
        case var s when s.StartsWith("mine"): return 200;
        case var s when s.StartsWith("equip"): return 300;
        case var s when s.StartsWith("drink"): return 300;
        case var s when s.StartsWith("eat"): return 300;
        case var s when s.StartsWith("use"): return 400;
        case "walk here": return 900;
        case "examine": return 950;
        case "cancel": return 1000;
        default: return 500; // Default priority for custom actions
    }
}

    void OnMouseOver()
    {
        // Handle left click for primary action
        if (Input.GetMouseButtonDown(0))
        {
            if (!EventSystem.current.IsPointerOverGameObject())
            {
                ExecutePrimaryAction();
            }
        }
        // Handle right click for context menu
        else if (Input.GetMouseButtonDown(1))
        {
            if (!EventSystem.current.IsPointerOverGameObject() || 
                (ContextMenu.Instance != null && ContextMenu.Instance.IsClickingMenuItem()))
            {
                ShowContextMenu();
            }
        }
    }

    private void ExecutePrimaryAction()
    {
        // Execute the first available action in the ordered list
        foreach (var option in orderedOptions)
        {
            if (customOptions.TryGetValue(option.Text, out var optionData))
            {
                if (optionData.condition())
                {
                    optionData.action?.Invoke();
                    return;
                }
            }
        }
    }

    private List<ContextMenuOption> GetAvailableOptions()
    {
        List<ContextMenuOption> availableOptions = new List<ContextMenuOption>();

        foreach (var option in orderedOptions)
        {
            if (customOptions.TryGetValue(option.Text, out var optionData))
            {
                if (optionData.condition())
                {
                    availableOptions.Add(option);
                }
            }
        }

        // Add Cancel option at the end
        availableOptions.Add(new ContextMenuOption("Cancel", () => {
            if (ContextMenu.Instance != null)
            {
                ContextMenu.Instance.HideMenu();
            }
        }));

        return availableOptions;
    }

private void ShowContextMenu()
{
    if (ContextMenu.Instance == null)
    {
        Debug.LogError("ContextMenu.Instance is null! Ensure ContextMenu prefab is in the scene.");
        return;
    }

    List<ContextMenuOption> availableOptions = GetAvailableOptions();
    if (availableOptions.Count > 0)
    {
        ContextMenu.Instance.ShowMenu(Input.mousePosition, availableOptions);
    }
}
}
using UnityEngine;
using UnityEngine.AI;
using System.Collections;

public abstract class BaseSkillAction : MonoBehaviour
{
    [Header("Basic Settings")]
    public float actionDistance = 2.0f;
    public float baseActionInterval = 3f;
    public float animationDuration = 0.8f;

    [Header("Requirements")]
    public ToolType requiredToolType;
    public int minimumLevel = 1;
    public string requiredSkillName;

    [Header("Audio")]
    public AudioClip[] actionSounds;

    public bool IsPerformingAction => isPerformingAction;
    private float lastSoundTime = 0f;
    private float soundCooldown = 1f;
    private SkillsAudioManager skillsAudioManager;

    protected NavMeshAgent agent;
    protected Animator animator;
    protected Inventory inventory;
    protected PlayerSkills playerSkills;
    protected ResourceNode currentTarget;
    protected bool isPerformingAction = false;
    protected bool isWalkingToTarget = false;
    private bool shouldStopAction = false;

    private Coroutine actionCoroutine;

    protected virtual void Start()
    {
        agent = GetComponent<NavMeshAgent>();
        animator = GetComponent<Animator>();
        inventory = Inventory.Instance;
        playerSkills = GetComponent<PlayerSkills>();
        skillsAudioManager = FindFirstObjectByType<SkillsAudioManager>();

        ValidateComponents();
    }

    protected virtual void ValidateComponents()
    {
        if (agent == null) Debug.LogError($"NavMeshAgent missing on {gameObject.name}");
        if (animator == null) Debug.LogError($"Animator missing on {gameObject.name}");
        if (inventory == null) Debug.LogError("Inventory not found");
        if (playerSkills == null) Debug.LogError("PlayerSkills not found");
    }

    protected virtual void Update()
    {
        if (isWalkingToTarget && currentTarget != null)
            CheckArrivalAtTarget();
    }

public virtual void SetTarget(ResourceNode target)
{
    if (isPerformingAction && currentTarget == target)
    {
        Debug.Log($"[BaseSkillAction] Already gathering from {target?.name}, skipping reset.");
        return;
    }

    Debug.Log($"[BaseSkillAction] Setting new target: {target?.name}");

    if (isPerformingAction)
    {
        Debug.Log($"[BaseSkillAction] Stopping current action before setting new target");
        StopAction();
    }

    UnsubscribeFromResourceEvents();
    currentTarget = target;
    
    if (currentTarget != null)
    {
        Debug.Log($"Setting target and walking to {target.name}");
        agent.stoppingDistance = actionDistance;
        agent.SetDestination(target.transform.position);
        agent.isStopped = false;
        isWalkingToTarget = true;
        SubscribeToResourceEvents();
    }
}

    protected virtual void CheckArrivalAtTarget()
    {
        if (currentTarget == null || agent.pathPending) return;

        float distanceToTarget = Vector3.Distance(transform.position, currentTarget.transform.position);
        if (distanceToTarget <= actionDistance && !isPerformingAction)
        {
            Debug.Log("Arrived at target, starting action");
            isWalkingToTarget = false;
            agent.isStopped = true;
            FaceTarget();
            StartAction();
        }
    }

    protected virtual void FaceTarget()
    {
        if (currentTarget == null) return;

        Vector3 directionToTarget = (currentTarget.transform.position - transform.position).normalized;
        Quaternion targetRotation = Quaternion.LookRotation(new Vector3(directionToTarget.x, 0, directionToTarget.z));
        transform.rotation = targetRotation;
    }

    protected virtual void StartAction()
    {
        if (!CanPerformAction() || isPerformingAction)
            return;

        Debug.Log("Starting gathering action");
        isPerformingAction = true;

        if (actionCoroutine != null)
            StopCoroutine(actionCoroutine);

        actionCoroutine = StartCoroutine(ActionRoutine());
    }

    protected virtual bool CanPerformAction()
    {
    if (currentTarget != null && (!currentTarget.IsValidForGathering() || currentTarget.IsRespawning))
    {
        Debug.Log($"[{requiredSkillName}] Cannot gather - resource is respawning or depleted");
        StopAction();
        return false;
    }

        if (!HasRequiredTool())
        {
            NotifyPlayer($"You need a {requiredToolType} to perform this action.");
            return false;
        }

        Skill skill = playerSkills.GetSkill(requiredSkillName);
        if (skill == null)
        {
            Debug.LogError($"Skill {requiredSkillName} not found!");
            return false;
        }

        if (minimumLevel > 1 && skill.CurrentLevel < minimumLevel)
        {
            NotifyPlayer($"You need level {minimumLevel} {requiredSkillName} to perform this action.");
            return false;
        }

        return true;
    }

    protected virtual bool HasRequiredTool()
    {
        if (requiredToolType == ToolType.None) return true;

        Tool tool = inventory.GetToolOfType(requiredToolType);
        if (tool != null)
        {
            Debug.Log($"Found required tool: {tool.itemName}");
            return true;
        }

        Debug.Log($"Required tool of type {requiredToolType} not found in inventory.");
        return false;
    }

    protected virtual IEnumerator ActionRoutine()
    {
        Debug.Log($"[{requiredSkillName}] Starting action routine");
        float nextActionTime = 0f;
        shouldStopAction = false;

        while (!shouldStopAction && isPerformingAction && CanPerformAction())
        {
            if (Time.time >= nextActionTime)
            {
                if (currentTarget == null || currentTarget.IsRespawning)
                {
                    Debug.Log($"[{requiredSkillName}] Target is null or respawning, stopping action");
                    shouldStopAction = true;
                    break;
                }

                PlayActionSound();
                SetAnimationState(true);
                
                yield return new WaitForSeconds(animationDuration);

                if (ProcessAction())
                {
                    SetAnimationState(false);
                    nextActionTime = Time.time + baseActionInterval;
                    
                    float remainingInterval = baseActionInterval - animationDuration;
                    if (remainingInterval > 0)
                    {
                        yield return new WaitForSeconds(remainingInterval);
                    }
                }
                else
                {
                    shouldStopAction = true;
                    break;
                }
            }
            yield return null;
        }

        Debug.Log($"[{requiredSkillName}] Exiting action routine");
        StopAction();
    }

    protected virtual void PlayActionSound()
    {
        if (skillsAudioManager != null && actionSounds != null && actionSounds.Length > 0)
        {
            if (Time.time - lastSoundTime >= soundCooldown)
            {
                AudioClip randomSound = actionSounds[Random.Range(0, actionSounds.Length)];
                skillsAudioManager.PlaySkillSound(randomSound);
                lastSoundTime = Time.time;
            }
        }
    }

    protected void UnsubscribeFromResourceEvents()
    {
        if (currentTarget != null)
        {
            currentTarget.OnRespawnStarted -= HandleResourceRespawnStarted;
            currentTarget.OnRespawnCompleted -= HandleResourceRespawnCompleted;
        }
    }

    protected virtual void HandleResourceRespawnStarted(ResourceNode resource)
    {
        if (resource == currentTarget)
        {
            Debug.Log($"[{requiredSkillName}] Resource entered respawn state, stopping action");
            StopAction();
        }
    }

    protected virtual void HandleResourceRespawnCompleted(ResourceNode resource)
    {
        Debug.Log($"[{requiredSkillName}] Resource has respawned");
    }

    protected virtual void SubscribeToResourceEvents()
    {
        if (currentTarget != null)
        {
            currentTarget.OnRespawnStarted += HandleResourceRespawnStarted;
            currentTarget.OnRespawnCompleted += HandleResourceRespawnCompleted;
        }
    }

    public virtual void StopAction()
    {
        if (!isPerformingAction) return;

        Debug.Log($"[{requiredSkillName}] Stopping action");
        shouldStopAction = true;
        isPerformingAction = false;
        SetAnimationState(false);

        if (actionCoroutine != null)
        {
            StopCoroutine(actionCoroutine);
            actionCoroutine = null;
        }

        if (agent != null)
        {
            agent.ResetPath();
        }

        UnsubscribeFromResourceEvents();
    }

    protected abstract bool ProcessAction();

    protected virtual void NotifyPlayer(string message)
    {
        EnhancedChatbox.Instance?.AddMessage(message);
    }

    protected virtual void SetAnimationState(bool active)
    {
        if (animator != null)
        {
            string trigger = GetAnimationTrigger();
            if (!string.IsNullOrEmpty(trigger))
            {
                animator.SetBool(trigger, active);
            }
        }
    }

    protected abstract string GetAnimationTrigger();
}
using UnityEngine;
using UnityEngine.AI;
using System.Collections;

[RequireComponent(typeof(NavMeshAgent))]
public class BasicNPC : MonoBehaviour, ICombatant
{
    [Header("NPC Base Stats")]
    public string npcName = "Training Dummy";
    public int level = 1;
    public int baseVitality = 100;
    private CombatStats stats;
    
    [Header("Combat Configuration")]
    public float attackRange = 2f;
    public float attackSpeed = 2.4f;
    public AttackStyle defaultAttackStyle = AttackStyle.Slash;
    public float baseXPValue = 40f;
    
    [Header("Combat Bonuses")]
    public CombatBonuses bonuses = new CombatBonuses();

    [Header("Behavior Settings")]
    public float aggroRange = 5f;
    public bool isAggressive = false;
    
    // State tracking
    private bool isAlive = true;
    private bool isInCombat = false;
    private NavMeshAgent agent;
    private ICombatant currentTarget;
    private float nextAttackTime;
    private Animator animator;

    // ICombatant interface implementation
    public CombatStats Stats => stats;
    public bool IsAlive => isAlive;
    public new Transform transform => base.transform;
    public string GetDisplayName() => npcName;

    private void Start()
    {
        InitializeComponents();
        InitializeStats();
        SetupInteraction();
        StartCoroutine(BehaviorRoutine());
    }

    private void InitializeComponents()
    {
        agent = GetComponent<NavMeshAgent>();
        animator = GetComponent<Animator>();
        
        if (agent == null)
            Debug.LogError($"NavMeshAgent missing on {npcName}!");
    }

    private void InitializeStats()
    {
        // Calculate scaled stats based on level
        int scaledVitality = baseVitality + (level * 4);
        int scaledPrecision = level;
        int scaledMight = level;
        int scaledFortitude = level;
        int scaledRange = level;
        int scaledSpellweaving = level;
        int scaledDivinity = level;

        stats = new CombatStats(
            vitality: scaledVitality,
            precision: scaledPrecision,
            might: scaledMight,
            fortitude: scaledFortitude,
            range: scaledRange,
            spellweaving: scaledSpellweaving,
            divinity: scaledDivinity
        );

        // Apply any additional bonuses
        stats.combatBonuses = bonuses;
        
        Debug.Log($"Initialized {npcName} (Level {level}) - " +
                 $"Vitality: {stats.Vitality}, " +
                 $"Combat Style: {defaultAttackStyle}");
    }

    private void SetupInteraction()
    {
        var interactable = gameObject.AddComponent<WorldInteractable>();
        interactable.objectName = npcName;
        
        // Add attack option
        interactable.AddCustomOption("Attack", () => {
            var player = GameObject.FindGameObjectWithTag("Player");
            if (player != null)
            {
                var playerCombat = player.GetComponent<CombatHandler>();
                if (playerCombat != null)
                {
                    playerCombat.StartCombat(this);
                }
            }
        });
    }

    private IEnumerator BehaviorRoutine()
    {
        while (isAlive)
        {
            if (isAggressive && !isInCombat)
            {
                CheckForTargets();
            }

            if (isInCombat)
            {
                UpdateCombat();
            }

            yield return new WaitForSeconds(0.5f);
        }
    }

    private void CheckForTargets()
    {
        var player = GameObject.FindGameObjectWithTag("Player");
        if (player != null)
        {
            float distance = Vector3.Distance(transform.position, player.transform.position);
            if (distance <= aggroRange)
            {
                var playerCombat = player.GetComponent<ICombatant>();
                if (playerCombat != null && playerCombat.IsAlive)
                {
                    StartCombat(playerCombat);
                }
            }
        }
    }

    private void UpdateCombat()
    {
        if (currentTarget == null || !currentTarget.IsAlive)
        {
            EndCombat();
            return;
        }

        float distance = Vector3.Distance(transform.position, currentTarget.transform.position);
        
        // Move towards target if too far
        if (distance > attackRange)
        {
            agent.SetDestination(currentTarget.transform.position);
        }
        else
        {
            agent.ResetPath();
            if (Time.time >= nextAttackTime)
            {
                Attack(currentTarget);
            }
        }
    }

    public void Attack(ICombatant target)
    {
        if (!IsAlive || target == null || !target.IsAlive) return;

        // Set up attack configuration
        var attackStyle = new WeaponAttackStyle
        {
            styleName = $"{npcName} Attack",
            attackStyle = defaultAttackStyle,
            trainingStyle = CombatTrainingStyle.Precision,
            accuracyModifier = 1f,
            damageModifier = 1f
        };

        // Calculate accuracy
        float accuracy = CombatCalculator.CalculateAccuracy(this, target, attackStyle);
        
        // Perform attack
        if (Random.value < accuracy)
        {
            int damage = CalculateDamage();
            target.TakeDamage(damage, defaultAttackStyle);
            Debug.Log($"{npcName} hit {target.GetDisplayName()} for {damage} damage!");

            // Play hit effects
            if (target is MonoBehaviour targetObj)
            {
                var combatHandler = targetObj.GetComponent<CombatHandler>();
                combatHandler?.PlayHitEffect(targetObj.transform.position);
                combatHandler?.PlayCombatSound(true);
            }
        }
        else
        {
            Debug.Log($"{npcName} missed their attack against {target.GetDisplayName()}!");
            if (target is MonoBehaviour targetObj)
            {
                var combatHandler = targetObj.GetComponent<CombatHandler>();
                combatHandler?.PlayCombatSound(false);
            }
        }

        nextAttackTime = Time.time + attackSpeed;

        // Update animation if available
        if (animator != null)
        {
            animator.SetTrigger("Attack");
        }
    }

    private int CalculateDamage()
    {
        int maxHit = stats.CalculateMaxHit(defaultAttackStyle);
        return Random.Range(1, maxHit + 1);
    }

    public void TakeDamage(int damage, AttackStyle style)
    {
        if (!IsAlive) return;

        stats.ModifyVitality(-damage);
        Debug.Log($"{npcName} took {damage} damage! Vitality: {stats.Vitality}/{stats.MaxVitality}");

        if (!stats.IsAlive)
        {
            Die();
        }
    }

    public AttackStyle GetCurrentCombatStyle()
    {
        return defaultAttackStyle;
    }
    public float GetAttackSpeed()
    {
        return attackSpeed;
    }

    private void StartCombat(ICombatant target)
    {
        currentTarget = target;
        isInCombat = true;
        
        if (animator != null)
        {
            animator.SetBool("InCombat", true);
        }
    }

    private void EndCombat()
    {
        currentTarget = null;
        isInCombat = false;
        agent.ResetPath();
        
        if (animator != null)
        {
            animator.SetBool("InCombat", false);
        }
    }

    private void Die()
    {
        isAlive = false;
        EndCombat();
        
        if (animator != null)
        {
            animator.SetTrigger("Death");
        }

        // Grant combat XP to player if killed by player
        var player = GameObject.FindGameObjectWithTag("Player");
        if (player != null)
        {
            var playerSkills = player.GetComponent<PlayerSkills>();
            if (playerSkills != null)
            {
                // Calculate XP based on NPC's level and base XP value
                float scaledXP = baseXPValue * (1 + level * 0.1f);
                playerSkills.AddExperience("Precision", scaledXP);
                EnhancedChatbox.Instance?.AddMessage($"Defeated {npcName}! Gained {scaledXP:F1} Combat experience!");
            }
        }

        // Remove interactability
        var interactable = GetComponent<WorldInteractable>();
        if (interactable != null)
        {
            Destroy(interactable);
        }

        // Destroy after delay to show death animation
        StartCoroutine(DeathSequence());
    }

    private IEnumerator DeathSequence()
    {
        // Wait for death animation
        yield return new WaitForSeconds(2f);
        
        // TODO: Drop loot here
        
        // Destroy the NPC
        Destroy(gameObject);
    }

    private void OnDrawGizmosSelected()
    {
        // Visualize attack range
        Gizmos.color = Color.red;
        Gizmos.DrawWireSphere(transform.position, attackRange);
        
        // Visualize aggro range
        if (isAggressive)
        {
            Gizmos.color = Color.yellow;
            Gizmos.DrawWireSphere(transform.position, aggroRange);
        }
    }
}
using UnityEngine;
using System.Collections;

public class ChoppableTree : ResourceNode
{
    [Header("Woodcutting Specific")]
    public TreeType treeType;
    public int birdNestChance = 5; // Percentage chance for bird's nests

    [Header("Tree Effects")]
    public ParticleSystem woodchipsParticles;
    public GameObject treeStump;
    public GameObject fallingTreeEffect;
    private Material originalMaterial;

    protected override void Initialize()
    {
        base.Initialize();
        if (resourceRenderer != null)
        {
            originalMaterial = resourceRenderer.material;
        }
        requiredToolType = ToolType.Axe; // Set the required tool type for chopping trees
    }

    public override bool Gather(Tool tool)
    {
        if (!base.Gather(tool)) return false;

        if (woodchipsParticles != null)
        {
            woodchipsParticles.Play();
        }

        CheckForBirdNest(tool);

        return true;
    }

    private void CheckForBirdNest(Tool tool)
    {
        float bonusChance = birdNestChance;
        if (tool != null)
        {
            bonusChance *= tool.GetEfficiencyMultiplier(1);
        }

        if (Random.value < bonusChance / 100f)
        {
            Debug.Log("Found a bird's nest!");
            // You might want to add a bird's nest item to the player's inventory here
            // For example: Inventory.Instance.AddItem(birdNestItem, 1);
        }
    }


    protected override IEnumerator FadeOut()
    {
        if (fallingTreeEffect != null)
        {
            Instantiate(fallingTreeEffect, transform.position, transform.rotation);
        }

        if (treeStump != null)
        {
            GameObject stump = Instantiate(treeStump, transform.position, transform.rotation);
            Destroy(stump, respawnTime);
        }

        float duration = 1f;
        float elapsed = 0;

        while (elapsed < duration)
        {
            elapsed += Time.deltaTime;
            if (resourceRenderer != null && resourceRenderer.material != null)
            {
                Color newColor = resourceRenderer.material.color;
                newColor.a = 1 - (elapsed / duration);
                resourceRenderer.material.color = newColor;
            }
            yield return null;
        }

        resourceRenderer.enabled = false;
        resourceCollider.enabled = false;
    }

    protected override IEnumerator FadeIn()
    {
        resourceRenderer.enabled = true;
        resourceCollider.enabled = true;

        float duration = 1f;
        float elapsed = 0;

        while (elapsed < duration)
        {
            elapsed += Time.deltaTime;
            if (resourceRenderer != null && resourceRenderer.material != null)
            {
                Color newColor = resourceRenderer.material.color;
                newColor.a = elapsed / duration;
                resourceRenderer.material.color = newColor;
            }
            yield return null;
        }

        // Reset the material to its original state
        if (resourceRenderer != null && originalMaterial != null)
        {
            resourceRenderer.material = originalMaterial;
        }
    }
}

​x
 
using UnityEngine;
using UnityEngine.EventSystems;
​
public class ClickDebug : MonoBehaviour
{
    void Update()
    {
        // Don't process clicks if over UI
        if (EventSystem.current.IsPointerOverGameObject())
        {
            return;
        }
​
        if (Input.GetMouseButtonDown(0)) // Left mouse button
        {
            Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
            RaycastHit hit;
​
            if (Physics.Raycast(ray, out hit))
            {
                Debug.Log($"Hit object: {hit.collider.gameObject.name} on layer: {LayerMask.LayerToName(hit.collider.gameObject.layer)}");
​
                // Check for ItemPickup
                ItemPickup itemPickup = hit.collider.GetComponent<ItemPickup>();
                if (itemPickup != null)
                {
                    Debug.Log($"Found ItemPickup: {itemPickup.item.itemName}");
                }
                else
                {
                    // Check for ResourceNode
                    ResourceNode resourceNode = hit.collider.GetComponent<ResourceNode>();
                    if (resourceNode != null)
                    {
                        Debug.Log($"Found ResourceNode: {resourceNode.nodeName}");
                    }
                    else
                    {
                        Debug.Log("No interactable component on this object");
                    }
                }
            }
        }
    }
}
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.EventSystems;
​
public class ClickIndicator : MonoBehaviour
{
    public GameObject clickMarkerPrefab;
    public Canvas canvas;
    public float markerLifetime = 0.5f;
    public LayerMask clickableLayers;
    public LayerMask groundLayer;
​
    private Camera mainCamera;
​
    private void Start()
    {
        mainCamera = Camera.main;
        if (canvas == null)
        {
            Debug.LogError("Canvas is not assigned in ClickIndicator script!");
        }
    }
​
    private void Update()
    {
        if (Input.GetMouseButtonDown(0))
        {
            if (EventSystem.current != null && EventSystem.current.IsPointerOverGameObject())
            {
                return;
            }
​
            Ray ray = mainCamera.ScreenPointToRay(Input.mousePosition);
            RaycastHit hit;
​
            if (Physics.Raycast(ray, out hit, Mathf.Infinity, clickableLayers))
            {
                // If we hit a clickable object, don't show marker
                return;
            }
​
            // Check if we hit the ground
            if (Physics.Raycast(ray, out hit, Mathf.Infinity, groundLayer))
            {
                CreateClickMarker(hit.point);
            }
        }
    }
​
    private void CreateClickMarker(Vector3 worldPosition)
    {
        GameObject marker = Instantiate(clickMarkerPrefab, canvas.transform);
        
        Vector2 screenPoint = mainCamera.WorldToScreenPoint(worldPosition);
        RectTransformUtility.ScreenPointToLocalPointInRectangle(
            canvas.GetComponent<RectTransform>(),
            screenPoint,
            canvas.worldCamera,
            out Vector2 localPoint
        );
​
        RectTransform markerRect = marker.GetComponent<RectTransform>();
        markerRect.localPosition = localPoint;
        Destroy(marker, markerLifetime);
    }
}
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.EventSystems;
​
public class ClickToMove : MonoBehaviour
{
    [Header("Movement Settings")]
    private NavMeshAgent navMeshAgent;
    public GameObject destinationMarkerPrefab;
    private GameObject destinationMarker;
    public float interactionRange = 1f;
​
    [Header("Layer Settings")]
    public LayerMask clickableLayers;
    public LayerMask groundLayer;
​
    private ResourceNode targetResourceNode;
    private Woodcutting woodcuttingSkill;
    private Mining miningSkill;
    private CombatHandler combatHandler;
    private bool isMovingToDestination = false;
    private bool isContextMenuMove = false;
​
    private void Start() //test
    {
        navMeshAgent = GetComponent<NavMeshAgent>();
        woodcuttingSkill = GetComponent<Woodcutting>();
        miningSkill = GetComponent<Mining>();
        combatHandler = GetComponent<CombatHandler>();
        InitializeDestinationMarker();
​
        Debug.Log($"ClickToMove initialized. NavMeshAgent: {navMeshAgent != null}, Ground Layer: {LayerMask.LayerToName(groundLayer)}");
    }
​
    private void InitializeDestinationMarker()
    {
        if (destinationMarkerPrefab != null)
        {
            destinationMarker = Instantiate(destinationMarkerPrefab);
            destinationMarker.SetActive(false);
        }
    }
​
    private void Update()
    {
        if (EventSystem.current != null && EventSystem.current.IsPointerOverGameObject())
            return;
​
        if (combatHandler != null && combatHandler.InCombat)
        {
            HideDestinationMarker();
            return;
        }
​
        if (Input.GetMouseButtonDown(0))
            HandleMouseClick();
​
        if (targetResourceNode != null)
            CheckResourceProximity();
​
        CheckDestinationReached();
    }
​
private void HandleMouseClick()
{
    Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
    RaycastHit hit;
​
    // First check for interactable objects
    if (Physics.Raycast(ray, out hit, Mathf.Infinity, clickableLayers))
    {
        Debug.Log($"Clicked on object: {hit.collider.gameObject.name} on layer: {LayerMask.LayerToName(hit.collider.gameObject.layer)}");
        
        // Don't stop movement for WorldInteractable objects since they handle their own interactions
        WorldInteractable interactable = hit.collider.GetComponent<WorldInteractable>();
        if (interactable != null)
        {
            return;
        }
​
        StopMovementAndActions();
        ResourceNode resourceNode = hit.collider.GetComponent<ResourceNode>();
        if (resourceNode != null)
        {
            targetResourceNode = resourceNode;
            MoveToPosition(hit.point);
            return;
        }
    }
​
    // Then check for ground movement
    if (Physics.Raycast(ray, out hit, Mathf.Infinity, groundLayer))
    {
        Debug.Log($"Clicked on ground at position: {hit.point}");
        StopMovementAndActions();
        targetResourceNode = null;
        MoveToPosition(hit.point);
    }
}
​
private void MoveToPosition(Vector3 position)
{
    if (navMeshAgent == null) 
    {
        Debug.LogError("NavMeshAgent is null!");
        return;
    }
​
    // Sample a valid position on the NavMesh
    if (NavMesh.SamplePosition(position, out NavMeshHit navHit, 2f, NavMesh.AllAreas))
    {
        Debug.Log($"Moving to position: {navHit.position}");
        
        // Set stopping distance based on whether we're moving to a resource or just walking
        navMeshAgent.stoppingDistance = targetResourceNode != null ? interactionRange : 0.1f;
        
        navMeshAgent.SetDestination(navHit.position);
        isMovingToDestination = true;
​
        // Show destination marker
        if (destinationMarker != null)
        {
            destinationMarker.transform.position = navHit.position + new Vector3(0, 0.1f, 0); // Slight offset to prevent z-fighting
            destinationMarker.SetActive(true);
        }
    }
    else
    {
        Debug.LogWarning("Could not find valid NavMesh position!");
    }
}
​
private void CheckResourceProximity()
{
    if (targetResourceNode == null || !targetResourceNode.IsValidForGathering()) 
    {
        StopMovementAndActions();
        return;
    }
​
    float distanceToResource = Vector3.Distance(transform.position, targetResourceNode.transform.position);
    if (distanceToResource <= interactionRange)
    {
        navMeshAgent.isStopped = true;
        AttemptGather();
        HideDestinationMarker();
    }
}
​
private void CheckDestinationReached()
{
    if (!isMovingToDestination || navMeshAgent.pathStatus == NavMeshPathStatus.PathInvalid)
        return;
​
    if (!navMeshAgent.pathPending)
    {
        if (navMeshAgent.remainingDistance <= navMeshAgent.stoppingDistance)
        {
            if (!navMeshAgent.hasPath || navMeshAgent.velocity.sqrMagnitude == 0f)
            {
                isMovingToDestination = false;
                HideDestinationMarker();
            }
        }
    }
}
​
    private void AttemptGather()
    {
        if (targetResourceNode is ChoppableTree && woodcuttingSkill != null)
        {
            woodcuttingSkill.SetTarget(targetResourceNode);
        }
        else if (targetResourceNode is MineableRock && miningSkill != null)
        {
            miningSkill.SetTarget(targetResourceNode);
        }
    }
​
    public void StopMovementAndActions()
    {
        if (navMeshAgent != null)
        {
            navMeshAgent.ResetPath();
        }
        
        targetResourceNode = null;
        HideDestinationMarker();
        woodcuttingSkill?.StopAction();
        miningSkill?.StopAction();
    }
​
    private void HideDestinationMarker()
    {
        if (destinationMarker != null)
            destinationMarker.SetActive(false);
        isMovingToDestination = false;
    }
​
    public void MoveToTarget(Vector3 targetPosition, bool fromContextMenu = false)
    {
        StopMovementAndActions();
        isContextMenuMove = fromContextMenu;
        MoveToPosition(targetPosition);
    }
​
    private void OnDrawGizmosSelected()
    {
        // Visualize the interaction range
        Gizmos.color = Color.yellow;
        Gizmos.DrawWireSphere(transform.position, interactionRange);
    }
​
    public bool IsGatheringInProgress()
    {
        return (woodcuttingSkill != null && woodcuttingSkill.IsPerformingAction) ||
               (miningSkill != null && miningSkill.IsPerformingAction);
    }
}
using UnityEngine;
​
[System.Serializable]
public class CombatBonuses
{
    // Attack Bonuses
    public int stabAttack;
    public int slashAttack;
    public int crushAttack;
    public int spellweavingAttack;
    public int rangeAttack;
​
    // Defense Bonuses
    public int stabDefense;
    public int slashDefense;
    public int crushDefense;
    public int spellweavingDefense;
    public int rangeDefense;
​
    // Other Combat Bonuses
    public int mightBonus;          // Previously strengthBonus
    public int rangeStrengthBonus;
    public int spellweavingDamage;
    public int divinityBonus;
​
    // Combat Properties
    public float attackSpeed = 2.4f;  // Base attack speed in seconds
    public AttackStyle attackStyle;   // The weapon's attack style
​
    public CombatBonuses()
    {
        // Initialize all values to 0
        ResetBonuses();
    }
​
    public void ResetBonuses()
    {
        stabAttack = 0;
        slashAttack = 0;
        crushAttack = 0;
        spellweavingAttack = 0;
        rangeAttack = 0;
​
        stabDefense = 0;
        slashDefense = 0;
        crushDefense = 0;
        spellweavingDefense = 0;
        rangeDefense = 0;
​
        mightBonus = 0;
        rangeStrengthBonus = 0;
        spellweavingDamage = 0;
        divinityBonus = 0;
    }
​
    // Get the attack bonus for a specific style
    public int GetAttackBonus(AttackStyle style)
    {
        return style switch
        {
            AttackStyle.Stab => stabAttack,
            AttackStyle.Slash => slashAttack,
            AttackStyle.Crush => crushAttack,
            AttackStyle.Spellweaving => spellweavingAttack,
            AttackStyle.Range => rangeAttack,
            _ => 0
        };
    }
​
    // Get the defense bonus for a specific style
    public int GetDefenseBonus(AttackStyle style)
    {
        return style switch
        {
            AttackStyle.Stab => stabDefense,
            AttackStyle.Slash => slashDefense,
            AttackStyle.Crush => crushDefense,
            AttackStyle.Spellweaving => spellweavingDefense,
            AttackStyle.Range => rangeDefense,
            _ => 0
        };
    }
}
​
// Attack styles enum
public enum AttackStyle
{
    None,
    Stab,
    Slash,
    Crush,
    Spellweaving,
    Range
}
​
// Training styles enum for combat skills
public enum CombatTrainingStyle
{
    Precision,    // Previously Attack
    Might,        // Previously Strength
    Fortitude,    // Previously Defence
    Balanced     // Trains both primary and Fortitude
}
using UnityEngine;
​
public static class CombatCalculator
{
    private const float MIN_PLAYER_HIT = 10f;
    private const float COMBAT_TRIANGLE_BONUS = 1.5f;
    private const float COMBAT_TRIANGLE_PENALTY = 0.6f;
​
    public static float CalculateAccuracy(ICombatant attacker, ICombatant defender, WeaponAttackStyle style)
    {
        float attackerRoll = CalculateAttackRoll(attacker, style);
        float defenderRoll = CalculateDefenceRoll(defender, attacker.GetCurrentCombatStyle());
        
        float triangleMultiplier = GetCombatTriangleMultiplier(
            attacker.GetCurrentCombatStyle(), 
            defender.GetCurrentCombatStyle()
        );
        
        float finalAccuracy = (attackerRoll * triangleMultiplier) / 
            (attackerRoll * triangleMultiplier + defenderRoll);
            
        return Mathf.Clamp01(finalAccuracy);
    }
​
    private static float CalculateAttackRoll(ICombatant attacker, WeaponAttackStyle style)
    {
        CombatStats stats = attacker.Stats;
        float effectiveLevel = stats.GetAttackSkillLevel(style.attackStyle);
        float equipmentBonus = stats.combatBonuses.GetAttackBonus(style.attackStyle);
        
        return effectiveLevel * (1 + equipmentBonus/100f) * style.accuracyModifier;
    }
​
    private static float CalculateDefenceRoll(ICombatant defender, AttackStyle attackStyle)
    {
        CombatStats stats = defender.Stats;
        float fortitudeLevel = stats.Fortitude;
        float defenseBonus = stats.GetDefenseBonus(attackStyle);
        
        return fortitudeLevel * (1 + defenseBonus/100f);
    }
​
    public static int CalculateDamage(ICombatant attacker, bool isPlayerAttacking)
    {
        int maxHit = attacker.Stats.CalculateMaxHit(attacker.GetCurrentCombatStyle());
        float randomFactor = Random.value;
​
        if (isPlayerAttacking)
        {
            return Mathf.Max(
                (int)MIN_PLAYER_HIT, 
                Mathf.FloorToInt(MIN_PLAYER_HIT + (maxHit - MIN_PLAYER_HIT) * randomFactor)
            );
        }
​
        return Mathf.FloorToInt(maxHit * randomFactor);
    }
​
    private static float GetCombatTriangleMultiplier(AttackStyle attackerStyle, AttackStyle defenderStyle)
    {
        if ((attackerStyle == AttackStyle.Spellweaving && defenderStyle == AttackStyle.Range) ||
            (attackerStyle == AttackStyle.Range && defenderStyle == AttackStyle.Stab) ||
            (attackerStyle == AttackStyle.Stab && defenderStyle == AttackStyle.Spellweaving))
        {
            return COMBAT_TRIANGLE_BONUS;
        }
        
        if ((attackerStyle == AttackStyle.Range && defenderStyle == AttackStyle.Spellweaving) ||
            (attackerStyle == AttackStyle.Stab && defenderStyle == AttackStyle.Range) ||
            (attackerStyle == AttackStyle.Spellweaving && defenderStyle == AttackStyle.Stab))
        {
            return COMBAT_TRIANGLE_PENALTY;
        }
        
        return 1f;
    }
}
using UnityEngine;
​
[CreateAssetMenu(fileName = "New Combat Config", menuName = "Combat/Combat Configuration")]
public class CombatConfig : ScriptableObject
{
   [System.Serializable]
   public class WeaponStyle
   {
       public string styleName;
       public AttackStyle attackStyle;
       public CombatTrainingStyle trainingStyle;
       public bool splitXPWithFortitude;
       [Range(0f, 2f)]
       public float accuracyModifier = 1f;
       [Range(0f, 2f)]
       public float damageModifier = 1f;
       [Range(1f, 10f)]
       public float experienceMultiplier = 4f;
   }
​
   [Header("Primary Combat Configuration")]
   public WeaponStyle primaryStyle;
   public float baseAttackInterval = 2.4f;
   public float weaponSpeedModifier = 1f;
​
   [Header("Combat Experience Settings")]
   public float vitalityXPMultiplier = 1.33f;
   public float vitalityXPPerDamage = 50.54f;
​
   [Header("Combat Triangle Settings")]
   public float strongAgainstMultiplier = 1.5f;
   public float weakAgainstMultiplier = 0.6f;
​
   [Header("Base Combat Settings")]
   public int minimumHit = 10;
   public float baseRegenRate = 0.01f;
   public float maxAccuracy = 0.99f;
​
   public float GetAttackInterval() => baseAttackInterval * weaponSpeedModifier;
​
   public float CalculateVitalityXP(float damageDealt, AttackStyle style)
   {
       float xpMultiplier = style switch
       {
           AttackStyle.Stab or AttackStyle.Slash or AttackStyle.Crush => 0.25f,
           AttackStyle.Range => 0.333f,
           AttackStyle.Spellweaving => 1f,
           _ => 0f
       };
​
       return damageDealt * vitalityXPPerDamage * xpMultiplier;
   }
​
   public float GetCombatTriangleMultiplier(AttackStyle attackerStyle, AttackStyle defenderStyle)
   {
       if ((attackerStyle == AttackStyle.Spellweaving && defenderStyle == AttackStyle.Range) ||
           (attackerStyle == AttackStyle.Range && defenderStyle == AttackStyle.Stab) ||
           (attackerStyle == AttackStyle.Stab && defenderStyle == AttackStyle.Spellweaving))
       {
           return strongAgainstMultiplier;
       }
       
       if ((attackerStyle == AttackStyle.Range && defenderStyle == AttackStyle.Spellweaving) ||
           (attackerStyle == AttackStyle.Stab && defenderStyle == AttackStyle.Range) ||
           (attackerStyle == AttackStyle.Spellweaving && defenderStyle == AttackStyle.Stab))
       {
           return weakAgainstMultiplier;
       }
       
       return 1f;
   }
​
   public int CalculateMaxHit(int skillLevel, int equipmentBonus, AttackStyle style)
   {
       return style switch
       {
           AttackStyle.Stab or AttackStyle.Slash or AttackStyle.Crush or AttackStyle.Range =>
               Mathf.FloorToInt(0.5f + (skillLevel * (equipmentBonus + 64)) / 640f),
           
           AttackStyle.Spellweaving =>
               Mathf.FloorToInt(10 * (1 + equipmentBonus / 100f)),
           
           _ => minimumHit
       };
   }
}
using UnityEngine;
​
[CreateAssetMenu(fileName = "New Combat Equipment", menuName = "Combat/Equipment")]
public class CombatEquipment : Item
{
    [Header("Combat Requirements")]
    public int requiredLevel = 1;
    public int requiredDivinity = 1;
​
    [Header("Combat Stats")]
    public CombatBonuses bonuses = new CombatBonuses();
​
    [Header("Equipment Properties")]
    public GameObject equipmentModel;
​
    [Header("Combat Style")]
    public AttackStyle defaultAttackStyle = AttackStyle.None;
    public CombatTrainingStyle defaultTrainingStyle = CombatTrainingStyle.Precision;
    public bool splitXPWithFortitude = false;
​
    private void OnValidate()
    {
        itemType = ItemType.Equipment;
        ValidateRequirements();
    }
​
    private void ValidateRequirements()
    {
        if (requiredLevel < 1) requiredLevel = 1;
        if (requiredDivinity < 1) requiredDivinity = 1;
    }
​
    public bool CheckRequirements(PlayerSkills skills)
    {
        if (skills == null) return false;
​
        string requiredSkill = defaultAttackStyle switch
        {
            AttackStyle.Stab or AttackStyle.Slash or AttackStyle.Crush => "Precision",
            AttackStyle.Range => "Range",
            AttackStyle.Spellweaving => "Spellweaving",
            _ => ""
        };
​
        if (!string.IsNullOrEmpty(requiredSkill))
        {
            var skill = skills.GetSkill(requiredSkill);
            if (skill == null || skill.CurrentLevel < requiredLevel)
                return false;
        }
​
        if (requiredDivinity > 1)
        {
            var divinity = skills.GetSkill("Divinity");
            if (divinity == null || divinity.CurrentLevel < requiredDivinity)
                return false;
        }
​
        return true;
    }
}
using UnityEngine;
​
public static class CombatExperience
{
    public static void AwardCombatExperience(ICombatant attacker, int damage, CombatWeaponData weapon)
    {
        if (damage <= 0) return;
        
        PlayerSkills skills = (attacker as MonoBehaviour)?.GetComponent<PlayerSkills>();
        if (skills == null) return;
​
        float baseXP = damage * weapon.experienceMultiplier;
        
        // Award combat skill XP
        switch (weapon.attackStyle)
        {
            case AttackStyle.Stab or AttackStyle.Slash:
                skills.AddExperience("Precision", weapon.splitXPWithFortitude ? baseXP * 0.5f : baseXP);
                break;
​
            case AttackStyle.Crush:
                skills.AddExperience("Might", weapon.splitXPWithFortitude ? baseXP * 0.5f : baseXP);
                break;
​
            case AttackStyle.Range:
                skills.AddExperience("Range", weapon.splitXPWithFortitude ? baseXP * 0.5f : baseXP);
                break;
​
            case AttackStyle.Spellweaving:
                skills.AddExperience("Spellweaving", weapon.splitXPWithFortitude ? baseXP * 0.5f : baseXP);
                break;
        }
​
        // Award Fortitude XP if applicable
        if (weapon.splitXPWithFortitude)
        {
            skills.AddExperience("Fortitude", baseXP * 0.5f);
        }
​
        // Calculate and award Vitality XP
        float vitalityXP = CalculateVitalityXP(damage, weapon.attackStyle);
        skills.AddExperience("Vitality", vitalityXP);
    }
​
    private static float CalculateVitalityXP(float damage, AttackStyle style)
    {
        float baseXP = damage * 50.54f;
​
        return style switch
        {
            AttackStyle.Stab or AttackStyle.Slash or AttackStyle.Crush => baseXP * 0.25f,
            AttackStyle.Range => baseXP * 0.333f,
            AttackStyle.Spellweaving => baseXP,
            _ => 0f
        };
    }
}
using UnityEngine;
using System.Collections;
​
public class CombatHandler : MonoBehaviour
{
    [Header("Combat Settings")]
    public float attackRange = 2f;
    public float rotationSpeed = 10f;
    private ICombatant attacker;
    private ICombatant target;
    private float nextAttackTime;
    private bool inCombat;
    private ClickToMove movementController;
    private Animator animator;
    private RegenerationManager regenManager;
​
    [Header("Combat Animations")]
    [SerializeField] private string attackAnimationTrigger = "PlayerAttack";
    [SerializeField] private string inCombatBoolParam = "IsInCombat";
    [SerializeField] private string weaponTypeParam = "WeaponType";
    [SerializeField] private string attackStyleParam = "AttackStyle";
    [SerializeField] private float attackAnimationDuration = 0.8f;
​
    [Header("Combat Effects")]
    public ParticleSystem hitEffect;
    public AudioClip[] hitSounds;
    public AudioClip[] missSounds;
    private AudioSource audioSource;
​
    public bool InCombat => inCombat;
    public ICombatant CurrentTarget => target;
​
    private void Start()
    {
        InitializeComponents();
        ValidateAnimator();
    }
​
    private void InitializeComponents()
    {
        attacker = GetComponent<ICombatant>();
        movementController = GetComponent<ClickToMove>();
        animator = GetComponent<Animator>();
        audioSource = gameObject.AddComponent<AudioSource>();
        regenManager = GetComponent<RegenerationManager>();
        
        if (attacker == null)
        {
            Debug.LogError("No ICombatant implementation found on GameObject!");
            enabled = false;
        }
    }
​
    private void ValidateAnimator()
    {
        if (animator != null)
        {
            bool hasAttackTrigger = false;
            bool hasInCombatBool = false;
            bool hasWeaponType = false;
            bool hasAttackStyle = false;
​
            foreach (AnimatorControllerParameter param in animator.parameters)
            {
                switch (param.name)
                {
                    case var name when name == attackAnimationTrigger:
                        hasAttackTrigger = true;
                        break;
                    case var name when name == inCombatBoolParam:
                        hasInCombatBool = true;
                        break;
                    case var name when name == weaponTypeParam:
                        hasWeaponType = true;
                        break;
                    case var name when name == attackStyleParam:
                        hasAttackStyle = true;
                        break;
                }
            }
​
            if (!hasAttackTrigger) Debug.LogError($"Missing animation parameter: {attackAnimationTrigger}");
            if (!hasInCombatBool) Debug.LogError($"Missing animation parameter: {inCombatBoolParam}");
            if (!hasWeaponType) Debug.LogError($"Missing animation parameter: {weaponTypeParam}");
            if (!hasAttackStyle) Debug.LogError($"Missing animation parameter: {attackStyleParam}");
        }
        else
        {
            Debug.LogError("No Animator component found on GameObject!");
        }
    }
​
    private void Update()
    {
        if (!inCombat || target == null) return;
​
        float distanceToTarget = Vector3.Distance(transform.position, target.transform.position);
        if (distanceToTarget > attackRange)
        {
            RequestMoveToTarget();
            return;
        }
        else if (movementController != null)
        {
            movementController.StopMovementAndActions();
        }
​
        FaceTarget();
​
        if (Time.time >= nextAttackTime)
        {
            StartCoroutine(PerformAttackSequence());
        }
    }
​
    private void UpdateAnimatorWeaponType(WeaponData weapon)
    {
        if (animator != null && weapon != null)
        {
            animator.SetInteger(weaponTypeParam, (int)weapon.weaponType);
            animator.SetInteger(attackStyleParam, (int)weapon.defaultAttackStyle);
        }
    }
​
    private void RequestMoveToTarget()
    {
        if (target == null || movementController == null) return;
        movementController.MoveToTarget(target.transform.position);
    }
​
    private void FaceTarget()
    {
        if (target == null) return;
​
        Vector3 direction = (target.transform.position - transform.position).normalized;
        Quaternion lookRotation = Quaternion.LookRotation(new Vector3(direction.x, 0, direction.z));
        transform.rotation = Quaternion.Slerp(transform.rotation, lookRotation, Time.deltaTime * rotationSpeed);
    }
​
    private IEnumerator PerformAttackSequence()
    {
        if (target == null || !target.IsAlive)
        {
            StopCombat();
            yield break;
        }
​
        // Trigger attack animation
        if (animator != null)
        {
            animator.SetTrigger(attackAnimationTrigger);
        }
​
        yield return new WaitForSeconds(attackAnimationDuration);
​
        if (target != null && target.IsAlive)
        {
            attacker.Attack(target);
        }
​
        nextAttackTime = Time.time + attacker.GetAttackSpeed();
    }
​
    public void StartCombat(ICombatant newTarget)
    {
        if (newTarget == null || !newTarget.IsAlive)
        {
            Debug.LogWarning("Attempted to start combat with invalid target");
            return;
        }
​
        target = newTarget;
        inCombat = true;
        nextAttackTime = Time.time;
​
        // Pause regeneration when entering combat
        if (regenManager != null)
        {
            regenManager.PauseRegeneration(1.0f);
        }
​
        if (animator != null)
        {
            animator.SetBool(inCombatBoolParam, true);
            
            // Update weapon type and attack style if available
            if (attacker is PlayerCombatant playerCombatant)
            {
                var equipment = FindFirstObjectByType<EquipmentManager>();
                var weapon = equipment?.GetEquippedItem(EquipmentSlot.MainHand) as WeaponData;
                if (weapon != null)
                {
                    animator.SetInteger(weaponTypeParam, (int)weapon.weaponType);
                    animator.SetInteger(attackStyleParam, (int)weapon.defaultAttackStyle);
                }
            }
        }
        
        EnhancedChatbox.Instance?.AddMessage($"Engaging in combat with {newTarget.GetDisplayName()}");
    }
​
    public void StopCombat()
    {
        target = null;
        inCombat = false;
        
        // Resume normal regeneration when leaving combat
        if (regenManager != null)
        {
            regenManager.StartRegeneration();
        }
        
        if (animator != null)
        {
            animator.ResetTrigger(attackAnimationTrigger);
            animator.SetBool(inCombatBoolParam, false);
            animator.SetInteger(weaponTypeParam, 0);
            animator.SetInteger(attackStyleParam, 0);
        }
    }
​
    public void PlayHitEffect(Vector3 position)
    {
        if (hitEffect != null)
        {
            ParticleSystem effect = Instantiate(hitEffect, position, Quaternion.identity);
            Destroy(effect.gameObject, effect.main.duration);
        }
    }
​
    public void PlayCombatSound(bool isHit)
    {
        if (audioSource == null) return;
​
        AudioClip[] clips = isHit ? hitSounds : missSounds;
        if (clips != null && clips.Length > 0)
        {
            AudioClip clip = clips[Random.Range(0, clips.Length)];
            audioSource.PlayOneShot(clip);
        }
    }
​
    #if UNITY_EDITOR
    private void OnValidate()
    {
        // Ensure animation parameter names are not empty
        if (string.IsNullOrEmpty(attackAnimationTrigger))
            attackAnimationTrigger = "PlayerAttack";
        if (string.IsNullOrEmpty(inCombatBoolParam))
            inCombatBoolParam = "IsInCombat";
        if (string.IsNullOrEmpty(weaponTypeParam))
            weaponTypeParam = "WeaponType";
        if (string.IsNullOrEmpty(attackStyleParam))
            attackStyleParam = "AttackStyle";
    }
    #endif
}
using UnityEngine;
using UnityEngine.UI;
using TMPro;
​
public class CombatPanel : MonoBehaviour
{
    [Header("Main References")]
    [SerializeField] private EquipmentManager equipmentManager;
    [SerializeField] private PlayerSkills playerSkills;
    
    [Header("Panel Elements")]
    [SerializeField] private TextMeshProUGUI combatLevelText;
    [SerializeField] private TextMeshProUGUI currentWeaponText;
    [SerializeField] private TextMeshProUGUI attackStyleText;
    
    [Header("Combat Style UI")]
    [SerializeField] private GameObject styleToggleContainer;
    [SerializeField] private Toggle precisionToggle;
    [SerializeField] private Toggle mightToggle;
    [SerializeField] private Toggle fortitudeToggle;
    
    [Header("Combat Stats Display")]
    [SerializeField] private TextMeshProUGUI attackBonusText;
    [SerializeField] private TextMeshProUGUI strengthBonusText;
    [SerializeField] private TextMeshProUGUI defenseBonusText;
​
    private WeaponData currentWeapon;
    private CombatTrainingStyle currentTrainingStyle;
​
private void Start()
{
    InitializeReferences();
    SetupEventListeners();
    
    // Register with EquipmentUI
    var equipmentUI = GetComponentInParent<EquipmentUI>();
    if (equipmentUI != null)
    {
        equipmentUI.SetCombatPanel(this);
    }
    
    UpdateUI();
}
​
    private void InitializeReferences()
    {
        if (equipmentManager == null)
            equipmentManager = EquipmentManager.Instance;
            
        if (playerSkills == null)
            playerSkills = FindFirstObjectByType<PlayerSkills>();
​
        // Initialize toggles
        SetupToggleGroup();
    }
​
    private void SetupEventListeners()
    {
        if (equipmentManager != null)
        {
            equipmentManager.OnEquipmentChanged += HandleEquipmentChanged;
        }
​
        // Setup style toggle listeners
        SetupStyleToggles();
    }
​
    private void SetupToggleGroup()
    {
        // Make sure only one toggle can be active at a time
        ToggleGroup group = styleToggleContainer.GetComponent<ToggleGroup>();
        if (group == null)
            group = styleToggleContainer.AddComponent<ToggleGroup>();
​
        precisionToggle.group = group;
        mightToggle.group = group;
        fortitudeToggle.group = group;
    }
​
    private void SetupStyleToggles()
    {
        precisionToggle.onValueChanged.AddListener((isOn) => {
            if (isOn) UpdateTrainingStyle(CombatTrainingStyle.Precision);
        });
​
        mightToggle.onValueChanged.AddListener((isOn) => {
            if (isOn) UpdateTrainingStyle(CombatTrainingStyle.Might);
        });
​
        fortitudeToggle.onValueChanged.AddListener((isOn) => {
            if (isOn) UpdateTrainingStyle(CombatTrainingStyle.Fortitude);
        });
    }
​
    private void HandleEquipmentChanged(EquipmentSlot slot, Item item)
    {
        if (slot == EquipmentSlot.MainHand)
        {
            currentWeapon = item as WeaponData;
            UpdateUI();
            UpdateAvailableStyles();
        }
    }
​
    private void UpdateTrainingStyle(CombatTrainingStyle newStyle)
    {
        currentTrainingStyle = newStyle;
        if (currentWeapon != null)
        {
            // Update the weapon's training style
            // This will need to be implemented in WeaponData
            UpdateUI();
        }
    }
​
    private void UpdateAvailableStyles()
    {
        if (currentWeapon == null)
        {
            // Disable all style toggles for unarmed
            precisionToggle.gameObject.SetActive(false);
            mightToggle.gameObject.SetActive(false);
            fortitudeToggle.gameObject.SetActive(false);
            return;
        }
​
        // Enable/disable toggles based on weapon's available styles
        bool canTrainPrecision = currentWeapon.defaultAttackStyle == AttackStyle.Stab || 
                                currentWeapon.defaultAttackStyle == AttackStyle.Slash;
        bool canTrainMight = currentWeapon.defaultAttackStyle == AttackStyle.Crush;
        bool canTrainFortitude = true; // Fortitude can always be trained
​
        precisionToggle.gameObject.SetActive(canTrainPrecision);
        mightToggle.gameObject.SetActive(canTrainMight);
        fortitudeToggle.gameObject.SetActive(canTrainFortitude);
​
        // Set default toggle based on weapon type
        if (canTrainPrecision) precisionToggle.isOn = true;
        else if (canTrainMight) mightToggle.isOn = true;
        else fortitudeToggle.isOn = true;
    }
​
    public void UpdateUI()
    {
        if (playerSkills != null)
        {
            int combatLevel = playerSkills.CalculateCombatLevel();
            combatLevelText.text = $"Combat Level: {combatLevel}";
        }
​
        if (currentWeapon != null)
        {
            currentWeaponText.text = currentWeapon.itemName;
            attackStyleText.text = $"Style: {currentWeapon.defaultAttackStyle}";
            
            // Update combat bonuses
            attackBonusText.text = $"Attack: +{currentWeapon.bonuses.GetAttackBonus(currentWeapon.defaultAttackStyle)}";
            strengthBonusText.text = $"Might: +{currentWeapon.bonuses.mightBonus}";
            defenseBonusText.text = $"Fortitude: +{currentWeapon.bonuses.GetDefenseBonus(currentWeapon.defaultAttackStyle)}";
        }
        else
        {
            currentWeaponText.text = "Unarmed";
            attackStyleText.text = "Style: Punch";
            attackBonusText.text = "Attack: +0";
            strengthBonusText.text = "Might: +0";
            defenseBonusText.text = "Fortitude: +0";
        }
    }
​
    private void OnDestroy()
    {
        if (equipmentManager != null)
        {
            equipmentManager.OnEquipmentChanged -= HandleEquipmentChanged;
        }
    }
}
using UnityEngine;
​
public enum CombatSkill
{
    Precision,
    Might,
    Fortitude,
    Range,
    Spellweaving,
    Divinity,
    RangeAndFortitude,
    SpellweavingAndFortitude
}
using UnityEngine;
using System.Collections.Generic;
​
public class CombatStats
{
   public int Vitality { get; private set; }
   public int MaxVitality { get; private set; }
   public int Precision { get; private set; }
   public int Might { get; private set; }
   public int Fortitude { get; private set; }
   public int Range { get; private set; }
   public int Spellweaving { get; private set; }
   public int Divinity { get; private set; }
​
   public CombatBonuses combatBonuses = new CombatBonuses();
​
   public bool IsAlive => Vitality > 0;
​
   public CombatStats(int vitality = 100, int precision = 1, int might = 1, 
                     int fortitude = 1, int range = 1, int spellweaving = 1, int divinity = 1)
   {
       MaxVitality = vitality;
       Vitality = vitality;
       Precision = precision;
       Might = might; 
       Fortitude = fortitude;
       Range = range;
       Spellweaving = spellweaving;
       Divinity = divinity;
   }
​
   public int CombatLevel => 
       Mathf.Min(240, (Fortitude + Vitality + (Divinity / 2) + 
       Mathf.Max(Mathf.Max(Precision + Might, Range), Spellweaving)) / 5);
​
   public int GetDefenseBonus(AttackStyle style) => combatBonuses.GetDefenseBonus(style);
​
   public int CalculateMaxHit(AttackStyle style)
   {
       return style switch
       {
           AttackStyle.Stab or AttackStyle.Slash or AttackStyle.Crush => 
               Mathf.FloorToInt(0.5f + (Might * (combatBonuses.mightBonus + 64)) / 640f),
           
           AttackStyle.Range => 
               Mathf.FloorToInt(0.5f + (Range * (combatBonuses.rangeStrengthBonus + 64)) / 640f),
           
           AttackStyle.Spellweaving => 
               Mathf.FloorToInt(10 * (1 + combatBonuses.spellweavingDamage / 100f)),
           
           _ => 0
       };
   }
​
   public float CalculateHitChance(AttackStyle style, CombatStats targetStats)
   {
       float effectiveAccuracy = GetAttackSkillLevel(style) + combatBonuses.GetAttackBonus(style);
       float effectiveFortitude = targetStats.Fortitude + targetStats.GetDefenseBonus(style);
       
       return effectiveAccuracy / (effectiveAccuracy + effectiveFortitude);
   }
​
   public int GetAttackSkillLevel(AttackStyle style)
   {
       return style switch
       {
           AttackStyle.Stab or AttackStyle.Slash or AttackStyle.Crush => Precision,
           AttackStyle.Range => Range,
           AttackStyle.Spellweaving => Spellweaving,
           _ => 1
       };
   }
​
   public float CalculateVitalityXP(float damage, AttackStyle style)
   {
       float baseXP = damage * 50.54f;
       return style switch
       {
           AttackStyle.Stab or AttackStyle.Slash or AttackStyle.Crush => baseXP * 0.25f,
           AttackStyle.Range => baseXP * 0.333f,
           AttackStyle.Spellweaving => baseXP,
           _ => 0f
       };
   }
​
   public float GetBaseRegen() => MaxVitality * 0.01f;
​
   public void ModifyVitality(int amount)
   {
       Vitality = Mathf.Clamp(Vitality + amount, 0, MaxVitality);
   }
}
using UnityEngine;
using System.Collections.Generic;
public enum CombatStyle
{
    Melee,
    Ranged,
    Magic
}
using UnityEngine;
using UnityEngine.UI;
using TMPro;
​
public class CombatUI : MonoBehaviour
{
    [Header("UI References")]
    public RectTransform combatPanel;
    public TextMeshProUGUI combatLevelText;
    public TextMeshProUGUI weaponNameText;
    public TextMeshProUGUI attackStyleText;
    public TextMeshProUGUI trainingStyleText;
​
    [Header("Training Style Controls")]
    public Button cycleTrainingButton;
    public Image trainingStyleIcon;
​
    [Header("Combat Stats")]
    public TextMeshProUGUI attackBonusText;
    public TextMeshProUGUI strengthBonusText;
    public TextMeshProUGUI defenseBonusText;
​
    private PlayerSkills playerSkills;
    private EquipmentManager equipmentManager;
    private WeaponData currentWeapon;
    private int currentTrainingStyleIndex = 0;
​
    private void Start()
    {
        InitializeReferences();
        SetupEventListeners();
        UpdateUI();
    }
​
    private void InitializeReferences()
    {
        playerSkills = FindFirstObjectByType<PlayerSkills>();
        equipmentManager = EquipmentManager.Instance;
​
        if (cycleTrainingButton != null)
        {
            cycleTrainingButton.onClick.AddListener(CycleTrainingStyle);
        }
    }
​
    private void SetupEventListeners()
    {
        if (equipmentManager != null)
        {
            equipmentManager.OnEquipmentChanged += HandleEquipmentChanged;
        }
    }
​
    private void HandleEquipmentChanged(EquipmentSlot slot, Item item)
    {
        if (slot == EquipmentSlot.MainHand)
        {
            currentWeapon = item as WeaponData;
            currentTrainingStyleIndex = 0; // Reset training style when weapon changes
            UpdateUI();
        }
    }
​
    public void UpdateUI()
    {
        if (playerSkills == null || equipmentManager == null) return;
​
        // Update combat level
        int combatLevel = playerSkills.CalculateCombatLevel();
        combatLevelText.text = $"Combat Level: {combatLevel}";
​
        // Update weapon info
        if (currentWeapon != null)
        {
            weaponNameText.text = currentWeapon.itemName;
            attackStyleText.text = $"Attack Style: {currentWeapon.defaultAttackStyle}";
            
            var currentStyle = currentWeapon.availableTrainingStyles[currentTrainingStyleIndex];
            trainingStyleText.text = $"Training: {currentStyle}";
​
            // Update combat stats
            UpdateCombatStats();
        }
        else
        {
            weaponNameText.text = "Unarmed";
            attackStyleText.text = "Attack Style: Punch";
            trainingStyleText.text = "Training: Precision";
        }
    }
​
    private void UpdateCombatStats()
    {
        if (currentWeapon == null) return;
​
        // Get total bonuses from equipment
        var bonuses = currentWeapon.bonuses;
        
        attackBonusText.text = $"Attack Bonus: +{bonuses.GetAttackBonus(currentWeapon.defaultAttackStyle)}";
        
        switch (currentWeapon.defaultAttackStyle)
        {
            case AttackStyle.Spellweaving:
                strengthBonusText.text = $"Magic Damage: +{bonuses.spellweavingDamage}%";
                break;
            case AttackStyle.Range:
                strengthBonusText.text = $"Range Strength: +{bonuses.rangeStrengthBonus}";
                break;
            default:
                strengthBonusText.text = $"Might Bonus: +{bonuses.mightBonus}";
                break;
        }
​
        defenseBonusText.text = $"Defense Bonus: +{bonuses.GetDefenseBonus(currentWeapon.defaultAttackStyle)}";
    }
​
    public void CycleTrainingStyle()
    {
        if (currentWeapon == null || currentWeapon.availableTrainingStyles.Length <= 1) return;
​
        currentTrainingStyleIndex = (currentTrainingStyleIndex + 1) % currentWeapon.availableTrainingStyles.Length;
        UpdateUI();
    }
​
    private void OnDestroy()
    {
        if (equipmentManager != null)
        {
            equipmentManager.OnEquipmentChanged -= HandleEquipmentChanged;
        }
    }
}
using UnityEngine;
using System.Collections.Generic;
​
[CreateAssetMenu(fileName = "New Weapon", menuName = "Combat/Weapon")]
public class CombatWeapon : ScriptableObject
{
    public string weaponName;
    public WeaponType weaponType;
    public AttackStyle defaultAttackStyle;  // Changed from combatStyle
    public int attackBonus;
    public int strengthBonus;
    public float attackSpeed = 2.4f;
    public int requiredLevel;
    public EquipmentSlot equipSlot = EquipmentSlot.MainHand;
​
    public float GetDPS(CombatStats stats)
    {
        float accuracy = CalculateAccuracy(stats);
        float avgDamage = CalculateAverageDamage(stats);
        return (accuracy * avgDamage) / attackSpeed;
    }
​
    private float CalculateAccuracy(CombatStats stats)
    {
        // Use new stat names
        float effectiveLevel = stats.GetAttackSkillLevel(defaultAttackStyle);
        return (effectiveLevel * (1 + attackBonus/100f));
    }
​
    private float CalculateAverageDamage(CombatStats stats)
    {
        float baseDamage = 0;
        switch (defaultAttackStyle)
        {
            case AttackStyle.Stab:
            case AttackStyle.Slash:
            case AttackStyle.Crush:
                baseDamage = stats.Might * (1 + strengthBonus/100f);
                break;
            case AttackStyle.Range:
                baseDamage = stats.Range * (1 + strengthBonus/100f);
                break;
            case AttackStyle.Spellweaving:
                baseDamage = stats.Spellweaving * (1 + strengthBonus/100f);
                break;
        }
        return baseDamage;
    }
}
using UnityEngine;
​
[CreateAssetMenu(fileName = "New Weapon", menuName = "Combat/Weapon Data")]
public class CombatWeaponData : CombatEquipment
{
    [Header("Weapon Specific")]
    public WeaponType weaponType;
    public AttackStyle attackStyle;
    public CombatTrainingStyle trainingStyle;
    public float attackSpeed = 2.4f;
    public float baseAccuracy = 1f;
    public WeaponAttackStyle[] availableAttackStyles;
​
    [Header("Experience")]
    public float experienceMultiplier = 4f;
}
using UnityEngine;
using UnityEngine.UI;
using TMPro;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
​
public class ContextMenu : MonoBehaviour
{
    public static ContextMenu Instance { get; private set; }
    
   [Header("UI References")]
    public GameObject menuPanel;
    public GameObject optionPrefab;
    public RectTransform menuContainer;
    
    [Header("Menu Settings")]
    public float minWidth = 100f;
    public float maxWidth = 300f;
    public float optionHeight = 25f;
    public float horizontalPadding = 20f;
    public float verticalPadding = 10f;
    public float verticalSpacing = 2f;
​
    [Header("Visual Settings")]
    public Color defaultTextColor = Color.white;
    public Color hoverTextColor = Color.grey;
    public int canvasSortingOrder = 31074;
​
    private List<GameObject> currentOptions = new List<GameObject>();
    private RectTransform panelRect;
    private Canvas menuCanvas;
    private float showTime;
    private bool IsVisible => menuPanel != null && menuPanel.activeSelf;
public Vector2 CurrentPosition => panelRect != null ? panelRect.position : Vector2.zero;
public int CurrentSortingOrder => menuCanvas != null ? menuCanvas.sortingOrder : 0;
​
    private void Awake()
    {
        if (Instance == null)
        {
            Instance = this;
            DontDestroyOnLoad(gameObject);
            InitializeCanvas();
        }
        else
        {
            Destroy(gameObject);
        }
    }
private void Update()
{
    if (menuPanel.activeSelf && Input.GetMouseButtonDown(0))
    {
        if (!IsClickingMenuItem())
        {
            HideMenu();
        }
    }
}
private void InitializeCanvas()
{
    menuCanvas = GetComponent<Canvas>();
    if (menuCanvas == null)
    {
        menuCanvas = gameObject.AddComponent<Canvas>();
    }
    
    // Ensure GraphicRaycaster exists and is enabled
    var raycaster = GetComponent<GraphicRaycaster>();
    if (raycaster == null)
    {
        raycaster = gameObject.AddComponent<GraphicRaycaster>();
    }
    raycaster.enabled = true;
​
    menuCanvas.renderMode = RenderMode.ScreenSpaceOverlay;
    menuCanvas.sortingOrder = 31074; // Set higher than current UI (-31073)
    menuCanvas.overrideSorting = true; // Make sure this is true
    
    panelRect = menuPanel.GetComponent<RectTransform>();
    
    // Add BlockRaycasts component to prevent click-through
    var blocker = menuPanel.GetComponent<CanvasGroup>();
    if (blocker == null)
    {
        blocker = menuPanel.AddComponent<CanvasGroup>();
    }
    blocker.blocksRaycasts = true;
    blocker.interactable = true;
    blocker.alpha = 1;
​
    menuPanel.SetActive(false);
​
    Debug.Log($"Context Menu initialized - Canvas Sort Order: {menuCanvas.sortingOrder}");
}
​
    public void ShowMenu(Vector2 screenPosition, List<ContextMenuOption> options)
    {
        if (menuPanel == null)
        {
            Debug.LogError("Menu Panel is not assigned!");
            return;
        }
​
        Debug.Log($"ShowMenu called with {options.Count} options at {screenPosition}");
        
        showTime = Time.time;
        ClearOptions();
​
        // Ensure proper sorting order and canvas setup
        if (menuCanvas != null)
        {
            menuCanvas.overrideSorting = true;
            menuCanvas.sortingOrder = canvasSortingOrder;
            Debug.Log($"Set canvas sorting order to {menuCanvas.sortingOrder}");
        }
​
        // Calculate maximum text width first
        float maxTextWidth = 0;
        foreach (var option in options)
        {
            GameObject optionObj = CreateOptionObject(option);
            
            // Calculate width needed for this option
            TMP_Text text = optionObj.GetComponentInChildren<TMP_Text>();
            if (text != null)
            {
                // Force text layout update
                text.ForceMeshUpdate();
                float textWidth = text.preferredWidth;
                maxTextWidth = Mathf.Max(maxTextWidth, textWidth);
            }
        }
​
        // Calculate final menu width (constrained between minWidth and maxWidth)
        float totalWidth = Mathf.Clamp(maxTextWidth + (horizontalPadding * 2), minWidth, maxWidth);
        float menuHeight = optionHeight * options.Count + (verticalSpacing * (options.Count - 1));
​
        // Update menu container size
        if (menuContainer != null)
        {
            menuContainer.sizeDelta = new Vector2(totalWidth, menuHeight);
        }
​
        // Update all option widths to match menu width
        for (int i = 0; i < currentOptions.Count; i++)
        {
            RectTransform rect = currentOptions[i].GetComponent<RectTransform>();
            if (rect != null)
            {
                rect.sizeDelta = new Vector2(totalWidth - (horizontalPadding * 2), optionHeight);
                rect.anchoredPosition = new Vector2(0, -i * (optionHeight + verticalSpacing));
            }
​
            // Update text component alignment and margins
            TMP_Text text = currentOptions[i].GetComponentInChildren<TMP_Text>();
            if (text != null)
            {
                text.margin = new Vector4(horizontalPadding, 0, horizontalPadding, 0);
                text.alignment = TextAlignmentOptions.Left;
            }
        }
​
        // Calculate screen bounds-aware position
        Vector2 adjustedPosition = screenPosition;
        Vector2 screenSize = new Vector2(Screen.width, Screen.height);
        
        // Adjust for right edge
        if (adjustedPosition.x + totalWidth > screenSize.x)
            adjustedPosition.x = screenSize.x - totalWidth;
        
        // Adjust for left edge
        if (adjustedPosition.x < 0)
            adjustedPosition.x = 0;
        
        // Adjust for bottom edge
        if (adjustedPosition.y + menuHeight > screenSize.y)
            adjustedPosition.y = screenSize.y - menuHeight;
        
        // Adjust for top edge
        if (adjustedPosition.y < 0)
            adjustedPosition.y = 0;
​
        // Set menu position and size
        panelRect.position = adjustedPosition;
        panelRect.sizeDelta = new Vector2(totalWidth, menuHeight);
        
        // Ensure proper hierarchy
        menuPanel.transform.SetAsLastSibling();
        
        // Show the menu
        menuPanel.SetActive(true);
​
        // Validate final position
        StartCoroutine(ValidateMenuPosition());
​
        Debug.Log($"Menu shown at {adjustedPosition}, Size: {totalWidth}x{menuHeight}");
    }
private IEnumerator ValidateMenuPosition()
{
    // Wait one frame for layout to update
    yield return null;
​
    // Get screen bounds of menu
    Vector3[] corners = new Vector3[4];
    panelRect.GetWorldCorners(corners);
    
    bool isPartiallyOffscreen = false;
    foreach (Vector3 corner in corners)
    {
        Vector2 screenPoint = RectTransformUtility.WorldToScreenPoint(null, corner);
        if (screenPoint.x < 0 || screenPoint.x > Screen.width ||
            screenPoint.y < 0 || screenPoint.y > Screen.height)
        {
            isPartiallyOffscreen = true;
            Debug.LogWarning($"Menu is partially offscreen at position {panelRect.position}");
            break;
        }
    }
​
    // Log final position validation
    if (!isPartiallyOffscreen)
    {
        Debug.Log("Menu position validated - fully on screen");
    }
}
​
    private void ValidateTransform()
{
    RectTransform rect = GetComponent<RectTransform>();
    if (rect.localPosition.z != 0)
    {
        Debug.LogWarning("ContextMenu Z position is not 0, this might cause layering issues");
        rect.localPosition = new Vector3(rect.localPosition.x, rect.localPosition.y, 0);
    }
}
private void ValidateEventSystem()
{
    var raycaster = GetComponentInParent<GraphicRaycaster>();
    if (raycaster == null || !raycaster.enabled)
    {
        Debug.LogError("GraphicRaycaster missing or disabled in ContextMenu hierarchy");
    }
}
public void ForceToFront()
{
    Canvas canvas = GetComponentInParent<Canvas>();
    if (canvas != null)
    {
        // Find highest sorting order in scene
        int highestOrder = FindObjectsByType<Canvas>(FindObjectsSortMode.None)
            .Max(c => c.sortingOrder);
        
        // Set our order higher
        canvas.sortingOrder = highestOrder + 1;
        Debug.Log($"Force context menu to front: {canvas.sortingOrder}");
    }
}
​
    private GameObject CreateOptionObject(ContextMenuOption option)
    {
        GameObject optionObj = Instantiate(optionPrefab, menuContainer);
        currentOptions.Add(optionObj);
​
        RectTransform rect = optionObj.GetComponent<RectTransform>();
        rect.localScale = Vector3.one;
​
        Button button = optionObj.GetComponent<Button>();
        TMP_Text text = optionObj.GetComponentInChildren<TMP_Text>();
        
        if (text != null)
        {
            text.text = option.Text;
            text.color = defaultTextColor;
            
            // Set text style
            text.textWrappingMode = TextWrappingModes.NoWrap;
            text.overflowMode = TextOverflowModes.Ellipsis;
            text.margin = new Vector4(horizontalPadding, 0, horizontalPadding, 0);
            text.alignment = TextAlignmentOptions.Left;
        }
​
        if (button != null)
        {
            button.onClick.RemoveAllListeners();
            button.onClick.AddListener(() => {
                HideMenu();
                option.Action?.Invoke();
            });
​
            // Optional: Add hover color change
            var colors = button.colors;
            colors.normalColor = Color.clear;
            colors.highlightedColor = new Color(1, 1, 1, 0.1f);
            button.colors = colors;
        }
​
        return optionObj;
    }
​
    private void ClearOptions()
    {
        foreach (var option in currentOptions)
        {
            Destroy(option);
        }
        currentOptions.Clear();
    }
​
​
private Vector2 ClampMenuPosition(Vector2 position, int optionCount)
{
    Vector2 screenSize = new Vector2(Screen.width, Screen.height);
    float totalWidth = menuContainer.sizeDelta.x; // Use the current menu width
    float menuHeight = optionHeight * optionCount;
​
    position.x = Mathf.Clamp(position.x, 0, screenSize.x - totalWidth);
    
    if (position.y - menuHeight < 0)
    {
        position.y += menuHeight;
    }
    
    if (position.y > screenSize.y)
    {
        position.y = screenSize.y;
    }
​
    return position;
}
​
    public void HideMenu()
    {
        if (Time.time - showTime < 0.1f) return;
        ClearOptions();
        menuPanel.SetActive(false);
    }
​
public bool IsClickingMenuItem()
{
    if (!menuPanel.activeSelf) return false;
    
    return RectTransformUtility.RectangleContainsScreenPoint(
        panelRect,
        Input.mousePosition,
        null
    );
}
    #if UNITY_EDITOR
void OnDrawGizmos()
{
    if (!menuPanel || !menuPanel.activeSelf) return;
    
    // Draw bounds
    RectTransform rect = menuPanel.GetComponent<RectTransform>();
    Vector3[] corners = new Vector3[4];
    rect.GetWorldCorners(corners);
    
    Gizmos.color = Color.yellow;
    for (int i = 0; i < 4; i++)
        Gizmos.DrawLine(corners[i], corners[(i + 1) % 4]);
        
    // Draw sorting order text
    UnityEditor.Handles.Label(corners[0], 
        $"Sort Order: {menuCanvas.sortingOrder}");
}
#endif
}
// ContextMenuOption.cs
public class ContextMenuOption
{
    public string Text { get; set; }
    public System.Action Action { get; set; }
​
    public ContextMenuOption(string text, System.Action action)
    {
        Text = text;
        Action = action;
    }
}
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.EventSystems;
using TMPro;
​
public class ContextMenuValidator : MonoBehaviour
{
    public void ValidateSetup()
    {
        var contextMenu = GetComponent<ContextMenu>();
        if (contextMenu == null)
        {
            Debug.LogError("Missing ContextMenu component!");
            return;
        }
​
        var canvas = GetComponent<Canvas>();
        if (canvas == null)
        {
            Debug.LogError("Missing Canvas component!");
            return;
        }
​
        if (canvas.renderMode != RenderMode.ScreenSpaceOverlay)
        {
            Debug.LogWarning($"Canvas render mode is {canvas.renderMode}, should be ScreenSpaceOverlay");
        }
​
        if (canvas.sortingOrder < 100)
        {
            Debug.LogWarning($"Canvas sorting order is {canvas.sortingOrder}, should be at least 100");
        }
​
        var raycaster = GetComponent<GraphicRaycaster>();
        if (raycaster == null)
        {
            Debug.LogError("Missing GraphicRaycaster component!");
        }
​
        if (contextMenu.menuPanel == null)
        {
            Debug.LogError("MenuPanel reference is missing!");
        }
        else
        {
            var panelCanvas = contextMenu.menuPanel.GetComponent<CanvasGroup>();
            if (panelCanvas == null)
            {
                Debug.LogWarning("MenuPanel should have a CanvasGroup component for proper interaction");
            }
        }
​
        if (contextMenu.optionPrefab == null)
        {
            Debug.LogError("Option prefab reference is missing!");
        }
        else
        {
            ValidateOptionPrefab(contextMenu.optionPrefab);
        }
​
        // Check EventSystem
        var eventSystem = FindFirstObjectByType<EventSystem>();
        if (eventSystem == null)
        {
            Debug.LogError("No EventSystem found in scene!");
        }
    }
​
    private void ValidateOptionPrefab(GameObject prefab)
    {
        var button = prefab.GetComponent<Button>();
        if (button == null)
        {
            Debug.LogError("Option prefab missing Button component!");
        }
​
        var text = prefab.GetComponentInChildren<TMP_Text>();
        if (text == null)
        {
            Debug.LogError("Option prefab missing TMP_Text component!");
        }
    }
}
using UnityEngine;
​
public class CursorManager : MonoBehaviour
{
    public static CursorManager Instance { get; private set; }
​
    [Header("Cursor Textures")]
    public Texture2D defaultCursor;
    public Texture2D interactiveCursor;
    public Texture2D combatCursor;
    public Texture2D harvestCursor;
​
    private void Awake()
    {
        if (Instance == null)
        {
            Instance = this;
            DontDestroyOnLoad(gameObject);
        }
        else
        {
            Destroy(gameObject);
        }
    }
​
    private void Start()
    {
        // Set default cursor
        SetDefaultCursor();
    }
​
    public void SetDefaultCursor()
    {
        Cursor.SetCursor(defaultCursor, Vector2.zero, CursorMode.Auto);
    }
}
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.EventSystems;
​
public class DragDropHandler : MonoBehaviour, IBeginDragHandler, IDragHandler, IEndDragHandler
{
    private RectTransform draggedIcon;
    private Canvas canvas;
    private CanvasGroup canvasGroup;
    private Vector2 originalPosition;
    private Transform originalParent;
    private int originalSlotIndex;
    private InventoryUI inventoryUI;
    private InventorySlotUI originalSlot;
    private GameObject draggedItemGO;
​
    private void Start()
    {
        // Get references
        canvas = GetComponentInParent<Canvas>();
        if (canvas == null)
            canvas = FindFirstObjectByType<Canvas>();
            
        inventoryUI = FindFirstObjectByType<InventoryUI>();
        originalSlot = GetComponentInParent<InventorySlotUI>();
    }
​
    public void OnBeginDrag(PointerEventData eventData)
    {
        if (originalSlot == null || originalSlot.itemIcon == null || !originalSlot.itemIcon.enabled)
            return;
​
        // Create a temporary icon for dragging
        draggedItemGO = new GameObject("DraggedItem");
        draggedIcon = draggedItemGO.AddComponent<RectTransform>();
        var image = draggedItemGO.AddComponent<Image>();
        
        // Copy the item icon properties
        image.sprite = originalSlot.itemIcon.sprite;
        image.raycastTarget = false;
        draggedIcon.sizeDelta = originalSlot.itemIcon.rectTransform.sizeDelta;
        
        // Set up the dragged icon
        draggedItemGO.transform.SetParent(canvas.transform);
        draggedItemGO.transform.SetAsLastSibling();
        
        // Store original values
        originalSlotIndex = originalSlot.slotIndex;
        
        // Make the original icon semi-transparent
        originalSlot.itemIcon.color = new Color(1, 1, 1, 0.5f);
​
        Debug.Log($"Started dragging item from slot {originalSlotIndex}");
    }
​
    public void OnDrag(PointerEventData eventData)
    {
        if (draggedIcon != null)
        {
            if (RectTransformUtility.ScreenPointToLocalPointInRectangle(
                canvas.GetComponent<RectTransform>(),
                eventData.position,
                eventData.pressEventCamera,
                out Vector2 localPoint))
            {
                draggedIcon.localPosition = localPoint;
            }
        }
    }
​
    public void OnEndDrag(PointerEventData eventData)
    {
        if (draggedItemGO != null)
        {
            Destroy(draggedItemGO);
        }
​
        // Restore original icon opacity
        if (originalSlot != null && originalSlot.itemIcon != null)
        {
            originalSlot.itemIcon.color = Color.white;
        }
​
        // Get the target slot
        InventorySlotUI targetSlot = null;
        if (eventData.pointerEnter != null)
        {
            targetSlot = eventData.pointerEnter.GetComponent<InventorySlotUI>();
            if (targetSlot == null)
            {
                targetSlot = eventData.pointerEnter.GetComponentInParent<InventorySlotUI>();
            }
        }
​
        if (targetSlot != null && originalSlotIndex >= 0 && targetSlot.slotIndex != originalSlotIndex)
        {
            Debug.Log($"Swapping items between slots {originalSlotIndex} and {targetSlot.slotIndex}");
            inventoryUI.SwapItems(originalSlotIndex, targetSlot.slotIndex);
        }
        else
        {
            Debug.Log($"No valid target slot found or same slot");
        }
    }
}
using UnityEngine;
​
public class DroppedItem : MonoBehaviour 
{
    public Item item { get; private set; }
    public int quantity { get; private set; }
    private float despawnTime;
    private MeshRenderer meshRenderer;
​
    public void Initialize(Item _item, int _quantity, float lifetime)
    {
        item = _item;
        quantity = _quantity;
        despawnTime = Time.time + lifetime;
        SetupVisuals();
        SetupCollider();
    }
​
private void SetupVisuals()
{
    // Create a simple cube to represent the item
    GameObject visual = GameObject.CreatePrimitive(PrimitiveType.Cube);
    visual.transform.SetParent(transform);
    visual.transform.localPosition = Vector3.zero;
    visual.transform.localScale = new Vector3(0.5f, 0.5f, 0.5f);
​
    meshRenderer = visual.GetComponent<MeshRenderer>();
    if (meshRenderer && item.itemIcon)
    {
        Material mat = new Material(Shader.Find("Standard"));
        mat.mainTexture = item.itemIcon.texture;
        meshRenderer.material = mat;
    }
}
private void SpawnDroppedItem(Vector3 position)
{
    GameObject player = GameObject.FindGameObjectWithTag("Player");
    if (player != null)
    {
        // Calculate position in front of player
        Vector3 dropPos = player.transform.position + 
            (player.transform.forward * 1f) + // 1 unit in front
            Vector3.up * 0.1f; // Slight elevation to prevent ground clipping
​
        GameObject droppedObj = new GameObject($"Dropped_{item.itemName}");
        droppedObj.transform.position = dropPos;
        
        var itemComponent = droppedObj.AddComponent<DroppedItem>();
        itemComponent.Initialize(item, 1, 180f);
​
        Debug.Log($"Spawned dropped item: {item.itemName} at {dropPos}");
    }
}
​
    private void SetupCollider()
    {
        BoxCollider col = gameObject.AddComponent<BoxCollider>();
        col.isTrigger = true;
        col.size = new Vector3(1f, 1f, 1f);
​
        Rigidbody rb = gameObject.AddComponent<Rigidbody>();
        rb.isKinematic = true;
    }
​
    private void OnTriggerEnter(Collider other)
    {
        if (other.CompareTag("Player"))
        {
            if (Inventory.Instance.AddItem(item, quantity))
            {
                EnhancedChatbox.Instance?.AddMessage($"Picked up: {item.itemName}");
                Destroy(gameObject);
            }
            else
            {
                EnhancedChatbox.Instance?.AddMessage("Inventory is full!");
            }
        }
    }
​
    private void Update()
    {
        if (Time.time >= despawnTime)
        {
            Destroy(gameObject);
        }
    }
}
using UnityEngine;
using TMPro;
using System.Collections.Generic;
​
public class EnhancedChatbox : MonoBehaviour
{
    public static EnhancedChatbox Instance { get; private set; }
​
    [System.Serializable]
    public class MessageStyle
    {
        public string prefix = "";
        public Color textColor = Color.white;
        public float displayDuration = 5f;
        public bool isBold = false;
        public bool isPermanent = false;
    }
​
    [Header("UI References")]
    public TMP_Text chatText;
    public int maxMessages = 20;
​
    [Header("Message Styles")]
    public MessageStyle defaultStyle;
    public MessageStyle levelUpStyle;
    public MessageStyle systemStyle;
​
    private Queue<ChatMessage> messageQueue = new Queue<ChatMessage>();
​
    private class ChatMessage
    {
        public string text;
        public MessageType type;
        public float timestamp;
        public bool isPermanent;
​
        public ChatMessage(string text, MessageType type, bool isPermanent = false)
        {
            this.text = text;
            this.type = type;
            this.timestamp = Time.time;
            this.isPermanent = isPermanent;
        }
    }
​
    public enum MessageType
    {
        Default,
        LevelUp,
        System
    }
​
    private void Awake()
    {
        if (Instance == null)
        {
            Instance = this;
        }
        else
        {
            Destroy(gameObject);
        }
    }
​
    private void Start()
    {
        AddMessage("Welcome to RVAMP!", MessageType.System, true);
    }
​
    public void AddMessage(string message, MessageType type = MessageType.Default, bool isPermanent = false)
    {
        if (messageQueue.Count >= maxMessages)
        {
            RemoveOldestNonPermanentMessage();
        }
​
        messageQueue.Enqueue(new ChatMessage(message, type, isPermanent));
        UpdateChatDisplay();
    }
​
    private void RemoveOldestNonPermanentMessage()
    {
        var tempQueue = new Queue<ChatMessage>();
        bool removed = false;
​
        while (messageQueue.Count > 0)
        {
            var message = messageQueue.Dequeue();
            if (!message.isPermanent && !removed)
            {
                removed = true;
                continue;
            }
            tempQueue.Enqueue(message);
        }
​
        messageQueue = tempQueue;
    }
​
    private void UpdateChatDisplay()
    {
        System.Text.StringBuilder sb = new System.Text.StringBuilder();
        foreach (var message in messageQueue)
        {
            string formattedMessage = FormatMessage(message);
            sb.AppendLine(formattedMessage);
        }
        chatText.text = sb.ToString();
    }
​
    private string FormatMessage(ChatMessage message)
    {
        MessageStyle style = GetStyleForType(message.type);
        string formattedText = message.text;
​
        if (style.isBold)
        {
            formattedText = $"<b>{formattedText}</b>";
        }
​
        if (!string.IsNullOrEmpty(style.prefix))
        {
            formattedText = $"{style.prefix}{formattedText}";
        }
​
        return $"<color=#{ColorUtility.ToHtmlStringRGB(style.textColor)}>{formattedText}</color>";
    }
​
    private MessageStyle GetStyleForType(MessageType type)
    {
        return type switch
        {
            MessageType.LevelUp => levelUpStyle,
            MessageType.System => systemStyle,
            _ => defaultStyle
        };
    }
}
using UnityEngine;
using System.Collections.Generic;
using System.Linq;
using System.Collections;
​
public class EquipmentManager : MonoBehaviour
{
    public static EquipmentManager Instance { get; private set; }
    
    [Header("Equipment Setup")]
    public Transform equipmentContainer;
    
    [Header("Mount Points")]
    public Transform rightHandMount;    // MainHand items
    public Transform leftHandMount;     // OffHand items
    public Transform backMount;         // Back items
    public Transform headMount;         // Head items
    public Transform chestMount;        // Body armor
    public Transform legsMount;         // Leg armor
    public Transform glovesMount;       // Glove items
    public Transform bootsMount;        // Boot items
    public Transform quiverMount;       // Quiver items
​
    [Header("Equipment Offsets")]
    [SerializeField] private Vector3 mainHandPositionOffset = Vector3.zero;
    [SerializeField] private Vector3 mainHandRotationOffset = new Vector3(0, 90, 0);
    [SerializeField] private Vector3 mainHandScale = Vector3.one;
    
    [SerializeField] private Vector3 offHandPositionOffset = Vector3.zero;
    [SerializeField] private Vector3 offHandRotationOffset = new Vector3(0, 90, 0);
    [SerializeField] private Vector3 offHandScale = Vector3.one;
​
    [SerializeField] private Vector3 backPositionOffset = Vector3.zero;
    [SerializeField] private Vector3 backRotationOffset = Vector3.zero;
    [SerializeField] private Vector3 backScale = Vector3.one;
​
    [SerializeField] private Vector3 armorPositionOffset = Vector3.zero;
    [SerializeField] private Vector3 armorRotationOffset = Vector3.zero;
    [SerializeField] private Vector3 armorScale = Vector3.one;
​
    [Header("Animation")]
    [SerializeField] private Animator playerAnimator;
​
    private Dictionary<EquipmentSlot, Item> equippedItems = new Dictionary<EquipmentSlot, Item>();
    private Dictionary<EquipmentSlot, GameObject> equippedModels = new Dictionary<EquipmentSlot, GameObject>();
    private EquipmentUI equipmentUI;
    private Animator characterAnimator;
​
    public System.Action<EquipmentSlot, Item> OnEquipmentChanged;
​
    private void Awake()
    {
        if (Instance == null)
        {
            Instance = this;
            DontDestroyOnLoad(gameObject);
        }
        else
        {
            Destroy(gameObject);
        }
​
        InitializeSlots();
    }
​
    private void Start()
    {
        equipmentUI = FindFirstObjectByType<EquipmentUI>();
        playerAnimator = GetComponent<Animator>();
        
        if (equipmentUI == null)
            Debug.LogWarning("EquipmentUI not found in scene");
​
        ValidateMountPoints();
    }
​
    private void ValidateMountPoints()
    {
        if (rightHandMount == null) Debug.LogError("Right hand mount point is missing!");
        if (leftHandMount == null) Debug.LogError("Left hand mount point is missing!");
        if (backMount == null) Debug.LogError("Back mount point is missing!");
        // Add validation for other mount points as needed
    }
        private void ValidateEquipmentUI()
    {
        var equipmentUI = FindFirstObjectByType<EquipmentUI>();
        if (equipmentUI != null)
        {
            equipmentUI.ValidateAllSlots();
        }
    }
​
    private void InitializeSlots()
    {
        equippedItems.Clear();
        equippedModels.Clear();
        
        foreach (EquipmentSlot slot in System.Enum.GetValues(typeof(EquipmentSlot)))
        {
            if (slot != EquipmentSlot.None)
            {
                equippedItems[slot] = null;
                equippedModels[slot] = null;
            }
        }
    }
​
    private Transform GetMountPointForSlot(EquipmentSlot slot)
    {
        return slot switch
        {
            EquipmentSlot.MainHand => rightHandMount,
            EquipmentSlot.OffHand => leftHandMount,
            EquipmentSlot.Back => backMount,
            EquipmentSlot.Head => headMount,
            EquipmentSlot.Chest => chestMount,
            EquipmentSlot.Legs => legsMount,
            EquipmentSlot.Gloves => glovesMount,
            EquipmentSlot.Boots => bootsMount,
            EquipmentSlot.Quiver => quiverMount,
            _ => null
        };
    }
​
    private Vector3 GetPositionOffsetForSlot(EquipmentSlot slot)
    {
        return slot switch
        {
            EquipmentSlot.MainHand => mainHandPositionOffset,
            EquipmentSlot.OffHand => offHandPositionOffset,
            EquipmentSlot.Back => backPositionOffset,
            EquipmentSlot.Head or EquipmentSlot.Chest or EquipmentSlot.Legs 
                or EquipmentSlot.Gloves or EquipmentSlot.Boots => armorPositionOffset,
            _ => Vector3.zero
        };
    }
​
    private Vector3 GetRotationOffsetForSlot(EquipmentSlot slot)
    {
        return slot switch
        {
            EquipmentSlot.MainHand => mainHandRotationOffset,
            EquipmentSlot.OffHand => offHandRotationOffset,
            EquipmentSlot.Back => backRotationOffset,
            EquipmentSlot.Head or EquipmentSlot.Chest or EquipmentSlot.Legs 
                or EquipmentSlot.Gloves or EquipmentSlot.Boots => armorRotationOffset,
            _ => Vector3.zero
        };
    }
​
    private Vector3 GetScaleForSlot(EquipmentSlot slot)
    {
        return slot switch
        {
            EquipmentSlot.MainHand => mainHandScale,
            EquipmentSlot.OffHand => offHandScale,
            EquipmentSlot.Back => backScale,
            EquipmentSlot.Head or EquipmentSlot.Chest or EquipmentSlot.Legs 
                or EquipmentSlot.Gloves or EquipmentSlot.Boots => armorScale,
            _ => Vector3.one
        };
    }
​
    public bool EquipItem(Item item)
    {
        if (item == null || item.equipSlot == EquipmentSlot.None) return false;
​
        try
        {
            if (item is CombatEquipment combatEquip)
            {
                string requiredSkill = combatEquip.defaultAttackStyle switch
                {
                    AttackStyle.Stab or AttackStyle.Slash or AttackStyle.Crush => "Precision",
                    AttackStyle.Range => "Range",
                    AttackStyle.Spellweaving => "Spellweaving",
                    _ => ""
                };
​
                if (!string.IsNullOrEmpty(requiredSkill))
                {
                    PlayerSkills playerSkills = FindFirstObjectByType<PlayerSkills>();
                    Skill skill = playerSkills?.GetSkill(requiredSkill);
                    if (skill == null || skill.CurrentLevel < combatEquip.requiredLevel)
                    {
                        EnhancedChatbox.Instance?.AddMessage(
                            $"You need {combatEquip.requiredLevel} {requiredSkill} to equip this item.");
                        return false;
                    }
                }
            }
​
            if (equippedItems.ContainsKey(item.equipSlot) && equippedItems[item.equipSlot] != null)
            {
                UnequipItem(item.equipSlot);
            }
​
            // Handle visual equipment model
            if (item is CombatEquipment equipment && equipment.equipmentModel != null)
            {
                Transform mountPoint = GetMountPointForSlot(item.equipSlot);
                if (mountPoint != null)
                {
                    if (equippedModels.ContainsKey(item.equipSlot) && equippedModels[item.equipSlot] != null)
                    {
                        Destroy(equippedModels[item.equipSlot]);
                    }
​
                    GameObject model = Instantiate(equipment.equipmentModel, mountPoint);
                    model.transform.localPosition = GetPositionOffsetForSlot(item.equipSlot);
                    model.transform.localRotation = Quaternion.Euler(GetRotationOffsetForSlot(item.equipSlot));
                    model.transform.localScale = GetScaleForSlot(item.equipSlot);
                    
                    equippedModels[item.equipSlot] = model;
                }
            }
​
            equippedItems[item.equipSlot] = item;
            OnEquipmentChanged?.Invoke(item.equipSlot, item);
​
            if (item is WeaponData weapon && playerAnimator != null)
            {
                playerAnimator.SetInteger("WeaponType", (int)weapon.weaponType);
                playerAnimator.SetInteger("AttackStyle", (int)weapon.defaultAttackStyle);
            }
​
            if (equipmentUI != null)
            {
                equipmentUI.UpdateEquipmentSlot(item.equipSlot, item);
                StartCoroutine(ValidateUIAfterEquip(item.equipSlot));
            }
​
            return true;
        }
        catch (System.Exception e)
        {
            Debug.LogError($"Error equipping item: {e.Message}\n{e.StackTrace}");
            return false;
        }
    }
​
public Item UnequipItem(EquipmentSlot slot)
{
    if (!equippedItems.ContainsKey(slot))
        return null;
​
    Item item = equippedItems[slot];
    if (item != null)
    {
        Debug.Log($"Unequipping {item.itemName} from slot {slot}");
        
        // Store the item before clearing equipment
        Item unequippedItem = item;
        
        // Remove the visual model
        if (equippedModels.ContainsKey(slot) && equippedModels[slot] != null)
        {
            Destroy(equippedModels[slot]);
            equippedModels[slot] = null;
        }
​
        // Clear equipment slot
        equippedItems[slot] = null;
        
        // Notify of equipment change
        OnEquipmentChanged?.Invoke(slot, null);
        
        // Reset animator if it was a weapon
        if (characterAnimator != null && slot == EquipmentSlot.MainHand)
        {
            characterAnimator.SetInteger("WeaponType", 0);
            characterAnimator.SetInteger("CombatStyle", 0);
        }
​
        // Return to inventory
        if (Inventory.Instance != null)
        {
            bool added = Inventory.Instance.AddItem(unequippedItem, 1);
            if (!added)
            {
                Debug.LogWarning($"Failed to add unequipped item {unequippedItem.itemName} to inventory");
                return null;
            }
            else
            {
                Debug.Log($"Successfully returned {unequippedItem.itemName} to inventory");
            }
        }
​
        // Update UI
        if (equipmentUI != null)
        {
            equipmentUI.UpdateEquipmentSlot(slot, null);
        }
​
        return unequippedItem;
    }
    return null;
}
private IEnumerator ValidateUIAfterEquip(EquipmentSlot slot) // Uses non-generic IEnumerator
{
    // Wait for one frame to ensure all UI updates have processed
    yield return null;
    
    // Validate the specific slot
    if (equipmentUI != null)
    {
        // Force a UI refresh
        equipmentUI.UpdateEquipmentSlot(slot, equippedItems[slot]);
        
        // Optional: Validate all slots to ensure consistency
        equipmentUI.ValidateAllSlots();
    }
    
    // Log the current state
    var equippedItem = equippedItems[slot];
    Debug.Log($"Post-equip validation - Slot: {slot}, Item: {equippedItem?.itemName ?? "null"}, " +
              $"Has Icon: {equippedItem?.itemIcon != null}, UI Found: {equipmentUI != null}");
}
​
// Add this helper method to validate equipment state
public void ValidateEquipmentState()
{
    Debug.Log("=== Equipment State Validation ===");
    foreach (var kvp in equippedItems)
    {
        var slot = kvp.Key;
        var item = kvp.Value;
        Debug.Log($"Slot {slot}: {(item != null ? $"{item.itemName} (Icon: {item.itemIcon != null})" : "empty")}");
        
        if (item != null && item.itemIcon == null)
        {
            Debug.LogError($"Item {item.itemName} in slot {slot} has no icon!");
        }
    }
}
    private void UpdateAnimatorWeaponType(WeaponData weapon)
    {
        if (characterAnimator != null && weapon != null)
        {
            characterAnimator.SetInteger("WeaponType", (int)weapon.weaponType);
            characterAnimator.SetInteger("AttackStyle", (int)weapon.defaultAttackStyle);
        }
    }
​
    // Update equipment handling to use new attack styles:
public void HandleEquipmentChanged(EquipmentSlot slot, Item item)
{
    if (item is WeaponData weapon)
    {
        UpdateAnimatorWeaponType(weapon);
    }
    
    OnEquipmentChanged?.Invoke(slot, item);
}
​
private void HandleWeaponEquip(WeaponData weapon)
{
    if (characterAnimator != null)
    {
        characterAnimator.SetInteger("WeaponType", (int)weapon.weaponType);
        characterAnimator.SetInteger("AttackStyle", (int)weapon.defaultAttackStyle);
    }
}
    private void HandleWeaponChange(WeaponData weapon)
    {
        if (playerAnimator != null)
        {
            playerAnimator.SetInteger("WeaponType", (int)weapon.weaponType);
            playerAnimator.SetInteger("AttackStyle", (int)weapon.defaultAttackStyle);
        }
    }
​
    public Item GetEquippedItem(EquipmentSlot slot)
    {
        return equippedItems.TryGetValue(slot, out Item item) ? item : null;
    }
​
    public bool HasItemEquipped(ItemType itemType)
    {
        return equippedItems.Values.Any(item => item != null && item.itemType == itemType);
    }
​
    public bool HasSpecificItemEquipped(Item item)
    {
        return equippedItems.Values.Contains(item);
    }
​
    public Dictionary<EquipmentSlot, Item> GetAllEquippedItems()
    {
        return new Dictionary<EquipmentSlot, Item>(equippedItems);
    }
​
    public float GetTotalMightBonus()
    {
        return equippedItems.Values
            .Where(item => item is CombatEquipment)
            .Sum(item => ((CombatEquipment)item).bonuses.mightBonus);
    }
​
    public float GetTotalFortitudeBonus()
    {
        return equippedItems.Values
            .Where(item => item is CombatEquipment)
            .Sum(item => ((CombatEquipment)item).bonuses.GetDefenseBonus(AttackStyle.None));
    }
​
    public float GetTotalPrecisionBonus()
    {
        return equippedItems.Values
            .Where(item => item is CombatEquipment)
            .Sum(item => ((CombatEquipment)item).bonuses.GetAttackBonus(AttackStyle.Stab));
    }
​
    public void LogEquipmentPositions()
    {
        foreach (var kvp in equippedModels)
        {
            if (kvp.Value != null)
            {
                Debug.Log($"Equipment in slot {kvp.Key}: " +
                    $"Position = {kvp.Value.transform.localPosition}, " +
                    $"Rotation = {kvp.Value.transform.localRotation.eulerAngles}, " +
                    $"Scale = {kvp.Value.transform.localScale}");
            }
        }
    }
}
using UnityEngine;
​
#if UNITY_EDITOR
using UnityEditor;
​
public class EquipmentPositionAdjuster : MonoBehaviour
{
    [Header("Equipment Transform")]
    public Vector3 positionOffset;
    public Vector3 rotationOffset;
    public Vector3 scale = Vector3.one;
​
    [Header("Equipment Type")]
    public EquipmentSlot slotType = EquipmentSlot.MainHand;
​
    [Header("Adjustment Speed")]
    public float positionStep = 0.1f;
    public float rotationStep = 5f;
    public float scaleStep = 0.1f;
​
    private Transform targetEquipment;
​
    void Update()
    {
        if (targetEquipment == null)
        {
            string mountPointName = slotType switch
            {
                EquipmentSlot.MainHand => "RightHandMount",
                EquipmentSlot.OffHand => "LeftHandMount",
                EquipmentSlot.Back => "BackMount",
                _ => ""
            };
​
            if (!string.IsNullOrEmpty(mountPointName))
            {
                var mountPoint = GameObject.Find(mountPointName);
                if (mountPoint != null && mountPoint.transform.childCount > 0)
                {
                    targetEquipment = mountPoint.transform.GetChild(0);
                }
            }
        }
​
        if (targetEquipment != null)
        {
            targetEquipment.localPosition = positionOffset;
            targetEquipment.localRotation = Quaternion.Euler(rotationOffset);
            targetEquipment.localScale = scale;
        }
    }
​
    public void CopyValuesToEquipmentManager()
    {
        var equipManager = FindFirstObjectByType<EquipmentManager>();
        if (equipManager != null)
        {
            SerializedObject serializedObject = new SerializedObject(equipManager);
​
            // Determine which property to modify based on slot type
            string positionProperty = slotType switch
            {
                EquipmentSlot.MainHand => "mainHandPositionOffset",
                EquipmentSlot.OffHand => "offHandPositionOffset",
                EquipmentSlot.Back => "backPositionOffset",
                _ => ""
            };
​
            string rotationProperty = slotType switch
            {
                EquipmentSlot.MainHand => "mainHandRotationOffset",
                EquipmentSlot.OffHand => "offHandRotationOffset",
                EquipmentSlot.Back => "backRotationOffset",
                _ => ""
            };
​
            string scaleProperty = slotType switch
            {
                EquipmentSlot.MainHand => "mainHandScale",
                EquipmentSlot.OffHand => "offHandScale",
                EquipmentSlot.Back => "backScale",
                _ => ""
            };
​
            if (!string.IsNullOrEmpty(positionProperty))
            {
                var positionProp = serializedObject.FindProperty(positionProperty);
                var rotationProp = serializedObject.FindProperty(rotationProperty);
                var scaleProp = serializedObject.FindProperty(scaleProperty);
​
                if (positionProp != null) positionProp.vector3Value = positionOffset;
                if (rotationProp != null) rotationProp.vector3Value = rotationOffset;
                if (scaleProp != null) scaleProp.vector3Value = scale;
​
                serializedObject.ApplyModifiedProperties();
                Debug.Log($"Copied values to EquipmentManager for slot {slotType}");
            }
        }
    }
}
​
[CustomEditor(typeof(EquipmentPositionAdjuster))]
public class EquipmentPositionAdjusterEditor : Editor
{
    public override void OnInspectorGUI()
    {
        DrawDefaultInspector();
​
        EquipmentPositionAdjuster adjuster = (EquipmentPositionAdjuster)target;
​
        if (GUILayout.Button("Copy Values to EquipmentManager"))
        {
            adjuster.CopyValuesToEquipmentManager();
        }
​
        EditorGUILayout.HelpBox(
            "1. Select the slot type you want to adjust\n" +
            "2. Adjust values in play mode to see real-time changes\n" +
            "3. Click 'Copy Values' when satisfied to save to EquipmentManager",
            MessageType.Info);
    }
}
#endif
public enum EquipmentSlot
{
    None,
    Head,
    Necklace,
    Back,
    Chest,
    MainHand,
    OffHand,
    Ring1,
    Ring2,
    Gloves,
    Legs,
    Boots,
    Quiver
}
using UnityEngine;
using UnityEngine.UI;
using TMPro;
using UnityEngine.EventSystems;
​
// Renamed from EquipmentSlot to EquipmentSlotComponent
public class EquipmentSlotComponent : MonoBehaviour
{
    [Header("Slot Configuration")]
    public EquipmentSlot slotType;          // Uses the enum EquipmentSlot
    public string displayName;              // Name shown on the slot
    
    [Header("UI Components")]
    public Image slotBackground;
    public Image itemIcon;
    public TextMeshProUGUI slotNameText;
    public TextMeshProUGUI requirementText;
    public GameObject highlightEffect;
    public Sprite emptySlotSprite;
​
    private void Awake()
    {
        ValidateComponents();
        InitializeSlot();
    }
    public void Initialize(EquipmentSlot type, string displayName)
{
    slotType = type;
    
    if (slotNameText != null)
        slotNameText.text = displayName;
    
    if (itemIcon != null)
        itemIcon.enabled = false;
        
    if (highlightEffect != null)
        highlightEffect.SetActive(false);
        
    if (requirementText != null)
        requirementText.text = "";
}
​
    private void ValidateComponents()
    {
        // Auto-find components if not assigned
        if (slotBackground == null)
            slotBackground = GetComponent<Image>();
            
        if (itemIcon == null)
            itemIcon = transform.Find("ItemIcon")?.GetComponent<Image>();
            
        if (slotNameText == null)
            slotNameText = transform.Find("SlotName")?.GetComponent<TextMeshProUGUI>();
            
        if (requirementText == null)
            requirementText = transform.Find("RequirementText")?.GetComponent<TextMeshProUGUI>();
​
        // Add required components
        if (GetComponent<Button>() == null)
            gameObject.AddComponent<Button>();
    }
​
    private void InitializeSlot()
    {
        // Set initial state
        if (slotNameText != null)
            slotNameText.text = displayName;
​
        if (itemIcon != null)
        {
            itemIcon.enabled = false;
            itemIcon.sprite = null;
        }
​
        if (requirementText != null)
            requirementText.text = "";
​
        if (highlightEffect != null)
            highlightEffect.SetActive(false);
​
        if (slotBackground != null && emptySlotSprite != null)
            slotBackground.sprite = emptySlotSprite;
​
        Debug.Log($"Initialized equipment slot: {displayName} ({slotType})");
    }
​
public void UpdateSlot(Item item)
{
    if (item != null)
    {
        if (itemIcon != null)
        {
            itemIcon.sprite = item.itemIcon;
            itemIcon.enabled = true;
            itemIcon.color = Color.white;
        }
​
        if (requirementText != null && item is CombatEquipment combatEquip)
        {
            requirementText.text = $"Req: {combatEquip.requiredLevel} {combatEquip.defaultAttackStyle}";
            requirementText.enabled = true;
        }
    }
    else
    {
        ClearSlot();
    }
}
​
    public void ClearSlot()
    {
        Debug.Log($"Clearing slot {slotType}");
        if (itemIcon != null)
        {
            itemIcon.sprite = null;
            itemIcon.enabled = false;
        }
​
        if (requirementText != null)
        {
            requirementText.text = "";
            requirementText.enabled = false;
        }
​
        if (highlightEffect != null)
        {
            highlightEffect.SetActive(false);
        }
    }
​
    #if UNITY_EDITOR
    private void OnValidate()
    {
        // Auto-update display name if not set
        if (string.IsNullOrEmpty(displayName))
        {
            displayName = slotType.ToString();
        }
    }
    #endif
}
using UnityEngine;
using UnityEngine.UI;
using TMPro;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
​
public class EquipmentUI : MonoBehaviour
{
    [Header("Required References")]
    [SerializeField] private RectTransform slotsContainer;
    [SerializeField] private GameObject equipmentSlotPrefab;
​
    [Header("Combat Panel")]
    [SerializeField] private GameObject combatPanelPrefab;
    [SerializeField] private Transform combatPanelContainer;
​
    [Header("Equipment Stats")]
    [SerializeField] private TextMeshProUGUI attackBonusText;
    [SerializeField] private TextMeshProUGUI strengthBonusText;
    [SerializeField] private TextMeshProUGUI defenceBonusText;
    [SerializeField] private TextMeshProUGUI combatStyleText;
​
    [Header("Layout Settings")]
    [SerializeField] private float slotSpacing = 10f;
    [SerializeField] private Vector2 slotSize = new Vector2(60, 60);
​
    private Dictionary<EquipmentSlot, EquipmentSlotComponent> equipmentSlots = new Dictionary<EquipmentSlot, EquipmentSlotComponent>();
    private GridLayoutGroup gridLayout;
    private EquipmentManager equipmentManager;
    private EnhancedChatbox chatbox;
    private bool isInitialized = false;
​
    private CombatPanel combatPanel;
​
    private readonly Dictionary<EquipmentSlot, string> slotNames = new Dictionary<EquipmentSlot, string>()
    {
        { EquipmentSlot.Head, "Head" },
        { EquipmentSlot.Necklace, "Necklace" },
        { EquipmentSlot.Back, "Back" },
        { EquipmentSlot.Chest, "Chest" },
        { EquipmentSlot.MainHand, "Main Hand" },
        { EquipmentSlot.OffHand, "Off Hand" },
        { EquipmentSlot.Ring1, "Ring" },
        { EquipmentSlot.Ring2, "Specialty" },
        { EquipmentSlot.Gloves, "Hands" },
        { EquipmentSlot.Legs, "Legs" },
        { EquipmentSlot.Boots, "Feet" },
        { EquipmentSlot.Quiver, "Ammo" }
    };
​
    private void Awake()
    {
        if (slotsContainer == null)
        {
            slotsContainer = transform.Find("SlotsContainer") as RectTransform;
        }
    }
​
​
    private void OnEnable()
    {
        if (!isInitialized)
        {
            EnsureInitialized();
        }
    }
​
public void EnsureInitialized()
{
    if (isInitialized) return;
​
    if (!ValidateReferences())
    {
        Debug.LogError($"EquipmentUI on {gameObject.name}: Missing required references!");
        return;
    }
​
    InitializeImmediate();
}
private void InitializeImmediate()
{
    try
    {
        InitializeLayout();
        CreateEquipmentSlots();
        InitializeCombatPanel(); // Add this line
        
        equipmentManager = EquipmentManager.Instance;
        chatbox = EnhancedChatbox.Instance;
​
        if (equipmentManager != null)
        {
            equipmentManager.OnEquipmentChanged += HandleEquipmentChanged;
            UpdateAllSlots();
        }
​
        isInitialized = true;
        Debug.Log($"EquipmentUI initialized successfully on {gameObject.name}");
    }
    catch (System.Exception e)
    {
        Debug.LogError($"Error initializing EquipmentUI: {e.Message}\n{e.StackTrace}");
    }
}
​
private void InitializeCombatPanel()
{
    if (combatPanelPrefab != null && combatPanelContainer != null)
    {
        GameObject panelObj = Instantiate(combatPanelPrefab, combatPanelContainer);
        combatPanel = panelObj.GetComponent<CombatPanel>();
        
        if (combatPanel != null)
        {
            combatPanel.UpdateUI();
        }
        else
        {
            Debug.LogError("CombatPanel component not found on prefab!");
        }
    }
}
​
    private bool ValidateReferences()
    {
        if (slotsContainer == null)
        {
            Debug.LogError($"EquipmentUI on {gameObject.name}: SlotsContainer is null!");
            return false;
        }
​
        if (equipmentSlotPrefab == null)
        {
            Debug.LogError($"EquipmentUI on {gameObject.name}: EquipmentSlotPrefab is null!");
            return false;
        }
​
        return true;
    }
​
    private IEnumerator InitializeCoroutine()
    {
        yield return null; // Wait a frame
​
        try
        {
            InitializeLayout();
            CreateEquipmentSlots();
            
            equipmentManager = EquipmentManager.Instance;
            chatbox = EnhancedChatbox.Instance;
​
            if (equipmentManager != null)
            {
                equipmentManager.OnEquipmentChanged += HandleEquipmentChanged;
                UpdateAllSlots(); // Update initial state
            }
​
            isInitialized = true;
            Debug.Log($"EquipmentUI initialized successfully on {gameObject.name}");
        }
        catch (System.Exception e)
        {
            Debug.LogError($"Error initializing EquipmentUI: {e.Message}\n{e.StackTrace}");
        }
    }
​
    private void InitializeLayout()
    {
        if (slotsContainer == null)
        {
            throw new System.NullReferenceException("SlotsContainer is null during InitializeLayout");
        }
​
        // Remove any existing layout
        var existingLayout = slotsContainer.GetComponent<GridLayoutGroup>();
        if (existingLayout != null)
        {
            DestroyImmediate(existingLayout);
        }
​
        // Add new layout
        gridLayout = slotsContainer.gameObject.AddComponent<GridLayoutGroup>();
        gridLayout.cellSize = slotSize;
        gridLayout.spacing = new Vector2(slotSpacing, slotSpacing);
        gridLayout.constraint = GridLayoutGroup.Constraint.FixedColumnCount;
        gridLayout.constraintCount = 3;
        
        var fitter = slotsContainer.gameObject.AddComponent<ContentSizeFitter>();
        fitter.horizontalFit = ContentSizeFitter.FitMode.PreferredSize;
        fitter.verticalFit = ContentSizeFitter.FitMode.PreferredSize;
​
        if (combatPanel != null)
        {
            combatPanel.UpdateUI();
        }
    }
​
    private void CreateEquipmentSlots()
    {
        // Clear existing slots
        foreach (Transform child in slotsContainer)
        {
            Destroy(child.gameObject);
        }
        equipmentSlots.Clear();
​
        // Define slot layout
        var slotLayout = new[]
        {
            EquipmentSlot.None,
            EquipmentSlot.Head,
            EquipmentSlot.None,
            
            EquipmentSlot.Back,
            EquipmentSlot.Necklace,
            EquipmentSlot.Quiver,
            
            EquipmentSlot.MainHand,
            EquipmentSlot.Chest,
            EquipmentSlot.OffHand,
            
            EquipmentSlot.Gloves,
            EquipmentSlot.Legs,
            EquipmentSlot.Ring1,
            
            EquipmentSlot.None,
            EquipmentSlot.Boots,
            EquipmentSlot.Ring2
        };
​
        foreach (var slotType in slotLayout)
        {
            if (slotType == EquipmentSlot.None)
            {
                CreateEmptySpacer();
                continue;
            }
​
            GameObject slotObj = Instantiate(equipmentSlotPrefab, slotsContainer);
            var slotComponent = slotObj.GetComponent<EquipmentSlotComponent>();
            
            if (slotComponent != null)
            {
                string displayName = slotNames.TryGetValue(slotType, out string name) ? name : "Equipment";
                slotComponent.Initialize(slotType, displayName);
                equipmentSlots[slotType] = slotComponent;
​
                // Add click handler
                Button button = slotObj.GetComponent<Button>();
                if (button != null)
                {
                    var slotTypeCopy = slotType; // Prevent closure issues
                    button.onClick.AddListener(() => HandleSlotClick(slotTypeCopy));
                }
            }
        }
    }
​
    private void CreateEmptySpacer()
    {
        GameObject spacer = new GameObject("Spacer");
        spacer.transform.SetParent(slotsContainer, false);
        
        RectTransform rt = spacer.AddComponent<RectTransform>();
        rt.sizeDelta = slotSize;
    }
​
    private void HandleSlotClick(EquipmentSlot slot)
    {
        if (equipmentManager == null) return;
​
        var equippedItem = equipmentManager.GetEquippedItem(slot);
        if (equippedItem != null)
        {
            if (Inventory.Instance != null && !Inventory.Instance.IsFull())
            {
                // Clear UI first
                if (equipmentSlots.TryGetValue(slot, out var slotComponent))
                {
                    slotComponent.ClearSlot();
                }
                
                equipmentManager.UnequipItem(slot);
                chatbox?.AddMessage($"Unequipped {equippedItem.itemName}");
            }
            else
            {
                chatbox?.AddMessage("Not enough inventory space to unequip item.");
            }
        }
    }
​
    private void HandleEquipmentChanged(EquipmentSlot slot, Item item)
    {
        UpdateEquipmentSlot(slot, item);
        UpdateBonusDisplay();
        if (combatPanel != null)
        {
            combatPanel.UpdateUI();
        }
    }
        public void SetCombatPanel(CombatPanel panel)
    {
        combatPanel = panel;
        if (combatPanel != null)
        {
            combatPanel.UpdateUI();
        }
    }
​
    public void UpdateEquipmentSlot(EquipmentSlot slot, Item item)
    {
        Debug.Log($"UpdateEquipmentSlot called for {slot} with item: {item?.itemName ?? "null"}");
        
        if (equipmentSlots.TryGetValue(slot, out var slotComponent))
        {
            try
            {
                if (slotComponent == null)
                {
                    Debug.LogError($"Slot component is null for slot {slot}");
                    return;
                }
​
                // Update the slot's visual elements
                slotComponent.UpdateSlot(item);
                
                // Update combat panel if weapon changed
                if (slot == EquipmentSlot.MainHand && combatPanel != null)
                {
                    combatPanel.UpdateUI();
                }
                
                // Force layout refresh
                LayoutRebuilder.ForceRebuildLayoutImmediate(slotComponent.GetComponent<RectTransform>());
            }
            catch (System.Exception e)
            {
                Debug.LogError($"Error updating equipment slot {slot}: {e.Message}\n{e.StackTrace}");
            }
        }
        else
        {
            Debug.LogError($"No slot component found for equipment slot: {slot}");
        }
    }
​
    // Add this method to validate all equipment slots
    public void ValidateAllSlots()
    {
        foreach (var kvp in equipmentSlots)
        {
            var slot = kvp.Key;
            var component = kvp.Value;
            
            if (component == null)
            {
                Debug.LogError($"Null component found for slot {slot}");
                continue;
            }
​
            if (component.itemIcon == null)
            {
                Debug.LogError($"Null itemIcon reference in slot {slot}");
            }
​
            // Force update from current equipment
            var equippedItem = EquipmentManager.Instance?.GetEquippedItem(slot);
            if (equippedItem != null)
            {
                UpdateEquipmentSlot(slot, equippedItem);
            }
        }
    }
​
​
private void UpdateBonusDisplay()
{
    if (equipmentManager == null) return;
​
    int totalAttack = 0;
    int totalMight = 0;
    int totalFortitude = 0;
    AttackStyle? mainhandStyle = null;
​
    var equippedItems = equipmentManager.GetAllEquippedItems();
    foreach (var kvp in equippedItems)
    {
        if (kvp.Value is CombatEquipment combatEquip)
        {
            var bonuses = combatEquip.bonuses;
            totalAttack += bonuses.GetAttackBonus(combatEquip.defaultAttackStyle);
            totalMight += bonuses.mightBonus;
            totalFortitude += bonuses.GetDefenseBonus(combatEquip.defaultAttackStyle);
​
            if (kvp.Key == EquipmentSlot.MainHand)
            {
                mainhandStyle = combatEquip.defaultAttackStyle;
            }
        }
    }
​
    if (attackBonusText != null)
        attackBonusText.text = $"Attack: +{totalAttack}";
    
    if (strengthBonusText != null)
        strengthBonusText.text = $"Might: +{totalMight}";
    
    if (defenceBonusText != null)
        defenceBonusText.text = $"Fortitude: +{totalFortitude}";
    
    if (combatStyleText != null)
        combatStyleText.text = $"Style: {mainhandStyle?.ToString() ?? "None"}";
}
​
    private void UpdateAllSlots()
    {
        if (equipmentManager == null) return;
​
        foreach (var slot in equipmentSlots)
        {
            var item = equipmentManager.GetEquippedItem(slot.Key);
            slot.Value.UpdateSlot(item);
        }
​
        UpdateBonusDisplay();
    }
​
    private void OnDestroy()
    {
        if (equipmentManager != null)
        {
            equipmentManager.OnEquipmentChanged -= HandleEquipmentChanged;
        }
    }
​
    #if UNITY_EDITOR
    private void OnValidate()
    {
        if (!Application.isPlaying) return;
​
        if (enabled && (slotsContainer == null || equipmentSlotPrefab == null))
        {
            Debug.LogWarning("EquipmentUI: Missing required references!");
        }
    }
    #endif
}
using UnityEngine;
using System;
​
public static class ExperienceTable
{
    private static readonly double[] xpTable;
    public const int MAX_LEVEL = 300;
    public const int MAX_VIRTUAL_LEVEL = 500;
    private const double BASE_XP = 83; 
    private const double INITIAL_SCALE = 1.065; // Early level scaling (1-50)
    private const double MID_SCALE = 1.085;    // Mid level scaling (50-99)
    private const double HIGH_SCALE = 1.095;   // High level scaling (99-300)
    private const double VIRTUAL_SCALE = 1.0;  // Virtual level scaling (301-500)
    
    // Milestone levels where scaling changes
    private const int MEDIUM_MILESTONE = 50;
    private const int HIGH_MILESTONE = 99;
    private const double TARGET_MAX_XP = 1_000_000_000; // 1 billion XP target for level 300
    private const double VIRTUAL_TARGET_XP = 2_000_000_000; // 2 billion XP for virtual level 500
​
    static ExperienceTable()
    {
        xpTable = new double[MAX_VIRTUAL_LEVEL + 1];
        GenerateXPTable();
    }
​
    private static void GenerateXPTable()
    {
        xpTable[1] = 0; // Level 1 starts at 0 XP
        double xp = 0;
​
        // Early levels (1-50) - Gentle curve for new players
        for (int level = 1; level < MEDIUM_MILESTONE; level++)
        {
            xp += BASE_XP * Math.Pow(INITIAL_SCALE, level - 1);
            xpTable[level + 1] = Math.Floor(xp);
        }
​
        // Mid levels (50-99) - Steeper curve
        for (int level = MEDIUM_MILESTONE; level < HIGH_MILESTONE; level++)
        {
            double multiplier = 1.0 + (level - MEDIUM_MILESTONE) * 0.015;
            xp += BASE_XP * Math.Pow(MID_SCALE, level - 1) * multiplier;
            xpTable[level + 1] = Math.Floor(xp);
        }
​
        // High levels (99-300) - Long-term achievement curve
        double remainingLevels = MAX_LEVEL - HIGH_MILESTONE;
        double xpAt99 = xpTable[HIGH_MILESTONE];
        double remainingXP = TARGET_MAX_XP - xpAt99;
        
        for (int level = HIGH_MILESTONE; level < MAX_LEVEL; level++)
        {
            double progressionRatio = (level - HIGH_MILESTONE) / remainingLevels;
            double scaledMultiplier = Math.Pow(HIGH_SCALE, progressionRatio * 2);
            double levelXP = (remainingXP / remainingLevels) * scaledMultiplier;
            
            xp += levelXP;
            xpTable[level + 1] = Math.Floor(xp);
        }
​
        // Virtual levels (301-500)
        double virtualStartXP = TARGET_MAX_XP;
        double virtualRemainingXP = VIRTUAL_TARGET_XP - virtualStartXP;
        
        for (int level = MAX_LEVEL; level < MAX_VIRTUAL_LEVEL; level++)
        {
            xp = virtualStartXP + (virtualRemainingXP * Math.Pow((level - MAX_LEVEL) / (double)(MAX_VIRTUAL_LEVEL - MAX_LEVEL), VIRTUAL_SCALE));
            xpTable[level + 1] = Math.Floor(xp);
        }
​
        LogMilestones();
    }
​
    // Combat level calculation based on the new formula
    public static int CalculateCombatLevel(int fortitude, int vitality, int divinity, int highestCombatSkill)
    {
        double combatLevel = (fortitude + vitality + (divinity / 2.0) + highestCombatSkill) / 5.0;
        return Math.Min(240, (int)Math.Floor(combatLevel));
    }
​
    // Vitality XP calculations
    public static float CalculateVitalityXP(float damageDealt, AttackStyle style)
    {
        float baseXP = damageDealt * 50.54f;
        return style switch
        {
            AttackStyle.Stab or AttackStyle.Slash or AttackStyle.Crush => baseXP * 0.25f,
            AttackStyle.Range => baseXP * 0.333f,
            AttackStyle.Spellweaving => baseXP,
            _ => 0f
        };
    }
​
    private static void LogMilestones()
    {
        Debug.Log("=== XP Table Milestones ===");
        int[] milestones = { 2, 10, 25, 50, 75, 99, 150, 200, 250, 300, 400, 500 };
        
        foreach (int level in milestones)
        {
            if (level > MAX_VIRTUAL_LEVEL) break;
            
            double xpForLevel = xpTable[level];
            double xpForPrevious = xpTable[level - 1];
            double xpDifference = xpForLevel - xpForPrevious;
            
            Debug.Log($"Level {level,-3}: {FormatXP(xpForLevel),-10} XP " +
                     $"(+{FormatXP(xpDifference)} from previous)");
            
            if (level == 99 || level == 150 || level == 200 || level == 250 || level == 300 || level == 500)
            {
                Debug.Log($"Percentage of max XP: {(xpForLevel / VIRTUAL_TARGET_XP * 100):F2}%");
            }
        }
    }
​
    public static string FormatXP(double xp)
    {
        if (xp >= 1_000_000_000)
            return $"{xp / 1_000_000_000:N2}B";
        if (xp >= 1_000_000)
            return $"{xp / 1_000_000:N2}M";
        if (xp >= 1_000)
            return $"{xp / 1_000:N2}K";
        return $"{xp:N0}";
    }
​
    public static int GetLevel(double xp)
    {
        for (int level = 1; level < xpTable.Length; level++)
        {
            if (xp < xpTable[level]) return level - 1;
        }
        return MAX_VIRTUAL_LEVEL;
    }
​
    public static double GetXPForLevel(int level)
    {
        if (level <= 0) return 0;
        if (level > MAX_VIRTUAL_LEVEL) return xpTable[MAX_VIRTUAL_LEVEL];
        return xpTable[level];
    }
​
    public static double GetXPToNextLevel(int currentLevel, double currentXP)
    {
        if (currentLevel >= MAX_VIRTUAL_LEVEL) return 0;
        return xpTable[currentLevel + 1] - currentXP;
    }
​
    public static float GetProgressToNextLevel(double currentXP)
    {
        int currentLevel = GetLevel(currentXP);
        if (currentLevel >= MAX_VIRTUAL_LEVEL) return 1f;
​
        double levelStartXP = GetXPForLevel(currentLevel);
        double levelEndXP = GetXPForLevel(currentLevel + 1);
        return (float)((currentXP - levelStartXP) / (levelEndXP - levelStartXP));
    }
​
    public static string GetXPRateInfo(int currentLevel, double xpPerAction, double actionsPerHour)
    {
        double xpPerHour = xpPerAction * actionsPerHour;
        double xpToNextLevel = GetXPToNextLevel(currentLevel, GetXPForLevel(currentLevel));
        double hoursToNextLevel = xpToNextLevel / xpPerHour;
​
        return $"XP Rate: {FormatXP(xpPerHour)}/hr\n" +
               $"Time to level: {(hoursToNextLevel >= 1 ? $"{hoursToNextLevel:F1} hours" : $"{hoursToNextLevel * 60:F0} minutes")}";
    }
}
using UnityEngine;
​
public interface ICombatant
{
    CombatStats Stats { get; }
    bool IsAlive => Stats.Vitality > 0;
    Transform transform { get; }
    void TakeDamage(int damage, AttackStyle style);
    void Attack(ICombatant target);
    float GetAttackSpeed();
    AttackStyle GetCurrentCombatStyle();
    string GetDisplayName();
}
using UnityEngine;
​
[RequireComponent(typeof(Collider))]
public class InteractiveObject : MonoBehaviour
{
    [Header("Highlight Settings")]
    public Color hoverColor = new Color(1f, 1f, 1f, 0.3f);
    public float outlineWidth = 0.02f;
    
    private Material originalMaterial;
    private Material highlightMaterial;
    private Renderer objectRenderer;
    private bool isHovered = false;
​
    private void Start()
    {
        objectRenderer = GetComponent<Renderer>();
        if (objectRenderer != null)
        {
            // Store the original material
            originalMaterial = objectRenderer.material;
            
            // Create highlight material
            highlightMaterial = new Material(Shader.Find("Standard"));
            highlightMaterial.color = hoverColor;
        }
    }
    public void SetupInteractiveObject(GameObject obj)
{
    // Add required components
    var collider = obj.GetComponent<Collider>() ?? obj.AddComponent<BoxCollider>();
    var worldInteractable = obj.GetComponent<WorldInteractable>() ?? obj.AddComponent<WorldInteractable>();
    var interactive = obj.GetComponent<InteractiveObject>() ?? obj.AddComponent<InteractiveObject>();
​
    // Configure the components
    collider.isTrigger = true; // Optional, depends on your needs
    worldInteractable.objectName = obj.name;
    
    // Make sure there's a renderer for the highlight effect
    var renderer = obj.GetComponent<Renderer>();
    if (renderer == null)
    {
        Debug.LogWarning($"Object {obj.name} needs a Renderer for highlight effects to work");
    }
}
​
    private void OnMouseEnter()
    {
        if (objectRenderer != null && !isHovered)
        {
            // Change cursor
            Cursor.SetCursor(CursorManager.Instance.interactiveCursor, Vector2.zero, CursorMode.Auto);
            
            // Add outline effect
            Material[] materials = objectRenderer.materials;
            System.Array.Resize(ref materials, materials.Length + 1);
            materials[materials.Length - 1] = highlightMaterial;
            objectRenderer.materials = materials;
            
            isHovered = true;
        }
    }
​
    private void OnMouseExit()
    {
        if (objectRenderer != null && isHovered)
        {
            // Reset cursor
            Cursor.SetCursor(null, Vector2.zero, CursorMode.Auto);
            
            // Remove outline effect
            Material[] materials = objectRenderer.materials;
            System.Array.Resize(ref materials, materials.Length - 1);
            objectRenderer.materials = materials;
            
            isHovered = false;
        }
    }
​
    private void OnDestroy()
    {
        if (highlightMaterial != null)
        {
            Destroy(highlightMaterial);
        }
    }
}
using UnityEngine;
using System.Collections.Generic;
​
public class Inventory : MonoBehaviour
{
    public static Inventory Instance { get; private set; }
​
    private InventoryUI inventoryUI;
    public int maxSlots = 32;
    public List<InventorySlot> slots = new List<InventorySlot>();
    public event System.Action OnInventoryChanged;
​
    private void Awake()
    {
        if (Instance == null)
        {
            Instance = this;
            DontDestroyOnLoad(gameObject);
        }
        else
        {
            Destroy(gameObject);
        }
    }
​
    private void Start()
    {
        InitializeInventory();
        FindInventoryUI();
    }
private void FindInventoryUI()
{
    if (inventoryUI == null)
    {
        inventoryUI = FindFirstObjectByType<InventoryUI>();
        if (inventoryUI == null)
        {
            Debug.LogError("InventoryUI not found! Please ensure it exists in the scene.");
        }
        else
        {
            Debug.Log("Successfully found InventoryUI reference");
        }
    }
}
​
    private void InitializeInventory()
    {
        slots.Clear();
        for (int i = 0; i < maxSlots; i++)
        {
            slots.Add(new InventorySlot());
        }
    }
​
    public bool AddItem(Item item, int quantity)
    {
        if (item == null)
        {
            Debug.LogError("Attempted to add null item to inventory!");
            return false;
        }
​
        Debug.Log($"Attempting to add {quantity}x {item.itemName} to inventory");
​
        bool added = false;
        if (item.isStackable)
        {
            // Try to stack with existing items
            foreach (var slot in slots)
            {
                if (slot.Item == item && slot.Quantity < item.maxStack)
                {
                    int availableSpace = item.maxStack - slot.Quantity;
                    int addQuantity = Mathf.Min(quantity, availableSpace);
​
                    slot.AddQuantity(addQuantity);
                    quantity -= addQuantity;
                    added = true;
​
                    if (quantity <= 0)
                    {
                        NotifyInventoryChanged();
                        return true;
                    }
                }
            }
        }
    
​
        // If we still have quantity to add or item isn't stackable
        foreach (var slot in slots)
        {
            if (slot.IsEmpty)
            {
                slot.SetSlot(item, quantity);
                Debug.Log($"Added {item.itemName} to empty slot");
                NotifyInventoryChanged();
                return true;
            }
        }
​
        if (!added)
        {
            EnhancedChatbox.Instance?.AddMessage("Inventory is full!", EnhancedChatbox.MessageType.System);
        }
        return added;
    }
​
    // Add this method for manual UI refresh
public void ForceUIUpdate()
{
    Debug.Log("Forcing inventory UI update");
    if (inventoryUI == null)
    {
        inventoryUI = FindFirstObjectByType<InventoryUI>();
    }
    if (inventoryUI != null)
    {
        inventoryUI.UpdateUI();
    }
}
​
​
    public int GetItemCount(Item item)
    {
        int total = 0;
        foreach (var slot in slots)
        {
            if (slot.Item == item)
            {
                total += slot.Quantity;
            }
        }
        return total;
    }
​
    public bool HasItem(Item item, int quantity = 1)
    {
        return GetItemCount(item) >= quantity;
    }
​
    public void RemoveItem(Item item, int quantity)
    {
        int remainingToRemove = quantity;
​
        foreach (var slot in slots)
        {
            if (slot.Item == item)
            {
                if (slot.Quantity >= remainingToRemove)
                {
                    slot.AddQuantity(-remainingToRemove);
                    if (slot.Quantity <= 0)
                    {
                        slot.ClearSlot();
                    }
                    NotifyInventoryChanged();
                    return;
                }
                else
                {
                    remainingToRemove -= slot.Quantity;
                    slot.ClearSlot();
                }
            }
        }
​
        NotifyInventoryChanged();
    }
​
    public bool IsFull()
    {
        return !slots.Exists(slot => slot.IsEmpty);
    }
​
    private void NotifyInventoryChanged()
    {
        Debug.Log("Inventory changed, notifying listeners");
        OnInventoryChanged?.Invoke();
​
        if (inventoryUI == null)
        {
            FindInventoryUI();
        }
​
        if (inventoryUI != null)
        {
            Debug.Log("Updating InventoryUI after change");
            inventoryUI.UpdateUI();
        }
        else
        {
            Debug.LogError("InventoryUI still not found during notification!");
            // Try one last time to find it using a different method
            var ui = GameObject.FindObjectOfType<InventoryUI>();
            if (ui != null)
            {
                inventoryUI = ui;
                inventoryUI.UpdateUI();
                Debug.Log("Found InventoryUI using alternative method");
            }
        }
    }
​
    public Tool GetToolOfType(ToolType toolType)
    {
        foreach (var slot in slots)
        {
            if (slot.Item is Tool tool && tool.toolType == toolType)
            {
                return tool;
            }
        }
        return null;
    }
}
using UnityEngine;
using UnityEngine.EventSystems;
using System.Collections.Generic;
​
public class InventoryItemUI : MonoBehaviour, IPointerClickHandler
{
    public Item item { get; private set; }
    private InventorySlot slot;
    private Inventory inventory;
​
    public void Initialize(Item newItem, InventorySlot newSlot)
    {
        item = newItem;
        slot = newSlot;
        inventory = FindFirstObjectByType<Inventory>();
    }
​
    public void OnPointerClick(PointerEventData eventData)
    {
        if (item == null) return;
​
        if (eventData.button == PointerEventData.InputButton.Left)
        {
            HandleLeftClick();
        }
        else if (eventData.button == PointerEventData.InputButton.Right)
        {
            ShowContextMenu();
        }
    }
​
    private void HandleLeftClick()
    {
        if (item == null) return;
​
        // Handle based on item type
        if (item.CanEquip)
        {
            EquipItem();
        }
        else if (item.CanConsume)
        {
            ConsumeItem();
        }
        else if (item.itemType == ItemType.Resource)
        {
            // For resources, show examine info
            ExamineItem();
        }
        else
        {
            // Default to examine for unknown types
            ExamineItem();
        }
    }
​
    private void ShowContextMenu()
    {
        if (item == null || ContextMenu.Instance == null) return;
​
        List<ContextMenuOption> options = new List<ContextMenuOption>();
​
        // Add options based on item type
        if (item.CanEquip)
        {
            options.Add(new ContextMenuOption("Equip", EquipItem));
        }
​
        if (item.CanConsume)
        {
            options.Add(new ContextMenuOption("Use", ConsumeItem));
        }
​
        // Always add examine and drop options
        options.Add(new ContextMenuOption("Examine", ExamineItem));
        options.Add(new ContextMenuOption("Drop", DropItem));
​
        ContextMenu.Instance.ShowMenu(Input.mousePosition, options);
    }
​
    private void EquipItem()
    {
        if (item == null) return;
​
        Debug.Log($"Attempting to equip: {item.itemName}");
        bool equipped = false;
​
        try
        {
            if (item is CombatEquipment || item.CanEquip)
            {
                equipped = EquipmentManager.Instance.EquipItem(item);
            }
​
            if (equipped)
            {
                inventory.RemoveItem(item, 1);
                EnhancedChatbox.Instance?.AddMessage($"Equipped {item.itemName}");
                Debug.Log($"Successfully equipped {item.itemName}");
            }
            else
            {
                EnhancedChatbox.Instance?.AddMessage($"Cannot equip {item.itemName}");
                Debug.Log($"Failed to equip {item.itemName}");
            }
        }
        catch (System.Exception e)
        {
            Debug.LogError($"Error equipping item: {e.Message}\n{e.StackTrace}");
            EnhancedChatbox.Instance?.AddMessage("Error equipping item");
        }
    }
​
    private void ConsumeItem()
    {
        if (item == null || !item.CanConsume) return;
​
        Debug.Log($"Using item: {item.itemName}");
        inventory.RemoveItem(item, 1);
        EnhancedChatbox.Instance?.AddMessage($"You used {item.itemName}.");
    }
​
    private void ExamineItem()
    {
        if (item == null) return;
        EnhancedChatbox.Instance?.AddMessage($"It's a {item.itemName}. {item.description}");
    }
​
    private void DropItem()
    {
        if (item == null) return;
​
        GameObject player = GameObject.FindGameObjectWithTag("Player");
        if (player != null)
        {
            Vector3 dropPos = player.transform.position - player.transform.forward;
            SpawnDroppedItem(dropPos);
            inventory.RemoveItem(item, 1);
            EnhancedChatbox.Instance?.AddMessage($"You dropped {item.itemName}");
        }
    }
​
    private void SpawnDroppedItem(Vector3 position)
    {
        GameObject droppedObj = new GameObject($"Dropped_{item.itemName}");
        droppedObj.transform.position = position;
        
        var itemComponent = droppedObj.AddComponent<DroppedItem>();
        itemComponent.Initialize(item, 1, 180f); // 3 minute despawn timer
​
        Debug.Log($"Spawned dropped item: {item.itemName} at {position}");
    }
}
using UnityEngine;
​
[System.Serializable]
public class InventorySlot
{
    [SerializeField] private Item _item;
    [SerializeField] private int _quantity;
​
    public Item Item => _item;
    public int Quantity => _quantity;
​
    public bool IsEmpty => _item == null;
​
    public InventorySlot()
    {
        ClearSlot();
    }
​
    public InventorySlot(Item item, int quantity)
    {
        SetSlot(item, quantity);
    }
​
public void SetSlot(Item item, int quantity)
{
    Debug.Log($"Setting slot with item: {item?.itemName ?? "null"} x{quantity}");
    _item = item;
    _quantity = Mathf.Max(0, quantity);
​
    // If quantity is 0, clear the slot
    if (_quantity == 0)
    {
        ClearSlot();
    }
}
​
    public void ClearSlot()
    {
        _item = null;
        _quantity = 0;
    }
​
    public void AddQuantity(int amount)
    {
        _quantity = Mathf.Max(0, _quantity + amount);
        if (_quantity == 0) _item = null;
    }
​
    public bool CanAddItem(Item item, int amount)
    {
        return IsEmpty || (_item == item && _item.isStackable);
    }
}
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.EventSystems;
using TMPro;
using System.Collections.Generic;
​
public class InventorySlotUI : MonoBehaviour, IPointerClickHandler
{
    public Image itemIcon;
    public TMP_Text quantityText;
    public int slotIndex;
    
    private Item _currentItem;
    private int _currentQuantity;
    private Inventory inventoryRef;
    private EquipmentManager equipmentManager;
        public Item CurrentItem => _currentItem;
    public int CurrentQuantity => _currentQuantity;
​
    private void Start()
    {
        // Get references
        inventoryRef = Inventory.Instance;
        if (inventoryRef == null)
        {
            Debug.LogError("Inventory Instance not found!");
        }
​
        equipmentManager = EquipmentManager.Instance;
        if (equipmentManager == null)
        {
            Debug.LogError("EquipmentManager Instance not found!");
        }
    }
​
    public void OnPointerClick(PointerEventData eventData)
    {
        if (_currentItem == null) return;
​
        if (eventData.button == PointerEventData.InputButton.Left)
        {
            HandleLeftClick();
        }
        else if (eventData.button == PointerEventData.InputButton.Right)
        {
            ShowContextMenu();
            eventData.Use();
        }
    }
​
    private void HandleLeftClick()
    {
        if (_currentItem == null) return;
​
        if (_currentItem.CanEquip)
        {
            HandleEquip();
        }
        else if (_currentItem.CanConsume)
        {
            HandleConsume();
        }
    }
​
private void ShowContextMenu()
{
    if (_currentItem == null || ContextMenu.Instance == null)
    {
        Debug.LogWarning("Cannot show context menu: " + 
            (_currentItem == null ? "No item selected" : "ContextMenu not found in scene"));
        return;
    }
​
    List<ContextMenuOption> options = new List<ContextMenuOption>();
​
    if (_currentItem.CanEquip)
    {
        options.Add(new ContextMenuOption("Equip", () => HandleEquip()));
    }
​
    if (_currentItem.CanConsume)
    {
        options.Add(new ContextMenuOption("Use", () => HandleConsume()));
    }
​
    options.Add(new ContextMenuOption("Drop", () => HandleDrop()));
    options.Add(new ContextMenuOption("Examine", () => HandleExamine()));
​
    ContextMenu.Instance.ShowMenu(Input.mousePosition, options);
}
​
public void HandleEquip()
{
    if (_currentItem == null || equipmentManager == null)
    {
        Debug.LogWarning($"Cannot equip - Item: {_currentItem != null}, EquipManager: {equipmentManager != null}");
        return;
    }
​
    if (!_currentItem.CanEquip)
    {
        Debug.LogWarning($"Item {_currentItem.itemName} cannot be equipped");
        return;
    }
​
    Debug.Log($"Attempting to equip {_currentItem.itemName}");
    
    // Store item reference before removing from inventory
    Item itemToEquip = _currentItem;
    
    // Remove from inventory first
    inventoryRef.RemoveItem(_currentItem, 1);
    
    // Then equip the item
    bool equipped = equipmentManager.EquipItem(itemToEquip);
​
    if (equipped)
    {
        EnhancedChatbox.Instance?.AddMessage($"Equipped {itemToEquip.itemName}");
        ContextMenu.Instance?.HideMenu();
    }
    else
    {
        // If equipping fails, add the item back to inventory
        inventoryRef.AddItem(itemToEquip, 1);
        EnhancedChatbox.Instance?.AddMessage($"Cannot equip {itemToEquip.itemName}");
    }
}
    private void HandleConsume()
    {
        if (_currentItem == null || !_currentItem.CanConsume) return;
​
        Debug.Log($"Using {_currentItem.itemName}");
        inventoryRef.RemoveItem(_currentItem, 1);
        EnhancedChatbox.Instance?.AddMessage($"You used {_currentItem.itemName}");
    }
​
    private void HandleDrop()
    {
        if (_currentItem == null) return;
​
        GameObject player = GameObject.FindGameObjectWithTag("Player");
        if (player != null)
        {
            Vector3 dropPos = player.transform.position - player.transform.forward;
            SpawnDroppedItem(dropPos);
            inventoryRef.RemoveItem(_currentItem, 1);
            EnhancedChatbox.Instance?.AddMessage($"Dropped {_currentItem.itemName}");
        }
    }
​
    private void HandleExamine()
    {
        if (_currentItem == null) return;
        EnhancedChatbox.Instance?.AddMessage($"It's a {_currentItem.itemName}. {_currentItem.description}");
    }
​
    public void UpdateSlotUI(Item item, int quantity)
    {
        Debug.Log($"Updating slot {slotIndex} UI with item: {item?.itemName ?? "null"} x{quantity}");
        _currentItem = item;
        _currentQuantity = quantity;
​
        if (itemIcon == null)
        {
            Debug.LogError($"ItemIcon is null on slot {slotIndex}");
            return;
        }
​
        if (item != null)
        {
            if (item.itemIcon == null)
            {
                Debug.LogError($"Item {item.itemName} has no icon sprite assigned!");
                return;
            }
​
            // Set and enable the icon with full opacity
            itemIcon.sprite = item.itemIcon;
            itemIcon.enabled = true;
            itemIcon.color = Color.white;
            
            // Update quantity text
            if (quantityText != null)
            {
                quantityText.text = item.isStackable && quantity > 1 ? quantity.ToString() : "";
                quantityText.enabled = item.isStackable && quantity > 1;
            }
            
            Debug.Log($"Updated slot {slotIndex} with {item.itemName}, sprite: {(item.itemIcon != null)}, enabled: {itemIcon.enabled}");
        }
        else
        {
            // Clear the slot
            itemIcon.sprite = null;
            itemIcon.enabled = false;
            if (quantityText != null)
            {
                quantityText.text = "";
                quantityText.enabled = false;
            }
            
            Debug.Log($"Cleared slot {slotIndex}");
        }
    }
​
    private void SpawnDroppedItem(Vector3 position)
    {
        GameObject droppedObj = new GameObject($"Dropped_{_currentItem.itemName}");
        droppedObj.transform.position = position;
        
        var itemComponent = droppedObj.AddComponent<DroppedItem>();
        itemComponent.Initialize(_currentItem, 1, 180f); // 3 minute despawn
    }
}
using UnityEngine;
using System.Collections.Generic;
​
public class InventoryUI : MonoBehaviour
{
    public GameObject slotPrefab;
    public Transform slotParent;
    private Inventory inventory;
    private InventorySlotUI[] slotUIs;
​
        private void Awake()
    {
        // Ensure this component isn't destroyed when loading new scenes
        DontDestroyOnLoad(gameObject);
    }
       private void Start()
    {
        Debug.Log("InventoryUI starting initialization");
        inventory = Inventory.Instance;
        if (inventory == null)
        {
            Debug.LogError("Inventory instance not found!");
            return;
        }
        InitializeSlots();
        UpdateUI();
    }
​
    private void InitializeSlots()
    {
        // Clear existing slots
        foreach (Transform child in slotParent)
        {
            Destroy(child.gameObject);
        }
​
        slotUIs = new InventorySlotUI[inventory.slots.Count];
​
        // Create slots to match inventory capacity
        for (int i = 0; i < inventory.slots.Count; i++)
        {
            GameObject newSlot = Instantiate(slotPrefab, slotParent);
            InventorySlotUI slotUI = newSlot.GetComponent<InventorySlotUI>();
            if (slotUI != null)
            {
                slotUI.slotIndex = i;
                slotUIs[i] = slotUI;
            }
        }
    }
public void ValidateSlots()
{
    Debug.Log("Validating inventory slots...");
    foreach (var slotUI in slotUIs)
    {
        if (slotUI == null)
        {
            Debug.LogError("Found null slot UI!");
            continue;
        }
​
        if (slotUI.itemIcon == null)
        {
            Debug.LogError($"Slot {slotUI.slotIndex} has null itemIcon reference!");
            continue;
        }
​
        var currentItem = slotUI.CurrentItem;
        if (currentItem != null)
        {
            Debug.Log($"Slot {slotUI.slotIndex}: Item={currentItem.itemName}, " +
                     $"Icon Enabled={slotUI.itemIcon.enabled}, " +
                     $"Has Sprite={slotUI.itemIcon.sprite != null}");
        }
    }
}
​
    public void UpdateUI()
    {
        if (inventory == null)
        {
            Debug.LogError("Cannot update UI - Inventory reference is null!");
            inventory = Inventory.Instance;
            if (inventory == null) return;
        }
​
        Debug.Log("Updating Inventory UI");
        if (slotUIs == null || slotUIs.Length != inventory.slots.Count)
        {
            Debug.Log("Reinitializing slots due to mismatch");
            InitializeSlots();
        }
​
        foreach (var slotUI in slotUIs)
        {
            if (slotUI != null)
            {
                int index = System.Array.IndexOf(slotUIs, slotUI);
                var slot = inventory.slots[index];
                slotUI.UpdateSlotUI(slot.Item, slot.Quantity);
            }
        }
    }
​
        public void SwapItems(int slotIndexA, int slotIndexB)
    {
        if (slotIndexA == slotIndexB) return;
        if (slotIndexA < 0 || slotIndexB < 0 || 
            slotIndexA >= inventory.slots.Count || 
            slotIndexB >= inventory.slots.Count)
        {
            Debug.LogWarning("Invalid slot indices for swap operation");
            return;
        }
​
        // Swap the items in the inventory
        var tempSlot = inventory.slots[slotIndexA];
        inventory.slots[slotIndexA] = inventory.slots[slotIndexB];
        inventory.slots[slotIndexB] = tempSlot;
​
        // Update only the affected slots
        slotUIs[slotIndexA].UpdateSlotUI(inventory.slots[slotIndexA].Item, inventory.slots[slotIndexA].Quantity);
        slotUIs[slotIndexB].UpdateSlotUI(inventory.slots[slotIndexB].Item, inventory.slots[slotIndexB].Quantity);
​
        Debug.Log($"Swapped items in slots {slotIndexA} and {slotIndexB}");
    }
}
​
public interface ISkill
{
    string SkillName { get; }
    int CurrentLevel { get; }
    double CurrentXP { get; }
    void AddExperience(double xp);
    bool HasRequirement(int level);
}
using UnityEngine;
​
[CreateAssetMenu(fileName = "New Item", menuName = "Inventory/Item")]
public class Item : ScriptableObject
{
    public string itemName;
    public Sprite itemIcon;
    public ItemType itemType = ItemType.Default;
    public bool isStackable = false;
    public int maxStack = 1;
    public string description;
    public int baseValue;
    public ToolType toolType;
​
    // Equipment properties
    public EquipmentSlot equipSlot = EquipmentSlot.None;
    public int armorValue;
    public int damageValue;
​
    public bool CanEquip => itemType == ItemType.Equipment || itemType == ItemType.Tool;
    public bool CanConsume => itemType == ItemType.Consumable;
    public bool IsGatheringTool => itemType == ItemType.Tool;
}
using UnityEngine;
using System.Collections.Generic;
public class ItemDatabase : MonoBehaviour
{
    public static ItemDatabase Instance { get; private set; }
​
    [Header("Resources")]
    public List<Item> ores;
    public List<Item> logs;
    public List<Item> gems;
    public List<Item> tools;
​
    private Dictionary<string, Item> itemDictionary = new Dictionary<string, Item>();
​
    private void Awake()
    {
        if (Instance == null)
        {
            Instance = this;
            DontDestroyOnLoad(gameObject);
            InitializeDatabase();
        }
        else
        {
            Destroy(gameObject);
        }
    }
​
    private void InitializeDatabase()
    {
        AddItemsToDictionary(ores);
        AddItemsToDictionary(logs);
        AddItemsToDictionary(gems);
        AddItemsToDictionary(tools);
    }
​
    private void AddItemsToDictionary(List<Item> items)
    {
        foreach (var item in items)
        {
            if (!itemDictionary.ContainsKey(item.itemName))
            {
                itemDictionary[item.itemName] = item;
            }
        }
    }
​
    public Item GetItem(string itemName)
    {
        if (itemDictionary.TryGetValue(itemName, out Item item))
        {
            return item;
        }
        Debug.LogWarning($"Item not found in database: {itemName}");
        return null;
    }
}
using UnityEngine;
​
[RequireComponent(typeof(ItemPickup))]
public class ItemHighlight : MonoBehaviour
{
    private Material originalMaterial;
    private MeshRenderer meshRenderer;
    private ItemPickup itemPickup;
    private Color highlightColor = new Color(1f, 0.8f, 0.2f, 1f); // Golden highlight
    private Color normalColor = Color.white;
    private bool isHighlighted = false;
​
    [SerializeField] private float highlightDistance = 5f; // Distance at which the item starts highlighting
​
    void Start()
    {
        meshRenderer = GetComponent<MeshRenderer>();
        itemPickup = GetComponent<ItemPickup>();
        
        if (meshRenderer != null)
        {
            originalMaterial = new Material(meshRenderer.material); // Create a new instance of the material
            meshRenderer.material = originalMaterial; // Assign the new instance
        }
    }
​
    void Update()
    {
        if (meshRenderer != null)
        {
            if (IsPlayerNearby())
            {
                if (!isHighlighted)
                {
                    isHighlighted = true;
                }
                float pulse = (Mathf.Sin(Time.time * 4f) + 1f) * 0.5f;
                meshRenderer.material.color = Color.Lerp(normalColor, highlightColor, pulse);
            }
            else
            {
                if (isHighlighted)
                {
                    isHighlighted = false;
                    meshRenderer.material.color = normalColor;
                }
            }
        }
    }
​
    bool IsPlayerNearby()
    {
        GameObject player = GameObject.FindGameObjectWithTag("Player");
        if (player != null)
        {
            float distance = Vector3.Distance(transform.position, player.transform.position);
            return distance <= highlightDistance;
        }
        return false;
    }
​
    void OnDestroy()
    {
        if (originalMaterial != null)
        {
            Destroy(originalMaterial); // Clean up the material instance
        }
    }
}
using UnityEngine;
using UnityEngine.AI;
using System.Collections;
using System.Linq;
​
[RequireComponent(typeof(Collider))]
public class ItemPickup : MonoBehaviour
{
    public Item item;
    public int quantity = 1;
    public float pickupRange = 3f;
​
    private GameObject player;
    private Inventory playerInventory;
    private NavMeshAgent playerAgent;
    private bool isInitialized = false;
    private bool isMovingToItem = false;
    private WorldInteractable worldInteractable;
​
    private void Start()
    {
        StartCoroutine(InitializePickup());
        SetupInteraction();
    }
​
private void SetupInteraction()
{
    worldInteractable = gameObject.AddComponent<WorldInteractable>();
    worldInteractable.objectName = item.itemName;
    
    // Add pickup option with high priority
    worldInteractable.AddCustomOption($"Pick up {item.itemName}" + (quantity > 1 ? $" x{quantity}" : ""), 
        () => {
            var clickToMove = FindFirstObjectByType<ClickToMove>();
            if (clickToMove != null)
            {
                clickToMove.MoveToTarget(transform.position);
                isMovingToItem = true;
            }
        }, 
        () => item != null && !isMovingToItem,
        100);
​
    // Add examine option with item description
    worldInteractable.examineText = item.description;
}
​
    private IEnumerator InitializePickup()
    {
        while (!isInitialized)
        {
            if (FindPlayer())
            {
                isInitialized = true;
                playerAgent = player.GetComponent<NavMeshAgent>();
                yield break;
            }
            yield return new WaitForSeconds(0.5f);
        }
    }
        private bool FindPlayer()
    {
        player = GameObject.FindGameObjectWithTag("Player");
        if (player != null)
        {
            playerInventory = player.GetComponent<Inventory>();
            if (playerInventory != null)
            {
                Debug.Log("Player and Inventory found successfully.");
                return true;
            }
            else
            {
                Debug.LogWarning("Player found, but it doesn't have an Inventory component!");
                Debug.Log("Components on player: " + string.Join(", ", player.GetComponents<Component>().Select(c => c.GetType().Name)));
                
                // Try to find Inventory in children
                playerInventory = player.GetComponentInChildren<Inventory>();
                if (playerInventory != null)
                {
                    Debug.Log("Inventory found in child object.");
                    return true;
                }
            }
        }
        else
        {
            Debug.LogWarning("Player not found. Will retry.");
        }
        return false;
    }
​
    private void Update()
    {
        if (!isInitialized)
            return;
​
        if (isMovingToItem)
        {
            float distance = Vector3.Distance(transform.position, player.transform.position);
            if (distance <= pickupRange)
            {
                AttemptPickup();
                isMovingToItem = false;
            }
        }
    }
​
    private void HandleItemClick()
    {
        float distance = Vector3.Distance(transform.position, player.transform.position);
        if (distance <= pickupRange)
        {
            AttemptPickup();
        }
        else
        {
            MovePlayerToItem();
        }
    }
​
    private void MovePlayerToItem()
    {
        if (playerAgent != null)
        {
            playerAgent.SetDestination(transform.position);
            isMovingToItem = true;
            Debug.Log($"Moving to item: {item.itemName}");
        }
        else
        {
            Debug.LogWarning("Player NavMeshAgent not found. Cannot move to item.");
        }
    }
​
    private void AttemptPickup()
    {
        Debug.Log($"Attempting pickup of {item.itemName}");
        if (playerInventory != null)
        {
            if (playerInventory.AddItem(item, quantity))
            {
                EnhancedChatbox.Instance?.AddMessage($"Picked up: {item.itemName}");
                Debug.Log($"Successfully picked up {item.itemName}");
                Destroy(gameObject);
            }
            else
            {
                EnhancedChatbox.Instance?.AddMessage("Inventory is full!");
                Debug.Log($"Pickup failed: Inventory full. Item: {item.itemName}");
            }
        }
        else
        {
            Debug.LogError("PlayerInventory is still null! Reinitializing...");
            StartCoroutine(InitializePickup());
        }
    }
}
public enum ItemType
{
    Default,
    Equipment,
    Consumable,
    Resource,
    Tool
}
using UnityEngine;
​
public class LevelingSystem : MonoBehaviour
{
    public int currentLevel = 1;       // Player's current level
    public int maxLevel = 300;        // Maximum level
    public int currentXP = 0;         // Current experience points
    public int xpToNextLevel = 100;   // XP required for next level
​
    public float xpGrowthFactor = 1.2f; // Growth factor for XP required per level
​
    public delegate void OnLevelChange(int level, int currentXP, int xpToNextLevel);
    public event OnLevelChange OnLevelChangeEvent;
​
    void Start()
    {
        // Initialize with level 1
        NotifyUI();
    }
​
    public void AddExperience(int xp)
    {
        if (currentLevel >= maxLevel)
        {
            
            Debug.Log("Max level reached!");
            return;
        }
​
        currentXP += xp;
​
        while (currentXP >= xpToNextLevel && currentLevel < maxLevel)
        {
            LevelUp();
        }
​
        NotifyUI();
    }
​
    private void LevelUp()
    {
        currentXP -= xpToNextLevel;  // Carry over extra XP
        currentLevel++;              // Increase level
        xpToNextLevel = Mathf.FloorToInt(xpToNextLevel * xpGrowthFactor); // Increase XP requirement
​
        Debug.Log($"Level Up! Current Level: {currentLevel}, XP for Next Level: {xpToNextLevel}");
    }
​
    private void NotifyUI()
    {
        // Notify listeners (e.g., UIManager)
        OnLevelChangeEvent?.Invoke(currentLevel, currentXP, xpToNextLevel);
    }
}
using UnityEngine;
using System.Collections;
​
public class MineableRock : ResourceNode
{
    [Header("Mining Specific")]
    public OreType oreType;
    public int gemChance = 5; // Percentage chance to find gems
​
    [Header("Mining Effects")]
    public ParticleSystem miningParticles;
    public GameObject depleteEffect;
    private Material originalMaterial;
​
    protected override void Initialize()
    {
        base.Initialize();
        requiredToolType = ToolType.Pickaxe;
        SetGatheringEffect(miningParticles); // Use a method to set the gathering effect
        Debug.Log($"[Rock-{oreType}] Initialized with requiredToolType: {requiredToolType}");
    }
​
public override bool Gather(Tool tool)
{
    Debug.Log($"[Rock-{oreType}] Attempting to gather with tool: {(tool != null ? tool.itemName : "null")}");
    
    if (tool == null || tool.toolType != ToolType.Pickaxe)
    {
        Debug.Log($"[Rock-{oreType}] Invalid tool for mining");
        return false;
    }
​
    if (!HasResources() || IsRespawning)
    {
        Debug.Log($"[Rock-{oreType}] No resources or is respawning");
        return false;
    }
​
    if (!base.Gather(tool))
    {
        Debug.Log($"[Rock-{oreType}] Base gather failed");
        return false;
    }
​
    CheckForGems(tool);
    return true;
}
​
    // Add this method to maintain compatibility with the Mining class
    public bool Mine(Tool tool)
    {
        return Gather(tool);
    }
​
    private void CheckForGems(Tool tool)
    {
        float bonusChance = gemChance;
        if (tool != null)
        {
            bonusChance *= tool.GetEfficiencyMultiplier(1);
        }
​
        if (Random.value < bonusChance / 100f)
        {
            // Implement gem drop logic here
            Debug.Log("Found a gem!");
            // You might want to add a gem item to the bonusItems list or handle it separately
            // For example: SpawnBonus(new BonusItem { item = gemItem, chance = 1f });
        }
    }
​
    protected override IEnumerator FadeOut()
    {
        if (depleteEffect != null)
        {
            Instantiate(depleteEffect, transform.position, Quaternion.identity);
        }
​
        // Implement the fade out logic here instead of calling the base method
        float duration = 1f;
        float elapsed = 0;
​
        while (elapsed < duration)
        {
            elapsed += Time.deltaTime;
            if (resourceRenderer != null && resourceRenderer.material != null)
            {
                Color newColor = resourceRenderer.material.color;
                newColor.a = 1 - (elapsed / duration);
                resourceRenderer.material.color = newColor;
            }
            yield return null;
        }
​
        resourceRenderer.enabled = false;
        resourceCollider.enabled = false;
    }
​
    protected override IEnumerator FadeIn()
    {
        resourceRenderer.enabled = true;
        resourceCollider.enabled = true;
​
        float duration = 1f;
        float elapsed = 0;
​
        while (elapsed < duration)
        {
            elapsed += Time.deltaTime;
            if (resourceRenderer != null && resourceRenderer.material != null)
            {
                Color newColor = resourceRenderer.material.color;
                newColor.a = elapsed / duration;
                resourceRenderer.material.color = newColor;
            }
            yield return null;
        }
    }
}
using UnityEngine;
​
public class Mining : BaseSkillAction
{
    [Header("Mining Specific")]
    public ParticleSystem miningParticles;
    private MineableRock currentRock;
​
    protected override void Start()
    {
        base.Start();
        requiredSkillName = "Mining";
        requiredToolType = ToolType.Pickaxe;
        Debug.Log("[Mining] Initialized mining skill action.");
    }
​
    public override void SetTarget(ResourceNode target)
    {
        if (target is MineableRock rock)
        {
            base.SetTarget(target);
            currentRock = rock;
            Debug.Log($"[Mining] Targeting rock: {rock.name}");
        }
        else
        {
            Debug.LogError("[Mining] Invalid target type. Expected MineableRock.");
            currentRock = null;
        }
    }
​
    protected override string GetAnimationTrigger() => "isMining";
​
    protected virtual void PlayMiningEffect()
    {
        if (miningParticles != null)
        {
            miningParticles.Play();
            Debug.Log("Playing mining particles effect.");
        }
    }
​
protected override bool ProcessAction()
{
    Debug.Log($"[Mining] Processing action with target: {currentTarget?.name}");
    
    if (currentTarget != null && currentTarget.IsRespawning)
    {
        Debug.Log($"[{requiredSkillName}] Cannot gather - resource is respawning");
        StopAction();
        return false;
    }
​
    if (currentRock == null)
    {
        Debug.Log("[Mining] Current rock is null, attempting to set from target");
        currentRock = currentTarget as MineableRock;
        if (currentRock == null)
        {
            Debug.Log("[Mining] Failed to set current rock from target");
            StopAction();
            return false;
        }
    }
​
    if (!currentRock.HasResources())
    {
        Debug.Log("[Mining] Rock depleted!");
        StopAction();
        return false;
    }
​
    Tool currentPickaxe = inventory.GetToolOfType(requiredToolType) as Tool;
    if (currentPickaxe == null)
    {
        Debug.Log("[Mining] No pickaxe found in inventory!");
        NotifyPlayer("You need a pickaxe to mine.");
        StopAction();
        return false;
    }
​
    if (currentRock.Gather(currentPickaxe))
    {
        Debug.Log("[Mining] Successfully mined rock.");
        PlayMiningEffect();
        inventory.AddItem(currentRock.primaryResource, 1);
        playerSkills.AddExperience(requiredSkillName, currentRock.baseXP);
        return true;
    }
​
    Debug.Log("[Mining] Failed to mine rock.");
    StopAction();
    return false;
}
​
    public override void StopAction()
    {
        base.StopAction();
        currentRock = null;
        SetAnimationState(false);
    }
}
using UnityEngine;
​
public class MusicTrigger : MonoBehaviour
{
    public AudioSource musicSource;
    public AudioClip areaMusic;
​
    void Start()
    {
        // Set the MusicTrigger to ignore raycasts
        gameObject.layer = LayerMask.NameToLayer("Ignore Raycast");
    }
​
    private void OnTriggerEnter(Collider other)
    {
        if (other.CompareTag("Player"))
        {
            if (musicSource != null && areaMusic != null)
            {
                musicSource.clip = areaMusic;
                musicSource.Play();
            }
            else
            {
                Debug.LogWarning("MusicSource or AreaMusic not assigned.");
            }
        }
    }
}
public enum OreType
{
    Copper,
    Tin,
    Iron,
    Coal,
    Mithril,
    Adamant,
    Rune
}
using UnityEngine;
using UnityEngine.AI;
using TMPro;
​
public class PlayerAnimationController : MonoBehaviour
{
    private Animator animator;
    public TMP_Text runButtonText; // Assign in Inspector
    private NavMeshAgent navMeshAgent;
    public bool isRunning = false; // Toggle state for running
​
    private void Start()
    {
        animator = GetComponent<Animator>();
        navMeshAgent = GetComponent<NavMeshAgent>();
​
        if (animator == null)
        {
            Debug.LogError("Animator not found! Ensure an Animator is attached to the player.");
        }
​
        if (navMeshAgent == null)
        {
            Debug.LogError("NavMeshAgent not found! Ensure a NavMeshAgent is attached to the player.");
        }
​
        UpdateAgentSpeed(); // Initialize NavMeshAgent speed
    }
​
    private void Update()
    {
        HandleMovementAnimations();
    }
​
private void HandleMovementAnimations()
{
    // Get the current speed of the NavMeshAgent
    float speed = navMeshAgent.velocity.magnitude;
​
    // Determine if the player is moving
    bool isMoving = speed > 0.1f; // Adjust threshold if needed
    animator.SetBool("isWalking", isMoving);
​
    // Set Speed parameter for blending
    animator.SetFloat("Speed", speed);
​
    // Explicitly handle idle state
    if (!navMeshAgent.pathPending && navMeshAgent.remainingDistance <= navMeshAgent.stoppingDistance)
    {
        isMoving = false;
        animator.SetBool("isWalking", false); // Ensure idle animation triggers
        animator.SetFloat("Speed", 0);       // Reset speed to zero
    }
}
​
    // Method to toggle running
public void ToggleRun()
{
    isRunning = !isRunning; // Toggle running state
    UpdateAgentSpeed();
        // Update Animator parameter
    animator.SetBool("isRunning", isRunning);
​
    if (runButtonText != null)
    {
        runButtonText.text = isRunning ? "Walk" : "Run"; // Update button text
    }
}
​
    private void UpdateAgentSpeed()
    {
        navMeshAgent.speed = isRunning ? 6f : 3.5f; // Adjust speed for running or walking
        Debug.Log($"Running toggled: {isRunning}, NavMeshAgent Speed: {navMeshAgent.speed}");
    }
}
using UnityEngine;
using System.Collections;
using Random = UnityEngine.Random;
​
public class PlayerCombatant : MonoBehaviour, ICombatant
{    
    private CombatStats stats;
    private PlayerSkills playerSkills;
    private EquipmentManager equipmentManager;
    private RegenerationManager regenManager;
​
    public CombatStats Stats => stats;
    public bool IsAlive => Stats.Vitality > 0;
    Transform ICombatant.transform => transform;
​
    private void Awake()
    {
        playerSkills = GetComponent<PlayerSkills>();
        equipmentManager = GetComponent<EquipmentManager>();
        regenManager = GetComponent<RegenerationManager>();
        InitializeStats();
    }
​
    private void InitializeStats()
    {
        stats = new CombatStats(
            vitality: GetSkillLevel("Vitality"),
            precision: GetSkillLevel("Precision"),
            might: GetSkillLevel("Might"),
            fortitude: GetSkillLevel("Fortitude"),
            range: GetSkillLevel("Range"),
            spellweaving: GetSkillLevel("Spellweaving"),
            divinity: GetSkillLevel("Divinity")
        );
​
        Debug.Log($"Initialized player combat stats: " +
                 $"Vitality={stats.Vitality}, " +
                 $"Precision={stats.Precision}, " +
                 $"Might={stats.Might}, " +
                 $"Fortitude={stats.Fortitude}");
​
        // Initialize regeneration
        if (regenManager != null)
        {
            regenManager.StartRegeneration();
        }
    }
​
    private int GetSkillLevel(string skillName)
    {
        var skill = playerSkills?.GetSkill(skillName);
        return skill?.CurrentLevel ?? 1;
    }
​
    public AttackStyle GetCurrentCombatStyle()
    {
        var weapon = equipmentManager?.GetEquippedItem(EquipmentSlot.MainHand) as WeaponData;
        return weapon?.defaultAttackStyle ?? AttackStyle.Stab;
    }
​
    public void Attack(ICombatant target)
    {
        if (!IsAlive || target == null || !target.IsAlive) return;
​
        // Pause regeneration when attacking
        if (regenManager != null)
        {
            regenManager.PauseRegeneration(2.0f); // Pause regen for 2 seconds after attacking
        }
​
        var weapon = equipmentManager?.GetEquippedItem(EquipmentSlot.MainHand) as CombatWeaponData;
        if (weapon == null)
        {
            PerformUnarmedAttack(target);
            return;
        }
​
        float accuracy = CombatCalculator.CalculateAccuracy(this, target, weapon.availableAttackStyles[0]);
        
        if (Random.value < accuracy)
        {
            int damage = CalculateDamage(target, weapon);
            target.TakeDamage(damage, weapon.attackStyle);
            CombatExperience.AwardCombatExperience(this, damage, weapon);
            Debug.Log($"Hit {target.GetDisplayName()} for {damage} damage!");
        }
        else
        {
            Debug.Log($"Missed attack against {target.GetDisplayName()}!");
        }
    }
​
    private void PerformUnarmedAttack(ICombatant target)
    {
        // Basic unarmed combat using Precision skill
        float accuracy = (float)GetSkillLevel("Precision") / 
                        (GetSkillLevel("Precision") + target.Stats.Fortitude);
        
        if (Random.value < accuracy)
        {
            int damage = Mathf.Max(1, GetSkillLevel("Might") / 10);
            target.TakeDamage(damage, AttackStyle.Crush);
            Debug.Log($"Unarmed hit for {damage} damage!");
        }
    }
​
    private int CalculateDamage(ICombatant target, CombatWeaponData weapon)
    {
        // Implement new damage formula based on weapon style
        return weapon.attackStyle switch
        {
            AttackStyle.Stab or AttackStyle.Slash or AttackStyle.Crush =>
                Mathf.FloorToInt(0.5f + (stats.Might * (weapon.bonuses.mightBonus + 64)) / 640f),
            
            AttackStyle.Range =>
                Mathf.FloorToInt(0.5f + (stats.Range * (weapon.bonuses.rangeStrengthBonus + 64)) / 640f),
            
            AttackStyle.Spellweaving =>
                Mathf.FloorToInt(10 * (1 + weapon.bonuses.spellweavingDamage / 100f)),
            
            _ => 1
        };
    }
​
    public void TakeDamage(int damage, AttackStyle style)
    {
        if (!IsAlive) return;
​
        // Pause regeneration when taking damage
        if (regenManager != null)
        {
            regenManager.PauseRegeneration(3.0f); // Pause regen for 3 seconds after taking damage
        }
​
        float defenceBonus = equipmentManager?.GetTotalFortitudeBonus() ?? 0;
        int reducedDamage = Mathf.Max(1, (int)(damage * (1 - defenceBonus/100)));
        stats.ModifyVitality(-reducedDamage);
​
        Debug.Log($"Player took {reducedDamage} damage! Vitality: {stats.Vitality}/{stats.MaxVitality}");
​
        if (!stats.IsAlive)
        {
            StartCoroutine(HandleDeath());
        }
    }
​
    private IEnumerator HandleDeath()
    {
        // Stop regeneration on death
        if (regenManager != null)
        {
            regenManager.StopRegeneration();
        }
​
        if (TryGetComponent<Animator>(out var animator))
        {
            animator.SetTrigger("Death");
            yield return new WaitForSeconds(2f);
        }
        // Additional death logic here
    }
​
    public float GetAttackSpeed()
    {
        var weapon = equipmentManager?.GetEquippedItem(EquipmentSlot.MainHand) as CombatWeaponData;
        return weapon?.attackSpeed ?? 2.4f;
    }
​
    public string GetDisplayName() => "Player";
}
using UnityEngine;
​
public class PlayerController : MonoBehaviour
{
    private ResourceNode currentResourceTarget;
    public static PlayerController Instance { get; private set; }
​
    private void Awake()
    {
        if (Instance == null)
        {
            Instance = this;
        }
        else
        {
            Destroy(gameObject);
        }
    }
​
    public void SetResourceTarget(ResourceNode target)
{
    if (currentResourceTarget != null)
    {
        currentResourceTarget.OnRespawnStarted -= HandleResourceRespawn;
    }
​
    currentResourceTarget = target;
​
    if (currentResourceTarget != null)
    {
        currentResourceTarget.OnRespawnStarted += HandleResourceRespawn;
    }
}
​
private void HandleResourceRespawn(ResourceNode resource)
{
    StopCurrentAction();
    currentResourceTarget = null;
}
    
    public void StopCurrentAction()
    {
    Woodcutting woodcutting = FindFirstObjectByType<Woodcutting>();
    if (woodcutting != null && woodcutting.IsPerformingAction)
    {
        woodcutting.StopAction();
    }
    
    // Update to FindFirstObjectByType
    Mining mining = FindFirstObjectByType<Mining>();
    if (mining != null && mining.IsPerformingAction)
    {
        mining.StopAction();
    }
}
​
}
using UnityEngine;
using System.Collections.Generic;
using System.Linq;
​
public class PlayerSkills : MonoBehaviour
{
    [System.Serializable]
    public class SkillData
    {
        public string skillName;
        [HideInInspector] public Skill skill;
        public double startingXP = 0; // Added this field
    }
​
    [Header("UI References")]
    [SerializeField] private UIManager uiManager;
    [SerializeField] private SkillsUI skillsUI;
​
    [Header("Skills Configuration")]
    [SerializeField] private List<SkillData> skillDataList = new List<SkillData>(); // Add this back
​
    [Header("Combat Skills")]
[SerializeField] private List<SkillData> combatSkills = new List<SkillData>
{
    new SkillData { skillName = "Vitality", startingXP = ExperienceTable.GetXPForLevel(10) }, // Starts at level 10
    new SkillData { skillName = "Precision" }, // Previously Attack
    new SkillData { skillName = "Might" },     // Previously Strength
    new SkillData { skillName = "Fortitude" }, // Previously Defence
    new SkillData { skillName = "Range" },     // Previously Ranged
    new SkillData { skillName = "Spellweaving" }, // Previously Magic
    new SkillData { skillName = "Divinity" }   // New skill
};
​
    [Header("Gathering Skills")]
    [SerializeField] private List<SkillData> gatheringSkills = new List<SkillData>
    {
        new SkillData { skillName = "Woodcutting" },
        new SkillData { skillName = "Mining" },
        //new SkillData { skillName = "Firemaking" }
        //new SkillData { skillName = "Fishing" }
        //new SkillData { skillName = "Smithing" }
        // Add other gathering skills...
    };
​
    private List<Skill> skills = new List<Skill>();
    public IReadOnlyList<Skill> Skills => skills;
​
    private void Awake()
    {
        if (uiManager == null)
        {
            uiManager = FindFirstObjectByType<UIManager>();
            Debug.Log($"UIManager assigned in Awake: {uiManager != null}");
        }
​
        if (skillsUI == null)
        {
            skillsUI = FindFirstObjectByType<SkillsUI>();
            Debug.Log($"SkillsUI assigned in Awake: {skillsUI != null}");
        }
    }
​
    private void Start()
    {
        Debug.Log("PlayerSkills.Start invoked.");
        InitializeSkills();
        InitializeReferences();
        SetupUICallbacks();
        Debug.Log($"Initialized and subscribed to {skills.Count} skills.");
    }
​
    private void InitializeSkills()
    {
        Debug.Log("Initializing skills...");
        skills.Clear();
​
        // Combine all skills into skillDataList
        skillDataList.Clear();
        skillDataList.AddRange(combatSkills);
        skillDataList.AddRange(gatheringSkills);
​
        foreach (var skillData in skillDataList)
        {
            InitializeSkill(skillData);
        }
​
        Debug.Log($"Total skills initialized: {skills.Count}");
    }
​
    private void InitializeSkill(SkillData skillData)
    {
        if (!string.IsNullOrEmpty(skillData.skillName))
        {
            Skill newSkill = new Skill(skillData.skillName);
            if (skillData.startingXP > 0)
            {
                newSkill.AddExperience(skillData.startingXP);
            }
            Debug.Log($"Created skill: {newSkill.SkillName} at level {newSkill.CurrentLevel}");
            skills.Add(newSkill);
            skillData.skill = newSkill;
        }
        else
        {
            Debug.LogError("Skill name is empty in SkillData. Skipping this entry.");
        }
    }
    private void InitializeReferences()
    {
        if (uiManager == null)
        {
            uiManager = FindFirstObjectByType<UIManager>();
            Debug.Log($"UIManager assigned: {uiManager != null}");
        }
​
        if (skillsUI == null)
        {
            skillsUI = FindFirstObjectByType<SkillsUI>();
            Debug.Log($"SkillsUI assigned: {skillsUI != null}");
        }
​
        ValidateReferences();
    }
​
    private void ValidateReferences()
    {
        if (uiManager == null)
        {
            Debug.LogError("UIManager reference is missing!");
        }
​
        if (skillsUI == null)
        {
            Debug.LogError("SkillsUI reference is missing!");
        }
    }
​
private void SetupUICallbacks()
{
    if (uiManager == null)
    {
        Debug.LogError("UIManager not found! Cannot set up UI callbacks.");
        return;
    }
​
    if (skillsUI == null)
    {
        Debug.LogError("SkillsUI not found! Cannot set up UI callbacks.");
        return;
    }
​
    Debug.Log($"Setting up UI callbacks for {skills.Count} skills.");
    foreach (var skill in skills)
    {
        if (skill != null)
        {
            // Create local variable to avoid closure issues
            var currentSkill = skill;
​
            // Clear existing subscribers
            currentSkill.ClearSubscribers();
​
            // Subscribe to XP gained event
            currentSkill.OnXPGained += (skillName, level, xp, nextLevel) =>
            {
                Debug.Log($"[PlayerSkills] XP gained callback for {skillName}: Level={level}, XP={xp}");
                if (uiManager != null)
                {
                    uiManager.UpdateSkillUI(skillName, level, (int)xp, (int)nextLevel);
                }
            };
​
            // Subscribe to level up event
            currentSkill.OnLevelUp += (skillName, level) =>
            {
                Debug.Log($"[PlayerSkills] Level up callback for {skillName}: Level={level}");
                var chatbox = EnhancedChatbox.Instance;
                if (chatbox != null)
                {
                    chatbox.AddMessage($"Congratulations! Your {skillName} level is now {level}!", 
                        EnhancedChatbox.MessageType.LevelUp);
                }
            };
​
            Debug.Log($"[PlayerSkills] Subscribed to events for {currentSkill.SkillName}");
        }
        else
        {
            Debug.LogWarning("Encountered a null skill while setting up callbacks");
        }
    }
}
public void AddExperience(string skillName, double xp)
{
    Debug.Log($"Adding {xp} XP to {skillName}");
    var skill = GetSkill(skillName);
    if (skill != null)
    {
        // Check if we need to re-initialize callbacks
        if (!skill.HasSubscribers())
        {
            Debug.LogWarning($"[PlayerSkills] Missing subscribers for {skillName}, re-initializing callbacks");
            SetupUICallbacks();
        }
        skill.AddExperience(xp);
    }
    else
    {
        Debug.LogError($"Skill not found: {skillName}");
        Debug.LogError($"Available skills: {string.Join(", ", skills.Select(s => s.SkillName))}");
    }
}
​
public int CalculateCombatLevel()
{
    Skill fortitude = GetSkill("Fortitude");
    Skill vitality = GetSkill("Vitality");
    Skill divinity = GetSkill("Divinity");
    
    // Get combat style levels
    int meleeLevel = Mathf.Max(
        GetSkill("Precision")?.CurrentLevel ?? 1,
        GetSkill("Might")?.CurrentLevel ?? 1
    );
    int rangeLevel = GetSkill("Range")?.CurrentLevel ?? 1;
    int spellweavingLevel = GetSkill("Spellweaving")?.CurrentLevel ?? 1;
​
    // Find highest combat style level
    int highestCombatStyle = Mathf.Max(meleeLevel, rangeLevel, spellweavingLevel);
​
    // Calculate combat level using the new formula
    float combatLevel = (
        (fortitude?.CurrentLevel ?? 1) + 
        (vitality?.CurrentLevel ?? 10) + 
        ((divinity?.CurrentLevel ?? 1) / 2f) + 
        highestCombatStyle
    ) / 5f;
​
    return Mathf.FloorToInt(combatLevel);
}
​
// Add this method to allow manual refresh of callbacks
public void RefreshCallbacks()
{
    Debug.Log("[PlayerSkills] Manually refreshing callbacks");
    SetupUICallbacks();
}
​
    private void HandleXPGained(string name, int level, double xp, double nextLevel)
    {
        Debug.Log($"XP gained callback triggered for {name} - Level: {level}, XP: {xp}");
​
        if (uiManager != null)
        {
            uiManager.UpdateSkillUI(name, level, (int)xp, (int)nextLevel);
        }
        else
        {
            Debug.LogError("UIManager is null. Cannot update UI.");
        }
    }
​
    private void HandleLevelUp(string name, int level)
    {
        Debug.Log($"Level up callback triggered for {name} - New Level: {level}");
​
        // Notify the player
        EnhancedChatbox.Instance?.AddMessage(
            $"Congratulations! Your {name} level is now {level}!",
            EnhancedChatbox.MessageType.LevelUp
        );
    }
​
    private void OnDestroy()
    {
        Debug.Log("Unsubscribing from skill events.");
        foreach (var skill in skills)
        {
            if (skill != null)
            {
                skill.OnXPGained -= HandleXPGained;
                skill.OnLevelUp -= HandleLevelUp;
            }
        }
    }
​
    public Skill GetSkill(string skillName)
    {
        return skills.FirstOrDefault(s =>
            string.Equals(s.SkillName, skillName, System.StringComparison.OrdinalIgnoreCase));
    }
​
    public int GetTotalLevel()
    {
        return skills.Sum(skill => skill.CurrentLevel);
    }
​
#if UNITY_EDITOR
    private void OnValidate()
    {
        Debug.Log("Validating SkillDataList...");
        foreach (var data in skillDataList)
        {
            Debug.Log($"SkillData: {data.skillName}");
        }
​
        var duplicates = skillDataList
            .GroupBy(x => x.skillName)
            .Where(g => g.Count() > 1)
            .Select(g => g.Key)
            .ToList();
​
        if (duplicates.Any())
        {
            Debug.LogError($"Duplicate skill names found: {string.Join(", ", duplicates)}");
        }
    }
#endif
}
​
using UnityEngine;
using System.Collections;
​
public class RegenerationManager : MonoBehaviour
{
    [Header("Regeneration Settings")]
    public float baseRegenRate = 0.01f; // 1% per second
    public float regenTickInterval = 0.6f; // Regenerate every 0.6 seconds
​
    private CombatStats combatStats;
    private bool isRegenerating = true;
    private Coroutine regenCoroutine;
​
    private void Start()
    {
        // Get reference to player's combat stats
        combatStats = GetComponent<PlayerCombatant>()?.Stats;
        if (combatStats == null)
        {
            Debug.LogError("RegenerationManager: No CombatStats found!");
            return;
        }
​
        StartRegeneration();
    }
​
    public void StartRegeneration()
    {
        if (!isRegenerating)
        {
            isRegenerating = true;
            if (regenCoroutine == null)
            {
                regenCoroutine = StartCoroutine(RegenerationRoutine());
            }
        }
    }
​
    public void StopRegeneration()
    {
        isRegenerating = false;
        if (regenCoroutine != null)
        {
            StopCoroutine(regenCoroutine);
            regenCoroutine = null;
        }
    }
​
    private IEnumerator RegenerationRoutine()
    {
        WaitForSeconds wait = new WaitForSeconds(regenTickInterval);
​
        while (isRegenerating)
        {
            if (combatStats != null && combatStats.Vitality < combatStats.MaxVitality)
            {
                // Calculate regen amount
                float regenAmount = combatStats.MaxVitality * baseRegenRate * regenTickInterval;
                
                // Apply regeneration
                combatStats.ModifyVitality(Mathf.CeilToInt(regenAmount));
                
                Debug.Log($"Regenerated {regenAmount:F1} Vitality. Current: {combatStats.Vitality}/{combatStats.MaxVitality}");
            }
​
            yield return wait;
        }
    }
​
    // Call this when player takes damage or enters combat
    public void PauseRegeneration(float duration)
    {
        StopRegeneration();
        StartCoroutine(ResumeRegenerationAfterDelay(duration));
    }
​
    private IEnumerator ResumeRegenerationAfterDelay(float delay)
    {
        yield return new WaitForSeconds(delay);
        StartRegeneration();
    }
}
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
​
public abstract class ResourceNode : MonoBehaviour
{
    [System.Serializable]
    public class BonusItem
    {
        public Item item;
        public float chance;
    }
​
    [Header("Basic Properties")]
    public string nodeName;
    public int requiredLevel = 1;
    public float baseGatherTime = 3f;
    public int baseXP = 25;
    public Item primaryResource;
    public ToolType requiredToolType;
    
    [Header("Resource Settings")]
    public int resourcesRemaining;
    public int maxResources = 5;
    public float respawnTime = 30f;
    public float depletionChance = 0.2f;
​
    [Header("Bonus Items")]
    public List<BonusItem> bonusItems = new List<BonusItem>();
​
    [Header("Effects")]
    protected ParticleSystem gatheringEffect;
​
     public bool IsRespawning => isRespawning;
    protected bool isRespawning = false;
    protected Renderer resourceRenderer;
    protected WorldInteractable worldInteractable;
    protected Collider resourceCollider;
    public event System.Action<ResourceNode> OnRespawnStarted;
    public event System.Action<ResourceNode> OnRespawnCompleted;
​
    protected virtual void Start()
    {
        Initialize();
        SetupInteraction();
        Debug.Log($"[{nodeName}] Initialized with requiredToolType: {requiredToolType}");
    }
​
    protected virtual void Initialize()
    {
        resourceRenderer = GetComponent<Renderer>();
        resourceCollider = GetComponent<Collider>();
        resourcesRemaining = maxResources;
        Debug.Log($"[{nodeName}] Resources: {resourcesRemaining}/{maxResources}");
    }
​
    public virtual bool CanGather(ISkill skill)
    {
        if (isRespawning || resourcesRemaining <= 0)
        {
            Debug.Log($"[{nodeName}] Cannot gather: isRespawning={isRespawning}, resourcesRemaining={resourcesRemaining}");
            return false;
        }
​
        if (skill != null && skill.CurrentLevel < requiredLevel)
        {
            Debug.Log($"[{nodeName}] Skill level too low. Required: {requiredLevel}, Current: {skill.CurrentLevel}");
            return false;
        }
​
        return true;
    }
​
public virtual bool Gather(Tool tool)
{
    Debug.Log($"[{nodeName}] Attempting to gather with tool: {(tool != null ? tool.itemName : "null")}");
    
    if (!CanGather(null))
    {
        Debug.Log($"[{nodeName}] Cannot gather - basic checks failed");
        return false;
    }
    
    if (tool == null)
    {
        Debug.Log($"[{nodeName}] No tool provided for gathering");
        return false;
    }
​
    if (tool.toolType != requiredToolType)
    {
        Debug.Log($"[{nodeName}] Incorrect tool type. Required: {requiredToolType}, Used: {tool.toolType}");
        return false;
    }
​
    resourcesRemaining--;
    Debug.Log($"[{nodeName}] Gathered successfully. Resources remaining: {resourcesRemaining}");
​
    if (gatheringEffect != null)
    {
        gatheringEffect.Play();
    }
​
    // Handle bonus items
    foreach (var bonus in bonusItems)
    {
        if (Random.value < bonus.chance)
        {
            SpawnBonus(bonus);
        }
    }
​
    if (resourcesRemaining <= 0 || (Random.value < depletionChance))
    {
        StartCoroutine(RespawnResource());
    }
​
    return true;
}
​
    public bool HasResources()
{
    return resourcesRemaining > 0 && !isRespawning;
}
​
    protected virtual void SpawnBonus(BonusItem bonus)
    {
        if (Inventory.Instance != null)
        {
            bool added = Inventory.Instance.AddItem(bonus.item, 1);
            Debug.Log($"[{nodeName}] Added bonus item {bonus.item.itemName} to inventory: {added}");
        }
    }
​
    protected virtual IEnumerator RespawnResource()
    {
        Debug.Log($"[{nodeName}] Starting respawn sequence");
        isRespawning = true;
        
        // Notify listeners that respawning has started
        OnRespawnStarted?.Invoke(this);
​
        yield return StartCoroutine(FadeOut());
​
        Debug.Log($"[{nodeName}] Waiting {respawnTime} seconds to respawn");
        yield return new WaitForSeconds(respawnTime);
​
        yield return StartCoroutine(FadeIn());
​
        resourcesRemaining = maxResources;
        isRespawning = false;
        
        // Notify listeners that respawning has completed
        OnRespawnCompleted?.Invoke(this);
        
        Debug.Log($"[{nodeName}] Respawn complete. Resources reset to {maxResources}");
    }
​
    protected abstract IEnumerator FadeOut();
    protected abstract IEnumerator FadeIn();
​
    protected void SetGatheringEffect(ParticleSystem effect)
    {
        gatheringEffect = effect;
    }
    protected virtual void SetupInteraction()
    {
        worldInteractable = gameObject.AddComponent<WorldInteractable>();
        worldInteractable.objectName = nodeName;
​
        // Add the appropriate gathering action based on resource type
        if (this is ChoppableTree)
        {
            worldInteractable.AddCustomOption($"Chop {nodeName}", 
                AttemptGather, 
                () => CanGather(null), // Convert method to Func<bool>
                200);
        }
        else if (this is MineableRock)
        {
            worldInteractable.AddCustomOption($"Mine {nodeName}", 
                AttemptGather, 
                () => CanGather(null), // Convert method to Func<bool>
                200);
        }
​
        // Subscribe to respawn events to update interaction availability
        OnRespawnStarted += (node) => worldInteractable.enabled = false;
        OnRespawnCompleted += (node) => worldInteractable.enabled = true;
    }
​
    public bool IsValidForGathering()
{
    return !isRespawning && resourcesRemaining > 0;
}
    private void AttemptGather()
    {
        var player = GameObject.FindGameObjectWithTag("Player");
        if (player != null)
        {
            if (this is ChoppableTree)
            {
                var woodcutting = player.GetComponent<Woodcutting>();
                if (woodcutting != null)
                    woodcutting.SetTarget(this);
            }
            else if (this is MineableRock)
            {
                var mining = player.GetComponent<Mining>();
                if (mining != null)
                    mining.SetTarget(this);
            }
        }
    }
}
using UnityEngine;
​
public class RuneScapeCamera : MonoBehaviour
{
    public Transform target;
    public float distance = 10f;
    public float minDistance = 5f;
    public float maxDistance = 20f;
    public float zoomSpeed = 2f;
    public float rotationSpeed = 100f;
    public float orbitSpeed = 50f;
    public float heightOffset = 2f;
    public float minVerticalAngle = -30f;
    public float maxVerticalAngle = 60f;
    public float groundClearance = 1f; // Minimum distance to keep from ground
    
    private float currentRotation = 0f;
    private float currentVerticalRotation = 45f;
    private float smoothedVerticalRotation;
    private const float groundCheckRadius = 0.3f; // Radius for ground checking
​
    void LateUpdate()
    {
        if (target == null) return;
​
        // Handle orbital movement with arrow keys
        if (Input.GetKey(KeyCode.LeftArrow)) // Orbit left
        {
            currentRotation += orbitSpeed * Time.deltaTime;
        }
        if (Input.GetKey(KeyCode.RightArrow)) // Orbit right
        {
            currentRotation -= orbitSpeed * Time.deltaTime;
        }
​
        // Store previous vertical rotation for ground check
        float previousVerticalRotation = currentVerticalRotation;
​
        if (Input.GetKey(KeyCode.UpArrow)) // Orbit up
        {
            currentVerticalRotation -= orbitSpeed * Time.deltaTime;
        }
        if (Input.GetKey(KeyCode.DownArrow)) // Orbit down
        {
            currentVerticalRotation += orbitSpeed * Time.deltaTime;
        }
​
        // Middle mouse rotation
        if (Input.GetMouseButton(2))
        {
            float mouseX = Input.GetAxis("Mouse X") * rotationSpeed * Time.deltaTime;
            float mouseY = Input.GetAxis("Mouse Y") * rotationSpeed * Time.deltaTime;
​
            currentRotation -= mouseX;
            currentVerticalRotation = Mathf.Clamp(currentVerticalRotation + mouseY, minVerticalAngle, maxVerticalAngle);
        }
​
        // Basic angle clamping
        currentVerticalRotation = Mathf.Clamp(currentVerticalRotation, minVerticalAngle, maxVerticalAngle);
​
        // Zoom with mouse wheel
        float scroll = Input.GetAxis("Mouse ScrollWheel") * zoomSpeed;
        distance = Mathf.Clamp(distance - scroll, minDistance, maxDistance);
​
        // Calculate desired camera position
        Vector3 targetPos = target.position + Vector3.up * heightOffset;
        
        // Check if new camera position would be too close to ground
        Vector3 rotation = new Vector3(currentVerticalRotation, currentRotation, 0);
        Vector3 negDistance = new Vector3(0.0f, 0.0f, -distance);
        Quaternion rot = Quaternion.Euler(rotation);
        Vector3 desiredPosition = rot * negDistance + targetPos;
​
        // Ground check using spherecast
        RaycastHit hit;
        Vector3 directionToCamera = (desiredPosition - targetPos).normalized;
        if (Physics.SphereCast(targetPos, groundCheckRadius, directionToCamera, out hit, distance))
        {
            float distanceToGround = hit.distance;
            if (distanceToGround < groundClearance)
            {
                // Revert vertical rotation if too close to ground
                currentVerticalRotation = previousVerticalRotation;
                rotation = new Vector3(currentVerticalRotation, currentRotation, 0);
                rot = Quaternion.Euler(rotation);
                desiredPosition = rot * negDistance + targetPos;
            }
        }
​
        // Update camera transform
        transform.rotation = rot;
        transform.position = desiredPosition;
    }
​
    // Helper method to reset camera position behind player
    public void ResetCamera()
    {
        if (target != null)
        {
            currentRotation = target.eulerAngles.y;
            currentVerticalRotation = 45f;
        }
    }
​
    // Optionally visualize the ground check radius in the editor
    private void OnDrawGizmosSelected()
    {
        if (target != null)
        {
            Gizmos.color = Color.yellow;
            Gizmos.DrawWireSphere(transform.position, groundCheckRadius);
        }
    }
}
using UnityEngine;
using UnityEngine.UI;
​
public class SidebarButton : MonoBehaviour
{
    public GameObject targetPanel;
    private Button button;
    private bool initialized = false;
​
    private void OnEnable()
    {
        if (!initialized)
        {
            Initialize();
        }
    }
​
    private void Initialize()
    {
        button = GetComponent<Button>();
        if (button == null)
        {
            Debug.LogError($"No Button component found on {gameObject.name}!");
            return;
        }
​
        if (targetPanel == null)
        {
            Debug.LogError($"No target panel assigned for {gameObject.name}!");
            return;
        }
​
        // Add listener programmatically
        button.onClick.RemoveAllListeners(); // Clear any existing listeners
        button.onClick.AddListener(OnButtonClick);
        
        // Make sure the panel starts hidden
        if (targetPanel != null)
        {
            targetPanel.SetActive(false);
        }
​
        initialized = true;
        Debug.Log($"SidebarButton initialized for {gameObject.name}");
    }
​
public void OnButtonClick()
{
    if (targetPanel == null || UIManager.Instance == null)
    {
        Debug.LogError($"Missing references on {gameObject.name}!");
        return;
    }
​
    // First activate the panel
    targetPanel.SetActive(true);
​
    // Then initialize if needed
    var equipmentUI = targetPanel.GetComponent<EquipmentUI>();
    if (equipmentUI != null)
    {
        equipmentUI.EnsureInitialized();
    }
​
    // Finally toggle through UI Manager
    UIManager.Instance.TogglePanel(targetPanel);
}
}
using UnityEngine;
using UnityEngine.UI;
using System.Collections.Generic;
​
public class SidebarUI : MonoBehaviour
{
    [System.Serializable]
    public class SidebarButton
    {
        public string name;
        public Sprite icon;
        public GameObject associatedPanel;
    }
​
    public List<SidebarButton> sidebarButtons;
    public GameObject buttonPrefab;
    public Transform buttonContainer;
    
    private GameObject activePanel;
​
    private void Start()
    {
        InitializeSidebar();
    }
​
    private void InitializeSidebar()
    {
        foreach (var buttonData in sidebarButtons)
        {
            GameObject buttonObj = Instantiate(buttonPrefab, buttonContainer);
            Button button = buttonObj.GetComponent<Button>();
            Image icon = buttonObj.GetComponentInChildren<Image>();
​
            // Set up button
            icon.sprite = buttonData.icon;
            
            // Set up click handler
            button.onClick.AddListener(() => OnSidebarButtonClicked(buttonData));
​
            // Initially hide all panels
            if (buttonData.associatedPanel != null)
            {
                buttonData.associatedPanel.SetActive(false);
            }
        }
    }
​
    private void OnSidebarButtonClicked(SidebarButton buttonData)
    {
        // Hide currently active panel
        if (activePanel != null)
        {
            activePanel.SetActive(false);
        }
​
        // Show new panel if it's different from the current one
        if (activePanel != buttonData.associatedPanel)
        {
            buttonData.associatedPanel.SetActive(true);
            activePanel = buttonData.associatedPanel;
        }
        else
        {
            activePanel = null;
        }
    }
}
using UnityEngine;
using System;
​
[System.Serializable]
public class Skill : ISkill
{
    public string skillName;
    private double currentXP;
    private int cachedLevel = 1;
    
    public string SkillName => skillName;
    public int CurrentLevel => GetCurrentLevel();
    public double CurrentXP => currentXP;
    public double XPToNextLevel => ExperienceTable.GetXPToNextLevel(CurrentLevel, currentXP);
​
    public event Action<string, int, double, double> OnXPGained;
    public event Action<string, int> OnLevelUp;
​
    public Skill(string name)
    {
        skillName = name;
        currentXP = 0;
    }
​
    public void InitializeUI()
    {
        OnXPGained?.Invoke(skillName, CurrentLevel, currentXP, XPToNextLevel);
    }
​
public void AddExperience(double xp)
{
    if (xp <= 0) 
    {
        Debug.LogWarning($"[{skillName}] Attempted to add invalid XP amount: {xp}");
        return;
    }
    
    double oldXP = currentXP;
    int oldLevel = CurrentLevel;
    
    currentXP = Math.Min(currentXP + xp, ExperienceTable.GetXPForLevel(ExperienceTable.MAX_LEVEL));
    int newLevel = GetCurrentLevel();
​
    Debug.Log($"[{skillName}] Added {xp} XP. Old XP: {oldXP}, New XP: {currentXP}");
    
    // Check for level up
    if (newLevel > oldLevel)
    {
        Debug.Log($"[{skillName}] Level Up! {oldLevel} -> {newLevel}");
        if (OnLevelUp != null)
        {
            OnLevelUp.Invoke(skillName, newLevel);
        }
        else
        {
            Debug.LogWarning($"[{skillName}] OnLevelUp has no subscribers!");
        }
    }
​
    // Trigger XP update
    if (OnXPGained != null)
    {
        Debug.Log($"[{skillName}] Triggering XP update. Level={CurrentLevel}, XP={currentXP}, NextLevel={XPToNextLevel}");
        OnXPGained.Invoke(skillName, CurrentLevel, currentXP, XPToNextLevel);
    }
    else
    {
        Debug.LogWarning($"[{skillName}] OnXPGained has no subscribers! Requesting callback refresh.");
        var playerSkills = UnityEngine.Object.FindFirstObjectByType<PlayerSkills>();
        if (playerSkills != null)
        {
            playerSkills.RefreshCallbacks();
        }
    }
}
    public bool HasSubscribers()
    {
        return OnXPGained != null;
    }
    public void ClearSubscribers()
    {
        OnXPGained = null;
        OnLevelUp = null;
        Debug.Log($"[{skillName}] Cleared event subscribers");
    }
    private int GetCurrentLevel()
    {
        cachedLevel = ExperienceTable.GetLevel(currentXP);
        return cachedLevel;
    }
​
    public bool HasRequirement(int level) => CurrentLevel >= level;
​
    public string GetSkillInfo()
    {
        return $"{skillName} - Level: {CurrentLevel} - XP: {ExperienceTable.FormatXP(currentXP)} " +
               $"- Next Level: {ExperienceTable.FormatXP(XPToNextLevel)} XP remaining";
    }
}
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.EventSystems;
using TMPro;
​
public class SkillEntryUI : MonoBehaviour, IPointerEnterHandler, IPointerExitHandler
{
    [Header("UI Components")]
    public Image skillIcon;
    public TextMeshProUGUI skillNameText;
    public TextMeshProUGUI levelText;
    public TextMeshProUGUI xpText;
    public Slider xpProgressBar;
    public GameObject tooltipPanel;
    public TextMeshProUGUI tooltipText;
​
    public void UpdateDisplay(string skillName, int level, double currentXP, double xpToNextLevel)
    {
        if (skillNameText != null)
            skillNameText.text = skillName;
​
        if (levelText != null)
            levelText.text = $"Level {level}";
​
        if (xpText != null)
        {
            if (level >= ExperienceTable.MAX_LEVEL)
                xpText.text = ExperienceTable.FormatXP(currentXP);
            else
                xpText.text = $"{currentXP:N0} / {(currentXP + xpToNextLevel):N0} XP";
        }
​
        if (xpProgressBar != null)
            xpProgressBar.value = ExperienceTable.GetProgressToNextLevel(currentXP);
​
        UpdateTooltip(skillName, level, currentXP, xpToNextLevel);
    }
​
private void UpdateTooltip(string skillName, int level, double currentXP, double xpToNextLevel)
{
    if (tooltipText == null) return;
​
    string tooltipString = $"{skillName}\n";
    tooltipString += $"Level: {level}";
    
    if (level < ExperienceTable.MAX_LEVEL)
    {
        double totalXPForLevel = currentXP + xpToNextLevel;
        double percentage = totalXPForLevel > 0 ? (currentXP / totalXPForLevel) * 100 : 0;
        
        tooltipString += $"\nXP: {ExperienceTable.FormatXP(currentXP)}";
        tooltipString += $"\nNext Level: {ExperienceTable.FormatXP(xpToNextLevel)} XP remaining";
        tooltipString += $"\nProgress: {percentage:F1}%";
    }
    else
    {
        tooltipString += $"\nMax Level!\nTotal XP: {ExperienceTable.FormatXP(currentXP)}";
    }
​
    tooltipText.text = tooltipString;
}
​
    public void OnPointerEnter(PointerEventData eventData)
    {
        if (tooltipPanel != null)
            tooltipPanel.SetActive(true);
    }
​
    public void OnPointerExit(PointerEventData eventData)
    {
        if (tooltipPanel != null)
            tooltipPanel.SetActive(false);
    }
}
using UnityEngine;
​
public class SkillsAudioManager : MonoBehaviour
{
    private AudioSource audioSource;
​
    private void Awake()
    {
        audioSource = GetComponent<AudioSource>();
        if (audioSource == null)
        {
            audioSource = gameObject.AddComponent<AudioSource>();
        }
    }
​
    public void PlaySkillSound(AudioClip clip)
    {
        if (audioSource != null && clip != null)
        {
            audioSource.PlayOneShot(clip);
        }
    }
}
using UnityEngine;
​
[CreateAssetMenu(fileName = "New Skill", menuName = "Skills/Skill Data")]
public class SkillData : ScriptableObject
{
    [Header("Basic Info")]
    public string skillName;
    public Sprite skillIcon;
    [TextArea(3, 5)]
    public string description;
​
    [Header("Skill Settings")]
    public int startingLevel = 1;
    public int maxLevel = 99;
    public float experienceMultiplier = 1f;
​
    [Header("Tool Requirements")]
    public ItemType[] allowedTools;
    public int minimumToolLevel = 1;
}
using UnityEngine;
using UnityEngine.UI;
using TMPro;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
​
public class SkillsUI : MonoBehaviour
{
    [System.Serializable]
    public class SkillIconData
    {
        public string skillName;
        public Sprite icon;
        [TextArea(2,3)]
        public string description;
    }
​
    [Header("References")]
    public GameObject skillEntryPrefab;
    public Transform skillsContainer;
    public TextMeshProUGUI totalLevelText;
​
    [Header("Visual Settings")]
    public Color normalColor = Color.white;
    public Color maxLevelColor = Color.yellow;
    public Color virtualLevelColor = new Color(0.7f, 0.7f, 1f);
​
    [Header("Skill Icons")]
    public List<SkillIconData> skillIcons = new List<SkillIconData>();
​
    private Dictionary<string, SkillEntryUI> skillEntries = new Dictionary<string, SkillEntryUI>();
    private PlayerSkills cachedPlayerSkills;
​
    private void Start()
    {
        Debug.Log("SkillsUI Starting...");
        InitializeReferences();
        StartCoroutine(DelayedInitialization());
    }
​
    private void InitializeReferences()
    {
        if (cachedPlayerSkills == null)
        {
            cachedPlayerSkills = FindFirstObjectByType<PlayerSkills>();
            if (cachedPlayerSkills == null)
            {
                Debug.LogError("PlayerSkills reference not found!");
                return;
            }
            Debug.Log($"Found PlayerSkills reference");
        }
​
        if (skillEntryPrefab == null || skillsContainer == null)
        {
            Debug.LogError($"Missing critical references - Prefab: {skillEntryPrefab != null}, Container: {skillsContainer != null}");
        }
    }
​
    private IEnumerator DelayedInitialization()
    {
        yield return new WaitForSeconds(0.1f); // Small delay
        InitializeSkills();
    }
​
    private void InitializeSkills()
    {
        ClearContainer();
        
        if (cachedPlayerSkills != null)
        {
            var skills = cachedPlayerSkills.Skills.ToList();
            Debug.Log($"Initializing {skills.Count} skills");
            
            foreach (var skill in skills)
            {
                CreateSkillEntry(skill.SkillName);
            }
            UpdateTotalLevel();
        }
        else
        {
            Debug.LogError("Cannot initialize skills - PlayerSkills reference is null");
        }
    }
​
    private void ClearContainer()
    {
        if (skillsContainer != null)
        {
            foreach (Transform child in skillsContainer)
            {
                Destroy(child.gameObject);
            }
            skillEntries.Clear();
            Debug.Log("Cleared existing skill entries");
        }
    }
​
    private void CreateSkillEntry(string skillName)
    {
        if (string.IsNullOrEmpty(skillName) || skillEntryPrefab == null || skillsContainer == null)
        {
            Debug.LogError($"Cannot create skill entry - missing references for {skillName}");
            return;
        }
​
        try
        {
            GameObject entryObj = Instantiate(skillEntryPrefab, skillsContainer);
            if (entryObj == null)
            {
                Debug.LogError($"Failed to instantiate skill entry prefab for {skillName}");
                return;
            }
​
            SkillEntryUI entryUI = entryObj.GetComponent<SkillEntryUI>();
            if (entryUI == null)
            {
                Debug.LogError($"SkillEntryUI component missing on prefab for {skillName}");
                Destroy(entryObj);
                return;
            }
​
            var iconData = skillIcons.FirstOrDefault(x => 
                string.Equals(x.skillName, skillName, StringComparison.OrdinalIgnoreCase));
​
            if (iconData != null && iconData.icon != null && entryUI.skillIcon != null)
            {
                entryUI.skillIcon.sprite = iconData.icon;
                entryUI.skillIcon.enabled = true;
                Debug.Log($"Set icon for {skillName}");
            }
            else
            {
                if (entryUI.skillIcon != null)
                {
                    entryUI.skillIcon.enabled = false;
                }
                Debug.LogWarning($"No icon data found for {skillName}");
            }
​
            if (cachedPlayerSkills != null)
            {
                var skill = cachedPlayerSkills.GetSkill(skillName);
                if (skill != null)
                {
                    skillEntries[skillName] = entryUI;
                    entryUI.UpdateDisplay(skillName, skill.CurrentLevel, skill.CurrentXP, skill.XPToNextLevel);
                    Debug.Log($"Successfully created entry for {skillName}");
                }
                else
                {
                    Debug.LogError($"Failed to get skill data for {skillName}");
                }
            }
        }
        catch (System.Exception e)
        {
            Debug.LogError($"Error creating skill entry for {skillName}: {e.Message}\n{e.StackTrace}");
        }
    }
​
    public void UpdateSkillDisplay(string skillName, int level, double currentXP, double xpToNextLevel)
    {
        try
        {
            Debug.Log($"Updating display for {skillName} - Level: {level}, Current XP: {currentXP}, Next Level: {xpToNextLevel}");
            
            if (!skillEntries.ContainsKey(skillName))
            {
                Debug.LogWarning($"No existing entry for {skillName}, creating new one");
                CreateSkillEntry(skillName);
                return;
            }
​
            if (skillEntries.TryGetValue(skillName, out SkillEntryUI entry))
            {
                if (entry != null)
                {
                    entry.UpdateDisplay(skillName, level, currentXP, xpToNextLevel);
                    Debug.Log($"Successfully updated UI for {skillName}");
                }
                else
                {
                    Debug.LogError($"Entry UI is null for {skillName}, recreating entry");
                    skillEntries.Remove(skillName);
                    CreateSkillEntry(skillName);
                }
            }
​
            UpdateTotalLevel();
        }
        catch (System.Exception e)
        {
            Debug.LogError($"Error updating skill display for {skillName}: {e.Message}\n{e.StackTrace}");
        }
    }
​
    private void UpdateTotalLevel()
    {
        if (cachedPlayerSkills != null && totalLevelText != null)
        {
            int total = cachedPlayerSkills.GetTotalLevel();
            int maxedSkills = cachedPlayerSkills.Skills.Count(s => s.CurrentLevel >= ExperienceTable.MAX_LEVEL);
            
            string levelText = $"Total Level: {total}";
            if (maxedSkills > 0)
            {
                levelText += $" ({maxedSkills} maxed)";
            }
            totalLevelText.text = levelText;
            Debug.Log($"Updated total level display: {levelText}");
        }
    }
​
    public void RefreshUI()
    {
        Debug.Log("Refreshing all skill displays");
        if (cachedPlayerSkills != null)
        {
            foreach (var skill in cachedPlayerSkills.Skills)
            {
                UpdateSkillDisplay(
                    skill.SkillName,
                    skill.CurrentLevel,
                    skill.CurrentXP,
                    skill.XPToNextLevel
                );
            }
        }
        else
        {
            Debug.LogError("Cannot refresh UI - PlayerSkills reference is null");
        }
    }
}
using UnityEngine;
​
[CreateAssetMenu(fileName = "New Tool", menuName = "RVAMP/Items/Tool")]
public class Tool : Item
{
    [Header("Tool Properties")]
    // Remove the duplicate toolType declaration
    public float toolEfficiency = 1f;
    public int requiredLevel = 1;
    public int tier = 1;
​
    public float GetEfficiencyMultiplier(int skillLevel)
    {
        // Base efficiency is 1.0
        float baseMultiplier = 1f;
        
        // Tool tier adds 10% per tier
        float tierBonus = tier * 0.1f;
        
        // Skill level adds 1% per level
        float skillBonus = skillLevel * 0.01f;
        
        // Tool efficiency is a direct multiplier
        return (baseMultiplier + tierBonus + skillBonus) * toolEfficiency;
    }
}
public enum ToolType
{
    None,
    Axe,
    Pickaxe,
    FishingRod,
    Shovel,
    Hammer
}
public enum TreeType
{
    Normal,
    Oak,
    Willow,
    Maple,
    Yew,
    Magic
}
using UnityEngine;
using UnityEngine.UI;
using UnityEngine.EventSystems;
​
public class UIDebugHelper : MonoBehaviour
{
    public Canvas targetCanvas;
    public GameObject contextMenuPanel;
    public RectTransform menuContainer;
    public EventSystem eventSystem;
​
    [Header("Debug Options")]
    public bool showDebugVisuals = true;
    public Color debugColor = Color.yellow;
    
    private void OnGUI()
    {
        if (!showDebugVisuals) return;
​
        GUILayout.BeginArea(new Rect(10, 10, 300, 500));
        GUILayout.Label("=== UI Debug Info ===");
        
        if (targetCanvas != null)
        {
            GUILayout.Label($"Canvas Mode: {targetCanvas.renderMode}");
            GUILayout.Label($"Sort Order: {targetCanvas.sortingOrder}");
            GUILayout.Label($"Pixel Perfect: {targetCanvas.pixelPerfect}");
            GUILayout.Label($"Scale Factor: {targetCanvas.scaleFactor}");
        }
        else
        {
            GUILayout.Label("No Canvas assigned!");
        }
​
        if (contextMenuPanel != null)
        {
            var rect = contextMenuPanel.GetComponent<RectTransform>();
            GUILayout.Label($"Menu Active: {contextMenuPanel.activeSelf}");
            GUILayout.Label($"Menu Position: {rect.position}");
            GUILayout.Label($"Menu Size: {rect.sizeDelta}");
            GUILayout.Label($"Menu Scale: {rect.localScale}");
            
            var canvasGroup = contextMenuPanel.GetComponent<CanvasGroup>();
            if (canvasGroup != null)
            {
                GUILayout.Label($"Alpha: {canvasGroup.alpha}");
                GUILayout.Label($"Interactable: {canvasGroup.interactable}");
                GUILayout.Label($"Blocks Raycasts: {canvasGroup.blocksRaycasts}");
            }
        }
        else
        {
            GUILayout.Label("No Context Menu Panel assigned!");
        }
​
        if (eventSystem != null)
        {
            GUILayout.Label($"EventSystem enabled: {eventSystem.enabled}");
            GUILayout.Label($"Current Selected: {eventSystem.currentSelectedGameObject?.name ?? "none"}");
            GUILayout.Label($"Mouse Position: {Input.mousePosition}");
            GUILayout.Label($"Over UI: {eventSystem.IsPointerOverGameObject()}");
        }
        else
        {
            GUILayout.Label("No EventSystem found!");
        }
​
        GUILayout.EndArea();
    }
​
  private void OnDrawGizmos()
    {
        if (!showDebugVisuals || contextMenuPanel == null) return;
​
        var rect = contextMenuPanel.GetComponent<RectTransform>();
        var corners = new Vector3[4];
        rect.GetWorldCorners(corners);
        
        Gizmos.color = debugColor;
        for (int i = 0; i < 4; i++)
        {
            Gizmos.DrawLine(corners[i], corners[(i + 1) % 4]);
        }
    }
​
    [UnityEngine.ContextMenu("Fix Common Issues")]
    public void FixCommonIssues()
    {
        if (targetCanvas != null)
        {
            targetCanvas.renderMode = RenderMode.ScreenSpaceOverlay;
            targetCanvas.sortingOrder = 100;
        }
​
        if (contextMenuPanel != null)
        {
            var rect = contextMenuPanel.GetComponent<RectTransform>();
            rect.localScale = Vector3.one;
            
            var canvasGroup = contextMenuPanel.GetComponent<CanvasGroup>();
            if (canvasGroup != null)
            {
                canvasGroup.alpha = 1;
                canvasGroup.interactable = true;
                canvasGroup.blocksRaycasts = true;
            }
        }
​
        if (eventSystem == null)
        {
            eventSystem = FindFirstObjectByType<EventSystem>();
            if (eventSystem == null)
            {
                var eventSystemObj = new GameObject("EventSystem");
                eventSystem = eventSystemObj.AddComponent<EventSystem>();
                eventSystemObj.AddComponent<StandaloneInputModule>();
            }
        }
    }
}
using UnityEngine;
using UnityEngine.UI;
using System.Collections.Generic;
​
public class UIManager : MonoBehaviour
{
    public static UIManager Instance { get; private set; }
​
    [Header("Panel References")]
    public GameObject inventoryPanel;
    public GameObject equipmentPanel;
    public GameObject skillsPanel;
    public GameObject settingsPanel;
​
    [Header("Skills UI Reference")]
    public SkillsUI skillsUI;
​
    private GameObject currentActivePanel;
​
    private void Awake()
    {
        if (Instance == null)
        {
            Instance = this;
        }
        else
        {
            Destroy(gameObject);
        }
    }
​
    private void Start()
    {
        HideAllPanels();
        
        if (skillsUI == null)
        {
            skillsUI = skillsPanel?.GetComponent<SkillsUI>();
        }
    }
​
        public void ToggleSkillsPanel()
    {
        if (skillsPanel != null)
        {
            bool isActive = !skillsPanel.activeSelf;
            skillsPanel.SetActive(isActive);
            
            if (isActive && skillsUI != null)
            {
                skillsUI.RefreshUI();
            }
        }
    }
​
    public void TogglePanel(GameObject panel)
    {
        if (currentActivePanel == panel)
        {
            panel.SetActive(false);
            currentActivePanel = null;
        }
        else
        {
            if (currentActivePanel != null)
            {
                currentActivePanel.SetActive(false);
            }
            panel.SetActive(true);
            currentActivePanel = panel;
        }
    }
​
public void UpdateSkillUI(string skillName, int level, int currentXP, int xpToNextLevel)
{
    Debug.Log($"UIManager.UpdateSkillUI called for {skillName}");
    if (skillsUI == null)
    {
        Debug.LogError("SkillsUI reference is null in UIManager!");
        return;
    }
    skillsUI.UpdateSkillDisplay(skillName, level, currentXP, xpToNextLevel);
}
    public void OpenSkillGuide(string skillName)
{
    Debug.Log($"Opening skill guide for {skillName}");
    // Add logic to open the skill guide UI
}
​
    public void HideAllPanels()
    {
        if (inventoryPanel) inventoryPanel.SetActive(false);
        if (equipmentPanel) equipmentPanel.SetActive(false);
        if (skillsPanel) skillsPanel.SetActive(false);
        if (settingsPanel) settingsPanel.SetActive(false);
        currentActivePanel = null;
    }
}
using UnityEngine;
using System.Collections.Generic;
​
public class VisibleEquipmentManager : MonoBehaviour 
{
    [System.Serializable]
    public class EquipmentSocket 
    {
        public EquipmentSlot slot;
        public Transform mountPoint;
        [Header("Equipment Positioning")]
        public Vector3 positionOffset = new Vector3(0, 0, 0);
        public Vector3 rotationOffset = new Vector3(0, -90, 0);
        public Vector3 scale = Vector3.one;
    }
​
    [Header("Equipment Setup")]
    public List<EquipmentSocket> equipmentSockets;
    private Dictionary<EquipmentSlot, GameObject> equippedModels = new Dictionary<EquipmentSlot, GameObject>();
​
    private void Start()
    {
        // Subscribe to equipment change events
        var equipmentManager = EquipmentManager.Instance;
        if (equipmentManager != null)
        {
            equipmentManager.OnEquipmentChanged += HandleEquipmentChanged;
        }
    }
​
    private void HandleEquipmentChanged(EquipmentSlot slot, Item item)
    {
        Debug.Log($"Handling equipment change for slot {slot}");
        
        // Remove existing model
        if (equippedModels.TryGetValue(slot, out GameObject existingModel))
        {
            Destroy(existingModel);
            equippedModels.Remove(slot);
        }
​
        // Handle new equipment
        if (item != null && item is CombatEquipment combatEquip)
        {
            var socket = equipmentSockets.Find(s => s.slot == slot);
            if (socket != null && socket.mountPoint != null && combatEquip.equipmentModel != null)
            {
                try
                {
                    GameObject model = Instantiate(combatEquip.equipmentModel, socket.mountPoint);
                    model.transform.localPosition = socket.positionOffset;
                    model.transform.localRotation = Quaternion.Euler(socket.rotationOffset);
                    model.transform.localScale = socket.scale;
                    
                    equippedModels[slot] = model;
                    Debug.Log($"Successfully created visual model for {item.itemName}");
                }
                catch (System.Exception e)
                {
                    Debug.LogError($"Error creating equipment model: {e.Message}");
                }
            }
            else
            {
                Debug.LogWarning($"Missing socket configuration for {slot} or equipment model for {item.itemName}");
            }
        }
    }
​
    private void OnDestroy()
    {
        if (EquipmentManager.Instance != null)
        {
            EquipmentManager.Instance.OnEquipmentChanged -= HandleEquipmentChanged;
        }
    }
}
using UnityEngine;
​
[System.Serializable]
public class WeaponAttackStyle
{
    public string styleName;
    public AttackStyle attackStyle;           // Stab, Slash, etc.
    public CombatTrainingStyle trainingStyle; // Precision, Might, etc.
    public bool splitXPWithFortitude;         // Whether to split XP with Fortitude
    public float accuracyModifier = 1f;       // Affects hit chance
    public float damageModifier = 1f;         // Affects max hit
    public float experienceMultiplier = 4f;   // Standard RS multiplier
    
    // Helper method to determine combat style
    public CombatStyle GetCombatStyle()
    {
        return attackStyle switch
        {
            AttackStyle.Stab or AttackStyle.Slash or AttackStyle.Crush => CombatStyle.Melee,
            AttackStyle.Range => CombatStyle.Ranged,
            AttackStyle.Spellweaving => CombatStyle.Magic,
            _ => CombatStyle.Melee
        };
    }
}
using UnityEngine;
​
[CreateAssetMenu(fileName = "New Weapon", menuName = "Combat/Weapon")]
public class WeaponData : CombatEquipment
{
    [Header("Weapon Properties")]
    public WeaponType weaponType;
    public CombatConfig combatConfig;
​
    [Header("Attack Properties")]
    public float baseAttackSpeed = 2.4f;
    public bool hasSpecialAttack;
    [Range(0, 100)]
    public int specialAttackCost = 50;
​
    [Header("Combat Training")]
    public CombatTrainingStyle primaryTrainingStyle; // Add this field
    public CombatTrainingStyle[] availableTrainingStyles;
    public bool allowFortitudeTraining = true;
    public float accuracyModifier = 1f;
    public float damageModifier = 1f;
​
    
​
    private void OnEnable()
    {
        itemType = ItemType.Equipment;
        equipSlot = EquipmentSlot.MainHand;
        SetupCombatConfig();
    }
​
    private void SetupCombatConfig()
    {
        if (combatConfig == null)
        {
            combatConfig = CreateInstance<CombatConfig>();
            combatConfig.baseAttackInterval = baseAttackSpeed;
            combatConfig.primaryStyle.attackStyle = defaultAttackStyle;
            combatConfig.primaryStyle.trainingStyle = primaryTrainingStyle;
            combatConfig.primaryStyle.splitXPWithFortitude = allowFortitudeTraining;
        }
    }
​
    public int CalculateMaxHit(PlayerSkills skills)
    {
        if (skills == null) return 0;
​
        switch (defaultAttackStyle)
        {
            case AttackStyle.Stab:
            case AttackStyle.Slash:
            case AttackStyle.Crush:
                var mightSkill = skills.GetSkill("Might");
                if (mightSkill == null) return 0;
                return Mathf.FloorToInt(0.5f + (mightSkill.CurrentLevel * (bonuses.mightBonus + 64)) / 640f);
​
            case AttackStyle.Range:
                var rangeSkill = skills.GetSkill("Range");
                if (rangeSkill == null) return 0;
                return Mathf.FloorToInt(0.5f + (rangeSkill.CurrentLevel * (bonuses.rangeStrengthBonus + 64)) / 640f);
​
            case AttackStyle.Spellweaving:
                int baseSpellDamage = 10;
                return Mathf.FloorToInt(baseSpellDamage * (1 + bonuses.spellweavingDamage / 100f));
​
            default:
                return 0;
        }
    }
​
    public float CalculateHitChance(PlayerSkills skills, CombatStats targetStats)
    {
        if (skills == null || targetStats == null) return 0f;
​
        var attackSkill = GetAttackSkill(skills);
        if (attackSkill == null) return 0f;
​
        float effectiveAccuracy = attackSkill.CurrentLevel + bonuses.GetAttackBonus(defaultAttackStyle);
        float effectiveFortitude = targetStats.Fortitude + targetStats.GetDefenseBonus(defaultAttackStyle);
​
        return effectiveAccuracy / (effectiveAccuracy + effectiveFortitude);
    }
​
    private Skill GetAttackSkill(PlayerSkills skills)
    {
        return defaultAttackStyle switch
        {
            AttackStyle.Stab or AttackStyle.Slash or AttackStyle.Crush => skills.GetSkill("Precision"),
            AttackStyle.Range => skills.GetSkill("Range"),
            AttackStyle.Spellweaving => skills.GetSkill("Spellweaving"),
            _ => null
        };
    }
​
    public int RollDamage(int maxHit)
    {
        float randomFactor = Random.value;
        return Mathf.Max(10, Mathf.FloorToInt(10 + (maxHit - 10) * randomFactor));
    }
}
using UnityEngine;
using System.Collections.Generic;
public enum WeaponType
{
    Unarmed,
    Sword,
    Dagger,
    Mace,
    Bow,
    Crossbow,
    Staff,
    Wand
}
using UnityEngine;
​
public class Woodcutting : BaseSkillAction
{
    [Header("Woodcutting Specific")]
    public ParticleSystem woodchipsEffect;
    private ChoppableTree currentTree;
​
    protected override void Start()
    {
        base.Start();
        requiredSkillName = "Woodcutting";
        requiredToolType = ToolType.Axe;
        Debug.Log("[Woodcutting] Initialized woodcutting skill action.");
    }
​
    public override void SetTarget(ResourceNode target)
    {
        if (target is ChoppableTree tree)
        {
            base.SetTarget(target);
            currentTree = tree;
            Debug.Log($"[Woodcutting] Targeting tree: {tree.name}");
        }
        else
        {
            Debug.LogError("[Woodcutting] Invalid target type. Expected ChoppableTree.");
            currentTree = null;
        }
    }
​
    protected override string GetAnimationTrigger() => "isChopping";
​
    protected virtual void PlayWoodchipsEffect()
    {
        if (woodchipsEffect != null)
        {
            woodchipsEffect.Play();
            Debug.Log("Playing woodchips effect.");
        }
    }
​
    protected override bool ProcessAction()
    {
        if (currentTarget != null && currentTarget.IsRespawning)
        {
            Debug.Log($"[{requiredSkillName}] Cannot gather - resource is respawning");
            StopAction();
            return false;
        }
​
        if (currentTree == null || !currentTree.HasResources())
        {
            Debug.Log("[Woodcutting] No tree target or tree depleted!");
            StopAction();
            return false;
        }
​
        Tool currentAxe = inventory.GetToolOfType(requiredToolType) as Tool;
        if (currentAxe == null)
        {
            Debug.Log("[Woodcutting] No axe found in inventory!");
            NotifyPlayer("You need an axe to chop wood.");
            StopAction();
            return false;
        }
​
        if (currentTree.Gather(currentAxe))
        {
            Debug.Log("[Woodcutting] Successfully chopped wood from tree.");
            PlayWoodchipsEffect();
            inventory.AddItem(currentTree.primaryResource, 1);
            playerSkills.AddExperience(requiredSkillName, currentTree.baseXP);
            return true;
        }
​
        Debug.Log("[Woodcutting] Failed to chop wood.");
        StopAction();
        return false;
    }
​
    public override void StopAction()
    {
        base.StopAction();
        currentTree = null;
        SetAnimationState(false);
    }
}
using UnityEngine;
using UnityEngine.EventSystems;
using System;
using System.Collections.Generic;
​
public class WorldInteractable : MonoBehaviour
{
    public string objectName = "Object";
    public string examineText;
​
    private List<ContextMenuOption> orderedOptions = new List<ContextMenuOption>();
    private Dictionary<string, (Action action, Func<bool> condition)> customOptions = 
        new Dictionary<string, (Action, Func<bool>)>();
​
    void Start()
    {
        InitializeDefaultOptions();
    }
​
private void InitializeDefaultOptions()
{
    // Add Walk Here as a standard option (except for inventory items)
    if (!gameObject.GetComponent<InventoryItemUI>())
    {
        AddCustomOption("Walk here", () => {
            var clickToMove = FindFirstObjectByType<ClickToMove>();
            if (clickToMove != null)
            {
                Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
                if (Physics.Raycast(ray, out RaycastHit hit, Mathf.Infinity, LayerMask.GetMask("Ground", "Terrain")))
                {
                    if (UnityEngine.AI.NavMesh.SamplePosition(hit.point, out UnityEngine.AI.NavMeshHit navHit, 2f, UnityEngine.AI.NavMesh.AllAreas))
                    {
                        clickToMove.MoveToTarget(navHit.position);
                    }
                }
            }
        }, null, 900);
    }
​
    // Add Examine as a standard option (except for ground)
    if (gameObject.layer != LayerMask.NameToLayer("Ground"))
    {
        AddCustomOption("Examine", () => {
            string displayText = !string.IsNullOrEmpty(examineText) 
                ? examineText 
                : $"You examine the {objectName}.";
            EnhancedChatbox.Instance?.AddMessage(displayText);
        }, null, 950);
    }
}
​
    public void AddCustomOption(string optionName, Action action, Func<bool> condition = null, int priority = 0)
    {
        // Store the option with its condition
        customOptions[optionName] = (action, condition ?? (() => true));
        
        // Create and insert the option in priority order
        var option = new ContextMenuOption(optionName, action);
        
        // Find the correct position to insert based on priority
        int insertIndex = 0;
        while (insertIndex < orderedOptions.Count && 
               GetOptionPriority(orderedOptions[insertIndex].Text) <= priority)
        {
            insertIndex++;
        }
        
        orderedOptions.Insert(insertIndex, option);
    }
​
private int GetOptionPriority(string optionName)
{
    // Define priorities for different types of actions
    switch (optionName.ToLower())
    {
        case var s when s.StartsWith("attack"): return 0;
        case var s when s.StartsWith("pick up"): return 100;
        case var s when s.StartsWith("chop"): return 200;
        case var s when s.StartsWith("mine"): return 200;
        case var s when s.StartsWith("equip"): return 300;
        case var s when s.StartsWith("drink"): return 300;
        case var s when s.StartsWith("eat"): return 300;
        case var s when s.StartsWith("use"): return 400;
        case "walk here": return 900;
        case "examine": return 950;
        case "cancel": return 1000;
        default: return 500; // Default priority for custom actions
    }
}
​
    void OnMouseOver()
    {
        // Handle left click for primary action
        if (Input.GetMouseButtonDown(0))
        {
            if (!EventSystem.current.IsPointerOverGameObject())
            {
                ExecutePrimaryAction();
            }
        }
        // Handle right click for context menu
        else if (Input.GetMouseButtonDown(1))
        {
            if (!EventSystem.current.IsPointerOverGameObject() || 
                (ContextMenu.Instance != null && ContextMenu.Instance.IsClickingMenuItem()))
            {
                ShowContextMenu();
            }
        }
    }
​
    private void ExecutePrimaryAction()
    {
        // Execute the first available action in the ordered list
        foreach (var option in orderedOptions)
        {
            if (customOptions.TryGetValue(option.Text, out var optionData))
            {
                if (optionData.condition())
                {
                    optionData.action?.Invoke();
                    return;
                }
            }
        }
    }
​
    private List<ContextMenuOption> GetAvailableOptions()
    {
        List<ContextMenuOption> availableOptions = new List<ContextMenuOption>();
​
        foreach (var option in orderedOptions)
        {
            if (customOptions.TryGetValue(option.Text, out var optionData))
            {
                if (optionData.condition())
                {
                    availableOptions.Add(option);
                }
            }
        }
​
        // Add Cancel option at the end
        availableOptions.Add(new ContextMenuOption("Cancel", () => {
            if (ContextMenu.Instance != null)
            {
                ContextMenu.Instance.HideMenu();
            }
        }));
​
        return availableOptions;
    }
​
private void ShowContextMenu()
{
    if (ContextMenu.Instance == null)
    {
        Debug.LogError("ContextMenu.Instance is null! Ensure ContextMenu prefab is in the scene.");
        return;
    }
​
    List<ContextMenuOption> availableOptions = GetAvailableOptions();
    if (availableOptions.Count > 0)
    {
        ContextMenu.Instance.ShowMenu(Input.mousePosition, availableOptions);
    }
}
}
using UnityEngine;
using UnityEngine.AI;
using System.Collections;
​
public abstract class BaseSkillAction : MonoBehaviour
{
    [Header("Basic Settings")]
    public float actionDistance = 2.0f;
    public float baseActionInterval = 3f;
    public float animationDuration = 0.8f;
​
    [Header("Requirements")]
    public ToolType requiredToolType;
    public int minimumLevel = 1;
    public string requiredSkillName;
​
    [Header("Audio")]
    public AudioClip[] actionSounds;
​
    public bool IsPerformingAction => isPerformingAction;
    private float lastSoundTime = 0f;
    private float soundCooldown = 1f;
    private SkillsAudioManager skillsAudioManager;
​
    protected NavMeshAgent agent;
    protected Animator animator;
    protected Inventory inventory;
    protected PlayerSkills playerSkills;
    protected ResourceNode currentTarget;
    protected bool isPerformingAction = false;
    protected bool isWalkingToTarget = false;
    private bool shouldStopAction = false;
​
    private Coroutine actionCoroutine;
​
    protected virtual void Start()
    {
        agent = GetComponent<NavMeshAgent>();
        animator = GetComponent<Animator>();
        inventory = Inventory.Instance;
        playerSkills = GetComponent<PlayerSkills>();
        skillsAudioManager = FindFirstObjectByType<SkillsAudioManager>();
​
        ValidateComponents();
    }
​
    protected virtual void ValidateComponents()
    {
        if (agent == null) Debug.LogError($"NavMeshAgent missing on {gameObject.name}");
        if (animator == null) Debug.LogError($"Animator missing on {gameObject.name}");
        if (inventory == null) Debug.LogError("Inventory not found");
        if (playerSkills == null) Debug.LogError("PlayerSkills not found");
    }
​
    protected virtual void Update()
    {
        if (isWalkingToTarget && currentTarget != null)
            CheckArrivalAtTarget();
    }
​
public virtual void SetTarget(ResourceNode target)
{
    if (isPerformingAction && currentTarget == target)
    {
        Debug.Log($"[BaseSkillAction] Already gathering from {target?.name}, skipping reset.");
        return;
    }
​
    Debug.Log($"[BaseSkillAction] Setting new target: {target?.name}");
​
    if (isPerformingAction)
    {
        Debug.Log($"[BaseSkillAction] Stopping current action before setting new target");
        StopAction();
    }
​
    UnsubscribeFromResourceEvents();
    currentTarget = target;
    
    if (currentTarget != null)
    {
        Debug.Log($"Setting target and walking to {target.name}");
        agent.stoppingDistance = actionDistance;
        agent.SetDestination(target.transform.position);
        agent.isStopped = false;
        isWalkingToTarget = true;
        SubscribeToResourceEvents();
    }
}
​
    protected virtual void CheckArrivalAtTarget()
    {
        if (currentTarget == null || agent.pathPending) return;
​
        float distanceToTarget = Vector3.Distance(transform.position, currentTarget.transform.position);
        if (distanceToTarget <= actionDistance && !isPerformingAction)
        {
            Debug.Log("Arrived at target, starting action");
            isWalkingToTarget = false;
            agent.isStopped = true;
            FaceTarget();
            StartAction();
        }
    }
​
    protected virtual void FaceTarget()
    {
        if (currentTarget == null) return;
​
        Vector3 directionToTarget = (currentTarget.transform.position - transform.position).normalized;
        Quaternion targetRotation = Quaternion.LookRotation(new Vector3(directionToTarget.x, 0, directionToTarget.z));
        transform.rotation = targetRotation;
    }
​
    protected virtual void StartAction()
    {
        if (!CanPerformAction() || isPerformingAction)
            return;
​
        Debug.Log("Starting gathering action");
        isPerformingAction = true;
​
        if (actionCoroutine != null)
            StopCoroutine(actionCoroutine);
​
        actionCoroutine = StartCoroutine(ActionRoutine());
    }
​
    protected virtual bool CanPerformAction()
    {
    if (currentTarget != null && (!currentTarget.IsValidForGathering() || currentTarget.IsRespawning))
    {
        Debug.Log($"[{requiredSkillName}] Cannot gather - resource is respawning or depleted");
        StopAction();
        return false;
    }
​
        if (!HasRequiredTool())
        {
            NotifyPlayer($"You need a {requiredToolType} to perform this action.");
            return false;
        }
​
        Skill skill = playerSkills.GetSkill(requiredSkillName);
        if (skill == null)
        {
            Debug.LogError($"Skill {requiredSkillName} not found!");
            return false;
        }
​
        if (minimumLevel > 1 && skill.CurrentLevel < minimumLevel)
        {
            NotifyPlayer($"You need level {minimumLevel} {requiredSkillName} to perform this action.");
            return false;
        }
​
        return true;
    }
​
    protected virtual bool HasRequiredTool()
    {
        if (requiredToolType == ToolType.None) return true;
​
        Tool tool = inventory.GetToolOfType(requiredToolType);
        if (tool != null)
        {
            Debug.Log($"Found required tool: {tool.itemName}");
            return true;
        }
​
        Debug.Log($"Required tool of type {requiredToolType} not found in inventory.");
        return false;
    }
​
    protected virtual IEnumerator ActionRoutine()
    {
        Debug.Log($"[{requiredSkillName}] Starting action routine");
        float nextActionTime = 0f;
        shouldStopAction = false;
​
        while (!shouldStopAction && isPerformingAction && CanPerformAction())
        {
            if (Time.time >= nextActionTime)
            {
                if (currentTarget == null || currentTarget.IsRespawning)
                {
                    Debug.Log($"[{requiredSkillName}] Target is null or respawning, stopping action");
                    shouldStopAction = true;
                    break;
                }
​
                PlayActionSound();
                SetAnimationState(true);
                
                yield return new WaitForSeconds(animationDuration);
​
                if (ProcessAction())
                {
                    SetAnimationState(false);
                    nextActionTime = Time.time + baseActionInterval;
                    
                    float remainingInterval = baseActionInterval - animationDuration;
                    if (remainingInterval > 0)
                    {
                        yield return new WaitForSeconds(remainingInterval);
                    }
                }
                else
                {
                    shouldStopAction = true;
                    break;
                }
            }
            yield return null;
        }
​
        Debug.Log($"[{requiredSkillName}] Exiting action routine");
        StopAction();
    }
​
    protected virtual void PlayActionSound()
    {
        if (skillsAudioManager != null && actionSounds != null && actionSounds.Length > 0)
        {
            if (Time.time - lastSoundTime >= soundCooldown)
            {
                AudioClip randomSound = actionSounds[Random.Range(0, actionSounds.Length)];
                skillsAudioManager.PlaySkillSound(randomSound);
                lastSoundTime = Time.time;
            }
        }
    }
​
    protected void UnsubscribeFromResourceEvents()
    {
        if (currentTarget != null)
        {
            currentTarget.OnRespawnStarted -= HandleResourceRespawnStarted;
            currentTarget.OnRespawnCompleted -= HandleResourceRespawnCompleted;
        }
    }
​
    protected virtual void HandleResourceRespawnStarted(ResourceNode resource)
    {
        if (resource == currentTarget)
        {
            Debug.Log($"[{requiredSkillName}] Resource entered respawn state, stopping action");
            StopAction();
        }
    }
​
    protected virtual void HandleResourceRespawnCompleted(ResourceNode resource)
    {
        Debug.Log($"[{requiredSkillName}] Resource has respawned");
    }
​
    protected virtual void SubscribeToResourceEvents()
    {
        if (currentTarget != null)
        {
            currentTarget.OnRespawnStarted += HandleResourceRespawnStarted;
            currentTarget.OnRespawnCompleted += HandleResourceRespawnCompleted;
        }
    }
​
    public virtual void StopAction()
    {
        if (!isPerformingAction) return;
​
        Debug.Log($"[{requiredSkillName}] Stopping action");
        shouldStopAction = true;
        isPerformingAction = false;
        SetAnimationState(false);
​
        if (actionCoroutine != null)
        {
            StopCoroutine(actionCoroutine);
            actionCoroutine = null;
        }
​
        if (agent != null)
        {
            agent.ResetPath();
        }
​
        UnsubscribeFromResourceEvents();
    }
​
    protected abstract bool ProcessAction();
​
    protected virtual void NotifyPlayer(string message)
    {
        EnhancedChatbox.Instance?.AddMessage(message);
    }
​
    protected virtual void SetAnimationState(bool active)
    {
        if (animator != null)
        {
            string trigger = GetAnimationTrigger();
            if (!string.IsNullOrEmpty(trigger))
            {
                animator.SetBool(trigger, active);
            }
        }
    }
​
    protected abstract string GetAnimationTrigger();
}
using UnityEngine;
using UnityEngine.AI;
using System.Collections;
​
[RequireComponent(typeof(NavMeshAgent))]
public class BasicNPC : MonoBehaviour, ICombatant
{
    [Header("NPC Base Stats")]
    public string npcName = "Training Dummy";
    public int level = 1;
    public int baseVitality = 100;
    private CombatStats stats;
    
    [Header("Combat Configuration")]
    public float attackRange = 2f;
    public float attackSpeed = 2.4f;
    public AttackStyle defaultAttackStyle = AttackStyle.Slash;
    public float baseXPValue = 40f;
    
    [Header("Combat Bonuses")]
    public CombatBonuses bonuses = new CombatBonuses();
​
    [Header("Behavior Settings")]
    public float aggroRange = 5f;
    public bool isAggressive = false;
    
    // State tracking
    private bool isAlive = true;
    private bool isInCombat = false;
    private NavMeshAgent agent;
    private ICombatant currentTarget;
    private float nextAttackTime;
    private Animator animator;
​
    // ICombatant interface implementation
    public CombatStats Stats => stats;
    public bool IsAlive => isAlive;
    public new Transform transform => base.transform;
    public string GetDisplayName() => npcName;
​
    private void Start()
    {
        InitializeComponents();
        InitializeStats();
        SetupInteraction();
        StartCoroutine(BehaviorRoutine());
    }
​
    private void InitializeComponents()
    {
        agent = GetComponent<NavMeshAgent>();
        animator = GetComponent<Animator>();
        
        if (agent == null)
            Debug.LogError($"NavMeshAgent missing on {npcName}!");
    }
​
    private void InitializeStats()
    {
        // Calculate scaled stats based on level
        int scaledVitality = baseVitality + (level * 4);
        int scaledPrecision = level;
        int scaledMight = level;
        int scaledFortitude = level;
        int scaledRange = level;
        int scaledSpellweaving = level;
        int scaledDivinity = level;
​
        stats = new CombatStats(
            vitality: scaledVitality,
            precision: scaledPrecision,
            might: scaledMight,
            fortitude: scaledFortitude,
            range: scaledRange,
            spellweaving: scaledSpellweaving,
            divinity: scaledDivinity
        );
​
        // Apply any additional bonuses
        stats.combatBonuses = bonuses;
        
        Debug.Log($"Initialized {npcName} (Level {level}) - " +
                 $"Vitality: {stats.Vitality}, " +
                 $"Combat Style: {defaultAttackStyle}");
    }
​
    private void SetupInteraction()
    {
        var interactable = gameObject.AddComponent<WorldInteractable>();
        interactable.objectName = npcName;
        
        // Add attack option
        interactable.AddCustomOption("Attack", () => {
            var player = GameObject.FindGameObjectWithTag("Player");
            if (player != null)
            {
                var playerCombat = player.GetComponent<CombatHandler>();
                if (playerCombat != null)
                {
                    playerCombat.StartCombat(this);
                }
            }
        });
    }
​
    private IEnumerator BehaviorRoutine()
    {
        while (isAlive)
        {
            if (isAggressive && !isInCombat)
            {
                CheckForTargets();
            }
​
            if (isInCombat)
            {
                UpdateCombat();
            }
​
            yield return new WaitForSeconds(0.5f);
        }
    }
​
    private void CheckForTargets()
    {
        var player = GameObject.FindGameObjectWithTag("Player");
        if (player != null)
        {
            float distance = Vector3.Distance(transform.position, player.transform.position);
            if (distance <= aggroRange)
            {
                var playerCombat = player.GetComponent<ICombatant>();
                if (playerCombat != null && playerCombat.IsAlive)
                {
                    StartCombat(playerCombat);
                }
            }
        }
    }
​
    private void UpdateCombat()
    {
        if (currentTarget == null || !currentTarget.IsAlive)
        {
            EndCombat();
            return;
        }
​
        float distance = Vector3.Distance(transform.position, currentTarget.transform.position);
        
        // Move towards target if too far
        if (distance > attackRange)
        {
            agent.SetDestination(currentTarget.transform.position);
        }
        else
        {
            agent.ResetPath();
            if (Time.time >= nextAttackTime)
            {
                Attack(currentTarget);
            }
        }
    }
​
    public void Attack(ICombatant target)
    {
        if (!IsAlive || target == null || !target.IsAlive) return;
​
        // Set up attack configuration
        var attackStyle = new WeaponAttackStyle
        {
            styleName = $"{npcName} Attack",
            attackStyle = defaultAttackStyle,
            trainingStyle = CombatTrainingStyle.Precision,
            accuracyModifier = 1f,
            damageModifier = 1f
        };
​
        // Calculate accuracy
        float accuracy = CombatCalculator.CalculateAccuracy(this, target, attackStyle);
        
        // Perform attack
        if (Random.value < accuracy)
        {
            int damage = CalculateDamage();
            target.TakeDamage(damage, defaultAttackStyle);
            Debug.Log($"{npcName} hit {target.GetDisplayName()} for {damage} damage!");
​
            // Play hit effects
            if (target is MonoBehaviour targetObj)
            {
                var combatHandler = targetObj.GetComponent<CombatHandler>();
                combatHandler?.PlayHitEffect(targetObj.transform.position);
                combatHandler?.PlayCombatSound(true);
            }
        }
        else
        {
            Debug.Log($"{npcName} missed their attack against {target.GetDisplayName()}!");
            if (target is MonoBehaviour targetObj)
            {
                var combatHandler = targetObj.GetComponent<CombatHandler>();
                combatHandler?.PlayCombatSound(false);
            }
        }
​
        nextAttackTime = Time.time + attackSpeed;
​
        // Update animation if available
        if (animator != null)
        {
            animator.SetTrigger("Attack");
        }
    }
​
    private int CalculateDamage()
    {
        int maxHit = stats.CalculateMaxHit(defaultAttackStyle);
        return Random.Range(1, maxHit + 1);
    }
​
    public void TakeDamage(int damage, AttackStyle style)
    {
        if (!IsAlive) return;
​
        stats.ModifyVitality(-damage);
        Debug.Log($"{npcName} took {damage} damage! Vitality: {stats.Vitality}/{stats.MaxVitality}");
​
        if (!stats.IsAlive)
        {
            Die();
        }
    }
​
    public AttackStyle GetCurrentCombatStyle()
    {
        return defaultAttackStyle;
    }
    public float GetAttackSpeed()
    {
        return attackSpeed;
    }
​
    private void StartCombat(ICombatant target)
    {
        currentTarget = target;
        isInCombat = true;
        
        if (animator != null)
        {
            animator.SetBool("InCombat", true);
        }
    }
​
    private void EndCombat()
    {
        currentTarget = null;
        isInCombat = false;
        agent.ResetPath();
        
        if (animator != null)
        {
            animator.SetBool("InCombat", false);
        }
    }
​
    private void Die()
    {
        isAlive = false;
        EndCombat();
        
        if (animator != null)
        {
            animator.SetTrigger("Death");
        }
​
        // Grant combat XP to player if killed by player
        var player = GameObject.FindGameObjectWithTag("Player");
        if (player != null)
        {
            var playerSkills = player.GetComponent<PlayerSkills>();
            if (playerSkills != null)
            {
                // Calculate XP based on NPC's level and base XP value
                float scaledXP = baseXPValue * (1 + level * 0.1f);
                playerSkills.AddExperience("Precision", scaledXP);
                EnhancedChatbox.Instance?.AddMessage($"Defeated {npcName}! Gained {scaledXP:F1} Combat experience!");
            }
        }
​
        // Remove interactability
        var interactable = GetComponent<WorldInteractable>();
        if (interactable != null)
        {
            Destroy(interactable);
        }
​
        // Destroy after delay to show death animation
        StartCoroutine(DeathSequence());
    }
​
    private IEnumerator DeathSequence()
    {
        // Wait for death animation
        yield return new WaitForSeconds(2f);
        
        // TODO: Drop loot here
        
        // Destroy the NPC
        Destroy(gameObject);
    }
​
    private void OnDrawGizmosSelected()
    {
        // Visualize attack range
        Gizmos.color = Color.red;
        Gizmos.DrawWireSphere(transform.position, attackRange);
        
        // Visualize aggro range
        if (isAggressive)
        {
            Gizmos.color = Color.yellow;
            Gizmos.DrawWireSphere(transform.position, aggroRange);
        }
    }
}
using UnityEngine;
using System.Collections;
​
public class ChoppableTree : ResourceNode
{
    [Header("Woodcutting Specific")]
    public TreeType treeType;
    public int birdNestChance = 5; // Percentage chance for bird's nests
​
    [Header("Tree Effects")]
    public ParticleSystem woodchipsParticles;
    public GameObject treeStump;
    public GameObject fallingTreeEffect;
    private Material originalMaterial;
​
    protected override void Initialize()
    {
        base.Initialize();
        if (resourceRenderer != null)
        {
            originalMaterial = resourceRenderer.material;
        }
        requiredToolType = ToolType.Axe; // Set the required tool type for chopping trees
    }
​
    public override bool Gather(Tool tool)
    {
        if (!base.Gather(tool)) return false;
​
        if (woodchipsParticles != null)
        {
            woodchipsParticles.Play();
        }
​
        CheckForBirdNest(tool);
​
        return true;
    }
​
    private void CheckForBirdNest(Tool tool)
    {
        float bonusChance = birdNestChance;
        if (tool != null)
        {
            bonusChance *= tool.GetEfficiencyMultiplier(1);
        }
​
        if (Random.value < bonusChance / 100f)
        {
            Debug.Log("Found a bird's nest!");
            // You might want to add a bird's nest item to the player's inventory here
            // For example: Inventory.Instance.AddItem(birdNestItem, 1);
        }
    }
​
​
    protected override IEnumerator FadeOut()
    {
        if (fallingTreeEffect != null)
        {
            Instantiate(fallingTreeEffect, transform.position, transform.rotation);
        }
​
        if (treeStump != null)
        {
            GameObject stump = Instantiate(treeStump, transform.position, transform.rotation);
            Destroy(stump, respawnTime);
        }
​
        float duration = 1f;
        float elapsed = 0;
​
        while (elapsed < duration)
        {
            elapsed += Time.deltaTime;
            if (resourceRenderer != null && resourceRenderer.material != null)
            {
                Color newColor = resourceRenderer.material.color;
                newColor.a = 1 - (elapsed / duration);
                resourceRenderer.material.color = newColor;
            }
            yield return null;
        }
​
        resourceRenderer.enabled = false;
        resourceCollider.enabled = false;
    }
​
    protected override IEnumerator FadeIn()
    {
        resourceRenderer.enabled = true;
        resourceCollider.enabled = true;
​
        float duration = 1f;
        float elapsed = 0;
​
        while (elapsed < duration)
        {
            elapsed += Time.deltaTime;
            if (resourceRenderer != null && resourceRenderer.material != null)
            {
                Color newColor = resourceRenderer.material.color;
                newColor.a = elapsed / duration;
                resourceRenderer.material.color = newColor;
            }
            yield return null;
        }
​
        // Reset the material to its original state
        if (resourceRenderer != null && originalMaterial != null)
        {
            resourceRenderer.material = originalMaterial;
        }
    }
}

2/25/2018 9:36:44 AM
5/24/2015 10:02:00 AM
1/1/1970 12:00:00 AM +00:00 --> Unix Seconds: 0
12/31/2018 11:59:00 PM +00:00 --> Unix Seconds: 1546300740
1/1/1970 12:01:00 AM +00:00 --> Unix Seconds: 60

Cached Result
Last Run:	11:40:57 pm
Compile:	0.126s
Execute:	0s
Memory:	8kb
CPU:	0s

View IL Code