Jaysyn/PRC8
Jaysyn/PRC8
1
1
Fork 1
Code Issues 25 Pull Requests Packages Projects Releases Wiki Activity
PRC8/nwn/nwnprc/trunk/scripts/prc_prereq.nss
Jaysyn904 1b043074dc Dodge update 
Added Grey Elf as possible RACE prereq for Arcane Archer, Baelnorn, Bladesinger, Champion of Corellon, Eternal Blade & Nightshade.

Added Expeditious Dodge, Midnight Dodge & Desert Wind Dodge as FEATOR prereqs for Mobility, Spring Attack, Sidestep Charge & Quick Staff.

Added Expeditious Dodge, Midnight Dodge & Desert Wind Dodge as FEATOR prereqs for Combat Medic, Duelist, Dwarven Defender, Drunken Master, Master of Nine, Ninja Spy, Sacred Fist, Shou Disciple, Telflammar Shadowlord, Shadowdancer and Spelldancer.

Fixed PnP Shifter prereqs for Shaman class.

Fixed Invisible Needle reserve feat to work per PnP.

Fixed Song of Fury & other Bladesinger abilities to work with one-handed elven blades.

Updated release archive.
2024-09-21 09:47:07 -04:00

1792 lines
62 KiB
Plaintext
Raw Blame History

