#include "hgll_const_inc"
#include "hgll_struct_stat"
#include "hgll_featreq_inc"
#include "hgll_classft_inc"
#include "hgll_leto_inc"
#include "hgll_spells_inc"
#include "aps_include"
//--------------------------------DECLARATIONS--------------------------------//
// This returns the current legendary level ("LL") of the PC. It is designed to
// work hand in hand with DAR subraces by tracking level by entering it in
// the (normally unused on PCs) Lootable field on the character file (".bic file").
// If you are not using DAR, it will still function correctly, using GetHitDice to
// track non-legendary levels.
int CheckLegendaryLevel(object oPC);
// This function determines whether a PC has enough experience to take the next legendary
// level. Possible return values: 1 for having enough, 0 for not, -1 for having too few
// levels to gain Legendary levels, and -2 for already having the maximum amount of LL.
int GetHasXPForNextLL(object oPC);
// This function was used to remove xp from a character based on what LL they were taking.
// It subtracted XP and then returned the XP that was subtracted. It returns zero if they
// are level 60 and -1 if they aren't level 40 yet. It is not used in the current configuration,
// which just lets the xp keep adding up, rather than subtracting the xp after the level is
// gained. This ensures that the character doesn't lose the experience that accrued if for some
// reason Letoscript misfires and fails to edit the character.
int SubtractXPForNextLL(object oPC);
// This function returns the amount of XP the PC is missing to reach their next LL. It will
// return the amount needed to reach level 41 if they are under level 40. If they already
// have enough, it returns 0. If they are level 60, it returns -1.
int GetXPNeededForNextLL(object oPC);
// This function checks for whether or not the PC gains a feat this level. By default it
// is set to one every three levels, carrying the progression of character feats onward from
// the last standard one received at 39, adding new feats starting at level 42 and ending at
// level 60. It is easily modified so that you can assign feats at whatever levels desired.
int GetGainsFeatOnLevelUp(object oPC);
// This function checks for whether or not the PC gains a stat this level. By default it
// is set to one every two levels, doubling the progression of character stats onward from
// the last standard one received at 40, adding new stats starting at level 42 and ending at
// level 60. It is easily modified so that you can assign stats at whatever levels desired.
int GetGainsStatOnLevelUp(object oPC);
// This function tells the caller whether the PC gains +1 to saving throws this level. By default
// it is set to one every four levels, halving the progression of character saves onward from
// the last standard increase received at 40, increasing saves starting at level 44 and ending at
// level 60. It is easily modified so that you can increase saves at whatever levels desired.
int GetGainsSavesOnLevelUp(object oPC);
// This function permanently tags a PC with the CLASS_TYPE that controls his LLs.
void SetControlClass(object oPC, int nClass);
// This function is where any other requirements besides experence and level
// are added to GetHasXPForNextLL. It returns TRUE by default unless modified.
int GetCanGainLL(object oPC);
// This function outputs debugging info to the player and log, but only if DEBUG is
// set to TRUE in hgll_const_inc.
void DoDebug(object oPC, string sDebug);
// This function calculates the Base Ability Scores and Skills of a character, including
// improvements by level and by feats, but filtering out bonuses from gear and effects.
// Skills need another round of filtering before they arrive at base levels.
// sWP: If you specify a WayPoint Tag in an inaccesible area, the clones will be
// generated there.
struct xAbility GetRoughAbilities(object oPC, string sWP="");
// This function returns the number of Great Strenth feats the character has.
int GetHasGreatStrenth(object oPC);
// This function returns the number of Great Dexterity feats the character has.
int GetHasGreatDexterity(object oPC);
// This function returns the number of Great Constitution feats the character has.
int GetHasGreatConstitution(object oPC);
// This function returns the number of Great Intelligence feats the character has.
int GetHasGreatIntelligence(object oPC);
// This function returns the number of Great Wisdom feats the character has.
int GetHasGreatWisdom(object oPC);
// This function returns the number of Great Charisma feats the character has.
int GetHasGreatCharisma(object oPC);
// This function filters out the Greater Stat Feats and Red Dragon Disciple ability bonuses
// from the ability scores.
int GetBaseStat(int nStatType, int nStat, object oPC);
// This function returns the Red Dragon Disciple ability bonus the character has for the
// specified ability.
int GetRDDStatMod(int nStatType, object oPC);
// This function returns the point vaule penalty (a positive number) for
// dexterity-based skills of the armor worn by the PC.
int GetArmorPenalty(object oPC);
// This function returns the point vaule penalty (a positive number) for
// dexterity-based skills of the shield worn by the PC.
int GetShieldPenalty(object oPC);
// This function takes a given stat number and calculates the bonus from it.
int GetBaseAbilityModifier(int nAmount);
// This function takes the scores retrieved from the GetRoughAbilities function and
// subtracts feat and ability bonuses from the skill to arrive at final base skill.
int GetBaseSkill(int nSkill, struct xAbility stat, object oPC);
// This function calculates the values of all the characters base skills,
// after adjusting them for stat modifiers and feats via GetBaseSkill.
struct xAbility GetBaseAbilities(struct xAbility stat, object oPC);
// This function sets local ints indicating the base ability for all 6 ability scores and
// all 27 skills. They are called later to help determine dependant characteristics like
// hitpoints, and are used to determine feat availabilities, etc.
void SetBaseAbilityMarkers(struct xAbility stat, object oPC);
//This function deletes all the ints tracking base ability and skill scores.
void DeleteBaseAbilityMarkers(object oPC);
// This function determines and returns the amount of skill points a character will get each
// LL based on their control class, INT modifier, and their main race (humans get +1)
int GetSkillPointsGainedOnLevelUp(object oPC);
// This function determines whether a skill is available to the charcter and should appear on the
// skill list, based on the character's control class, the amount of points they have remaining,
// the cost of the skill for the control class, and their current skill level in the skill.
int GetIsSkillAvailable(object oPC, int nSkill);
// This function returns the name string of the specified skill.
string GetNameOfSkill(int nSkill);
// This function returns the name of the tracking int for the specified skill.
string GetNameOfTrackingInt(int nSkill);
// This function determines the amount of HP that a character gets on levelup based on their
// control class, their CON modifier, and whether or not they've taken the toughness feat.
int GetHitPointsGainedOnLevelUp(object oPC);
// This function restores all limited usage feats so that GetHasFeat will not
// return a false negative.
void ReplenishLimitedUseFeats(object oPC);
// This function determines whether a feat is available to the charcter and should appear on the
// feat list, based on the character's control class, whether they meet the feat's requirements,
// whether they already have the feat, and whether the feat is restricted.
int GetIsFeatAvailable(int nFeat, object oPC);
// This function returns the name of the designated ability score.
string GetNameOfAbility(int nStat);
// This function returns TRUE if the specified feat is a class feat and the character has
// enough levels in the class to take it. Otherwise it returns FALSE.
int GetIsClassFeat(int nFeat, int nClass, object oPC);
//----------------------------------FUNCTIONS---------------------------------//
int CheckLegendaryLevel(object oPC)
{
int nLevel = GetLootable(oPC);
if (nLevel<41)
{
return GetHitDice(oPC);
}
else
{
return nLevel;
}
}
int GetHasXPForNextLL(object oPC)
{
switch(CheckLegendaryLevel(oPC))
{
case 40: return (XP_REQ_LVL41-GetXP(oPC)<=0); break;
case 41: return (XP_REQ_LVL42-GetXP(oPC)<=0); break;
case 42: return (XP_REQ_LVL43-GetXP(oPC)<=0); break;
case 43: return (XP_REQ_LVL44-GetXP(oPC)<=0); break;
case 44: return (XP_REQ_LVL45-GetXP(oPC)<=0); break;
case 45: return (XP_REQ_LVL46-GetXP(oPC)<=0); break;
case 46: return (XP_REQ_LVL47-GetXP(oPC)<=0); break;
case 47: return (XP_REQ_LVL48-GetXP(oPC)<=0); break;
case 48: return (XP_REQ_LVL49-GetXP(oPC)<=0); break;
case 49: return (XP_REQ_LVL50-GetXP(oPC)<=0); break;
case 50: return (XP_REQ_LVL51-GetXP(oPC)<=0); break;
case 51: return (XP_REQ_LVL52-GetXP(oPC)<=0); break;
case 52: return (XP_REQ_LVL53-GetXP(oPC)<=0); break;
case 53: return (XP_REQ_LVL54-GetXP(oPC)<=0); break;
case 54: return (XP_REQ_LVL55-GetXP(oPC)<=0); break;
case 55: return (XP_REQ_LVL56-GetXP(oPC)<=0); break;
case 56: return (XP_REQ_LVL57-GetXP(oPC)<=0); break;
case 57: return (XP_REQ_LVL58-GetXP(oPC)<=0); break;
case 58: return (XP_REQ_LVL59-GetXP(oPC)<=0); break;
case 59: return (XP_REQ_LVL60-GetXP(oPC)<=0); break;
case 60: return -2; break;
default: return -1; break;
}
return -3;
}
int SubtractXPForNextLL(object oPC)
{
switch(CheckLegendaryLevel(oPC))
{
case 40: SetXP(oPC,(GetXP(oPC)-XP_REQ_LVL41)); return XP_REQ_LVL41; break;
case 41: SetXP(oPC,(GetXP(oPC)-XP_REQ_LVL42)); return XP_REQ_LVL42; break;
case 42: SetXP(oPC,(GetXP(oPC)-XP_REQ_LVL43)); return XP_REQ_LVL43; break;
case 43: SetXP(oPC,(GetXP(oPC)-XP_REQ_LVL44)); return XP_REQ_LVL44; break;
case 44: SetXP(oPC,(GetXP(oPC)-XP_REQ_LVL45)); return XP_REQ_LVL45; break;
case 45: SetXP(oPC,(GetXP(oPC)-XP_REQ_LVL46)); return XP_REQ_LVL46; break;
case 46: SetXP(oPC,(GetXP(oPC)-XP_REQ_LVL47)); return XP_REQ_LVL47; break;
case 47: SetXP(oPC,(GetXP(oPC)-XP_REQ_LVL48)); return XP_REQ_LVL48; break;
case 48: SetXP(oPC,(GetXP(oPC)-XP_REQ_LVL49)); return XP_REQ_LVL49; break;
case 49: SetXP(oPC,(GetXP(oPC)-XP_REQ_LVL50)); return XP_REQ_LVL50; break;
case 50: SetXP(oPC,(GetXP(oPC)-XP_REQ_LVL51)); return XP_REQ_LVL51; break;
case 51: SetXP(oPC,(GetXP(oPC)-XP_REQ_LVL52)); return XP_REQ_LVL52; break;
case 52: SetXP(oPC,(GetXP(oPC)-XP_REQ_LVL53)); return XP_REQ_LVL53; break;
case 53: SetXP(oPC,(GetXP(oPC)-XP_REQ_LVL54)); return XP_REQ_LVL54; break;
case 54: SetXP(oPC,(GetXP(oPC)-XP_REQ_LVL55)); return XP_REQ_LVL55; break;
case 55: SetXP(oPC,(GetXP(oPC)-XP_REQ_LVL56)); return XP_REQ_LVL56; break;
case 56: SetXP(oPC,(GetXP(oPC)-XP_REQ_LVL57)); return XP_REQ_LVL57; break;
case 57: SetXP(oPC,(GetXP(oPC)-XP_REQ_LVL58)); return XP_REQ_LVL58; break;
case 58: SetXP(oPC,(GetXP(oPC)-XP_REQ_LVL59)); return XP_REQ_LVL59; break;
case 59: SetXP(oPC,(GetXP(oPC)-XP_REQ_LVL60)); return XP_REQ_LVL60; break;
case 60: return 0; break;
default: return -1; break;
}
return -3;
}
int GetXPNeededForNextLL(object oPC)
{
int nXP;
switch(CheckLegendaryLevel(oPC))
{
case 40: nXP = XP_REQ_LVL41-(GetXP(oPC)); if(nXP<=0) nXP = 0; break;
case 41: nXP = XP_REQ_LVL42-(GetXP(oPC)); if(nXP<=0) nXP = 0; break;
case 42: nXP = XP_REQ_LVL43-(GetXP(oPC)); if(nXP<=0) nXP = 0; break;
case 43: nXP = XP_REQ_LVL44-(GetXP(oPC)); if(nXP<=0) nXP = 0; break;
case 44: nXP = XP_REQ_LVL45-(GetXP(oPC)); if(nXP<=0) nXP = 0; break;
case 45: nXP = XP_REQ_LVL46-(GetXP(oPC)); if(nXP<=0) nXP = 0; break;
case 46: nXP = XP_REQ_LVL47-(GetXP(oPC)); if(nXP<=0) nXP = 0; break;
case 47: nXP = XP_REQ_LVL48-(GetXP(oPC)); if(nXP<=0) nXP = 0; break;
case 48: nXP = XP_REQ_LVL49-(GetXP(oPC)); if(nXP<=0) nXP = 0; break;
case 49: nXP = XP_REQ_LVL50-(GetXP(oPC)); if(nXP<=0) nXP = 0; break;
case 50: nXP = XP_REQ_LVL51-(GetXP(oPC)); if(nXP<=0) nXP = 0; break;
case 51: nXP = XP_REQ_LVL52-(GetXP(oPC)); if(nXP<=0) nXP = 0; break;
case 52: nXP = XP_REQ_LVL53-(GetXP(oPC)); if(nXP<=0) nXP = 0; break;
case 53: nXP = XP_REQ_LVL54-(GetXP(oPC)); if(nXP<=0) nXP = 0; break;
case 54: nXP = XP_REQ_LVL55-(GetXP(oPC)); if(nXP<=0) nXP = 0; break;
case 55: nXP = XP_REQ_LVL56-(GetXP(oPC)); if(nXP<=0) nXP = 0; break;
case 56: nXP = XP_REQ_LVL57-(GetXP(oPC)); if(nXP<=0) nXP = 0; break;
case 57: nXP = XP_REQ_LVL58-(GetXP(oPC)); if(nXP<=0) nXP = 0; break;
case 58: nXP = XP_REQ_LVL59-(GetXP(oPC)); if(nXP<=0) nXP = 0; break;
case 59: nXP = XP_REQ_LVL60-(GetXP(oPC)); if(nXP<=0) nXP = 0; break;
case 60: nXP = -1;
default: nXP = XP_REQ_LVL41-(GetXP(oPC)); if(nXP<=0) nXP = 0; break;
}
return nXP;
}
int GetGainsFeatOnLevelUp(object oPC)
{
switch(CheckLegendaryLevel(oPC))
{
case 41: return 1; break;
case 44: return 1; break;
case 47: return 1; break;
case 50: return 1; break;
case 53: return 1; break;
case 56: return 1; break;
case 59: return 1; break;
default: return 0; break;
}
return -3;
}
int GetGainsStatOnLevelUp(object oPC)
{
switch(CheckLegendaryLevel(oPC))
{
case 41: return 1; break;
case 43: return 1; break;
case 45: return 1; break;
case 47: return 1; break;
case 49: return 1; break;
case 51: return 1; break;
case 53: return 1; break;
case 55: return 1; break;
case 57: return 1; break;
case 59: return 1; break;
default: return 0; break;
}
return -3;
}
int GetGainsSavesOnLevelUp(object oPC)
{
switch(CheckLegendaryLevel(oPC))
{
case 43:
case 47:
case 51:
case 55:
case 59: return 1; break;
default: return 0; break;
}
return -3;
}
void SetControlClass(object oPC, int nClass)
{
SetPersistentInt(oPC, "ControlClass", nClass);
DoDebug(oPC, "Control Class: " + IntToString(nClass));
}
int GetCanGainLL(object oPC)
{
string immortalname;
string sName = GetName(oPC);
immortalname = GetStringLeft(sName, 8) + GetStringRight(sName, 8) + GetStringLeft(GetPCPlayerName(oPC), 8) + GetStringRight(GetPCPlayerName(oPC), 8);
int nImmortal = 2;//GetLocalInt(oPC, immortalname);
if (nImmortal == 2) return TRUE;
return FALSE;
}
void DoDebug(object oPC, string sDebug)
{
if (DEBUG)
{
WriteTimestampedLogEntry(sDebug);
SendMessageToPC(oPC, sDebug);
}
}
struct xAbility GetRoughAbilities(object oPC, string sWP="")
{
effect eEffect;
itemproperty ipPenalty;
int iCount;
int nValue;
int nValue2;
int nClass = GetControlClass(oPC);
object oItem, oWP, oClone;
location lClone;
struct xAbility xAbility;
for(iCount = 0; iCount < NUM_INVENTORY_SLOTS; iCount++)
{
oItem = GetItemInSlot(iCount, oPC);
if(GetIsObjectValid(oItem))
{
ipPenalty = GetFirstItemProperty(oItem);
while(GetIsItemPropertyValid(ipPenalty))
{
if(GetItemHasItemProperty(oItem, ITEM_PROPERTY_DECREASED_ABILITY_SCORE))
{
if(GetItemPropertyType(ipPenalty) == ITEM_PROPERTY_DECREASED_ABILITY_SCORE)
{
nValue = GetItemPropertyCostTableValue(ipPenalty);//will return between -1 and -10, matching the maximum penalty to skills from any given item
switch(GetItemPropertySubType(ipPenalty))
{
case ABILITY_STRENGTH: xAbility.nSTR += nValue; break;
case ABILITY_DEXTERITY: xAbility.nDEX += nValue; break;
case ABILITY_CONSTITUTION: xAbility.nCON += nValue; break;
case ABILITY_INTELLIGENCE: xAbility.nINT += nValue; break;
case ABILITY_WISDOM: xAbility.nWIS += nValue; break;
case ABILITY_CHARISMA: xAbility.nCHA += nValue; break;
}
}
}
if(GetItemHasItemProperty(oItem, ITEM_PROPERTY_DECREASED_SKILL_MODIFIER))
{
if(GetItemPropertyType(ipPenalty) == ITEM_PROPERTY_DECREASED_SKILL_MODIFIER)
{
nValue2 = GetItemPropertyCostTableValue(ipPenalty);//will return between -1 and -10, matching the maximum penalty to skills from any given item
switch(GetItemPropertySubType(ipPenalty))
{
case SKILL_ANIMAL_EMPATHY: xAbility.nANIMAL_EMPATHY += nValue2; break;
case SKILL_CONCENTRATION: xAbility.nCONCENTRATION += nValue2; break;
case SKILL_DISABLE_TRAP: xAbility.nDISABLE_TRAP += nValue2; break;
case SKILL_DISCIPLINE: xAbility.nDISCIPLINE += nValue2; break;
case SKILL_HEAL: xAbility.nHEAL += nValue2; break;
case SKILL_HIDE: xAbility.nHIDE += nValue2; break;
case SKILL_LISTEN: xAbility.nLISTEN += nValue2; break;
case SKILL_LORE: xAbility.nLORE += nValue2; break;
case SKILL_MOVE_SILENTLY: xAbility.nMOVE_SILENTLY += nValue2; break;
case SKILL_OPEN_LOCK: xAbility.nOPEN_LOCK += nValue2; break;
case SKILL_PARRY: xAbility.nPARRY += nValue2; break;
case SKILL_PERFORM: xAbility.nPERFORM += nValue2; break;
case SKILL_PERSUADE: xAbility.nPERSUADE += nValue2; break;
case SKILL_PICK_POCKET: xAbility.nPICK_POCKET += nValue2; break;
case SKILL_SEARCH: xAbility.nSEARCH += nValue2; break;
case SKILL_SET_TRAP: xAbility.nSET_TRAP += nValue2; break;
case SKILL_SPELLCRAFT: xAbility.nSPELLCRAFT += nValue2; break;
case SKILL_SPOT: xAbility.nSPOT += nValue2; break;
case SKILL_TAUNT: xAbility.nTAUNT += nValue2; break;
case SKILL_USE_MAGIC_DEVICE: xAbility.nUSE_MAGIC_DEVICE += nValue2; break;
case SKILL_APPRAISE: xAbility.nAPPRAISE += nValue2; break;
case SKILL_TUMBLE: xAbility.nTUMBLE += nValue2; break;
case SKILL_CRAFT_TRAP: xAbility.nCRAFT_TRAP += nValue2; break;
case SKILL_BLUFF: xAbility.nBLUFF += nValue2; break;
case SKILL_INTIMIDATE: xAbility.nINTIMIDATE += nValue2; break;
case SKILL_CRAFT_ARMOR: xAbility.nCRAFT_ARMOR += nValue2; break;
case SKILL_CRAFT_WEAPON: xAbility.nCRAFT_WEAPON += nValue2; break;
}
}
}
ipPenalty = GetNextItemProperty(oItem);
}
}
}
//Create Clone
oWP = GetWaypointByTag(sWP);
lClone = GetLocation(oWP);
if(sWP != "" && oWP != OBJECT_INVALID && GetAreaFromLocation(lClone)!= OBJECT_INVALID)
{
lClone = GetLocation(oWP);
}
else
{
lClone = GetLocation(oPC);
}
oClone = CopyObject(oPC,lClone);
//Remove Effects from Clone
eEffect = GetFirstEffect(oClone);
while(GetEffectType(eEffect) != EFFECT_TYPE_INVALIDEFFECT)
{
RemoveEffect(oClone, eEffect);
eEffect = GetNextEffect(oClone);
}
for(iCount = 0; iCount < 6; iCount++)
{
eEffect = EffectAbilityIncrease(iCount, 12);
ApplyEffectToObject(DURATION_TYPE_PERMANENT, eEffect, oClone);
nValue = GetAbilityScore(oClone, iCount);
switch(iCount)
{
case ABILITY_STRENGTH: if(xAbility.nSTR >= -10) xAbility.nSTR += nValue - 12; else xAbility.nSTR = nValue - 2; break;
case ABILITY_DEXTERITY: if(xAbility.nDEX >= -10) xAbility.nDEX += nValue - 12; else xAbility.nDEX = nValue - 2; break;
case ABILITY_CONSTITUTION: if(xAbility.nCON >= -10) xAbility.nCON += nValue - 12; else xAbility.nCON = nValue - 2; break;
case ABILITY_INTELLIGENCE: if(xAbility.nINT >= -10) xAbility.nINT += nValue - 12; else xAbility.nINT = nValue - 2; break;
case ABILITY_WISDOM: if(xAbility.nWIS >= -10) xAbility.nWIS += nValue - 12; else xAbility.nWIS = nValue - 2; break;
case ABILITY_CHARISMA: if(xAbility.nCHA >= -10) xAbility.nCHA += nValue - 12; else xAbility.nCHA = nValue - 2; break;
}
}
for(iCount = 0; iCount < 27; iCount++)
{
//eEffect = EffectSkillIncrease(iCount, 50);
ApplyEffectToObject(DURATION_TYPE_PERMANENT, eEffect, oClone);
nValue = GetSkillRank(iCount, oClone);
switch(iCount)//we subtract and extra 6 here for the stats being at +12, for a total of -56
{
case SKILL_ANIMAL_EMPATHY: if(xAbility.nANIMAL_EMPATHY >= -10) xAbility.nANIMAL_EMPATHY += nValue - 6; else xAbility.nANIMAL_EMPATHY = nValue - 2; break;
case SKILL_CONCENTRATION: if(xAbility.nCONCENTRATION >= -10) xAbility.nCONCENTRATION += nValue - 6; else xAbility.nCONCENTRATION = nValue - 2; break;
case SKILL_DISABLE_TRAP: if(xAbility.nDISABLE_TRAP >= -10) xAbility.nDISABLE_TRAP += nValue - 6; else xAbility.nDISABLE_TRAP = nValue - 2; break;
case SKILL_DISCIPLINE: if(xAbility.nDISCIPLINE >= -10) xAbility.nDISCIPLINE += nValue - 6; else xAbility.nDISCIPLINE = nValue - 2; break;
case SKILL_HEAL: if(xAbility.nHEAL >= -10) xAbility.nHEAL += nValue - 6; else xAbility.nHEAL = nValue - 2; break;
case SKILL_HIDE: if(xAbility.nHIDE >= -10) xAbility.nHIDE += nValue - 6; else xAbility.nHIDE = nValue - 2; break;
case SKILL_LISTEN: if(xAbility.nLISTEN >= -10) xAbility.nLISTEN += nValue - 6; else xAbility.nLISTEN = nValue - 2; break;
case SKILL_LORE: if(xAbility.nLORE >= -10) xAbility.nLORE += nValue - 6; else xAbility.nLORE = nValue - 2; break;
case SKILL_MOVE_SILENTLY: if(xAbility.nMOVE_SILENTLY >= -10) xAbility.nMOVE_SILENTLY += nValue - 6; else xAbility.nMOVE_SILENTLY = nValue - 2; break;
case SKILL_OPEN_LOCK: if(xAbility.nOPEN_LOCK >= -10) xAbility.nOPEN_LOCK += nValue - 6; else xAbility.nOPEN_LOCK = nValue - 2; break;
case SKILL_PARRY: if(xAbility.nPARRY >= -10) xAbility.nPARRY += nValue - 6; else xAbility.nPARRY = nValue - 2; break;
case SKILL_PERFORM: if(xAbility.nPERFORM >= -10) xAbility.nPERFORM += nValue - 6; else xAbility.nPERFORM = nValue - 2; break;
case SKILL_PERSUADE: if(xAbility.nPERSUADE >= -10) xAbility.nPERSUADE += nValue - 6; else xAbility.nPERSUADE = nValue - 2; break;
case SKILL_PICK_POCKET: if(xAbility.nPICK_POCKET >= -10) xAbility.nPICK_POCKET += nValue - 6; else xAbility.nPICK_POCKET = nValue - 2; break;
case SKILL_SEARCH: if(xAbility.nSEARCH >= -10) xAbility.nSEARCH += nValue - 6; else xAbility.nSEARCH = nValue - 2; break;
case SKILL_SET_TRAP: if(xAbility.nSET_TRAP >= -10) xAbility.nSET_TRAP += nValue - 6; else xAbility.nSET_TRAP = nValue - 2; break;
case SKILL_SPELLCRAFT: if(xAbility.nSPELLCRAFT >= -10) xAbility.nSPELLCRAFT += nValue - 6; else xAbility.nSPELLCRAFT = nValue - 2; break;
case SKILL_SPOT: if(xAbility.nSPOT >= -10) xAbility.nSPOT += nValue - 6; else xAbility.nSPOT = nValue - 2; break;
case SKILL_TAUNT: if(xAbility.nTAUNT >= -10) xAbility.nTAUNT += nValue - 6; else xAbility.nTAUNT = nValue - 2; break;
case SKILL_USE_MAGIC_DEVICE: if(xAbility.nUSE_MAGIC_DEVICE >= -10) xAbility.nUSE_MAGIC_DEVICE += nValue - 6; else xAbility.nUSE_MAGIC_DEVICE = nValue - 2; break;
case SKILL_APPRAISE: if(xAbility.nAPPRAISE >= -10) xAbility.nAPPRAISE += nValue - 6; else xAbility.nAPPRAISE = nValue - 2; break;
case SKILL_TUMBLE: if(xAbility.nTUMBLE >= -10) xAbility.nTUMBLE += nValue - 6; else xAbility.nTUMBLE = nValue - 2; break;
case SKILL_CRAFT_TRAP: if(xAbility.nCRAFT_TRAP >= -10) xAbility.nCRAFT_TRAP += nValue - 6; else xAbility.nCRAFT_TRAP = nValue - 2; break;
case SKILL_BLUFF: if(xAbility.nBLUFF >= -10) xAbility.nBLUFF += nValue - 6; else xAbility.nBLUFF = nValue - 2; break;
case SKILL_INTIMIDATE: if(xAbility.nINTIMIDATE >= -10) xAbility.nINTIMIDATE += nValue - 6; else xAbility.nINTIMIDATE = nValue - 2; break;
case SKILL_CRAFT_ARMOR: if(xAbility.nCRAFT_ARMOR >= -10) xAbility.nCRAFT_ARMOR += nValue - 6; else xAbility.nCRAFT_ARMOR = nValue - 2; break;
case SKILL_CRAFT_WEAPON: if(xAbility.nCRAFT_WEAPON >= -10) xAbility.nCRAFT_WEAPON += nValue - 6; else xAbility.nCRAFT_WEAPON = nValue - 2; break;
}
}
//dont try to destroy or take the clone items, wont work
DestroyObject(oClone);
return xAbility;
}
int GetBaseAbilityModifier(int nAmount)
{
if ((nAmount%2)==0)
{
nAmount = (nAmount/2)+(nAmount%2);
nAmount = nAmount-5;
}
else
{
nAmount = (nAmount/2)+(nAmount%2);
nAmount = nAmount-6;
}
return nAmount;
}
int GetHasGreatStrenth(object oPC)
{
int nFeat = 0;
if(GetHasFeat(FEAT_EPIC_GREAT_STRENGTH_1,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_STRENGTH_2,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_STRENGTH_3,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_STRENGTH_4,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_STRENGTH_5,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_STRENGTH_6,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_STRENGTH_7,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_STRENGTH_8,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_STRENGTH_9,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_STRENGTH_10,oPC)) nFeat++;
return nFeat;
}
int GetHasGreatDexterity(object oPC)
{
int nFeat = 0;
if(GetHasFeat(FEAT_EPIC_GREAT_DEXTERITY_1,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_DEXTERITY_2,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_DEXTERITY_3,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_DEXTERITY_4,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_DEXTERITY_5,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_DEXTERITY_6,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_DEXTERITY_7,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_DEXTERITY_8,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_DEXTERITY_9,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_DEXTERITY_10,oPC)) nFeat++;
return nFeat;
}
int GetHasGreatConstitution(object oPC)
{
int nFeat = 0;
if(GetHasFeat(FEAT_EPIC_GREAT_CONSTITUTION_1,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_CONSTITUTION_2,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_CONSTITUTION_3,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_CONSTITUTION_4,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_CONSTITUTION_5,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_CONSTITUTION_6,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_CONSTITUTION_7,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_CONSTITUTION_8,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_CONSTITUTION_9,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_CONSTITUTION_10,oPC)) nFeat++;
return nFeat;
}
int GetHasGreatIntelligence(object oPC)
{
int nFeat = 0;
if(GetHasFeat(FEAT_EPIC_GREAT_INTELLIGENCE_1,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_INTELLIGENCE_2,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_INTELLIGENCE_3,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_INTELLIGENCE_4,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_INTELLIGENCE_5,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_INTELLIGENCE_6,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_INTELLIGENCE_7,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_INTELLIGENCE_8,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_INTELLIGENCE_9,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_INTELLIGENCE_10,oPC)) nFeat++;
return nFeat;
}
int GetHasGreatWisdom(object oPC)
{
int nFeat = 0;
if(GetHasFeat(FEAT_EPIC_GREAT_WISDOM_1,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_WISDOM_2,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_WISDOM_3,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_WISDOM_4,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_WISDOM_5,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_WISDOM_6,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_WISDOM_7,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_WISDOM_8,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_WISDOM_9,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_WISDOM_10,oPC)) nFeat++;
return nFeat;
}
int GetHasGreatCharisma(object oPC)
{
int nFeat = 0;
if(GetHasFeat(FEAT_EPIC_GREAT_CHARISMA_1,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_CHARISMA_2,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_CHARISMA_3,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_CHARISMA_4,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_CHARISMA_5,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_CHARISMA_6,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_CHARISMA_7,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_CHARISMA_8,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_CHARISMA_9,oPC)) nFeat++;
if(GetHasFeat(FEAT_EPIC_GREAT_CHARISMA_10,oPC)) nFeat++;
return nFeat;
}
int GetBaseStat(int nStatType, int nStat, object oPC)
{
int nSubtract = 0;
int nBase;
switch(nStatType)
{
case ABILITY_STRENGTH:
nSubtract = GetHasGreatStrenth(oPC) + GetRDDStatMod(nStatType, oPC);
nBase = nStat; break;
case ABILITY_DEXTERITY:
nSubtract = GetHasGreatDexterity(oPC) + GetRDDStatMod(nStatType, oPC);
nBase = nStat; break ;
case ABILITY_CONSTITUTION:
nSubtract = GetHasGreatConstitution(oPC) + GetRDDStatMod(nStatType, oPC);;
nBase = nStat; break;
case ABILITY_INTELLIGENCE:
nSubtract = GetHasGreatIntelligence(oPC) + GetRDDStatMod(nStatType, oPC);;
nBase = nStat; break;
case ABILITY_WISDOM:
nSubtract = GetHasGreatWisdom(oPC) + GetRDDStatMod(nStatType, oPC);;
nBase = nStat; break;
case ABILITY_CHARISMA:
nSubtract = GetHasGreatCharisma(oPC) + GetRDDStatMod(nStatType, oPC);;
nBase = nStat; break;
default: return -3; break;
}
return (nBase-nSubtract);
}
int GetRDDStatMod(int nStatType, object oPC)
{
int nRDDLevel = GetLevelByClass(CLASS_TYPE_DRAGONDISCIPLE, oPC);
int nReturn = 0;
if (nRDDLevel < 1) return 0;//if not rdd, return
switch(nStatType)
{
case ABILITY_STRENGTH:
if (nRDDLevel > 9) nReturn = 8;
else if (nRDDLevel > 3) nReturn = 4;
else if (nRDDLevel > 1) nReturn = 2;
else nReturn = 0;
break;
case ABILITY_DEXTERITY:
if (nRDDLevel > 6) nReturn = 2;
else nReturn = 0;
break;
case ABILITY_CONSTITUTION:
case ABILITY_INTELLIGENCE:
if (nRDDLevel > 8) nReturn = 2;
else nReturn = 0;
break;
case ABILITY_WISDOM:
nReturn = 0;
break;
case ABILITY_CHARISMA:
if (nRDDLevel > 9) nReturn = 2;
else nReturn = 0;
break;
}
return nReturn;
}
int GetArmorPenalty(object oPC)
{
object oItem = GetItemInSlot(INVENTORY_SLOT_CHEST, oPC);
if (!GetIsObjectValid(oItem)) return 0;
if (GetBaseItemType(oItem) != BASE_ITEM_ARMOR) return 0;
SetIdentified(oItem,FALSE);
int nPenalty = 0;
switch (GetGoldPieceValue(oItem))
{
case 1: nPenalty = 0; break;
case 5: nPenalty = 0; break;
case 10: nPenalty = 0; break;
case 15: nPenalty = 1; break;
case 100: nPenalty = 2; break;
case 150: nPenalty = 5; break;
case 200: nPenalty = 7; break;
case 600: nPenalty = 7; break;
case 1500: nPenalty = 8; break;
}
SetIdentified(oItem,TRUE);
return nPenalty;
}
int GetShieldPenalty(object oPC)
{
object oItem = GetItemInSlot(INVENTORY_SLOT_LEFTHAND, oPC);
if (!GetIsObjectValid(oItem)) return 0;
int nType = GetBaseItemType(oItem);
int nPenalty = 0;
switch(nType)
{
case BASE_ITEM_SMALLSHIELD: nPenalty = 1; break;
case BASE_ITEM_LARGESHIELD: nPenalty = 2; break;
case BASE_ITEM_TOWERSHIELD: nPenalty = 10; break;
default: nPenalty = 0; break;
}
return nPenalty;
}
int GetBaseSkill(int nSkill, struct xAbility stat, object oPC)
{
int nSubtract = 0;
int nModifier = 0;
int nBase = 0;
int nArmorShield = 0;
int nValue = GetSkillRank(nSkill, oPC);
if (GetCostOfSkill(GetControlClass(oPC), nSkill) == -1 || nValue == 0)
{
return 0; //if skill non-available return 0
}
else
{
switch(nSkill)
{
case SKILL_ANIMAL_EMPATHY:
nBase = stat.nANIMAL_EMPATHY;
if(GetHasFeat(FEAT_SKILL_FOCUS_ANIMAL_EMPATHY,oPC))
nSubtract=nSubtract+3;
if(GetHasFeat(FEAT_EPIC_SKILL_FOCUS_ANIMAL_EMPATHY,oPC))
nSubtract=nSubtract+10;
// nSubtract = nSubtract + (GetHasGreatCharisma(oPC)/2);
nModifier=GetBaseAbilityModifier(stat.nCHA);
break;
case SKILL_APPRAISE:
nBase = stat.nAPPRAISE;
if(GetHasFeat(FEAT_SILVER_PALM,oPC))
nSubtract=nSubtract+2;
if(GetHasFeat(FEAT_SKILLFOCUS_APPRAISE,oPC))
nSubtract=nSubtract+3;
if(GetHasFeat(FEAT_EPIC_SKILL_FOCUS_APPRAISE,oPC))
nSubtract=nSubtract+10;
// nSubtract = nSubtract + (GetHasGreatIntelligence(oPC)/2);
nModifier = GetBaseAbilityModifier(stat.nINT);
break;
case SKILL_BLUFF:
nBase = stat.nBLUFF;
if(GetHasFeat(FEAT_EPIC_REPUTATION,oPC))
nSubtract=nSubtract+4;
if(GetHasFeat(FEAT_SKILL_FOCUS_BLUFF,oPC))
nSubtract=nSubtract+3;
if(GetHasFeat(FEAT_EPIC_SKILL_FOCUS_BLUFF,oPC))
nSubtract=nSubtract+10;
// nSubtract = nSubtract + (GetHasGreatCharisma(oPC)/2);
nModifier = GetBaseAbilityModifier(stat.nCHA);
break;
case SKILL_CONCENTRATION:
nBase = stat.nCONCENTRATION;
if(GetHasFeat(FEAT_SKILL_AFFINITY_CONCENTRATION,oPC))
nSubtract=nSubtract+2;
if(GetHasFeat(FEAT_SKILL_FOCUS_CONCENTRATION,oPC))
nSubtract=nSubtract+3;
if(GetHasFeat(FEAT_EPIC_SKILL_FOCUS_CONCENTRATION,oPC))
nSubtract=nSubtract+10;
// nSubtract = nSubtract + (GetHasGreatConstitution(oPC)/2);
nModifier = GetBaseAbilityModifier(stat.nCON);
break;
case SKILL_CRAFT_ARMOR:
nBase = stat.nCRAFT_ARMOR;
if(GetHasFeat(FEAT_SKILL_FOCUS_CRAFT_ARMOR,oPC))
nSubtract=nSubtract+3;
if(GetHasFeat(FEAT_EPIC_SKILL_FOCUS_CRAFT_ARMOR,oPC))
nSubtract=nSubtract+10;
// nSubtract = nSubtract + (GetHasGreatIntelligence(oPC)/2);
nModifier = GetBaseAbilityModifier(stat.nINT);
break;
case SKILL_CRAFT_TRAP:
nBase = stat.nCRAFT_TRAP;
if(GetHasFeat(FEAT_SKILL_FOCUS_CRAFT_TRAP,oPC))
nSubtract=nSubtract+3;
if(GetHasFeat(FEAT_EPIC_SKILL_FOCUS_CRAFT_TRAP,oPC))
nSubtract=nSubtract+10;
// nSubtract = nSubtract + (GetHasGreatIntelligence(oPC)/2);
nModifier = GetBaseAbilityModifier(stat.nINT);
break;
case SKILL_CRAFT_WEAPON:
nBase = stat.nCRAFT_WEAPON;
if(GetHasFeat(FEAT_SKILL_FOCUS_CRAFT_WEAPON,oPC))
nSubtract=nSubtract+3;
if(GetHasFeat(FEAT_EPIC_SKILL_FOCUS_CRAFT_WEAPON,oPC))
nSubtract=nSubtract+10;
// nSubtract = nSubtract + (GetHasGreatIntelligence(oPC)/2);
nModifier = GetBaseAbilityModifier(stat.nINT);
break;
case SKILL_DISABLE_TRAP:
nBase = stat.nDISABLE_TRAP;
if(GetHasFeat(FEAT_SKILL_FOCUS_DISABLE_TRAP,oPC))
nSubtract=nSubtract+3;
if(GetHasFeat(FEAT_EPIC_SKILL_FOCUS_DISABLETRAP,oPC))
nSubtract=nSubtract+10;
// nSubtract = nSubtract + (GetHasGreatIntelligence(oPC)/2);
nModifier = GetBaseAbilityModifier(stat.nINT);
break;
case SKILL_DISCIPLINE:
nBase = stat.nDISCIPLINE;
if(GetHasFeat(FEAT_SKILL_FOCUS_DISCIPLINE,oPC))
nSubtract=nSubtract+3;
if(GetHasFeat(FEAT_EPIC_SKILL_FOCUS_DISCIPLINE,oPC))
nSubtract=nSubtract+10;
// nSubtract = nSubtract + (GetHasGreatStrenth(oPC)/2);
nModifier = GetBaseAbilityModifier(stat.nSTR);
break;
case SKILL_HEAL:
nBase = stat.nHEAL;
if(GetHasFeat(FEAT_SKILL_FOCUS_HEAL,oPC))
nSubtract=nSubtract+3;
if(GetHasFeat(FEAT_EPIC_SKILL_FOCUS_HEAL,oPC))
nSubtract=nSubtract+10;
// nSubtract = nSubtract + (GetHasGreatWisdom(oPC)/2);
nModifier = GetBaseAbilityModifier(stat.nWIS);
break;
case SKILL_HIDE:
nBase = stat.nHIDE;
if(GetHasFeat(FEAT_STEALTHY,oPC))
nSubtract=nSubtract+2;
if(GetHasFeat(FEAT_SKILL_FOCUS_HIDE,oPC))
nSubtract=nSubtract+3;
if(GetHasFeat(FEAT_EPIC_SKILL_FOCUS_HIDE,oPC))
nSubtract=nSubtract+10;
nArmorShield = GetArmorPenalty(oPC) + GetShieldPenalty(oPC);
// nSubtract = nSubtract + (GetHasGreatDexterity(oPC)/2);
nModifier = GetBaseAbilityModifier(stat.nDEX);
break;
case SKILL_INTIMIDATE:
nBase = stat.nINTIMIDATE;
if(GetHasFeat(FEAT_EPIC_REPUTATION,oPC))
nSubtract=nSubtract+4;
if(GetHasFeat(FEAT_SKILL_FOCUS_INTIMIDATE,oPC))
nSubtract=nSubtract+3;
if(GetHasFeat(FEAT_EPIC_SKILL_FOCUS_INTIMIDATE,oPC))
nSubtract=nSubtract+10;
// nSubtract = nSubtract + (GetHasGreatCharisma(oPC)/2);
nModifier = GetBaseAbilityModifier(stat.nCHA);
break;
case SKILL_LISTEN:
nBase = stat.nLISTEN;
if(GetHasFeat(FEAT_PARTIAL_SKILL_AFFINITY_LISTEN,oPC))
nSubtract++;
if(GetHasFeat(FEAT_ALERTNESS,oPC))
nSubtract=nSubtract+2;
if(GetHasFeat(FEAT_SKILL_AFFINITY_LISTEN,oPC))
nSubtract=nSubtract+2;
if(GetHasFeat(FEAT_SKILL_FOCUS_LISTEN,oPC))
nSubtract=nSubtract+3;
if(GetHasFeat(FEAT_EPIC_SKILL_FOCUS_LISTEN,oPC))
nSubtract=nSubtract+10;
// nSubtract = nSubtract + (GetHasGreatWisdom(oPC)/2);
nModifier = GetBaseAbilityModifier(stat.nWIS);
break;
case SKILL_LORE:
nBase = stat.nLORE;
if(GetHasFeat(FEAT_BARDIC_KNOWLEDGE,oPC))
nSubtract=nSubtract+GetLevelByClass(CLASS_TYPE_BARD,oPC)+GetLevelByClass(CLASS_TYPE_HARPER);
if(GetHasFeat(FEAT_SKILL_AFFINITY_LORE,oPC))
nSubtract=nSubtract+2;
if(GetHasFeat(FEAT_COURTLY_MAGOCRACY,oPC))
nSubtract=nSubtract+2;
if(GetHasFeat(FEAT_SKILL_FOCUS_LORE,oPC))
nSubtract=nSubtract+3;
if(GetHasFeat(FEAT_EPIC_SKILL_FOCUS_LORE,oPC))
nSubtract=nSubtract+10;
// nSubtract = nSubtract + (GetHasGreatIntelligence(oPC)/2);
nModifier = GetBaseAbilityModifier(stat.nINT);
break;
case SKILL_MOVE_SILENTLY:
nBase = stat.nMOVE_SILENTLY;
if(GetHasFeat(FEAT_STEALTHY,oPC))
nSubtract=nSubtract+2;
if(GetHasFeat(FEAT_SKILL_AFFINITY_MOVE_SILENTLY,oPC))
nSubtract=nSubtract+2;
if(GetHasFeat(FEAT_SKILL_FOCUS_MOVE_SILENTLY,oPC))
nSubtract=nSubtract+3;
if(GetHasFeat(FEAT_EPIC_SKILL_FOCUS_MOVESILENTLY,oPC))
nSubtract=nSubtract+10;
nArmorShield = GetArmorPenalty(oPC) + GetShieldPenalty(oPC);
// nSubtract = nSubtract + (GetHasGreatDexterity(oPC)/2);
nModifier = GetBaseAbilityModifier(stat.nDEX);
break;
case SKILL_OPEN_LOCK:
nBase = stat.nOPEN_LOCK;
if(GetHasFeat(FEAT_SKILL_FOCUS_OPEN_LOCK,oPC))
nSubtract=nSubtract+3;
if(GetHasFeat(FEAT_EPIC_SKILL_FOCUS_OPENLOCK,oPC))
nSubtract=nSubtract+10;
// nSubtract = nSubtract + (GetHasGreatDexterity(oPC)/2);
nModifier = GetBaseAbilityModifier(stat.nDEX);
break;
case SKILL_PARRY:
nBase = stat.nPARRY;
if(GetHasFeat(FEAT_SKILL_FOCUS_PARRY,oPC))
nSubtract=nSubtract+3;
if(GetHasFeat(FEAT_EPIC_SKILL_FOCUS_PARRY,oPC))
nSubtract=nSubtract+10;
nArmorShield = GetArmorPenalty(oPC) + GetShieldPenalty(oPC);
// nSubtract = nSubtract + (GetHasGreatDexterity(oPC)/2);
nModifier = GetBaseAbilityModifier(stat.nDEX);
break;
case SKILL_PERFORM:
nBase = stat.nPERFORM;
if(GetHasFeat(FEAT_ARTIST,oPC))
nSubtract=nSubtract+2;
if(GetHasFeat(FEAT_SKILL_FOCUS_PERFORM,oPC))
nSubtract=nSubtract+3;
if(GetHasFeat(FEAT_EPIC_SKILL_FOCUS_PERFORM,oPC))
nSubtract=nSubtract+10;
// nSubtract = nSubtract + (GetHasGreatCharisma(oPC)/2);
nModifier = GetBaseAbilityModifier(stat.nCHA);
break;
case SKILL_PERSUADE:
nBase = stat.nPERSUADE;
if(GetHasFeat(FEAT_SILVER_PALM,oPC))
nSubtract=nSubtract+2;
if(GetHasFeat(FEAT_THUG,oPC))
nSubtract=nSubtract+2;
if(GetHasFeat(FEAT_EPIC_REPUTATION,oPC))
nSubtract=nSubtract+4;
if(GetHasFeat(FEAT_SKILL_FOCUS_PERSUADE,oPC))
nSubtract=nSubtract+3;
if(GetHasFeat(FEAT_EPIC_SKILL_FOCUS_PERSUADE,oPC))
nSubtract=nSubtract+10;
// nSubtract = nSubtract + (GetHasGreatCharisma(oPC)/2);
nModifier = GetBaseAbilityModifier(stat.nCHA);
break;
case SKILL_PICK_POCKET:
nBase = stat.nPICK_POCKET;
if(GetHasFeat(FEAT_SKILL_FOCUS_PICK_POCKET,oPC))
nSubtract=nSubtract+3;
if(GetHasFeat(FEAT_EPIC_SKILL_FOCUS_PICKPOCKET,oPC))
nSubtract=nSubtract+10;
nArmorShield = GetArmorPenalty(oPC) + GetShieldPenalty(oPC);
// nSubtract = nSubtract + (GetHasGreatDexterity(oPC)/2);
nModifier = GetBaseAbilityModifier(stat.nDEX);
break;
case SKILL_SEARCH:
nBase = stat.nSEARCH;
if(GetHasFeat(FEAT_PARTIAL_SKILL_AFFINITY_SEARCH,oPC))
nSubtract=nSubtract+1;
if(GetHasFeat(FEAT_SKILL_AFFINITY_SEARCH,oPC))
nSubtract=nSubtract+2;
if(GetHasFeat(FEAT_SKILL_FOCUS_SEARCH,oPC))
nSubtract=nSubtract+3;
if(GetHasFeat(FEAT_EPIC_SKILL_FOCUS_SEARCH,oPC))
nSubtract=nSubtract+10;
// nSubtract = nSubtract + (GetHasGreatIntelligence(oPC)/2);
nModifier = GetBaseAbilityModifier(stat.nINT);
break;
case SKILL_SET_TRAP:
nBase = stat.nSET_TRAP;
if(GetHasFeat(FEAT_SKILL_FOCUS_SET_TRAP,oPC))
nSubtract=nSubtract+3;
if(GetHasFeat(FEAT_EPIC_SKILL_FOCUS_SETTRAP,oPC))
nSubtract=nSubtract+10;
nArmorShield = GetArmorPenalty(oPC) + GetShieldPenalty(oPC);
// nSubtract = nSubtract + (GetHasGreatDexterity(oPC)/2);
nModifier = GetBaseAbilityModifier(stat.nDEX);
break;
case SKILL_SPELLCRAFT:
nBase = stat.nSPELLCRAFT;
if(GetHasFeat(FEAT_COURTLY_MAGOCRACY,oPC))
nSubtract=nSubtract+2;
if(GetHasFeat(FEAT_SKILL_FOCUS_SPELLCRAFT,oPC))
nSubtract=nSubtract+3;
if(GetHasFeat(FEAT_EPIC_SKILL_FOCUS_SPELLCRAFT,oPC))
nSubtract=nSubtract+10;
// nSubtract = nSubtract + (GetHasGreatIntelligence(oPC)/2);
nModifier = GetBaseAbilityModifier(stat.nINT);
break;
case SKILL_SPOT:
nBase = stat.nSPOT;
if(GetHasFeat(FEAT_ALERTNESS,oPC))
nSubtract=nSubtract+2;
if(GetHasFeat(FEAT_BLOODED,oPC))
nSubtract=nSubtract+2;
if(GetHasFeat(FEAT_ARTIST,oPC))
nSubtract=nSubtract+2;
if(GetHasFeat(FEAT_PARTIAL_SKILL_AFFINITY_SPOT,oPC))
nSubtract=nSubtract+1;
if(GetHasFeat(FEAT_SKILL_AFFINITY_SPOT,oPC))
nSubtract=nSubtract+2;
if(GetHasFeat(FEAT_SKILL_FOCUS_SPOT,oPC))
nSubtract=nSubtract+3;
if(GetHasFeat(FEAT_EPIC_SKILL_FOCUS_SPOT,oPC))
nSubtract=nSubtract+10;
// nSubtract = nSubtract + (GetHasGreatWisdom(oPC)/2);
nModifier = GetBaseAbilityModifier(stat.nWIS);
break;
case SKILL_TAUNT:
nBase = stat.nTAUNT;
if(GetHasFeat(FEAT_EPIC_REPUTATION,oPC))
nSubtract=nSubtract+4;
if(GetHasFeat(FEAT_SKILL_FOCUS_TAUNT,oPC))
nSubtract=nSubtract+3;
if(GetHasFeat(FEAT_EPIC_SKILL_FOCUS_TAUNT,oPC))
nSubtract=nSubtract+10;
// nSubtract = nSubtract + (GetHasGreatCharisma(oPC)/2);
nModifier = GetBaseAbilityModifier(stat.nCHA);
break;
case SKILL_TUMBLE:
nBase = stat.nTUMBLE;
if(GetHasFeat(FEAT_SKILL_FOCUS_TUMBLE,oPC))
nSubtract=nSubtract+3;
if(GetHasFeat(FEAT_EPIC_SKILL_FOCUS_TUMBLE,oPC))
nSubtract=nSubtract+10;
nArmorShield = GetArmorPenalty(oPC) + GetShieldPenalty(oPC);
// nSubtract = nSubtract + (GetHasGreatDexterity(oPC)/2);
nModifier = GetBaseAbilityModifier(stat.nDEX);
break;
case SKILL_USE_MAGIC_DEVICE:
nBase = stat.nUSE_MAGIC_DEVICE;
if(GetHasFeat(FEAT_SKILL_FOCUS_USE_MAGIC_DEVICE,oPC))
nSubtract=nSubtract+3;
if(GetHasFeat(FEAT_EPIC_SKILL_FOCUS_USEMAGICDEVICE,oPC))
nSubtract=nSubtract+10;
// nSubtract = nSubtract + (GetHasGreatCharisma(oPC)/2);
nModifier = GetBaseAbilityModifier(stat.nCHA);
break;
default: return -3;
}
return (nBase-nSubtract-nModifier+nArmorShield);
}
}
struct xAbility GetBaseAbilities(struct xAbility stat, object oPC)
{
struct xAbility base;
int iCount;
int nBaseAbility;
for(iCount = 0; iCount < 6; iCount++)//filter out the greater stat feats
{
switch(iCount)
{
case ABILITY_STRENGTH: base.nSTR = GetBaseStat(iCount, stat.nSTR, oPC); break;
case ABILITY_DEXTERITY: base.nDEX = GetBaseStat(iCount, stat.nDEX, oPC); break;
case ABILITY_CONSTITUTION: base.nCON = GetBaseStat(iCount, stat.nCON, oPC); break;
case ABILITY_INTELLIGENCE: base.nINT = GetBaseStat(iCount, stat.nINT, oPC); break;
case ABILITY_WISDOM: base.nWIS = GetBaseStat(iCount, stat.nWIS, oPC); break;
case ABILITY_CHARISMA: base.nCHA = GetBaseStat(iCount, stat.nCHA, oPC); break;
}
}
//For skills we must still process them to remove ability and feat bonuses.
for(iCount = 0; iCount < 27; iCount++)
{
nBaseAbility = GetBaseSkill(iCount, stat, oPC);
switch (iCount)
{
case 0: base.nANIMAL_EMPATHY = nBaseAbility; break;
case 1: base.nCONCENTRATION = nBaseAbility; break;
case 2: base.nDISABLE_TRAP = nBaseAbility; break;
case 3: base.nDISCIPLINE = nBaseAbility; break;
case 4: base.nHEAL = nBaseAbility; break;
case 5: base.nHIDE = nBaseAbility; break;
case 6: base.nLISTEN = nBaseAbility; break;
case 7: base.nLORE = nBaseAbility; break;
case 8: base.nMOVE_SILENTLY = nBaseAbility; break;
case 9: base.nOPEN_LOCK = nBaseAbility; break;
case 10: base.nPARRY = nBaseAbility; break;
case 11: base.nPERFORM = nBaseAbility; break;
case 12: base.nPERSUADE = nBaseAbility; break;
case 13: base.nPICK_POCKET = nBaseAbility; break;
case 14: base.nSEARCH = nBaseAbility; break;
case 15: base.nSET_TRAP = nBaseAbility; break;
case 16: base.nSPELLCRAFT = nBaseAbility; break;
case 17: base.nSPOT = nBaseAbility; break;
case 18: base.nTAUNT = nBaseAbility; break;
case 19: base.nUSE_MAGIC_DEVICE = nBaseAbility; break;
case 20: base.nAPPRAISE = nBaseAbility; break;
case 21: base.nTUMBLE = nBaseAbility; break;
case 22: base.nCRAFT_TRAP = nBaseAbility; break;
case 23: base.nBLUFF = nBaseAbility; break;
case 24: base.nINTIMIDATE = nBaseAbility; break;
case 25: base.nCRAFT_ARMOR = nBaseAbility; break;
case 26: base.nCRAFT_WEAPON = nBaseAbility; break;
}
}
return base;
}
void SetBaseAbilityMarkers(struct xAbility stat, object oPC)
{
SetLocalInt(oPC, "BASE_STR", stat.nSTR);
SetLocalInt(oPC, "BASE_DEX", stat.nDEX);
SetLocalInt(oPC, "BASE_CON", stat.nCON);
SetLocalInt(oPC, "BASE_INT", stat.nINT);
SetLocalInt(oPC, "BASE_WIS", stat.nWIS);
SetLocalInt(oPC, "BASE_CHA", stat.nCHA);
DoDebug(oPC, "Base ability ints set as STR: "+IntToString(GetLocalInt(oPC, "BASE_STR"))+", DEX: "+IntToString(GetLocalInt(oPC, "BASE_DEX"))+", CON: "+IntToString(GetLocalInt(oPC, "BASE_CON"))+", INT: "+IntToString(GetLocalInt(oPC, "BASE_INT"))+", WIS: "+IntToString(GetLocalInt(oPC, "BASE_WIS"))+", CHA: "+IntToString(GetLocalInt(oPC, "BASE_CHA"))+".");
SetLocalInt(oPC, "BASE_ANIMAL", stat.nANIMAL_EMPATHY);
SetLocalInt(oPC, "BASE_CONCEN", stat.nCONCENTRATION);
SetLocalInt(oPC, "BASE_DISABL", stat.nDISABLE_TRAP);
SetLocalInt(oPC, "BASE_DISCIP", stat.nDISCIPLINE);
SetLocalInt(oPC, "BASE_HEAL", stat.nHEAL);
SetLocalInt(oPC, "BASE_HIDE", stat.nHIDE);
DoDebug(oPC, "Base ability ints set as ANIMAL: "+IntToString(GetLocalInt(oPC, "BASE_ANIMAL"))+", CONCEN: "+IntToString(GetLocalInt(oPC, "BASE_CONCEN"))+", DISABL: "+IntToString(GetLocalInt(oPC, "BASE_DISABL"))+", DISCIP: "+IntToString(GetLocalInt(oPC, "BASE_DISCIP"))+", HEAL: "+IntToString(GetLocalInt(oPC, "BASE_HEAL"))+", HIDE: "+IntToString(GetLocalInt(oPC, "BASE_HIDE"))+".");
SetLocalInt(oPC, "BASE_LISTEN", stat.nLISTEN);
SetLocalInt(oPC, "BASE_LORE", stat.nLORE);
SetLocalInt(oPC, "BASE_MOVE_S", stat.nMOVE_SILENTLY);
SetLocalInt(oPC, "BASE_OPEN_L", stat.nOPEN_LOCK);
SetLocalInt(oPC, "BASE_PARRY", stat.nPARRY);
SetLocalInt(oPC, "BASE_PERFOR", stat.nPERFORM);
DoDebug(oPC, "Base ability ints set as LISTEN: "+IntToString(GetLocalInt(oPC, "BASE_LISTEN"))+", LORE: "+IntToString(GetLocalInt(oPC, "BASE_LORE"))+", MOVE_S: "+IntToString(GetLocalInt(oPC, "BASE_MOVE_S"))+", OPEN_L: "+IntToString(GetLocalInt(oPC, "BASE_OPEN_L"))+", PARRY: "+IntToString(GetLocalInt(oPC, "BASE_PARRY"))+", PERFOR: "+IntToString(GetLocalInt(oPC, "BASE_PERFOR"))+".");
SetLocalInt(oPC, "BASE_PERSUA", stat.nPERSUADE);
SetLocalInt(oPC, "BASE_PICK_P", stat.nPICK_POCKET);
SetLocalInt(oPC, "BASE_SEARCH", stat.nSEARCH);
SetLocalInt(oPC, "BASE_SET_TR", stat.nSET_TRAP);
SetLocalInt(oPC, "BASE_SPELLC", stat.nSPELLCRAFT);
SetLocalInt(oPC, "BASE_SPOT", stat.nSPOT);
DoDebug(oPC, "Base ability ints set as PERSUA: "+IntToString(GetLocalInt(oPC, "BASE_PERSUA"))+", PICK_P: "+IntToString(GetLocalInt(oPC, "BASE_PICK_P"))+", SEARCH: "+IntToString(GetLocalInt(oPC, "BASE_SEARCH"))+", SET_TR: "+IntToString(GetLocalInt(oPC, "BASE_SET_TR"))+", SPELLC: "+IntToString(GetLocalInt(oPC, "BASE_SPELLC"))+", SPOT: "+IntToString(GetLocalInt(oPC, "BASE_SPOT"))+".");
SetLocalInt(oPC, "BASE_TAUNT", stat.nTAUNT);
SetLocalInt(oPC, "BASE_USE_MA", stat.nUSE_MAGIC_DEVICE);
SetLocalInt(oPC, "BASE_APPRAI", stat.nAPPRAISE);
SetLocalInt(oPC, "BASE_TUMBLE", stat.nTUMBLE);
SetLocalInt(oPC, "BASE_CRAFT_T", stat.nCRAFT_TRAP);
SetLocalInt(oPC, "BASE_BLUFF", stat.nBLUFF);
DoDebug(oPC, "Base ability ints set as TAUNT: "+IntToString(GetLocalInt(oPC, "BASE_TAUNT"))+", USE_MA: "+IntToString(GetLocalInt(oPC, "BASE_USE_MA"))+", APPRAI: "+IntToString(GetLocalInt(oPC, "BASE_APPRAI"))+", TUMBLE: "+IntToString(GetLocalInt(oPC, "BASE_TUMBLE"))+", CRAFT_T: "+IntToString(GetLocalInt(oPC, "BASE_CRAFT_T"))+", BLUFF: "+IntToString(GetLocalInt(oPC, "BASE_BLUFF"))+".");
SetLocalInt(oPC, "BASE_INTIMI", stat.nINTIMIDATE);
SetLocalInt(oPC, "BASE_CRAFT_A", stat.nCRAFT_ARMOR);
SetLocalInt(oPC, "BASE_CRAFT_W", stat.nCRAFT_WEAPON);
DoDebug(oPC, "Base ability ints set as INTIMI: "+IntToString(GetLocalInt(oPC, "BASE_INTIMI"))+", CRAFT_A: "+IntToString(GetLocalInt(oPC, "BASE_CRAFT_A"))+", CRAFT_W: "+IntToString(GetLocalInt(oPC, "BASE_CRAFT_W"))+".");
}
void DeleteBaseAbilityMarkers(object oPC)
{
DeleteLocalInt(oPC, "BASE_STR");
DeleteLocalInt(oPC, "BASE_DEX");
DeleteLocalInt(oPC, "BASE_CON");
DeleteLocalInt(oPC, "BASE_INT");
DeleteLocalInt(oPC, "BASE_WIS");
DeleteLocalInt(oPC, "BASE_CHA");
DoDebug(oPC, "Base ability ints set as STR: "+IntToString(GetLocalInt(oPC, "BASE_STR"))+", DEX: "+IntToString(GetLocalInt(oPC, "BASE_DEX"))+", CON: "+IntToString(GetLocalInt(oPC, "BASE_CON"))+", INT: "+IntToString(GetLocalInt(oPC, "BASE_INT"))+", WIS: "+IntToString(GetLocalInt(oPC, "BASE_WIS"))+", CHA: "+IntToString(GetLocalInt(oPC, "BASE_CHA"))+".");
DeleteLocalInt(oPC, "BASE_ANIMAL");
DeleteLocalInt(oPC, "BASE_CONCEN");
DeleteLocalInt(oPC, "BASE_DISABL");
DeleteLocalInt(oPC, "BASE_DISCIP");
DeleteLocalInt(oPC, "BASE_HEAL");
DeleteLocalInt(oPC, "BASE_HIDE");
DoDebug(oPC, "Base ability ints set as ANIMAL: "+IntToString(GetLocalInt(oPC, "BASE_ANIMAL"))+", CONCEN: "+IntToString(GetLocalInt(oPC, "BASE_CONCEN"))+", DISABL: "+IntToString(GetLocalInt(oPC, "BASE_DISABL"))+", DISCIP: "+IntToString(GetLocalInt(oPC, "BASE_DISCIP"))+", HEAL: "+IntToString(GetLocalInt(oPC, "BASE_HEAL"))+", HIDE: "+IntToString(GetLocalInt(oPC, "BASE_HIDE"))+".");
DeleteLocalInt(oPC, "BASE_LISTEN");
DeleteLocalInt(oPC, "BASE_LORE");
DeleteLocalInt(oPC, "BASE_MOVE_S");
DeleteLocalInt(oPC, "BASE_OPEN_L");
DeleteLocalInt(oPC, "BASE_PARRY");
DeleteLocalInt(oPC, "BASE_PERFOR");
DoDebug(oPC, "Base ability ints set as LISTEN: "+IntToString(GetLocalInt(oPC, "BASE_LISTEN"))+", LORE: "+IntToString(GetLocalInt(oPC, "BASE_LORE"))+", MOVE_S: "+IntToString(GetLocalInt(oPC, "BASE_MOVE_S"))+", OPEN_L: "+IntToString(GetLocalInt(oPC, "BASE_OPEN_L"))+", PARRY: "+IntToString(GetLocalInt(oPC, "BASE_PARRY"))+", PERFOR: "+IntToString(GetLocalInt(oPC, "BASE_PERFOR"))+".");
DeleteLocalInt(oPC, "BASE_PERSUA");
DeleteLocalInt(oPC, "BASE_PICK_P");
DeleteLocalInt(oPC, "BASE_SEARCH");
DeleteLocalInt(oPC, "BASE_SET_TR");
DeleteLocalInt(oPC, "BASE_SPELLC");
DeleteLocalInt(oPC, "BASE_SPOT");
DoDebug(oPC, "Base ability ints set as PERSUA: "+IntToString(GetLocalInt(oPC, "BASE_PERSUA"))+", PICK_P: "+IntToString(GetLocalInt(oPC, "BASE_PICK_P"))+", SEARCH: "+IntToString(GetLocalInt(oPC, "BASE_SEARCH"))+", SET_TR: "+IntToString(GetLocalInt(oPC, "BASE_SET_TR"))+", SPELLC: "+IntToString(GetLocalInt(oPC, "BASE_SPELLC"))+", SPOT: "+IntToString(GetLocalInt(oPC, "BASE_SPOT"))+".");
DeleteLocalInt(oPC, "BASE_TAUNT");
DeleteLocalInt(oPC, "BASE_USE_MA");
DeleteLocalInt(oPC, "BASE_APPRAI");
DeleteLocalInt(oPC, "BASE_TUMBLE");
DeleteLocalInt(oPC, "BASE_CRAFT_T");
DeleteLocalInt(oPC, "BASE_BLUFF");
DoDebug(oPC, "Base ability ints set as TAUNT: "+IntToString(GetLocalInt(oPC, "BASE_TAUNT"))+", USE_MA: "+IntToString(GetLocalInt(oPC, "BASE_USE_MA"))+", APPRAI: "+IntToString(GetLocalInt(oPC, "BASE_APPRAI"))+", TUMBLE: "+IntToString(GetLocalInt(oPC, "BASE_TUMBLE"))+", CRAFT_T: "+IntToString(GetLocalInt(oPC, "BASE_CRAFT_T"))+", BLUFF: "+IntToString(GetLocalInt(oPC, "BASE_BLUFF"))+".");
DeleteLocalInt(oPC, "BASE_INTIMI");
DeleteLocalInt(oPC, "BASE_CRAFT_A");
DeleteLocalInt(oPC, "BASE_CRAFT_W");
DoDebug(oPC, "Base ability ints set as INTIMI: "+IntToString(GetLocalInt(oPC, "BASE_INTIMI"))+", CRAFT_A: "+IntToString(GetLocalInt(oPC, "BASE_CRAFT_A"))+", CRAFT_W: "+IntToString(GetLocalInt(oPC, "BASE_CRAFT_W"))+".");
}
int GetSkillPointsGainedOnLevelUp(object oPC)
{
int nClass = GetControlClass(oPC);
int nInt = GetLocalInt(oPC, "BASE_INT");
int nClassBonus = 0;
int nRaceBonus = 0;
int nTotal;
if(GetRacialType(oPC)==RACIAL_TYPE_HUMAN)
{
nRaceBonus = 1;
}
switch(nClass)
{
case CLASS_TYPE_ROGUE:
nClassBonus = 8; break;
case CLASS_TYPE_SHADOWDANCER:
nClassBonus = 6; break;
case CLASS_TYPE_ARCANE_ARCHER:
case CLASS_TYPE_ASSASSIN:
case CLASS_TYPE_BARBARIAN:
case CLASS_TYPE_BARD:
case CLASS_TYPE_DRUID:
case CLASS_TYPE_HARPER:
case CLASS_TYPE_MONK:
case CLASS_TYPE_RANGER:
case CLASS_TYPE_SHIFTER:
nClassBonus = 4; break;
case CLASS_TYPE_BLACKGUARD:
case CLASS_TYPE_CLERIC:
case CLASS_TYPE_FIGHTER:
case CLASS_TYPE_DIVINECHAMPION:
case CLASS_TYPE_DRAGONDISCIPLE:
case CLASS_TYPE_DWARVENDEFENDER:
case CLASS_TYPE_PALADIN:
case CLASS_TYPE_PALEMASTER:
case CLASS_TYPE_SORCERER:
case CLASS_TYPE_WEAPON_MASTER:
case CLASS_TYPE_WIZARD:
nClassBonus = 2; break;
}
nTotal = nClassBonus+nRaceBonus+GetBaseAbilityModifier(nInt);
DoDebug(oPC, "Skill Points Gained: "+IntToString(nTotal)+".");
return nTotal;
}
int GetIsSkillAvailable(object oPC, int nSkill)
{
int nPointsAvailable = GetLocalInt(oPC, "PointsAvailable");
int nClass = GetControlClass(oPC);
int nLevel = CheckLegendaryLevel(oPC);
int nSkillMax;
int nSkillTotal;
switch (nSkill)
{
case 0: nSkillTotal = GetLocalInt(oPC, "BASE_ANIMAL"); break;
case 1: nSkillTotal = GetLocalInt(oPC, "BASE_CONCEN"); break;
case 2: nSkillTotal = GetLocalInt(oPC, "BASE_DISABL"); break;
case 3: nSkillTotal = GetLocalInt(oPC, "BASE_DISCIP"); break;
case 4: nSkillTotal = GetLocalInt(oPC, "BASE_HEAL"); break;
case 5: nSkillTotal = GetLocalInt(oPC, "BASE_HIDE"); break;
case 6: nSkillTotal = GetLocalInt(oPC, "BASE_LISTEN"); break;
case 7: nSkillTotal = GetLocalInt(oPC, "BASE_LORE"); break;
case 8: nSkillTotal = GetLocalInt(oPC, "BASE_MOVE_S"); break;
case 9: nSkillTotal = GetLocalInt(oPC, "BASE_OPEN_L"); break;
case 10: nSkillTotal = GetLocalInt(oPC, "BASE_PARRY"); break;
case 11: nSkillTotal = GetLocalInt(oPC, "BASE_PERFOR"); break;
case 12: nSkillTotal = GetLocalInt(oPC, "BASE_PERSUA"); break;
case 13: nSkillTotal = GetLocalInt(oPC, "BASE_PICK_P"); break;
case 14: nSkillTotal = GetLocalInt(oPC, "BASE_SEARCH"); break;
case 15: nSkillTotal = GetLocalInt(oPC, "BASE_SET_TR"); break;
case 16: nSkillTotal = GetLocalInt(oPC, "BASE_SPELLC"); break;
case 17: nSkillTotal = GetLocalInt(oPC, "BASE_SPOT"); break;
case 18: nSkillTotal = GetLocalInt(oPC, "BASE_TAUNT"); break;
case 19: nSkillTotal = GetLocalInt(oPC, "BASE_USE_MA"); break;
case 20: nSkillTotal = GetLocalInt(oPC, "BASE_APPRAI"); break;
case 21: nSkillTotal = GetLocalInt(oPC, "BASE_TUMBLE"); break;
case 22: nSkillTotal = GetLocalInt(oPC, "BASE_CRAFT_T"); break;
case 23: nSkillTotal = GetLocalInt(oPC, "BASE_BLUFF"); break;
case 24: nSkillTotal = GetLocalInt(oPC, "BASE_INTIMI"); break;
case 25: nSkillTotal = GetLocalInt(oPC, "BASE_CRAFT_A"); break;
case 26: nSkillTotal = GetLocalInt(oPC, "BASE_CRAFT_W"); break;
}
int nSkillCost = GetCostOfSkill(nClass, nSkill);//returns -1 if not available
if (nSkillCost == 2)//cross-class
{
nSkillMax = (nLevel+4)/2;//they can go up to half of (three points higher than their new level), CheckLegendaryLevel returns the CURRENT level
}
else
{
nSkillMax = nLevel+4;//they can go three points higher than their new level, CheckLegendaryLevel returns the CURRENT level
}
if((nSkillCost > 0) && (nPointsAvailable >= nSkillCost) && (nSkillTotal < nSkillMax)) return TRUE;
else return FALSE;
}
string GetNameOfSkill(int nSkill)
{
string sSkill;
switch (nSkill)
{
case 0: sSkill = "Animal Empathy"; break;
case 1: sSkill = "Concentration"; break;
case 2: sSkill = "Disable Trap"; break;
case 3: sSkill = "Discipline"; break;
case 4: sSkill = "Heal"; break;
case 5: sSkill = "Hide"; break;
case 6: sSkill = "Listen"; break;
case 7: sSkill = "Lore"; break;
case 8: sSkill = "Move Silently"; break;
case 9: sSkill = "Open Lock"; break;
case 10: sSkill = "Parry"; break;
case 11: sSkill = "Perform"; break;
case 12: sSkill = "Persuade"; break;
case 13: sSkill = "Pick Pocket"; break;
case 14: sSkill = "Search"; break;
case 15: sSkill = "Set Trap"; break;
case 16: sSkill = "Spellcraft"; break;
case 17: sSkill = "Spot"; break;
case 18: sSkill = "Taunt"; break;
case 19: sSkill = "Use Magic Device"; break;
case 20: sSkill = "Appraise"; break;
case 21: sSkill = "Tumble"; break;
case 22: sSkill = "Craft Trap"; break;
case 23: sSkill = "Bluff"; break;
case 24: sSkill = "Intimidate"; break;
case 25: sSkill = "Craft Armor"; break;
case 26: sSkill = "Craft Weapon"; break;
default: sSkill = ""; break;
}
return sSkill;
}
string GetNameOfTrackingInt(int nSkill)
{
string sSkill;
switch (nSkill)
{
case 0: sSkill = "BASE_ANIMAL"; break;
case 1: sSkill = "BASE_CONCEN"; break;
case 2: sSkill = "BASE_DISABL"; break;
case 3: sSkill = "BASE_DISCIP"; break;
case 4: sSkill = "BASE_HEAL"; break;
case 5: sSkill = "BASE_HIDE"; break;
case 6: sSkill = "BASE_LISTEN"; break;
case 7: sSkill = "BASE_LORE"; break;
case 8: sSkill = "BASE_MOVE_S"; break;
case 9: sSkill = "BASE_OPEN_L"; break;
case 10: sSkill = "BASE_PARRY"; break;
case 11: sSkill = "BASE_PERFOR"; break;
case 12: sSkill = "BASE_PERSUA"; break;
case 13: sSkill = "BASE_PICK_P"; break;
case 14: sSkill = "BASE_SEARCH"; break;
case 15: sSkill = "BASE_SET_TR"; break;
case 16: sSkill = "BASE_SPELLC"; break;
case 17: sSkill = "BASE_SPOT"; break;
case 18: sSkill = "BASE_TAUNT"; break;
case 19: sSkill = "BASE_USE_MA"; break;
case 20: sSkill = "BASE_APPRAI"; break;
case 21: sSkill = "BASE_TUMBLE"; break;
case 22: sSkill = "BASE_CRAFT_T"; break;
case 23: sSkill = "BASE_BLUFF"; break;
case 24: sSkill = "BASE_INTIMI"; break;
case 25: sSkill = "BASE_CRAFT_A"; break;
case 26: sSkill = "BASE_CRAFT_W"; break;
default: sSkill = ""; break;
}
return sSkill;
}
int GetHitPointsGainedOnLevelUp(object oPC)
{
int nClass = GetControlClass(oPC);
int nCon = GetLocalInt(oPC, "BASE_CON");
int nClassDie;
int nFeatBonus = 0;
int nTotal;
if(GetHasFeat(FEAT_TOUGHNESS, oPC))
{
nFeatBonus = 1;
}
switch(nClass)
{
case CLASS_TYPE_DWARVENDEFENDER:
case CLASS_TYPE_BARBARIAN:
nClassDie = 12; break;
case CLASS_TYPE_DIVINECHAMPION:
case CLASS_TYPE_WEAPON_MASTER:
case CLASS_TYPE_PALADIN:
case CLASS_TYPE_RANGER:
case CLASS_TYPE_BLACKGUARD:
case CLASS_TYPE_FIGHTER:
case CLASS_TYPE_DRAGONDISCIPLE:
nClassDie = 10; break;
case CLASS_TYPE_SHADOWDANCER:
case CLASS_TYPE_DRUID:
case CLASS_TYPE_ARCANE_ARCHER:
case CLASS_TYPE_MONK:
case CLASS_TYPE_SHIFTER:
case CLASS_TYPE_CLERIC:
nClassDie = 8; break;
case CLASS_TYPE_ROGUE:
case CLASS_TYPE_ASSASSIN:
case CLASS_TYPE_BARD:
case CLASS_TYPE_HARPER:
case CLASS_TYPE_PALEMASTER:
nClassDie = 6; break;
case CLASS_TYPE_SORCERER:
case CLASS_TYPE_WIZARD:
nClassDie = 4; break;
}
nTotal = nClassDie+nFeatBonus+GetBaseAbilityModifier(nCon)+10;
DoDebug(oPC, "HP Gained: "+IntToString(nTotal)+".");
return nTotal;
}
void ReplenishLimitedUseFeats(object oPC)
{
int nFeat = 0;
for(nFeat = 0; nFeat < 1072; nFeat++)
{
if (GetIsFeatLimitedUses(nFeat))
{
IncrementRemainingFeatUses(oPC, nFeat);
}
}
}
int GetIsFeatAvailable(int nFeat, object oPC)
{
int nClass = GetControlClass(oPC);
if (DEV_CRIT_DISABLED && GetIsFeatDevCrit(nFeat)) return FALSE;
if (GetIsFeatFirstLevelOnly(nFeat)) return FALSE;
if (GetHasFeat(nFeat, oPC) && nFeat != 13) return FALSE;//only Extra Turning (13) may be taken multiple times
if (!GetIsClassFeat(nFeat, nClass, oPC) && !GetIsGeneralFeat(nFeat)) return FALSE;//if it's not a class skill and it's not a general skill return FALSE
if (GetAreFeatStatReqsMet(nFeat, oPC) &&
GetAreFeatSkillReqsMet(nFeat, oPC) &&
GetAreFeatFeatReqsMet(nFeat, oPC) &&
GetHasRequiredSpellLevelForFeat(oPC, nFeat)) return TRUE;
return FALSE;
}
string GetNameOfAbility(int nStat)
{
string sReturn;
switch (nStat)
{
case ABILITY_STRENGTH: sReturn = "Strength"; break;
case ABILITY_DEXTERITY: sReturn = "Dexterity"; break;
case ABILITY_CONSTITUTION: sReturn = "Constitution"; break;
case ABILITY_INTELLIGENCE: sReturn = "Intelligence"; break;
case ABILITY_WISDOM: sReturn = "Wisdom"; break;
case ABILITY_CHARISMA: sReturn = "Charisma"; break;
}
return sReturn;
}
int GetIsClassFeat(int nFeat, int nClass, object oPC)
{
int nLevel = GetClassLevelReqForFeat(nFeat, nClass);
if (nLevel < -1) return FALSE;
if (GetLevelByClass(nClass, oPC) < nLevel) return FALSE;
return TRUE;
}
//below used to compile
/*
void main()
{
}
*/