//:://////////////////////////////////////////////
//:: Completely redone Armor and Weapon redesign functions
//:: Further redone by Loki Hakanin
//:: zep_inc_craft
//:://////////////////////////////////////////////
/*
    This is a complete rework of the Armor- and Weaponcrafting skill
    No existing scripts are overridden or replaced, only the conversation
    x0_skill_ctrap needs to be replaced to activate the custom crafting.

    Original scripts written by SartriX
    Modified for inclusion in the CEP by Loki Hakanin
    Note from Loki: In general, all comments I've added
    will be labeled as "Note from Loki".

    Additions to the original Bioware scripts:
    - Bugs fixed
    - Enhanced performance
    - Support for custom armor- and weaponmodels
    - Helmet and Shield crafting added

    Note from Loki: Do not have a decent server handy to
    test the below out on.  If the zep_cr_nocheat script is
    used either as an "OnEnter" script for a module/server,
    or executed therein, it should stop this exploit.  This
    function is 100% SartriX's original, as since I have not
    tested it, I do not know if it needs modification.
    - Counters the 'double item' exploit !

    Note from Loki: Optional Features: Can be enabled
    by enabling flags.  Bottom 2 use SartriX's original
    code, but just with renamed variables and the like to
    conform to CEP naming convention.
    - Reworked Cost and DC
    - Use of crafting placeables (like Forge)
    - Use of NPC crafters

    Modifications and enhancements by Loki Hakanin-
    - Fixed errors in logic of conditional statements
        causing them not to function when a PC attempts
        crafting by themselves (with the "require
        placble" flag set to FALSE).
    - Added code to next/previous cyclying segments to
        enhance robustness-functions can now handle
        irregular inputs-that is to say, custom models
        that aren't all 100% identical to Bioware
        numbering conventions (e.g. more than 3
        appearances/colors for a given shield index, more
        than 4 for weapons).
    - Fixed coding error causing shield alterations to require
        dyes.
    - Added support for new CEP weapon types.
    - Fixed error causing incorrect display of leg options
    - Fixed glitch preventing remodelling of hand axes.

    To be Added Later:
    - Built in color selection for armor and helmets (optional flag)

    Note from Loki: Note that the code for coloring and
    the like is still here, I have merely temporarily
    disabled it, by and large  For CEP R1, we wanted
    things to work just like Bioware's code where we were
    replacing/updating code to work with custom content.
    Also, as the dynamic color alteration requires
    addiitonal item blueprints (the full dyeset), there
    was concern this would make default Bioware dyes
    useless, violating the CEP's "harm no existing content"
    rule.  This code and these items will be re-worked in a
    later release to integrate with the original Bioware
    dyes.

    This crafting system  was originally made by SartriX
    His original scriptset has been posted on nwvault:
    - http://nwvault.ign.com/Files/scripts/data/1071920548260.shtml

*/
//:://////////////////////////////////////////////
//:: Created By: SartriX(original version)
//:: Modified by Loki Hakanin
//:: Created On(original version): 16-dec-2003
//:: Updated On(original version): 16-jan-2004
//:: Updated/Modified by Loki: 26-Feb-2004
//:://////////////////////////////////////////////


#include "x2_inc_craft"
#include "zep_inc_main"
#include "prc_inc_racial"
#include "prc_misc_const"

// Set to FALSE to disable the requirement of the proper placeable to be near the PC
const int    ZEP_CR_REQUIRE_PLACEABLE = FALSE;
//Tag of crafting placeable
const string ZEP_CR_PLACEABLE_TAG = "zep_cr_craftplace";
// Maximum distance to a crafting placeable
const float  ZEP_CR_REQUIRED_DISTANCE = 4.0f;

// Set to FALSE to disable the requirement and use of dyes when recolouring
const int    ZEP_CR_REQUIRE_DYES      = FALSE;

// Maximum cost in percent of the item's original valie at all times regardless of any other settings
const int    ZEP_CR_MAXCOST           = 90;
// Percentage of cost for each part of a weapon (3 parts max) or a helmet/shield (1 part max)
const int    ZEP_CR_PARTCOST          = 20;
// Added percentage of cost for dye changes by NPC
const int    ZEP_CR_NPCDYECOST        = 1;
// Percentage it costs to craft one self compared to what a NPC would ask for the same
// NPC cost is always 100% of the CraftCost in des_crft_aparts.2da
const int    ZEP_CR_SELFCRAFT         = 70;
// The DC that's added to craft magical items. This DC is added for each magical property it has
const int    ZEP_CR_DCADD             = 2;

// Tag of the backup container
// One is supplied as custom placeable (custom -> special -> custom5 -> zep_cr_backup)
// and should be placed on a preferrably inaccessible location. If the container can not be found,
// the backup item will be added to the PC's inventory, it won't break the entire script.
// Note from Loki:  I've altered this implementatoin as well.
// Following Bioware's example, I spawn and make invisible a crafting container
// if I find none in the module.  Difference being, I delete
// it at the end of crafting, for completeness's sake.
const string ZEP_CR_BACKUP_PLACEABLE  = "zep_cr_backup";

// Internal constants, do not touch!
const int    ZEP_CR_DONE_SUCCESS = 1;
const int    ZEP_CR_DONE_FAILED  = 2;
const int    ZEP_CR_DONE_NOGOLD  = 3;
const int    ZEP_CR_DONE_NODYE   = 4;

const int    ZEP_CR_PART_NEXT  = 0;
const int    ZEP_CR_PART_PREV  = 1;
const int    ZEP_CR_COLOR_NEXT = 3;
const int    ZEP_CR_COLOR_PREV = 4;

const int    ZEP_CR_TOKENBASE = 20000;

const int    ZEP_CR_HELMET = 8888;
const int    ZEP_CR_SHIELD = 8889;

//Note from Loki: Above constants were all from
//the original script.  Have simply been renamed to
//keep them consistent with CEP nomenclature.
//Constants declared below are my own additions:

//This constant controls whether SartriX's modified
//DC and costs are used.  By default, it is FALSE
//(using Bioware defaults instead).  Re-enabling it
//will use the costs in the des_crft_aparts.2da
//file instead.
const int    ZEP_USE_OPTIONAL_DC_COST = FALSE;

//Following constants added when we removed the NumParts
//alterations from the des_crafts_aparts.2da file.  This was
//done so people using the default NWN crafting system with
//the CEP would not have a very long set of armors that
//would have blank entries (all the lines in the armor
//2DA files from the last Bioware to the first CEP entry).
//These constants define the max "numparts" in place of the
//2DA files
//Note that weapons and helmets still read the baseitems
//file correctly, or have no problems with the default Bioware
//craft system.  Shields, of course, are only craftable with
//a custom script, so they are not included as the below is
//a "legacy compatibility" change.

const int ZEP_MAX_PARTS_NECK = 255;
const int ZEP_MAX_PARTS_SHOULDER = 255;
const int ZEP_MAX_PARTS_BICEP = 255;
const int ZEP_MAX_PARTS_FOREARM = 255;
const int ZEP_MAX_PARTS_HAND = 255;
const int ZEP_MAX_PARTS_TORSO = 255;
const int ZEP_MAX_PARTS_BELT = 255;
const int ZEP_MAX_PARTS_PELVIS = 255;
const int ZEP_MAX_PARTS_THIGH = 255;
const int ZEP_MAX_PARTS_SHIN = 255;
const int ZEP_MAX_PARTS_FOOT = 255;
const int ZEP_MAX_PARTS_ROBE = 255;


// - End of constants - //


// Sets up everything for oPC to start crafting on oItem
void ZEP_StartCraft(object oPC, object oItem);

// Tries to let oPC perform the crafting of his current item
// Will set the localvar ZEP_CR_DONE on success or fail with one
// of the following values to check with a conditional script:
//    ZEP_CR_DONE_SUCCESS
//    ZEP_CR_DONE_FAILED
//    ZEP_CR_DONE_NOGOLD
//    ZEP_CR_DONE_NODYE
void ZEP_AttemptCraft(object oPC);

