/*

    This include governs all the new itemproperties
    Both restrictions and features

*/
//:: Updated for .35 by Jaysyn 2023/03/10

//////////////////////////////////////////////////
/*                 Constants                    */
//////////////////////////////////////////////////

const string PLAYER_SPEED_INCREASE = "player_speed_increase";
const string PLAYER_SPEED_DECREASE = "player_speed_decrease";


//////////////////////////////////////////////////
/*             Function prototypes              */
//////////////////////////////////////////////////

int DoUMDCheck(object oItem, object oPC, int nDCMod);

int CheckPRCLimitations(object oItem, object oPC = OBJECT_INVALID);

/**
 * Non-returning wrapper for CheckPRCLimitations.
 */
void VoidCheckPRCLimitations(object oItem, object oPC = OBJECT_INVALID);

void CheckForPnPHolyAvenger(object oItem);


//////////////////////////////////////////////////
/*                  Includes                    */
//////////////////////////////////////////////////

#include "inc_utility"
#include "prc_inc_newip"


//////////////////////////////////////////////////
/*             Internal functions               */
//////////////////////////////////////////////////

/*void _prc_inc_itmrstr_ApplySpeedModification(object oPC, int nEffectType, int nSpeedMod)
{
    if(DEBUG) DoDebug("_prc_inc_itmrstr_ApplySpeedModification(" + DebugObject2Str(oPC) + ", " + IntToString(nEffectType) + ", " + IntToString(nSpeedMod) + ")");
    // The skin object should be OBJECT_SELF here
    // Clean up existing speed modification
    effect eTest = GetFirstEffect(oPC);
    while(GetIsEffectValid(eTest))
    {
        if(GetEffectCreator(eTest) == OBJECT_SELF         &&
           GetEffectType(eTest)    == nEffectType         &&
           GetEffectSubType(eTest) == SUBTYPE_SUPERNATURAL
           )
            RemoveEffect(oPC, eTest);
        eTest = GetNextEffect(oPC);
    }

    // Apply speed mod if there is any
    if(nSpeedMod > 0)
    {
        effect eSpeedMod = SupernaturalEffect(nEffectType == EFFECT_TYPE_MOVEMENT_SPEED_INCREASE ?
                                               EffectMovementSpeedIncrease(nSpeedMod) :
                                               EffectMovementSpeedDecrease(nSpeedMod)
                                              );
        /// @todo Determine if the delay is actually needed here
        DelayCommand(0.5, ApplyEffectToObject(DURATION_TYPE_PERMANENT, eSpeedMod, oPC));
    }
}

void _prc_inc_itmrstr_ApplySpeedIncrease(object oPC)
{
    // Get target speed modification value. Limit to 99, since that's the effect constructor maximum value
    int nSpeedMod = PRCMin(99, GetLocalInt(oPC, PLAYER_SPEED_INCREASE));
    object oSkin = GetPCSkin(oPC);

    AssignCommand(oSkin, _prc_inc_itmrstr_ApplySpeedModification(oPC, EFFECT_TYPE_MOVEMENT_SPEED_INCREASE, nSpeedMod));
}


void _prc_inc_itmrstr_ApplySpeedDecrease(object oPC)
{
    // Get target speed modification value. Limit to 99, since that's the effect constructor maximum value
    int nSpeedMod = GetLocalInt(oPC, PLAYER_SPEED_DECREASE);
    object oSkin = GetPCSkin(oPC);

    AssignCommand(oSkin, _prc_inc_itmrstr_ApplySpeedModification(oPC, EFFECT_TYPE_MOVEMENT_SPEED_DECREASE, nSpeedMod));
}*/

