//::///////////////////////////////////////////////
//:: [Item Property Function]
//:: [inc_item_props.nss]
//:://////////////////////////////////////////////
/** @file
    This file defines several functions used to
    manipulate item properties.  In particular,
    It defines functions used in the prc_* files
    to apply passive feat bonuses.

    Take special note of SetCompositeBonus.  This
    function is crucial for allowing bonuses of the
    same type from different PRCs to stack.
*/
//:://////////////////////////////////////////////
//:: Created By: Aaon Graywolf
//:: Created On: Dec 19, 2003
//:://////////////////////////////////////////////
//:: Update: Jan 4 2002
//::    - Extended Composite bonus function to handle pretty much
//::      every property that can possibly be composited.

//////////////////////////////
// Function Prototypes      //
//////////////////////////////

#include "prc_feat_const"
#include "prc_misc_const"

//:: Test void
//:: void main (){}

/**
 * Checks oItem for all properties matching iType and iSubType. Removes all
 * these properties and returns their total CostTableVal.
 * This function should only be used for Item Properties that have simple
 * integer CostTableVals, such as AC, Save/Skill Bonuses, etc.
 *
 * @param oItem    The item on which to look for the itemproperties. Usually a
 *                 skin object.
 * @param iType    ITEM_PROPERTY_* constant of the itemproperty to look for.
 * @param iSubType IP_CONST_* constant of itemproperty SubType if applicable.
 * @return         The total CostTableValue of the itemproperties found
 *                 matching iType and iSubType.
 */
int TotalAndRemoveProperty(object oItem, int iType, int iSubType = -1);

/**
 * Used to roll bonuses from multiple sources into a single property.
 * Only supports properties which have simple integer CostTableVals.
 * See the code for a list of supported types.  Some important properties
 * that CANNOT be composited are SpellResistance, DamageBonus, DamageReduction
 * DamageResistance and MassiveCritical, as these use 2da-referencing constants
 * instead of integers for CostTableVals.
 *
 * <DEPRECATED>
 * LocalInts from SetCompositeBonus() when applied to the skin need to be
 * added to DeletePRCLocalInts() in prc_inc_function in order for the system to
 * properly clear the properties when the itemproperties are removed using
 * ScrubPCSkin().
 * When applied to equipment, the LocalInts need to be added to
 * DeletePRCLocalIntsT() in inc_item_props.
 * </DEPRECATED>
 *
 * Use SetCompositeBonus() for the skin, SetCompositeBonusT() for other equipment.
 *
 *
 * @param oPC      Object wearing / using the item
 * @param oItem    Object to apply bonus to
 * @param sBonus   String name of the source for this bonus
 * @param iVal     Integer value to set this bonus to
 * @param iType    ITEM_PROPERTY_* constant of itemproperty to apply
 * @param iSubType IP_CONST_* constant of itemproperty SubType if applicable
 */
void SetCompositeBonus(object oItem, string sBonus, int iVal, int iType, int iSubType = -1);

/**
 * See SetCompositeBonus(). This is an equivalent, except it applies the itemproperties as
 * temporary ones with duration of 9999 seconds.
 */
void SetCompositeBonusT(object oItem, string sBonus, int iVal, int iType, int iSubType = -1);

/**
 * Calculates the total Bonus AC granted by itemproperties on an item.
 *
 * @param oItem The item to calculate AC bonus given by.
 * @return      The total of all AC bonus itemproperties on oItem.
 */
int GetACBonus(object oItem);

/**
 * Calculates the Base AC (i.e. AC without bonuses) of an item
 *
 * @param oItem The item to calculate base AC for.
 * @return      The base AC, as calculated by removing the value returned by
 *              GetACBonus() on the item from the value returned by GetItemACValue().
 */
int GetBaseAC(object oItem);

/**
 * Gets the itemproperty number of a specific SR value
 */
int GetSRByValue(int nValue);

/**
 * Returns the opposite element from iElem or -1 if iElem is not valid
 * Can be useful for determining elemental strengths and weaknesses
 *
 * @param iElem IP_CONST_DAMAGETYPE_* constant.
 * @return      IP_CONST_DAMAGETYPE_* constant of the opposing damage type.
 */
int GetOppositeElement(int iElem);

/**
 * Used to find the damage type done by any given weapon using 2da lookups.
 * Only usable on weapon items.
 *
 * @param oWeapon The weapon whose damage type to examine.
 * @return        One of IP_CONST_DAMAGETYPE_BLUDGEONING,
 *                       IP_CONST_DAMAGETYPE_PIERCING,
 *                       IP_CONST_DAMAGETYPE_SLASHING
 *                if used on a weapon item. Otherwise -1.
 */
int GetItemPropertyDamageType(object oWeapon);

/**
 * Used to find the damage type done by any given weapon using 2da lookups.
 * Only usable on weapon items.
 *
 * @param oWeapon The weapon whose damage type to examine.
 * @return        One of DAMAGE_TYPE_BLUDGEONING,
 *                       DAMAGE_TYPE_PIERCING,
 *                       DAMAGE_TYPE_SLASHING
 *                if used on a weapon item. Otherwise -1.
 */
int GetItemDamageType(object oWeapon);

/**
 * To ensure a damage bonus stacks with any existing enhancement bonus,
 * create a temporary damage bonus on the weapon.  You do not want to do this
 * if the weapon is of the "slashing and piercing" type, because the
 * enhancement bonus is considered "physical", not "slashing" or "piercing".
 *
 * Because of this strange Bioware behavior, you'll want to only call this code as such:
 *
 * if (StringToInt(Get2DACache("baseitems","WeaponType",GetBaseItemType(oWeapon))) != 4)
 * {
 *     IPEnhancementBonusToDamageBonus(oWeapon);
 * }
 *
 *
 * @param oWeap The weapon to perform the operation on.
 */
void IPEnhancementBonusToDamageBonus(object oWeap);

/**
 * Used to roll bonuses from multiple sources into a single property
 * Only supports damage bonuses in a linear fashion - +1 through +20.
 *
 * Note: If you do not define iSubType, the damage applied will most likely not
 * stack with any enhancement bonus.  See IPEnhancementBonusToDamageBonus() above.
 *
 * <DEPRECATED>
 * LocalInts from SetCompositeDamageBonus() need to be added to
 * DeletePRCLocalInts() in prc_inc_function.
 * LocalInts from SetCompositeDamageBonusT() need to be added to
 * DeletePRCLocalIntsT() in inc_item_props.
 * </DEPRECATED>
 *
 *
 * @param oItem    Object to apply bonus to
 * @param sBonus   String name of the source for this bonus
 * @param iVal     Integer value to set this bonus to (damage +1 through +20)
 * @param iSubType IP_CONST_DAMAGETYPE* constant -- leave blank to use the weapon's damage type.
 */
void SetCompositeDamageBonusT(object oItem, string sBonus, int iVal, int iSubType = -1); // for temporary bonuses

/**
 * Removes a number of itemproperties matching the parameters.
 *
 * @param oItem     The item to remove itemproperties from.
 * @param iType     ITEM_PROPERTY_* constant.
 * @param iSubType  IP_CONST_* constant of the itemproperty subtype or -1 to
 *                  match all possible subtypes. Also use -1 if the itemproperty
 *                  has no subtypes.
 * @param iCostVal  CostTableValue of the itemproperty to remove. Again, -1 for
 *                  any.
 * @param iNum      How many matching itemproperties to remove. -1 for all. Defaults
 *                  to 1.
 * @param sFlag     Name of a local integer on the item to set to 0 when this is run.
 *                  If anyone knows why the fuck this is done, please write here - Ornedan
 * @param iParam1   Param1 value of the itemproperty to remove. Again, -1 for any.
 * @param iDuration DURATION_TYPE_* constant. The duration type of the itemproperty.
 *                  Again, -1 for any.
 */
void RemoveSpecificProperty(object oItem, int iType, int iSubType = -1, int iCostVal = -1, int iNum = 1,
                            string sFlag = "", int iParam1 = -1, int iDuration = DURATION_TYPE_PERMANENT);

/**
 * Finds the first itemproperty matching the parameters.
 *   Use GetIsItemPropertyValid() to check if an itemproperty exists.
 *
 * @param oItem     The item to remove itemproperties from.
 * @param iType     ITEM_PROPERTY_* constant.
 * @param iSubType  IP_CONST_* constant of the itemproperty subtype or -1 to
 *                  match all possible subtypes. Also use -1 if the itemproperty
 *                  has no subtypes.
 * @param iCostVal  CostTableValue of the itemproperty to remove. Again, -1 for
 *                  any.
 * @param iParam1   Param1 value of the itemproperty to remove. Again, -1 for any.
 * @param iDuration DURATION_TYPE_* constant. The duration type of the itemproperty.
 *                  Again, -1 for any.
 */
itemproperty GetSpecificProperty(object oItem, int iType, int iSubType = -1, int iCostVal = -1,
                            int iParam1 = -1, int iDuration = DURATION_TYPE_PERMANENT);

/**
 * Keeps track of Attack Bonus effects and stacks them appropriately... you cannot set up
 * "special" attack bonuses against races or alignments, but it will keep seperate tabs on
 * on-hand attack bonuses and off-hand attack bonuses.
 *
 * NOTE: This attack bonus is an effect on the creature, not an item property.  Item Property
 * attacks have the downside that they pierce DR, whereas effects do not.
 *
 * NOTE: DO *NOT* USE THIS FUNCTION WITH SPELL/SLA EFFECTS.  They stack fine on their own.
 *
 * <DEPRECATED>
 * LocalInts in and finally SetCompositeAttackBonus() need to be added to
 * DeletePRCLocalInts() in prc_inc_function.
 * </DEPRECATED>
 *
 *
 * @param oPC      PC/NPC you wish to apply an attack bonus effect to
 * @param sBonus   The unique name you wish to give this attack bonus
 * @param iVal     The amount the attack bonus should be (there is a hardcoded limit of 20)
 * @param iSubType ATTACK_BONUS_MISC applies to both hands, ATTACK_BONUS_ONHAND applies to the right (main)
 *                 hand, and ATTACK_BONUS_OFFHAND applies to the left (off) hand
 */
void SetCompositeAttackBonus(object oPC, string sBonus, int iVal, int iSubType = ATTACK_BONUS_MISC);

/**
 * Internal function.
 * Handles maintaining a list of composite itemproperty names for
 * use when clearing the itemproperties away.
 *
 * @param oItem      The item a composite bonus is being set on.
 * @param sBase      The base name for the local variables used. For differentiating between
 *                   permanent and temporary lists.
 * @param sComposite The name of a composite property being set.
 */
void UpdateUsedCompositeNamesList(object oItem, string sBase, string sComposite);

/**
 * Internal function.
 * Deletes all the composite itemproperty names listed and deletes the list.
 *
 * @param oItem The item being cleaned of composite properties.
 * @param sBase The base name for the local variables used. For differentiating between
 *              permanent and temporary lists.
 */