// Stops crafting and cleans up everything set by the crafting script
// When nExecute is FALSE, it will abort the craft,
// when it's TRUE, it will replace the old item with the new one.
void ZEP_StopCraft(object oPC, int nExecute=FALSE);

// Sets the current part oPC is working on
// It accepts all 4 partseries ITEM_APPR_ARMOR_MODEL_*,
// ITEM_APPR_WEAPON_MODEL_*, ITEM_APPR_ARMOR_COLOR_*, ITEM_APPR_WEAPON_COLOR_*
// as long as the proper item has been set to craft on
// Focusses the camery on the selected part (if applicable)
void ZEP_SetPart(object oPC, int nPart, int nStrRef);

// Gets the cost to modify oItem into oNew
// Calls the default bioware routines for this, edit this function to override
int ZEP_GetModificationCost(object oItem, object oNew, int nNPC=FALSE);

// Gets the DC to modify oItem into oNew
// Calls the default bioware routines for this, edit this function to override
int ZEP_GetModificationDC(object oItem, object oNew, int nNPC=FALSE);

// Remakes and equips the item oPC is working, having the currently set part
// cycled either forward or backward
// nMode: ZEP_CR_PART_NEXT - cycle forward
// nMode: ZEP_CR_PART_PREV - cycle backward
void ZEP_RemakeItem(object oPC, int nMode);

// Remakes and equips the item oPC is working, having the currently set color
// cycled either forward or backward
// nMode: ZEP_CR_COLOR_NEXT - cycle forward
// nMode: ZEP_CR_COLOR_PREV - cycle backward
void ZEP_RecolorItem(object oPC, int nMode);

//Function Added by Loki
//Decided to do container checks dynamically and have it
//construct a work container as necessary.  This closely
//mirrors Bioware's Own implementation.
object ZEP_GetZEPWorkContainer(object oCaller);

//Function added by Loki
//Below function used as a substitution for the
//IPGetNumberOfArmorAppearances function in the CEP code.
//This is done because the max NumParts is coded as a
//constant to ensure compatibility with "vanilla' NWN.
int ZEP_GetNumberOfArmorAppearances(int nPart);

//Will check if item oItem owned by oPC is a crafting duplicate.
//If so will destroy item and Notify all DMs, as well as
//logging this fact.  nIsEntering should be set to TRUE if
//this function is called as part of an OnEnter script, or
//to FALSE otherwise.
void ZEP_PurifyItem(object oItem, object oPC, int nIsEntering);

//Following function is basically just an iterative version
//of the above PurifyItem function.  In other words, ir will
//cycle through oPCs inventory and Purify all items (as well
//as all appropriate equipable slots).
void ZEP_PurifyAllItems(object oPC, int nIsEntering=FALSE,int nDeleteTempVars=FALSE);

// - Implementation - //


// Sets up everything for oPC to start crafting on oItem
void ZEP_StartCraft(object oPC, object oItem) {
    // Immobilize player while crafting
    effect eImmob = EffectCutsceneImmobilize();
    eImmob = ExtraordinaryEffect(eImmob);
    ApplyEffectToObject(DURATION_TYPE_PERMANENT,eImmob,oPC);

    // Make the camera float near the PC
    StoreCameraFacing();
    float fFacing  = GetFacing(oPC) + 180.0;
    if (fFacing >= 360.0) fFacing -=360.0;
    SetCameraFacing(fFacing, 3.5f, 75.0, CAMERA_TRANSITION_TYPE_FAST);

    // Make backup
    // Note from Loki: Changed implemenation to stash item in container ALWAYS.
    // ZEP_GetZEPWorkContainer will create container if needs be.
    object oBackup = CopyItem(oItem, ZEP_GetZEPWorkContainer(OBJECT_SELF), TRUE);
    SetLocalObject(oPC, "ZEP_CR_BACKUP", oBackup);

    // Mark temporary item
    SetStolenFlag(oItem, TRUE);
    SetLocalInt(oItem, "ZEP_CR_TEMPITEM", TRUE);
    SetLocalObject(oPC, "ZEP_CR_ITEM", oItem);

    // Preset settings
    SetLocalInt(oPC, "ZEP_CR_STARTED", 1);
    SetLocalInt(oPC, "ZEP_CR_COST", 0);
    SetLocalInt(oPC, "ZEP_CR_DC", 0);
    SetLocalInt(oPC, "ZEP_CR_DONE", 0);
    SetLocalInt(oPC, "ZEP_CR_CHANGED", FALSE);
    SetCustomToken(ZEP_CR_TOKENBASE,   "");
    SetCustomToken(ZEP_CR_TOKENBASE+1, "0");
    SetCustomToken(ZEP_CR_TOKENBASE+2, "0");
    SetCustomToken(ZEP_CR_TOKENBASE+3, "");
}

// - private -
// Checks if the color for nIndex has changed, if not returns TRUE
// if it has, checks if oPC has the new dye and returns TRUE when he has
// returns FALSE and sets CUSTOM20003 when the required dye is not present
int ZEP_ColorCheck(object oPC, object oItem, object oBackup, int nType, int nIndex) {
    // if required dyes are disabled, always return TRUE
    if (!ZEP_CR_REQUIRE_DYES) return TRUE;

    // get new color
    int nColor = GetItemAppearance(oItem, nType, nIndex);
    string sDyeTag = "Dye";

    if (nColor != GetItemAppearance(oBackup, nType, nIndex)) {
        // color has changed, build the tag for the required dye
        if (nType == ITEM_APPR_TYPE_ARMOR_COLOR) {
            switch(nIndex) {
                case ITEM_APPR_ARMOR_COLOR_CLOTH1:
                case ITEM_APPR_ARMOR_COLOR_CLOTH2:   sDyeTag+= "C"; break;
                case ITEM_APPR_ARMOR_COLOR_LEATHER1:
                case ITEM_APPR_ARMOR_COLOR_LEATHER2: sDyeTag+= "L"; break;
                case ITEM_APPR_ARMOR_COLOR_METAL1:
                case ITEM_APPR_ARMOR_COLOR_METAL2:   sDyeTag+= "M";
                    if (nColor>55 && nColor<60) nColor-=4; break; // translate missing/double metal colors
            }
            if (nColor<10) sDyeTag+= "0";
            sDyeTag+= IntToString(nColor);
        } else {
            switch (nColor) {
                case 1: sDyeTag+= "M01"; break; // Steel
                case 2: sDyeTag+= "M13"; break; // Gold
                case 3: sDyeTag+= "M21"; break; // Copper
                case 4: sDyeTag+= "M02"; break; // Dark Steel
            }
        }
        if (GetIsObjectValid(GetItemPossessedBy(oPC, sDyeTag))) {
            // oPC has the dye, so this color is alright
            SetLocalString(oPC, "ZEP_CR_DYES", GetLocalString(oPC, "ZEP_CR_DYES") + sDyeTag + ":");
            return TRUE;
        } else {
            // oPC does not have the dye, tell which dye is missing
            if (GetName(GetObjectByTag(sDyeTag))=="") SpeakString("Missing dye/name: "+sDyeTag);
            SetCustomToken(ZEP_CR_TOKENBASE+3, GetName(GetObjectByTag(sDyeTag)));
            return FALSE;
        }
    }
    return TRUE;
}