void _prc_inc_itmrstr_ApplyAoE(object oPC, object oItem, int nSubType, int nCost)
{
    int nAoEID    = StringToInt(Get2DACache("iprp_aoe", "AoEID", nSubType));
    string sTag   = Get2DACache("vfx_persistent", "LABEL", nAoEID);
    effect eAoE   = EffectAreaOfEffect(nAoEID,
                    Get2DACache("iprp_aoe", "EnterScript", nSubType),
                    Get2DACache("iprp_aoe", "HBScript",    nSubType),
                    Get2DACache("iprp_aoe", "ExitScript",  nSubType));

    // The item applies the AoE effect
    ApplyEffectToObject(DURATION_TYPE_PERMANENT, eAoE, oPC);

    // Get an object reference to the newly created AoE
    location lLoc = GetLocation(oPC);
    object oAoE = GetFirstObjectInShape(SHAPE_SPHERE, 1.0f, lLoc, FALSE, OBJECT_TYPE_AREA_OF_EFFECT);
    while(GetIsObjectValid(oAoE))
    {
        // Test if we found the correct AoE
        if(GetTag(oAoE) == sTag &&
           !GetLocalInt(oAoE, "PRC_AoE_IPRP_Init")
           )
        {
            SetLocalInt(oAoE, "PRC_AoE_IPRP_Init", TRUE);
            break;
        }
        // Didn't find, get next
        oAoE = GetNextObjectInShape(SHAPE_SPHERE, 1.0f, lLoc, FALSE, OBJECT_TYPE_AREA_OF_EFFECT);
    }
    if(!GetIsObjectValid(oAoE)) DoDebug("ERROR: _prc_inc_itmrstr_ApplyAoE: Can't find AoE created by " + DebugObject2Str(oItem));

    // Set caster level override on the AoE
    SetLocalInt(oAoE, PRC_CASTERLEVEL_OVERRIDE, nCost);
    //if(DEBUG) DoDebug("_prc_inc_itmrstr_ApplyAoE: AoE level: " + IntToString(nCost));
}

void _prc_inc_itmrstr_ApplyWizardry(object oPC, object oItem, int nSpellLevel, string sType)
{
    //properties were already applied - happens when loading a saved game
    if(GetLocalInt(oItem, "PRC_Wizardry"+IntToString(nSpellLevel)))
        return;

    SetLocalInt(oItem, "PRC_Wizardry"+IntToString(nSpellLevel), TRUE);
    int nClass, nSlots, i;
    for(i = 1; i <= 8; i++)
    {
        nClass = GetClassByPosition(i, oPC);
        if((sType == "A" && GetIsArcaneClass(nClass)) || (sType == "D" && GetIsDivineClass(nClass)))
        {
            if(GetAbilityScoreForClass(nClass, oPC) < nSpellLevel + 10)
                continue;

            int nSpellSlotLevel = GetSpellslotLevel(nClass, oPC) - 1;
            string sFile = Get2DACache("classes", "SpellGainTable", nClass);
            nSlots = StringToInt(Get2DACache(sFile, "SpellLevel" + IntToString(nSpellLevel), nSpellSlotLevel));
            //if(DEBUG) DoDebug("Adding "+IntToString(nSlots)" bonus slots for "+IntToString(nClass)" class.");

            if(nSlots)
            {
                string sVar = "PRC_IPRPBonSpellSlots_" + IntToString(nClass) + "_" + IntToString(nSpellLevel);
                int j = 0;
                while(j < nSlots)
                {
                    //DoDebug(IntToString(j));
                    AddItemProperty(DURATION_TYPE_PERMANENT, ItemPropertyBonusLevelSpell(nClass, nSpellLevel), oItem);
                    //nsb compatibility
                    SetLocalInt(oPC, sVar, (GetLocalInt(oPC, sVar) + 1));
                    j++;
                }
            }
        }
    }
    SetPlotFlag(oItem, TRUE);
}

