Legendaries

## How to use that page

Search the name of item (list is not full, because most of rolls are common)

1)RPCItems:GetLogarithmicVarianceValue means max value multiplies by 1.35, rounds to the bigger value, and multiplies 1.1 (in the best luck roll)(ex: 18x1485=26.73-27 runes) This function means you cannot get these runes rerolling via Blacksmith, only on first drop.

2)RPCItems:RollMagebaneRuneProperty() is equal 52, next row with valueX1.3 means it will be multiplied by 1.3. (ex.1.3X52 = 67.6=67 runes

3) Max factor at max equal 300.

```
RPCItems:RollAttribute(100, 20, 100, 0, 0, item.rarity, false, maxFactor*18)

```

Means it rolls 18X300 attributes = 5400

```
RandomInt(maxFactor*2, maxFactor*4)

```

Means value is random between 600 and 1200

4)paragonBonus is equal 4. 45+(paragonBonus\*2) is equal 53.
5)RPCItems:RollSkillProperty value is equal 85

## HeroicConquerorVestments

```
function RPCItems:RollHeroicConquerorVestments(deathLocation, pitLevel)
    local item = RPCItems:CreateVariant("item_rpc_heroic_conqueror_vestments", "immortal", "heroic conqueror", "body", true, "Slot: Body")
    local maxFactor = RPCItems:GetMaxFactor()

    item.hasRunePoints = true

    local runeName = "rune_d_a"
    local runeValue = RPCItems:GetLogarithmicVarianceValue(11+pitLevel, 0, 0, 0, 0)
    item.property1name = runeName
    item.property1 = runeValue
    RPCItems:SetPropertyValues(item, item.property1, "rune", "#7DFF12",  1)

    local runeName = "rune_d_b"
    local runeValue = RPCItems:GetLogarithmicVarianceValue(11+pitLevel, 0, 0, 0, 0)
    item.property2name = runeName
    item.property2 = runeValue
    RPCItems:SetPropertyValues(item, item.property2, "rune", "#7DFF12",  2)

    local runeName = "rune_d_c"
    local runeValue = RPCItems:GetLogarithmicVarianceValue(11+pitLevel, 0, 0, 0, 0)
    item.property3name = runeName
    item.property3 = runeValue
    RPCItems:SetPropertyValues(item, item.property3, "rune", "#7DFF12",  3)

    local runeName = "rune_d_d"
    local runeValue = RPCItems:GetLogarithmicVarianceValue(11+pitLevel, 0, 0, 0, 0)
    item.property4name = runeName
    item.property4 = runeValue
    RPCItems:SetPropertyValues(item, item.property4, "rune", "#7DFF12",  4)

    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item
end

```

## Champions

```
function RPCItems:RollChampionsGearMail(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_champions_mail", "immortal", "champions_gear", "body", true, "Slot: Body")
    local maxFactor = RPCItems:GetMaxFactor()

    item.hasRunePoints = true

    local runeName = "rune_d_a"
    local runeValue = RPCItems:GetLogarithmicVarianceValue(20, 0, 0, 0, 0)
    item.property1name = runeName
    item.property1 = runeValue
    RPCItems:SetPropertyValues(item, item.property1, "rune", "#7DFF12",  1)

    RPCItems:RollBodyProperty2(item, 0)
    RPCItems:RollBodyProperty3(item, 0)
    RPCItems:RollBodyProperty4(item, 0)
    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Deity Crown

```
function RPCItems:RollFireDeityCrown(deathLocation, isSpirit, paragonBonus)
    local item = RPCItems:CreateVariant("item_rpc_fire_deity_crown", "immortal", "Fire Deity Crown", "head", true, "Slot: Head")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "fire_deity"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_fire_deity", "#E85A4A",  1, "#property_fire_deity_description")

    item.hasRunePoints = true

    local runeName = "rune_c_b"
    local runeValue = 0
    if isSpirit then
        runeValue = RPCItems:GetLogarithmicVarianceValue(45+(paragonBonus*2), 0, 0, 0, 0)
    else
        runeValue = RPCItems:GetLogarithmicVarianceValue(25+(paragonBonus*2), 0, 0, 0, 0)
    end
    local luck = RandomInt(1,3)
    if luck == 3 then
        runeName = "rune_d_b"
        if isSpirit then
            runeValue = RPCItems:GetLogarithmicVarianceValue(20+paragonBonus, 0, 0, 0, 0)
        else
            runeValue = RPCItems:GetLogarithmicVarianceValue(13+paragonBonus, 0, 0, 0, 0)
        end
    end
    item.property2name = runeName
    item.property2 = runeValue
    RPCItems:SetPropertyValues(item, item.property2, "rune", "#7DFF12",  2)

    RPCItems:RollHoodProperty3(item, 0)
    RPCItems:RollHoodProperty4(item, 0)
    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Hood of Lords

```
function RPCItems:RollHoodOfLords(deathLocation, spiritRealm)
    local item = RPCItems:CreateVariant("item_rpc_hood_of_lords", "immortal", "Hood of Lords", "head", true, "Slot: Head")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "lords"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_lords", "#FEFFC6",  1, "#property_lords_description")

    item.hasRunePoints = true

    local runeName = "rune_c_"..RPCItems:GetRandomRuneLetter(1, 4)
    if GameState:GetDifficultyFactor() > 1 then
        local luck = RandomInt(1, 5-GameState:GetDifficultyFactor())
        if luck == 1 then
            runeName = "rune_d_"..RPCItems:GetRandomRuneLetter(1, 4)
        end
    end
    local bonus = 0
    if spiritRealm then
        bonus = 9
    end
    local runeValue = RPCItems:GetLogarithmicVarianceValue(15+bonus, 0, 0, 0, 0)
    item.property2name = runeName
    item.property2 = runeValue
    RPCItems:SetPropertyValues(item, item.property2, "rune", "#7DFF12",  2)

    RPCItems:RollHoodProperty3(item, 0)
    RPCItems:RollHoodProperty4(item, 0)
    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Spellfire Gloves

```
function RPCItems:RollSpellfireGloves(deathLocation, spiritRealm)
    local item = RPCItems:CreateVariant("item_rpc_spellfire_gloves", "immortal", "Spellfire Gloves", "hands", true, "Slot: Hands")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "spellfire"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_spellfire", "#FFA62B",  1, "#property_spellfire_description")

    item.hasRunePoints = true

    local runeName = "rune_c_b"
    if GameState:GetDifficultyFactor() > 1 then
        local luck = RandomInt(1, 5-GameState:GetDifficultyFactor())
        if luck == 1 then
            runeName = "rune_d_b"
        end
    end
    local bonus = 0
    if spiritRealm then
        bonus = 8
    end
    local runeValue = RPCItems:GetLogarithmicVarianceValue(14+bonus, 0, 0, 0, 0)
    item.property2name = runeName
    item.property2 = runeValue
    RPCItems:SetPropertyValues(item, item.property2, "rune", "#7DFF12",  2)

    RPCItems:RollHandProperty3(item, 0)
    RPCItems:RollHandProperty4(item, 0)
    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Sun Crystal

```
function RPCItems:RollSunCrystal(deathLocation, infiniteWave)
   local item = RPCItems:CreateVariant("item_rpc_serengaard_sun_crystal", "immortal", "Serengaard Sun Crystal", "amulet", true, "Slot: Trinket")
   local maxFactor = RPCItems:GetMaxFactor()

```

```
   local initRoll = RandomInt(1000, 1000+infiniteWave*40)
   local value = math.min(RPCItems:GetLogarithmicVarianceValue(initRoll, 0, 0, 0, 0), 9000)
   item.property1 = value
   item.property1name = "strength"
   RPCItems:SetPropertyValues(item, item.property1, "#item_strength", "#CC0000",  1)

```

```
   local initRoll = RandomInt(1000, 1000+infiniteWave*40)
   local value = math.min(RPCItems:GetLogarithmicVarianceValue(initRoll, 0, 0, 0, 0), 9000)
   item.property2 = value
   item.property2name = "agility"
   RPCItems:SetPropertyValues(item, item.property2, "#item_agility", "#2EB82E",  2)

```

```
   local initRoll = RandomInt(1000, 1000+infiniteWave*40)
   local value = math.min(RPCItems:GetLogarithmicVarianceValue(initRoll, 0, 0, 0, 0), 9000)
   item.property3 = value
   item.property3name = "intelligence"
   RPCItems:SetPropertyValues(item, item.property3, "#item_intelligence", "#33CCFF",  3)

```

```
   local initRoll = RandomInt(50, 50+infiniteWave*5)
   local value = math.min(RPCItems:GetLogarithmicVarianceValue(initRoll, 0, 0, 0, 0), 1000)
   item.property4 = value
   item.property4name = "all_elements"
   RPCItems:SetPropertyValues(item, item.property4, "#property_all_elements", "#BED5E5", 4)

```

```
   local drop = CreateItemOnPositionSync( deathLocation, item )
   local position = deathLocation
   RPCItems:DropItem(item, position)
   return item

```

## Azure

```
function RPCItems:RollAzureEmpire(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_azure_empire", "immortal", "Pendant of the Azure Empire", "amulet", true, "Slot: Trinket")
    local maxFactor = RPCItems:GetMaxFactor()

    item.property1name = "azure_empire"
    item.property1 = 1

    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_azure_empire", "#7AD2F0",  1, "#property_azure_empire_description")

    local luck = RandomInt(1, 4)
    if luck == 1 then
        item.property2 = 0
        item.property2name = "azure_silver"
        RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_azure_empire_silver", "#C9E6ED",  2, "#property_azure_empire_silver_description")
    elseif luck == 2 then
        item.property2 = 0
        item.property2name = "azure_green"
        RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_azure_empire_green", "#67EA64",  2, "#property_azure_empire_green_description")
    elseif luck == 3 then
        item.property2 = 0
        item.property2name = "azure_blue"
        RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_azure_empire_blue", "#74A0ED",  2, "#property_azure_empire_blue_description")
    elseif luck == 4 then
        item.property2 = 0
        item.property2name = "azure_red"
        RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_azure_empire_red", "#E03018",  2, "#property_azure_empire_red_description")
    end

    local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
    item.property3 = math.ceil(value*1.4)
    item.property3name = propertyName
    RPCItems:SetPropertyValues(item, item.property3, "rune", "#7DFF12",  3)

    local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
    item.property4 = math.ceil(value*1.4)
    item.property4name = propertyName
    RPCItems:SetPropertyValues(item, item.property4, "rune", "#7DFF12",  4)

    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Augmented Nobility

```
function RPCItems:CreateAugmentedRingOfNobility(hero, ability)
    local item = RPCItems:CreateVariantWithMin("item_rpc_ring_of_nobility_augmented", "immortal", "Ring of Nobility Augmented", "amulet", true, "Slot: Trinket", ability.minLevel, "", "")
    local maxFactor = RPCItems:GetMaxFactor()

    item.property1name = "nobility_augmented"
    item.property1 = 1

    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_nobility_augmented", "#FFFFFF",  1, "#property_nobility_augmented_description")

    item.property2 = ability.property2*15
    local primaryAttribute = hero:GetPrimaryAttribute()
    if primaryAttribute == 0 then
        item.property2name = "strength"
        RPCItems:SetPropertyValues(item, item.property2, "#item_strength", "#CC0000",  2)
    elseif primaryAttribute == 1 then
        item.property2name = "agility"
        RPCItems:SetPropertyValues(item, item.property2, "#item_agility", "#2EB82E",  2)
    else
        item.property2name = "intelligence"
        RPCItems:SetPropertyValues(item, item.property2, "#item_intelligence", "#33CCFF",  2)
    end

    item.property3 = ability.property3*2
    item.property3name = ability.property3name
    RPCItems:SetPropertyValues(item, item.property3, "rune", "#7DFF12",  3)

    item.property4 = ability.property4*2
    item.property4name = ability.property4name
    RPCItems:SetPropertyValues(item, item.property4, "rune", "#7DFF12",  4)
    item.pickedUp = true
    RPCItems:AmuletPickup(hero, item)
    Weapons:Equip(hero, item)
    return item