// Tries to let oPC perform the crafting of his current item
// Will set the localvar ZEP_CR_DONE on success or fail with one
// of the following values to check with a conditional script:
//    ZEP_CR_DONE_SUCCESS
//    ZEP_CR_DONE_FAILED
//    ZEP_CR_DONE_NOGOLD
//    ZEP_CR_DONE_NODYE
void ZEP_AttemptCraft(object oPC) {
    // don't reattempt a previously craftattempt
    if (GetLocalInt(oPC, "ZEP_CR_DONE")>0) return;

    // get current item and backup
    object oItem = GetLocalObject(oPC, "ZEP_CR_ITEM");
    object oBackup = GetLocalObject(oPC, "ZEP_CR_BACKUP");
    int nNPC = GetIsObjectValid(GetLocalObject(oPC, "ZEP_CR_NPC"));
    int nCost = ZEP_GetModificationCost(oBackup, oItem, nNPC);
    int nDC   = ZEP_GetModificationDC(oBackup, oItem, nNPC);
    int nSkill;

    if (GetGold(oPC)<nCost) {
        // player has insufficent gold, cancel
        SetLocalInt(oPC, "ZEP_CR_DONE", ZEP_CR_DONE_NOGOLD);
        return;
    }
    // check if all dyes are present and set the skill to be used
    if (GetBaseItemType(oItem)==BASE_ITEM_ARMOR || GetBaseItemType(oItem)==BASE_ITEM_HELMET) {
        if (!nNPC) {
          if (!(ZEP_ColorCheck(oPC, oItem, oBackup, ITEM_APPR_TYPE_ARMOR_COLOR, ITEM_APPR_ARMOR_COLOR_CLOTH1)
           && ZEP_ColorCheck(oPC, oItem, oBackup, ITEM_APPR_TYPE_ARMOR_COLOR, ITEM_APPR_ARMOR_COLOR_CLOTH2)
           && ZEP_ColorCheck(oPC, oItem, oBackup, ITEM_APPR_TYPE_ARMOR_COLOR, ITEM_APPR_ARMOR_COLOR_LEATHER1)
           && ZEP_ColorCheck(oPC, oItem, oBackup, ITEM_APPR_TYPE_ARMOR_COLOR, ITEM_APPR_ARMOR_COLOR_LEATHER2)
           && ZEP_ColorCheck(oPC, oItem, oBackup, ITEM_APPR_TYPE_ARMOR_COLOR, ITEM_APPR_ARMOR_COLOR_METAL1)
           && ZEP_ColorCheck(oPC, oItem, oBackup, ITEM_APPR_TYPE_ARMOR_COLOR, ITEM_APPR_ARMOR_COLOR_METAL2))) {
            SetLocalInt(oPC, "ZEP_CR_DONE", ZEP_CR_DONE_NODYE);
            return;
          }
        }
        nSkill = SKILL_CRAFT_ARMOR;
    } else
      {

 /*Next bit was part of else*/   //if ((GetBaseItemType(oItem) != BASE_ITEM_LARGESHIELD) && (GetBaseItemType(oItem) != BASE_ITEM_SMALLSHIELD) && (GetBaseItemType(oItem) != BASE_ITEM_TOWERSHIELD)) {
//        if (!nNPC) {
//          if (!(ZEP_ColorCheck(oPC, oItem, oBackup, ITEM_APPR_TYPE_WEAPON_COLOR, ITEM_APPR_WEAPON_COLOR_TOP)
//           && ZEP_ColorCheck(oPC, oItem, oBackup, ITEM_APPR_TYPE_WEAPON_COLOR, ITEM_APPR_WEAPON_COLOR_MIDDLE)
//           && ZEP_ColorCheck(oPC, oItem, oBackup, ITEM_APPR_TYPE_WEAPON_COLOR, ITEM_APPR_WEAPON_COLOR_BOTTOM))) {
//            SetLocalInt(oPC, "ZEP_CR_DONE", ZEP_CR_DONE_NODYE);
//            return;
//          }
       // }
        nSkill = SKILL_CRAFT_WEAPON;
    }

    // take gold
    TakeGoldFromCreature(nCost, oPC, TRUE);
    // take dyes
    string sDyes = GetLocalString(oPC, "ZEP_CR_DYES");
    string sDyeTag;
    int nLen = GetStringLength(sDyes);
    int n;
    while (sDyes!="") {
        n = FindSubString(sDyes, ":");
        sDyeTag = GetSubString(sDyes, 0, n);
        sDyes = GetSubString(sDyes, n+1, nLen);
        DestroyObject(GetItemPossessedBy(oPC, sDyeTag));
    }
    // roll DC
    if (nNPC || GetIsSkillSuccessful(oPC, nSkill, nDC)) {
        SetLocalInt(oPC, "ZEP_CR_DONE", ZEP_CR_DONE_SUCCESS);
        return;
    }
    SetLocalInt(oPC, "ZEP_CR_DONE", ZEP_CR_DONE_FAILED);
}

// Stops crafting and cleans up everything set by the crafting script
// When nExecute is FALSE, it will abort the craft,
// when it's TRUE, it will replace the old item with the new one.
void ZEP_StopCraft(object oPC, int nExecute) {
    // Get and equip correct  item (backup when not successfull or cancelled)
    object oItem = GetLocalObject(oPC, "ZEP_CR_ITEM");
    object oBackup = GetLocalObject(oPC, "ZEP_CR_BACKUP");
    if (nExecute) {
        DestroyObject(oBackup);
        SetStolenFlag(oItem, FALSE);
        DeleteLocalInt(oItem, "ZEP_CR_TEMPITEM");
    } else {
        DestroyObject(oItem);
        oItem = CopyItem(oBackup, oPC, TRUE);
        DestroyObject(oBackup);
    }
    AssignCommand(oPC, ClearAllActions(TRUE));
    if (GetBaseItemType(oItem)==BASE_ITEM_ARMOR) {
        AssignCommand(oPC, ActionEquipItem(oItem, INVENTORY_SLOT_CHEST));
    } else if (GetBaseItemType(oItem)==BASE_ITEM_HELMET) {
        AssignCommand(oPC, ActionEquipItem(oItem, INVENTORY_SLOT_HEAD));
    } else {
        AssignCommand(oPC, ActionEquipItem(oItem, INVENTORY_SLOT_RIGHTHAND));
    }

    // Postclean settings
    DeleteLocalInt(oPC, "ZEP_CR_COST");
    DeleteLocalInt(oPC, "ZEP_CR_DC");
    DeleteLocalInt(oPC, "ZEP_CR_PART");
    DeleteLocalInt(oPC, "ZEP_CR_DONE");
    DeleteLocalInt(oPC, "ZEP_CR_CHANGED");
    DeleteLocalObject(oPC, "ZEP_CR_ITEM");
    DeleteLocalObject(oPC, "ZEP_CR_BACKUP");
    DeleteLocalObject(oPC, "ZEP_CR_NPC");
    DeleteLocalObject(oPC, "ZEP_CR_PLACEABLE");

    // Remove custscene immobilize and light from player
    //Note from Loki: Doesn't seem to be any light.  [FUTURE FIX]
    effect eEff = GetFirstEffect(oPC);
    while (GetIsEffectValid(eEff)) {
        if (GetEffectType(eEff) == EFFECT_TYPE_CUTSCENEIMMOBILIZE)
            RemoveEffect(oPC,eEff);
        eEff = GetNextEffect(oPC);
    }
    RestoreCameraFacing();

}

// - private -
void ZEP_SetColorToken(int nIndex, int nColor) {
    string sDyeTag = "Dye";
    switch(nIndex) {
        case ITEM_APPR_ARMOR_COLOR_CLOTH1:
        case ITEM_APPR_ARMOR_COLOR_CLOTH2:   sDyeTag+= "C"; break;
        case ITEM_APPR_ARMOR_COLOR_LEATHER1:
        case ITEM_APPR_ARMOR_COLOR_LEATHER2: sDyeTag+= "L"; break;
        case ITEM_APPR_ARMOR_COLOR_METAL1:
        case ITEM_APPR_ARMOR_COLOR_METAL2:   sDyeTag+= "M";
            if (nColor>55 && nColor<60) nColor-=4; break; // translate missing/double metal colors
    }
    if (nColor<10) sDyeTag+= "0";
    sDyeTag+= IntToString(nColor);
    SetCustomToken(ZEP_CR_TOKENBASE+3, GetName(GetObjectByTag(sDyeTag)));
}

