Skins: |
NWN SCRIPTS

- Jump to comments -
Title
UMD fix type 2 (User friendlier)
Author
Webscav
Submitted / Updated
03-17-2003 / 11-22-2006
Category
Rulesets
Expansions
Works on all versions
View Code
//::///////////////////////////////////////////////
//:: Cast Check
//:: web_cast.nss
//:://////////////////////////////////////////////
/*
Used to check for spell failure when reading off a
scroll in order to attept to simulate 3rd ed rules.
This also will check for prerequisite scores and
other such things.
*/
//:://////////////////////////////////////////////
//:: Created By: Chris Duemling
//:: Created On: March 7th, 2003
//:://////////////////////////////////////////////

//::///////////////////////////////////////////////
//:: GetAbProb
//:://////////////////////////////////////////////
/*
Give a percentage chance of sucessfully casting a
scroll of spell level nSLvl with a UMd score of
nUMD.
*/
//:://////////////////////////////////////////////
//:: Created By: Chris Duemling
//:: Created On: March 17th, 2003
//:://////////////////////////////////////////////
float GetAbProb(int nUMD, int nSLvl)
{
    float fChance = IntToFloat(nUMD + 11 - nSLvl) * 0.05;
    if (fChance > 1.0) fChance = 1.0;
    if (fChance < 0.0) fChance = 0.0;
    return fChance;
}

//::///////////////////////////////////////////////
//:: GetProb
//:://////////////////////////////////////////////
/*
Give a percentage chance of sucessfully casting a
scroll of caster level nLvl with a UMD score of
nUMD.
*/
//:://////////////////////////////////////////////
//:: Created By: Chris Duemling
//:: Created On: March 17th, 2003
//:://////////////////////////////////////////////
float GetProb(int nUMD, int nLvl)
{
    int x = 1;
    float fChance = 0.0;
    if (nUMD >= nLvl + 20) return 1.0;
    while (x < 21)
    {
        if (nUMD + x - 20 >= nLvl)
            fChance = fChance + 0.05;
        else if (nUMD + x - 20 >= nLvl - 19 && nUMD + x >= 20)
            fChance = fChance + (0.05 * IntToFloat(nUMD + x - nLvl)) * 0.05;
        x++;
    }
    return fChance;
}

//::///////////////////////////////////////////////
//:: GetChance
//:://////////////////////////////////////////////
/*
Give a percentage chance of sucessfully casting
from a scroll, staff or wand.
-nLvl: The level of the caster
-nCLvl: The caster level of the item
-nSLvl: The spell level
-nAtt: The relevant attribute (Int, Wis, Cha)
-nUMD: The UMD score of the item activator
-nAbility: TURE if it is a scroll, FALSE if not
-nAlign: TRUE if it is a paladin based casting
*/
//:://////////////////////////////////////////////
//:: Created By: Chris Duemling
//:: Created On: March 17th, 2003
//:://////////////////////////////////////////////
float GetChance(int nLvl, int nCLvl, int nSLvl, int nAtt, int nUMD, int nAbility, int nAlign=FALSE)
{
    float fChance = 0.0;
    if(nSLvl != -1) {
        if(nAtt >= nSLvl + 10 || !nAbility) {
            if (nLvl >= nCLvl) {
                fChance = 1.0;
            }
            else if(nUMD > 0) {
                if(!nAbility) {
                    fChance = GetProb(nUMD, nCLvl);
                }
                else {
                    fChance = IntToFloat(nUMD) * 0.05;
                    if (fChance > 1.0) fChance = 1.0;
                }
            }
            if (nLvl != 0) {
                if ((fChance < (IntToFloat(20 - nCLvl + nLvl) * 0.05)) && nAbility) {
                    fChance = IntToFloat(20 - nCLvl + nLvl) * 0.05;
                    if(fChance > 1.0) fChance = 1.0;
                }
                else if (!nAbility) fChance = 1.0;
            }
        }
        else if(nUMD > 0) {
            fChance = 1.0;
            if (nLvl < nCLvl) {
                fChance = GetProb(nUMD, nCLvl);
            }
            fChance = fChance * GetAbProb(nUMD, nSLvl);
        }
    }
    if(nAlign) {
        fChance = fChance * GetAbProb(nUMD, 5); } // Same as emulating a 15
    return fChance;
}