void DeleteNamedComposites(object oItem, string sBase);

/**
 * Determines if any of the given item's itemproperties would make it a
 * magical item.
 *
 * @param oItem The item to test
 * @return      TRUE if the item is a magical item, FALSE otherwise
 */
int GetIsMagicItem(object oItem);

/**
 * Special function for adding ip feats to creatures hide.
 * The hide is always equipped so it easier to use GetHasFeat()
 * than to loop over all ips to check if given skin was already
 * added.
 * @param nFeat  The ID of real feat we want to add (row number in feat.2da)
 * @param IPFeat The ID of ip feat (row number in iprp_feats.2da)
 * @param oSkin  Target item to which we add the feat - should be an equipped
 *               creature skin (the script doesn't check it it's valid)
 * @param oPC    Owner of oSkin
 */
void AddSkinFeat(int nFeat, int IPFeat, object oSkin, object oPC = OBJECT_SELF, float fDuration = 0.0f);

//////////////////////////////////////////////////
/* Include section                              */
//////////////////////////////////////////////////

#include "inc_2dacache"
#include "inc_persist_loca"
#include "inc_prc_npc"
//#include "inc_utility"
#include "prc_ipfeat_const"
#include "inc_array"

//////////////////////////////
// Function Definitions     //
//////////////////////////////

int TotalAndRemoveProperty(object oItem, int iType, int iSubType = -1)
{
    itemproperty ip = GetFirstItemProperty(oItem);
    int total = 0;

    while(GetIsItemPropertyValid(ip)){
        if(GetItemPropertyType(ip) == iType && (GetItemPropertySubType(ip) == iSubType || iSubType == -1)){
            total += GetItemPropertyCostTableValue(ip);
            RemoveItemProperty(oItem, ip);
        }
        ip = GetNextItemProperty(oItem);
    }
    return total;
}

itemproperty GetSpecificProperty(object oItem, int iType, int iSubType = -1, int iCostVal = -1,
                            int iParam1 = -1, int iDuration = DURATION_TYPE_PERMANENT)
{
    itemproperty ip = GetFirstItemProperty(oItem);
    while(GetIsItemPropertyValid(ip)){
        if(GetItemPropertyType(ip)            == iType                          &&
           (GetItemPropertyDurationType(ip)   == iDuration || iDuration == -1)  &&
           (GetItemPropertySubType(ip)        == iSubType  || iSubType  == -1)  &&
           (GetItemPropertyCostTableValue(ip) == iCostVal  || iCostVal  == -1)  &&
           (GetItemPropertyParam1Value(ip)    == iParam1   || iParam1   == -1)
          )
        {
            return ip;
        }
        ip = GetNextItemProperty(oItem);
    }
    return ip;
}

void RemoveSpecificProperty(object oItem, int iType, int iSubType = -1, int iCostVal = -1, int iNum = 1,
                            string sFlag = "", int iParam1 = -1, int iDuration = DURATION_TYPE_PERMANENT)
{
    int iRemoved = 0;
    itemproperty ip = GetFirstItemProperty(oItem);
    while(GetIsItemPropertyValid(ip) && (iRemoved < iNum || iNum == -1)){
        if(GetItemPropertyType(ip)            == iType                          &&
           (GetItemPropertyDurationType(ip)   == iDuration || iDuration == -1)  &&
           (GetItemPropertySubType(ip)        == iSubType  || iSubType  == -1)  &&
           (GetItemPropertyCostTableValue(ip) == iCostVal  || iCostVal  == -1)  &&
           (GetItemPropertyParam1Value(ip)    == iParam1   || iParam1   == -1)
          )
        {
            RemoveItemProperty(oItem, ip);
            iRemoved++;
        }
        ip = GetNextItemProperty(oItem);
    }
    SetLocalInt(oItem, sFlag, 0);
}

