/*
Utility     : Modification on Nimlyr's Custom XP Script
Created     : Sunday, May 11th, 2003
Version     : Final
Description : OnDeath Script (set NWN xp slider to 0)
              xp given with calculation due PartySize, AveragePartyLevel
              CRcreatureKilled.
Modified    : Arjan Duijs and Iain MacColl, December 10th 2003.
Extra Modification for C-PEN : by Iain MacColl
*/
#include "nw_i0_tool"
int GetPartyLevel(object oKiller);
int GetIsInSameArea(object oKiller, object oTarget);
int GetMultiMod(object oKiller, object oTarget);
void Message(object oKiller, string sMessage);
void RespawnObject(string sResRef, int iType, location lLoc)
{
CreateObject(iType, sResRef, lLoc);
}
void main()
{
////////////////////////////////////////////////////////////////////////////////
//implentment for automatic respawn
string sResRef = GetResRef(OBJECT_SELF);
int iType = GetObjectType(OBJECT_SELF);
// For creatures, save the location at spawn-time as a local location and
// use it instead. Otherwise, the creature will respawn where it died.
// No changes are required for placeables as they do not move (usually
location lLoc =GetLocation(OBJECT_SELF);
float fDelay = 500000.0; // 5 minute delay; adjust as desired
AssignCommand(GetModule(), DelayCommand(fDelay, RespawnObject(sResRef, iType, lLoc)));
////////////////////////////////////////////////////////////////////////////////

    /* Set up the needed variables. */
   float fCR = GetChallengeRating(OBJECT_SELF);
    object oKiller = GetLastKiller();
    if (GetMaster(oKiller) != OBJECT_INVALID)
        oKiller = GetMaster(oKiller);
    if (GetTrapCreator(oKiller) != OBJECT_INVALID)
        oKiller = GetTrapCreator(oKiller);
    if (GetIsPC(oKiller) == FALSE)
       return;
    int iXPMod = 100;
    int iPartyLevel = GetPartyLevel(oKiller);
    int iPartySize = GetLocalInt(OBJECT_SELF, "PartySize");
    int iHighPC = GetLocalInt(OBJECT_SELF, "HighPC");
    int iLowPC = GetLocalInt(OBJECT_SELF, "LowPC");
    int iDeadCR = FloatToInt(GetChallengeRating(OBJECT_SELF));
    if (iDeadCR < 1)
       iDeadCR = 1;
//summary message

/* determine party size vs reward percentage */
if (iPartySize = 1){ iXPMod = 100;}
else if (iPartySize = 2){ iXPMod = 100;}
else if (iPartySize = 3){ iXPMod = 80;}
else if (iPartySize = 4){ iXPMod = 75;}
else if (iPartySize = 5){ iXPMod = 50;}
else if (iPartySize = 6){ iXPMod = 40;}
else if (iPartySize > 6){ iXPMod = 40;}
/* Begin the task of determing the amount of XP given. */
if (iHighPC - iLowPC > 5)
    {
    /* The difference in levels of the highest and lowest pc's is too large. */
    Message(oKiller, "No XP gained Due Party level difference");
    }
else
    {
    // NOTE: I used this part for my trainings area where ppl can choose their own fight
    // depended on Creature CR and I didn't want ppl that are lvl 6 kill CR 1 creatures
    // Gives extra penalty when foe was 50% weaker then you are
    if (iDeadCR <= (iPartyLevel / 2))
        {
        /* The dead monster was too weak to be of any real danger to the PC's. */
        iXPMod = (iXPMod - 55);//55 percent XP penalty
        }
     if (iDeadCR >= (iPartyLevel / 2))
        {
        /* The dead monster was too strong to be killed without using uber weapons. */
        iXPMod = (iXPMod - 25);//25 percent XP penalty
        }


    /* Adjust the iXP to change max XP gained for a creature*/
    int iXP;
    if (iDeadCR < 5)                      { iXP = 20; }
    if ((iDeadCR > 5)  && (iDeadCR < 10)) { iXP = 30; }
    if ((iDeadCR > 10) && (iDeadCR < 15)) { iXP = 40; }
    if ((iDeadCR > 15) && (iDeadCR < 20)) { iXP = 50; }
    if ((iDeadCR > 20) && (iDeadCR < 25)) { iXP = 60; }
    if ((iDeadCR > 25) && (iDeadCR < 30)) { iXP = 70; }
    if ((iDeadCR > 25) && (iDeadCR < 30)) { iXP = 80; }
    if ((iDeadCR > 30) && (iDeadCR < 35)) { iXP = 90; }
    if ((iDeadCR > 35) && (iDeadCR < 40)) { iXP = 100; }
    if (iDeadCR > 40)                     { iXP = 105; }
    /* Check CR difference for XP bonus or penalty of 1XP per level difference */
    int iCRMod = (iDeadCR - iPartyLevel);
    if (iCRMod < 1) { Message(oKiller, IntToString(iCRMod)+"XP Penalty Due Low CR creature.");}
    //if (iCRMod >= 1){ Message(oKiller, IntToString(iCRMod)+"XP Bonus Due High CR creature.");}
    /* apply bonus or penalty percentage to iXPMod*/
    iXP = (iXP + iCRMod);
    /* Divide the XP Given by the number of Party Members */
    int iPartySize = GetLocalInt(OBJECT_SELF, "PartySize");
    //iXP = iXP / iPartySize;

    /* Calculate the result of XP based upon the percentage PartySize*/
    iXP = (iXP * iXPMod)/100;
////////////////////////////////////////////////////////////////////////////////
// Geeft elke PC appart van elkaar XP met de evt daarbij horende Multiclass penalty
////////////////////////////////////////////////////////////////////////////////
object oTarget = GetFirstFactionMember(oKiller);
while (oTarget != OBJECT_INVALID)
    {
    if (GetIsInSameArea(oKiller, oTarget) == TRUE && GetDistanceBetween(oKiller, oTarget) <= 50.0f)
        {
        int iMultiClMod = 100;// =100%
        // determine what class on position 1, 2 and 3
        int nClass1    = GetClassByPosition (1 , oKiller);
        int nClass2    = GetClassByPosition (2 , oKiller);
        int nClass3    = GetClassByPosition (3 , oKiller);
        // determine what Level on position 1, 2 and 3
        int nClassLvl1 = GetLevelByPosition (1 , oKiller);
        int nClassLvl2 = GetLevelByPosition (2 , oKiller);
        int nClassLvl3 = GetLevelByPosition (3 , oKiller);
        //Message(oKiller, "nClass1 is    "+IntToString(nClass1)+".");
        //Message(oKiller, "nClass2 is    "+IntToString(nClass2)+".");
        //Message(oKiller, "nClass3 is    "+IntToString(nClass3)+".");
        //Message(oKiller, "nClassLvl1 is "+IntToString(nClassLvl1)+".");
        //Message(oKiller, "nClassLvl2 is "+IntToString(nClassLvl2)+".");
        //Message(oKiller, "nClassLvl3 is "+IntToString(nClassLvl3)+".");
        /* we have 3 parts to determine the multiclass penaly or not */
        /* 1.# Even levels         100% : If 2 of the 3 the multiclass levels are the same with a max difference of 1 level */
        /* 2.# Oneven Levels       -20% : If 2 of the 3 the multiclass levels are larger then a difference of 1 level */
        /* 3.# Races & Multiclass  -20% : If 2 of the 3 the multiclass levels are the same with a max difference of 1 level */
        // 1.# and 2.#
        if ( (nClass3 != 255)
           &&( ((nClassLvl1 - nClassLvl3)>=1) || ((nClassLvl2 - nClassLvl3)>=1) ) )
                {
                iMultiClMod=iMultiClMod -10;
               // Message(oKiller, "10% Penalty due Uneven Multiclasses.");
                }
        else { iMultiClMod ==100; }
        // 3.#
        // if DWARF is multi-class. 1 class has to be Fighter
        // Or get 20% penalty
        if ( (GetRacialType(oKiller) == RACIAL_TYPE_DWARF)
            // if dwarf is multiclass?
            && ((nClass2 != 255) || (nClass3 != 255))
            //check if multiclass has a favored class.
            != ((nClass1 == 4)
            ||  (nClass2 == 4)
            ||  (nClass3 == 4)) )
                {
                // if not give penalty
                iMultiClMod=iMultiClMod -10;
               // Message(oKiller, "10% Penalty due Dwarf Multiclasses.");
                }
        // if ELF is multi-class. 1 class has to be Wizzard
        // or get 20% penalty
        else if ( (GetRacialType(oKiller)== RACIAL_TYPE_ELF)
            // if Elf is multiclass?
            && ((nClass2 != 255) || (nClass3 != 255))
            //check if multiclass has a favored class.
            != ((nClass1 == 10)
            ||  (nClass2 == 10)
            ||  (nClass3 == 10)) )
                {
                // if not give penalty
                iMultiClMod=iMultiClMod -10;
              //  Message(oKiller, "10% Penalty due Elf Multiclasses.");
                }
        // if GNOME is multi-class. 1 class has to be wizzard.
        // or get 20% penalty
        else if( (GetRacialType(oKiller)== RACIAL_TYPE_GNOME)
            // if Gnome is multiclass?
            && ((nClass2 != 255) || (nClass3 != 255))
            //check if multiclass has a favored class.
            != ((nClass1 == 10)
            ||  (nClass2 == 10)
            ||  (nClass3 == 10)) )
            //&& (nSpellSchool==FALSE) )
                {
                // if not give penalty
                iMultiClMod=iMultiClMod -10;
              //  Message(oKiller, "10% Penalty due Gnome Multiclasses.");
                }
        // if HALF ELF is multi-class.
        //else if (GetRacialType(oKiller)== RACIAL_TYPE_HALFELF)
        //    {
        //    // any favored multiclass (no Penalty's)
        //    }
        // if HALFLING is multi-class. 1 class has to be Rogue, Assasin or shadow dancer
        // or get 20% penalty
        else if( (GetRacialType(oKiller)== RACIAL_TYPE_HALFLING)
            // if Halfling is multiclass any
            && ((nClass2 != 255) || (nClass3 != 255))
            //check if multiclass has a favored class.
            != ((nClass1 == 8)
            ||  (nClass2 == 8)
            ||  (nClass3 == 8) ) )
                {
                // if not give penalty
                iMultiClMod=iMultiClMod -10;
              //  Message(oKiller, "10% Penalty due Halfling Multiclasses.");
                }
        // if HALF ORC is multi-class. 1 class has to be Barbarian
        // or get 20% penalty
        else if( (GetRacialType(oKiller)== RACIAL_TYPE_HALFORC)
            // if Half orc is multiclass any
            && ((nClass2 != 255) || (nClass3 != 255))
            //check if multiclass has a favored class.
            != ((nClass1 == 0)
            ||  (nClass2 == 0)
            ||  (nClass3 == 0)) )
                {
                // if not give penalty
                iMultiClMod=iMultiClMod -10;
             //   Message(oKiller, "10% Penalty due Half Orc Multiclasses.");
                }
     //   Message(oKiller, IntToString(iMultiClMod)+"% XP due forbidden Multiclasses.");
        // if HUMAN is multi-class.
        //else if (GetRacialType(oKiller)== RACIAL_TYPE_HUMAN)
        //    {
        //    // any favored multiclass (no Penalty's)
        //    }
        //>new/* Calculate the result of XP based upon the percentage Multiclass*/
        iXP = (iXP * iMultiClMod)/100;
        // reward each PC XP
            GiveXPToCreature(oTarget, iXP);
            }
        oTarget = GetNextFactionMember(oKiller);
        }
    }
/* Clean up variables. */
DeleteLocalInt(OBJECT_SELF, "PartySize");
DeleteLocalInt(OBJECT_SELF, "HighPC");
DeleteLocalInt(OBJECT_SELF, "LowPC");
}
/* Custom functions. */
////////////////////////////////////////////////////////////////////////////////
int GetPartyLevel(object oKiller)
////////////////////////////////////////////////////////////////////////////////
{
object oTarget = GetFirstFactionMember(oKiller, TRUE);
int iTargetLevel = GetHitDice(oTarget);
SetLocalInt(OBJECT_SELF, "HighPC", iTargetLevel);
SetLocalInt(OBJECT_SELF, "LowPC", iTargetLevel);
int iPartySize;
int iPartyLevel = 0;
    while (oTarget != OBJECT_INVALID)
        {
        if (GetIsInSameArea(oKiller, oTarget) == TRUE)
            {
            if (GetLocalInt(OBJECT_SELF, "HighPC") < iTargetLevel)
                {
                /* This sets the highest level member of the party. */
                SetLocalInt(OBJECT_SELF,"HighPC", iTargetLevel);
                }
            if (GetLocalInt(OBJECT_SELF, "LowPC") > iTargetLevel)
                {
                /* This sets the lowest level member of the party. */
                SetLocalInt(OBJECT_SELF,"LowPC", iTargetLevel);
                }
            iPartyLevel += iTargetLevel;
            iPartySize++;
            }
        oTarget = GetNextFactionMember(oKiller, TRUE);
        iTargetLevel = GetHitDice(oTarget);
        }
iPartyLevel = iPartyLevel / iPartySize;
SetLocalInt(OBJECT_SELF, "PartySize", iPartySize);
return iPartyLevel;
}
////////////////////////////////////////////////////////////////////////////////
int GetIsInSameArea(object oKiller, object oTarget)
////////////////////////////////////////////////////////////////////////////////
{
object oKillerArea = GetArea(oKiller);
object oTargetArea = GetArea(oTarget);
if (oKillerArea == oTargetArea && GetDistanceBetween(oKiller, oTarget) <= 50.0f)
    return TRUE;
return FALSE;
}
void Message (object oKiller, string sMessage)
{
object oTarget = GetFirstFactionMember(oKiller);
while (oTarget != OBJECT_INVALID)
    {
    if (GetIsInSameArea(oKiller, oTarget) == TRUE && GetDistanceBetween(oKiller, oTarget) <= 50.0f)
        {
        SendMessageToPC(oTarget, sMessage);
        }
    oTarget = GetNextFactionMember(oKiller);
    }
}