CreatureEvent [TFS 1.3 / 1.4] Upgrade System

local FieldAbsorb = MoveEvent()
function FieldAbsorb.onStepIn(player, item, position, fromPosition)

    --Required locals
    local primaryDamageTotal = 0
    local tickInterval = 0
    local duration = 0
    local conditionType = 0
    local initDamage = 0
    local startValue = 0
 
    if player:isPlayer() then
        --Set values for each field type
        if item:getId() == 1490 or item:getId() == 1496 or item:getId() == 1503 then
            tickInterval = 3000
            duration = 180000
            conditionType = CONDITION_POISON
            initDamage = initDamage
            startValue = startValue + 5
        elseif item:getId() == 1487 or item:getId() == 1492 or item:getId() == 1500 or item:getId() == 1423 then --Big Fire field id's (and Big Campfire ID), could be in table for example (initDamage = 20)
            tickInterval = 8000
            duration = 56000 --7 cycles for 8 second each
            conditionType = CONDITION_FIRE
            initDamage = initDamage + 20
            startValue = startValue + 10
        elseif item:getId() == 1488 or item:getId() == 1493 or item:getId() == 1501 or item:getId() == 1424 or item:getId() == 1425 then --Small Fire field id's (and Small Campfire ID's), could be in table for example (initDamage = 10)
            tickInterval = 8000
            duration = 56000 --7 cycles for 8 second each
            conditionType = CONDITION_FIRE
            initDamage = initDamage + 10
            startValue = startValue + 10
        elseif item:getId() == 1491 or item:getId() == 1495 or item:getId() == 1504 then --Energy field id's, could be in table for example (initDamage = 30)
            tickInterval = 10000
            duration = 15000 --1 cycle for 10 second each
            conditionType = CONDITION_ENERGY
            initDamage = initDamage + 30
            startValue = startValue + 25
        end
    
        --Find custom item absorb attributes
        for slot = CONST_SLOT_HEAD, CONST_SLOT_AMMO do
            local item = player:getSlotItem(slot)
            if item then
                if item:getType():usesSlot(slot) then
                    local values = item:getBonusAttributes()
                    if values then
                        for key, value in pairs(values) do
                            local attr = US_ENCHANTMENTS[value[1]]
                            if attr then
                                if attr.combatType and attr.combatType ~= US_TYPES.CONDITION then
                                    if conditionType == CONDITION_POISON then
                                        if attr.combatDamage == COMBAT_EARTHDAMAGE then
                                            if attr.combatType == US_TYPES.DEFENSIVE then
                                                primaryDamageTotal = primaryDamageTotal + value[2] --GetBonusFieldAbsorption
                                            end
                                        end
                                    elseif conditionType == CONDITION_FIRE then
                                        if attr.combatDamage == COMBAT_FIREDAMAGE then
                                            if attr.combatType == US_TYPES.DEFENSIVE then
                                                primaryDamageTotal = primaryDamageTotal + value[2] --GetBonusFieldAbsorption
                                            end
                                        end
                                    elseif conditionType == CONDITION_ENERGY then
                                        if attr.combatDamage == COMBAT_ENERGYDAMAGE then
                                            if attr.combatType == US_TYPES.DEFENSIVE then
                                                primaryDamageTotal = primaryDamageTotal + value[2] --GetBonusFieldAbsorption
                                            end
                                        end
                                    end
                                end
                            end
                        end
                    end
                end
            end
        end
    
        --Set initDamage and startValue
        if primaryDamageTotal > 0 then
            --Decrease damage if attributes was present
            initDamage = math.ceil(initDamage - (initDamage * primaryDamageTotal / 100))
            startValue = math.ceil(startValue - (startValue * primaryDamageTotal / 100))
        end
    
        --Deal proper initial damage (different effects)
        if conditionType == CONDITION_POISON then
            player:getPosition():sendMagicEffect(CONST_ME_GREEN_RINGS)
        elseif conditionType == CONDITION_FIRE then
            doTargetCombat(0, player, COMBAT_FIREDAMAGE, -initDamage, -initDamage, CONST_ME_HITBYFIRE, true, false, false)
        elseif conditionType == CONDITION_ENERGY then
            doTargetCombat(0, player, COMBAT_ENERGYDAMAGE, -initDamage, -initDamage, CONST_ME_HITBYENERGY, true, false, false)
        end
    
        --Set condition to player
        local condition = Condition(conditionType)
            condition:setParameter(CONDITION_PARAM_DELAYED, true)
            condition:setParameter(CONDITION_PARAM_MINVALUE, 70) -- Minimum damage
            condition:setParameter(CONDITION_PARAM_MAXVALUE, 100) -- Maximum damage
            condition:setParameter(CONDITION_PARAM_STARTVALUE, startValue) -- Starting damage
            condition:setParameter(CONDITION_PARAM_TICKINTERVAL, tickInterval)
            condition:setParameter(CONDITION_PARAM_FORCEUPDATE, true)
            condition:setParameter(CONDITION_PARAM_DURATION, duration)
        
            player:addCondition(condition)
    
        return true
    end