//SetCompositeBonus is a special case that doesn't need to use DelayAddItemProperty because
//the property that is added is always different from the one that was deleted by TotalAndRemoveProperty.
void SetCompositeBonus(object oItem, string sBonus, int iVal, int iType, int iSubType = -1)
{
    int iOldVal = GetLocalInt(oItem, sBonus);
    int iChange = iVal - iOldVal;
    int iCurVal = 0;

    if(iChange == 0) return;

    // Store the bonus name for use during cleanup
    UpdateUsedCompositeNamesList(oItem, "PRC_CBon", sBonus);

    //Moved TotalAndRemoveProperty into switch to prevent
    //accidental deletion of unsupported property types
    switch(iType)
    {
        case ITEM_PROPERTY_ABILITY_BONUS:
            iCurVal = TotalAndRemoveProperty(oItem, iType, iSubType);
            iCurVal -= GetPersistantLocalInt(GetItemPossessor(oItem), "LetoAbility_"+IntToString(iSubType));
            if (DEBUG) DoDebug("Ability Decrease #1: oItem "+GetName(oItem)+" sBonus "+sBonus+" iChange "+IntToString(iChange)+" iCurVal "+IntToString(iCurVal)+" iSubType "+IntToString(iSubType));
            if ((iCurVal + iChange) > 50)
            {
                iVal -= iCurVal + iChange - 50;
                iCurVal = 50;
                iChange = 0;
            }
            if(iCurVal+iChange > 0)
            {
                AddItemProperty(DURATION_TYPE_PERMANENT, ItemPropertyAbilityBonus(iSubType, iCurVal + iChange), oItem);
                if (DEBUG) DoDebug("Ability Increase");
            }    
            else if(iCurVal+iChange < 0)
            {
            	if (DEBUG) DoDebug("Ability Decrease #2: oItem "+GetName(oItem)+" sBonus "+sBonus+" iChange "+IntToString(iChange)+" iSubType "+IntToString(iSubType));
                AddItemProperty(DURATION_TYPE_PERMANENT, ItemPropertyDecreaseAbility(iSubType, -1*(iCurVal + iChange)), oItem);
            }    
            break;
        case ITEM_PROPERTY_AC_BONUS:
            iCurVal = TotalAndRemoveProperty(oItem, iType);
            if ((iCurVal + iChange)  > 20)
            {
                iVal -= iCurVal + iChange - 20;
                iCurVal = 20;
                iChange = 0;
            }
            if(iCurVal+iChange > 0)
                AddItemProperty(DURATION_TYPE_PERMANENT, ItemPropertyACBonus(iCurVal + iChange), oItem);
            break;
        case ITEM_PROPERTY_AC_BONUS_VS_ALIGNMENT_GROUP:
            iCurVal = TotalAndRemoveProperty(oItem, iType, iSubType);
            if ((iCurVal + iChange)  > 20)
            {
                iVal -= iCurVal + iChange - 20;
                iCurVal = 20;
                iChange = 0;
            }
            if(iCurVal+iChange > 0)
                AddItemProperty(DURATION_TYPE_PERMANENT, ItemPropertyACBonusVsAlign(iSubType, iCurVal + iChange), oItem);
            break;
        case ITEM_PROPERTY_AC_BONUS_VS_DAMAGE_TYPE:
            iCurVal = TotalAndRemoveProperty(oItem, iType, iSubType);
            if ((iCurVal + iChange)  > 20)
            {
                iVal -= iCurVal + iChange - 20;
                iCurVal = 20;
                iChange = 0;
            }
            if(iCurVal+iChange > 0)
                AddItemProperty(DURATION_TYPE_PERMANENT, ItemPropertyACBonusVsDmgType(iSubType, iCurVal + iChange), oItem);
            break;
        case ITEM_PROPERTY_AC_BONUS_VS_RACIAL_GROUP:
            iCurVal = TotalAndRemoveProperty(oItem, iType, iSubType);
            if ((iCurVal + iChange)  > 20)
            {
                iVal -= iCurVal + iChange - 20;
                iCurVal = 20;
                iChange = 0;
            }
            if(iCurVal+iChange > 0)
                AddItemProperty(DURATION_TYPE_PERMANENT, ItemPropertyACBonusVsRace(iSubType, iCurVal + iChange), oItem);
            break;
        case ITEM_PROPERTY_AC_BONUS_VS_SPECIFIC_ALIGNMENT:
            iCurVal = TotalAndRemoveProperty(oItem, iType, iSubType);
            if ((iCurVal + iChange)  > 20)
            {
                iVal -= iCurVal + iChange - 20;
                iCurVal = 20;
                iChange = 0;
            }
            if(iCurVal+iChange > 0)
                AddItemProperty(DURATION_TYPE_PERMANENT, ItemPropertyACBonusVsSAlign(iSubType, iCurVal + iChange), oItem);
            break;
        case ITEM_PROPERTY_ATTACK_BONUS:
            iCurVal = TotalAndRemoveProperty(oItem, iType);
            if ((iCurVal + iChange)  > 20)
            {
                iVal -= iCurVal + iChange - 20;
                iCurVal = 20;
                iChange = 0;
            }
            if(iCurVal+iChange > 0)
                AddItemProperty(DURATION_TYPE_PERMANENT, ItemPropertyAttackBonus(iCurVal + iChange), oItem);
            break;
        case ITEM_PROPERTY_ATTACK_BONUS_VS_ALIGNMENT_GROUP:
            iCurVal = TotalAndRemoveProperty(oItem, iType, iSubType);
            if ((iCurVal + iChange)  > 20)
            {
                iVal -= iCurVal + iChange - 20;
                iCurVal = 20;
                iChange = 0;
            }
            if(iCurVal+iChange > 0)
                AddItemProperty(DURATION_TYPE_PERMANENT, ItemPropertyAttackBonusVsAlign(iSubType, iCurVal + iChange), oItem);
            break;
        case ITEM_PROPERTY_ATTACK_BONUS_VS_RACIAL_GROUP:
            iCurVal = TotalAndRemoveProperty(oItem, iType, iSubType);
            if ((iCurVal + iChange)  > 20)
            {
                iVal -= iCurVal + iChange - 20;
                iCurVal = 20;
                iChange = 0;
            }
            if(iCurVal+iChange > 0)
                AddItemProperty(DURATION_TYPE_PERMANENT, ItemPropertyAttackBonusVsRace(iSubType, iCurVal + iChange), oItem);
            break;
        case ITEM_PROPERTY_ATTACK_BONUS_VS_SPECIFIC_ALIGNMENT:
            iCurVal = TotalAndRemoveProperty(oItem, iType, iSubType);
            if ((iCurVal + iChange)  > 20)
            {
                iVal -= iCurVal + iChange - 20;
                iCurVal = 20;
                iChange = 0;
            }
            if(iCurVal+iChange > 0)
                AddItemProperty(DURATION_TYPE_PERMANENT, ItemPropertyAttackBonusVsSAlign(iSubType, iCurVal + iChange), oItem);
            break;
        case ITEM_PROPERTY_DAMAGE_BONUS_VS_RACIAL_GROUP:
            iCurVal = TotalAndRemoveProperty(oItem, iType, iSubType);
            if ((iCurVal + iChange)  > 20)
            {
                iVal -= iCurVal + iChange - 20;
                iCurVal = 20;
                iChange = 0;
            }
            if(iCurVal+iChange > 0)
                AddItemProperty(DURATION_TYPE_PERMANENT, ItemPropertyDamageBonusVsRace(iSubType, DAMAGE_TYPE_SLASHING, iCurVal + iChange), oItem);
            break;            
        case ITEM_PROPERTY_DECREASED_ABILITY_SCORE:
            iCurVal = TotalAndRemoveProperty(oItem, iType, iSubType);
            if ((iCurVal + iChange)  > 10)
            {
                iVal -= iCurVal + iChange - 10;
                iCurVal = 10;
                iChange = 0;
            }
            if(iCurVal+iChange > 0)
                AddItemProperty(DURATION_TYPE_PERMANENT, ItemPropertyDecreaseAbility(iSubType, iCurVal + iChange), oItem);
            break;
        case ITEM_PROPERTY_DECREASED_AC:
            iCurVal = TotalAndRemoveProperty(oItem, iType, iSubType);
            if ((iCurVal + iChange)  > 5)
            {
                iVal -= iCurVal + iChange - 5;
                iCurVal = 5;
                iChange = 0;
            }
            if(iCurVal+iChange > 0)
                AddItemProperty(DURATION_TYPE_PERMANENT, ItemPropertyDecreaseAC(iSubType, iCurVal + iChange), oItem);
            break;
        case ITEM_PROPERTY_DECREASED_ATTACK_MODIFIER:
            iCurVal = TotalAndRemoveProperty(oItem, iType);
            if ((iCurVal + iChange)  > 5)
            {
                iVal -= iCurVal + iChange - 5;
                iCurVal = 5;
                iChange = 0;
            }
            if(iCurVal+iChange > 0)
                AddItemProperty(DURATION_TYPE_PERMANENT, ItemPropertyAttackPenalty(iCurVal + iChange), oItem);
            break;
        case ITEM_PROPERTY_DECREASED_ENHANCEMENT_MODIFIER:
            iCurVal = TotalAndRemoveProperty(oItem, iType);
            if ((iCurVal + iChange)  > 5)
            {
                iVal -= iCurVal + iChange - 5;
                iCurVal = 5;
                iChange = 0;
            }
            if(iCurVal+iChange > 0)
                AddItemProperty(DURATION_TYPE_PERMANENT, ItemPropertyEnhancementPenalty(iCurVal + iChange), oItem);
            break;
        case ITEM_PROPERTY_DECREASED_SAVING_THROWS:
            iCurVal = TotalAndRemoveProperty(oItem, iType, iSubType);
            if ((iCurVal + iChange)  > 20)
            {
                iVal -= iCurVal + iChange - 20;
                iCurVal = 20;
                iChange = 0;
            }
            if(iCurVal+iChange > 0)
                AddItemProperty(DURATION_TYPE_PERMANENT, ItemPropertyReducedSavingThrow(iSubType, iCurVal + iChange), oItem);
            break;
        case ITEM_PROPERTY_DECREASED_SAVING_THROWS_SPECIFIC:
            iCurVal = TotalAndRemoveProperty(oItem, iType, iSubType);
            if ((iCurVal + iChange)  > 20)
            {
                iVal -= iCurVal + iChange - 20;
                iCurVal = 20;
                iChange = 0;
            }
            if(iCurVal+iChange > 0)
                AddItemProperty(DURATION_TYPE_PERMANENT, ItemPropertyReducedSavingThrowVsX(iSubType, iCurVal + iChange), oItem);
            break;
        case ITEM_PROPERTY_DECREASED_SKILL_MODIFIER:
            iCurVal = TotalAndRemoveProperty(oItem, iType, iSubType);
            if ((iCurVal + iChange)  > 10)
            {
                iVal -= iCurVal + iChange - 10;
                iCurVal = 10;
                iChange = 0;
            }
            if(iCurVal+iChange > 0)
                AddItemProperty(DURATION_TYPE_PERMANENT, ItemPropertyDecreaseSkill(iSubType, iCurVal + iChange), oItem);
            break;
        case ITEM_PROPERTY_ENHANCEMENT_BONUS:
            iCurVal = TotalAndRemoveProperty(oItem, iType);
            if ((iCurVal + iChange)  > 20)
            {
                iVal -= iCurVal + iChange - 20;
                iCurVal = 20;
                iChange = 0;
            }
            if(iCurVal+iChange > 0)
                AddItemProperty(DURATION_TYPE_PERMANENT, ItemPropertyEnhancementBonus(iCurVal + iChange), oItem);
            break;
        case ITEM_PROPERTY_ENHANCEMENT_BONUS_VS_ALIGNMENT_GROUP:
            iCurVal = TotalAndRemoveProperty(oItem, iType, iSubType);
            if ((iCurVal + iChange)  > 20)
            {
                iVal -= iCurVal + iChange - 20;
                iCurVal = 20;
                iChange = 0;
            }
            if(iCurVal+iChange > 0)
                AddItemProperty(DURATION_TYPE_PERMANENT, ItemPropertyEnhancementBonusVsAlign(iSubType, iCurVal + iChange), oItem);
            break;
        case ITEM_PROPERTY_ENHANCEMENT_BONUS_VS_RACIAL_GROUP:
            iCurVal = TotalAndRemoveProperty(oItem, iType);
            if ((iCurVal + iChange)  > 20)
            {
                iVal -= iCurVal + iChange - 20;
                iCurVal = 20;
                iChange = 0;
            }
            if(iCurVal+iChange > 0)
                AddItemProperty(DURATION_TYPE_PERMANENT, ItemPropertyEnhancementBonusVsRace(iSubType, iCurVal + iChange), oItem);
            break;
        case ITEM_PROPERTY_ENHANCEMENT_BONUS_VS_SPECIFIC_ALIGNEMENT:
            iCurVal = TotalAndRemoveProperty(oItem, iType, iSubType);
            if ((iCurVal + iChange)  > 20)
            {
                iVal -= iCurVal + iChange - 20;
                iCurVal = 20;
                iChange = 0;
            }
            if(iCurVal+iChange > 0)
                AddItemProperty(DURATION_TYPE_PERMANENT, ItemPropertyEnhancementBonusVsSAlign(iSubType, iCurVal + iChange), oItem);
            break;
        case ITEM_PROPERTY_MIGHTY:
            iCurVal = TotalAndRemoveProperty(oItem, iType);
            if ((iCurVal + iChange)  > 20)
            {
                iVal -= iCurVal + iChange - 20;
                iCurVal = 20;
                iChange = 0;
            }
            if(iCurVal+iChange > 0)
                AddItemProperty(DURATION_TYPE_PERMANENT, ItemPropertyMaxRangeStrengthMod(iCurVal + iChange), oItem);
            break;
        case ITEM_PROPERTY_REGENERATION:
            iCurVal = TotalAndRemoveProperty(oItem, iType);
            if ((iCurVal + iChange)  > 20)
            {
                iVal -= iCurVal + iChange - 20;
                iCurVal = 20;
                iChange = 0;
            }
            if(iCurVal+iChange > 0)
                AddItemProperty(DURATION_TYPE_PERMANENT, ItemPropertyRegeneration(iCurVal + iChange), oItem);
            break;
        case ITEM_PROPERTY_REGENERATION_VAMPIRIC:
            iCurVal = TotalAndRemoveProperty(oItem, iType);
            if ((iCurVal + iChange)  > 20)
            {
                iVal -= iCurVal + iChange - 20;
                iCurVal = 20;
                iChange = 0;
            }
            if(iCurVal+iChange > 0)
                AddItemProperty(DURATION_TYPE_PERMANENT, ItemPropertyVampiricRegeneration(iCurVal + iChange), oItem);
            break;
        case ITEM_PROPERTY_SAVING_THROW_BONUS:
            iCurVal = TotalAndRemoveProperty(oItem, iType, iSubType);
            if ((iCurVal + iChange)  > 20)
            {
                iVal -= iCurVal + iChange - 20;
                iCurVal = 20;
                iChange = 0;
            }
            if(iCurVal+iChange > 0)
                AddItemProperty(DURATION_TYPE_PERMANENT, ItemPropertyBonusSavingThrowVsX(iSubType, iCurVal + iChange), oItem);
            break;
        case ITEM_PROPERTY_SAVING_THROW_BONUS_SPECIFIC:
            iCurVal = TotalAndRemoveProperty(oItem, iType, iSubType);
            if ((iCurVal + iChange)  > 20)
            {
                iVal -= iCurVal + iChange - 20;
                iCurVal = 20;
                iChange = 0;
            }
            if(iCurVal+iChange > 0)
                AddItemProperty(DURATION_TYPE_PERMANENT, ItemPropertyBonusSavingThrow(iSubType, iCurVal + iChange), oItem);
            break;
        case ITEM_PROPERTY_SKILL_BONUS:
            iCurVal = TotalAndRemoveProperty(oItem, iType, iSubType);
            if ((iCurVal + iChange)  > 50)
            {
                iVal -= iCurVal + iChange - 50;
                iCurVal = 50;
                iChange = 0;
            }
            if(iCurVal+iChange > 0)
                AddItemProperty(DURATION_TYPE_PERMANENT, ItemPropertySkillBonus(iSubType, iCurVal + iChange), oItem);
            break;
    }
    SetLocalInt(oItem, sBonus, iVal);
}

int GetACBonus(object oItem)
{
    if(!GetIsObjectValid(oItem)) return 0;

    itemproperty ip = GetFirstItemProperty(oItem);
    int iTotal = 0;

    while(GetIsItemPropertyValid(ip)){
        if(GetItemPropertyType(ip) == ITEM_PROPERTY_AC_BONUS)
            iTotal += GetItemPropertyCostTableValue(ip);
        ip = GetNextItemProperty(oItem);
    }
    return iTotal;
}

int GetBaseAC(object oItem){ return GetItemACValue(oItem) - GetACBonus(oItem); }

int GetOppositeElement(int iElem)
{
    switch(iElem){
        case IP_CONST_DAMAGETYPE_ACID:
            return DAMAGE_TYPE_ELECTRICAL;
        case IP_CONST_DAMAGETYPE_COLD:
            return IP_CONST_DAMAGETYPE_FIRE;
        case IP_CONST_DAMAGETYPE_DIVINE:
            return IP_CONST_DAMAGETYPE_NEGATIVE;
        case IP_CONST_DAMAGETYPE_ELECTRICAL:
            return IP_CONST_DAMAGETYPE_ACID;
        case IP_CONST_DAMAGETYPE_FIRE:
            return IP_CONST_DAMAGETYPE_COLD;
        case IP_CONST_DAMAGETYPE_NEGATIVE:
            return IP_CONST_DAMAGETYPE_POSITIVE;
     }
     return -1;
}