// Sets the current part oPC is working on
// It accepts all 4 partseries ITEM_APPR_ARMOR_MODEL_*,
// ITEM_APPR_WEAPON_MODEL_*, ITEM_APPR_ARMOR_COLOR_*, ITEM_APPR_WEAPON_COLOR_*
// as long as the proper item has been set to craft on
// Focusses the camera on the selected part (if applicable)
void ZEP_SetPart(object oPC, int nPart, int nStrRef) {
    SetLocalInt(oPC, "ZEP_CR_PART", nPart);
    object oItem = GetLocalObject(oPC, "ZEP_CR_ITEM");

    // * Make the camera float near the PC
    float fFacing  = GetFacing(oPC) + 180.0;
    float fPitch   = 75.0;
    float fDistance= 3.5;

    if (GetBaseItemType(oItem)==BASE_ITEM_ARMOR) {
        switch (nPart) {
            case ITEM_APPR_ARMOR_MODEL_LBICEP:
            case ITEM_APPR_ARMOR_MODEL_LFOREARM:
            case ITEM_APPR_ARMOR_MODEL_LHAND:
            case ITEM_APPR_ARMOR_MODEL_LSHOULDER:
            case ITEM_APPR_ARMOR_MODEL_LTHIGH:
            case ITEM_APPR_ARMOR_MODEL_LSHIN:
            case ITEM_APPR_ARMOR_MODEL_LFOOT: fFacing += 60.0; break;
            case ITEM_APPR_ARMOR_MODEL_RBICEP:
            case ITEM_APPR_ARMOR_MODEL_RFOREARM:
            case ITEM_APPR_ARMOR_MODEL_RHAND:
            case ITEM_APPR_ARMOR_MODEL_RSHOULDER:
            case ITEM_APPR_ARMOR_MODEL_RTHIGH:
            case ITEM_APPR_ARMOR_MODEL_RSHIN:
            case ITEM_APPR_ARMOR_MODEL_RFOOT: fFacing -= 60.0; break;
        }
        switch (nPart) {
            case ITEM_APPR_ARMOR_MODEL_LBICEP:
            case ITEM_APPR_ARMOR_MODEL_RBICEP:
            case ITEM_APPR_ARMOR_MODEL_LFOOT:
            case ITEM_APPR_ARMOR_MODEL_RFOOT: fDistance = 3.5; fPitch = 47.0; break;
            case ITEM_APPR_ARMOR_MODEL_LFOREARM:
            case ITEM_APPR_ARMOR_MODEL_RFOREARM:
            case ITEM_APPR_ARMOR_MODEL_LHAND:
            case ITEM_APPR_ARMOR_MODEL_RHAND: fDistance = 2.0; fPitch = 60.0; break;
            case ITEM_APPR_ARMOR_MODEL_LSHIN:
            case ITEM_APPR_ARMOR_MODEL_RSHIN: fDistance = 3.5; fPitch = 95.0; break;
            case ITEM_APPR_ARMOR_MODEL_LSHOULDER:
            case ITEM_APPR_ARMOR_MODEL_RSHOULDER: fDistance = 3.0; fPitch = 50.0; break;
            case ITEM_APPR_ARMOR_MODEL_LTHIGH:
            case ITEM_APPR_ARMOR_MODEL_RTHIGH: fDistance = 2.5; fPitch = 65.0; break;
            case ITEM_APPR_ARMOR_MODEL_NECK: fPitch = 90.0; break;
            case ITEM_APPR_ARMOR_MODEL_BELT:
            case ITEM_APPR_ARMOR_MODEL_PELVIS: fDistance = 2.0; break;
        }
    } else if (nPart==ZEP_CR_HELMET) {
        fDistance = 2.5;
        fPitch = 85.0;
    } else if (nPart==ZEP_CR_SHIELD) {
        fFacing += 60.0;
        fDistance = 3.0;
        fPitch = 65.0;
    } else {
        fFacing -= 60.0;
        fDistance = 3.0;
        fPitch = 65.0;
    }
    if (fFacing >= 360.0) fFacing -=360.0;
    if (MyPRCGetRacialType(oPC) == RACIAL_TYPE_HALFORC) fDistance += 1.0f;
    SetCameraFacing(fFacing, fDistance, fPitch, CAMERA_TRANSITION_TYPE_VERY_FAST);

    int nCost = GetLocalInt(oPC, "ZEP_CR_COST");
    int nDC   = GetLocalInt(oPC, "ZEP_CR_DC");
    SetCustomToken(ZEP_CR_TOKENBASE, GetStringByStrRef(nStrRef));
    SetCustomToken(ZEP_CR_TOKENBASE+1, IntToString(nCost));
    SetCustomToken(ZEP_CR_TOKENBASE+2, IntToString(nDC));
    ZEP_SetColorToken(nPart, GetItemAppearance(oItem, ITEM_APPR_TYPE_ARMOR_COLOR, nPart));

}

// - private -
// Gets the cost to modify oItem into oNew
int ZEP_GetModificationCost(object oItem, object oNew, int nNPC=FALSE) {
    int nCost = 0;
    int nChanges = -1;
    int nPart;
    float fFactor;
    //Note from Loki: Below segment's logical flow modified
    //from original.  As SartriX had used differing DC and
    //cost values from Bioware, defined in  des_crft_aparts.2da,
    //this conflicted with the CEP's "play nice with Bioware"
    //policy.
    //I have left this functionality in, but you must enable
    //a flag in the constants section of this file to turn it
    //on.  Otherwise, default Bioware costs will be used.
    //Note that helmets and shields will ALWAYS default to
    //using this case, as there is no Bioware code to emulate
    //in their case.
    if ((ZEP_USE_OPTIONAL_DC_COST == TRUE) || (GetBaseItemType(oItem)==BASE_ITEM_HELMET) || (GetBaseItemType(oItem)== BASE_ITEM_LARGESHIELD) || (GetBaseItemType(oItem)== BASE_ITEM_SMALLSHIELD) || (GetBaseItemType(oItem)== BASE_ITEM_TOWERSHIELD) )
        {
        // Find and count changes
        if (GetBaseItemType(oItem)==BASE_ITEM_ARMOR) {
            for (nPart = 0; nPart<=ITEM_APPR_ARMOR_MODEL_ROBE; nPart++) {
                if (GetItemAppearance(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, nPart) != GetItemAppearance(oNew, ITEM_APPR_TYPE_ARMOR_MODEL, nPart)) {
                    // Part changed, add price factor
                    nCost += StringToInt(Get2DAString("des_crft_aparts", "CraftCost", nPart));
                    nChanges++;
                }
            }
        } else {
            for (nPart = 0; nPart<3; nPart++) {
                if (GetItemAppearance(oItem, ITEM_APPR_TYPE_WEAPON_MODEL, nPart) != GetItemAppearance(oNew, ITEM_APPR_TYPE_WEAPON_MODEL, nPart)) {
                    // Part changed, add price factor
                    nCost += ZEP_CR_PARTCOST;
                    nChanges++;
                }
            }
            nChanges *= 5;
        }
        // More as 1 part changed, give a 'discount'
        if (nChanges>0) nCost -= nChanges;
        // Reworked item may not cost more as 90% of a brand new one
        if (nCost>ZEP_CR_MAXCOST) nCost = ZEP_CR_MAXCOST;
        if (nNPC) {
            // If made by a NPC, charge for the dyes
            if (GetBaseItemType(oItem)==BASE_ITEM_ARMOR) {
                for (nPart = 0; nPart<=ITEM_APPR_ARMOR_MODEL_ROBE; nPart++) {
                    if (GetItemAppearance(oItem, ITEM_APPR_TYPE_ARMOR_COLOR, nPart) != GetItemAppearance(oNew, ITEM_APPR_TYPE_ARMOR_COLOR, nPart)) {
                        // Part changed, add price factor
                        nCost += ZEP_CR_NPCDYECOST;
                    }
                }
            } else {
                for (nPart = 0; nPart<3; nPart++) {
                    if (GetItemAppearance(oItem, ITEM_APPR_TYPE_WEAPON_COLOR, nPart) != GetItemAppearance(oNew, ITEM_APPR_TYPE_WEAPON_COLOR, nPart)) {
                        // Part changed, add price factor
                        nCost += ZEP_CR_NPCDYECOST;
                    }
                }
            }
            fFactor = IntToFloat(nCost) / 100.0;
        } else {
            // If made by the PC himself, the price is 70% of what an NPC would ask him
            fFactor = IntToFloat(nCost * ZEP_CR_SELFCRAFT) / 10000.0;
        }
        // Calculate and return final cost
        nCost = FloatToInt(IntToFloat(GetGoldPieceValue(oItem)) * fFactor);
        if (nCost<1) nCost=1;
        }
    else  //Use base Bioware costs for armor and weapons unless told otherwise.
        {
        int nItemType=GetBaseItemType(oItem);
        if (nItemType == BASE_ITEM_ARMOR)
            {
            nPart=GetLocalInt(GetPCSpeaker(),"ZEP_CR_PART");
            if (nPart==ITEM_APPR_ARMOR_MODEL_ROBE)
                nCost=0;
            else nCost=CIGetArmorModificationCost(oItem,oNew);
            }
        else nCost=CIGetWeaponModificationCost(oItem,oNew);
        }
    return nCost;
}