end
--Poison Field's Register
FieldAbsorb:id(1490) --Standard Poison Field
FieldAbsorb:id(1496) --Standard Poison Field
FieldAbsorb:id(1503) --Yellow Poison Field

--Big Fire Field's and Big Campfire register
FieldAbsorb:id(1487) --Big Fire Field
FieldAbsorb:id(1492) --Big Fire Field
FieldAbsorb:id(1500) --Yellow Big Fire Field
FieldAbsorb:id(1423) --CampFire Big (20 Init Damage)

--Small Fire Field's and Small Campfire's register
FieldAbsorb:id(1488) --Small Fire Field
FieldAbsorb:id(1493) --Small Fire Field
FieldAbsorb:id(1501) --Yellow Small Fire Field
FieldAbsorb:id(1424) --CampFire Small (10 Init Damage)
FieldAbsorb:id(1425) --CampFire Small (10 Init Damage)

--Energy Field's register:
FieldAbsorb:id(1491) --Energy Field
FieldAbsorb:id(1495) --Energy Field
FieldAbsorb:id(1504) --Yellow Energy Field
FieldAbsorb:register()

11:58 You lose 10 hitpoints.
11:59 You lose 10 hitpoints.
11:59 You lose 9 hitpoints.
11:59 You lose 9 hitpoints.
11:59 You lose 8 hitpoints.
11:59 You lose 8 hitpoints.
11:59 You lose 7 hitpoints.
11:59 You lose 7 hitpoints.
12:00 You lose 7 hitpoints.
12:00 You lose 7 hitpoints.
12:00 You lose 6 hitpoints.
12:00 You lose 6 hitpoints.
12:00 You lose 6 hitpoints.
12:00 You lose 6 hitpoints.
12:00 You lose 5 hitpoints.
12:00 You lose 5 hitpoints.
12:01 You lose 4 hitpoints.
12:01 You lose 4 hitpoints.
12:01 You lose 4 hitpoints.
12:01 You lose 4 hitpoints.
12:01 You lose 4 hitpoints.
12:01 You lose 4 hitpoints.
12:01 You lose 3 hitpoints.
12:02 You lose 3 hitpoints.
12:02 You lose 3 hitpoints.
12:02 You lose 3 hitpoints.
12:02 You lose 3 hitpoints.
12:02 You lose 3 hitpoints.
12:02 You lose 2 hitpoints.
12:02 You lose 2 hitpoints.
12:03 You lose 2 hitpoints.
12:03 You lose 2 hitpoints.
12:03 You lose 2 hitpoints.
12:03 You lose 2 hitpoints.
12:03 You lose 2 hitpoints.
12:03 You lose 2 hitpoints.
12:03 You lose 2 hitpoints.
12:03 You lose 2 hitpoints.
12:04 You lose 1 hitpoint.
12:04 You lose 1 hitpoint.
12:04 You lose 1 hitpoint.
12:04 You lose 1 hitpoint.
12:04 You lose 1 hitpoint.
12:04 You lose 1 hitpoint.
12:04 You lose 1 hitpoint.
12:05 You lose 1 hitpoint.
12:05 You lose 1 hitpoint.
12:05 You lose 1 hitpoint.
12:05 You lose 1 hitpoint.
12:05 You lose 1 hitpoint.
12:05 You lose 1 hitpoint.
12:05 You lose 1 hitpoint.
12:05 You lose 1 hitpoint.
12:06 You lose 1 hitpoint.
12:06 You lose 1 hitpoint.
12:06 You lose 1 hitpoint.
12:06 You lose 1 hitpoint.
12:06 You lose 1 hitpoint.
12:06 You lose 1 hitpoint.