int TotalAndRemovePropertyT(object oItem, int iType, int iSubType = -1)
{
    itemproperty ip = GetFirstItemProperty(oItem);
    int total = 0;
    int iTemp;

    while(GetIsItemPropertyValid(ip)){
        if(GetItemPropertyType(ip) == iType && (GetItemPropertySubType(ip) == iSubType || iSubType == -1)){
             iTemp = GetItemPropertyCostTableValue(ip);
            total = iTemp > total ? iTemp : total;
            if (GetItemPropertyDurationType(ip)== DURATION_TYPE_TEMPORARY) RemoveItemProperty(oItem, ip);
        }
        ip = GetNextItemProperty(oItem);
    }
    return total;
}

//SetCompositeBonusT is a special case that doesn't need to use DelayAddItemProperty because
//the property that is added is always different from the one that was deleted by TotalAndRemovePropertyT.
void SetCompositeBonusT(object oItem, string sBonus, int iVal, int iType, int iSubType = -1)
{
    int iOldVal = GetLocalInt(oItem, sBonus);
    if (GetLocalInt(GetItemPossessor(oItem),"ONREST")) iOldVal =0;
    int iChange = iVal - iOldVal;
    int iCurVal = 0;

    if(iChange == 0) return;

    // Store the bonus name for use during cleanup
    UpdateUsedCompositeNamesList(oItem, "PRC_CBonT", sBonus);

    //Moved TotalAndRemoveProperty into switch to prevent
    //accidental deletion of unsupported property types
    switch(iType)
    {
        case ITEM_PROPERTY_ABILITY_BONUS:
            iCurVal = TotalAndRemovePropertyT(oItem, iType, iSubType);
            if ((iCurVal + iChange)  > 50)
            {
                iVal -= iCurVal + iChange - 50;
                iCurVal = 50;
                iChange = 0;
            }
            AddItemProperty(DURATION_TYPE_TEMPORARY, ItemPropertyAbilityBonus(iSubType, iCurVal + iChange), oItem,9999.0);
            break;
        case ITEM_PROPERTY_AC_BONUS:
            iCurVal = TotalAndRemovePropertyT(oItem, iType);
            if ((iCurVal + iChange)  > 20)
            {
                iVal -= iCurVal + iChange - 20;
                iCurVal = 20;
                iChange = 0;
            }
            AddItemProperty(DURATION_TYPE_TEMPORARY, ItemPropertyACBonus(iCurVal + iChange), oItem,9999.0);
            break;
        case ITEM_PROPERTY_AC_BONUS_VS_ALIGNMENT_GROUP:
            iCurVal = TotalAndRemovePropertyT(oItem, iType, iSubType);
            if ((iCurVal + iChange)  > 20)
            {
                iVal -= iCurVal + iChange - 20;
                iCurVal = 20;
                iChange = 0;
            }
            AddItemProperty(DURATION_TYPE_TEMPORARY, ItemPropertyACBonusVsAlign(iSubType, iCurVal + iChange), oItem,9999.0);
            break;
        case ITEM_PROPERTY_AC_BONUS_VS_DAMAGE_TYPE:
            iCurVal = TotalAndRemovePropertyT(oItem, iType, iSubType);
            if ((iCurVal + iChange)  > 20)
            {
                iVal -= iCurVal + iChange - 20;
                iCurVal = 20;
                iChange = 0;
            }
            AddItemProperty(DURATION_TYPE_TEMPORARY, ItemPropertyACBonusVsDmgType(iSubType, iCurVal + iChange), oItem,9999.0);
            break;
        case ITEM_PROPERTY_AC_BONUS_VS_RACIAL_GROUP:
            iCurVal = TotalAndRemovePropertyT(oItem, iType, iSubType);
            if ((iCurVal + iChange)  > 20)
            {
                iVal -= iCurVal + iChange - 20;
                iCurVal = 20;
                iChange = 0;
            }
            AddItemProperty(DURATION_TYPE_TEMPORARY, ItemPropertyACBonusVsRace(iSubType, iCurVal + iChange), oItem,9999.0);
            break;
        case ITEM_PROPERTY_AC_BONUS_VS_SPECIFIC_ALIGNMENT:
            iCurVal = TotalAndRemovePropertyT(oItem, iType, iSubType);
            if ((iCurVal + iChange)  > 20)
            {
                iVal -= iCurVal + iChange - 20;
                iCurVal = 20;
                iChange = 0;
            }
            AddItemProperty(DURATION_TYPE_TEMPORARY, ItemPropertyACBonusVsSAlign(iSubType, iCurVal + iChange), oItem,9999.0);
            break;
        case ITEM_PROPERTY_ATTACK_BONUS:
            iCurVal = TotalAndRemovePropertyT(oItem, iType);
            if ((iCurVal + iChange)  > 20)
            {
                iVal -= iCurVal + iChange - 20;
                iCurVal = 20;
                iChange = 0;
            }
            AddItemProperty(DURATION_TYPE_TEMPORARY, ItemPropertyAttackBonus(iCurVal + iChange), oItem,9999.0);
            break;
        case ITEM_PROPERTY_ATTACK_BONUS_VS_ALIGNMENT_GROUP:
            iCurVal = TotalAndRemovePropertyT(oItem, iType, iSubType);
            if ((iCurVal + iChange)  > 20)
            {
                iVal -= iCurVal + iChange - 20;
                iCurVal = 20;
                iChange = 0;
            }
            AddItemProperty(DURATION_TYPE_TEMPORARY, ItemPropertyAttackBonusVsAlign(iSubType, iCurVal + iChange), oItem,9999.0);
            break;
        case ITEM_PROPERTY_ATTACK_BONUS_VS_RACIAL_GROUP:
            iCurVal = TotalAndRemovePropertyT(oItem, iType, iSubType);
            if ((iCurVal + iChange)  > 20)
            {
                iVal -= iCurVal + iChange - 20;
                iCurVal = 20;
                iChange = 0;
            }
            AddItemProperty(DURATION_TYPE_TEMPORARY, ItemPropertyAttackBonusVsRace(iSubType, iCurVal + iChange), oItem,9999.0);
            break;
        case ITEM_PROPERTY_ATTACK_BONUS_VS_SPECIFIC_ALIGNMENT:
            iCurVal = TotalAndRemovePropertyT(oItem, iType, iSubType);
            if ((iCurVal + iChange)  > 20)
            {
                iVal -= iCurVal + iChange - 20;
                iCurVal = 20;
                iChange = 0;
            }
            AddItemProperty(DURATION_TYPE_TEMPORARY, ItemPropertyAttackBonusVsSAlign(iSubType, iCurVal + iChange), oItem,9999.0);
            break;
        case ITEM_PROPERTY_DAMAGE_BONUS_VS_RACIAL_GROUP:
            iCurVal = TotalAndRemoveProperty(oItem, iType, iSubType);
            if ((iCurVal + iChange)  > 20)
            {
                iVal -= iCurVal + iChange - 20;
                iCurVal = 20;
                iChange = 0;
            }
            if(iCurVal+iChange > 0)
                AddItemProperty(DURATION_TYPE_PERMANENT, ItemPropertyDamageBonusVsRace(iSubType,  DAMAGE_TYPE_SLASHING, iCurVal + iChange), oItem);
            break;              
        case ITEM_PROPERTY_DECREASED_ABILITY_SCORE:
            iCurVal = TotalAndRemovePropertyT(oItem, iType, iSubType);
            if ((iCurVal + iChange)  > 20)
            {
                iVal -= iCurVal + iChange - 20;
                iCurVal = 20;
                iChange = 0;
            }
            AddItemProperty(DURATION_TYPE_TEMPORARY, ItemPropertyDecreaseAbility(iSubType, iCurVal + iChange), oItem,9999.0);
            break;
        case ITEM_PROPERTY_DECREASED_AC:
            iCurVal = TotalAndRemovePropertyT(oItem, iType, iSubType);
            if ((iCurVal + iChange)  > 5)
            {
                iVal -= iCurVal + iChange - 5;
                iCurVal = 5;
                iChange = 0;
            }
            AddItemProperty(DURATION_TYPE_TEMPORARY, ItemPropertyDecreaseAC(iSubType, iCurVal + iChange), oItem,9999.0);
            break;
        case ITEM_PROPERTY_DECREASED_ATTACK_MODIFIER:
            iCurVal = TotalAndRemovePropertyT(oItem, iType);
            if ((iCurVal + iChange)  > 5)
            {
                iVal -= iCurVal + iChange - 5;
                iCurVal = 5;
                iChange = 0;
            }
            AddItemProperty(DURATION_TYPE_TEMPORARY, ItemPropertyAttackPenalty(iCurVal + iChange), oItem,9999.0);
            break;
        case ITEM_PROPERTY_DECREASED_ENHANCEMENT_MODIFIER:
            iCurVal = TotalAndRemovePropertyT(oItem, iType);
            if ((iCurVal + iChange)  > 5)
            {
                iVal -= iCurVal + iChange - 5;
                iCurVal = 5;
                iChange = 0;
            }
            AddItemProperty(DURATION_TYPE_TEMPORARY, ItemPropertyEnhancementPenalty(iCurVal + iChange), oItem,9999.0);
            break;
        case ITEM_PROPERTY_DECREASED_SAVING_THROWS:
            iCurVal = TotalAndRemovePropertyT(oItem, iType, iSubType);
            if ((iCurVal + iChange)  > 20)
            {
                iVal -= iCurVal + iChange - 20;
                iCurVal = 20;
                iChange = 0;
            }
            AddItemProperty(DURATION_TYPE_TEMPORARY, ItemPropertyReducedSavingThrowVsX(iSubType, iCurVal + iChange), oItem,9999.0);
            break;
        case ITEM_PROPERTY_DECREASED_SAVING_THROWS_SPECIFIC:
            iCurVal = TotalAndRemovePropertyT(oItem, iType, iSubType);
            if ((iCurVal + iChange)  > 20)
            {
                iVal -= iCurVal + iChange - 20;
                iCurVal = 20;
                iChange = 0;
            }
            AddItemProperty(DURATION_TYPE_TEMPORARY, ItemPropertyReducedSavingThrow(iSubType, iCurVal + iChange), oItem,9999.0);
            break;
        case ITEM_PROPERTY_DECREASED_SKILL_MODIFIER:
            iCurVal = TotalAndRemovePropertyT(oItem, iType, iSubType);
            if ((iCurVal + iChange)  > 10)
            {
                iVal -= iCurVal + iChange - 10;
                iCurVal = 10;
                iChange = 0;
            }
            AddItemProperty(DURATION_TYPE_TEMPORARY, ItemPropertyDecreaseSkill(iSubType, iCurVal + iChange), oItem,9999.0);
            break;
        case ITEM_PROPERTY_ENHANCEMENT_BONUS:
            iCurVal = TotalAndRemovePropertyT(oItem, iType);
            if ((iCurVal + iChange)  > 20)
            {
                iVal -= iCurVal + iChange - 20;
                iCurVal = 20;
                iChange = 0;
            }
            AddItemProperty(DURATION_TYPE_TEMPORARY, ItemPropertyEnhancementBonus(iCurVal + iChange), oItem,9999.0);
            break;
        case ITEM_PROPERTY_ENHANCEMENT_BONUS_VS_ALIGNMENT_GROUP:
            iCurVal = TotalAndRemovePropertyT(oItem, iType, iSubType);
            if ((iCurVal + iChange)  > 20)
            {
                iVal -= iCurVal + iChange - 20;
                iCurVal = 20;
                iChange = 0;
            }
            AddItemProperty(DURATION_TYPE_TEMPORARY, ItemPropertyEnhancementBonusVsAlign(iSubType, iCurVal + iChange), oItem,9999.0);
            break;
        case ITEM_PROPERTY_ENHANCEMENT_BONUS_VS_RACIAL_GROUP:
            iCurVal = TotalAndRemovePropertyT(oItem, iType);
            if ((iCurVal + iChange)  > 20)
            {
                iVal -= iCurVal + iChange - 20;
                iCurVal = 20;
                iChange = 0;
            }
            AddItemProperty(DURATION_TYPE_TEMPORARY, ItemPropertyEnhancementBonusVsRace(iSubType, iCurVal + iChange), oItem,9999.0);
            break;
        case ITEM_PROPERTY_ENHANCEMENT_BONUS_VS_SPECIFIC_ALIGNEMENT:
            iCurVal = TotalAndRemovePropertyT(oItem, iType, iSubType);
            if ((iCurVal + iChange)  > 20)
            {
                iVal -= iCurVal + iChange - 20;
                iCurVal = 20;
                iChange = 0;
            }
            AddItemProperty(DURATION_TYPE_TEMPORARY, ItemPropertyEnhancementBonusVsSAlign(iSubType, iCurVal + iChange), oItem,9999.0);
            break;
        case ITEM_PROPERTY_MIGHTY:
            iCurVal = TotalAndRemovePropertyT(oItem, iType);
            if ((iCurVal + iChange)  > 20)
            {
                iVal -= iCurVal + iChange - 20;
                iCurVal = 20;
                iChange = 0;
            }
            AddItemProperty(DURATION_TYPE_TEMPORARY, ItemPropertyMaxRangeStrengthMod(iCurVal + iChange), oItem,9999.0);
            break;
        case ITEM_PROPERTY_REGENERATION:
            iCurVal = TotalAndRemovePropertyT(oItem, iType);
            if ((iCurVal + iChange)  > 20)
            {
                iVal -= iCurVal + iChange - 20;
                iCurVal = 20;
                iChange = 0;
            }
            AddItemProperty(DURATION_TYPE_TEMPORARY, ItemPropertyRegeneration(iCurVal + iChange), oItem,9999.0);
            break;
        case ITEM_PROPERTY_REGENERATION_VAMPIRIC:
            iCurVal = TotalAndRemovePropertyT(oItem, iType);
            if ((iCurVal + iChange)  > 20)
            {
                iVal -= iCurVal + iChange - 20;
                iCurVal = 20;
                iChange = 0;
            }
            AddItemProperty(DURATION_TYPE_TEMPORARY, ItemPropertyVampiricRegeneration(iCurVal + iChange), oItem,9999.0);
            break;
        case ITEM_PROPERTY_SAVING_THROW_BONUS:
            iCurVal = TotalAndRemovePropertyT(oItem, iType, iSubType);
            if ((iCurVal + iChange)  > 20)
            {
                iVal -= iCurVal + iChange - 20;
                iCurVal = 20;
                iChange = 0;
            }
            AddItemProperty(DURATION_TYPE_TEMPORARY, ItemPropertyBonusSavingThrowVsX(iSubType, iCurVal + iChange), oItem,9999.0);
            break;
        case ITEM_PROPERTY_SAVING_THROW_BONUS_SPECIFIC:
            iCurVal = TotalAndRemovePropertyT(oItem, iType, iSubType);
            if ((iCurVal + iChange)  > 20)
            {
                iVal -= iCurVal + iChange - 20;
                iCurVal = 20;
                iChange = 0;
            }
            AddItemProperty(DURATION_TYPE_TEMPORARY, ItemPropertyBonusSavingThrow(iSubType, iCurVal + iChange), oItem,9999.0);
            break;
        case ITEM_PROPERTY_SKILL_BONUS:
            iCurVal = TotalAndRemovePropertyT(oItem, iType, iSubType);
            if ((iCurVal + iChange)  > 50)
            {
                iVal -= iCurVal + iChange - 50;
                iCurVal = 50;
                iChange = 0;
            }
            AddItemProperty(DURATION_TYPE_TEMPORARY, ItemPropertySkillBonus(iSubType, iCurVal + iChange), oItem,9999.0);
            break;
    }
    SetLocalInt(oItem, sBonus, iVal);
}