```

## Geode

```
function RPCItems:RollFractionalEnhancementGeode(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_fractional_enhancement_geode", "immortal", "Fractional Enhancement Geode", "amulet", true, "Slot: Trinket")
    local maxFactor = RPCItems:GetMaxFactor()

    item.property1name = "geode"
    item.property1 = 1

    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_geode", "#05FF0D",  1, "#property_geode_description")

    local difficulty = math.min(GameState:GetDifficultyFactor(), 3)
    local armorRoll = 10^difficulty
    item.property2 = armorRoll
    item.property2name = "armor"
    RPCItems:SetPropertyValues(item, item.property2, "#item_armor", "#D1D1D1", 2)

    local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
    item.property3 = value
    item.property3name = propertyName
    RPCItems:SetPropertyValues(item, item.property3, "rune", "#7DFF12",  3)

    local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
    item.property4 = math.floor(value*1.3)
    item.property4name = propertyName
    RPCItems:SetPropertyValues(item, item.property4, "rune", "#7DFF12",  4)

    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Volcano Orb

```
function RPCItems:RollVolcanoOrb(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_volcano_orb", "immortal", "Volcano Orb", "amulet", true, "Slot: Trinket")
    local maxFactor = RPCItems:GetMaxFactor()

    item.property1name = "volcano_orb"
    item.property1 = 1

    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_volcano_orb", "#995050",  1, "#property_volcano_orb_description")

    local tier, value, propertyName = RPCItems:RollAmuletProperty2(item, 300, 1)
    if tier > 0 then
        item.property2 = value
        item.property2name = propertyName
        RPCItems:SetPropertyValues(item, item.property2, "rune", "#7DFF12",  2)
    end

    local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
    item.property3 = value
    item.property3name = propertyName
    RPCItems:SetPropertyValues(item, item.property3, "rune", "#7DFF12",  3)

    local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
    item.property4 = math.floor(value*1.3)
    item.property4name = propertyName
    RPCItems:SetPropertyValues(item, item.property4, "rune", "#7DFF12",  4)

    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item
end

```

## Galaxy Orb

```
function RPCItems:RollGalaxyOrb(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_galaxy_orb", "immortal", "Galaxy Orb", "amulet", true, "Slot: Trinket")
    local maxFactor = RPCItems:GetMaxFactor()

    item.property1name = "galaxy_orb"
    item.property1 = 1

    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_galaxy_orb", "#FF9100",  1, "#property_galaxy_orb_description")

    Elements:RollElementAttribute(item, RPC_ELEMENT_COSMOS, 2, 2, 30, 2)

    local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
    item.property3 = value
    item.property3name = propertyName
    RPCItems:SetPropertyValues(item, item.property3, "rune", "#7DFF12",  3)

    local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
    item.property4 = value*2
    item.property4name = propertyName
    RPCItems:SetPropertyValues(item, item.property4, "rune", "#7DFF12",  4)

    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## WorldTreesFlowerCache

```
function RPCItems:RollWorldTreesFlowerCache(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_world_trees_flower_cache", "immortal", "World Tree's Flower Cache", "amulet", true, "Slot: Trinket")
    local maxFactor = RPCItems:GetMaxFactor()

    item.property1name = "world_tree_flower"
    item.property1 = 1
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_world_trees_flower_cache", "#C4544E",  1, "#property_world_trees_flower_cache_description")

    local luck = RandomInt(1,3)
    if luck == 1 then
        Elements:RollElementAttribute(item, RPC_ELEMENT_NATURE, 2, 2, 24, 2)
    else
        local value, nameLevel = RPCItems:RollAttribute(0, 6, 11, 0, 0, item.rarity, false, maxFactor*11)
        item.property2 = value
        item.property2name = "all_attributes"
        RPCItems:SetPropertyValues(item, item.property2, "#item_all_attributes", "#FFFFFF",  2)
    end

    local tier, value, propertyName = RPCItems:RollSkillProperty()
    if tier > 0 then
        item.property3 = value
        item.property3name = propertyName
        RPCItems:SetPropertyValues(item, item.property3, "rune", "#7DFF12",  3)
    end

    local tier, value, propertyName = RPCItems:RollSkillProperty()
    if tier > 0 then
        item.property4 = value
        item.property4name = propertyName
        RPCItems:SetPropertyValues(item, item.property4, "rune", "#7DFF12",  4)
    end

    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## ConquestStoneFalcon

```
function RPCItems:RollConquestStoneFalcon(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_conquest_stone_falcon", "immortal", "Conquest Stone Falcon", "amulet", true, "Slot: Trinket")
    local maxFactor = RPCItems:GetMaxFactor()

    item.property1name = "stone_falcon"
    item.property1 = 1
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_stone_falcon", "#A5B5A9",  1, "#property_stone_falcon_description")

    local maxFactor = RPCItems:GetMaxFactor()

    local value, nameLevel = RPCItems:RollAttribute(0, 4, 10, 0, 0, item.rarity, false, maxFactor*5)
    item.property2 = value
    item.property2name = "armor"
    RPCItems:SetPropertyValues(item, item.property2, "#item_armor", "#D1D1D1",  2)

    local tier, value, propertyName = RPCItems:RollSkillProperty()
    if tier > 0 then
        item.property3 = value
        item.property3name = propertyName
        RPCItems:SetPropertyValues(item, item.property3, "rune", "#7DFF12",  3)
    end

    local tier, value, propertyName = RPCItems:RollSkillProperty()
    if tier > 0 then
        item.property4 = math.floor(value*1.4)
        item.property4name = propertyName
        RPCItems:SetPropertyValues(item, item.property4, "rune", "#7DFF12",  4)
    end

    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Raven Idol, Raven Idol upgraded

```
function RPCItems:RollRavenIdol(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_raven_idol", "immortal", "Raven Idol", "amulet", true, "Slot: Trinket")
    local maxFactor = RPCItems:GetMaxFactor()

    item.property1name = "raven"
    item.property1 = 0
    RPCItems:SetPropertyValuesSpecial(item, 0, "#item_property_raven_idol", "#807F85",  1, "#property_raven_idol_description")

    local maxFactor = RPCItems:GetMaxFactor()

    local luck = RandomInt(1, 3)
    if luck == 1 then
        local value, nameLevel = RPCItems:RollAttribute(50, 1, 35, 0, 0, item.rarity, false, maxFactor*12)
        item.property2 = value
        item.property2name = "strength"
        RPCItems:SetPropertyValues(item, item.property2, "#item_strength", "#CC0000",  2)
    elseif luck == 2 then
        local value, nameLevel = RPCItems:RollAttribute(50, 1, 35, 0, 0, item.rarity, false, maxFactor*12)
        item.property2 = value
        item.property2name = "agility"
        RPCItems:SetPropertyValues(item, item.property2, "#item_agility", "#2EB82E",  2)
    else
        local value, nameLevel = RPCItems:RollAttribute(50, 1, 35, 0, 0, item.rarity, false, maxFactor*12)
        item.property2 = value
        item.property2name = "intelligence"
        RPCItems:SetPropertyValues(item, item.property2, "#item_intelligence", "#33CCFF",  2)
    end

    local tier, value, propertyName = RPCItems:RollSkillProperty()
    if tier > 0 then
        item.property3 = value
        item.property3name = propertyName
        RPCItems:SetPropertyValues(item, item.property3, "rune", "#7DFF12",  3)
    end

    local tier, value, propertyName = RPCItems:RollSkillProperty()
    if tier > 0 then
        item.property4 = math.floor(value*1.4)
        item.property4name = propertyName
        RPCItems:SetPropertyValues(item, item.property4, "rune", "#7DFF12",  4)
    end

    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

```
function RPCItems:RollRavenIdol2(hero, ability)
    local item = RPCItems:CreateVariantWithMin("item_rpc_raven_idol2", "immortal", "Raven Idol", "amulet", true, "Slot: Trinket", ability.minLevel, "", "")
    local maxFactor = RPCItems:GetMaxFactor()

    item.property1name = "raven2"
    item.property1 = 1
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_raven_idol2", "#807F85",  1, "#property_raven_idol_description2")

    local oldProperty = CustomNetTables:GetTableValue("item_properties", tostring(ability:GetEntityIndex()).."-"..tostring(2))
    local value = math.ceil(ability.property2*1.1)
    CustomNetTables:SetTableValue( "item_properties", tostring(item:GetEntityIndex()).."-"..tostring(2), {propertyValue = value, propertyName = oldProperty.propertyName, propertyColor = oldProperty.propertyColor })
    item.property2 = value
    item.property2name = ability.property2name

    local oldProperty = CustomNetTables:GetTableValue("item_properties", tostring(ability:GetEntityIndex()).."-"..tostring(3))
    local value = math.ceil(ability.property3*1.0)
    CustomNetTables:SetTableValue( "item_properties", tostring(item:GetEntityIndex()).."-"..tostring(3), {propertyValue = value, propertyName = oldProperty.propertyName, propertyColor = oldProperty.propertyColor })
    item.property3 = value
    item.property3name = ability.property3name

    local oldProperty = CustomNetTables:GetTableValue("item_properties", tostring(ability:GetEntityIndex()).."-"..tostring(4))
    local value = math.ceil(ability.property4*1.0)
    CustomNetTables:SetTableValue( "item_properties", tostring(item:GetEntityIndex()).."-"..tostring(4), {propertyValue = value, propertyName = oldProperty.propertyName, propertyColor = oldProperty.propertyColor })
    item.property4 = value
    item.property4name = ability.property4name

    RPCItems:ReduceLevelRequirement(item)

    item.pickedUp = true
    Weapons:Equip(hero, item)
    return item

```

Token of Oceanis

```
function RPCItems:RollTokenOfOceanis(deathLocation, bBossDrop)
    local item = RPCItems:CreateVariant("item_rpc_sparkling_token_of_oceanis", "immortal", "Sparkling Token of Oceanis", "amulet", true, "Slot: Trinket")
    local maxFactor = RPCItems:GetMaxFactor()

    item.property1name = "oceanis"
    item.property1 = 1
    RPCItems:SetPropertyValuesSpecial(item, "★", "#property_sparkling_token", "#FFE884",  1, "#property_sparkling_token_Description")
    local bossMax = 14
    if bBossDrop then
        bossMax = 18
    end
    local value, nameLevel = RPCItems:RollAttribute(0, 6, bossMax, 0, 0, item.rarity, false, maxFactor*bossMax)
    item.property2 = value
    item.property2name = "all_attributes"
    RPCItems:SetPropertyValues(item, item.property2, "#item_all_attributes", "#FFFFFF",  2)

    local tier, value, propertyName = RPCItems:RollSkillProperty()
    if tier > 0 then
        item.property3 = value
        item.property3name = propertyName
        RPCItems:SetPropertyValues(item, item.property3, "rune", "#7DFF12",  3)
    end

    local tier, value, propertyName = RPCItems:RollSkillProperty()
    if tier > 0 then
        item.property4 = value
        item.property4name = propertyName
        RPCItems:SetPropertyValues(item, item.property4, "rune", "#7DFF12",  4)
    end

    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Boots of Fortune

```
function RPCItems:RollBootsOfGreatFortune(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_boots_of_great_fortune", "immortal", "Boots of Great Fortune", "feet", true, "Slot: Feet")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "great_fortune"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_boots_of_great_fortune", "#F1F756",  1, "#property_boots_of_great_fortune_description")

    item.hasRunePoints = true
    item.property2 = RPCItems:GetLogarithmicVarianceValue(GameState:GetDifficultyFactor()*5, 0, 0, 0, 0)
    item.property2name = "rune_d_c"
    RPCItems:SetPropertyValues(item, item.property2, "rune", "#7DFF12",  2)

    RPCItems:RollFootProperty3(item, 0)
    RPCItems:RollFootProperty4(item, 0)
    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## RedOctoberBoots

```
function RPCItems:RollRedOctoberBoots(deathLocation, isSpirit)
    local item = RPCItems:CreateVariant("item_rpc_red_october_boots", "immortal", "Red October Boots", "feet", true, "Slot: Feet")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "red_october"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_red_october", "#E87B7B",  1, "#property_red_october_description")

    item.hasRunePoints = true
    local runeName = "rune_d_c"
    local runeValue = 0
    if isSpirit then
        runeValue = RPCItems:GetLogarithmicVarianceValue(14, 0, 0, 0, 0)
    else
        runeValue = RPCItems:GetLogarithmicVarianceValue(9, 0, 0, 0, 0)
    end
    item.property2name = runeName
    item.property2 = runeValue
    RPCItems:SetPropertyValues(item, item.property2, "rune", "#7DFF12",  2)

    local luck = RandomInt(1,3)
    if luck == 1 then
        if isSpirit then
            runeValue = RPCItems:GetLogarithmicVarianceValue(14, 0, 0, 0, 0)
        else
            runeValue = RPCItems:GetLogarithmicVarianceValue(9, 0, 0, 0, 0)
        end
        item.property3name = runeName
        item.property3 = runeValue
        RPCItems:SetPropertyValues(item, item.property3, "rune", "#7DFF12",  3)
    else
        RPCItems:RollFootProperty3(item, 0)
    end
    RPCItems:RollFootProperty4(item, 0)
    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Oceanrunner Boots

```
function RPCItems:RollOceanrunnerBoots(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_oceanrunner_boots", "immortal", "Oceanrunner", "feet", true, "Slot: Feet")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "oceanrunner"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#property_oceanrunner", "#58EFD6",  1, "#property_oceanrunner_Description")

    value, nameLevel = RPCItems:RollAttribute(0, 6, 10, 0, 0, item.rarity, false, maxFactor*10)
    item.property2 = value
    item.property2name = "agility"
    RPCItems:SetPropertyValues(item, item.property2, "#item_agility", "#2EB82E",  2)

    RPCItems:RollFootProperty3(item, 0)
    RPCItems:RollFootProperty4(item, 0)
    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## BlueDragonGreaves

```
function RPCItems:RollBlueDragonGreaves(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_blue_dragon_greaves", "immortal", "Blue Dragon Greaves", "feet", true, "Slot: Feet")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "dragon_greaves"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_dragon_greaves", "#2B4DE3",  1, "#property_dragon_greaves_description")

    local luck = RandomInt(1,5)
    if luck > 1 then
        RPCItems:RollFootProperty2(item, 0)
    else
        local luck = RandomInt(1,8)
        item.hasRunePoints = true
        if luck == 1 then
            local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
            item.property2 = math.floor(value*1.2)
            item.property2name = "rune_c_c"
            RPCItems:SetPropertyValues(item, item.property2, "rune", "#7DFF12",  2)
        else
            local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
            item.property2 = math.floor(value*1.8)
            item.property2name = propertyName
            RPCItems:SetPropertyValues(item, item.property2, "rune", "#7DFF12",  2)
        end
    end
    RPCItems:RollFootProperty3(item, 0)
    RPCItems:RollFootProperty4(item, 0)
    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Harvester Boots

```
function RPCItems:RollHarvesterBoots(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_harvester_boots", "immortal", "Harvester Boots", "feet", true, "Slot: Feet")
    local maxFactor = RPCItems:GetMaxFactor()

    RPCItems:RollFootProperty1(item, 0)
    local luck = RandomInt(1,3)
    if luck == 3 then
        local letter = RPCItems:GetRandomRuneLetter(1, 4)
        runeName = "rune_a_"..letter
        runeValue = math.floor(RPCItems:GetLogarithmicVarianceValue(maxFactor/5, 0, 0, 0, 0))

        item.property1name = runeName
        item.property1 = runeValue
        RPCItems:SetPropertyValues(item, item.property1, "rune", "#7DFF12",  1)
    else
        local itemBonus = RPCItems:GetLogarithmicVarianceNoRounding(1.0)
        itemBonus = math.min(itemBonus, 1.35)
        local ability = item
        local oldProperty = CustomNetTables:GetTableValue("item_properties", tostring(ability:GetEntityIndex()).."-"..tostring(1))
        local value = math.ceil(ability.property1*itemBonus)
        value = math.ceil(value)
        CustomNetTables:SetTableValue( "item_properties", tostring(item:GetEntityIndex()).."-"..tostring(1), {propertyValue = value, propertyName = oldProperty.propertyName, propertyColor = oldProperty.propertyColor })
        item.property1 = value
        item.property1name = ability.property1name
        item.hasRunePoints = true
    end
    RPCItems:RollFootProperty2(item, 0)
    local luck = RandomInt(1,3)
    if luck == 3 then
        local letter = RPCItems:GetRandomRuneLetter(1, 4)
        runeName = "rune_b_"..letter
        runeValue = math.floor(RPCItems:GetLogarithmicVarianceValue(maxFactor/5, 0, 0, 0, 0))

        item.property2name = runeName
        item.property2 = math.floor(runeValue)
        RPCItems:SetPropertyValues(item, item.property2, "rune", "#7DFF12",  2)
    else
        local itemBonus = RPCItems:GetLogarithmicVarianceNoRounding(1.0)
        itemBonus = math.min(itemBonus, 1.35)
        local ability = item
        local oldProperty = CustomNetTables:GetTableValue("item_properties", tostring(ability:GetEntityIndex()).."-"..tostring(2))
        local value = math.ceil(ability.property2*itemBonus)
        value = math.ceil(value)
        CustomNetTables:SetTableValue( "item_properties", tostring(item:GetEntityIndex()).."-"..tostring(2), {propertyValue = value, propertyName = oldProperty.propertyName, propertyColor = oldProperty.propertyColor })
        item.property2 = value
        item.property2name = ability.property2name
        item.hasRunePoints = true
    end
    RPCItems:RollFootProperty3(item, 0)
    local luck = RandomInt(1,3)
    if luck == 3 and maxFactor >= 150 then
        local letter = RPCItems:GetRandomRuneLetter(1, 4)
        runeName = "rune_c_"..letter
        runeValue = RPCItems:GetLogarithmicVarianceValue(maxFactor/10, 0, 0, 0, 0)

        item.property3name = runeName
        item.property3 = math.floor(runeValue)
        RPCItems:SetPropertyValues(item, item.property3, "rune", "#7DFF12",  3)
    else
        local itemBonus = RPCItems:GetLogarithmicVarianceNoRounding(1.0)
        itemBonus = math.min(itemBonus, 1.35)
        local ability = item
        local oldProperty = CustomNetTables:GetTableValue("item_properties", tostring(ability:GetEntityIndex()).."-"..tostring(3))
        local value = math.ceil(ability.property3*itemBonus)
        value = math.ceil(value)
        CustomNetTables:SetTableValue( "item_properties", tostring(item:GetEntityIndex()).."-"..tostring(3), {propertyValue = value, propertyName = oldProperty.propertyName, propertyColor = oldProperty.propertyColor })
        item.property3 = value
        item.property3name = ability.property3name
        item.hasRunePoints = true
    end
    RPCItems:RollFootProperty4(item, 0)
    local luck = RandomInt(1,4)
    if luck == 4 and maxFactor >= 270 then
        local letter = RPCItems:GetRandomRuneLetter(1, 4)
        runeName = "rune_d_"..letter
        runeValue = RPCItems:GetLogarithmicVarianceValue(maxFactor/30, 0, 0, 0, 0)

        item.property4name = runeName
        item.property4 = math.floor(runeValue)
        RPCItems:SetPropertyValues(item, item.property4, "rune", "#7DFF12",  4)
    else
        local itemBonus = RPCItems:GetLogarithmicVarianceNoRounding(1.0)
        itemBonus = math.min(itemBonus, 1.35)
        local ability = item
        local oldProperty = CustomNetTables:GetTableValue("item_properties", tostring(ability:GetEntityIndex()).."-"..tostring(4))
        local value = math.ceil(ability.property4*itemBonus)
        value = math.ceil(value)
        CustomNetTables:SetTableValue( "item_properties", tostring(item:GetEntityIndex()).."-"..tostring(4), {propertyValue = value, propertyName = oldProperty.propertyName, propertyColor = oldProperty.propertyColor })
        item.property4 = value
        item.property4name = ability.property4name
        item.hasRunePoints = true
    end
    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Neptune Water Gliders

```
function RPCItems:RollNeptunesWaterGliders(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_neptunes_water_gliders", "immortal", "Neptune's Water Gliders", "feet", true, "Slot: Feet")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "neptune"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_neptune", "#2294F2",  1, "#property_neptune_description")

    item.hasRunePoints = true
    local luck = RandomInt(1, 10)
    local runeName = "rune_a_c"
    if luck <= 8 and luck > 4 then
        runeName = "rune_b_c"
    elseif luck > 8 then
        runeName = "rune_c_c"
    end

    local value, nameLevel = RPCItems:RollAttribute(0, 1, math.ceil(maxFactor/4), 0, 0, item.rarity, false, math.ceil(maxFactor/2.6 + 4))
    item.property2 = math.floor(value)
    item.property2name = runeName
    RPCItems:SetPropertyValues(item, item.property2, "rune", "#7DFF12",  2)

    RPCItems:RollFootProperty3(item, 0)
    RPCItems:RollFootProperty4(item, 0)
    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Resonant Pathfinder Boots

```
function RPCItems:RollResonantPathfinderBoots(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_pathfinders_resonant_boots", "immortal", "Pathfinder's Resonant Boots", "feet", true, "Slot: Feet")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "pathfinder"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_pathfinder", "#E3E02D",  1, "#property_pathfinder_description")

    item.hasRunePoints = true
    local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
    item.property2 = math.floor(value*1.3)
    item.property2name = propertyName
    RPCItems:SetPropertyValues(item, item.property2, "rune", "#7DFF12",  2)

    RPCItems:RollFootProperty3(item, 0)
    RPCItems:RollFootProperty4(item, 0)
    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Giant Hunter Boots

```
function RPCItems:RollGiantHunterBoots(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_giant_hunters_boots_of_resilience", "immortal", "Giant Hunters Boots of Resilience", "feet", true, "Slot: Feet")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "giant_hunter"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_giant_hunter_boot", "#E3E300",  1, "#property_giant_hunter_boot_description")

    local value, prefixLevel = RPCItems:RollAttribute(300, 220, 600, 1, 1, item.rarity, false, maxFactor*400)
    item.property2 = value
    item.property2name = "max_health"
    RPCItems:SetPropertyValues(item, item.property2, "#item_max_health", "#B02020",  2)

    item.hasRunePoints = true
    local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
    item.property3 = math.floor(value*1.6)
    item.property3name = propertyName
    RPCItems:SetPropertyValues(item, item.property3, "rune", "#7DFF12",  3)

    RPCItems:RollFootProperty4(item, 0)
    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Alarana Ice Boots

```
function RPCItems:RollAlaranaIceBoot(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_alaranas_ice_boot", "immortal", "Alarana's Ice Boot", "feet", true, "Slot: Feet")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "alarana"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_alarana", "#AFECFF",  1, "#property_alarana_description")
    local luck = RandomInt(1,3)
    if luck == 1 then
        RPCItems:RollFootProperty2(item, 0)
    elseif luck == 2 then
        Elements:RollElementAttribute(item, RPC_ELEMENT_ICE, 2.4, 1, 20, 2)
    else
        local luck = RandomInt(1,6)
        item.hasRunePoints = true
        if luck == 1 then
            local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
            item.property2 = math.floor(value*1.0)
            item.property2name = "rune_c_c"
            RPCItems:SetPropertyValues(item, item.property2, "rune", "#7DFF12",  2)
        else
            local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
            item.property2 = math.floor(value*1.4)
            item.property2name = propertyName
            RPCItems:SetPropertyValues(item, item.property2, "rune", "#7DFF12",  2)
        end
    end
    RPCItems:RollFootProperty3(item, 0)
    RPCItems:RollFootProperty4(item, 0)
    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

Crystalline Slippers

```
function RPCItems:RollCrystallineSlippers(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_crystalline_slippers", "immortal", "Crystalline Slippers", "feet", true, "Slot: Feet")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "crystalline"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#property_crystalline", "#99E8E0",  1, "#property_crystalline_Description")

    item.hasRunePoints = true
    local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
    item.property2 = math.floor(value*1.3)
    item.property2name = propertyName
    RPCItems:SetPropertyValues(item, item.property2, "rune", "#7DFF12",  2)

    RPCItems:RollFootProperty3(item, 0)
    RPCItems:RollFootProperty4(item, 0)
    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Emerald Speed Runners

```
function RPCItems:RollEmeraldSpeedRunners(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_emerald_speed_runners", "immortal", "Emerald Speed Runners", "feet", true, "Slot: Feet")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "emerald_speed"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_emerald_speed", "#3EC18A",  1, "#property_emerald_speed_description")

    item.hasRunePoints = true
    local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
    item.property2 = math.floor(value*1.3)
    item.property2name = propertyName
    RPCItems:SetPropertyValues(item, item.property2, "rune", "#7DFF12",  2)

    RPCItems:RollFootProperty3(item, 0)
    RPCItems:RollFootProperty4(item, 0)
    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Dark Reef Shark Helmet

```
function RPCItems:RollDarkReefSharkHelmet(deathLocation, isShop)
    local item = RPCItems:CreateVariant("item_rpc_dark_reef_shark_helmet", "immortal", "Dark Reef Shark Helmet", "head", true, "Slot: Head")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "shark_helmet"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#property_shark_helmet", "#A7BAB7",  1, "#property_shark_helmet_Description")

    local luck = RandomInt(1,2)
    if luck == 1 then
        local value = RandomInt(maxFactor*5, maxFactor*500)
        item.property2 = value
        item.property2name = "attack_damage"
        RPCItems:SetPropertyValues(item, item.property2, "#item_bonus_attack_damage", "#343EC9",  2)
    else
        local value, nameLevel = RPCItems:RollAttribute(0, 8, 14, 0, 0, item.rarity, false, maxFactor*14)
        item.property2 = value
        item.property2name = "agility"
        RPCItems:SetPropertyValues(item, item.property2, "#item_agility", "#2EB82E",  2)
    end

    RPCItems:RollHoodProperty3(item, 0)
    RPCItems:RollHoodProperty4(item, 0)

    RPCItems:DropOrGiveItem(hero, item, isShop, deathLocation)

```

## Hood Of Defiler

```
function RPCItems:RollHoodOfDefiler(deathLocation, isShop)
    local item = RPCItems:CreateVariant("item_rpc_hood_of_defiler", "immortal", "Hood of the Defiler", "head", true, "Slot: Head")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "hood_of_defiler"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_hood_of_defiler", "#B36481",  1, "#property_hood_of_defiler_description")

    local luck = RandomInt(1,2)
    if luck == 1 then
        local value = RandomInt(maxFactor*5, maxFactor*500)
        item.property2 = value
        item.property2name = "attack_damage"
        RPCItems:SetPropertyValues(item, item.property2, "#item_bonus_attack_damage", "#343EC9",  2)
    else
        Elements:RollElementAttribute(item, RPC_ELEMENT_DEMON, 2.7, 2, 29, 2)
    end

    RPCItems:RollHoodProperty3(item, 0)
    RPCItems:RollHoodProperty4(item, 0)

    RPCItems:DropOrGiveItem(hero, item, isShop, deathLocation)
    return item

```

## Mask of Tyrius

```
function RPCItems:RollMaskOfTyrius(deathLocation, isShop)
    local item = RPCItems:CreateVariant("item_rpc_mask_of_tyrius", "immortal", "Mask of Tyrius", "head", true, "Slot: Head")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "tyrius"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_tyrius", "#D6693A",  1, "#property_tyrius_description")

    item.hasRunePoints = true
    local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
    item.property2 = WallPhysics:round(value*1.5, 0)
    item.property2name = propertyName
    RPCItems:SetPropertyValues(item, item.property2, "rune", "#7DFF12",  2)

    value, nameLevel = RPCItems:RollAttribute(100, 20, 60, 0, 0, item.rarity, false, maxFactor*14)
    item.property3 = value
    item.property3name = "strength"
    RPCItems:SetPropertyValues(item, item.property3, "#item_strength", "#CC0000",  3)

    RPCItems:RollHoodProperty4(item, 0)
    RPCItems:DropOrGiveItem(hero, item, isShop, deathLocation)
    return item

```

## CrestOfTheUmbralSentinel

```
function RPCItems:RollCrestOfTheUmbralSentinel(deathLocation, isShop)
    local item = RPCItems:CreateVariant("item_rpc_crest_of_the_umbral_sentinel", "immortal", "Crest of the Umbral Sentinel", "head", true, "Slot: Head")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "umbral"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_umbral", "#90C3D4",  1, "#property_umbral_description")

    item.hasRunePoints = true

    local luck = RandomInt(1,10)
    local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
    value = math.floor(value*1.5)
    if luck <= 5 then
        propertyName = "rune_a_b"
    elseif luck <= 9 then
        propertyName = "rune_b_b"
    elseif luck == 10 then
        propertyName = "rune_c_b"
    end

    item.property2 = value
    item.property2name = propertyName
    RPCItems:SetPropertyValues(item, item.property2, "rune", "#7DFF12",  2)

    RPCItems:RollHoodProperty3(item, 0)
    RPCItems:RollHoodProperty4(item, 0)
    RPCItems:DropOrGiveItem(hero, item, isShop, deathLocation)
    return item

```

## Demon Mask (roll is broken)

```
function RPCItems:RollDemonMask(deathLocation, isShop, waveBonus)
    local item = RPCItems:CreateVariant("item_rpc_demon_mask", "immortal", "Demon Mask", "head", true, "Slot: Head")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "demon_mask"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_demon", "#C91818",  1, "#property_demon_description")

    item.hasRunePoints = true

    local luck = RandomInt(1,4)
    local propertyName = ""
    if luck == 1 then
        propertyName = "rune_c_a"
    elseif luck == 2 then
        propertyName = "rune_c_b"
    elseif luck == 3 then
        propertyName = "rune_c_c"
    elseif luck == 4 then
        propertyName = "rune_c_d"
    end
    local difficulty = GameState:GetDifficultyFactor()
    if difficulty == 1 then
        waveBonus = math.max(waveBonus-40, 10)
    elseif difficulty == 2 then
        waveBonus = math.max(waveBonus-30, 10)
    elseif difficulty == 3 then
        waveBonus = math.max(waveBonus-20, 10)
    end
    waveBonus = math.min(waveBonus, 60)
    item.property2 = RPCItems:GetLogarithmicVarianceValue(waveBonus, 0, 0, 0, 0)
    item.property2name = propertyName
    RPCItems:SetPropertyValues(item, item.property2, "rune", "#7DFF12",  2)

    RPCItems:RollHoodProperty3(item, 0)
    RPCItems:RollHoodProperty4(item, 0)
    RPCItems:DropOrGiveItem(hero, item, isShop, deathLocation)
    return item

```

## Trickster Mask

```
function RPCItems:RollTricksterMask(deathLocation, isShop)
    local item = RPCItems:CreateVariant("item_rpc_tricksters_mask", "immortal", "Trickster's Mask", "head", true, "Slot: Head")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "trickster"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_trickster", "#FFFB17",  1, "#property_trickster_description")

    value, nameLevel = RPCItems:RollAttribute(0, 6, 20, 0, 0, item.rarity, false, maxFactor*20)
    item.property2 = value
    item.property2name = "agility"
    RPCItems:SetPropertyValues(item, item.property2, "#item_agility", "#2EB82E",  2)

    item.hasRunePoints = true
    local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
    item.property3 = math.floor(value*2)
    item.property3name = propertyName
    RPCItems:SetPropertyValues(item, item.property3, "rune", "#7DFF12",  3)

    RPCItems:RollHoodProperty4(item, 0)
    RPCItems:DropOrGiveItem(hero, item, isShop, deathLocation)
    return item

```

## Excavators Focus Hat

```
function RPCItems:RollExcavatorsFocusHat(deathLocation, isShop)
    local item = RPCItems:CreateVariant("item_rpc_excavators_focus_cap", "immortal", "Excavator's Focus Cap", "head", true, "Slot: Head")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "excavator"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_excavator", "#7300DE",  1, "#property_excavator_description")

    value, nameLevel = RPCItems:RollAttribute(0, 7, 11, 0, 0, item.rarity, false, maxFactor*10)
    item.property2 = value
    item.property2name = "intelligence"
    RPCItems:SetPropertyValues(item, item.property2, "#item_intelligence", "#58BFD6",  2)

    item.hasRunePoints = true
    local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
    item.property3 = math.floor(value*1.5)
    item.property3name = propertyName
    RPCItems:SetPropertyValues(item, item.property3, "rune", "#7DFF12",  3)

    RPCItems:RollHoodProperty4(item, 0)
    RPCItems:DropOrGiveItem(hero, item, isShop, deathLocation)
    return item

```

## Iron Colossus

```
function RPCItems:RollIronColossus(deathLocation, isShop)
    local item = RPCItems:CreateVariant("item_rpc_iron_colussus", "immortal", "Helm of the Iron Colossus", "head", true, "Slot: Head")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "iron_colossus"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_iron_colossus", "#874E4D",  1, "#property_iron_colossus_description")

    value, prefixLevel = RPCItems:RollAttribute(100, 5, 18, 0, 0, item.rarity, false, maxFactor*12)
    item.property2 = value
    item.property2name = "strength"
    RPCItems:SetPropertyValues(item, item.property2, "#item_strength", "#CC0000",  2)

    value, nameLevel = RPCItems:RollAttribute(100, 5, 12, 0, 0, item.rarity, false, maxFactor*4)
    item.property3 = value
    item.property3name = "armor"
    RPCItems:SetPropertyValues(item, item.property3, "#item_armor", "#D1D1D1",  3)

    RPCItems:RollHoodProperty4(item, 0)

    RPCItems:DropOrGiveItem(hero, item, isShop, deathLocation)
    return item
end

```

## Stormcrack Helm

```
function RPCItems:RollStormcrackHelm(deathLocation, isShop)
    local item = RPCItems:CreateVariant("item_rpc_stormcrack_helm", "immortal", "Stormcrack Helm", "head", true, "Slot: Head")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 0
    item.property1name = "stormcrack"
    RPCItems:SetPropertyValuesSpecial(item, 0, "#item_property_stormcrack", "#EFF2AE",  1, "#property_stormcrack_description")

    item.hasRunePoints = true
    local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
    item.property2 = value*2
    item.property2name = propertyName
    RPCItems:SetPropertyValues(item, item.property2, "rune", "#7DFF12",  2)

    RPCItems:RollHoodProperty3(item, 0)
    RPCItems:RollHoodProperty4(item, 0)
    RPCItems:DropOrGiveItem(hero, item, isShop, deathLocation)
    return item

```

## Odin Helmet

```
function RPCItems:RollOdinHelmet(deathLocation, isShop)
    local item = RPCItems:CreateVariant("item_rpc_odin_helmet", "immortal", "Odin Helmet", "head", true, "Slot: Head")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "odin"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_odin", "#82A6B3",  1, "#property_odin_description")

    item.hasRunePoints = true
    local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
    item.property2 = value*2
    item.property2name = propertyName
    RPCItems:SetPropertyValues(item, item.property2, "rune", "#7DFF12",  2)

    RPCItems:RollHoodProperty3(item, 0)
    RPCItems:RollHoodProperty4(item, 0)
    RPCItems:DropOrGiveItem(hero, item, isShop, deathLocation)
    return item

```

## Death Whisper Helm

```
function RPCItems:RollDeathWhisperHelm(deathLocation, isShop)
    local item = RPCItems:CreateVariant("item_rpc_death_whisper_helm", "immortal", "Death Whisper Helm", "head", true, "Slot: Head")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "death_whisper"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_death_whisper", "#4A6A8C",  1, "#property_death_whisper_description")

    item.hasRunePoints = true
    local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
    item.property2 = value*3
    item.property2name = propertyName
    RPCItems:SetPropertyValues(item, item.property2, "rune", "#7DFF12",  2)

    RPCItems:RollHoodProperty3(item, 0)
    RPCItems:RollHoodProperty4(item, 0)
    RPCItems:DropOrGiveItem(hero, item, isShop, deathLocation)
    return item

```

## Hood of Chosen

```
function RPCItems:RollHoodOfChosen(deathLocation, isShop)
    local item = RPCItems:CreateVariant("item_rpc_hood_of_chosen", "immortal", "Hood of the Chosen", "head", true, "Slot: Head")
    local maxFactor = RPCItems:GetMaxFactor()

    item.hasRunePoints = true
    local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
    item.property1 = math.ceil(value*2)
    item.property1name = propertyName
    RPCItems:SetPropertyValues(item, item.property1, "rune", "#7DFF12",  1)
    local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
    item.property2 = value*2
    item.property2name = propertyName
    RPCItems:SetPropertyValues(item, item.property2, "rune", "#7DFF12",  2)

    RPCItems:RollHoodProperty3(item, 0)
    RPCItems:RollHoodProperty4(item, 0)

    RPCItems:DropOrGiveItem(hero, item, isShop, deathLocation)
    return item
end

```

## Burning Spirit Helm

```
function RPCItems:RollBurningSpiritHelmet(deathLocation, isShop)
    local item = RPCItems:CreateVariant("item_rpc_burning_spirit_helmet", "immortal", "Burning Spirit Helmet", "head", true, "Slot: Head")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "burning_spirit"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_burning_spirit", "#D6B948",  1, "#property_burning_spirit_description")

    local luck = RandomInt(1,3)
    if luck == 1 then
        value, nameLevel = RPCItems:RollAttribute(100, 20, 100, 0, 0, item.rarity, false, maxFactor*18)
        item.property2 = value
        item.property2name = "strength"
        RPCItems:SetPropertyValues(item, item.property2, "#item_strength", "#CC0000",  2)
    elseif luck == 2 then
        value, nameLevel = RPCItems:RollAttribute(100, 20, 100, 0, 0, item.rarity, false, maxFactor*18)
        item.property2 = value
        item.property2name = "agility"
        RPCItems:SetPropertyValues(item, item.property2, "#item_agility", "#2EB82E",  2)
    elseif luck == 3 then
        value, nameLevel = RPCItems:RollAttribute(100, 20, 100, 0, 0, item.rarity, false, maxFactor*18)
        item.property2 = value
        item.property2name = "intelligence"
        RPCItems:SetPropertyValues(item, item.property2, "#item_intelligence", "#33CCFF",  2)
    end

    RPCItems:RollHoodProperty3(item, 0)
    RPCItems:RollHoodProperty4(item, 0)
    RPCItems:DropOrGiveItem(hero, item, isShop, deathLocation)
    return item

```

## Shipyard Veil

```
function RPCItems:RollShipyardVeil1(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_shipyard_veil_lv1", "immortal", "Shipyard Veil LV1", "head", true, "Slot: Head")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 0
    item.property1name = "shipyard_veil"
    RPCItems:SetPropertyValuesSpecial(item, 0, "#item_property_shipyard_veil_1", "#91F2F1",  1, "#property_shipyard_veil_1_description")

    item.hasRunePoints = true
    local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
    item.property2 = math.ceil(value*1.15)
    item.property2name = "rune_c_a"
    RPCItems:SetPropertyValues(item, item.property2, "rune", "#7DFF12",  2)

    RPCItems:RollHoodProperty3(item, 0)
    RPCItems:RollHoodProperty4(item, 0)

    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Masks of Ahnqhir

```
function RPCItems:RollTwistedMaskOfAhnqhirPurple(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_twisted_purple_mask_of_ahnqhir", "immortal", "Twisted Purple Mask of Ahn'qhir", "head", true, "Slot: Head")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 0
    item.property1name = "mask_of_ahnqir"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#property_twisted_mask_of_ahnqhir_a", "#BC60F2",  1, "#property_twisted_mask_of_ahnqhir_a_Description")

    item.hasRunePoints = true
    local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
    item.property2 = math.ceil(value*0.9)
    item.property2name = "rune_c_a"
    RPCItems:SetPropertyValues(item, item.property2, "rune", "#7DFF12",  2)

    RPCItems:RollHoodProperty3(item, 0)
    RPCItems:RollHoodProperty4(item, 0)

    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## OceanHelmOfValdun

```
function RPCItems:RollOceanHelmOfValdun(deathLocation, bBossDrop)
    local item = RPCItems:CreateVariant("item_rpc_ocean_helm_of_valdun", "immortal", "Ocean Helm of Val'Dun", "head", true, "Slot: Head")
    local maxFactor = RPCItems:GetMaxFactor()

    local rollFactor = 8
    if bBossDrop then
        rollFactor = 12
    end

    local value, nameLevel = RPCItems:RollAttribute(100, 8, 20, 0, 1, item.rarity, false, rollFactor*50)
    item.property1 = value
    item.property1name = "all_elements"
    RPCItems:SetPropertyValues(item, item.property1, "#property_all_elements", "#BED5E5", 1)

    item.hasRunePoints = true

    item.property2 = Weapons:GetDeviation(rollFactor, 0)
    local luck = RandomInt(1,4)
    if luck == 1 then
        item.property2name = "rune_d_a"
    elseif luck == 2 then
        item.property2name = "rune_d_b"
    elseif luck == 3 then
        item.property2name = "rune_d_c"
    elseif luck == 4 then
        item.property2name = "rune_d_d"
    end
    RPCItems:SetPropertyValues(item, item.property2, "rune", "#7DFF12",  2)

    RPCItems:RollHoodProperty3(item, 0)
    RPCItems:RollHoodProperty4(item, 0)

    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Hood of Sea Oracle

```
function RPCItems:RollHoodOfTheSeaOracle(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_hood_of_the_sea_oracle", "immortal", "Hood of the Sea Oracle", "head", true, "Slot: Head")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "sea_oracle"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#property_sea_oracle", "#FFBC49",  1, "#property_sea_oracle_Description")

    item.hasRunePoints = true
    item.property2 = Weapons:GetDeviation(10, 0)
    item.property2name = "rune_d_a"
    RPCItems:SetPropertyValues(item, item.property2, "rune", "#7DFF12",  2)

    RPCItems:RollHoodProperty3(item, 0)
    RPCItems:RollHoodProperty4(item, 0)

    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## BasiliskPlagueHelm

```
function RPCItems:RollBasiliskPlagueHelm(deathLocation, isShop)
    local item = RPCItems:CreateVariant("item_rpc_basilisk_plague_helm", "immortal", "Basilisk Plague Helm", "head", true, "Slot: Head")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "basilisk_plague"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_basilisk_plague", "#93B058",  1, "#property_basilisk_plague_description")

    local luck = RandomInt(1,2)
    if luck == 1 then
        local value, prefixLevel = RPCItems:RollAttribute(100, 6, 12, 0, 0, item.rarity, false, maxFactor*15)
        item.property2 = value
        item.property2name = "health_regen"
        RPCItems:SetPropertyValues(item, item.property2, "#item_health_regen", "#6AA364",  2)
    else
        Elements:RollElementAttribute(item, RPC_ELEMENT_POISON, 3, 2, 30, 2)
    end

    RPCItems:RollHoodProperty3(item, 0)
    RPCItems:RollHoodProperty4(item, 0)
    RPCItems:DropOrGiveItem(hero, item, isShop, deathLocation)
    return item

```

## WhiteMageHat 1 and 2

```
function RPCItems:RollWhiteMageHat(deathLocation, isShop)
    local item = RPCItems:CreateVariant("item_rpc_white_mage_hat", "immortal", "White Mage Hat", "head", true, "Slot: Head")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 0
    item.property1name = "white_mage_hat"
    RPCItems:SetPropertyValuesSpecial(item, 0, "#item_property_white_mage_hat", "#FFFFFF",  1, "#property_white_mage_hat_description")

    local value, prefixLevel = RPCItems:RollAttribute(100, 6, 12, 0, 0, item.rarity, false, maxFactor*12)
    item.property2 = value
    item.property2name = "health_regen"
    RPCItems:SetPropertyValues(item, item.property2, "#item_health_regen", "#6AA364",  2)

    RPCItems:RollHoodProperty3(item, 0)
    RPCItems:RollHoodProperty4(item, 0)
    RPCItems:DropOrGiveItem(hero, item, isShop, deathLocation)
    return item

```

```
function RPCItems:CreateWhiteMageHat2(hero, ability)
    local item = RPCItems:CreateVariantWithMin("item_rpc_white_mage_hat_2", "immortal", "White Mage Hat LV2", "head", true, "Slot: Head", ability.minLevel, "", "")
    local maxFactor = RPCItems:GetMaxFactor()

    item.property1name = "white_mage_hat2"
    item.property1 = 1

    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_white_mage_hat_2", "#FFFFFF",  1, "#property_white_mage_hat_2_description")

    local oldProperty = CustomNetTables:GetTableValue("item_properties", tostring(ability:GetEntityIndex()).."-"..tostring(2))
    local value = math.ceil(ability.property2*1.2)
    CustomNetTables:SetTableValue( "item_properties", tostring(item:GetEntityIndex()).."-"..tostring(2), {propertyValue = value, propertyName = oldProperty.propertyName, propertyColor = oldProperty.propertyColor })
    item.property2 = value
    item.property2name = ability.property2name

    local oldProperty = CustomNetTables:GetTableValue("item_properties", tostring(ability:GetEntityIndex()).."-"..tostring(3))
    local value = math.ceil(ability.property3*1.2)
    CustomNetTables:SetTableValue( "item_properties", tostring(item:GetEntityIndex()).."-"..tostring(3), {propertyValue = value, propertyName = oldProperty.propertyName, propertyColor = oldProperty.propertyColor })
    item.property3 = value
    item.property3name = ability.property3name

    local oldProperty = CustomNetTables:GetTableValue("item_properties", tostring(ability:GetEntityIndex()).."-"..tostring(4))
    local value = math.ceil(ability.property4*1.2)
    CustomNetTables:SetTableValue( "item_properties", tostring(item:GetEntityIndex()).."-"..tostring(4), {propertyValue = value, propertyName = oldProperty.propertyName, propertyColor = oldProperty.propertyColor })
    item.property4 = value
    item.property4name = ability.property4name

    RPCItems:ReduceLevelRequirement(item)

    item.pickedUp = true
    Weapons:Equip(hero, item)
    return item

```

## Light Seer Robes

```
function RPCItems:RollLightSeersRobes(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_templar_light_seers_robe", "immortal", "Templar Light Seer's Robe", "body", true, "Slot: Body")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "light_seer"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#property_light_seer", "#F4E155",  1, "#property_light_seer_Description")
    local luck = RandomInt(1,3)
    if luck == 1 then
        local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
        item.property2 = math.ceil(value*1.5)
        item.property2name = propertyName
        RPCItems:SetPropertyValues(item, item.property2, "rune", "#7DFF12",  2)

        item.hasRunePoints = true
    elseif luck == 2 then
        Elements:RollElementAttribute(item, RPC_ELEMENT_HOLY, 3, 2, 22, 2)
    else
        value, nameLevel = RPCItems:RollAttribute(100, 20, 100, 0, 0, item.rarity, false, maxFactor*18)
        item.property2 = value
        item.property2name = "intelligence"
        RPCItems:SetPropertyValues(item, item.property2, "#item_intelligence", "#33CCFF",  2)
    end

    RPCItems:RollBodyProperty3(item, 0)
    RPCItems:RollBodyProperty4(item, 0)

    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Vermillion Dream Robes

```
function RPCItems:VermillionDreamRobes(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_vermillion_dream_robes", "immortal", "Vermillion Dream Robes", "body", true, "Slot: Body")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "vermillion_dream"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_vermillion_dream_robes", "#D14268",  1, "#property_vermillion_dream_robes_description")

    local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
    item.property2 = math.ceil(value*1.15)
    item.property2name = propertyName
    RPCItems:SetPropertyValues(item, item.property2, "rune", "#7DFF12",  2)

    item.hasRunePoints = true

    RPCItems:RollBodyProperty3(item, 0)
    RPCItems:RollBodyProperty4(item, 0)

    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Windsteed Armor

```
function RPCItems:RollWindsteelArmor(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_windsteel_armor", "immortal", "Windsteel Armor", "body", true, "Slot: Body")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "windsteel"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_windsteel_armor", "#5079D9",  1, "#property_windsteel_armor_description")

    local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
    item.property2 = math.ceil(value*1.4)
    item.property2name = propertyName
    RPCItems:SetPropertyValues(item, item.property2, "rune", "#7DFF12",  2)

    item.hasRunePoints = true

    RPCItems:RollBodyProperty3(item, 0)
    RPCItems:RollBodyProperty4(item, 0)

    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Bluestar Armor

```
function RPCItems:RollBluestarArmor(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_bluestar_armor", "immortal", "Bluestar Armor", "body", true, "Slot: Body")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "bluestar"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_bluestar_armor", "#285EBD",  1, "#property_bluestar_armor_description")

    local value, suffixLevel = RPCItems:RollAttribute(100, 5, 10, 0, 0, item.rarity, false, maxFactor*9)
    item.property2 = value
    item.property2name = "mana_regen"
    RPCItems:SetPropertyValues(item, item.property2, "#item_mana_regen", "#649FA3",  2)

    RPCItems:RollBodyProperty3(item, 0)
    RPCItems:RollBodyProperty4(item, 0)

    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Armor of Atlantis

```
function RPCItems:RollArmorOfAtlantis(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_armor_of_atlantis", "immortal", "Outland Stone Cuirass", "body", true, "Slot: Body")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "atlantis"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#property_armor_of_atlantis", "#478EC1",  1, "#property_armor_of_atlantis_Description")

    local value, prefixLevel = RPCItems:RollAttribute(300, 200, 800, 1, 1, item.rarity, false, maxFactor*800)
    item.property2 = value
    item.property2name = "max_health"
    RPCItems:SetPropertyValues(item, item.property2, "#item_max_health", "#B02020",  2)

    RPCItems:RollBodyProperty3(item, 0)
    RPCItems:RollBodyProperty4(item, 0)

    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Outland Stone Cuirass

```
function RPCItems:RollOutlandStoneCuirass(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_outland_stone_cuirass", "immortal", "Outland Stone Cuirass", "body", true, "Slot: Body")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "outland_stone"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_outland_stone", "#FFB668",  1, "#property_outland_stone_description")

    local value, prefixLevel = RPCItems:RollAttribute(300, 200, 800, 1, 1, item.rarity, false, maxFactor*600)
    item.property2 = value
    item.property2name = "max_health"
    RPCItems:SetPropertyValues(item, item.property2, "#item_max_health", "#B02020",  2)

    RPCItems:RollBodyProperty3(item, 0)
    RPCItems:RollBodyProperty4(item, 0)

    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Blazing Fury Armor

```
function RPCItems:RollBlazingFuryArmor(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_blazing_fury_armor", "immortal", "Blazing Fury Armor", "body", true, "Slot: Body")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "blazing_fury"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_blazing_fury_armor", "#C1513E",  1, "#property_blazing_fury_description")

    local value, nameLevel = RPCItems:RollAttribute(100, 5, 15, 0, 0, item.rarity, false, maxFactor*13)
    item.property2 = value
    item.property2name = "agility"
    RPCItems:SetPropertyValues(item, item.property2, "#item_agility", "#2EB82E",  2)

    RPCItems:RollBodyProperty3(item, 0)
    RPCItems:RollBodyProperty4(item, 0)

    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Vestments of Dark Arts

```
function RPCItems:RollDarkArtsVestments(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_dark_arts_vestments", "immortal", "Vestments of the Dark Arts", "body", true, "Slot: Body")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "dark_arts"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_dark_arts", "#7A3B63",  1, "#property_dark_arts_description")

    item.hasRunePoints = true
    local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
    item.property2 = value*2
    item.property2name = propertyName
    RPCItems:SetPropertyValues(item, item.property2, "rune", "#7DFF12",  2)

    RPCItems:RollBodyProperty3(item, 0)
    RPCItems:RollBodyProperty4(item, 0)

    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Guard of Feronia

```
function RPCItems:RollGuardOfFeronia(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_guard_of_feronia", "immortal", "Guard of Feronia", "body", true, "Slot: Body")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "feronia"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_guard_of_feronia", "#D67CC9",  1, "#property_guard_of_feronia_description")

    item.hasRunePoints = true
    local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
    item.property2 = math.ceil(value*1.3)
    item.property2name = "rune_c_a"
    RPCItems:SetPropertyValues(item, item.property2, "rune", "#7DFF12",  2)

    RPCItems:RollBodyProperty3(item, 0)
    RPCItems:RollBodyProperty4(item, 0)

    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item
end

```

## Dragon Ceremony Vestments

```
function RPCItems:RollDragonCeremonyVestments(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_dragon_ceremony_vestments", "immortal", "Vestments of the Dragon Ceremony", "body", true, "Slot: Body")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "dragon_ceremony"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_dragon_ceremony", "#D4583F",  1, "#property_dragon_ceremony_description")

    item.hasRunePoints = true
    local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
    item.property2 = WallPhysics:round(value*1.5, 0)
    item.property2name = propertyName
    RPCItems:SetPropertyValues(item, item.property2, "rune", "#7DFF12",  2)

    RPCItems:RollBodyProperty3(item, 0)
    RPCItems:RollBodyProperty4(item, 0)

    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Featherwhite armor

```
function RPCItems:RollFeatherwhiteArmor(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_featherwhite_armor", "immortal", "Featherwhite Armor", "body", true, "Slot: Body")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "featherwhite"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_featherwhite_armor", "#FFFFFF",  1, "#property_featherwhite_armor_description")

    item.hasRunePoints = true
    local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
    item.property2 = math.floor(value*1.5)
    item.property2name = propertyName
    RPCItems:SetPropertyValues(item, item.property2, "rune", "#7DFF12",  2)

    RPCItems:RollBodyProperty3(item, 0)
    RPCItems:RollBodyProperty4(item, 0)

    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Depth Crest Armor

```
function RPCItems:RollDepthCrestArmor(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_depth_crest_armor", "immortal", "Depth Crest Armor", "body", true, "Slot: Body")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "depth_crest"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_depth_crest", "#6877E8",  1, "#property_depth_crest_description")

    local value, prefixLevel = RPCItems:RollAttribute(100, 5, 10, 0, 0, item.rarity, false, maxFactor*4)
    item.property2 = value
    item.property2name = "armor"
    RPCItems:SetPropertyValues(item, item.property2, "#item_armor", "#D1D1D1",  2)

    item.hasRunePoints = true
    local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
    item.property3 = math.floor(value*2)
    item.property3name = propertyName
    RPCItems:SetPropertyValues(item, item.property3, "rune", "#7DFF12",  3)

    RPCItems:RollBodyProperty4(item, 0)
    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Sorcerer Regalia

```
function RPCItems:RollSorcererRegalia(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_sorcerers_regalia", "immortal", "Sorcerer's Regalia", "body", true, "Slot: Body")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "sorcerer"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_sorcerers_regalia", "#1996E3",  1, "#property_sorcerers_regalia_description")

    item.hasRunePoints = true
    local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
    item.property2 = value*3
    local luck = RandomInt(1, 3)
    if luck == 1 then
        propertyName = "rune_a_b"
    elseif luck == 2 then
        propertyName = "rune_b_b"
    elseif luck == 3 then
        propertyName = "rune_c_b"
    end
    item.property2name = propertyName
    RPCItems:SetPropertyValues(item, item.property2, "rune", "#7DFF12",  2)

    value, nameLevel = RPCItems:RollAttribute(0, 10, 13, 0, 0, item.rarity, false, maxFactor*14)
    item.property3 = value
    item.property3name = "intelligence"
    RPCItems:SetPropertyValues(item, item.property3, "#item_intelligence", "#33CCFF",  3)

    RPCItems:RollBodyProperty4(item, 0)
    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Empyreal Sunrise Robe

```
function RPCItems:RollEmpyrealSunriseRobe(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_empyreal_sunrise_robe", "immortal", "Empyreal Sunrise Robe", "body", true, "Slot: Body")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "sunrise"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#property_tropical_sunrise", "#F7E37E",  1, "#property_tropical_sunrise_Description")

    local value, nameLevel = RPCItems:RollAttribute(0, 4, 16, 0, 0, item.rarity, false, maxFactor*18)
    item.property2 = value
    item.property2name = "all_attributes"
    RPCItems:SetPropertyValues(item, item.property2, "#item_all_attributes", "#FFFFFF",  2)

    RPCItems:RollBodyProperty3(item, 0)
    RPCItems:RollBodyProperty4(item, 0)
    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Tanari Wind Armor

```
function RPCItems:RollTanariWindArmor(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_ancient_tanari_wind_armor", "immortal", "Ancient Tanari Wind Armor", "body", true, "Slot: Body")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "ancient_tanari"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_tanari_wind_armor", "#C5E7FC",  1, "#property_tanari_wind_armor_description")

    local value, nameLevel = RPCItems:RollAttribute(0, 4, 16, 0, 0, item.rarity, false, maxFactor*18)
    item.property2 = value
    item.property2name = "all_attributes"
    RPCItems:SetPropertyValues(item, item.property2, "#item_all_attributes", "#FFFFFF",  2)

    local luck = RandomInt(1, 3)
    if luck == 1 then
        item.hasRunePoints = true
        local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
        item.property3 = math.ceil(value*1.3)
        item.property3name = propertyName
        RPCItems:SetPropertyValues(item, item.property3, "rune", "#7DFF12",  3)
    elseif luck == 2 then
        item.hasRunePoints = true
        local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
        item.property3 = math.ceil(value*1.0)
        item.property3name = "rune_c_a"
        RPCItems:SetPropertyValues(item, item.property3, "rune", "#7DFF12",  3)
    else
        Elements:RollElementAttribute(item, RPC_ELEMENT_WIND, 2.5, 1, 50, 3)
    end

    RPCItems:RollBodyProperty4(item, 0)
    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Armor of Violet Guard

```
function RPCItems:RollVioletGuardArmor(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_armor_of_violet_guard", "immortal", "Armor of Violet Guard", "body", true, "Slot: Body")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 0
    item.property1name = "violet_guard"
    RPCItems:SetPropertyValuesSpecial(item, 0, "#item_property_violet_guard_armor", "#A337E6",  1, "#property_violet_guard_armor_description")

    item.hasRunePoints = true
    local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
    item.property2 = math.ceil(value*2.4)
    item.property2name = propertyName
    RPCItems:SetPropertyValues(item, item.property2, "rune", "#7DFF12",  2)

    local evasionValue = RandomInt(12, 20)
    item.property3 = evasionValue
    item.property3name = "evasion"
    RPCItems:SetPropertyValues(item, item.property3, "#item_evasion", "#759C7C",  3)

    RPCItems:RollBodyProperty4(item, 0)
    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## TerrasicStonePlate

```
function RPCItems:RollTerrasicStonePlate(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_terrasic_stone_plate", "immortal", "Terrasic Stone Plate", "body", true, "Slot: Body")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "terrasic_stone"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_terrasic_stone", "#BF8154",  1, "#property_terrasic_stone_description")

    local luck = RandomInt(1,3)
    if luck == 1 then
        Elements:RollElementAttribute(item, RPC_ELEMENT_EARTH, 2.7, 2, 32, 2)
    else
        local value, nameLevel = RPCItems:RollAttribute(0, 8, 15, 0, 0, item.rarity, false, maxFactor*15)
        item.property2 = value
        item.property2name = "strength"
        RPCItems:SetPropertyValues(item, item.property2, "#item_strength", "#CC0000",  2)
    end
    RPCItems:RollBodyProperty3(item, 0)
    RPCItems:RollBodyProperty4(item, 0)
    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Sea Giants Plate

```
function RPCItems:RollSeaGiantsPlate(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_sea_giants_plate", "immortal", "Sea Giant's Plate", "body", true, "Slot: Body")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 0
    item.property1name = "sea_giant"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#property_sea_giant_plate", "#C7E8E2",  1, "#property_sea_giant_plate_Description")

    local value, nameLevel = RPCItems:RollAttribute(0, 8, 28, 0, 0, item.rarity, false, maxFactor*28)
    item.property2 = value
    item.property2name = "strength"
    RPCItems:SetPropertyValues(item, item.property2, "#item_strength", "#CC0000",  2)

    RPCItems:RollBodyProperty3(item, 0)
    RPCItems:RollBodyProperty4(item, 0)
    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Avalanche Plate

```
function RPCItems:RollAvalanchePlate(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_avalanche_plate", "immortal", "Avalanche Plate LV1", "body", true, "Slot: Body")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 0
    item.property1name = "avalanche"
    RPCItems:SetPropertyValuesSpecial(item, 0, "#item_property_avalanche", "#9C8C81",  1, "#property_avalanche_description")

    local value, nameLevel = RPCItems:RollAttribute(0, 8, 18, 0, 0, item.rarity, false, maxFactor*18)
    item.property2 = value
    item.property2name = "strength"
    RPCItems:SetPropertyValues(item, item.property2, "#item_strength", "#CC0000",  2)
    RPCItems:RollBodyProperty3(item, 0)
    RPCItems:RollBodyProperty4(item, 0)
    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Claw Of The Ethereal Revenant

```
function RPCItems:RollClawOfTheEtherealRevenant(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_claws_of_the_ethereal_revenant", "immortal", "Claws of the Ethereal Revenant", "hands", true, "Slot: Hands")
    local maxFactor = RPCItems:GetMaxFactor()

    item.property1 = 1
    item.property1name = "ethereal_revenant"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_ethereal_revenant", "#90DFF5",  1, "#property_ethereal_revenant_description")

    item.hasRunePoints = true
    local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
    local luck = RandomInt(1, 4+(GameState:GetDifficultyFactor()*3))
    if luck <= 3 then
        value = math.floor(value*1.3)
        propertyName = "rune_a_b"
    elseif luck <= 6 then
        value = math.floor(value*1.3)
        propertyName = "rune_b_b"
    elseif luck <= 9 then
        value = math.floor(value*1)
        propertyName = "rune_c_b"
    elseif luck == 10 then
        value = math.floor(value*0.7)
        propertyName = "rune_d_b"
    end
    item.property2 = value
    item.property2name = propertyName
    RPCItems:SetPropertyValues(item, item.property2, "rune", "#7DFF12",  2)

    RPCItems:RollHandProperty3(item, 0)
    RPCItems:RollHandProperty4(item, 0)
    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Demonfire Gauntlet

```
function RPCItems:RollDemonfireGauntlet(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_demonfire_gauntlet", "immortal", "Demonfire Gauntlet", "hands", true, "Slot: Hands")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "demonfire"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_demonfire", "#8C1C1C",  1, "#property_demonfire_description")

    item.hasRunePoints = true
    local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
    item.property2 = math.floor(value*1.5)
    item.property2name = propertyName
    RPCItems:SetPropertyValues(item, item.property2, "rune", "#7DFF12",  2)

    RPCItems:RollHandProperty3(item, 0)
    RPCItems:RollHandProperty4(item, 0)
    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Aquasteel Bracers

```
function RPCItems:RollAquasteelBracers(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_aquasteel_bracers", "immortal", "Aquasteel Bracers", "hands", true, "Slot: Hands")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "aquasteel"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_aquasteel", "#56BBEA",  1, "#property_aquasteel_description")

    local value, nameLevel = RPCItems:RollAttribute(0, 3, 14, 0, 0, item.rarity, false, maxFactor*8)
    item.property2 = value
    item.property2name = "armor"
    RPCItems:SetPropertyValues(item, item.property2, "#item_armor", "#D1D1D1",  2)

    item.hasRunePoints = true
    local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
    item.property3 = math.floor(value*1.5)
    item.property3name = propertyName
    RPCItems:SetPropertyValues(item, item.property3, "rune", "#7DFF12",  3)

    RPCItems:RollHandProperty4(item, 0)
    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Royal Wristguards

```
function RPCItems:RollRoyalWristguards(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_royal_wristguards", "immortal", "Royal Wristguards", "hands", true, "Slot: Hands")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "royal_wrist"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_royal_wrist", "#D94848",  1, "#property_royal_wrist_description")

    local maxFactor = RPCItems:GetMaxFactor()
    local value = RandomInt(maxFactor*15, maxFactor*34)*GameState:GetDifficultyFactor()
    item.property2 = value
    item.property2name = "cooldown_reduction"
    RPCItems:SetPropertyValues(item, item.property2, "#item_bonus_attack_damage", "#343EC9",  2)

    item.hasRunePoints = true
    local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
    item.property3 = value*2
    item.property3name = propertyName
    RPCItems:SetPropertyValues(item, item.property3, "rune", "#7DFF12",  3)

    RPCItems:RollHandProperty4(item, 0)
    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Blue Rain Gauntlet

```
function RPCItems:RollBlueRainGauntlet(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_blue_rain_gauntlet", "immortal", "Blue Rain Gauntlet", "hands", true, "Slot: Hands")
    local maxFactor = RPCItems:GetMaxFactor()

    item.property1 = 1
    item.property1name = "blue_rain"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_blue_rain", "#B6DEE3",  1, "#property_blue_rain_description")

    Elements:RollElementAttribute(item, RPC_ELEMENT_WATER, 2.0, 2, 15, 2)

    item.hasRunePoints = true
    local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
    item.property3 = math.floor(value*1.3)
    item.property3name = propertyName
    RPCItems:SetPropertyValues(item, item.property3, "rune", "#7DFF12",  3)

    RPCItems:RollHandProperty4(item, 0)
    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Gravekeepers Gauntlet

```
function RPCItems:RollGravekeepersGauntlet(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_gravekeepers_gauntlet", "immortal", "Gravekeeper's Gauntlet", "hands", true, "Slot: Hands")
    local maxFactor = RPCItems:GetMaxFactor()

    item.property1 = 1
    item.property1name = "gravekeeper"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_gravekeeper_gauntlet", "#94EBFF",  1, "#property_gravekeeper_gauntlet_description")

    local value, nameLevel = RPCItems:RollAttribute(100, 3, 12, 0, 0, item.rarity, false, math.ceil(maxFactor/2.2))
    item.property2 = value
    item.property2name = "base_ability"
    RPCItems:SetPropertyValues(item, item.property2, "#item_base_ability", "#7AB4CC",  2)

    item.hasRunePoints = true
    local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
    item.property3 = math.floor(value*1.5)
    item.property3name = propertyName
    RPCItems:SetPropertyValues(item, item.property3, "rune", "#7DFF12",  3)

    local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
    item.property4 = math.ceil(value*1.5)
    local luck = RandomInt(1, 3)
    if luck == 1 then
        propertyName = "rune_a_b"
    elseif luck == 2 then
        propertyName = "rune_b_b"
    elseif luck == 3 then
        propertyName = "rune_c_b"
    end
    item.property4name = propertyName
    RPCItems:SetPropertyValues(item, item.property4, "rune", "#7DFF12",  4)

    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Halcyon Soul Glove

```
function RPCItems:RollHalcyonSoulGlove(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_halcyon_soul_glove", "immortal", "Halcyon Soul Glove", "hands", true, "Slot: Hands")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "halcyon_soul"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_halcyon_soul", "#E8F274",  1, "#property_halcyon_soul_description")

    local value, nameLevel = RPCItems:RollAttribute(0, 5, 14, 0, 0, item.rarity, false, maxFactor*12)
    item.property2 = value
    item.property2name = "all_attributes"
    RPCItems:SetPropertyValues(item, item.property2, "#item_all_attributes", "#FFFFFF",  2)

    item.hasRunePoints = true
    local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
    item.property3 = math.floor(value*1.5)
    item.property3name = propertyName
    RPCItems:SetPropertyValues(item, item.property3, "rune", "#7DFF12",  3)

    RPCItems:RollHandProperty4(item, 0)
    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Frostburn Gauntlets

```
function RPCItems:RollFrostburnGauntlets(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_frostburn_gauntlets", "immortal", "Frostburn Gauntlets", "hands", true, "Slot: Hands")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "frostburn"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_frostburn_gauntlets", "#7DDAE8",  1, "#property_frostburn_gauntlets_description")

    local value, suffixLevel = RPCItems:RollAttribute(100, 5, 10, 0, 0, item.rarity, false, maxFactor*10)
    item.property2 = value
    item.property2name = "mana_regen"
    RPCItems:SetPropertyValues(item, item.property2, "#item_mana_regen", "#649FA3",  2)

    RPCItems:RollHandProperty3(item, 0)
    RPCItems:RollHandProperty4(item, 0)
    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Shadowflame Fist

```
function RPCItems:RollShadowflameFist(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_shadowflame_fist", "immortal", "Shadowflame Fist", "hands", true, "Slot: Hands")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "shadowflame"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_shadowflame_fist", "#5A25BC",  1, "#property_shadowflame_fist_description")
    local luck = RandomInt(1,2)
    if luck == 1 then
        local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
        item.property2 = value
        item.property2name = propertyName
        RPCItems:SetPropertyValues(item, item.property2, "rune", "#7DFF12",  2)
        item.hasRunePoints = true
    else
        Elements:RollElementAttribute(item, RPC_ELEMENT_SHADOW, 2.4, 2, 24, 2)
    end

    RPCItems:RollHandProperty3(item, 0)
    RPCItems:RollHandProperty4(item, 0)
    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Far seer's gloves

```
function RPCItems:RollFarSeersEnchantedGloves(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_far_seers_enchanted_gloves", "immortal", "Far Seer's Enchanted Gloves", "hands", true, "Slot: Hands")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "far_seer"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_farseer_glove", "#CAD683",  1, "#property_farseer_description")

    local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
    item.property2 = value
    item.property2name = propertyName
    RPCItems:SetPropertyValues(item, item.property2, "rune", "#7DFF12",  2)

    item.hasRunePoints = true

    RPCItems:RollHandProperty3(item, 0)
    RPCItems:RollHandProperty4(item, 0)
    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Ironbound Gloves

```
function RPCItems:RollIronboundGloves(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_ironbound_gloves", "immortal", "Ironbound Gloves", "hands", true, "Slot: Hands")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "ironbound"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_ironbound_gloves", "#CFD2D4",  1, "#property_ironbound_gloves_description")

    local maxFactor = RPCItems:GetMaxFactor()
    local value = RandomInt(maxFactor*2, maxFactor*4)*GameState:GetDifficultyFactor()
    item.property2 = value
    item.property2name = "armor"
    RPCItems:SetPropertyValues(item, item.property2, "#item_armor", "#D1D1D1",  2)

    RPCItems:RollHandProperty3(item, 0)
    RPCItems:RollHandProperty4(item, 0)
    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Depth Demon Claw

```
function RPCItems:RollDepthDemonClaw(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_depth_demon_claw", "immortal", "Depth Demon Claw", "hands", true, "Slot: Hands")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "depth_demon"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#property_depth_demon_claw", "#634F87",  1, "#property_depth_demon_claw_Description")

    Elements:RollElementAttribute(item, RPC_ELEMENT_DEMON, 2.4, 2, 27, 2)

    RPCItems:RollHandProperty3(item, 0)
    RPCItems:RollHandProperty4(item, 0)
    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Dark Emissary Glove

```
function RPCItems:RollDarkEmissaryGlove(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_dark_emissary_glove", "immortal", "Dark Emissary Glove", "hands", true, "Slot: Hands")
    local maxFactor = RPCItems:GetMaxFactor()
    item.property1 = 1
    item.property1name = "dark_emissary"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#property_dark_emissary", "#3E7BBC",  1, "#property_dark_emissary_Description")

    Elements:RollElementAttribute(item, RPC_ELEMENT_GHOST, 2.8, 2, 30, 2)

    RPCItems:RollHandProperty3(item, 0)
    RPCItems:RollHandProperty4(item, 0)
    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Claw of Azinoth

```
function RPCItems:RollClawOfAzinoth(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_claw_of_azinoth", "immortal", "Claw of Azinoth", "hands", true, "Slot: Hands")
    item.property1 = 1
    item.property1name = "azinoth"
    RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_azinoth", "#543553",  1, "#property_azinoth_description")
    item.hasRunePoints = true
    local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
    item.property2 = value*4
    item.property2name = propertyName
    RPCItems:SetPropertyValues(item, item.property2, "rune", "#7DFF12",  2)

    RPCItems:RollHandProperty3(item, 0)
    RPCItems:RollHandProperty4(item, 0)
    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Magebane gloves

```
function RPCItems:RollMageBaneGloves(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_magebane_gloves", "immortal", "Magebane Gloves", "hands", true, "Slot: Hands")
    item.hasRunePoints = true
    local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
    value = math.floor(value*2)
    item.property1 = value
    item.property1name = propertyName
    RPCItems:SetPropertyValues(item, item.property1, "rune", "#7DFF12",  1)
    local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
    value = math.floor(value*2)
    item.property2 = value
    item.property2name = propertyName
    RPCItems:SetPropertyValues(item, item.property2, "rune", "#7DFF12",  2)

    RPCItems:RollHandProperty3(item, 0)
    RPCItems:RollHandProperty4(item, 0)
    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Aquastone ring

```
function RPCItems:RollAquastoneRing(deathLocation)
    local item = RPCItems:CreateVariant("item_rpc_aquastone_ring", "immortal", "Aquastone Ring", "amulet", true, "Slot: Trinket")
    local maxFactor = RPCItems:GetMaxFactor()
    local luck = RandomInt(3, 10)
    value = luck
    item.property1name = "t4_runes"
    item.property1 = value

    RPCItems:SetPropertyValues(item, item.property1, "#item_t4_runes", "#7DFF12",  1)

    local value, nameLevel = RPCItems:RollAttribute(0, 6, 10, 0, 0, item.rarity, false, maxFactor*10)
    item.property2 = value
    item.property2name = "all_attributes"
    RPCItems:SetPropertyValues(item, item.property2, "#item_all_attributes", "#FFFFFF",  2)

    local tier, value, propertyName = RPCItems:RollSkillProperty()
    if tier > 0 then
        item.property3 = value
        item.property3name = propertyName
        RPCItems:SetPropertyValues(item, item.property3, "rune", "#7DFF12",  3)
    end

    local tier, value, propertyName = RPCItems:RollSkillProperty()
    if tier > 0 then
        item.property4 = value
        item.property4name = propertyName
        RPCItems:SetPropertyValues(item, item.property4, "rune", "#7DFF12",  4)
    end

    local drop = CreateItemOnPositionSync( deathLocation, item )
    local position = deathLocation
    RPCItems:DropItem(item, position)
    return item

```

## Carbuncle's Helm of Reflection

```
function RPCItems:RollCarbuncleHelm(deathLocation, isShop)

```

```
   local item = RPCItems:CreateVariant("item_rpc_carbuncles_helm_of_reflection", "immortal", "Carbuncle's Helm of Reflection", "head", true, "Slot: Head")
   local maxFactor = RPCItems:GetMaxFactor()
   item.property1 = 1
   item.property1name = "carbuncle"
   RPCItems:SetPropertyValuesSpecial(item, "★", "#item_property_carbuncle", "#B85454",  1, "#property_carbuncle_description")

```

```
item.hasRunePoints = true

```

```
   local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
   item.property2 = math.ceil(value*1.2)
   item.property2name = propertyName
   RPCItems:SetPropertyValues(item, item.property2, "rune", "#7DFF12",  2)

```

```
   local luck = RandomInt(1,10)
   if luck < 10 then
       local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
       item.property3 = math.ceil(value*1.5)
       item.property3name = propertyName
       RPCItems:SetPropertyValues(item, item.property3, "rune", "#7DFF12",  3)
   else
       local tier, value, propertyName = RPCItems:RollMagebaneRuneProperty()
       item.property3 = math.ceil(value*2.0)
       item.property3name = propertyName
       RPCItems:SetPropertyValues(item, item.property3, "rune", "#7DFF12",  3)
   end

```

```
   RPCItems:RollHoodProperty4(item, 0)
   RPCItems:DropOrGiveItem(hero, item, isShop, deathLocation)
   return item

```