// - private -
// Gets the DC to modify oItem into oNew
int ZEP_GetModificationDC(object oItem, object oNew, int nNPC=FALSE) {
    if (nNPC) return 0;
    int nDC=0;
    int nChanges = -1;
    int nPart;
    float fFactor;

    //Note from Loki: Below segment's logical flow modified
    //from original.  As SartriX had used differing DC and
    //cost values from Bioware, defined in  des_crft_aparts.2da,
    //this conflicted with the CEP's "play nice with Bioware"
    //policy.
    //I have left this functionality in, but you must enable
    //a flag in the constants section of this file to turn it
    //on.  Otherwise, default Bioware costs/DC will be used.
    //Note that helmets and shields will ALWAYS default to
    //using this case, as there is no Bioware code to emulate
    //in their case.

    if ((ZEP_USE_OPTIONAL_DC_COST == TRUE) || (GetBaseItemType(oItem)==BASE_ITEM_HELMET) || (GetBaseItemType(oItem)== BASE_ITEM_LARGESHIELD) || (GetBaseItemType(oItem)== BASE_ITEM_SMALLSHIELD) || (GetBaseItemType(oItem)== BASE_ITEM_TOWERSHIELD) )
        {
        // Find and count changes
        if (GetBaseItemType(oItem)==BASE_ITEM_ARMOR) {
            for (nPart = 0; nPart<=ITEM_APPR_ARMOR_MODEL_ROBE; nPart++) {
                if (GetItemAppearance(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, nPart) != GetItemAppearance(oNew, ITEM_APPR_TYPE_ARMOR_MODEL, nPart)) {
                    // Part changed, add DC factor
                    nDC += StringToInt(Get2DAString("des_crft_aparts", "CraftDC", nPart));
                    nChanges++;
                }
            }
        } else {
            for (nPart = 0; nPart<3; nPart++) {
                if (GetItemAppearance(oItem, ITEM_APPR_TYPE_WEAPON_MODEL, nPart) != GetItemAppearance(oNew, ITEM_APPR_TYPE_WEAPON_MODEL, nPart)) {
                    // Part changed, add DC factor
                    nDC += 6;
                    nChanges++;
                }
            }
            nChanges *= 2;
        }
        // More as 1 part changed, give a 'discount'
        if (nChanges>0) nDC -= nChanges;
        itemproperty iP = GetFirstItemProperty(oItem);
        while (GetIsItemPropertyValid(iP)) {
            nDC += ZEP_CR_DCADD;
            iP = GetNextItemProperty(oItem);
            }
        }
    else
        {
        if (GetBaseItemType(oItem)==BASE_ITEM_ARMOR)
            {
            nPart=GetLocalInt(GetPCSpeaker(),"ZEP_CR_PART");
            if (nPart==ITEM_APPR_ARMOR_MODEL_ROBE)
                nDC=0;
            else nDC=CIGetArmorModificationDC(oItem,oNew);
            }
        else nDC=15;    //This value pulled directly from Bioware scripts.
        }
    return nDC;

}

// - private -
// Reverses a : seperated stringlist
string ZEP_ListReverse(string s) {
    string sCache;
    int n;
    int l = GetStringLength(s);
    s = GetSubString(s, 1, l);
    while (s!="") {
        // take string upto next seperator and put this in front of cache
        n = FindSubString(s, ":")+1;
        sCache = GetStringLeft(s, n) + sCache;
        s = GetSubString(s, n, l);
    }
    return ":"+sCache;
}

// - private -
// Prereads the parts_chest.2da-file for sAC and puts all used ID's in a : seperated stringlist
string ZEP_PreReadArmorACList(string sAC) {
    // pick the right 2da to read the parts from
    string s2DA = "parts_chest";
    string sCache= ":";
    string sLine;
    // get the maxID used (not the amount of ID's !!!)
    //int nMax = IPGetNumberOfArmorAppearances(ITEM_APPR_ARMOR_MODEL_TORSO);
    //Note from Loki: Below line changed to make use of
    //backward compatibility function.  Was previously the
    //preceding line.
    int nMax = ZEP_GetNumberOfArmorAppearances(ITEM_APPR_ARMOR_MODEL_TORSO);
    int n=1;
    sAC = GetStringLeft(sAC, 1);
    while (n<=nMax) {
        // Verify validity of the ID and add to the list
        sLine = Get2DAString(s2DA, "ACBONUS", n);
        if (GetStringLeft(sLine, 1)==sAC) {
            sCache+= IntToString(n)+":";
        }
        n++;
    }
    // Store the list in a modulestring, once normal, once reversed, both with ID 0 added as first index for cycling
    SetLocalString(GetModule(), "ZEP_IDPreReadAC_"+GetStringLeft(sAC,1), sCache);
    SetLocalString(GetModule(), "ZEP_IDPreReadACR_"+GetStringLeft(sAC,1), ZEP_ListReverse(sCache));

    return sCache;
}

// - private -
// Prereads the 2da-file for nPart and puts all used ID's in a : seperated stringlist
string ZEP_PreReadArmorPartList(int nPart) {
    // pick the right 2da to read the parts from
    string s2DA = "parts_";
    switch (nPart) {
        case ITEM_APPR_ARMOR_MODEL_LBICEP:
        case ITEM_APPR_ARMOR_MODEL_RBICEP: s2DA+= "bicep"; break;
        case ITEM_APPR_ARMOR_MODEL_LFOOT:
        case ITEM_APPR_ARMOR_MODEL_RFOOT: s2DA+= "foot"; break;
        case ITEM_APPR_ARMOR_MODEL_LFOREARM:
        case ITEM_APPR_ARMOR_MODEL_RFOREARM: s2DA+= "forearm"; break;
        case ITEM_APPR_ARMOR_MODEL_LHAND:
        case ITEM_APPR_ARMOR_MODEL_RHAND: s2DA+= "hand"; break;
        case ITEM_APPR_ARMOR_MODEL_LSHIN:
        case ITEM_APPR_ARMOR_MODEL_RSHIN: s2DA+= "shin"; break;
        case ITEM_APPR_ARMOR_MODEL_LSHOULDER:
        case ITEM_APPR_ARMOR_MODEL_RSHOULDER: s2DA+= "shoulder"; break;
        case ITEM_APPR_ARMOR_MODEL_LTHIGH:
        case ITEM_APPR_ARMOR_MODEL_RTHIGH: s2DA+= "legs"; break;
        case ITEM_APPR_ARMOR_MODEL_NECK: s2DA+= "neck"; break;
        case ITEM_APPR_ARMOR_MODEL_BELT: s2DA+= "belt"; break;
        case ITEM_APPR_ARMOR_MODEL_PELVIS: s2DA+= "pelvis"; break;
        case ITEM_APPR_ARMOR_MODEL_ROBE: s2DA+= "robe"; break;
    }

    string sCache= ":";
    string sLine;
    // get the maxID used (not the amount of ID's !!!)
    //int nMax = StringToInt(Get2DAString("des_crft_aparts", "NumParts", nPart));
    //Note from Loki: Below line changed to make use of
    //backward compatibility function.  Was previously the
    //preceding line.
    int nMax = ZEP_GetNumberOfArmorAppearances(nPart);
    int n=1;
    while (n<=nMax) {
        // Verify validity of the ID and add to the list
        sLine = Get2DAString(s2DA, "ACBONUS", n);
        if (sLine!="") {
            sCache+= IntToString(n)+":";
        }
        n++;
    }
    // Store the list in a modulestring, once normal, once reversed, both with ID 0 added as first index for cycling
    SetLocalString(GetModule(), "ZEP_IDPreRead_"+IntToString(nPart), ":0"+sCache);
    SetLocalString(GetModule(), "ZEP_IDPreReadR_"+IntToString(nPart), ":0"+ZEP_ListReverse(sCache));
    return sCache;
}