int GetItemPropertyDamageType(object oWeapon)
{
    if(GetObjectType(oWeapon) != OBJECT_TYPE_ITEM)
        return -1;

    int iWeaponType = GetBaseItemType(oWeapon);
    int iDamageType = StringToInt(Get2DACache("baseitems","WeaponType",iWeaponType));
    switch(iDamageType)
    {
        case 1: return IP_CONST_DAMAGETYPE_PIERCING;    break;
        case 2: return IP_CONST_DAMAGETYPE_BLUDGEONING; break;
        case 3: return IP_CONST_DAMAGETYPE_SLASHING;    break;
        case 4: return IP_CONST_DAMAGETYPE_SLASHING;    break; // slashing & piercing... slashing bonus.

        default: return -1;
    }
    return -1;
}

int GetItemDamageType(object oWeapon)
{
    if(GetObjectType(oWeapon) != OBJECT_TYPE_ITEM)
        return -1;

    int iWeaponType = GetBaseItemType(oWeapon);
    int iDamageType = StringToInt( Get2DACache("baseitems","WeaponType",iWeaponType) );
    switch(iDamageType)
    {
        case 1: return DAMAGE_TYPE_PIERCING;    break;
        case 2: return DAMAGE_TYPE_BLUDGEONING; break;
        case 3: return DAMAGE_TYPE_SLASHING;    break;
        case 4: return DAMAGE_TYPE_SLASHING;    break; // slashing & piercing... slashing bonus.

        default: return -1;
    }
    return -1;
}

// To ensure the damage bonus stacks with any existing enhancement bonus,
// we create a temporary damage bonus on the weapon.  We do not want to do this
// if the weapon is of the "slashing and piercing" type, because the
// enhancement bonus is considered "physical", not "slashing" or "piercing".
// If you borrow this code, make sure to keep the "IPEnh" and realize that
// "slashing and piercing" weapons need a special case.
void IPEnhancementBonusToDamageBonus(object oWeap)
{
    int iBonus = 0;
    int iTemp;

    if (GetLocalInt(oWeap, "IPEnh") || !GetIsObjectValid(oWeap)) return;

    itemproperty ip = GetFirstItemProperty(oWeap);
    while(GetIsItemPropertyValid(ip))
    {
        if(GetItemPropertyType(ip) == ITEM_PROPERTY_ENHANCEMENT_BONUS)
            iTemp = GetItemPropertyCostTableValue(ip);
            iBonus = iTemp > iBonus ? iTemp : iBonus;
        ip = GetNextItemProperty(oWeap);
    }

    SetCompositeDamageBonusT(oWeap,"IPEnh",iBonus);
}

int TotalAndRemoveDamagePropertyT(object oItem, int iSubType)
{
    itemproperty ip = GetFirstItemProperty(oItem);
    int iPropertyValue;
    int total = 0;
    int iTemp;

    while(GetIsItemPropertyValid(ip))
    {
        iPropertyValue = GetItemPropertyCostTableValue(ip);

        if((GetItemPropertyType(ip) == ITEM_PROPERTY_DAMAGE_BONUS) &&
           (GetItemPropertySubType(ip) == iSubType) &&
           ((iPropertyValue < 6) || (iPropertyValue > 15)))
        {
            total = iPropertyValue > total ? iPropertyValue : total;
            if (GetItemPropertyDurationType(ip)== DURATION_TYPE_TEMPORARY) RemoveItemProperty(oItem, ip);
       }
        ip = GetNextItemProperty(oItem);

    }
    return total;
}

void SetCompositeDamageBonusT(object oItem, string sBonus, int iVal, int iSubType = -1)
{
    int iOldVal = GetLocalInt(oItem, sBonus);
    int iChange = iVal - iOldVal;
    int iLinearDamage = 0;
    int iCurVal = 0;

    if(iChange == 0) return;

    // Store the bonus name for use during cleanup
    UpdateUsedCompositeNamesList(oItem, "PRC_CBonT", sBonus);

    if (iSubType == -1) iSubType = GetItemPropertyDamageType(oItem);
    if (iSubType == -1) return;  // if it's still -1 we're not dealing with a weapon.

    iCurVal = TotalAndRemoveDamagePropertyT(oItem, iSubType);

    if (iCurVal > 15) iCurVal -= 10; // values 6-20 are in the 2da as lines 16-30
    iLinearDamage = iCurVal + iChange;
    if (iLinearDamage > 20)
    {
        iVal = iLinearDamage - 20; // Change the stored value to reflect the fact that we overflowed
        iLinearDamage = 20; // This is prior to adjustment due to non-linear values
    }
    if (iLinearDamage > 5) iLinearDamage += 10; // values 6-20 are in the 2da as lines 16-30
    AddItemProperty(DURATION_TYPE_TEMPORARY, ItemPropertyDamageBonus(iSubType, iLinearDamage), oItem,9999.0);

    SetLocalInt(oItem, sBonus, iVal);
}

void TotalRemovePropertyT(object oItem)
{
    itemproperty ip = GetFirstItemProperty(oItem);
    while(GetIsItemPropertyValid(ip))
    {
        if(GetItemPropertyDurationType(ip)== DURATION_TYPE_TEMPORARY)
            RemoveItemProperty(oItem, ip);
        ip = GetNextItemProperty(oItem);
    }
}