void _prc_inc_itmrstr_RemoveWizardry(object oPC, object oItem, int nSpellLevel, string sType)
{
    DeleteLocalInt(oItem, "PRC_Wizardry"+IntToString(nSpellLevel));
    SetPlotFlag(oItem, FALSE);
    itemproperty ipTest = GetFirstItemProperty(oItem);
    string sVar;
    while(GetIsItemPropertyValid(ipTest))
    {
        if(GetItemPropertyType(ipTest) == ITEM_PROPERTY_BONUS_SPELL_SLOT_OF_LEVEL_N)
        {
            if(GetItemPropertyCostTableValue(ipTest) == nSpellLevel)
            {
                int nClass = GetItemPropertySubType(ipTest);
                if((sType == "A" && GetIsArcaneClass(nClass)) || (sType == "D" && GetIsDivineClass(nClass)))
                {
                    RemoveItemProperty(oItem, ipTest);
                    //remove bonus slots from nsb classes
                    sVar = "PRC_IPRPBonSpellSlots_" + IntToString(nClass) + "_" + IntToString(nSpellLevel);
                    SetLocalInt(oPC, sVar, (GetLocalInt(oPC, sVar) - 1));
                    int nCount, nSpellbook = GetSpellbookTypeForClass(nClass);
                    string sArray = "NewSpellbookMem_"+IntToString(nClass);
                    if(nSpellbook == SPELLBOOK_TYPE_SPONTANEOUS)
                    {
                        nCount = persistant_array_get_int(oPC, sArray, nSpellLevel);
                        if(nCount)
                        {
                            nCount--;
                            persistant_array_set_int(oPC, sArray, nSpellLevel, nCount);
                        }
                    }
                    else if(nSpellbook == SPELLBOOK_TYPE_PREPARED)
                    {
                        string sIDX = "SpellbookIDX" + IntToString(nSpellLevel) + "_" + IntToString(nClass);
                        int i, nSpellbookID, nMax = persistant_array_get_size(oPC, sIDX) - 1;
                        for(i = nMax; i >= 0; i--)
                        {
                            nSpellbookID = persistant_array_get_int(oPC, sIDX, i);
                            nCount = persistant_array_get_int(oPC, sArray, nSpellbookID);
                            if(nCount)
                            {
                                nCount--;
                                persistant_array_set_int(oPC, sArray, nSpellbookID, nCount);
                                break;
                            }
                        }
                    }
                }
            }
        }
        ipTest = GetNextItemProperty(oItem);
    }
}

//////////////////////////////////////////////////
/*             Function definitions             */
//////////////////////////////////////////////////

int GetUMDForItemCost(object oItem)
{
    string s2DAEntry;
    int nValue = GetGoldPieceValue(oItem);
    int n2DAValue = StringToInt(s2DAEntry);
    int i;
    while(n2DAValue < nValue)
    {
        s2DAEntry = Get2DACache("skillvsitemcost", "DeviceCostMax", i);
        n2DAValue = StringToInt(s2DAEntry);
        i++;
    }
    i--;
    string s2DAReqSkill = Get2DACache("skillvsitemcost", "SkillReq_Class", i);
    if(s2DAReqSkill == "")
        return -1;
    return StringToInt(s2DAReqSkill);
}

//this is a scripted version of the bioware UMD check for using restricted items
//this also applies effects relating to new itemproperties
int DoUMDCheck(object oItem, object oPC, int nDCMod)
{

    //doesnt have UMD
    if(!GetHasSkill(SKILL_USE_MAGIC_DEVICE, oPC))
        return FALSE;

    int nSkill = GetSkillRank(SKILL_USE_MAGIC_DEVICE, oPC);
    int nReqSkill = GetUMDForItemCost(oItem);
    //class is a dc20 test
    nReqSkill = nReqSkill - 20 + nDCMod;
    if(nReqSkill > nSkill)
        return FALSE;
    else
        return TRUE;
}

void VoidCheckPRCLimitations(object oItem, object oPC = OBJECT_INVALID)
{
    CheckPRCLimitations(oItem, oPC);
}