//::///////////////////////////////////////////////
//:: CastCheck
//:://////////////////////////////////////////////
/*
Checks to see if spell can be cast
- nBrd: Spell level for bards
- nClr: Spell level for clerics
- nDrd: Spell level for druids
- nPal: Spell level for paladins
- nRgr: Spell level for rangers
- nWiz: Spell level for sorcerers and wizards
- nSchool: reserved for later date
returns 1 if spell is sucessfully cast, 0 if it fails or if a mishap occurs.

*** This is the function that you should call from your spell script ***
*/
//:://////////////////////////////////////////////
//:: Created By: Chris Duemling
//:: Created On: March 17th, 2003
//:://////////////////////////////////////////////
int CastCheck(int nBrd, int nClr, int nDrd, int nPal, int nRgr, int nWiz, int nSchool=0)
{
    int nRoll;

    //No object means automatically cast right (duh!)
    object oItem = GetSpellCastItem();
    if(!GetIsObjectValid(oItem))
        return 1;
    object oCaster = GetItemPossessor(oItem);

    // Check the item type and see if it needs ability
    int nAbility = FALSE;
    if(GetBaseItemType(oItem) == BASE_ITEM_SPELLSCROLL) nAbility = TRUE;
    else if(GetBaseItemType(oItem) == BASE_ITEM_MAGICSTAFF) nAbility = FALSE;
    else if(GetBaseItemType(oItem) == BASE_ITEM_MAGICWAND) nAbility = FALSE;
    else return 1; //generic items

    //Get the relavent ability scores
    int Wis = GetAbilityScore(oCaster, ABILITY_WISDOM);
    int Int = GetAbilityScore(oCaster, ABILITY_INTELLIGENCE);
    int Cha = GetAbilityScore(oCaster, ABILITY_CHARISMA);

    //Get the relavent levels
    int nBrd2 = GetLevelByClass(CLASS_TYPE_BARD, oCaster);
    int nClr2 = GetLevelByClass(CLASS_TYPE_CLERIC, oCaster);
    int nDrd2 = GetLevelByClass(CLASS_TYPE_DRUID, oCaster);
    int nPal2 = GetLevelByClass(CLASS_TYPE_PALADIN, oCaster) / 2;
    if (nPal2 < 2) nPal2 = 0;
    int nRgr2 = GetLevelByClass(CLASS_TYPE_RANGER, oCaster) / 2;
    if (nRgr2 < 2) nRgr2 = 0;
    int nSoc2 = GetLevelByClass(CLASS_TYPE_SORCERER, oCaster);
    int nWiz2 = GetLevelByClass(CLASS_TYPE_WIZARD, oCaster);

    //Figure modifier for magic domain
    int nMagic = 0;
    if (GetHasFeat(FEAT_MAGIC_DOMAIN_POWER, oCaster)) {
        nMagic = GetLevelByClass(CLASS_TYPE_CLERIC, oCaster) / 2;
        if(!nMagic) nMagic = 1;
        nWiz2 += nMagic;
    }

    // Get the UMD skill
    int nUMD = GetSkillRank(SKILL_USE_MAGIC_DEVICE, oCaster);
    int nRog = GetLevelByClass(CLASS_TYPE_ROGUE, oCaster);
    if(nUMD > nRog + nBrd2 + GetAbilityModifier(ABILITY_CHARISMA) + 3) {
        nUMD = nRog + nBrd2 + GetAbilityModifier(ABILITY_CHARISMA) + 3;
        if (GetHasFeat(FEAT_SKILL_FOCUS_USE_MAGIC_DEVICE, oCaster)) nUMD +=4;
    }

    // Get the caster level of the item
    int nLvl = GetCasterLevel(OBJECT_SELF);

    // Get the user's alignment
    int nGood = FALSE;
    if (GetAlignmentGoodEvil(oCaster) > 70)
        nGood = TRUE;

    // Figure out the probablity of sucess for each class
    float fBrd = GetChance(nBrd2, nLvl, nBrd, Cha, nUMD, nAbility);
    float fClr = GetChance(nClr2, nLvl, nClr, Wis, nUMD, nAbility);
    float fDrd = GetChance(nDrd2, nLvl, nDrd, Wis, nUMD, nAbility);
    float fPal = GetChance(nPal2, nLvl, nPal, Wis, nUMD, nAbility, !nGood);
    float fRgr = GetChance(nRgr2, nLvl, nRgr, Wis, nUMD, nAbility);
    float fSoc = GetChance(nSoc2, nLvl, nWiz, Cha, nUMD, nAbility);
    float fWiz = GetChance(nWiz2, nLvl, nWiz, Int, nUMD, nAbility);

    // Check for automatic sucess
    if (fBrd == 1.0) return 1;
    if (fClr == 1.0) return 1;
    if (fDrd == 1.0) return 1;
    if (fPal == 1.0) return 1;
    if (fRgr == 1.0) return 1;
    if (fSoc == 1.0) return 1;
    if (fWiz == 1.0) return 1;

    // Check to see what class would be best to try it as
    float fChance = 0.0;
    int nClass = 0;
    if (fBrd > fChance) nClass = 1;
    if (fClr > fChance) nClass = 2;
    if (fDrd > fChance) nClass = 3;
    if (fPal > fChance) nClass = 4;
    if (fRgr > fChance) nClass = 5;
    if (fSoc > fChance) nClass = 6;
    if (fWiz > fChance) nClass = 7;

    //Check for no chance for success
    if (nClass == 0) return 0;

    // Figure what needs to be emulated
    int nUMD1 = 0; // Level
    int nUMD2 = 0; // Stats: 1 = Wis, 2 = Int, 3 = Cha
    int nUMD3 = 0; // Alignment
    if (nClass == 1) { // Bard
        if (nBrd2 < nLvl) nUMD1 = 1;
        if (nBrd2 > 0 && !nAbility) nUMD1 = 0;
        if (nBrd2 != 0 && IntToFloat(nBrd2 + 20 - nLvl) * 0.05 > GetProb(nUMD, nLvl)) nUMD1 = 0;
        if (Cha < nBrd + 10) nUMD2 = 3;
    }
    if (nClass == 2) { // Cleric
        if (nClr2 < nLvl) nUMD1 = 1;
        if (nClr2 > 0 && !nAbility) nUMD1 = 0;
        if (nClr2 != 0 && IntToFloat(nClr2 + 20 - nLvl) * 0.05 > GetProb(nUMD, nLvl)) nUMD1 = 0;
        if (Wis < nClr + 10) nUMD2 = 1;
    }
    if (nClass == 3) { // Druid
        if (nDrd2 < nLvl) nUMD1 = 1;
        if (nDrd2 > 0 && !nAbility) nUMD1 = 0;
        if (nDrd2 != 0 && IntToFloat(nDrd2 + 20 - nLvl) * 0.05 > GetProb(nUMD, nLvl)) nUMD1 = 0;
        if (Wis < nDrd + 10) nUMD2 = 1;
    }
    if (nClass == 4) { // Paladin
        if (nPal2 < nLvl) nUMD1 = 1;
        if (nPal2 > 0 && !nAbility) nUMD1 = 0;
        if (nPal2 != 0 && IntToFloat(nPal2 + 20 - nLvl) * 0.05 > GetProb(nUMD, nLvl)) nUMD1 = 0;
        if (Wis < nPal + 10) nUMD2 = 1;
        if (!nGood) nUMD3 = 1;
    }
    if (nClass == 5) { // Ranger
        if (nRgr2 < nLvl) nUMD1 = 1;
        if (nRgr2 > 0 && !nAbility) nUMD1 = 0;
        if (nRgr2 != 0 && IntToFloat(nRgr2 + 20 - nLvl) * 0.05 > GetProb(nUMD, nLvl)) nUMD1 = 0;
        if (Wis < nRgr + 10) nUMD2 = 1;
    }
    if (nClass == 6) { // Sorcerer
        if (nSoc2 < nLvl) nUMD1 = 1;
        if (nSoc2 > 0 && !nAbility) nUMD1 = 0;
        if (nSoc2 != 0 && IntToFloat(nSoc2 + 20 - nLvl) * 0.05 > GetProb(nUMD, nLvl)) nUMD1 = 0;
        if (Cha < nWiz + 10) nUMD2 = 3;
    }
    if (nClass == 7) { // Wizard
        if (nWiz2 < nLvl) nUMD1 = 1;
        if (nWiz2 > 0 && !nAbility) nUMD1 = 0;
        if (nWiz2 != 0 && IntToFloat(nWiz2 + 20 - nLvl) * 0.05 > GetProb(nUMD, nLvl)) nUMD1 = 0;
        if (Int < nWiz + 10) nUMD2 = 2;
    }

    // Figure emulated caster level if neccisary
    int nFL = -1;
    if (nUMD1) {
        nRoll = d20();
        nFL = nUMD + nRoll - 20;
        if(nFL >= 0)
            SendMessageToPC(oCaster, "Use Magic Device check to emulate spell ability: " + IntToString(nRoll) + " + " + IntToString(nUMD) + " = " + IntToString(nUMD + nRoll) + " vs. DC 20 *Success*: Caster level " + IntToString(nFL) + " emulated.");
        else if (nFL <= -10) {
            SendMessageToPC(oCaster, "Use Magic Device check to emulate spell ability: " + IntToString(nRoll) + " + " +  IntToString(nUMD) + " = " + IntToString(nUMD + nRoll) + " vs. DC 20 *Failure*: Mishap caused.");
            effect eDam = EffectDamage(d6(2));
            ApplyEffectToObject(DURATION_TYPE_INSTANT, eDam, oCaster);
            return 0;
            }
        else {
            SendMessageToPC(oCaster, "Use Magic Device check to emulate spell ability: " + IntToString(nRoll) + " + " +  IntToString(nUMD) + " = " + IntToString(nUMD + nRoll) + " vs. DC 20 *Failure*");
            nRoll = d20();
            if(GetAbilityModifier(ABILITY_WISDOM, oCaster) + nRoll < 5 || nRoll == 1 && nAbility) {
                SendMessageToPC(oCaster, "Scroll mishap: " + IntToString(nRoll) + " + " + IntToString(GetAbilityModifier(ABILITY_WISDOM, oCaster)) + " = " + IntToString(GetAbilityModifier(ABILITY_WISDOM, oCaster) + nRoll) + " vs. DC 5 *Failure*");
                effect eDam = EffectDamage(d6(2));
                ApplyEffectToObject(DURATION_TYPE_INSTANT, eDam, oCaster);
                return 0;
                }
            else if (nAbility) {
                SendMessageToPC(oCaster, "Scroll mishap: " + IntToString(nRoll) + " + " + IntToString(GetAbilityModifier(ABILITY_WISDOM, oCaster)) + " = " + IntToString(GetAbilityModifier(ABILITY_WISDOM, oCaster) + nRoll) + " vs. DC 5 *Success*");
                return 0;
                }
            }
    }

    // Figure emulated ability if neccisary
    int nFA = -1;
    if (nUMD2 > 0 && nAbility) {
        nRoll = d20();
        nFA = nUMD + nRoll - 15;
        if (nFA < 1) nFA = -1;
        if (nFA < 10) nFA = 0;
        if(nFA > 0) {
            string sTemp = "Use Magic Device check to emulate ability score: " + IntToString(nRoll) + " + " +  IntToString(nUMD) + " = " + IntToString(nUMD + nRoll) + " vs. DC 25 *Success*: ";
            if (nUMD2 == 1) SendMessageToPC(oCaster, sTemp + "Wisdom score of " + IntToString(nFA) + " emulated.");
            if (nUMD2 == 2) SendMessageToPC(oCaster, sTemp + "Intelligence score of " + IntToString(nFA) + " emulated.");
            if (nUMD2 == 3) SendMessageToPC(oCaster, sTemp + "Charisma score of " + IntToString(nFA) + " emulated.");
            }
        else if (nFA == -1) {
            SendMessageToPC(oCaster, "Use Magic Device check to emulate ability score: " + IntToString(nRoll) + " + " +  IntToString(nUMD) + " = " + IntToString(nUMD + nRoll) + " vs. DC 25 *Failure*: Mishap caused");
            effect eDam = EffectDamage(d6(2));
            ApplyEffectToObject(DURATION_TYPE_INSTANT, eDam, oCaster);
            return 0;
            }
        else {
            SendMessageToPC(oCaster, "Use Magic Device check to emulate ability score: " + IntToString(nRoll) + " + " +  IntToString(nUMD) + " = " + IntToString(nUMD + nRoll) + " vs. DC 25 *Failure*");
            return 0;
            }
    }

    // Check if emulated ability is high enough
    int nCheck = 0;
    switch (nClass)
    {
        case 1: if(nFA < nBrd + 10) nCheck = nBrd + 10; break;
        case 2: if(nFA < nClr + 10) nCheck = nClr + 10; break;
        case 3: if(nFA < nDrd + 10) nCheck = nDrd + 10; break;
        case 4: if(nFA < nPal + 10) nCheck = nPal + 10; break;
        case 5: if(nFA < nRgr + 10) nCheck = nRgr + 10; break;
        case 6: if(nFA < nWiz + 10) nCheck = nWiz + 10; break; // Sorcerer
        case 7: if(nFA < nWiz + 10) nCheck = nWiz + 10; break; // Wizard
    }
    if (nCheck > 0 && nUMD2 > 0) {
        SendMessageToPC(oCaster, "Your spell fails however since you needed to emulate a score of " + IntToString(nCheck) + " or higher.");
        nRoll = d20();
        if(GetAbilityModifier(ABILITY_WISDOM, oCaster) + nRoll < 5 || nRoll == 1) {
            SendMessageToPC(oCaster, "Scroll mishap: " + IntToString(nRoll) + " + " + IntToString(GetAbilityModifier(ABILITY_WISDOM, oCaster)) + " = " + IntToString(GetAbilityModifier(ABILITY_WISDOM, oCaster) + nRoll) + " vs. DC 5 *Failure*");
            effect eDam = EffectDamage(d6(2));
            ApplyEffectToObject(DURATION_TYPE_INSTANT, eDam, oCaster);
            return 0;
            }
        else {
            SendMessageToPC(oCaster, "Scroll mishap: " + IntToString(nRoll) + " + " + IntToString(GetAbilityModifier(ABILITY_WISDOM, oCaster)) + " = " + IntToString(GetAbilityModifier(ABILITY_WISDOM, oCaster) + nRoll) + " vs. DC 5 *Success*");
            return 0;
            }
    }

    // Check alignment emulation if neccisary
    if(nUMD3) {
        nRoll = d20();
        if (nUMD + nRoll > 30) {
            SendMessageToPC(oCaster, "Use Magic Device check to emulate alignment: " + IntToString(nRoll) + " + " +  IntToString(nUMD) +  " = " + IntToString(nUMD + nRoll) +" vs. DC 30 *Success*");
            }
        else if (nUMD + nRoll < 21) {
            SendMessageToPC(oCaster, "Use Magic Device check to emulate alignment: " + IntToString(nRoll) + " + " +  IntToString(nUMD) +  " = " + IntToString(nUMD + nRoll) +" vs. DC 30 *Failure*: Mishap caused");
            effect eDam = EffectDamage(d6(2));
            ApplyEffectToObject(DURATION_TYPE_INSTANT, eDam, oCaster);
            return 0;
            }
        else {
            SendMessageToPC(oCaster, "Use Magic Device check to emulate alignment: " + IntToString(nRoll) + " + " +  IntToString(nUMD) +  " = " + IntToString(nUMD + nRoll) +" vs. DC 30 *Failure*");
            nRoll = d20();
            if(GetAbilityModifier(ABILITY_WISDOM, oCaster) + nRoll < 5 || nRoll == 1 && nAbility) {
                SendMessageToPC(oCaster, "Scroll mishap: " + IntToString(nRoll) + " + " + IntToString(GetAbilityModifier(ABILITY_WISDOM, oCaster)) + " = " + IntToString(GetAbilityModifier(ABILITY_WISDOM, oCaster) + nRoll) + " vs. DC 5 *Failure*");
                effect eDam = EffectDamage(d6(2));
                ApplyEffectToObject(DURATION_TYPE_INSTANT, eDam, oCaster);
                return 0;
                }
            else if (nAbility) {
                SendMessageToPC(oCaster, "Scroll mishap: " + IntToString(nRoll) + " + " + IntToString(GetAbilityModifier(ABILITY_WISDOM, oCaster)) + " = " + IntToString(GetAbilityModifier(ABILITY_WISDOM, oCaster) + nRoll) + " vs. DC 5 *Success*");
                return 0;
                }
            }
    }

    // Staves and wands have completed all thier tests
    if(GetBaseItemType(oItem) == BASE_ITEM_MAGICSTAFF) return 1;
    if(GetBaseItemType(oItem) == BASE_ITEM_MAGICWAND) return 1;

    // Scroll
    if(GetBaseItemType(oItem) == BASE_ITEM_SPELLSCROLL){

        nCheck = 0;

        // Get the character's casting level
        if(nFL > -1) nCheck = nFL;
        else
            switch (nClass)
            {
                case 1: nCheck = nBrd2; break;
                case 2: nCheck = nClr2; break;
                case 3: nCheck = nDrd2; break;
                case 4: nCheck = nPal2; break;
                case 5: nCheck = nRgr2; break;
                case 6: nCheck = nSoc2; break;
                case 7: nCheck = nWiz2; break;
            }

        // Get the difference in levels
        nCheck = nLvl - nCheck;

        // Check for no difference
        if (nCheck <= 0) return 1;

        // Check for a difference of over 19
        if (nCheck >= 20) return 0;

        // Check to see if the spell is sucessfully cast
        nRoll = d20();
        if (nRoll <= nCheck) {
            SendMessageToPC(oCaster, "Caster level check: " + IntToString(nRoll) + " + " + IntToString(nLvl - nCheck) + " = " + IntToString(nLvl - nCheck + nRoll) + " vs. DC " + IntToString(nLvl + 1) + " *Failure*");
            nRoll = d20();
            if(GetAbilityModifier(ABILITY_WISDOM, oCaster) + nRoll < 5 || nRoll == 1) {
                SendMessageToPC(oCaster, "Scroll mishap: " + IntToString(nRoll) + " + " + IntToString(GetAbilityModifier(ABILITY_WISDOM, oCaster)) + " = " + IntToString(GetAbilityModifier(ABILITY_WISDOM, oCaster) + nRoll) + " vs. DC 5 *Failure*");
                effect eDam = EffectDamage(d6(2));
                ApplyEffectToObject(DURATION_TYPE_INSTANT, eDam, oCaster);
                return 0;
                }
            else {
                SendMessageToPC(oCaster, "Scroll mishap: " + IntToString(nRoll) + " + " + IntToString(GetAbilityModifier(ABILITY_WISDOM, oCaster)) + " = " + IntToString(GetAbilityModifier(ABILITY_WISDOM, oCaster) + nRoll) + " vs. DC 5 *Success*");
                return 0;
                }
         }
         else {
             SendMessageToPC(oCaster, "Caster level check: " + IntToString(nRoll) + " + " + IntToString(nLvl - nCheck) + " = " + IntToString(nLvl - nCheck + nRoll) + " vs. DC " + IntToString(nLvl + 1) + " *Success*");
             return 1;
             }

    } // end of scroll

    return 1;
}
Select All Text | View Code in separate window
Format
Code Only
Type
Type - Classic PnP
Includes
None
Description
You have to include this code snippet in all of your spell files in order for this to work. Substitue the spell level that this spell is for bards for a, clerics for b, druids for c, paladins for d, rangers for e and sorcerers/wizards for f. #include 'web_cast2' void main() { int nCheck = CastCheck(a, b, c, d, e, f); //UMD Check if(nCheck == 0) return; // Failure check