void DeletePRCLocalIntsT(object oPC, object oItem = OBJECT_INVALID)
{
    // See if we were given a valid item as parameter. If we were, we
    // will be removing ints from it.
    // Otherwise, we will take the item in each slot and removing the
    // ints that should be on it.
    int bGivenObject = GetIsObjectValid(oItem);

    // RIGHT HAND
    if(!bGivenObject)
        oItem = GetItemInSlot(INVENTORY_SLOT_RIGHTHAND,oPC);

    if(bGivenObject || GetIsObjectValid(oItem))
    {
        // Clear composite bonuses
        TotalRemovePropertyT(oItem);
        DeleteNamedComposites(oItem, "PRC_CBonT");

        /* Clear other stuff
         *
         * All the commented out values are the ones that didn't seem to be used anywhere anymore - Ornedan
         */
        //Stormlord
        DeleteLocalInt(oItem,"STShock"); /// @todo Rewrite the Stormlord not to directly manipulate values
        DeleteLocalInt(oItem,"STThund");
        DeleteLocalInt(oItem,"ManArmsCore");
        //Vile/Sanctify & Un/Holy Martial Strike
        DeleteLocalInt(oItem,"SanctMar");
        DeleteLocalInt(oItem,"MartialStrik");
        DeleteLocalInt(oItem,"UnholyStrik");
        DeleteLocalInt(oItem,"USanctMar");
        //Duelist Precise Strike
        DeleteLocalInt(oItem,"DuelistPreciseSlash");
        //DeleteLocalInt(oItem,"DuelistPreciseSmash");
        // Dispater
        DeleteLocalInt(oItem,"DispIronPowerA");
        DeleteLocalInt(oItem,"DispIronPowerD");
        // Dragonwrack
        DeleteLocalInt(oItem,"DWright");
    }

    // LEFT HAND
    if(!bGivenObject)
        oItem = GetItemInSlot(INVENTORY_SLOT_LEFTHAND,oPC);

    if(bGivenObject || GetIsObjectValid(oItem))
    {
        if(!bGivenObject)
        {
            // Clear composite bonuses
            TotalRemovePropertyT(oItem);
            DeleteNamedComposites(oItem, "PRC_CBonT");
        }

        //Vile/Sanctify & Un/Holy Martial Strike
        DeleteLocalInt(oItem,"SanctMar");
        DeleteLocalInt(oItem,"MartialStrik");
        DeleteLocalInt(oItem,"UnholyStrik");
        DeleteLocalInt(oItem,"USanctMar");
        // Dragonwrack
        DeleteLocalInt(oItem,"DWleft");
        // Dispater
        DeleteLocalInt(oItem,"DispIronPowerA");
        DeleteLocalInt(oItem,"DispIronPowerD");
    }

    // CHEST
    if(!bGivenObject)
        oItem = GetItemInSlot(INVENTORY_SLOT_CHEST,oPC);

    if(bGivenObject || GetIsObjectValid(oItem))
    {
        if(!bGivenObject)
        {
            // Clear composite bonuses
            TotalRemovePropertyT(oItem);
            DeleteNamedComposites(oItem, "PRC_CBonT");
        }
        // Frenzied Berzerker
        DeleteLocalInt(oItem,"AFrenzy");
        // Shadowlord
        DeleteLocalInt(oItem,"ShaDiscorp");
        // Dragonwrack
        DeleteLocalInt(oItem,"Dragonwrack");
    }

    // LEFT RING
    if(!bGivenObject)
        oItem = GetItemInSlot(INVENTORY_SLOT_LEFTRING,oPC);

    if(bGivenObject || GetIsObjectValid(oItem))
    {
        if(!bGivenObject)
        {
            // Clear composite bonuses
            TotalRemovePropertyT(oItem);
            DeleteNamedComposites(oItem, "PRC_CBonT");
        }
    }

    // ARMS
    if(!bGivenObject)
        oItem = GetItemInSlot(INVENTORY_SLOT_ARMS,oPC);

    if(bGivenObject || GetIsObjectValid(oItem))
    {
        if(!bGivenObject)
        {
            // Clear composite bonuses
            TotalRemovePropertyT(oItem);
            DeleteNamedComposites(oItem, "PRC_CBonT");
        }

        // Disciple of Mephistopheles
        DeleteLocalInt(oItem,"DiscMephGlove");
    }
}

void SetCompositeAttackBonus(object oPC, string sBonus, int iVal, int iSubType = ATTACK_BONUS_MISC)
{
    object oCastingObject = CreateObject(OBJECT_TYPE_PLACEABLE, "x0_rodwonder", GetLocation(oPC));

    int iSpl = 2732; //SPELL_SET_COMPOSITE_ATTACK_BONUS;

    SetLocalString(oCastingObject, "SET_COMPOSITE_STRING", sBonus);
    SetLocalInt(oCastingObject, "SET_COMPOSITE_VALUE", iVal);
    SetLocalInt(oCastingObject, "SET_COMPOSITE_SUBTYPE", iSubType);

    DelayCommand(0.1, AssignCommand(oCastingObject, ActionCastSpellAtObject(iSpl, oPC, METAMAGIC_NONE, TRUE, 0, PROJECTILE_PATH_TYPE_DEFAULT, TRUE)));

    DestroyObject(oCastingObject, 6.0);
}

int GetSRByValue(int nValue)
{
    switch(nValue)
    {
        case  1: return 52;
        case  2: return 53;
        case  3: return 54;
        case  4: return 55;
        case  5: return 56;
        case  6: return 57;
        case  7: return 58;
        case  8: return 59;
        case  9: return 60;
        case 10: return  0;
        case 12: return  1;
        case 14: return  2;
        case 16: return  3;
        case 18: return  4;
        case 20: return  5;
        case 22: return  6;
        case 24: return  7;
        case 26: return  8;
        case 28: return  9;
        case 30: return 10;
        case 32: return 11;
        case 34: return 12;
        case 36: return 13;
        case 38: return 14;
        case 40: return 15;
        case 42: return 16;
        case 44: return 17;
        case 46: return 18;
        case 48: return 19;
        case 50: return 20;
        case 52: return 21;
        case 54: return 22;
        case 56: return 23;
        case 58: return 24;
        case 60: return 25;
        case 11: return 26;
        case 13: return 27;
        case 15: return 28;
        case 17: return 29;
        case 19: return 30;
        case 21: return 31;
        case 23: return 32;
        case 25: return 33;
        case 27: return 34;
        case 29: return 35;
        case 31: return 36;
        case 33: return 37;
        case 35: return 38;
        case 37: return 39;
        case 39: return 40;
        case 41: return 41;
        case 43: return 42;
        case 45: return 43;
        case 47: return 44;
        case 49: return 45;
        case 51: return 46;
        case 53: return 47;
        case 55: return 48;
        case 57: return 49;
        case 59: return 50;
        case 61: return 51;
    }
    if(nValue < 1)
        return -1;
    if(nValue > 98)
        return 61;//99 max
    if(nValue > 61)
        return 51;//61 flat cap
    return -1;
}

void UpdateUsedCompositeNamesList(object oItem, string sBase, string sComposite)
{
    // Add the bonus name to the list if it isn't there already
    if(!GetLocalInt(oItem, sBase + "_Exist_" + sComposite))
    {
        if(DEBUG) DoDebug("Storing the composite name '" + sComposite + "' for later deletion");

        string sArrayName = sBase + "_Names";
        // Create the array if it doesn't exist already
        if(!array_exists(oItem, sArrayName))
            array_create(oItem, sArrayName);

        // Store the bonus name in a list
        array_set_string(oItem, sArrayName, array_get_size(oItem, sArrayName), sComposite);

        // Store a marker so we don't need to loop over the list to find out if the name has been stored already
        SetLocalInt(oItem, sBase + "_Exist_" + sComposite, TRUE);
    }
}

void DeleteNamedComposites(object oItem, string sBase)
{
    if(DEBUG) DoDebug("Deleting composite bonus list '" + sBase + "' on " + DebugObject2Str(oItem));

    string sArrayName = sBase + "_Names";
    string sComposite;
    int nMax = array_get_size(oItem, sArrayName);
    int i = 0;

    // Delete all composite values and markers
    for(; i < nMax; i++)
    {
        sComposite = array_get_string(oItem, sArrayName, i);
        if(DEBUG) DoDebug("Deleting bonus marker '" + sComposite + "'");
        DeleteLocalInt(oItem, sComposite);
        DeleteLocalInt(oItem, sBase + "_Exist_" + sComposite);
    }

    // Delete the array
    array_delete(oItem, sArrayName);
}

int GetIsMagicItem(object oItem)
{
    itemproperty ip = GetFirstItemProperty(oItem);
    int nType;
    int nSubtype;
    while(GetIsItemPropertyValid(ip))   //loop through item properties looking for a magical one
    {
        if(GetItemPropertyDurationType(ip) == DURATION_TYPE_PERMANENT)
        {   //ignore temporary properties
            nType = GetItemPropertyType(ip);
            if((nType >= 0 && nType <= 9) ||    //read from itempropdef.2da
                (nType >= 13 && nType <= 20) ||
                (nType == 26) ||
                (nType >= 32 && nType <= 44) ||
                (nType == 46) ||
                (nType >= 51 && nType <= 59) ||
                (nType == 61) ||
                (nType >= 67 && nType <= 69) ||
                (nType >= 71 && nType <= 80) ||
                (nType == 82) ||
                (nType == 84) ||
                (nType >= 100 && nType <= 101) ||
                (nType >= 133 && nType <= 134))
            {
                return 1;   //magical property
            }
            nSubtype = GetItemPropertySubType(ip);

            if(nType == ITEM_PROPERTY_BONUS_FEAT)
            {
                if(GetBaseItemType(oItem) == BASE_ITEM_WHIP)
                {
                    if(nSubtype != IP_CONST_FEAT_DISARM_WHIP)
                        return 1;
                }
                else
                    return 1;
            }
            ip = GetNextItemProperty(oItem);
        }
    }
    return 0;
}