// Remakes and equips the item oPC is working, having the currently set part
// cycled either forward or backward
// nMode: ZEP_CR_PART_NEXT - cycle forward
// nMode: ZEP_CR_PART_PREV - cycle backward
void ZEP_RemakeItem(object oPC, int nMode) {
    SetLocalInt(oPC, "ZEP_CR_CHANGED", TRUE);
    object oItem = GetLocalObject(oPC, "ZEP_CR_ITEM");
    int nPart    = GetLocalInt(oPC, "ZEP_CR_PART");
    int nCurrApp, nSlot, nCost, nDC;
    string sPreRead;
    object oNew;

    if (GetBaseItemType(oItem)==BASE_ITEM_ARMOR) {
        // Handle Armor change
        nCurrApp = GetItemAppearance(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, nPart);

        if (nPart == ITEM_APPR_ARMOR_MODEL_TORSO) {
            string sAC = Get2DAString("parts_chest", "ACBONUS", nCurrApp);
            // Fetch the stringlist that holds the ID's for this part
            sPreRead = GetLocalString(GetModule(), "ZEP_IDPreReadAC_"+GetStringLeft(sAC,1));
            if (sPreRead=="") // list didn't exist yet, so generate it
                sPreRead = ZEP_PreReadArmorACList(sAC);
            if (nMode==ZEP_CR_PART_PREV)
                sPreRead = GetLocalString(GetModule(), "ZEP_IDPreReadACR_"+GetStringLeft(sAC,1));
        } else {
            // Fetch the stringlist that holds the ID's for this part
            sPreRead = GetLocalString(GetModule(), "ZEP_IDPreRead_"+IntToString(nPart));
            if (sPreRead=="") // list didn't exist yet, so generate it
                sPreRead = ZEP_PreReadArmorPartList(nPart);
            if (nMode==ZEP_CR_PART_PREV) sPreRead = GetLocalString(GetModule(), "ZEP_IDPreReadR_"+IntToString(nPart));
        }

        // Find the current ID in the stringlist and pick the one coming after that
        string sID;
        string sCurrApp = IntToString(nCurrApp);
        int n = FindSubString(sPreRead, ":"+sCurrApp+":");
        sID = GetSubString(sPreRead, n+GetStringLength(sCurrApp)+2, 5);
        n = FindSubString(sID, ":");
        sID = GetStringLeft(sID, n);
        if (sID=="" && nPart == ITEM_APPR_ARMOR_MODEL_TORSO) {
            sID = GetSubString(sPreRead, 1, 5);
            n = FindSubString(sID, ":");
            sID = GetStringLeft(sID, n);
        }
        nCurrApp = StringToInt(sID);

        oNew = CopyItemAndModify(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, nPart, nCurrApp, TRUE);
        nSlot = INVENTORY_SLOT_CHEST;

    } else if (nPart == ZEP_CR_HELMET) {
        // Handle Helmet change
        nCurrApp = GetItemAppearance(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, 0);
        int nMin = 1;
        int nMax = StringToInt(Get2DAString("baseitems", "MaxRange", BASE_ITEM_HELMET));

        //Note from Loki: Below code added in Do/while loop to
        //allow for scaling of helmets within reason without
        //needing to constantly reset the baseitems.2da file
        //parameters
        do {
            if (nMode == ZEP_CR_PART_NEXT) {
                if (++nCurrApp>nMax) nCurrApp = nMin;
            } else {
                if (--nCurrApp<nMin) nCurrApp = nMax;
            }

            oNew = CopyItemAndModify(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, 0, nCurrApp, TRUE);
            } while (!GetIsObjectValid(oNew));
            nSlot = INVENTORY_SLOT_HEAD;

    } else if (nPart == ZEP_CR_SHIELD) {
        // Handle Shield change
        nCurrApp = GetItemAppearance(oItem, ITEM_APPR_TYPE_SIMPLE_MODEL, 0);
        int nBaseType = GetBaseItemType(oItem);
        int nMin = StringToInt(Get2DAString("baseitems", "MinRange", nBaseType));
        int nMax = StringToInt(Get2DAString("baseitems", "MaxRange", nBaseType));

        //Note from Loki: This code i nthe Do/While may look a
        //bit odd.  This is because it does not follow the
        //standard method in the rest of this code for
        //changing appearance with one variable and color with
        //another.  Since shields do not have colors per se,
        //and CEP shields are not all numbered as the Bioware
        //shields are (only using appearanes **1-**3, always
        //contiguous in their appearance indexes), treating
        //them as if they did seemed to be inefficient.  Hence,
        //the loop updates it's counter a single index at a time
        //and searches for the next valid model.  This allows
        //for shields with one's digits of over 3, as well as
        //those starting at odd places (not having a **1
        //appearance, for example).

        do {
              if (nMode == ZEP_CR_PART_NEXT)
                  {
                  if (++nCurrApp > nMax) nCurrApp=nMin;
                  }
              else
                  {
                  if (--nCurrApp < nMin) nCurrApp=nMax;
                  }
            oNew = CopyItemAndModify(oItem, ITEM_APPR_TYPE_SIMPLE_MODEL, 0, nCurrApp, TRUE);
            } while (!GetIsObjectValid(oNew));

            nSlot = INVENTORY_SLOT_LEFTHAND;

    } else {
        // Handle Weapon change
        nCurrApp = GetItemAppearance(oItem, ITEM_APPR_TYPE_WEAPON_MODEL, nPart);
        int nBaseType = GetBaseItemType(oItem);
        int nMin = StringToInt(Get2DAString("baseitems", "MinRange", nBaseType)) /10;
        int nMax = StringToInt(Get2DAString("baseitems", "MaxRange", nBaseType)) /10;


        //Once again, Do/While loop added to accomodate the fact that
        //CEP models are not all contiguous with each other.  This
        //allows the code to rapidly skip over gaps in the weapon
        //models to the next valid index.

        do {
            if (nMode == ZEP_CR_PART_NEXT) {
                if (++nCurrApp>nMax) nCurrApp = nMin;
            } else {
                if (--nCurrApp<nMin) nCurrApp = nMax;
            }
            oNew = CopyItemAndModify(oItem, ITEM_APPR_TYPE_WEAPON_MODEL, nPart, nCurrApp, TRUE);
            } while (!GetIsObjectValid(oNew));

        nSlot = INVENTORY_SLOT_RIGHTHAND;
    }

    if (GetIsObjectValid(oNew)) {
        // new object is valid
        // get cost and DC
        int nNPC = GetIsObjectValid(GetLocalObject(oPC, "ZEP_CR_NPC"));
        object oBackup = GetLocalObject(oPC, "ZEP_CR_BACKUP");
        nCost = ZEP_GetModificationCost(oBackup, oNew, nNPC);
        nDC   = ZEP_GetModificationDC(oBackup, oNew, nNPC);
        SetLocalInt(oPC, "ZEP_CR_COST", nCost);
        SetLocalInt(oPC, "ZEP_CR_DC", nDC);
        SetCustomToken(ZEP_CR_TOKENBASE+1, IntToString(nCost));
        SetCustomToken(ZEP_CR_TOKENBASE+2, IntToString(nDC));

        // replace old current object with new one
        DestroyObject(oItem);
        //DestroyObject(oBackup);
        //oItem = oNew;
        SetLocalObject(oPC, "ZEP_CR_ITEM", oNew);
        SetLocalInt(oNew, "ZEP_CR_TEMPITEM", TRUE);
        SetStolenFlag(oNew,TRUE);
        AssignCommand(oPC, ClearAllActions(TRUE));
        AssignCommand(oPC, ActionEquipItem(oNew, nSlot));
    }
}