//::///////////////////////////////////////////////
//:: PRC Prerequisites
//:: prc_prereq.nss
//:://////////////////////////////////////////////
//:: Check to see what classes a PC is capable of taking.
//:://////////////////////////////////////////////
//:: Created By: Stratovarius.
//:: Created On: July 3rd, 2004
//:://////////////////////////////////////////////
//:: Updated for NWN .35 by Jaysyn 2024/02/04
#include "inc_epicspells"
#include "prc_inc_sneak"
#include "psi_inc_psifunc"
#include "tob_inc_tobfunc"
#include "shd_inc_shdfunc"
#include "inc_newspellbook"
#include "prc_allow_const"
#include "inv_inc_invfunc"
#include "prc_inc_template"
#include "moi_inc_moifunc"
#include "bnd_inc_bndfunc"
/*
AlignRestrict flags in classes.2da:
0x01 - no neutral
0x02 - no lawful
0x04 - no chaotic
0x08 - no good
0x10 - no evil
AlignRstrctType:
0x01 - law/chaos
0x02 - good/evil
*/
// Some alignment restrictions can't be setup properly in classes.2da
// ie. for Soldier of Light the closest thing to NG requirement is 0x16 0x3
// which will allow only NG and TN alignments.
// To disable True Neutral Soldiers of Light a Script Var 'PRC_ExAlignTN'
// was added to cls_pres_sol.2da.
void reqAlignment(object oPC)
{
string sAling = "PRC_ExAlign";
DeleteLocalInt(oPC, sAling+"LG");
DeleteLocalInt(oPC, sAling+"LN");
DeleteLocalInt(oPC, sAling+"LE");
DeleteLocalInt(oPC, sAling+"NG");
DeleteLocalInt(oPC, sAling+"TN");
DeleteLocalInt(oPC, sAling+"NE");
DeleteLocalInt(oPC, sAling+"CG");
DeleteLocalInt(oPC, sAling+"CN");
DeleteLocalInt(oPC, sAling+"CE");
int nGoodEvil = GetAlignmentGoodEvil(oPC);
int nLawChaos = GetAlignmentLawChaos(oPC);
if(nGoodEvil == ALIGNMENT_GOOD)
{
if(nLawChaos == ALIGNMENT_LAWFUL)
SetLocalInt(oPC, sAling+"LG", 1);
else if(nLawChaos == ALIGNMENT_NEUTRAL)
SetLocalInt(oPC, sAling+"NG", 1);
else// if(nLawChaos == ALIGNMENT_CHAOTIC)
SetLocalInt(oPC, sAling+"CG", 1);
}
else if(nGoodEvil == ALIGNMENT_NEUTRAL)
{
if(nLawChaos == ALIGNMENT_LAWFUL)
SetLocalInt(oPC, sAling+"LN", 1);
else if(nLawChaos == ALIGNMENT_NEUTRAL)
SetLocalInt(oPC, sAling+"TN", 1);
else// if(nLawChaos == ALIGNMENT_CHAOTIC)
SetLocalInt(oPC, sAling+"CN", 1);
}
else// if(nGoodEvil == ALIGNMENT_EVIL)
{
if(nLawChaos == ALIGNMENT_LAWFUL)
SetLocalInt(oPC, sAling+"LE", 1);
else if(nLawChaos == ALIGNMENT_NEUTRAL)
SetLocalInt(oPC, sAling+"NE", 1);
else// if(nLawChaos == ALIGNMENT_CHAOTIC)
SetLocalInt(oPC, sAling+"CE", 1);
}
}
//for requirements that Skirmish or Sneak Attack apply to
void reqSpecialAttack(object oPC)
{
int iSneak = GetTotalSneakAttackDice(oPC);
int nLevel = GetLevelByClass(CLASS_TYPE_SCOUT, oPC);
int iCount;
string sVariable1, sVariable2;
//Skirmish
int nDice = (nLevel + 3) / 4;
for (iCount = 1; iCount <= 30; iCount++)
{
sVariable1 = "PRC_SkirmishLevel" + IntToString(iCount);
sVariable2 = "PRC_SplAtkLevel" + IntToString(iCount);
if (nDice >= iCount)
{
SetLocalInt(oPC, sVariable1, 0);
SetLocalInt(oPC, sVariable2, 0);
}
}
//Sneak Attack
for (iCount = 1; iCount <= 30; iCount++)
{
sVariable1 = "PRC_SneakLevel" + IntToString(iCount);
sVariable2 = "PRC_SplAtkLevel" + IntToString(iCount);
if (iSneak >= iCount)
{
SetLocalInt(oPC, sVariable1, 0);
SetLocalInt(oPC, sVariable2, 0);
}
}
}
void reqGender()
{
int nGender = GetGender(OBJECT_SELF);
SetLocalInt(OBJECT_SELF, "PRC_Female", 1);
SetLocalInt(OBJECT_SELF, "PRC_Male", 1);
if (nGender == GENDER_FEMALE)
DeleteLocalInt(OBJECT_SELF, "PRC_Female");
else if (nGender == GENDER_MALE)
DeleteLocalInt(OBJECT_SELF, "PRC_Male");
}
void Kord(object oPC)
{
SetLocalInt(oPC, "PRC_PrereqKord", 1);
if (GetFortitudeSavingThrow(oPC) >= 6)
{
SetLocalInt(oPC, "PRC_PrereqKord", 0);
}
}
void Purifier(object oPC)
{
SetLocalInt(oPC, "PRC_PrereqPurifier", 1);
if (GetWillSavingThrow(oPC) >= 5)
{
SetLocalInt(oPC, "PRC_PrereqPurifier", 0);
}
}
void Dragonheart(object oPC)
{
SetLocalInt(oPC, "PRC_PrereqDragonheart", 1);
int nClassSlot = 1;
while(nClassSlot <= 8)
{
int nClass = GetClassByPosition(nClassSlot, oPC);
nClassSlot += 1;
if(GetIsArcaneClass(nClass) && GetSpellbookTypeForClass(nClass) == SPELLBOOK_TYPE_SPONTANEOUS)
SetLocalInt(oPC, "PRC_PrereqDragonheart", 0);
}
}
void Cultist(object oPC)
{
SetLocalInt(oPC, "PRC_PrereqCultist", 1);
// Can't be arcane
int i;
for (i = 1; i <= 8; i++)
{
if (!GetIsArcaneClass(GetClassByPosition(i, oPC)))
{
SetLocalInt(oPC, "PRC_PrereqCultist", 0);
break;
}
}
}
/* void Cultist(object oPC)
{
SetLocalInt(oPC, "PRC_PrereqCultist", 1);
// Can't be arcane
if(!GetIsArcaneClass(GetClassByPosition(1, oPC)) && (!GetIsArcaneClass(GetClassByPosition(2, oPC)) || GetClassByPosition(2, oPC) == CLASS_TYPE_CULTIST_SHATTERED_PEAK))
SetLocalInt(oPC, "PRC_PrereqCultist", 0);
} */
void Shifter(object oPC, int iArcSpell, int iDivSpell)
{
//This function checks if the Pnp Shifter requirement "You must be able to assume an alternate form" is met.
SetLocalInt(oPC, "PRC_PrereqShift", 1);
//This used to check for Cleric class, animal domain, and divine spell level 5.
//I've eliminated the Cleric class check--any class with the animal domain should qualify--
//and changed it to check for divine spell level 9 instead of 5, since it isn't until level 9
//that the PRC Animal domain gains the Shapechange spell, which is what qualifies it for PnP Shifter.
//(The Bioware implementation of the Animal domain gives Polymorph Self at spell level 5).
if (GetHasFeat(FEAT_ANIMAL_DOMAIN_POWER) && iDivSpell >= 9)
{
SetLocalInt(oPC, "PRC_PrereqShift", 0);
}
//Sorcerer (if it uses the old spellbook) and Wizard (which always does) need special checks
if ((GetLevelByClass(CLASS_TYPE_SORCERER) && !UseNewSpellBook(oPC)) || GetLevelByClass(CLASS_TYPE_WIZARD))
{
if(GetHasSpell(SPELL_POLYMORPH_SELF, oPC))
{
// done this way as it's the only way to see if a bioware spellcaster knows the spell
// actually checks if they have at least one use left
SetLocalInt(oPC, "PRC_PrereqShift", 0);
return;
}
}
//Ranger also needs special check since it also uses the old spellbook. It gains Polymorph Self at spell level 4.
if (GetLevelByClass(CLASS_TYPE_RANGER) && iDivSpell >= 4)
{
SetLocalInt(oPC, "PRC_PrereqShift", 0);
}
//Any class that has Polymorph Self spell qualifies
if (PRCGetIsRealSpellKnown(SPELL_POLYMORPH_SELF, oPC))
{
SetLocalInt(oPC, "PRC_PrereqShift", 0);
}
//Warlock doesn't normally qualify for PnP Shifter since it doesn't cast spells,
//but these invocations from Warlock meets the alternate form qualification
//if another class provides the level 3 spells
if(GetHasInvocation(INVOKE_MASK_OF_FLESH, oPC)
|| GetHasInvocation(INVOKE_HUMANOID_SHAPE, oPC)
|| GetHasInvocation(INVOKE_SPIDER_SHAPE, oPC)
|| GetHasInvocation(INVOKE_HELLSPAWNED_GRACE, oPC))
{
SetLocalInt(oPC, "PRC_PrereqShift", 0);
}
//These classes have appropriate alternate forms
if (GetLevelByClass(CLASS_TYPE_DRUID) >= 5)
{
//Wild Shape qualifies
SetLocalInt(oPC, "PRC_PrereqShift", 0);
}
//These classes have appropriate alternate forms
if (GetLevelByClass(CLASS_TYPE_SHAMAN) >= 7)
{
//Wild Shape qualifies
SetLocalInt(oPC, "PRC_PrereqShift", 0);
}
if (GetLevelByClass(CLASS_TYPE_INITIATE_DRACONIC) >= 10)
{
//Dragon Shape qualifies
SetLocalInt(oPC, "PRC_PrereqShift", 0);
}
if (GetLevelByClass(CLASS_TYPE_NINJA_SPY) >= 7)
{
//Thousand Faces qualifies
SetLocalInt(oPC, "PRC_PrereqShift", 0);
}
if (GetLevelByClass(CLASS_TYPE_WEREWOLF) >= 1)
{
//Alternate Form, Wolf qualifies
SetLocalInt(oPC, "PRC_PrereqShift", 0);
}
if (GetLevelByClass(CLASS_TYPE_BONDED_SUMMONNER) >= 10)
{
//Elemental Form qualifies
SetLocalInt(oPC, "PRC_PrereqShift", 0);
}
//This is not strictly necessary because Witch gains Polymorph Self
//at an earlier level, but add it here anyway for completeness:
if (GetLevelByClass(CLASS_TYPE_WITCH) >= 13)
{
SetLocalInt(oPC, "PRC_PrereqShift", 0);
}
int nRace = GetRacialType(oPC);
//These races have appropriate alternate forms
if(nRace == RACIAL_TYPE_PURE_YUAN
|| nRace == RACIAL_TYPE_ABOM_YUAN
|| nRace == RACIAL_TYPE_PIXIE
|| nRace == RACIAL_TYPE_RAKSHASA
|| nRace == RACIAL_TYPE_FEYRI
|| nRace == RACIAL_TYPE_HOUND_ARCHON
|| nRace == RACIAL_TYPE_IRDA
|| nRace == RACIAL_TYPE_ZAKYA_RAKSHASA
|| nRace == RACIAL_TYPE_CHANGELING
|| nRace == RACIAL_TYPE_DOPPELGANGER
|| nRace == RACIAL_TYPE_ARANEA
|| nRace == RACIAL_TYPE_SHIFTER
// not counted since it is just "disguise self" and not alter self or shape change
//||nRace == RACIAL_TYPE_DEEP_GNOME
|| nRace == RACIAL_TYPE_NAZTHARUNE_RAKSHASA)
{
SetLocalInt(oPC, "PRC_PrereqShift", 0);
}
}
void Tempest()
{
SetLocalInt(OBJECT_SELF, "PRC_PrereqTemp", 1);
if(((GetHasFeat(FEAT_AMBIDEXTERITY) || GetPRCSwitch(PRC_35_TWO_WEAPON_FIGHTING)) && GetHasFeat(FEAT_TWO_WEAPON_FIGHTING))
|| GetHasFeat(FEAT_RANGER_DUAL))
DeleteLocalInt(OBJECT_SELF, "PRC_PrereqTemp");
}
void KOTC(object oPC)
{
SetLocalInt(oPC, "PRC_PrereqKOTC", 1);
// to check if PC can cast protection from evil
if(GetLevelByClass(CLASS_TYPE_CLERIC))
DeleteLocalInt(oPC, "PRC_PrereqKOTC");
if(GetLevelByClass(CLASS_TYPE_PALADIN) > 3)
{
if(GetAbilityScore(oPC, ABILITY_WISDOM) > 11
|| GetLevelByClass(CLASS_TYPE_PALADIN) > 5)
{
DeleteLocalInt(oPC, "PRC_PrereqKOTC");
return;
}
}
if(PRCGetIsRealSpellKnown(SPELL_PROTECTION_FROM_EVIL, oPC))
{
DeleteLocalInt(oPC, "PRC_PrereqKOTC");
}
}
void Shadowlord(object oPC, int iArcSpell)
{
SetLocalInt(oPC, "PRC_PrereqTelflam", 1);
if(iArcSpell > 3 //ability to cast Level 4 Arcane Spells
|| GetLevelByClass(CLASS_TYPE_SHADOWDANCER, oPC) //at least 1 lvl of shadowdancer
|| GetPersistantLocalInt(oPC, "shadowwalkerstok")) //a token proving a donation of 10,000 gold to the Telflamm Guild
//|| GetHasItem(oPC, "shadowwalkerstok"))
{
SetLocalInt(oPC, "PRC_PrereqTelflam", 0);
}
}
//:: Taken out of master at arms because I wanted to use the code in Eternal Blade prereq too.
int WeaponFocusCount(object oPC)
{
int iWF;
// Calculate the total number of Weapon Focus feats the character has
iWF = GetHasFeat(FEAT_WEAPON_FOCUS_BASTARD_SWORD, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_BATTLE_AXE, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_CLUB, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_DART, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_DIRE_MACE, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_DOUBLE_AXE, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_DOUBLE_SCIMITAR, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_DWAXE, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_EAGLE_CLAW, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_ELVEN_COURTBLADE, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_ELVEN_LIGHTBLADE, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_ELVEN_THINBLADE, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_FALCHION, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_GOAD, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_GREAT_AXE, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_HALBERD, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_HAND_AXE, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_HEAVY_CROSSBOW, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_HEAVY_FLAIL, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_HEAVY_MACE, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_HEAVY_PICK, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_KATANA, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_KATAR, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_KUKRI, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_LIGHT_CROSSBOW, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_LIGHT_FLAIL, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_LIGHT_HAMMER, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_LIGHT_LANCE, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_LIGHT_MACE, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_LIGHT_PICK, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_LONGBOW, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_LONG_SWORD, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_MAUL, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_MINDBLADE, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_MORNING_STAR, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_NUNCHAKU, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_RAPIER, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_RAY, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_SAI, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_SAP, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_SCIMITAR, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_SCYTHE, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_SHORTBOW, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_SHORT_SWORD, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_SICKLE, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_SLING, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_STAFF, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_THROWING_AXE, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_TWO_BLADED_SWORD, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_WHIP, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_DAGGER, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_GREAT_SWORD, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_SHURIKEN, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_SPEAR, oPC)
+ GetHasFeat(FEAT_WEAPON_FOCUS_WAR_HAMMER, oPC);
// If they are a soulknife, their WF Mindblade might be counting twice due to how it is implemented, so account for it if necessary
if(GetStringLeft(GetTag(GetItemInSlot(INVENTORY_SLOT_RIGHTHAND, oPC)), 14) == "prc_sk_mblade_" ||
GetStringLeft(GetTag(GetItemInSlot(INVENTORY_SLOT_LEFTHAND, oPC)), 14) == "prc_sk_mblade_")
iWF--;
return iWF;
}
void DemiLich(object oPC)
{
DeleteLocalInt(oPC, "PRC_DemiLich");
if (!GetIsEpicSpellcaster(oPC) && GetLevelByClass(CLASS_TYPE_LICH) > 3)
SetLocalInt(oPC, "PRC_DemiLich", 1); // Need to be an epic caster to take demilich
if(GetPRCSwitch(PRC_DISABLE_DEMILICH) && GetLevelByClass(CLASS_TYPE_LICH) > 3)
{
SetLocalInt(oPC, "PRC_DemiLich", 1); // This is here because it'll always turn things off
}
}
void reqDomains()
{
//Black Flame Zealot
SetLocalInt(OBJECT_SELF, "PRC_PrereqBFZ", 1);
if(GetHasFeat(FEAT_FIRE_DOMAIN_POWER)
+ GetHasFeat(FEAT_DESTRUCTION_DOMAIN_POWER)
+ GetHasFeat(FEAT_DOMAIN_POWER_RENEWAL) >= 2)
DeleteLocalInt(OBJECT_SELF, "PRC_PrereqBFZ");
//Brimstone Speaker
SetLocalInt(OBJECT_SELF, "PRC_PrereqBrimstone", 1);
if(GetHasFeat(FEAT_FIRE_DOMAIN_POWER)
|| GetHasFeat(FEAT_GOOD_DOMAIN_POWER))
DeleteLocalInt(OBJECT_SELF, "PRC_PrereqBrimstone");
//Shining Blade of Heironeous
SetLocalInt(OBJECT_SELF, "PRC_PrereqSBHeir", 1);
if (GetHasFeat(FEAT_WAR_DOMAIN_POWER)
&& GetHasFeat(FEAT_GOOD_DOMAIN_POWER))
DeleteLocalInt(OBJECT_SELF, "PRC_PrereqSBHeir");
//Eye of Gruumsh
SetLocalInt(OBJECT_SELF, "PRC_PrereqEOG", 1);
if(GetHasFeat(FEAT_WAR_DOMAIN_POWER)
+ GetHasFeat(FEAT_STRENGTH_DOMAIN_POWER)
+ GetHasFeat(FEAT_EVIL_DOMAIN_POWER) >= 2)
DeleteLocalInt(OBJECT_SELF, "PRC_PrereqEOG");
//Stormlord
SetLocalInt(OBJECT_SELF, "PRC_PrereqStormL", 1);
if(GetHasFeat(FEAT_FIRE_DOMAIN_POWER)
+ GetHasFeat(FEAT_DESTRUCTION_DOMAIN_POWER)
+ GetHasFeat(FEAT_EVIL_DOMAIN_POWER)
+ GetHasFeat(FEAT_DOMAIN_POWER_STORM) >= 2)
DeleteLocalInt(OBJECT_SELF, "PRC_PrereqStormL");
//Battleguard of Tempus
SetLocalInt(OBJECT_SELF, "PRC_PrereqTempus", 1);
if(GetHasFeat(FEAT_PROTECTION_DOMAIN_POWER)
+ GetHasFeat(FEAT_STRENGTH_DOMAIN_POWER) >= 1
&& GetHasFeat(FEAT_WAR_DOMAIN_POWER))
DeleteLocalInt(OBJECT_SELF, "PRC_PrereqTempus");
//Heartwarder
SetLocalInt(OBJECT_SELF, "PRC_PrereqHeartW", 1);
if(GetHasFeat(FEAT_GOOD_DOMAIN_POWER)
+ GetHasFeat(FEAT_PROTECTION_DOMAIN_POWER)
+ GetHasFeat(FEAT_DOMAIN_POWER_CHARM) >= 2)
DeleteLocalInt(OBJECT_SELF, "PRC_PrereqHeartW");
//Talontar Blightlord
SetLocalInt(OBJECT_SELF, "PRC_PrereqBlightL", 1);
if(GetHasFeat(FEAT_DESTRUCTION_DOMAIN_POWER)
&& GetHasFeat(FEAT_EVIL_DOMAIN_POWER))
DeleteLocalInt(OBJECT_SELF, "PRC_PrereqBlightL");
//Shadow Adept
SetLocalInt(OBJECT_SELF, "PRC_PrereqShadAd", 1);
if(GetHasFeat(FEAT_EVIL_DOMAIN_POWER)
+ GetHasFeat(FEAT_KNOWLEDGE_DOMAIN_POWER)
+ GetHasFeat(FEAT_DARKNESS_DOMAIN) >= 2)
DeleteLocalInt(OBJECT_SELF, "PRC_PrereqShadAd");
//Thrall of Graz'zt
SetLocalInt(OBJECT_SELF, "PRC_PrereqTOG", 1);
if(GetHasFeat(FEAT_EVIL_DOMAIN_POWER)
&& GetHasFeat(FEAT_DARKNESS_DOMAIN))
DeleteLocalInt(OBJECT_SELF, "PRC_PrereqTOG");
//Champion of Corellon
SetLocalInt(OBJECT_SELF, "PRC_PrereqCoC", 1);
if(GetHasFeat(FEAT_DOMAIN_POWER_ELF)
//+ GetHasFeat(FEAT_DOMAIN_POWER_CHAOS) //chaos domain not yet implemented
+ GetHasFeat(FEAT_GOOD_DOMAIN_POWER)
+ GetHasFeat(FEAT_MAGIC_DOMAIN_POWER)
+ GetHasFeat(FEAT_PROTECTION_DOMAIN_POWER)
+ GetHasFeat(FEAT_WAR_DOMAIN_POWER) >= 2)
DeleteLocalInt(OBJECT_SELF, "PRC_PrereqCoC");
//Morninglord of Lathander
SetLocalInt(OBJECT_SELF, "PRC_PrereqMornLord", 1);
if(GetHasFeat(FEAT_GOOD_DOMAIN_POWER)
+ GetHasFeat(FEAT_PROTECTION_DOMAIN_POWER)
+ GetHasFeat(FEAT_STRENGTH_DOMAIN_POWER)
+ GetHasFeat(FEAT_SUN_DOMAIN_POWER)
+ GetHasFeat(FEAT_DOMAIN_POWER_NOBILITY)
+ GetHasFeat(FEAT_DOMAIN_POWER_RENEWAL) >= 2)
DeleteLocalInt(OBJECT_SELF, "PRC_PrereqMornLord");
//Favored of Milil
SetLocalInt(OBJECT_SELF, "PRC_PrereqFoM", 1);
if(GetHasFeat(FEAT_GOOD_DOMAIN_POWER)
+ GetHasFeat(FEAT_DOMAIN_POWER_NOBILITY)
+ GetHasFeat(FEAT_DOMAIN_POWER_CHARM)
+ GetHasFeat(FEAT_KNOWLEDGE_DOMAIN_POWER) >= 2)
DeleteLocalInt(OBJECT_SELF, "PRC_PrereqFoM");
//Soldier of Light
SetLocalInt(OBJECT_SELF, "PRC_PrereqSOL", 1);
if(GetHasFeat(FEAT_GOOD_DOMAIN_POWER)
+ GetHasFeat(FEAT_HEALING_DOMAIN_POWER)
+ GetHasFeat(FEAT_LUCK_DOMAIN_POWER)
+ GetHasFeat(FEAT_PROTECTION_DOMAIN_POWER)
+ GetHasFeat(FEAT_SUN_DOMAIN_POWER)
+ GetHasFeat(FEAT_KNOWLEDGE_DOMAIN_POWER) >= 2)
DeleteLocalInt(OBJECT_SELF, "PRC_PrereqSOL");
}
void WWolf(object oPC)
{
//If not a natural lycanthrope or not already leveled in werewolf, prevent the player from taking the werewolf class
if (!GetHasFeat(FEAT_TRUE_LYCANTHROPE, oPC) || GetLevelByClass(CLASS_TYPE_WEREWOLF, oPC) < 1)
{
SetLocalInt(oPC, "PRC_PrereqWWolf", 1);
}
if (GetHasFeat(FEAT_TRUE_LYCANTHROPE, oPC))
{
SetLocalInt(oPC, "PRC_PrereqWWolf", 0);
}
}
void Maester(object oPC)
{
SetLocalInt(oPC, "PRC_PrereqMaester", 1);
// Base Ranks Only
if(GetSkillRank(SKILL_CRAFT_ARMOR, oPC, TRUE) > 7
|| GetSkillRank(SKILL_CRAFT_TRAP, oPC, TRUE) > 7
|| GetSkillRank(SKILL_CRAFT_ALCHEMY, oPC, TRUE) > 7
|| GetSkillRank(SKILL_CRAFT_POISON, oPC, TRUE) > 7
|| GetSkillRank(SKILL_CRAFT_GENERAL, oPC, TRUE) > 7
|| GetSkillRank(SKILL_CRAFT_WEAPON, oPC, TRUE) > 7)
{
// At least two crafting feats
if(GetItemCreationFeatCount() > 1)
{
//check for arcane caster levels
if(!GetLocalInt(oPC, "PRC_ArcSpell5") || GetInvokerLevel(oPC) > 4)
SetLocalInt(oPC, "PRC_PrereqMaester", 0);
}
}
}
void reqCombatMedic(object oPC)
{
/* The combat medic can only be taken if the player is able to cast Cure Light Wounds.
* Base classes:
* With druids and clerics, that's no problem - they get it at first level. Paladins and
* rangers are a bit more complicated, due to their bonus spells and later spell gains.
HEALER
KNIGHT_CHALICE
KNIGHT_MIDDLECIRCLE
NENTYAR_HUNTER
OASHAMAN
SOL
*/
//:: Get casting ability scores
int iCha = GetLocalInt(GetPCSkin(oPC), "PRC_trueCHA");
int iInt = GetLocalInt(GetPCSkin(oPC), "PRC_trueINT");
int iWis = GetLocalInt(GetPCSkin(oPC), "PRC_trueWIS");
//:: Check PRC NewSpellBook divine classes (Archivist,
//:: Favoured Soul, JoWaW, Spirit Shaman)
int nMedicCha = GetLevelByClass(CLASS_TYPE_FAVOURED_SOUL)
+ GetLevelByClass(CLASS_TYPE_SPIRIT_SHAMAN);
int nMedicInt = GetLevelByClass(CLASS_TYPE_ARCHIVIST);
int nMedicWis = GetLevelByClass(CLASS_TYPE_JUSTICEWW);
int bKnowsCLW = PRCGetIsRealSpellKnown(SPELL_CURE_LIGHT_WOUNDS, oPC);
if(iInt >= 11 && nMedicInt >= 1 && bKnowsCLW)
{
SetLocalInt(oPC, "PRC_PrereqCbtMed", 0);
return;
}
if(iWis >= 11 && nMedicWis >= 1 && bKnowsCLW)
{
SetLocalInt(oPC, "PRC_PrereqCbtMed", 0);
return;
}
if(iCha >= 11 && nMedicCha >= 1 && bKnowsCLW)
{
SetLocalInt(oPC, "PRC_PrereqCbtMed", 0);
return;
}
//:: Check Paladin, Cleric, Druid, Ranger, Healer, KotC,
//:: KotMC, Nentyar Hunter, Shaman & SoL
if(iWis > 10)
{
if(GetLevelByClass(CLASS_TYPE_CLERIC)
|| GetLevelByClass(CLASS_TYPE_DRUID)
|| GetLevelByClass(CLASS_TYPE_HEALER)
|| GetLevelByClass(CLASS_TYPE_KNIGHT_CHALICE)
|| GetLevelByClass(CLASS_TYPE_KNIGHT_MIDDLECIRCLE)
|| GetLevelByClass(CLASS_TYPE_NENTYAR_HUNTER)
|| GetLevelByClass(CLASS_TYPE_SOLDIER_OF_LIGHT)
|| GetLevelByClass(CLASS_TYPE_SHAMAN)
|| GetLevelByClass(CLASS_TYPE_PALADIN) >= 6
|| GetLevelByClass(CLASS_TYPE_RANGER) >= 10
|| (iWis > 11 && GetLevelByClass(CLASS_TYPE_PALADIN) >= 4)
|| (iWis > 14 && GetLevelByClass(CLASS_TYPE_RANGER) >= 8))
SetLocalInt(oPC, "PRC_PrereqCbtMed", 0);
}
}
void RedWizard(object oPC)
{
SetLocalInt(oPC, "PRC_PrereqRedWiz", 1);
int iFeat;
int iFocus;
iFocus = GetHasFeat(FEAT_RW_TF_ABJ, oPC)
+ GetHasFeat(FEAT_RW_TF_CON, oPC)
+ GetHasFeat(FEAT_RW_TF_DIV, oPC)
+ GetHasFeat(FEAT_RW_TF_ENC, oPC)
+ GetHasFeat(FEAT_RW_TF_EVO, oPC)
+ GetHasFeat(FEAT_RW_TF_ILL, oPC)
+ GetHasFeat(FEAT_RW_TF_NEC, oPC)
+ GetHasFeat(FEAT_RW_TF_TRS, oPC);
// Metamagic or Item Creation feats
iFeat = GetItemCreationFeatCount()
+ GetHasFeat(FEAT_EMPOWER_SPELL, oPC)
+ GetHasFeat(FEAT_EXTEND_SPELL, oPC)
+ GetHasFeat(FEAT_MAXIMIZE_SPELL, oPC)
+ GetHasFeat(FEAT_QUICKEN_SPELL, oPC)
+ GetHasFeat(FEAT_SILENCE_SPELL, oPC)
+ GetHasFeat(FEAT_STILL_SPELL, oPC)
+ GetHasFeat(FEAT_SUDDEN_EMPOWER, oPC)
+ GetHasFeat(FEAT_SUDDEN_MAXIMIZE, oPC)
+ GetHasFeat(FEAT_SUDDEN_EXTEND, oPC)
+ GetHasFeat(FEAT_SUDDEN_WIDEN, oPC);
// At least two arcane feats, one tattoo focus
if (iFeat > 2 && iFocus == 1)
{
SetLocalInt(oPC, "PRC_PrereqRedWiz", 0);
}
}
void WildMageReq(object oPC)
{
SetLocalInt(oPC, "PRC_PresWildMageReq", 1);
int iFeat = GetHasFeat(FEAT_EMPOWER_SPELL, oPC)
+ GetHasFeat(FEAT_EXTEND_SPELL, oPC)
+ GetHasFeat(FEAT_MAXIMIZE_SPELL, oPC)
+ GetHasFeat(FEAT_QUICKEN_SPELL, oPC)
+ GetHasFeat(FEAT_SILENCE_SPELL, oPC)
+ GetHasFeat(FEAT_STILL_SPELL, oPC)
+ GetHasFeat(FEAT_SUDDEN_EMPOWER, oPC)
+ GetHasFeat(FEAT_SUDDEN_MAXIMIZE, oPC)
+ GetHasFeat(FEAT_SUDDEN_EXTEND, oPC)
+ GetHasFeat(FEAT_SUDDEN_WIDEN, oPC);
// At least one metamagic feat
if (iFeat)
SetLocalInt(oPC, "PRC_PresWildMageReq", 0);
}
void SancWarmind(object oPC)
{
SetLocalInt(oPC, "PRC_AllowWarmind", 1);
SetLocalInt(oPC, "PRC_AllowSancMind", 1);
int iPwrPoints = GetMaximumPowerPoints(oPC);
//:: Requires at least one Power Point
if (iPwrPoints > 0)
{
SetLocalInt(oPC, "PRC_AllowWarmind", 0);
SetLocalInt(oPC, "PRC_AllowSancMind", 0);
}
}
void DalQuor(object oPC)
{
SetLocalInt(oPC, "PRC_PrereqDalQuor", 1);
// Psionic feats
if(GetHasFeat(FEAT_COMBAT_MANIFESTATION , oPC)
|| GetHasFeat(FEAT_MENTAL_LEAP , oPC)
|| GetHasFeat(FEAT_NARROW_MIND , oPC)
|| GetHasFeat(FEAT_POWER_PENETRATION , oPC)
|| GetHasFeat(FEAT_GREATER_POWER_PENETRATION , oPC)
|| GetHasFeat(FEAT_POWER_SPECIALIZATION , oPC)
|| GetHasFeat(FEAT_GREATER_POWER_SPECIALIZATION, oPC)
|| GetHasFeat(FEAT_PSIONIC_DODGE , oPC)
|| GetHasFeat(FEAT_PSIONIC_ENDOWMENT , oPC)
|| GetHasFeat(FEAT_GREATER_PSIONIC_ENDOWMENT , oPC)
|| GetHasFeat(FEAT_PSIONIC_FIST , oPC)
|| GetHasFeat(FEAT_GREATER_PSIONIC_FIST , oPC)
|| GetHasFeat(FEAT_PSIONIC_WEAPON , oPC)
|| GetHasFeat(FEAT_GREATER_PSIONIC_WEAPON , oPC)
|| GetHasFeat(FEAT_PSIONIC_SHOT , oPC)
|| GetHasFeat(FEAT_GREATER_PSIONIC_SHOT , oPC)
|| GetHasFeat(FEAT_OVERCHANNEL , oPC)
|| GetHasFeat(FEAT_PSIONIC_MEDITATION , oPC)
|| GetHasFeat(FEAT_RAPID_METABOLISM , oPC)
|| GetHasFeat(FEAT_TALENTED , oPC)
|| GetHasFeat(FEAT_UNAVOIDABLE_STRIKE , oPC)
|| GetHasFeat(FEAT_WILD_TALENT , oPC)
|| GetHasFeat(FEAT_WOUNDING_ATTACK , oPC)
|| GetHasFeat(FEAT_BOOST_CONSTRUCT , oPC)
|| GetHasFeat(FEAT_SPEED_OF_THOUGHT , oPC)
|| GetHasFeat(FEAT_PSIONIC_TALENT_1 , oPC)
|| GetHasFeat(FEAT_METAMORPHIC_TRANSFER_1 , oPC)
|| GetHasFeat(FEAT_DEEP_IMPACT , oPC)
|| GetHasFeat(FEAT_FELL_SHOT , oPC)
|| GetHasFeat(FEAT_EXPANDED_KNOWLEDGE_1 , oPC)
|| GetHasFeat(FEAT_INVEST_ARMOUR , oPC))
// At least one psionic feat
SetLocalInt(oPC, "PRC_PrereqDalQuor", 0);
}
void Thrallherd(object oPC)
{
SetLocalInt(oPC, "PRC_PrereqThrallherd", 1);
// Technically, you must be able to manifest mindlink, and the only class that can do so is a Telepath Psion
// Thus, this restriction.
if(GetHasFeat(FEAT_PSION_DIS_TELEPATH, oPC))
{
// @todo Replace with some mechanism that is not dependent on power enumeration. Maybe a set of variables that tell how many powers of each discipline a character knows <- requires hooking to power gain / loss
if(GetHasPower(POWER_CHARMPERSON, oPC)
|| GetHasPower(POWER_AVERSION, oPC)
|| GetHasPower(POWER_BRAINLOCK, oPC)
|| GetHasPower(POWER_CRISISBREATH, oPC)
|| GetHasPower(POWER_EMPATHICTRANSFERHOSTILE, oPC)
|| GetHasPower(POWER_DOMINATE, oPC)
|| GetHasPower(POWER_CRISISLIFE, oPC)
|| GetHasPower(POWER_PSYCHICCHIR_REPAIR, oPC))
{
SetLocalInt(oPC, "PRC_PrereqThrallherd", 0);
}
}
}
void Shadowmind(object oPC)
{
SetLocalInt(oPC, "PRC_PrereqShadowmind", 1);
if(GetHasPower(POWER_CONCEALAMORPHA, oPC))
SetLocalInt(oPC, "PRC_PrereqShadowmind", 0);
}
void SoulEater(object oPC)
{
SetLocalInt(oPC, "PRC_PrereqSoulEater", 1);
int nRace = MyPRCGetRacialType(oPC);
if(nRace == RACIAL_TYPE_ABERRATION
|| nRace == RACIAL_TYPE_OOZE
|| nRace == RACIAL_TYPE_PLANT
|| nRace == RACIAL_TYPE_ANIMAL
|| nRace == RACIAL_TYPE_BEAST
|| nRace == RACIAL_TYPE_DRAGON
|| nRace == RACIAL_TYPE_ELEMENTAL
|| nRace == RACIAL_TYPE_FEY
|| nRace == RACIAL_TYPE_GIANT
|| nRace == RACIAL_TYPE_HUMANOID_MONSTROUS
|| nRace == RACIAL_TYPE_MAGICAL_BEAST
|| nRace == RACIAL_TYPE_OUTSIDER)
SetLocalInt(oPC, "PRC_PrereqSoulEater", 0);
}
void RacialHD(object oPC)
{
SetLocalInt(oPC, "PRC_PrereqAberration", 1);
SetLocalInt(oPC, "PRC_PrereqAnimal", 1);
SetLocalInt(oPC, "PRC_PrereqConstruct", 1);
SetLocalInt(oPC, "PRC_PrereqHumanoid", 1);
SetLocalInt(oPC, "PRC_PrereqMonstrous", 1);
SetLocalInt(oPC, "PRC_PrereqEle", 1);
SetLocalInt(oPC, "PRC_PrereqFey", 1);
SetLocalInt(oPC, "PRC_PrereqDragon", 1);
SetLocalInt(oPC, "PRC_PrereqUndead", 1);
SetLocalInt(oPC, "PRC_PrereqBeast", 1);
SetLocalInt(oPC, "PRC_PrereqGiant", 1);
SetLocalInt(oPC, "PRC_PrereqMagicalBeast", 1);
SetLocalInt(oPC, "PRC_PrereqOutsider", 1);
SetLocalInt(oPC, "PRC_PrereqShapechanger", 1);
SetLocalInt(oPC, "PRC_PrereqVermin", 1);
SetLocalInt(oPC, "PRC_PrereqPlant", 1);
if(GetPRCSwitch(PRC_XP_USE_SIMPLE_RACIAL_HD))
{
int nRealRace = GetRacialType(oPC);
int nRacialHD = StringToInt(Get2DACache("ECL", "RaceHD", nRealRace));
int nRacialClass = StringToInt(Get2DACache("ECL", "RaceClass", nRealRace));
if(nRacialHD && GetLevelByClass(nRacialClass, oPC) < nRacialHD)
{
switch(nRacialClass)
{
case CLASS_TYPE_ABERRATION: SetLocalInt(oPC, "PRC_PrereqAberration", 0); break;
case CLASS_TYPE_ANIMAL: SetLocalInt(oPC, "PRC_PrereqAnmal", 0); break;
case CLASS_TYPE_CONSTRUCT: SetLocalInt(oPC, "PRC_PrereqConstruct", 0); break;
case CLASS_TYPE_HUMANOID: SetLocalInt(oPC, "PRC_PrereqHumanoid", 0); break;
case CLASS_TYPE_MONSTROUS: SetLocalInt(oPC, "PRC_PrereqMonstrous", 0); break;
case CLASS_TYPE_ELEMENTAL: SetLocalInt(oPC, "PRC_PrereqEle", 0); break;
case CLASS_TYPE_FEY: SetLocalInt(oPC, "PRC_PrereqFey", 0); break;
case CLASS_TYPE_DRAGON: SetLocalInt(oPC, "PRC_PrereqDragon", 0); break;
case CLASS_TYPE_UNDEAD: SetLocalInt(oPC, "PRC_PrereqUndead", 0); break;
case CLASS_TYPE_BEAST: SetLocalInt(oPC, "PRC_PrereqBeast", 0); break;
case CLASS_TYPE_GIANT: SetLocalInt(oPC, "PRC_PrereqGiant", 0); break;
case CLASS_TYPE_MAGICAL_BEAST: SetLocalInt(oPC, "PRC_PrereqMagicalBeast", 0); break;
case CLASS_TYPE_OUTSIDER: SetLocalInt(oPC, "PRC_PrereqOutsider", 0); break;
case CLASS_TYPE_SHAPECHANGER: SetLocalInt(oPC, "PRC_PrereqShapechanger", 0); break;
case CLASS_TYPE_VERMIN: SetLocalInt(oPC, "PRC_PrereqVermin", 0); break;
case CLASS_TYPE_PLANT: SetLocalInt(oPC, "PRC_PrereqPlant", 0); break;
default: SetLocalInt(oPC, "NoRace", 0);
}
}
}
}
void Virtuoso(object oPC)
{ //Needs 6 ranks of Persuade OR 6 ranks of Intimidate
SetLocalInt(oPC, "PRC_PrereqVirtuoso", 1);
if((GetSkillRank(SKILL_PERSUADE, oPC) >= 6) || (GetSkillRank(SKILL_INTIMIDATE, oPC) >= 6))
SetLocalInt(oPC, "PRC_PrereqVirtuoso", 0);
}
void FistRaziel(object oPC)
{
/* The fist of Raziel can only be taken if the player is able to cast Divine Favor.
* Base classes:
* Cleric gets it at level 1. Paladin at level 4 (with wis > 11) to 6 (wis == 11)
*/
SetLocalInt(oPC, "PRC_PrereqFistRaz", 1);
object oSkin = GetPCSkin(oPC);
int iWis = GetLocalInt(oSkin, "PRC_trueWIS");
// hard code it to work for Bioware classes
if (GetLevelByClass(CLASS_TYPE_CLERIC))
{
SetLocalInt(oPC, "PRC_PrereqFistRaz", 0);
return;
}
if (GetLevelByClass(CLASS_TYPE_PALADIN))
{
if(iWis > 11 && GetLevelByClass(CLASS_TYPE_PALADIN) >= 4)
{
SetLocalInt(oPC, "PRC_PrereqFistRaz", 0);
return;
}
else if (GetLevelByClass(CLASS_TYPE_PALADIN) >= 6)
{
SetLocalInt(oPC, "PRC_PrereqFistRaz", 0);
return;
}
}
if (PRCGetIsRealSpellKnown(SPELL_DIVINE_FAVOR, oPC))
{
SetLocalInt(oPC, "PRC_PrereqFistRaz", 0);
return;
}
}
void Pyro(object oPC)
{
SetLocalInt(oPC, "PRC_PrereqPyro", 1);
if(GetIsPsionicCharacter(oPC))
SetLocalInt(oPC, "PRC_PrereqPyro", 0);
}
void Suel()
{
SetLocalInt(OBJECT_SELF, "PRC_PrereqSuelWeap", 1);
//martial weapon proficiences
int nProf = GetHasFeat(FEAT_WEAPON_PROFICIENCY_SHORTSWORD)
+ GetHasFeat(FEAT_WEAPON_PROFICIENCY_LONGSWORD)
+ GetHasFeat(FEAT_WEAPON_PROFICIENCY_BATTLEAXE)
+ GetHasFeat(FEAT_WEAPON_PROFICIENCY_WARHAMMER)
+ GetHasFeat(FEAT_WEAPON_PROFICIENCY_LONGBOW)
+ GetHasFeat(FEAT_WEAPON_PROFICIENCY_LIGHT_FLAIL)
+ GetHasFeat(FEAT_WEAPON_PROFICIENCY_HALBERD)
+ GetHasFeat(FEAT_WEAPON_PROFICIENCY_SHORTBOW)
+ GetHasFeat(FEAT_WEAPON_PROFICIENCY_GREATSWORD)
+ GetHasFeat(FEAT_WEAPON_PROFICIENCY_GREATAXE)
+ GetHasFeat(FEAT_WEAPON_PROFICIENCY_HEAVY_FLAIL)
+ GetHasFeat(FEAT_WEAPON_PROFICIENCY_LIGHT_HAMMER)
+ GetHasFeat(FEAT_WEAPON_PROFICIENCY_HANDAXE)
+ GetHasFeat(FEAT_WEAPON_PROFICIENCY_RAPIER)
+ GetHasFeat(FEAT_WEAPON_PROFICIENCY_SCIMITAR)
+ GetHasFeat(FEAT_WEAPON_PROFICIENCY_THROWING_AXE);
//exotic weapon proficiences
+ GetHasFeat(FEAT_WEAPON_PROFICIENCY_BASTARD_SWORD)
+ GetHasFeat(FEAT_WEAPON_PROFICIENCY_TWO_BLADED_SWORD)
+ GetHasFeat(FEAT_WEAPON_PROFICIENCY_BATTLEAXE)
+ GetHasFeat(FEAT_WEAPON_PROFICIENCY_DIRE_MACE)
+ GetHasFeat(FEAT_WEAPON_PROFICIENCY_DOUBLE_AXE)
+ GetHasFeat(FEAT_WEAPON_PROFICIENCY_KAMA)
+ GetHasFeat(FEAT_WEAPON_PROFICIENCY_KUKRI)
+ GetHasFeat(FEAT_WEAPON_PROFICIENCY_KATANA)
+ GetHasFeat(FEAT_WEAPON_PROFICIENCY_SCYTHE)
+ GetHasFeat(FEAT_WEAPON_PROFICIENCY_SHURIKEN)
+ GetHasFeat(FEAT_WEAPON_PROFICIENCY_DWARVEN_WARAXE)
+ GetHasFeat(FEAT_WEAPON_PROFICIENCY_WHIP)
+ GetHasFeat(FEAT_WEAPON_PROFICIENCY_ELVEN_THINBLADE)
+ GetHasFeat(FEAT_WEAPON_PROFICIENCY_RAPIER)
+ GetHasFeat(FEAT_WEAPON_PROFICIENCY_ELVEN_COURTBLADE);
if(nProf > 3)
DeleteLocalInt(OBJECT_SELF, "PRC_PrereqSuelWeap");
}
void TomeOfBattle(object oPC = OBJECT_SELF)
{
// Deepstone Sentinel
SetLocalInt(oPC, "PRC_PrereqDeepSt", 1);
// Needs two Stone Dragon maneuvers
int nMove = GetManeuverCountByDiscipline(oPC, DISCIPLINE_STONE_DRAGON, MANEUVER_TYPE_MANEUVER);
// Needs one Stone Dragon Stance
int nStance = GetManeuverCountByDiscipline(oPC, DISCIPLINE_STONE_DRAGON, MANEUVER_TYPE_STANCE);
if(nMove > 1 && nStance)
SetLocalInt(oPC, "PRC_PrereqDeepSt", 0);
// Bloodclaw Master
SetLocalInt(oPC, "PRC_PrereqBloodclaw", 1);
// Needs three Tiger Claw maneuvers
if(_CheckPrereqsByDiscipline(oPC, DISCIPLINE_TIGER_CLAW, 3))
SetLocalInt(oPC, "PRC_PrereqBloodclaw", 0);
// Ruby Knight Vindicator
SetLocalInt(oPC, "PRC_PrereqRubyKnight", 1);
// Needs one Devoted Spirit maneuver
nMove = GetManeuverCountByDiscipline(oPC, DISCIPLINE_DEVOTED_SPIRIT, MANEUVER_TYPE_MANEUVER);
// Needs one Devoted Spirit stance
nStance = GetManeuverCountByDiscipline(oPC, DISCIPLINE_DEVOTED_SPIRIT, MANEUVER_TYPE_STANCE);
// If it's a cleric, needs to have Death, Law and Magic as domains.
int nDomain = TRUE;
if(GetLevelByClass(CLASS_TYPE_CLERIC, oPC))
{
nDomain = GetHasFeat(FEAT_DEATH_DOMAIN_POWER, oPC)
+ GetHasFeat(FEAT_MAGIC_DOMAIN_POWER, oPC)
//+ GetHasFeat(FEAT_LAW_DOMAIN_POWER, oPC)
> 1;
}
if(nMove && nStance && nDomain)
SetLocalInt(oPC, "PRC_PrereqRubyKnight", 0);
// Jade Phoenix Mage
SetLocalInt(oPC, "PRC_PrereqJPM", 1);
// Skip the rest of not an arcane caster
if(GetLocalInt(oPC, "PRC_ArcSpell2") == 0)
{
int nUser;
int nMove = 0;
int nStance = 0;
int nType;
// Only need first blade magic class. Can't take a second and Jade Phoenix and meet requirements.
nUser = GetPrimaryBladeMagicClass(oPC);
// If inv_inc_moveknwn can be included here, GetManeuverCount() can be used in place of GetPersistantLocalInt()
// the following is pulled from the function
nType = MANEUVER_TYPE_MANEUVER;
nMove += GetPersistantLocalInt(oPC, "PRC_ManeuverList_" + IntToString(nUser) + IntToString(nType) + "_TotalKnown");
nType = MANEUVER_TYPE_STANCE;
nStance += GetPersistantLocalInt(oPC, "PRC_ManeuverList_" + IntToString(nUser) + IntToString(nType) + "_TotalKnown");
if (nMove >= 2 && nStance >= 1)
SetLocalInt(oPC, "PRC_PrereqJPM", 0);
}
//Master of Nine
SetLocalInt(oPC, "PRC_PrereqMoNine", 1);
// Needs 6 maneuvers, so check the persistent locals
int i, nCount, nSkills;
for(i = 1; i <= 256; i <<= 1)
{
// Loop over all disciplines, and total up how many he knows
if(_CheckPrereqsByDiscipline(oPC, i))
nCount++;
}
// Base ranks only
if(GetSkillRank(SKILL_TUMBLE, oPC, TRUE) >= 10) nSkills += 1;
if(GetSkillRank(SKILL_INTIMIDATE, oPC, TRUE) >= 10) nSkills += 1;
if(GetSkillRank(SKILL_CONCENTRATION, oPC, TRUE) >= 10) nSkills += 1;
if(GetSkillRank(SKILL_BALANCE, oPC, TRUE) >= 10) nSkills += 1;
if(GetSkillRank(SKILL_SENSE_MOTIVE, oPC, TRUE) >= 10) nSkills += 1;
if(GetSkillRank(SKILL_HIDE, oPC, TRUE) >= 10) nSkills += 1;
if(GetSkillRank(SKILL_JUMP, oPC, TRUE) >= 10) nSkills += 1;
if(GetSkillRank(SKILL_PERSUADE, oPC, TRUE) >= 10) nSkills += 1;
if(nCount >= 6 && nSkills >= 4)
SetLocalInt(oPC, "PRC_PrereqMoNine", 0);
//Eternal Blade
SetLocalInt(oPC, "PRC_PrereqETBL", 1);
int iWF = WeaponFocusCount(oPC);
nCount = _CheckPrereqsByDiscipline(oPC, DISCIPLINE_DEVOTED_SPIRIT)
+ _CheckPrereqsByDiscipline(oPC, DISCIPLINE_DIAMOND_MIND);
if(nCount >= 2 && iWF >= 1)
SetLocalInt(oPC, "PRC_PrereqETBL", 0);
//Shadow Sun Ninja
SetLocalInt(oPC, "PRC_PrereqSSN", 1);
int nLv2 = GetPersistantLocalInt(oPC, "ShadowSunNinjaLv2Req");
int nSS = _CheckPrereqsByDiscipline(oPC, DISCIPLINE_SETTING_SUN);
int nSH = _CheckPrereqsByDiscipline(oPC, DISCIPLINE_SHADOW_HAND);
// We have at least one 2nd level Shadow Hand or Setting Sun maneuver
// And at least one of each Shadow Hand and Setting Sun maneuvers
if(nLv2 && nSS && nSH && (nSS >= 2 || nSH >= 2))
SetLocalInt(oPC, "PRC_PrereqSSN", 0);
}
void FMMPreReqs(object oPC)
{
//:: Force Missile Mage can only be taken by arcane classes that can cast Magic Missile.
SetLocalInt(oPC, "PRC_PrereqFMM", 1);
//:: Check PRC NewSpellBook classes: Archivist, Aberration, Monstrous, Outsider,
//:: Shapechanger, Knight of the Weave, Sorcerer, Warmage
if(PRCGetIsRealSpellKnown(SPELL_MAGIC_MISSILE, oPC))
{
SetLocalInt(oPC, "PRC_PrereqFMM", 0);
}
//:: Check Bioware Sorcerer
int iCha = GetLocalInt(GetPCSkin(oPC), "PRC_trueCHA");
if(iCha > 10)
{
if(GetIsInKnownSpellList(oPC, CLASS_TYPE_SORCERER, SPELL_MAGIC_MISSILE))
{
SetLocalInt(oPC, "PRC_PrereqFMM", 0);
}
}
//:: Check Wizard
int iInt = GetLocalInt(GetPCSkin(oPC), "PRC_trueINT");
if(iInt > 10)
{
if(GetLevelByClass(CLASS_TYPE_WIZARD))
SetLocalInt(oPC, "PRC_PrereqFMM", 0);
}
//:: Check Nentyar Hunter
int iWis = GetLocalInt(GetPCSkin(oPC), "PRC_trueWis");
if(iWis > 10)
{
if(GetLevelByClass(CLASS_TYPE_NENTYAR_HUNTER))
SetLocalInt(oPC, "PRC_PrereqFMM", 0);
}
}
void ThrallOfOrcusPreReqs(object oPC)
{
int iArcane = 0;
int iShadow = 0;
if(GetLocalInt(oPC, "PRC_ArcSpell1") == 0)
{
iArcane = 1;
}
if(GetLocalInt(oPC, "PRC_MystLevel1") == 0)
{
iShadow = 1;
}
// Initialize the prerequisite variable to 1
SetLocalInt(oPC, "PRC_PrereqOrcus", 1);
// Count how many conditions are true
int conditionsMet = 0;
if (iArcane > 0) conditionsMet++;
if (iShadow > 0) conditionsMet++;
// Check if at least one of the conditions are met and set "PRC_PrereqOrcus" to 0 if true
if (conditionsMet >= 1)
{
SetLocalInt(oPC, "PRC_PrereqOrcus", 0);
}
}
void ElementalSavantPreReqs(object oPC)
{
int iArcane = 0;
int iShadow = 0;
if(GetLocalInt(oPC, "PRC_ArcSpell3") == 0)
{
iArcane = 1;
}
if(GetLocalInt(oPC, "PRC_MystLevel3") == 0)
{
iShadow = 1;
}
// Initialize the prerequisite variable to 1
SetLocalInt(oPC, "PRC_PrereqElSav", 1);
// Count how many conditions are true
int conditionsMet = 0;
if (iArcane > 0) conditionsMet++;
if (iShadow > 0) conditionsMet++;
// Check if at least one of the conditions are met and set "PRC_PrereqElSav" to 0 if true
if (conditionsMet >= 1)
{
SetLocalInt(oPC, "PRC_PrereqElSav", 0);
}
}
void MysticTheurgePreReqs(object oPC)
{
int iArcane = 0;
int iDivine = 0;
int iShadow = 0;
if(GetLocalInt(oPC, "PRC_ArcSpell2") == 0)
{
iArcane = 2;
}
if(GetLocalInt(oPC, "PRC_DivSpell2") == 0)
{
iDivine = 1;
}
if(GetLocalInt(oPC, "PRC_MystLevel2") == 0)
{
iShadow = 2;
}
// Initialize the prerequisite variable to 1
SetLocalInt(oPC, "PRC_PrereqMysticTheurge", 1);
// Count how many conditions are true
int conditionsMet = iArcane + iDivine + iShadow;
/* if (iArcane > 0) conditionsMet++;
if (iDivine > 0) conditionsMet++;
if (iShadow > 0) conditionsMet++; */
// Check that oPC has a divine class & either an arcane or shadowcasting class.
if (conditionsMet == 3)
{
SetLocalInt(oPC, "PRC_PrereqMysticTheurge", 0);
}
}
void AlienistPreReqs(object oPC)
{
int iArcane = 0;
int iShadow = 0;
if(GetLocalInt(oPC, "PRC_ArcSpell3") == 0)
{
iArcane = 1;
}
if(GetLocalInt(oPC, "PRC_MystLevel3") == 0)
{
iShadow = 1;
}
// Initialize the prerequisite variable to 1
SetLocalInt(oPC, "PRC_PrereqAlienist", 1);
// Check if any of the conditions are met and set "PRC_PrereqAlienist" to 0 if true
if (iArcane > 0 || iShadow > 0)
{
SetLocalInt(oPC, "PRC_PrereqAlienist", 0);
}
}
void AOTSPreReqs(object oPC)
{
int iArcane = 0;
int iShadow = 0;
if(GetLocalInt(oPC, "PRC_ArcSpell2") == 0)
{
iArcane = 1;
}
if(GetLocalInt(oPC, "PRC_MystLevel2") == 0)
{
iShadow = 1;
}
// Initialize the prerequisite variable to 1
SetLocalInt(oPC, "PRC_PrereqAOTS", 1);
// Check if any of the conditions are met and set "PRC_PrereqAOTS" to 0 if true
if (iArcane > 0 || GetInvokerLevel(oPC) > 2 || iShadow > 0)
{
SetLocalInt(oPC, "PRC_PrereqAOTS", 0);
}
}
/* void AOTS(object oPC)
{
SetLocalInt(oPC, "PRC_PrereqAOTS", 1);
int iArcane = GetLocalInt(oPC, "PRC_ArcSpell3");
if(iArcane == 0 || GetInvokerLevel(oPC)<= 2 || GetHighestShadowcasterLevel(oPC) <= 2)
SetLocalInt(oPC, "PRC_PrereqAOTS", 0);
} */
void EnlF(object oPC)
{
SetLocalInt(oPC, "PRC_PrereqEnlF", 1);
int iArcane = GetLocalInt(oPC, "PRC_ArcSpell3");
if(iArcane == 0 || GetInvokerLevel(oPC) >= 3)
SetLocalInt(oPC, "PRC_PrereqEnlF", 0);
}
void LichPrereq(object oPC)
{
SetLocalInt(oPC, "PRC_PrereqLich", 1);
if(PRCAmIAHumanoid(oPC) || GetLevelByClass(CLASS_TYPE_LICH, oPC) >= 4)
SetLocalInt(oPC, "PRC_PrereqLich", 0);
}
void DragDisciple(object oPC)
{
int bRace = FALSE;
int bSpells = FALSE;
SetLocalInt(oPC, "PRC_PrereqDrDis", 1);
//Any nondragon (cannot already be a half-dragon)
int nRace = GetRacialType(oPC);
if(!GetHasTemplate(TEMPLATE_HALF_DRAGON, oPC)
&& nRace != RACIAL_TYPE_SPIRETOPDRAGON
&& nRace != RACIAL_TYPE_BOZAK
&& nRace != RACIAL_TYPE_KAPAK)
bRace = TRUE;
// Ability to cast arcane spells without preparation
// (dragon blooded feat eliminates that requirement)
if(GetHasFeat(DRAGON_BLOODED, oPC))
bSpells = TRUE;
else if(GetLevelByClass(CLASS_TYPE_ASSASSIN, oPC)
|| GetLevelByClass(CLASS_TYPE_BARD, oPC)
|| GetLevelByClass(CLASS_TYPE_BEGUILER, oPC)
|| GetLevelByClass(CLASS_TYPE_DREAD_NECROMANCER, oPC)
|| GetLevelByClass(CLASS_TYPE_DUSKBLADE, oPC)
|| GetLevelByClass(CLASS_TYPE_HEXBLADE, oPC)
|| GetLevelByClass(CLASS_TYPE_SORCERER, oPC)
|| GetLevelByClass(CLASS_TYPE_SUEL_ARCHANAMACH, oPC)
|| GetLevelByClass(CLASS_TYPE_WARMAGE, oPC)
|| GetLevelByClass(CLASS_TYPE_WITCH, oPC))
{
if(!GetLocalInt(oPC, "PRC_ArcSpell0")
|| !GetLocalInt(oPC, "PRC_ArcSpell1"))
bSpells = TRUE;
}
if(bRace && bSpells)
SetLocalInt(oPC, "PRC_PrereqDrDis", 0);
}
void WarlockPrCs(object oPC)
{
SetLocalInt(oPC, "PRC_PrereqHFWar", 1);
SetLocalInt(oPC, "PRC_PrereqEDisc", 1);
SetLocalInt(oPC, "PRC_PrereqETheurg", 1);
if(GetHasInvocation(INVOKE_BRIMSTONE_BLAST, oPC)
|| GetHasInvocation(INVOKE_HELLRIME_BLAST, oPC))
{
SetLocalInt(oPC, "PRC_PrereqHFWar", 0);
}
//currently there are only 2 invocation using classes
//all start with least invocations so this should be accurate
if(GetIsInvocationUser(oPC))
{
SetLocalInt(oPC, "PRC_PrereqEDisc", 0);
if(GetBlastDamageDices(oPC, GetInvokerLevel(oPC, CLASS_TYPE_WARLOCK)) > 1)
{
SetLocalInt(oPC, "PRC_PrereqETheurg", 0);
}
}
}
void Shadowbane(object oPC)
{
SetLocalInt(oPC, "PRC_PrereqShadowbane", 1);
if(GetLevelByClass(CLASS_TYPE_CLERIC, oPC) ||
GetLevelByClass(CLASS_TYPE_ARCHIVIST, oPC) ||
GetLevelByClass(CLASS_TYPE_PALADIN, oPC) ||
GetLevelByClass(CLASS_TYPE_KNIGHT_CHALICE, oPC) ||
GetLevelByClass(CLASS_TYPE_SOLDIER_OF_LIGHT, oPC) ||
GetLevelByClass(CLASS_TYPE_SHAMAN, oPC) ||
GetLevelByClass(CLASS_TYPE_SLAYER_OF_DOMIEL, oPC))
SetLocalInt(oPC, "PRC_PrereqShadowbane", 0);
}
void KnightWeave(object oPC)
{
int bSpontCaster = FALSE;
//make sure user is a spontaneous arcane caster
int i;
for(i = 1; i <= 8; i++)
{
int nClass = GetClassByPosition(i, oPC);
if((GetSpellbookTypeForClass(nClass) == SPELLBOOK_TYPE_SPONTANEOUS) && GetMaxSpellLevelForCasterLevel(nClass, GetLevelByTypeArcane(oPC)) >= 3)
bSpontCaster = TRUE;
//if (DEBUG) DoDebug("Knight of the Weave: Spellbook Type "+IntToString(GetSpellbookTypeForClass(nClass))+", MaxSpellLevel "+IntToString(GetMaxSpellLevelForCasterLevel(nClass, GetLevelByTypeArcane(oPC)))+", BAB "+IntToString(GetBaseAttackBonus(oPC)));
}
SetLocalInt(oPC, "PRC_PrereqKnightWeave", 1);
if((GetBaseAttackBonus(oPC) >= 5 || bSpontCaster) && !GetHasFeat(FEAT_SHADOWWEAVE, oPC)) // Shadow weave not allowed
SetLocalInt(oPC, "PRC_PrereqKnightWeave", 0);
}
void Incarnate(object oPC)
{
SetLocalInt(oPC, "PRC_PrereqIncarnate", 1);
if(IncarnateAlignment(oPC) && (PRCGetIsAliveCreature(oPC) || GetHasFeat(FEAT_UNDEAD_MELDSHAPER, oPC)))
SetLocalInt(oPC, "PRC_PrereqIncarnate", 0);
}
void Spinemeld(object oPC)
{
SetLocalInt(oPC, "PRC_PrereqSpinemeld", 1);
SetLocalInt(oPC, "PRC_PrereqUmbral", 1);
SetLocalInt(oPC, "PRC_PrereqIncandescent", 1);
if(GetTotalEssentia(oPC))
{
SetLocalInt(oPC, "PRC_PrereqSpinemeld", 0);
SetLocalInt(oPC, "PRC_PrereqUmbral", 0);
SetLocalInt(oPC, "PRC_PrereqIncandescent", 0);
}
//FloatingTextStringOnCreature("PRC_PrereqSpinemeld is "+IntToString(GetLocalInt(oPC, "PRC_PrereqSpinemeld"))+" GetBAB is "+IntToString(GetBaseAttackBonus(oPC))+" GetLawChaos is "+IntToString(GetAlignmentLawChaos(oPC))+" GetRace is "+IntToString(GetRacialType(oPC)), oPC, FALSE);
}
void SapphireHierarch(object oPC)
{
SetLocalInt(oPC, "PRC_PrereqSapphire", 1);
if(GetTotalEssentia(oPC) >= 3 &&/* GetHasFeat(FEAT_LAW_DOMAIN_POWER, oPC) &&*/ GetTotalSoulmeldCount(oPC) >= 3)
SetLocalInt(oPC, "PRC_PrereqSapphire", 0);
}
void SoulcasterReq(object oPC)
{
SetLocalInt(oPC, "PRC_PrereqSoulcaster", 1);
if( GetMaxBindCount(oPC, GetPrimaryIncarnumClass(oPC)) >= 1 && GetTotalSoulmeldCount(oPC) >= 3 &&
((!GetLocalInt(oPC, "PRC_PsiPower2") && GetHasFeat(FEAT_AZURE_TALENT, oPC)) ||
(!GetLocalInt(oPC, "PRC_ArcSpell2") && GetHasFeat(FEAT_INCARNUM_SPELLSHAPING))))
SetLocalInt(oPC, "PRC_PrereqSoulcaster", 0);
}
void Ironsoul(object oPC)
{
SetLocalInt(oPC, "PRC_PrereqIronsoul", 1);
if(GetTotalSoulmeldCount(oPC) >= 1)
SetLocalInt(oPC, "PRC_PrereqIronsoul", 0);
}
void Necrocarnum(object oPC)
{
SetLocalInt(oPC, "PRC_PrereqNecrocarnum", 1);
if(GetTotalSoulmeldCount(oPC) && GetCanBindChakra(oPC, CHAKRA_CROWN) && GetCanBindChakra(oPC, CHAKRA_FEET) && GetCanBindChakra(oPC, CHAKRA_HANDS))
SetLocalInt(oPC, "PRC_PrereqNecrocarnum", 0);
}
void Witchborn(object oPC)
{
SetLocalInt(oPC, "PRC_PrereqWitchborn", 1);
// Can't be arcane at all, Meldshaper level 6th
if(GetPrimaryArcaneClass(oPC) == CLASS_TYPE_INVALID && GetHighestMeldshaperLevel(oPC) >= 6)
SetLocalInt(oPC, "PRC_PrereqWitchborn", 0);
}
void AbChamp(object oPC)
{
SetLocalInt(oPC, "PRC_PrereqAbjCha", 1);
if(GetHasFeat(FEAT_COMBAT_CASTING, oPC))
SetLocalInt(oPC, "PRC_PrereqAbjCha", 0);
}
void AnimaMageReq(object oPC)
{
SetLocalInt(oPC, "PRC_PrereqAnimaMage", 1);
int iFeat = GetHasFeat(FEAT_EMPOWER_SPELL, oPC)
+ GetHasFeat(FEAT_EXTEND_SPELL, oPC)
+ GetHasFeat(FEAT_MAXIMIZE_SPELL, oPC)
+ GetHasFeat(FEAT_QUICKEN_SPELL, oPC)
+ GetHasFeat(FEAT_SILENCE_SPELL, oPC)
+ GetHasFeat(FEAT_STILL_SPELL, oPC);
// At least one metamagic feat, 2nd level vestiges from Binder class
if (iFeat && GetMaxVestigeLevel(oPC) >= 2 && GetLevelByClass(CLASS_TYPE_BINDER, oPC))
SetLocalInt(oPC, "PRC_PrereqAnimaMage", 0);
}
void TenebrousReq(object oPC)
{
SetLocalInt(oPC, "PRC_PrereqTenebrous", 1);
int nDomain = FALSE;
if(GetHasFeat(FEAT_DEATH_DOMAIN_POWER)
+ GetHasFeat(FEAT_TRICKERY_DOMAIN_POWER)
+ GetHasFeat(FEAT_EVIL_DOMAIN_POWER) >= 2)
nDomain = TRUE;
// Tenebrous grants turn undead, so it actually meets that requirement.
// 4th level vestiges from Binder class
if ((nDomain || !GetLevelByClass(CLASS_TYPE_CLERIC, oPC)) && GetMaxVestigeLevel(oPC) >= 4 && GetLevelByClass(CLASS_TYPE_BINDER, oPC))
SetLocalInt(oPC, "PRC_PrereqTenebrous", 0);
}
void ScionReq(object oPC)
{
SetLocalInt(oPC, "PRC_PrereqScion", 1);
int nCheck = FALSE;
int nRace = MyPRCGetRacialType(oPC);
if(nRace == RACIAL_TYPE_HUMAN
|| nRace == RACIAL_TYPE_HALFORC
|| nRace == RACIAL_TYPE_HALFELF)
nCheck = TRUE;
// 5th level vestiges from Binder class
if (nCheck && GetMaxVestigeLevel(oPC) >= 5 && GetLevelByClass(CLASS_TYPE_BINDER, oPC))
SetLocalInt(oPC, "PRC_PrereqScion", 0);
}
void DragonDevotee(object oPC)
{
SetLocalInt(oPC, "PRC_PrereqDragonDevotee", 1);
if(MyPRCGetRacialType(oPC) != RACIAL_TYPE_DRAGON)
SetLocalInt(oPC, "PRC_PrereqDragonDevotee", 0);
}
void UrPriest(object oPC)
{
SetLocalInt(oPC, "PRC_PrereqUrPriest", 1);
if (GetWillSavingThrow(oPC) >= 3 && GetFortitudeSavingThrow(oPC) >= 3)
{
SetLocalInt(oPC, "PRC_PrereqUrPriest", 0);
}
}
void Ocular(object oPC)
{
SetLocalInt(oPC, "PRC_PrereqOcular", 1);
if (GetFortitudeSavingThrow(oPC) >= 4)
{
SetLocalInt(oPC, "PRC_PrereqOcular", 0);
}
}
void TotemRager(object oPC)
{
SetLocalInt(oPC, "PRC_PrereqTotemRager", 1);
if(GetLevelByClass(CLASS_TYPE_TOTEMIST, oPC) >= 2)
SetLocalInt(oPC, "PRC_PrereqTotemRager", 0);
}
void UMagus(object oPC)
{
SetLocalInt(oPC, "PRC_PrereqUMagus", 1);
if(GetLevelByClass(CLASS_TYPE_WIZARD, oPC) >= 4 && GetLevelByClass(CLASS_TYPE_SORCERER, oPC))
SetLocalInt(oPC, "PRC_PrereqUMagus", 0);
}
void main()
{
//Declare Major Variables
object oPC = OBJECT_SELF;
object oSkin = GetPCSkin(oPC);
SetLocalInt(oPC, "PRC_PrereqFMM", 1);
SetLocalInt(oPC, "PRC_PrereqEKnight", 1);
// Initialize all the variables.
string sVariable, sCount;
int iCount;
for (iCount = 0; iCount <= 9; iCount++)
{
sCount = IntToString(iCount);
sVariable = "PRC_AllSpell" + sCount;
SetLocalInt(oPC, sVariable, 1);
sVariable = "PRC_ArcSpell" + sCount;
SetLocalInt(oPC, sVariable, 1);
sVariable = "PRC_DivSpell" + sCount;
SetLocalInt(oPC, sVariable, 1);
sVariable = "PRC_PsiPower" + sCount;
SetLocalInt(oPC, sVariable, 1);
sVariable = "PRC_MystLevel" + sCount;
SetLocalInt(oPC, sVariable, 1);
}
for (iCount = 1; iCount <= 30; iCount++)
{
sCount = IntToString(iCount);
sVariable = "PRC_SneakLevel" + sCount;
SetLocalInt(oPC, sVariable, 1);
sVariable = "PRC_SkirmishLevel" + sCount;
SetLocalInt(oPC, sVariable, 1);
sVariable = "PRC_SplAtkLevel" + sCount;
SetLocalInt(oPC, sVariable, 1);
}
// Find the spell levels.
int iCha = GetLocalInt(oSkin, "PRC_trueCHA") - 10;
int iWis = GetLocalInt(oSkin, "PRC_trueWIS") - 10;
int iInt = GetLocalInt(oSkin, "PRC_trueINT") - 10;
int nArcHighest;
int nDivHighest;
int nPsiHighest;
int bFirstArcClassFound, bFirstDivClassFound, bFirstPsiClassFound, bFirstShdClassFound;
//for(i=1;i<3;i++)
int nSpellLevel;
int nClassSlot = 1;
while(nClassSlot <= 8)
{
int nClass = GetClassByPosition(nClassSlot, oPC);
nClassSlot += 1;
if(GetIsDivineClass(nClass))
{
int nLevel = GetLevelByClass(nClass, oPC);
if (!bFirstDivClassFound &&
GetPrimaryDivineClass(oPC) == nClass)
{
nLevel += GetDivinePRCLevels(oPC, nClass);
bFirstDivClassFound = TRUE;
}
int nAbility = GetAbilityScoreForClass(nClass, oPC);
for(nSpellLevel = 0; nSpellLevel <= 9; nSpellLevel++)
{
int nSlots = GetSlotCount(nLevel, nSpellLevel, nAbility, nClass);
if(nSlots > 0)
{
SetLocalInt(oPC, "PRC_AllSpell"+IntToString(nSpellLevel), 0);
SetLocalInt(oPC, "PRC_DivSpell"+IntToString(nSpellLevel), 0);
if(nSpellLevel > nDivHighest)
nDivHighest = nSpellLevel;
// if(DEBUG) DoDebug("Divine Prereq Variable " + IntToString(nSpellLevel) +": " + IntToString(GetLocalInt(oPC, "PRC_DivSpell"+IntToString(nSpellLevel))), oPC);
// if(DEBUG) DoDebug("All Prereq Variable " + IntToString(nSpellLevel) +": " + IntToString(GetLocalInt(oPC, "PRC_AllSpell"+IntToString(nSpellLevel))), oPC);
}
}
}
else if(GetIsArcaneClass(nClass))
{
int nLevel = GetLevelByClass(nClass, oPC);
// check for monster caster race/class combos, all of which are arcane at the moment
int nMonsterCaster = FALSE;
if (nClass == CLASS_TYPE_SHAPECHANGER && GetRacialType(oPC) == RACIAL_TYPE_ARANEA && !GetLevelByClass(CLASS_TYPE_SORCERER, oPC))
nMonsterCaster = TRUE;
if (nClass == CLASS_TYPE_OUTSIDER && GetRacialType(oPC) == RACIAL_TYPE_RAKSHASA && !GetLevelByClass(CLASS_TYPE_SORCERER, oPC))
nMonsterCaster = TRUE;
if (nClass == CLASS_TYPE_ABERRATION && GetRacialType(oPC) == RACIAL_TYPE_DRIDER && !GetLevelByClass(CLASS_TYPE_SORCERER, oPC))
nMonsterCaster = TRUE;
if (nClass == CLASS_TYPE_MONSTROUS && GetRacialType(oPC) == RACIAL_TYPE_ARKAMOI && !GetLevelByClass(CLASS_TYPE_SORCERER, oPC))
nMonsterCaster = TRUE;
if (nClass == CLASS_TYPE_MONSTROUS && GetRacialType(oPC) == RACIAL_TYPE_REDSPAWN_ARCANISS && !GetLevelByClass(CLASS_TYPE_SORCERER, oPC))
nMonsterCaster = TRUE;
if (nClass == CLASS_TYPE_MONSTROUS && GetRacialType(oPC) == RACIAL_TYPE_MARRUTACT && !GetLevelByClass(CLASS_TYPE_SORCERER, oPC))
nMonsterCaster = TRUE;
if (nClass == CLASS_TYPE_FEY && GetRacialType(oPC) == RACIAL_TYPE_GLOURA && !GetLevelByClass(CLASS_TYPE_BARD, oPC))
nMonsterCaster = TRUE;
if (!bFirstArcClassFound &&
(GetPrimaryArcaneClass(oPC) == nClass || nMonsterCaster))
{
nLevel += GetArcanePRCLevels(oPC, nClass);
bFirstArcClassFound = TRUE;
}
int nAbility = GetAbilityScoreForClass(nClass, oPC);
if (nMonsterCaster)
{
nAbility = GetAbilityScoreForClass(CLASS_TYPE_SORCERER, oPC);
nClass = CLASS_TYPE_SORCERER;
}
for(nSpellLevel = 0; nSpellLevel <= 9; nSpellLevel++)
{
int nSlots = GetSlotCount(nLevel, nSpellLevel, nAbility, nClass);
if(nSlots > 0)
{
SetLocalInt(oPC, "PRC_AllSpell"+IntToString(nSpellLevel), 0);
SetLocalInt(oPC, "PRC_ArcSpell"+IntToString(nSpellLevel), 0);
if(nSpellLevel > nArcHighest)
nArcHighest = nSpellLevel;
// if(DEBUG) DoDebug ("Arcane Prereq Variable " + IntToString(nSpellLevel) +": " + IntToString(GetLocalInt(oPC, "PRC_ArcSpell"+IntToString(nSpellLevel))), oPC);
// if(DEBUG) DoDebug ("All Prereq Variable " + IntToString(nSpellLevel) +": " + IntToString(GetLocalInt(oPC, "PRC_AllSpell"+IntToString(nSpellLevel))), oPC);
}
}
}
else if(GetIsPsionicClass(nClass))
{
int nLevel = GetLevelByClass(nClass, oPC);
/* if (!bFirstPsiClassFound &&
GetPrimaryPsionicClass(oPC) == nClass)
{ */
nLevel += GetPsionicPRCLevels(oPC, nClass);
bFirstPsiClassFound = TRUE;
//}
int nAbility = GetAbilityScoreForClass(nClass, oPC);
string sPsiFile = GetAMSKnownFileName(nClass);
int nMaxLevel = StringToInt(Get2DACache(sPsiFile, "MaxPowerLevel", nLevel));
int nPsiHighest = min(nMaxLevel, nAbility - 10);
for(nSpellLevel = 1; nSpellLevel <= nPsiHighest; nSpellLevel++)
{
SetLocalInt(oPC, "PRC_PsiPower"+IntToString(nSpellLevel), 0);
//if(DEBUG) DoDebug("Psionics power level Prereq Variable " + IntToString(nSpellLevel) +": " + IntToString(GetLocalInt(oPC, "PRC_PsiPower"+IntToString(nSpellLevel))), oPC);
}
}
else if(GetIsShadowMagicClass(nClass))
{
int nLevel = GetLevelByClass(nClass, oPC);
if (!bFirstShdClassFound &&
GetPrimaryShadowMagicClass(oPC) == nClass)
{
nLevel += GetShadowMagicPRCLevels(oPC);
bFirstShdClassFound = TRUE;
}
int nAbility = GetAbilityScoreForClass(nClass, oPC);
string sShdFile = GetAMSKnownFileName(nClass);
int nShdHighest = max(GetMaxMysteryLevelLearnable(oPC, nClass, 1), GetMaxMysteryLevelLearnable(oPC, nClass, 2));
nShdHighest = max(nShdHighest, GetMaxMysteryLevelLearnable(oPC, nClass, 3));
for(nSpellLevel = 1; nSpellLevel <= nShdHighest; nSpellLevel++)
{
SetLocalInt(oPC, "PRC_MystLevel"+IntToString(nSpellLevel), 0);
//if(DEBUG) DoDebug("Shadowcasting mystery level Prereq Variable " + IntToString(nSpellLevel) +": " + IntToString(GetLocalInt(oPC, "PRC_MystLevel"+IntToString(nSpellLevel))), oPC);
}
}
}// end while - loop over all 8 class slots
// special alignment requirements
reqAlignment(oPC);
// special gender requirements
reqGender();
// Find the sneak attack/skirmish capacity.
reqSpecialAttack(oPC);
// Cleric domain requirements
if(GetLevelByClass(CLASS_TYPE_CLERIC))
reqDomains();
// Special requirements for several classes.
AOTSPreReqs(oPC);
AbChamp(oPC);
AnimaMageReq(oPC);
Cultist(oPC);
DalQuor(oPC);
DemiLich(oPC);
DragDisciple(oPC);
DragonDevotee(oPC);
Dragonheart(oPC);
EnlF(oPC);
Incarnate(oPC);
Ironsoul(oPC);
KOTC(oPC);
KnightWeave(oPC);
Kord(oPC);
LichPrereq(oPC);
Maester(oPC);
Necrocarnum(oPC);
Ocular(oPC);
Purifier(oPC);
Pyro(oPC);
RacialHD(oPC);
RedWizard(oPC);
SapphireHierarch(oPC);
ScionReq(oPC);
Shadowbane(oPC);
Shadowlord(oPC, nArcHighest);
Shadowmind(oPC);
Shifter(oPC, nArcHighest, nDivHighest);
SoulEater(oPC);
SoulcasterReq(oPC);
Spinemeld(oPC);
Suel();
Tempest();
TenebrousReq(oPC);
Thrallherd(oPC);
TomeOfBattle(oPC);
TotemRager(oPC);
UMagus(oPC);
UrPriest(oPC);
Virtuoso(oPC);
WWolf(oPC);
WarlockPrCs(oPC);
WildMageReq(oPC);
Witchborn(oPC);
reqCombatMedic(oPC);
// Truly massive debug message flood if activated.
/* if (DEBUG)
{
string sPRC_AllSpell;
string sPRC_ArcSpell;
string sPRC_DivSpell;
string sPRC_PsiPower;
string sPRC_ShdMyst;
for (iCount = 1; iCount <= 9; iCount++)
{
sPRC_AllSpell = "PRC_AllSpell" + IntToString(iCount);
sPRC_ArcSpell = "PRC_ArcSpell" + IntToString(iCount);
sPRC_DivSpell = "PRC_DivSpell" + IntToString(iCount);
sPRC_PsiPower = "PRC_PsiPower" + IntToString(iCount);
sPRC_ShdMyst = "PRC_MystLevel" + IntToString(iCount);
SendMessageToPC(oPC, sPRC_AllSpell + " is " + IntToString(GetLocalInt(oPC, sPRC_AllSpell)) + ". " +
sPRC_ArcSpell + " is " + IntToString(GetLocalInt(oPC, sPRC_ArcSpell)) + ". " +
sPRC_DivSpell + " is " + IntToString(GetLocalInt(oPC, sPRC_DivSpell)) + ". " +
sPRC_PsiPower + " is " + IntToString(GetLocalInt(oPC, sPRC_PsiPower)) + ". " +
sPRC_ShdMyst + " is " + IntToString(GetLocalInt(oPC, sPRC_ShdMyst)) + ".");
}
for (iCount = 1; iCount <= 30; iCount++)
{
sVariable = "PRC_SneakLevel" + IntToString(iCount);
SendMessageToPC(oPC, sVariable + " is " + IntToString(GetLocalInt(oPC, sVariable)) + ".");
}
} */
}
Reference in New Issue View Git Blame Copy Permalink