int FeatToIprop(int nFeat)
{
            switch(nFeat)
            {
            case FEAT_WEAPON_FOCUS_BASTARD_SWORD: 	return IP_CONST_FEAT_WEAPON_FOCUS_BASTARD_SWORD;
            case FEAT_WEAPON_FOCUS_BATTLE_AXE: 		return IP_CONST_FEAT_WEAPON_FOCUS_BATTLE_AXE;
            case FEAT_WEAPON_FOCUS_CLUB: 			return IP_CONST_FEAT_WEAPON_FOCUS_CLUB;
            case FEAT_WEAPON_FOCUS_DAGGER: 			return IP_CONST_FEAT_WEAPON_FOCUS_DAGGER;
            case FEAT_WEAPON_FOCUS_DART: 			return IP_CONST_FEAT_WEAPON_FOCUS_DART;
            case FEAT_WEAPON_FOCUS_DIRE_MACE: 		return IP_CONST_FEAT_WEAPON_FOCUS_DIRE_MACE;
            case FEAT_WEAPON_FOCUS_DOUBLE_AXE: 		return IP_CONST_FEAT_WEAPON_FOCUS_DOUBLE_AXE;
            case FEAT_WEAPON_FOCUS_DWAXE: 			return IP_CONST_FEAT_WEAPON_FOCUS_DWAXE;
            case FEAT_WEAPON_FOCUS_GREAT_AXE: 		return IP_CONST_FEAT_WEAPON_FOCUS_GREAT_AXE;
            case FEAT_WEAPON_FOCUS_GREAT_SWORD: 	return IP_CONST_FEAT_WEAPON_FOCUS_GREAT_SWORD;
            case FEAT_WEAPON_FOCUS_HALBERD: 		return IP_CONST_FEAT_WEAPON_FOCUS_HALBERD;
            case FEAT_WEAPON_FOCUS_HAND_AXE: 		return IP_CONST_FEAT_WEAPON_FOCUS_HAND_AXE;
            case FEAT_WEAPON_FOCUS_HEAVY_CROSSBOW: 	return IP_CONST_FEAT_WEAPON_FOCUS_HEAVY_CROSSBOW;
            case FEAT_WEAPON_FOCUS_HEAVY_FLAIL: 	return IP_CONST_FEAT_WEAPON_FOCUS_HEAVY_FLAIL;
            case FEAT_WEAPON_FOCUS_KAMA: 			return IP_CONST_FEAT_WEAPON_FOCUS_KAMA;
            case FEAT_WEAPON_FOCUS_KATANA: 			return IP_CONST_FEAT_WEAPON_FOCUS_KATANA;
            case FEAT_WEAPON_FOCUS_KUKRI: 			return IP_CONST_FEAT_WEAPON_FOCUS_KUKRI;
            case FEAT_WEAPON_FOCUS_LIGHT_CROSSBOW: 	return IP_CONST_FEAT_WEAPON_FOCUS_LIGHT_CROSSBOW;
            case FEAT_WEAPON_FOCUS_LIGHT_FLAIL: 	return IP_CONST_FEAT_WEAPON_FOCUS_LIGHT_FLAIL;
            case FEAT_WEAPON_FOCUS_LIGHT_HAMMER: 	return IP_CONST_FEAT_WEAPON_FOCUS_LIGHT_HAMMER;
            case FEAT_WEAPON_FOCUS_LIGHT_MACE: 		return IP_CONST_FEAT_WEAPON_FOCUS_LIGHT_MACE;
            case FEAT_WEAPON_FOCUS_LONG_SWORD: 		return IP_CONST_FEAT_WEAPON_FOCUS_LONG_SWORD;
            case FEAT_WEAPON_FOCUS_LONGBOW: 		return IP_CONST_FEAT_WEAPON_FOCUS_LONGBOW;
            case FEAT_WEAPON_FOCUS_MORNING_STAR: 	return IP_CONST_FEAT_WEAPON_FOCUS_MORNING_STAR;
            case FEAT_WEAPON_FOCUS_STAFF: 			return IP_CONST_FEAT_WEAPON_FOCUS_STAFF;
            case FEAT_WEAPON_FOCUS_RAPIER: 			return IP_CONST_FEAT_WEAPON_FOCUS_RAPIER;
            case FEAT_WEAPON_FOCUS_SCIMITAR: 		return IP_CONST_FEAT_WEAPON_FOCUS_SCIMITAR;
            case FEAT_WEAPON_FOCUS_SCYTHE: 			return IP_CONST_FEAT_WEAPON_FOCUS_SCYTHE;
            case FEAT_WEAPON_FOCUS_SHORTBOW: 		return IP_CONST_FEAT_WEAPON_FOCUS_SHORTBOW;
            case FEAT_WEAPON_FOCUS_SPEAR: 			return IP_CONST_FEAT_WEAPON_FOCUS_SPEAR;
            case FEAT_WEAPON_FOCUS_SHORT_SWORD: 	return IP_CONST_FEAT_WEAPON_FOCUS_SHORT_SWORD;
            case FEAT_WEAPON_FOCUS_SHURIKEN: 		return IP_CONST_FEAT_WEAPON_FOCUS_SHURIKEN;
            case FEAT_WEAPON_FOCUS_SICKLE: 			return IP_CONST_FEAT_WEAPON_FOCUS_SICKLE;
            case FEAT_WEAPON_FOCUS_SLING: 			 return IP_CONST_FEAT_WEAPON_FOCUS_SLING;
            case FEAT_WEAPON_FOCUS_THROWING_AXE: 	 return IP_CONST_FEAT_WEAPON_FOCUS_THROWING_AXE;
            case FEAT_WEAPON_FOCUS_TWO_BLADED_SWORD: return IP_CONST_FEAT_WEAPON_FOCUS_TWO_BLADED_SWORD;
            case FEAT_WEAPON_FOCUS_WAR_HAMMER: 		 return IP_CONST_FEAT_WEAPON_FOCUS_WAR_HAMMER;
            case FEAT_WEAPON_FOCUS_WHIP:			 return IP_CONST_FEAT_WEAPON_FOCUS_WHIP;
			case FEAT_WEAPON_FOCUS_EAGLE_CLAW:		 return IP_CONST_FEAT_WEAPON_FOCUS_EAGLE_CLAW;
			case FEAT_WEAPON_FOCUS_FALCHION:		 return IP_CONST_FEAT_WEAPON_FOCUS_FALCHION;
			case FEAT_WEAPON_FOCUS_HEAVY_MACE:	   	 return IP_CONST_FEAT_WEAPON_FOCUS_HEAVY_MACE;
			case FEAT_WEAPON_FOCUS_LIGHT_PICK:		 return IP_CONST_FEAT_WEAPON_FOCUS_LIGHT_PICK;
			case FEAT_WEAPON_FOCUS_HEAVY_PICK:		 return IP_CONST_FEAT_WEAPON_FOCUS_HEAVY_PICK;
			case FEAT_WEAPON_FOCUS_KATAR:			 return IP_CONST_FEAT_WEAPON_FOCUS_KATAR;
			case FEAT_WEAPON_FOCUS_SAI:			 	 return IP_CONST_FEAT_WEAPON_FOCUS_SAI;	
			case FEAT_WEAPON_FOCUS_NUNCHAKU:		 return IP_CONST_FEAT_WEAPON_FOCUS_NUNCHAKU;	
			case FEAT_WEAPON_FOCUS_MAUL:			 return IP_CONST_FEAT_WEAPON_FOCUS_MAUL;	
			case FEAT_WEAPON_FOCUS_SAP:			 	 return IP_CONST_FEAT_WEAPON_FOCUS_SAP;	
			case FEAT_WEAPON_FOCUS_DOUBLE_SCIMITAR:  return IP_CONST_FEAT_WEAPON_FOCUS_DOUBLE_SCIMITAR;
			case FEAT_WEAPON_FOCUS_GOAD:			 return IP_CONST_FEAT_WEAPON_FOCUS_GOAD;		
			case FEAT_WEAPON_FOCUS_TRIDENT:			 return IP_CONST_FEAT_WEAPON_FOCUS_TRIDENT;			
			case FEAT_WEAPON_FOCUS_ELVEN_LIGHTBLADE: return IP_CONST_FEAT_WEAPON_FOCUS_ELVEN_LIGHTBLADE;
			case FEAT_WEAPON_FOCUS_ELVEN_THINBLADE:  return IP_CONST_FEAT_WEAPON_FOCUS_ELVEN_THINBLADE;
			case FEAT_WEAPON_FOCUS_ELVEN_COURTBLADE: return IP_CONST_FEAT_WEAPON_FOCUS_ELVEN_COURTBLADE;   
		

        case FEAT_WEAPON_SPECIALIZATION_CLUB: return              IP_CONST_FEAT_WEAPON_SPECIALIZATION_CLUB              ;
        case FEAT_WEAPON_SPECIALIZATION_DAGGER: return            IP_CONST_FEAT_WEAPON_SPECIALIZATION_DAGGER            ;
        case FEAT_WEAPON_SPECIALIZATION_DART: return              IP_CONST_FEAT_WEAPON_SPECIALIZATION_DART              ;
        case FEAT_WEAPON_SPECIALIZATION_HEAVY_CROSSBOW: return    IP_CONST_FEAT_WEAPON_SPECIALIZATION_HEAVY_CROSSBOW    ;
        case FEAT_WEAPON_SPECIALIZATION_LIGHT_CROSSBOW: return    IP_CONST_FEAT_WEAPON_SPECIALIZATION_LIGHT_CROSSBOW    ;
        case FEAT_WEAPON_SPECIALIZATION_LIGHT_MACE: return        IP_CONST_FEAT_WEAPON_SPECIALIZATION_LIGHT_MACE        ;
        case FEAT_WEAPON_SPECIALIZATION_MORNING_STAR: return      IP_CONST_FEAT_WEAPON_SPECIALIZATION_MORNING_STAR      ;
        case FEAT_WEAPON_SPECIALIZATION_STAFF: return             IP_CONST_FEAT_WEAPON_SPECIALIZATION_STAFF             ;
        case FEAT_WEAPON_SPECIALIZATION_SPEAR: return             IP_CONST_FEAT_WEAPON_SPECIALIZATION_SPEAR             ;
        case FEAT_WEAPON_SPECIALIZATION_SICKLE: return            IP_CONST_FEAT_WEAPON_SPECIALIZATION_SICKLE            ;
        case FEAT_WEAPON_SPECIALIZATION_SLING: return             IP_CONST_FEAT_WEAPON_SPECIALIZATION_SLING             ;
        case FEAT_WEAPON_SPECIALIZATION_UNARMED_STRIKE: return    IP_CONST_FEAT_WEAPON_SPECIALIZATION_UNARMED_STRIKE    ;
        case FEAT_WEAPON_SPECIALIZATION_LONGBOW: return           IP_CONST_FEAT_WEAPON_SPECIALIZATION_LONGBOW           ;
        case FEAT_WEAPON_SPECIALIZATION_SHORTBOW: return          IP_CONST_FEAT_WEAPON_SPECIALIZATION_SHORTBOW          ;
        case FEAT_WEAPON_SPECIALIZATION_SHORT_SWORD: return       IP_CONST_FEAT_WEAPON_SPECIALIZATION_SHORT_SWORD       ;
        case FEAT_WEAPON_SPECIALIZATION_RAPIER: return            IP_CONST_FEAT_WEAPON_SPECIALIZATION_RAPIER            ;
        case FEAT_WEAPON_SPECIALIZATION_SCIMITAR: return          IP_CONST_FEAT_WEAPON_SPECIALIZATION_SCIMITAR          ;
        case FEAT_WEAPON_SPECIALIZATION_LONG_SWORD: return        IP_CONST_FEAT_WEAPON_SPECIALIZATION_LONG_SWORD        ;
        case FEAT_WEAPON_SPECIALIZATION_GREAT_SWORD: return       IP_CONST_FEAT_WEAPON_SPECIALIZATION_GREAT_SWORD       ;
        case FEAT_WEAPON_SPECIALIZATION_HAND_AXE: return          IP_CONST_FEAT_WEAPON_SPECIALIZATION_HAND_AXE          ;
        case FEAT_WEAPON_SPECIALIZATION_THROWING_AXE: return      IP_CONST_FEAT_WEAPON_SPECIALIZATION_THROWING_AXE      ;
        case FEAT_WEAPON_SPECIALIZATION_BATTLE_AXE: return        IP_CONST_FEAT_WEAPON_SPECIALIZATION_BATTLE_AXE        ;
        case FEAT_WEAPON_SPECIALIZATION_GREAT_AXE: return         IP_CONST_FEAT_WEAPON_SPECIALIZATION_GREAT_AXE         ;
        case FEAT_WEAPON_SPECIALIZATION_HALBERD: return           IP_CONST_FEAT_WEAPON_SPECIALIZATION_HALBERD           ;
        case FEAT_WEAPON_SPECIALIZATION_LIGHT_HAMMER: return      IP_CONST_FEAT_WEAPON_SPECIALIZATION_LIGHT_HAMMER      ;
        case FEAT_WEAPON_SPECIALIZATION_LIGHT_FLAIL: return       IP_CONST_FEAT_WEAPON_SPECIALIZATION_LIGHT_FLAIL       ;
        case FEAT_WEAPON_SPECIALIZATION_WAR_HAMMER: return        IP_CONST_FEAT_WEAPON_SPECIALIZATION_WAR_HAMMER        ;
        case FEAT_WEAPON_SPECIALIZATION_HEAVY_FLAIL: return       IP_CONST_FEAT_WEAPON_SPECIALIZATION_HEAVY_FLAIL       ;
        case FEAT_WEAPON_SPECIALIZATION_KAMA: return              IP_CONST_FEAT_WEAPON_SPECIALIZATION_KAMA              ;
        case FEAT_WEAPON_SPECIALIZATION_KUKRI: return             IP_CONST_FEAT_WEAPON_SPECIALIZATION_KUKRI             ;
        case FEAT_WEAPON_SPECIALIZATION_SHURIKEN: return          IP_CONST_FEAT_WEAPON_SPECIALIZATION_SHURIKEN          ;
        case FEAT_WEAPON_SPECIALIZATION_SCYTHE: return            IP_CONST_FEAT_WEAPON_SPECIALIZATION_SCYTHE            ;
        case FEAT_WEAPON_SPECIALIZATION_KATANA: return            IP_CONST_FEAT_WEAPON_SPECIALIZATION_KATANA            ;
        case FEAT_WEAPON_SPECIALIZATION_BASTARD_SWORD: return     IP_CONST_FEAT_WEAPON_SPECIALIZATION_BASTARD_SWORD     ;
        case FEAT_WEAPON_SPECIALIZATION_DIRE_MACE: return         IP_CONST_FEAT_WEAPON_SPECIALIZATION_DIRE_MACE         ;
        case FEAT_WEAPON_SPECIALIZATION_DOUBLE_AXE: return        IP_CONST_FEAT_WEAPON_SPECIALIZATION_DOUBLE_AXE        ;
        case FEAT_WEAPON_SPECIALIZATION_TWO_BLADED_SWORD: 	return IP_CONST_FEAT_WEAPON_SPECIALIZATION_TWO_BLADED_SWORD;
        case FEAT_WEAPON_SPECIALIZATION_DWAXE: 				return IP_CONST_FEAT_WEAPON_SPECIALIZATION_DWAXE;
        case FEAT_WEAPON_SPECIALIZATION_WHIP: 				return IP_CONST_FEAT_WEAPON_SPECIALIZATION_WHIP;	
		case FEAT_WEAPON_SPECIALIZATION_ELVEN_LIGHTBLADE: 	return IP_CONST_FEAT_WEAPON_SPECIALIZATION_ELVEN_LIGHTBLADE;
		case FEAT_WEAPON_SPECIALIZATION_ELVEN_THINBLADE: 	return IP_CONST_FEAT_WEAPON_SPECIALIZATION_ELVEN_THINBLADE;
		case FEAT_WEAPON_SPECIALIZATION_ELVEN_COURTBLADE: 	return IP_CONST_FEAT_WEAPON_SPECIALIZATION_ELVEN_COURTBLADE;		
            }
    return - 1;
}