//tests for use restrictions
//also appies effects for those IPs tat need them
/// @todo Rename. It's not just limitations anymore
int CheckPRCLimitations(object oItem, object oPC = OBJECT_INVALID)
{
    // Sanity check - the item needs to be valid
    if(!GetIsObjectValid(oItem))
        return FALSE; /// @todo Might be better to auto-pass the limitation aspect in case of invalid item

    // In case no item owner was given, find it out
    if(!GetIsObjectValid(oPC))
        oPC = GetItemPossessor(oItem);

    // Sanity check - the item needs to be in some creature's possession for this function to make sense
    if(!GetIsObjectValid(oPC))
        return FALSE;

    // Equip and Unequip events need some special handling
    int bUnequip = GetItemLastUnequipped() == oItem && GetLocalInt(oPC, "ONEQUIP") == 1;
    int bEquip   = GetItemLastEquipped()   == oItem && GetLocalInt(oPC, "ONEQUIP") == 2;

    // Use restriction and UMD use
    int bPass  = TRUE;
    int nUMDDC = 0;

    // Speed modification. Used to determine if effects need to be applied
    int nSpeedIncrease = GetLocalInt(oPC, PLAYER_SPEED_INCREASE);
    int nSpeedDecrease = GetLocalInt(oPC, PLAYER_SPEED_DECREASE);

    // Loop over all itemproperties on the item
    itemproperty ipTest = GetFirstItemProperty(oItem);
    while(GetIsItemPropertyValid(ipTest))
    {
        int ipType = GetItemPropertyType(ipTest);
        /* Use restrictions. All of these can be skipped when unequipping */
        if(!bUnequip)
        {
            if     (ipType == ITEM_PROPERTY_USE_LIMITATION_ABILITY_SCORE)
            {
                int nValue = GetItemPropertyCostTableValue(ipTest);
                if(GetAbilityScore(oPC, GetItemPropertySubType(ipTest), TRUE) < nValue)
                    bPass = FALSE;
                nUMDDC += nValue - 15;
            }
            else if(ipType == ITEM_PROPERTY_USE_LIMITATION_SKILL_RANKS)
            {
                int nValue = GetItemPropertyCostTableValue(ipTest);
                if(GetSkillRank(GetItemPropertySubType(ipTest), oPC) < nValue)
                    bPass = FALSE;
                nUMDDC += nValue - 10;
            }
            else if(ipType == ITEM_PROPERTY_USE_LIMITATION_SPELL_LEVEL)
            {
                int nLevel = GetItemPropertyCostTableValue(ipTest);
                if(GetLocalInt(oPC, "PRC_AllSpell" + IntToString(nLevel)))
                    bPass = FALSE;
                nUMDDC += (nLevel * 2) - 20;
            }
            else if(ipType == ITEM_PROPERTY_USE_LIMITATION_ARCANE_SPELL_LEVEL)
            {
                int nLevel = GetItemPropertyCostTableValue(ipTest);
                if(GetLocalInt(oPC, "PRC_ArcSpell" + IntToString(nLevel)))
                    bPass = FALSE;
                nUMDDC += (nLevel * 2) - 20;
            }
            else if(ipType == ITEM_PROPERTY_USE_LIMITATION_DIVINE_SPELL_LEVEL)
            {
                int nLevel = GetItemPropertyCostTableValue(ipTest);
                if(GetLocalInt(oPC, "PRC_DivSpell" + IntToString(nLevel)))
                    bPass = FALSE;
                nUMDDC += (nLevel * 2) - 20;
            }
            else if(ipType == ITEM_PROPERTY_USE_LIMITATION_SNEAK_ATTACK)
            {
                int nLevel = GetItemPropertyCostTableValue(ipTest);
                if(GetLocalInt(oPC, "PRC_SneakLevel" + IntToString(nLevel)))
                    bPass = FALSE;
                nUMDDC += (nLevel * 2) - 20;
            }
            else if(ipType == ITEM_PROPERTY_USE_LIMITATION_GENDER)
            {
                if(GetGender(oPC) != GetItemPropertySubType(ipTest))
                    bPass = FALSE;
                nUMDDC += 5;
            }
        }

        /* Properties that apply effects. Unequip should cause cleanup here */
        if(ipType == ITEM_PROPERTY_SPEED_INCREASE)
        {
            int iItemAdjust;
            switch(GetItemPropertyCostTableValue(ipTest))
            {
                case 0: iItemAdjust = 10;  break;
                case 1: iItemAdjust = 20;  break;
                case 2: iItemAdjust = 30;  break;
                case 3: iItemAdjust = 40;  break;
                case 4: iItemAdjust = 50;  break;
                case 5: iItemAdjust = 60;  break;
                case 6: iItemAdjust = 70;  break;
                case 7: iItemAdjust = 80;  break;
                case 8: iItemAdjust = 90;  break;
                case 9: iItemAdjust = 100; break;
            }
            if(bUnequip)
                nSpeedIncrease -= iItemAdjust;
            else if(bEquip)
                nSpeedIncrease += iItemAdjust;
        }
        else if(ipType == ITEM_PROPERTY_SPEED_DECREASE)
        {
            int iItemAdjust;
            switch(GetItemPropertyCostTableValue(ipTest))
            {
                case 0: iItemAdjust = 10; break;
                case 1: iItemAdjust = 20; break;
                case 2: iItemAdjust = 30; break;
                case 3: iItemAdjust = 40; break;
                case 4: iItemAdjust = 50; break;
                case 5: iItemAdjust = 60; break;
                case 6: iItemAdjust = 70; break;
                case 7: iItemAdjust = 80; break;
                case 8: iItemAdjust = 90; break;
                case 9: iItemAdjust = 99; break;
            }
            if(bUnequip)
                nSpeedDecrease -= iItemAdjust;
            else if(bEquip)
                nSpeedDecrease += iItemAdjust;
        }
        else if(ipType == ITEM_PROPERTY_PNP_HOLY_AVENGER)
        {
            if(bEquip)
            {
                int nPaladinLevels = GetLevelByClass(CLASS_TYPE_PALADIN, oPC);
                if(!nPaladinLevels)
                {
                    //not a paladin? fake it
                    //not really a true PnP test
                    //instead it sets the paladin level
                    //to the UMD ranks minus the amount required
                    //to use a class restricted item of that value
                    int nSkill = GetSkillRank(SKILL_USE_MAGIC_DEVICE, oPC);
                    if(nSkill)
                    {
                        int nReqSkill = GetUMDForItemCost(oItem);
                        nSkill -= nReqSkill;
                        if(nSkill > 0)
                            nPaladinLevels = nSkill;
                    }
                }

                // Add Holy Avenger specials for Paladins (or successfull fake-Paladins)
                if(nPaladinLevels)
                {
                    DelayCommand(0.1, IPSafeAddItemProperty(oItem,
                        ItemPropertyEnhancementBonus(5), 99999.9));
                    DelayCommand(0.1, IPSafeAddItemProperty(oItem,
                        ItemPropertyDamageBonusVsAlign(IP_CONST_ALIGNMENTGROUP_EVIL,
                            IP_CONST_DAMAGETYPE_DIVINE, IP_CONST_DAMAGEBONUS_2d6), 99999.9));
                    //this is a normal dispel magic useage, should be specific
                    DelayCommand(0.1, IPSafeAddItemProperty(oItem,
                        ItemPropertyCastSpell(IP_CONST_CASTSPELL_DISPEL_MAGIC_5,
                            IP_CONST_CASTSPELL_NUMUSES_UNLIMITED_USE), 99999.9));
                    DelayCommand(0.1, IPSafeAddItemProperty(oItem,
                        ItemPropertyCastSpellCasterLevel(SPELL_DISPEL_MAGIC,
                            nPaladinLevels), 99999.9));
                }
                // Non-Paladin's get +2 enhancement bonus
                else
                {
                    DelayCommand(0.1, IPSafeAddItemProperty(oItem,
                        ItemPropertyEnhancementBonus(2), 99999.9));

                    // Remove Paladin specials
                    IPRemoveMatchingItemProperties(oItem, ITEM_PROPERTY_ENHANCEMENT_BONUS, DURATION_TYPE_TEMPORARY, -1);
                    IPRemoveMatchingItemProperties(oItem, ITEM_PROPERTY_DAMAGE_BONUS_VS_ALIGNMENT_GROUP, DURATION_TYPE_TEMPORARY, IP_CONST_ALIGNMENTGROUP_EVIL);
                    IPRemoveMatchingItemProperties(oItem, ITEM_PROPERTY_CAST_SPELL, DURATION_TYPE_TEMPORARY);
                    IPRemoveMatchingItemProperties(oItem, ITEM_PROPERTY_CAST_SPELL_CASTER_LEVEL, DURATION_TYPE_TEMPORARY);
                }
            }
            else if(bUnequip)
            {
                IPRemoveMatchingItemProperties(oItem, ITEM_PROPERTY_ENHANCEMENT_BONUS,
                    DURATION_TYPE_TEMPORARY, -1);
                IPRemoveMatchingItemProperties(oItem, ITEM_PROPERTY_DAMAGE_BONUS_VS_ALIGNMENT_GROUP,
                    DURATION_TYPE_TEMPORARY, IP_CONST_ALIGNMENTGROUP_EVIL);
                IPRemoveMatchingItemProperties(oItem, ITEM_PROPERTY_CAST_SPELL,
                    DURATION_TYPE_TEMPORARY);
                IPRemoveMatchingItemProperties(oItem, ITEM_PROPERTY_CAST_SPELL_CASTER_LEVEL,
                    DURATION_TYPE_TEMPORARY);
            }
        }
        else if(ipType == ITEM_PROPERTY_AREA_OF_EFFECT)
        {

            // This should only happen on equip or unequip
            if(bEquip || bUnequip)
            {
                // Remove existing AoE
                effect eTest = GetFirstEffect(oPC);
                while(GetIsEffectValid(eTest))
                {
                    if(GetEffectCreator(eTest) == oItem
                       && GetEffectType(eTest) == EFFECT_TYPE_AREA_OF_EFFECT)
                    {
                        RemoveEffect(oPC, eTest);
                        if(DEBUG) DoDebug("CheckPRCLimitations: Removing old AoE effect");
                    }
                    eTest = GetNextEffect(oPC);
                }

                // Create new AoE - Only when equipping
                if(bEquip)
                {
                    AssignCommand(oItem, _prc_inc_itmrstr_ApplyAoE(oPC, oItem, GetItemPropertySubType(ipTest), GetItemPropertyCostTable(ipTest)));
                }// end if - Equip event
            }// end if - Equip or Unequip event
        }// end if - AoE iprp
        else if(ipType == ITEM_PROPERTY_BONUS_SPELL_SLOT_OF_LEVEL_N)
        {
            // Only equippable items can provide bonus spell slots
            if(bEquip || bUnequip)
            {
                int nSubType  = GetItemPropertySubType(ipTest);
                int nCost     = GetItemPropertyCostTable(ipTest);
                SetLocalInt(oPC,
                            "PRC_IPRPBonSpellSlots_" + IntToString(nSubType) + "_" + IntToString(nCost),
                            GetLocalInt(oPC,
                                        "PRC_IPRPBonSpellSlots_" + IntToString(nSubType) + "_" + IntToString(nCost)
                                        )
                             + (bEquip ? 1 : -1)
                            );
            }
        }
        else if(ipType == ITEM_PROPERTY_WIZARDRY)
        {
            int nCost = GetItemPropertyCostTableValue(ipTest);
            if(bEquip)
                AssignCommand(oItem, _prc_inc_itmrstr_ApplyWizardry(oPC, oItem, nCost, "A"));
            else if(bUnequip)
                AssignCommand(oItem, _prc_inc_itmrstr_RemoveWizardry(oPC, oItem, nCost, "A"));
        }
        else if(ipType == ITEM_PROPERTY_DIVINITY)
        {
            int nCost = GetItemPropertyCostTableValue(ipTest);
            if(bEquip)
                AssignCommand(oItem, _prc_inc_itmrstr_ApplyWizardry(oPC, oItem, nCost, "D"));
            else if(bUnequip)
                AssignCommand(oItem, _prc_inc_itmrstr_RemoveWizardry(oPC, oItem, nCost, "D"));
        }

        ipTest = GetNextItemProperty(oItem);
    }// end while - Loop over all itemproperties

    // Determine if speed modification totals had changed
    if(nSpeedDecrease != GetLocalInt(oPC, PLAYER_SPEED_DECREASE))
    {
        SetLocalInt(oPC, PLAYER_SPEED_DECREASE, nSpeedDecrease);
        //_prc_inc_itmrstr_ApplySpeedDecrease(oPC);
    }
    if(nSpeedIncrease != GetLocalInt(oPC, PLAYER_SPEED_INCREASE))
    {
        SetLocalInt(oPC, PLAYER_SPEED_INCREASE, nSpeedIncrease);
        //_prc_inc_itmrstr_ApplySpeedIncrease(oPC);
    }

    // If some restriction would prevent item use, perform UMD skill check
    // Skip in case of unequip
    if(!bUnequip && !bPass)
        bPass = DoUMDCheck(oItem, oPC, nUMDDC);

    return bPass;
}

void CheckForPnPHolyAvenger(object oItem)
{
    if(!GetPRCSwitch(PRC_PNP_HOLY_AVENGER_IPROP))
        return;
    itemproperty ipTest = GetFirstItemProperty(oItem);
    while(GetIsItemPropertyValid(ipTest))
    {
        if(GetItemPropertyType(ipTest) == ITEM_PROPERTY_HOLY_AVENGER)
        {
            DelayCommand(0.1, RemoveItemProperty(oItem, ipTest));
            DelayCommand(0.1, IPSafeAddItemProperty(oItem, ItemPropertyPnPHolyAvenger()));
        }
        ipTest = GetNextItemProperty(oItem);
    }
}

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