ENCHANT_MAX_HP = 1
ENCHANT_MAX_MP = 2
ENCHANT_MAGIC_LEVEL = 3
ENCHANT_MELEE_SKILLS = 4
ENCHANT_FISHING = 5
ENCHANT_DISTANCE_FIGHTING = 6
ENCHANT_SHIELDING = 7

US_ENCHANTMENTS = {
  [ENCHANT_MAX_HP] = {
    name = "Maximum Life",

function Player:addAttribute(attrId, value)
  local pid = self:getId()
  if not PLAYER_ATTRIBUTES[pid][attrId] then
    PLAYER_ATTRIBUTES[pid][attrId] = 0
  end
 
  PLAYER_ATTRIBUTES[pid][attrId] = PLAYER_ATTRIBUTES[pid][attrId] + value
end

function Player:removeAttribute(attrId, value)
  local pid = self:getId()
  if PLAYER_ATTRIBUTES[pid][attrId] ~= nil then
    PLAYER_ATTRIBUTES[pid][attrId] = PLAYER_ATTRIBUTES[pid][attrId] - value
    if PLAYER_ATTRIBUTES[pid][attrId] == 0 then
      PLAYER_ATTRIBUTES[pid][attrId] = nil
    end
  end
end

function Player:getAttributes()
  return PLAYER_ATTRIBUTES[self:getId()]
end

function Player:getAttribute(attrId)
  return PLAYER_ATTRIBUTES[self:getId()][attrId] or 0
end

function Player:hasAttribute(attrId)
  return PLAYER_ATTRIBUTES[self:getId()][attrId] ~= nil
end

-- Optimized Damage Calculation
function us_onDamaged(creature, attacker, primaryDamage, primaryType, origin)
    -- Handle healing bonuses
    if primaryType == COMBAT_HEALING then
        if attacker:isPlayer() then
            local healBonus = attacker:getAttribute(ATTR_INCREASED_HEALING)
            if healBonus > 0 then
                primaryDamage = math.floor(primaryDamage + (primaryDamage * healBonus / 100))
            end
        end
        if creature:isPlayer() then
            local healBonus = creature:getAttribute(ATTR_INCREASED_HEALING)
            if healBonus > 0 then
                primaryDamage = math.floor(primaryDamage + (primaryDamage * healBonus / 100))
            end
        end
        return primaryDamage, primaryType
    end

    -- Offensive attributes (attacker)
    if attacker:isPlayer() then
        -- Double damage chance
        local doubleDamageChance = attacker:getAttribute(ATTR_DOUBLE_DAMAGE)
        if doubleDamageChance > 0 and math.random(100) < doubleDamageChance then
            primaryDamage = primaryDamage * 2
            attacker:sendTextMessage(MESSAGE_EVENT_ADVANCE, "Double damage!")
        end

        -- Damage type bonuses - now includes both specific and elemental damage
        local damageBonus = 0
     
        -- 1. Get specific damage type bonus (fire/earth/energy/physical)
        local damageAttr = getDamageBonusAttribute(primaryType)
        if damageAttr then
            damageBonus = damageBonus + attacker:getAttribute(damageAttr)
        end
     
        -- 2. Add elemental damage bonus (applies to all damage types)
        damageBonus = damageBonus + attacker:getAttribute(ATTR_ELEMENTAL_DAMAGE)
     
        -- Apply total damage bonus
        if damageBonus > 0 then
        print(damageBonus)
            primaryDamage = math.floor(primaryDamage + (primaryDamage * damageBonus / 100))
        end
     
        -- Life/Mana steal
        if math.random(100) < 95 then
            local lifeSteal = attacker:getAttribute(ATTR_LIFE_STEAL)
            if lifeSteal > 0 then
                attacker:addHealth(math.floor(primaryDamage * lifeSteal / 100))
            end
         
            local manaSteal = attacker:getAttribute(ATTR_MANA_STEAL)
            if manaSteal > 0 then
                attacker:addMana(math.floor(primaryDamage * manaSteal / 100))
            end
        end
    end

    -- Defensive attributes (creature)
    if creature:isPlayer() then
        -- Reduction type bonuses - now includes both specific and elemental reduction
        local damageReduction = 0
     
        -- 1. Get specific damage type reduction (fire/earth/energy/physical)
        local reductionAttr = getDamageReductionAttribute(primaryType)
        if reductionAttr then
            damageReduction = damageReduction + creature:getAttribute(reductionAttr)
        end
     
        -- 2. Add elemental reduction (applies to all damage types)
        damageReduction = damageReduction + creature:getAttribute(ATTR_ELEMENTAL_REDUCTION)
     
        -- Apply total damage reduction
        if damageReduction > 0 then
            primaryDamage = math.floor(primaryDamage - (primaryDamage * damageReduction / 100))
        end
    end

    return primaryDamage, primaryType
end

function getDamageBonusAttribute(damageType)
    if damageType == COMBAT_PHYSICALDAMAGE then
        return ATTR_PHYSICAL_DAMAGE
    elseif damageType == COMBAT_FIREDAMAGE then
        return ATTR_FIRE_DAMAGE
    elseif damageType == COMBAT_EARTHDAMAGE then
        return ATTR_EARTH_DAMAGE
    elseif damageType == COMBAT_ENERGYDAMAGE then
        return ATTR_ENERGY_DAMAGE
    end
    return nil
end

function getDamageReductionAttribute(damageType)
    if damageType == COMBAT_PHYSICALDAMAGE then
        return ATTR_PHYSICAL_REDUCTION
    elseif damageType == COMBAT_FIREDAMAGE then
        return ATTR_FIRE_REDUCTION
    elseif damageType == COMBAT_EARTHDAMAGE then
        return ATTR_EARTH_REDUCTION
    elseif damageType == COMBAT_ENERGYDAMAGE then
        return ATTR_ENERGY_REDUCTION
    end
    return nil
end

            --Start of Mana healing bonus when attribute is present
            local healvalue = math.random(25, 100)
            local healBonus = player:getAttribute(ATTR_MANA_HEALING)
                if healBonus > 0 then
                    healvalue = math.floor(healvalue + (healvalue * healBonus / 100))
                end
            --End of Mana healing bonus when attribute is present
            target:addMana(healvalue)

UpgradeSystemInventory = {
    conditionTracker = {}
}

function UpgradeSystemInventory.onInventoryUpdate(player, item, slot, equip)
    local pid = player:getId()

    -- Handle de-equip: remove conditions and attributes
    if not equip and UpgradeSystemInventory.conditionTracker[pid] and UpgradeSystemInventory.conditionTracker[pid][slot] then
        for conditionId, data in pairs(UpgradeSystemInventory.conditionTracker[pid][slot]) do
            player:removeCondition(data.condition:getType(), CONDITIONID_COMBAT, data.condition:getSubId())
            player:removeAttribute(data.bonusId, data.value)
            if US_CONDITIONS[data.bonusId] and US_CONDITIONS[data.bonusId][data.value] then
                US_CONDITIONS[data.bonusId][data.value][conditionId] = nil
            end
        end
        UpgradeSystemInventory.conditionTracker[pid][slot] = nil
    end

    -- Handle equip logic
    if equip and item then
        local itemType = item:getType()

        -- Add attributes and conditions
        local bonuses = item:getBonusAttributes()
        if bonuses then
            for index, bonus in ipairs(bonuses) do
                local bonusId, bonusValue = bonus[1], bonus[2]
                local attr = US_ENCHANTMENTS[bonusId]
                if attr then
                    player:addAttribute(bonusId, bonusValue)

                    if attr.combatType == US_TYPES.CONDITION then
                        UpgradeSystemInventory.conditionTracker[pid] = UpgradeSystemInventory.conditionTracker[pid] or {}
                        UpgradeSystemInventory.conditionTracker[pid][slot] = UpgradeSystemInventory.conditionTracker[pid][slot] or {}

                        US_CONDITIONS[bonusId] = US_CONDITIONS[bonusId] or {}
                        US_CONDITIONS[bonusId][bonusValue] = US_CONDITIONS[bonusId][bonusValue] or {}

                        local conditionId = string.format("%d:%d:%d:%d", pid, slot, item:getId(), bonusId)
                        if not US_CONDITIONS[bonusId][bonusValue][conditionId] then
                            local condition = Condition(attr.condition)
                            condition:setParameter(CONDITION_PARAM_SUBID, 1000 + player:getNextSubId(slot, index))
                            condition:setParameter(attr.param, attr.percentage and (100 + bonusValue) or bonusValue)
                            condition:setParameter(CONDITION_PARAM_TICKS, -1)

                            US_CONDITIONS[bonusId][bonusValue][conditionId] = condition
                            UpgradeSystemInventory.conditionTracker[pid][slot][conditionId] = {
                                condition = condition,
                                bonusId = bonusId,
                                value = bonusValue
                            }

                            player:addCondition(condition)
                        end
                    end
                end
            end
        end
    end

    return true
end

function us_onLogin(player)
    local pid = player:getId()
    PLAYER_ATTRIBUTES[pid] = {}

    -- Register player-related upgrade events
    player:registerEvent("UpgradeSystemKill")
    player:registerEvent("UpgradeSystemHealth")
    player:registerEvent("UpgradeSystemMana")
    player:registerEvent("UpgradeSystemPD")

    -- Apply bonuses for all equipped items using centralized logic
    for slot = CONST_SLOT_HEAD, CONST_SLOT_AMMO do
        local item = player:getSlotItem(slot)
        if item then
            UpgradeSystemInventory.onInventoryUpdate(player, item, slot, true)
        end
    end
end

local FieldAbsorb = MoveEvent()
function FieldAbsorb.onStepIn(player, item, position, fromPosition)
    -- Validate player
    if not player or not player:isPlayer() then
        return true
    end

    -- Field type configuration table (more maintainable than if/else chains)
    local fieldConfig = {
        -- Poison fields
        [1490] = {type = CONDITION_POISON, tick = 3000, cycles = 100, initDmg = 0, startVal = 5, effect = CONST_ME_GREEN_RINGS},
        [1496] = {type = CONDITION_POISON, tick = 3000, cycles = 100, initDmg = 0, startVal = 5, effect = CONST_ME_GREEN_RINGS},
        [1503] = {type = CONDITION_POISON, tick = 3000, cycles = 100, initDmg = 0, startVal = 5, effect = CONST_ME_GREEN_RINGS},
      
        -- Big fire fields
        [1487] = {type = CONDITION_FIRE, tick = 8000, cycles = 70, initDmg = 20, startVal = 10, combat = COMBAT_FIREDAMAGE, effect = CONST_ME_HITBYFIRE},
        [1492] = {type = CONDITION_FIRE, tick = 8000, cycles = 70, initDmg = 20, startVal = 10, combat = COMBAT_FIREDAMAGE, effect = CONST_ME_HITBYFIRE},
        [1500] = {type = CONDITION_FIRE, tick = 8000, cycles = 70, initDmg = 20, startVal = 10, combat = COMBAT_FIREDAMAGE, effect = CONST_ME_HITBYFIRE},
        [1423] = {type = CONDITION_FIRE, tick = 8000, cycles = 70, initDmg = 20, startVal = 10, combat = COMBAT_FIREDAMAGE, effect = CONST_ME_HITBYFIRE},
      
        -- Small fire fields
        [1488] = {type = CONDITION_FIRE, tick = 8000, cycles = 50, initDmg = 10, startVal = 10, combat = COMBAT_FIREDAMAGE, effect = CONST_ME_HITBYFIRE},
        [1493] = {type = CONDITION_FIRE, tick = 8000, cycles = 50, initDmg = 10, startVal = 10, combat = COMBAT_FIREDAMAGE, effect = CONST_ME_HITBYFIRE},
        [1501] = {type = CONDITION_FIRE, tick = 8000, cycles = 50, initDmg = 10, startVal = 10, combat = COMBAT_FIREDAMAGE, effect = CONST_ME_HITBYFIRE},
        [1424] = {type = CONDITION_FIRE, tick = 8000, cycles = 50, initDmg = 10, startVal = 10, combat = COMBAT_FIREDAMAGE, effect = CONST_ME_HITBYFIRE},
        [1425] = {type = CONDITION_FIRE, tick = 8000, cycles = 50, initDmg = 10, startVal = 10, combat = COMBAT_FIREDAMAGE, effect = CONST_ME_HITBYFIRE},
      
        -- Energy fields
        [1491] = {type = CONDITION_ENERGY, tick = 10000, cycles = 25, initDmg = 30, startVal = 25, combat = COMBAT_ENERGYDAMAGE, effect = CONST_ME_HITBYENERGY},
        [1495] = {type = CONDITION_ENERGY, tick = 10000, cycles = 25, initDmg = 30, startVal = 25, combat = COMBAT_ENERGYDAMAGE, effect = CONST_ME_HITBYENERGY},
        [1504] = {type = CONDITION_ENERGY, tick = 10000, cycles = 25, initDmg = 30, startVal = 25, combat = COMBAT_ENERGYDAMAGE, effect = CONST_ME_HITBYENERGY}
    }

    -- Get field configuration
    local config = fieldConfig[item:getId()]
    if not config then
        return true
    end

    -- Calculate damage reduction based on player's resistances
    local damageReduction = 0
  
    -- NEW: Use player:getAttribute() instead of inventory scanning
    if config.type == CONDITION_POISON then
        damageReduction = player:getAttribute(ATTR_EARTH_REDUCTION) + player:getAttribute(ATTR_ELEMENTAL_REDUCTION)
    elseif config.type == CONDITION_FIRE then
        damageReduction = player:getAttribute(ATTR_FIRE_REDUCTION) + player:getAttribute(ATTR_ELEMENTAL_REDUCTION)
    elseif config.type == CONDITION_ENERGY then
        damageReduction = player:getAttribute(ATTR_ENERGY_REDUCTION) + player:getAttribute(ATTR_ELEMENTAL_REDUCTION)
    end

    -- Apply damage reduction
    local finalInitDmg = math.ceil(config.initDmg * (1 - damageReduction / 100))
    local finalStartVal = math.ceil(config.startVal * (1 - damageReduction / 100))

    -- Apply initial damage/effect
    if config.combat then
        doTargetCombat(0, player, config.combat, -finalInitDmg, -finalInitDmg, config.effect, true, false, false)
    else
        player:getPosition():sendMagicEffect(config.effect)
    end

    -- Create and apply condition
    local condition = Condition(config.type)
  
    -- Type-specific parameters
    if config.type == CONDITION_FIRE then
        local condition = Condition(CONDITION_FIRE)
        condition:setParameter(CONDITION_PARAM_DELAYED, true)
        condition:addDamage(6, 8000, -finalStartVal)
        player:addCondition(condition)
    elseif config.type == CONDITION_POISON then
        local condition = Condition(CONDITION_POISON)
        condition:setParameter(CONDITION_PARAM_DELAYED, true)
        condition:setParameter(CONDITION_PARAM_MINVALUE, 70) -- Minimum damage
        condition:setParameter(CONDITION_PARAM_MAXVALUE, 100) -- Maximum damage
        condition:setParameter(CONDITION_PARAM_STARTVALUE, -finalStartVal) -- Starting damage
        condition:setParameter(CONDITION_PARAM_TICKINTERVAL, 4000) -- 5 seconds interval
        condition:setParameter(CONDITION_PARAM_FORCEUPDATE, true)
        condition:setParameter(CONDITION_PARAM_DURATION, 240000) -- 240 seconds (4 minutes)
        player:addCondition(condition)
    elseif config.type == CONDITION_ENERGY then
        local condition = Condition(CONDITION_ENERGY)
        condition:setParameter(CONDITION_PARAM_DELAYED, true)
        condition:addDamage(0, 10000, -finalStartVal)
        player:addCondition(condition)
    end
    return true
end

-- Register all field types
FieldAbsorb:id(1490, 1496, 1503)  -- Poison fields
FieldAbsorb:id(1487, 1492, 1500, 1423)  -- Big fire fields
FieldAbsorb:id(1488, 1493, 1501, 1424, 1425)  -- Small fire fields
FieldAbsorb:id(1491, 1495, 1504)  -- Energy fields
FieldAbsorb:register()

-- Field configuration table
local FIELD_CONFIG = {
    -- Poison fields
    [1490] = {type = CONDITION_POISON, tick = 3000, initDmg = 0, startVal = 5, effect = CONST_ME_GREEN_RINGS},
    [1496] = {type = CONDITION_POISON, tick = 3000, initDmg = 0, startVal = 5, effect = CONST_ME_GREEN_RINGS},
    [1503] = {type = CONDITION_POISON, tick = 3000, initDmg = 0, startVal = 5, effect = CONST_ME_GREEN_RINGS},
    
    -- Big fire fields
    [1487] = {type = CONDITION_FIRE, tick = 8000, initDmg = 20, startVal = 10, combat = COMBAT_FIREDAMAGE, effect = CONST_ME_HITBYFIRE},
    [1492] = {type = CONDITION_FIRE, tick = 8000, initDmg = 20, startVal = 10, combat = COMBAT_FIREDAMAGE, effect = CONST_ME_HITBYFIRE},
    [1500] = {type = CONDITION_FIRE, tick = 8000, initDmg = 20, startVal = 10, combat = COMBAT_FIREDAMAGE, effect = CONST_ME_HITBYFIRE},
    [1423] = {type = CONDITION_FIRE, tick = 8000, initDmg = 20, startVal = 10, combat = COMBAT_FIREDAMAGE, effect = CONST_ME_HITBYFIRE},
    
    -- Small fire fields
    [1488] = {type = CONDITION_FIRE, tick = 8000, initDmg = 10, startVal = 10, combat = COMBAT_FIREDAMAGE, effect = CONST_ME_HITBYFIRE},
    [1493] = {type = CONDITION_FIRE, tick = 8000, initDmg = 10, startVal = 10, combat = COMBAT_FIREDAMAGE, effect = CONST_ME_HITBYFIRE},
    [1501] = {type = CONDITION_FIRE, tick = 8000, initDmg = 10, startVal = 10, combat = COMBAT_FIREDAMAGE, effect = CONST_ME_HITBYFIRE},
    [1424] = {type = CONDITION_FIRE, tick = 8000, initDmg = 10, startVal = 10, combat = COMBAT_FIREDAMAGE, effect = CONST_ME_HITBYFIRE},
    [1425] = {type = CONDITION_FIRE, tick = 8000, initDmg = 10, startVal = 10, combat = COMBAT_FIREDAMAGE, effect = CONST_ME_HITBYFIRE},
    
    -- Energy fields
    [1491] = {type = CONDITION_ENERGY, tick = 10000, initDmg = 30, startVal = 25, combat = COMBAT_ENERGYDAMAGE, effect = CONST_ME_HITBYENERGY},
    [1495] = {type = CONDITION_ENERGY, tick = 10000, initDmg = 30, startVal = 25, combat = COMBAT_ENERGYDAMAGE, effect = CONST_ME_HITBYENERGY},
    [1504] = {type = CONDITION_ENERGY, tick = 10000, initDmg = 30, startVal = 25, combat = COMBAT_ENERGYDAMAGE, effect = CONST_ME_HITBYENERGY}
}

local FieldAbsorb = MoveEvent()
function FieldAbsorb.onStepIn(player, item, position, fromPosition)
    -- Validate player
    if not player or not player:isPlayer() then
        return true
    end

    -- Get field configuration
    local config = FIELD_CONFIG[item:getId()]
    if not config then
        return true
    end

    -- Calculate damage reduction based on player's resistances
    local damageReduction = 0
    
    -- NEW: Use player:getAttribute() instead of inventory scanning
    if config.type == CONDITION_POISON then
        damageReduction = player:getAttribute(ATTR_EARTH_REDUCTION) + player:getAttribute(ATTR_ELEMENTAL_REDUCTION)
    elseif config.type == CONDITION_FIRE then
        damageReduction = player:getAttribute(ATTR_FIRE_REDUCTION) + player:getAttribute(ATTR_ELEMENTAL_REDUCTION)
    elseif config.type == CONDITION_ENERGY then
        damageReduction = player:getAttribute(ATTR_ENERGY_REDUCTION) + player:getAttribute(ATTR_ELEMENTAL_REDUCTION)
    end

    -- Apply damage reduction
    local finalInitDmg = math.ceil(config.initDmg * (1 - damageReduction / 100))
    local finalStartVal = math.ceil(config.startVal * (1 - damageReduction / 100))

    -- Apply initial damage/effect
    if config.combat then
        doTargetCombat(0, player, config.combat, -finalInitDmg, -finalInitDmg, config.effect, true, false, false)
    else
        player:getPosition():sendMagicEffect(config.effect)
    end

    -- Create and apply condition
    local condition = Condition(config.type)
    
    -- Type-specific parameters
    if config.type == CONDITION_FIRE then
        local condition = Condition(CONDITION_FIRE)
        condition:setParameter(CONDITION_PARAM_DELAYED, true)
        condition:addDamage(6, 8000, -finalStartVal)
        player:addCondition(condition)
    elseif config.type == CONDITION_POISON then
        local condition = Condition(CONDITION_POISON)
        condition:setParameter(CONDITION_PARAM_DELAYED, true)
        
        -- Always add the first damage tick with the full damage
        condition:addDamage(0, 4000, -finalStartVal)
        
        -- Add subsequent ticks only if they would do at least 1 damage
        local damage = finalStartVal - 1
        if damage >= 1 then
            condition:addDamage(3, 4000, -damage)
        end
        
        damage = damage - 1
        if damage >= 1 then
            condition:addDamage(6, 4000, -damage)
        end
        
        damage = damage - 1
        if damage >= 1 then
            condition:addDamage(9, 4000, -damage)
        end
        
        damage = damage - 1
        if damage >= 1 then
            condition:addDamage(37, 4000, -damage)
        end
        
        player:addCondition(condition)
    elseif config.type == CONDITION_ENERGY then
        local condition = Condition(CONDITION_ENERGY)
        condition:setParameter(CONDITION_PARAM_DELAYED, true)
        condition:addDamage(0, 10000, -finalStartVal)
        player:addCondition(condition)
    end
    return true
end

-- Register all field types
FieldAbsorb:id(1490, 1496, 1503)  -- Poison fields
FieldAbsorb:id(1487, 1492, 1500, 1423)  -- Big fire fields
FieldAbsorb:id(1488, 1493, 1501, 1424, 1425)  -- Small fire fields
FieldAbsorb:id(1491, 1495, 1504)  -- Energy fields
FieldAbsorb:register()

function Player.getNextSubId(self, itemSlot, attrSlot)
    local cid = self:getId()
    if not US_SUBID[cid] then
        US_SUBID[cid] = {}
    end

    if not US_SUBID[cid][itemSlot] then
        US_SUBID[cid][itemSlot] = {}
    end

    -- Calculate a unique subId based on slot and attribute position
    -- This ensures each combination of itemSlot and attrSlot gets a unique subId
    -- Format: 1XXYY where XX is itemSlot (01-99) and YY is attrSlot (01-99)
    -- This gives us unique subIds from 10101 to 19999
    
    -- Ensure slots are within valid range
    local normalizedItemSlot = (itemSlot % 99) + 1
    local normalizedAttrSlot = (attrSlot % 99) + 1
    
    -- Generate unique subId
    local subId = 10000 + (normalizedItemSlot * 100) + normalizedAttrSlot
    
    -- Store the subId for reference
    US_SUBID[cid][itemSlot][attrSlot] = subId

    return subId
end

US_SUBID[pid] = nil  -- Clean up subIds on logout

US_SUBID[pid] = {}

                -- Clean up subIds for this slot
                if US_SUBID[pid] and US_SUBID[pid][slot] then
                    US_SUBID[pid][slot] = {}
                end