//Note from Loki: Below function is currently not used,
//except on weapons, as we have not yet fully converted
//SartriX's implementation of preview-able dye-ing of
//armor and weapons into something compatible with
//Bioware's existing system.  This function
//subject to heavy change and gutting in future releases.
//[FUTURE FIX]

// Remakes and equips the item oPC is working, having the currently set color
// cycled either forward or backward
// nMode: ZEP_CR_COLOR_NEXT - cycle forward
// nMode: ZEP_CR_COLOR_PREV - cycle backward
void ZEP_RecolorItem(object oPC, int nMode) {
    SetLocalInt(oPC, "ZEP_CR_CHANGED", TRUE);
    object oItem = GetLocalObject(oPC, "ZEP_CR_ITEM");
    int nPart    = GetLocalInt(oPC, "ZEP_CR_PART");
    int nCurrApp, nSlot, nCost, nDC;
    object oNew;


    if (GetBaseItemType(oItem)==BASE_ITEM_ARMOR || GetBaseItemType(oItem)==BASE_ITEM_HELMET) {
        // Handle Armor change
        nCurrApp = GetItemAppearance(oItem, ITEM_APPR_TYPE_ARMOR_COLOR, nPart);
        int nMin = 0;
        int nMax = 63;         //64 colors in NWN Palette-Loki

        if (nMode == ZEP_CR_COLOR_NEXT) {
            if (++nCurrApp>nMax) nCurrApp = nMin;
        } else {
            if (--nCurrApp<nMin) nCurrApp = nMax;
        }

        ZEP_SetColorToken(nPart, nCurrApp);
        oNew  = CopyItemAndModify(oItem, ITEM_APPR_TYPE_ARMOR_COLOR, nPart, nCurrApp, TRUE);
        nSlot = INVENTORY_SLOT_CHEST;
        if (GetBaseItemType(oItem)==BASE_ITEM_HELMET)
            nSlot = INVENTORY_SLOT_HEAD;

    } else if (nPart == ZEP_CR_SHIELD) {
        // Handle Weapon change
        nCurrApp = GetItemAppearance(oItem, ITEM_APPR_TYPE_SIMPLE_MODEL, 0);
        int nMod = (nCurrApp/10)*10;
        nCurrApp-= nMod;
        int nMin = 1;
        int nMax = 9; //Shield models final digit can range from 1-9 (techniclly 0 is included, but there are no index 0 models)

        do {
            if (nMode == ZEP_CR_COLOR_NEXT) {
                if (++nCurrApp>nMax) nCurrApp = nMin;
            } else {
                if (--nCurrApp<nMin) nCurrApp = nMax;
            }
            nCurrApp += nMod;
//
            oNew = CopyItemAndModify(oItem, ITEM_APPR_TYPE_SIMPLE_MODEL, 0, nCurrApp, TRUE);
            } while (!GetIsObjectValid(oNew));
        nSlot = INVENTORY_SLOT_LEFTHAND;

    } else {
        // Handle Weapon change- Addition of Do/While and indexes over 4 not tested yet [FUTURE FIX]
        nCurrApp = GetItemAppearance(oItem, ITEM_APPR_TYPE_WEAPON_COLOR, nPart);
        int nMin = 1;
        int nMax = 3;   //Only 3 colors supported in R1 of CEP, until we get 4th colors for all weapons.

//        do {
            if (nMode == ZEP_CR_COLOR_NEXT)
                {
                if (++nCurrApp>nMax) nCurrApp = nMin;
                }
            else {
                 if (--nCurrApp<nMin) nCurrApp = nMax;
                 }

            oNew = CopyItemAndModify(oItem, ITEM_APPR_TYPE_WEAPON_COLOR, nPart, nCurrApp, TRUE);
  //          } while (!GetIsObjectValid(oNew));

        nSlot = INVENTORY_SLOT_RIGHTHAND;
    }

    if (GetIsObjectValid(oNew)) {
        // new object is valid
        // get cost and DC
        int nNPC = GetIsObjectValid(GetLocalObject(oPC, "ZEP_CR_NPC"));
        object oBackup = GetLocalObject(oPC, "ZEP_CR_BACKUP");
        nCost = ZEP_GetModificationCost(oBackup, oNew, nNPC);
        nDC   = ZEP_GetModificationDC(oBackup, oNew, nNPC);
        SetLocalInt(oPC, "ZEP_CR_COST", nCost);
        SetLocalInt(oPC, "ZEP_CR_DC", nDC);
        SetCustomToken(ZEP_CR_TOKENBASE+1, IntToString(nCost));
        SetCustomToken(ZEP_CR_TOKENBASE+2, IntToString(nDC));

        // replace old current object with new one
        DestroyObject(oItem);
        oItem = oNew;
        SetLocalObject(oPC, "ZEP_CR_ITEM", oItem);
        AssignCommand(oPC, ClearAllActions(TRUE));
        AssignCommand(oPC, ActionEquipItem(oItem, nSlot));
    }
}

int ZEP_GetIsWeapon(object oWeapon) {
    int iType = GetBaseItemType(oWeapon);
    switch (iType) {
        case BASE_ITEM_BASTARDSWORD:
        case BASE_ITEM_BATTLEAXE:
        case BASE_ITEM_DAGGER:
        case BASE_ITEM_DIREMACE:
        case BASE_ITEM_DOUBLEAXE:
        case BASE_ITEM_DWARVENWARAXE:
        case BASE_ITEM_GREATAXE:
        case BASE_ITEM_GREATSWORD:
        case BASE_ITEM_HALBERD:
        case BASE_ITEM_HANDAXE:
        case BASE_ITEM_HEAVYFLAIL:
        case BASE_ITEM_KAMA:
        case BASE_ITEM_KATANA:
        case BASE_ITEM_KUKRI:
        case BASE_ITEM_LIGHTFLAIL:
        case BASE_ITEM_LIGHTHAMMER:
        case BASE_ITEM_LIGHTMACE:
        case BASE_ITEM_LONGSWORD:
        case BASE_ITEM_MORNINGSTAR:
        case BASE_ITEM_RAPIER:
        case BASE_ITEM_SCIMITAR:
        case BASE_ITEM_SCYTHE:
        case BASE_ITEM_SHORTSPEAR:
        case BASE_ITEM_SHORTSWORD:
        case BASE_ITEM_SICKLE:
        case BASE_ITEM_THROWINGAXE:
        case BASE_ITEM_TWOBLADEDSWORD:
        case BASE_ITEM_WARHAMMER:
        case BASE_ITEM_CLUB:
        case BASE_ITEM_HEAVYCROSSBOW:
        case BASE_ITEM_LIGHTCROSSBOW:
        case BASE_ITEM_LONGBOW:
        case BASE_ITEM_MAGICSTAFF:
        case BASE_ITEM_QUARTERSTAFF:
        case BASE_ITEM_SHORTBOW:
        case BASE_ITEM_SLING:
        case BASE_ITEM_WHIP:
//Note from Loki: Following cases are custom CEP weapon types
        case BASE_ITEM_TRIDENT:
        case BASE_ITEM_HEAVY_PICK:
        case BASE_ITEM_LIGHT_PICK:
        case BASE_ITEM_SAI:
        case BASE_ITEM_NUNCHAKU:
        //case BASE_ITEM_FALCHION1:
        case BASE_ITEM_SAP:
        case BASE_ITEM_DAGGERASSASSIN:
        case BASE_ITEM_KATAR:
        case BASE_ITEM_LIGHTMACE2:
        case BASE_ITEM_KUKRI2:
        case BASE_ITEM_FALCHION2:
        case BASE_ITEM_HEAVY_MACE:
        case BASE_ITEM_MAUL:
        case BASE_ITEM_MERCURIALLONGSWORD:
        case BASE_ITEM_MERCURIALGREATSWORD:
        case BASE_ITEM_DOUBLE_SCIMITAR:
        case BASE_ITEM_GOAD:
        case BASE_ITEM_WINDFIREWHEEL: return TRUE;
    }

    return FALSE;
}