int FocusToWeapProf(int nFeat)
{
    switch(nFeat)
    {
        case FEAT_WEAPON_FOCUS_CLUB:             	return BASE_ITEM_CLUB;
        case FEAT_WEAPON_FOCUS_DAGGER:           	return BASE_ITEM_DAGGER;
        case FEAT_WEAPON_FOCUS_DART:             	return BASE_ITEM_DART;
        case FEAT_WEAPON_FOCUS_HEAVY_CROSSBOW:   	return BASE_ITEM_HEAVYCROSSBOW;
        case FEAT_WEAPON_FOCUS_LIGHT_CROSSBOW:   	return BASE_ITEM_LIGHTCROSSBOW;
        case FEAT_WEAPON_FOCUS_LIGHT_MACE:       	return BASE_ITEM_LIGHTMACE;
        case FEAT_WEAPON_FOCUS_MORNING_STAR:     	return BASE_ITEM_MORNINGSTAR;
        case FEAT_WEAPON_FOCUS_STAFF:            	return BASE_ITEM_QUARTERSTAFF;
        case FEAT_WEAPON_FOCUS_SPEAR:            	return BASE_ITEM_SHORTSPEAR;
        case FEAT_WEAPON_FOCUS_SICKLE:           	return BASE_ITEM_SICKLE;
        case FEAT_WEAPON_FOCUS_SLING:            	return BASE_ITEM_SLING;
        case FEAT_WEAPON_FOCUS_LONGBOW:          	return BASE_ITEM_LONGBOW;
        case FEAT_WEAPON_FOCUS_SHORTBOW:         	return BASE_ITEM_SHORTBOW;
        case FEAT_WEAPON_FOCUS_SHORT_SWORD:      	return BASE_ITEM_SHORTSWORD;
        case FEAT_WEAPON_FOCUS_RAPIER:           	return BASE_ITEM_RAPIER;
        case FEAT_WEAPON_FOCUS_SCIMITAR:         	return BASE_ITEM_SCIMITAR;
        case FEAT_WEAPON_FOCUS_LONG_SWORD:       	return BASE_ITEM_LONGSWORD;
        case FEAT_WEAPON_FOCUS_GREAT_SWORD:      	return BASE_ITEM_GREATSWORD;
        case FEAT_WEAPON_FOCUS_HAND_AXE:         	return BASE_ITEM_HANDAXE;
        case FEAT_WEAPON_FOCUS_THROWING_AXE:     	return BASE_ITEM_THROWINGAXE;
        case FEAT_WEAPON_FOCUS_BATTLE_AXE:       	return BASE_ITEM_BATTLEAXE;
        case FEAT_WEAPON_FOCUS_GREAT_AXE:        	return BASE_ITEM_GREATAXE;
        case FEAT_WEAPON_FOCUS_HALBERD:          	return BASE_ITEM_HALBERD;
        case FEAT_WEAPON_FOCUS_LIGHT_HAMMER:     	return BASE_ITEM_LIGHTHAMMER;
        case FEAT_WEAPON_FOCUS_LIGHT_FLAIL:      	return BASE_ITEM_LIGHTFLAIL;
        case FEAT_WEAPON_FOCUS_WAR_HAMMER:       	return BASE_ITEM_WARHAMMER;
        case FEAT_WEAPON_FOCUS_HEAVY_FLAIL:      	return BASE_ITEM_HEAVYFLAIL;
        case FEAT_WEAPON_FOCUS_KAMA:             	return BASE_ITEM_KAMA;
        case FEAT_WEAPON_FOCUS_KUKRI:            	return BASE_ITEM_KUKRI;
        case FEAT_WEAPON_FOCUS_SHURIKEN:         	return BASE_ITEM_SHURIKEN;
        case FEAT_WEAPON_FOCUS_SCYTHE:           	return BASE_ITEM_SCYTHE;
        case FEAT_WEAPON_FOCUS_KATANA:           	return BASE_ITEM_KATANA;
        case FEAT_WEAPON_FOCUS_BASTARD_SWORD:    	return BASE_ITEM_BASTARDSWORD;
        case FEAT_WEAPON_FOCUS_DIRE_MACE:        	return BASE_ITEM_DIREMACE;
        case FEAT_WEAPON_FOCUS_DOUBLE_AXE:       	return BASE_ITEM_DOUBLEAXE;
        case FEAT_WEAPON_FOCUS_TWO_BLADED_SWORD: 	return BASE_ITEM_TWOBLADEDSWORD;
        case FEAT_WEAPON_FOCUS_DWAXE:            	return BASE_ITEM_DWARVENWARAXE;
        case FEAT_WEAPON_FOCUS_WHIP:             	return BASE_ITEM_WHIP;
		case FEAT_WEAPON_FOCUS_EAGLE_CLAW:		 	return BASE_ITEM_EAGLE_CLAW;
		case FEAT_WEAPON_FOCUS_FALCHION:		 	return BASE_ITEM_FALCHION;
		case FEAT_WEAPON_FOCUS_GOAD:			 	return BASE_ITEM_GOAD;
		case FEAT_WEAPON_FOCUS_HEAVY_MACE:	   	 	return BASE_ITEM_HEAVY_MACE;
		case FEAT_WEAPON_FOCUS_LIGHT_PICK:		 	return BASE_ITEM_LIGHT_PICK;
		case FEAT_WEAPON_FOCUS_HEAVY_PICK:		 	return BASE_ITEM_HEAVY_PICK;
		case FEAT_WEAPON_FOCUS_KATAR:			 	return BASE_ITEM_KATAR;
		case FEAT_WEAPON_FOCUS_SAI:			 	 	return BASE_ITEM_SAI;	
		case FEAT_WEAPON_FOCUS_NUNCHAKU:		 	return BASE_ITEM_NUNCHAKU;	
		case FEAT_WEAPON_FOCUS_MAUL:			 	return BASE_ITEM_MAUL;	
		case FEAT_WEAPON_FOCUS_SAP:			 	 	return BASE_ITEM_SAP;	
		case FEAT_WEAPON_FOCUS_DOUBLE_SCIMITAR:  	return BASE_ITEM_DOUBLE_SCIMITAR;
		case FEAT_WEAPON_FOCUS_TRIDENT:			 	return BASE_ITEM_TRIDENT;
		case FEAT_WEAPON_FOCUS_ELVEN_LIGHTBLADE:	return BASE_ITEM_ELVEN_LIGHTBLADE;
		case FEAT_WEAPON_FOCUS_ELVEN_THINBLADE:		return BASE_ITEM_ELVEN_THINBLADE;
		case FEAT_WEAPON_FOCUS_ELVEN_COURTBLADE:	return BASE_ITEM_ELVEN_COURTBLADE;
				
    }
    return - 1;
}

void AddSkinFeat(int nFeat, int IPFeat, object oSkin, object oPC = OBJECT_SELF, float fDuration = 0.0f)
{
    // Already has that feat - do nothing
    if(GetHasFeat(nFeat, oPC))
        return;

    int nDurType = fDuration == 0.0f ? DURATION_TYPE_PERMANENT : DURATION_TYPE_TEMPORARY;

    AddItemProperty(nDurType, ItemPropertyBonusFeat(IPFeat), oSkin, fDuration);
}