Further file organization

Further file organization

nwn/nwnprc/trunk/smp/smp_inc_turning.nss

@@ -0,0 +1,282 @@
+/*:://////////////////////////////////////////////
+//:: Name Spell Turning Include
+//:: FileName SMP_INC_TURNING
+//:://////////////////////////////////////////////
+    This includes the functions to let spells turn back from the target
+    to the caster!
+
+    From 3.5 rules:
+
+    Spell Turning
+    Abjuration
+    Level: Luck 7, Magic 7, Sor/Wiz 7
+    Components: V, S, M/DF
+    Casting Time: 1 standard action
+    Range: Personal
+    Target: You
+    Duration: Until expended or 10 min./level
+
+    Spells and spell-like effects targeted on you are turned back upon the
+    original caster. The abjuration turns only spells that have you as a target.
+    Effect and area spells are not affected. Spell turning also fails to stop
+    touch range spells.
+
+    From seven to ten (1d4+6) spell levels are affected by the turning. The
+    exact number is rolled secretly.
+
+    When you are targeted by a spell of higher level than the amount of spell
+    turning you have left, that spell is partially turned. The subtract the
+    amount of spell turning left from the spell level of the incoming spell,
+    then divide the result by the spell level of the incoming spell to see what
+    fraction of the effect gets through. For damaging spells, you and the caster
+    each take a fraction of the damage. For nondamaging spells, each of you has
+    a proportional chance to be affected.
+
+    If you and a spellcasting attacker are both warded by spell turning effects
+    in operation, a resonating field is created.
+
+    Roll randomly to determine the result.
+
+    d%          Effect
+    01-70       Spell drains away without effect.
+    71-80       Spell affects both of you equally at full effect.
+    81-97       Both turning effects are rendered nonfunctional for 1d4 minutes.
+    98-100      Both of you go through a rift into another plane.
+
+    Arcane Material Component: A small silver mirror.
+
+//:://////////////////////////////////////////////
+//:: Created By: Jasperre
+//:: Created On: October
+//::////////////////////////////////////////////*/
+
+// Note: Need to complete
+
+const string SMP_SPELL_TURNING_TEMP_OFF = "SMP_SPELL_TURNING_TEMP_OFF";
+const string SMP_SPELL_TURNING_AMOUNT   = "SMP_SPELL_TURNING_AMOUNT";
+const string SMP_SPELL_TURNING_FRACTION = "SMP_SPELL_TURNING_FRACTION";
+const string SMP_RIFT_TARGET            = "SMP_RIFT_TARGET";
+
+#include "SMP_INC_CONSTANT"
+
+// SMP_INC_TURNING. This checks for the spell "Spell Turning" and does a check
+// based on it. Each spell has to be done on a case-by-case basis.
+// It will return:
+// 0 = No effect - (EG: Not present), should affect target normally.
+// 1 = Spell drains away without effect.
+//     (Can be: Both turning effects are rendered nonfunctional for 1d4 minutes.)
+//     (Can be: Both of you go through a rift into another plane.)
+// 2 = Affect the caster only, full power.
+// 3 = Affects the caster OR the target, a % type thing. Set on local that can be
+//     retrieved. If damaging, part damage each. If not, % chance to affect either.
+// 4 = Spell affects both people equally at full effect.
+// * The remaing power is automatically decreased.
+int SMP_SpellTurningCheck(object oCaster, object oTarget, int nSpellLevel, float fDelay = 0.0);
+
+// SMP_INC_TURNING. Remove all effects from SMP_SPELL_SPELL_TURNING
+void SMP_SpellTurningRemoveSpellTurning(object oTarget);
+
+// SMP_INC_TURNING. Sends both players to the rift, IF THERE IS ONE.
+// * TRUE if they are moved to the rift.
+int SMP_SpellTurningMoveToRift(object oCaster, object oTarget);
+
+// SMP_INC_TURNING. Renders both non-functional for the time
+void SMP_SpellTurningRenderTurningUnfunctonal(object oCaster, object oTarget);
+
+// SMP_INC_TURNING. Decreases the stored integer by 1
+// * Deletes if it would be 0.
+void SMP_SpellTurningReduceInteger(object oTarget, string sStored);
+
+// This checks for the spell "Spell Turning" and does a check
+// based on it. Each spell has to be done on a case-by-case basis.
+// It will return:
+// 0 = No effect - (EG: Not present), should affect target normally.
+// 1 = Spell drains away without effect.
+//     (Can be: Both turning effects are rendered nonfunctional for 1d4 minutes.)
+//     (Can be: Both of you go through a rift into another plane.)
+// 2 = Affect the caster only, full power.
+// 3 = Affects the caster OR the target, a % type thing. Set on local that can be
+//     retrieved. If damaging, part damage each. If not, % chance to affect either.
+// 4 = Spell affects both people equally at full effect.
+// * The remaing power is automatically decreased.
+int SMP_SpellTurningCheck(object oCaster, object oTarget, int nSpellLevel, float fDelay = 0.0)
+{
+    // Does the target have the effects
+    if(GetHasSpellEffect(SMP_SPELL_SPELL_TURNING, oTarget) &&
+      !GetLocalInt(oTarget, SMP_SPELL_TURNING_TEMP_OFF))
+    {
+        // We first check if they already have spell turning too (and it is
+        // activated) If so, will maybe do one of 4 random things!
+        if(GetHasSpellEffect(SMP_SPELL_SPELL_TURNING, oCaster) &&
+          !GetLocalInt(oCaster, SMP_SPELL_TURNING_TEMP_OFF))
+        {
+/*
+    d%          Effect
+    01-70       Spell drains away without effect.
+    71-80       Spell affects both of you equally at full effect.
+    81-97       Both turning effects are rendered nonfunctional for 1d4 minutes.
+    98-100      Both of you go through a rift into another plane.
+*/
+            // Roll dice
+            int nDice = d100();
+
+            // "Spell drains away without effect." - return 1
+            if(nDice <= 70)
+            {
+                return 1;
+            }
+            // "Spell affects both of you equally at full effect." - return 4
+            else if(nDice <= 80)
+            {
+                return 4;
+            }
+            // "Both turning effects are rendered nonfunctional for 1d4 minutes." - return 1
+            else if(nDice <= 97)
+            {
+                // We set an integer for a cirain amount of time
+                SMP_SpellTurningRenderTurningUnfunctonal(oCaster, oTarget);
+                return 1;
+            }
+            // "Both of you go through a rift into another plane." - return 1
+            else //if(nDice <= 100)
+            {
+                // Use function
+                SMP_SpellTurningMoveToRift(oCaster, oTarget);
+                return 1;
+            }
+        }
+        // Must be, of course, not a cantrip
+        else if(nSpellLevel > 0)
+        {
+            // Normal spell turning!
+            int nTurnPower = GetLocalInt(oTarget, SMP_SPELL_TURNING_AMOUNT);
+
+            // Get new power - this minus spell level
+            int nNewPower = nTurnPower - nSpellLevel;
+
+            // Remove now, if <= 0
+            if(nNewPower <= 0)
+            {
+                // Remove it
+                SMP_SpellTurningRemoveSpellTurning(oTarget);
+            }
+
+            // We check the spell power
+            if(nNewPower >= 0)
+            {
+                // If we have any normal left, we "rebound" normally...
+                // return 2 - Affect the caster only, full power.
+                return 2;
+            }
+            else //if(nNewPower < 0)
+            {
+/*              Must be a fraction.
+    When you are targeted by a spell of higher level than the amount of spell
+    turning you have left, that spell is partially turned. The subtract the
+    amount of spell turning left from the spell level of the incoming spell,
+    then divide the result by the spell level of the incoming spell to see what
+    fraction of the effect gets through. For damaging spells, you and the caster
+    each take a fraction of the damage. For nondamaging spells, each of you has
+    a proportional chance to be affected.
+*/
+                // Divide by spell level
+                float fFraction = IntToFloat(nNewPower) / IntToFloat(nSpellLevel);
+
+                // Set it
+                SetLocalFloat(oCaster, SMP_SPELL_TURNING_FRACTION, fFraction);
+
+// 3 = Affects the caster OR the target, a % type thing. Set on local that can be
+//     retrieved. If damaging, part damage each. If not, % chance to affect either.
+                return 3;
+            }
+        }
+        else
+        {
+            // Can trip, always stop
+            // return 2 - Affect the caster only, full power.
+            return 2;
+        }
+    }
+    // Return nothing - error
+    return FALSE;
+}
+
+// Remove all effects from SMP_SPELL_SPELL_TURNING
+void SMP_SpellTurningRemoveSpellTurning(object oTarget)
+{
+    //Declare major variables
+    effect eCheck = GetFirstEffect(oTarget);;
+    //Search through the valid effects on the target.
+    while(GetIsEffectValid(eCheck))
+    {
+        //If the effect was created by the spell then remove it
+        if(GetEffectSpellId(eCheck) == SMP_SPELL_SPELL_TURNING)
+        {
+            RemoveEffect(oTarget, eCheck);
+        }
+        //Get next effect on the target
+        eCheck = GetNextEffect(oTarget);
+    }
+}
+
+// Sends both players to the rift, IF THERE IS ONE.
+// * TRUE if they are moved to the rift.
+int SMP_SpellTurningMoveToRift(object oCaster, object oTarget)
+{
+    object oWP = GetObjectByTag(SMP_RIFT_TARGET);
+    if(GetIsObjectValid(oWP))
+    {
+        location lWP = GetLocation(oWP);
+        // Move the caster
+        AssignCommand(oCaster, ClearAllActions());
+        AssignCommand(oCaster, JumpToLocation(lWP));
+        // Move the target
+        AssignCommand(oTarget, ClearAllActions());
+        AssignCommand(oTarget, JumpToLocation(lWP));
+        return TRUE;
+    }
+    return FALSE;
+}
+
+
+// Renders both non-functional for the time
+void SMP_SpellTurningRenderTurningUnfunctonal(object oCaster, object oTarget)
+{
+    // 1d4 minutes - same for both
+    float fMinutes = TurnsToSeconds(d4());
+
+    // We increase the stored integer by 1 for caster
+    int nStored = GetLocalInt(oCaster, SMP_SPELL_TURNING_TEMP_OFF) + 1;
+    SetLocalInt(oCaster, SMP_SPELL_TURNING_TEMP_OFF, nStored);
+
+    // We increase the stored integer by 1 for target
+    nStored = GetLocalInt(oTarget, SMP_SPELL_TURNING_TEMP_OFF) + 1;
+    SetLocalInt(oTarget, SMP_SPELL_TURNING_TEMP_OFF, nStored);
+
+    // Delay the reduction.
+    DelayCommand(fMinutes, SMP_SpellTurningReduceInteger(oCaster, SMP_SPELL_TURNING_TEMP_OFF));
+    DelayCommand(fMinutes, SMP_SpellTurningReduceInteger(oTarget, SMP_SPELL_TURNING_TEMP_OFF));
+}
+
+// Decreases the stored integer by 1
+// * Deletes if it would be 0.
+void SMP_SpellTurningReduceInteger(object oTarget, string sStored)
+{
+    int nInteger = GetLocalInt(oTarget, SMP_SPELL_TURNING_TEMP_OFF) - 1;
+    if(nInteger <= 0)
+    {
+        DeleteLocalInt(oTarget, SMP_SPELL_TURNING_TEMP_OFF);
+    }
+    else
+    {
+        SetLocalInt(oTarget, SMP_SPELL_TURNING_TEMP_OFF, nInteger);
+    }
+}
+
+// End of file Debug lines. Uncomment below "/*" with "//" and compile.
+/*
+void main()
+{
+    return;
+}
+//*/