int ZEP_GetIsShield(object oShield) {
    int iType = GetBaseItemType(oShield);
    if (iType==BASE_ITEM_SMALLSHIELD || iType==BASE_ITEM_LARGESHIELD || iType==BASE_ITEM_TOWERSHIELD)
        return TRUE;
    return FALSE;
}

//Below script by Loki...basically just a copy of Bioware's
//script for X2 to get the local crafting work container, if
//it exists, and if not, to create it and render it invisble
//and unselectable.
object ZEP_GetZEPWorkContainer(object oCaller)
{
//First try to get the container.
object oContainer = GetObjectByTag(ZEP_CR_BACKUP_PLACEABLE);
//If it's not valid, we make one.
if (!GetIsObjectValid(oContainer))
    {
        oContainer = CreateObject(OBJECT_TYPE_PLACEABLE,ZEP_CR_BACKUP_PLACEABLE,GetLocation(oCaller));
 //       SetLocalInt(oContainer,"DYNAMICALLY_CREATED",1);
        effect eCutsceneInvis =  EffectVisualEffect( VFX_DUR_CUTSCENE_INVISIBILITY);
        eCutsceneInvis = ExtraordinaryEffect(eCutsceneInvis);
        ApplyEffectToObject(DURATION_TYPE_PERMANENT,eCutsceneInvis,oContainer);

    }
    return oContainer;
}

//Below function by Loki
//Below function used as a substitution for the
//IPGetNumberOfArmorAppearances function in the CEP code.
//This is done because the max NumParts is coded as a
//constant to ensure compatibility with "vanilla' NWN.
int ZEP_GetNumberOfArmorAppearances(int nPart)
{
int nReturn;
switch (nPart)
    {
    case ITEM_APPR_ARMOR_MODEL_RFOOT:
    case ITEM_APPR_ARMOR_MODEL_LFOOT: nReturn=ZEP_MAX_PARTS_FOOT;
    case ITEM_APPR_ARMOR_MODEL_RSHIN:
    case ITEM_APPR_ARMOR_MODEL_LSHIN: nReturn=ZEP_MAX_PARTS_SHIN;
    case ITEM_APPR_ARMOR_MODEL_LTHIGH:
    case ITEM_APPR_ARMOR_MODEL_RTHIGH: nReturn=ZEP_MAX_PARTS_THIGH;
    case ITEM_APPR_ARMOR_MODEL_PELVIS: nReturn=ZEP_MAX_PARTS_PELVIS;
    case ITEM_APPR_ARMOR_MODEL_TORSO: nReturn=ZEP_MAX_PARTS_TORSO;
    case ITEM_APPR_ARMOR_MODEL_BELT: nReturn=ZEP_MAX_PARTS_BELT;
    case ITEM_APPR_ARMOR_MODEL_NECK: nReturn=ZEP_MAX_PARTS_NECK;
    case ITEM_APPR_ARMOR_MODEL_RFOREARM:
    case ITEM_APPR_ARMOR_MODEL_LFOREARM: nReturn=ZEP_MAX_PARTS_FOREARM;
    case ITEM_APPR_ARMOR_MODEL_RBICEP:
    case ITEM_APPR_ARMOR_MODEL_LBICEP: nReturn=ZEP_MAX_PARTS_BICEP;
    case ITEM_APPR_ARMOR_MODEL_RSHOULDER:
    case ITEM_APPR_ARMOR_MODEL_LSHOULDER: nReturn=ZEP_MAX_PARTS_SHOULDER;
    case ITEM_APPR_ARMOR_MODEL_RHAND:
    case ITEM_APPR_ARMOR_MODEL_LHAND: nReturn=ZEP_MAX_PARTS_HAND;
    case ITEM_APPR_ARMOR_MODEL_ROBE: nReturn=ZEP_MAX_PARTS_ROBE;
    }
return nReturn;
}

//Below function heavily modified by Loki
//This is a retooled version of SartriX's PurifyItem function.
//It has been enhanced to create a message to log the name
//of any duplicate found, as well as the player posessing it,
//and send this information to all DMs as well as log it to
//the server log file.
//Arguments
//  oItem is the object to test.
//  oPC is the PC Owner of the item
//  nIsEntering is a TRUE/FALSE flag that tells the function
//      if it is being called in an OnEnter script or not.
//      If so, it notes this in the Log file message, saying
//      the item was found on an entering player.  Logs
//      without this message mean the item was on an
//      already logged-on player, indicating recent duping.
void ZEP_PurifyItem(object oItem, object oPC, int nIsEntering)
{
  string sDupeReport;
  if (GetLocalInt(oItem, "ZEP_CR_TEMPITEM"))
      {
      //SendMessageToPC(oPC,("Destroyed: "+GetName(oItem)+"Crafting Duplicate"));
      //Note from Loki: The following block of code checks if
      //the function is being run as part of an "OnEnter"
      //script (as indicated y the function argument "nIsEntering".
      //If so, we note this in the log file.  Otherwise we send a
      //slightly shorter message.

      if (nIsEntering)
          sDupeReport="Crafting Duplicate '"+GetName(oItem)+"' Detected on entering player: "+GetName(oPC)+".  Item Destroyed.";
      else sDupeReport="Crafting Duplicate '"+GetName(oItem)+"' Detected on player: "+GetName(oPC)+".  Item Destroyed.";
      DestroyObject(oItem);
      WriteTimestampedLogEntry(sDupeReport);
      SendMessageToAllDMs(sDupeReport);
      }
}

//Below Function a modification of SartriX's original nocheat
//code.  I felt it would be better to encapsulate such
//functionality into a function, to make it easier to
//integrate into the OnEnter event hooks of existing modules
//and PWs.
//Argument explanation:
//      oPC -   PCs whos items we want ot check for crafting
//              duplicates
//      nIsEntering -
//              Variable determines whether to flag potential
//              DM Alert messages as "entering" or not.
//              Should be TRUE in an OnEnter script, FALSE
//              otherwise.
//      nDeleteTempVars -
//              When set to true, function will delete
//              crafting-associated local variables from the
//              PC in question.
void ZEP_PurifyAllItems(object oPC, int nIsEntering=FALSE,int nDeleteTempVars=FALSE)
{
  ZEP_PurifyItem(GetItemInSlot(INVENTORY_SLOT_CHEST, oPC),oPC,nIsEntering);
  ZEP_PurifyItem(GetItemInSlot(INVENTORY_SLOT_HEAD, oPC),oPC,nIsEntering);
  ZEP_PurifyItem(GetItemInSlot(INVENTORY_SLOT_RIGHTHAND, oPC),oPC,nIsEntering);
  ZEP_PurifyItem(GetItemInSlot(INVENTORY_SLOT_LEFTHAND, oPC),oPC,nIsEntering);
  object oItem = GetFirstItemInInventory(oPC);
  while (GetIsObjectValid(oItem))
      {
      ZEP_PurifyItem(oItem,oPC,TRUE);
      oItem = GetNextItemInInventory(oPC);
      }
  if (nDeleteTempVars == FALSE)
      return;
  DeleteLocalInt(oPC, "ZEP_CR_STARTED");
}

//:: void main (){}