960 lines
32 KiB
Plaintext
960 lines
32 KiB
Plaintext
//::///////////////////////////////////////////////
|
|
//:: Name Forge System Handler
|
|
//:: FileName ld_forge.nss
|
|
//:://////////////////////////////////////////////
|
|
/*
|
|
|
|
This is the main file for the forge system.
|
|
The system now uses tokens to cover the cost
|
|
of enhancements. This is to allow the DM
|
|
more control over forge access. The tokens
|
|
are under Plot Items, they stack to a maximum
|
|
stack size of 99, however the forge will count
|
|
all tokens in the possession of the player
|
|
regardless of how many are in each stack.
|
|
The system has two configurable settings,
|
|
for max mods per item, and token value.
|
|
These settings are below.
|
|
|
|
Lord Delekhan
|
|
|
|
*/
|
|
//:://////////////////////////////////////////////
|
|
//:: Created By: Lord Delekhan
|
|
//:: Created On: 11/16/2004
|
|
//:://////////////////////////////////////////////
|
|
#include "prc_x2_itemprop"
|
|
|
|
//:://////////////////////////////////////////////
|
|
//:: Set the value below to your desired maximum
|
|
//:: enhancements on any given item, default is 8
|
|
//:://////////////////////////////////////////////
|
|
const int FORGE_MAX_ENHANCEMENTS = 5;
|
|
|
|
//:://////////////////////////////////////////////
|
|
//:: Set the value below to your desired forge
|
|
//:: token value, default is 15000gp per token
|
|
//:: *note* at default value it takes 90
|
|
//:: tokens to add +9 to a plain item
|
|
//:://////////////////////////////////////////////
|
|
const int FORGE_TOKEN_VALUE = 7500;
|
|
|
|
//:://////////////////////////////////////////////
|
|
//:: Do not alter below this line
|
|
//:://////////////////////////////////////////////
|
|
|
|
void DoEnhancements(object oTarget,string sTag);
|
|
|
|
void d(string output)
|
|
{
|
|
// object oPC = GetFirstPC();
|
|
// FloatingTextStringOnCreature(output, oPC, FALSE);
|
|
}
|
|
|
|
|
|
itemproperty Enhancement(int Token, int Parm1=0,int Parm2=0)
|
|
{
|
|
itemproperty ipNew;
|
|
switch(Token){
|
|
case 1:ipNew = ItemPropertyEnhancementBonus(Parm1);break;
|
|
case 2:ipNew = ItemPropertyACBonus(Parm1);break;
|
|
case 3:ipNew = ItemPropertyDamageBonus(Parm1,Parm2);break;
|
|
case 4:ipNew = ItemPropertyDamageResistance(Parm1,Parm2);break;
|
|
case 5:ipNew = ItemPropertyAttackBonus(Parm1);break;
|
|
case 6:ipNew = ItemPropertyMaxRangeStrengthMod(Parm1);break;
|
|
case 10:ipNew = ItemPropertyHaste();break;
|
|
case 11:ipNew = ItemPropertyKeen();break;
|
|
case 12:ipNew = ItemPropertyUnlimitedAmmo(Parm1);break;
|
|
case 13:ipNew = ItemPropertyMassiveCritical(Parm1);break;
|
|
case 14:ipNew = ItemPropertyVampiricRegeneration(Parm1);break;
|
|
case 20:ipNew = ItemPropertyDamageBonus(IP_CONST_DAMAGETYPE_BLUDGEONING,
|
|
IPGetDamageBonusConstantFromNumber(Parm1));break;
|
|
case 21:ipNew = ItemPropertyImmunityMisc(Parm1);break;
|
|
case 22:ipNew = ItemPropertyAbilityBonus(Parm1, Parm2);break;
|
|
case 23:ipNew = ItemPropertyFreeAction();break;
|
|
case 24:ipNew = ItemPropertySkillBonus(Parm1, Parm2);break;
|
|
case 25:ipNew = ItemPropertyTrueSeeing();break;
|
|
case 26:ipNew = ItemPropertyDamageReduction(Parm1,Parm2);break;
|
|
case 27:ipNew = ItemPropertyBonusSavingThrow(Parm1,Parm2);break;
|
|
case 28:ipNew = ItemPropertyBonusFeat(Parm1);break;
|
|
case 29:ipNew = ItemPropertyBonusSavingThrowVsX(IP_CONST_SAVEVS_UNIVERSAL,Parm1);break;
|
|
case 30:ipNew = ItemPropertyHolyAvenger();break;
|
|
case 31:ipNew = ItemPropertyBonusSpellResistance(Parm1);break;
|
|
case 32:ipNew = ItemPropertyBonusLevelSpell(Parm1,Parm2);break;
|
|
case 33:ipNew = ItemPropertyImprovedEvasion();break;
|
|
case 34:ipNew = ItemPropertyDamageImmunity(Parm1,Parm2);break;
|
|
case 35:ipNew = ItemPropertyVisualEffect(Parm1);break;
|
|
}
|
|
return ipNew;
|
|
}
|
|
|
|
string TagEncode(int Token)
|
|
{
|
|
string sBase = "0ABCDEFGHIJKLMNOPQRSTUVWXYZ123456789";
|
|
string sToken = GetSubString(sBase,Token,1);
|
|
return sToken;
|
|
}
|
|
|
|
int TagDecode(string sTag)
|
|
{
|
|
string sBase = "0ABCDEFGHIJKLMNOPQRSTUVWXYZ123456789";
|
|
int iValue = FindSubString(sBase,sTag);
|
|
return iValue;
|
|
}
|
|
|
|
int BaseItemValid(object oItem)
|
|
{
|
|
int rValue = 0;
|
|
if(IPGetIsRangedWeapon(oItem) || IPGetIsMeleeWeapon(oItem))
|
|
rValue = 1;
|
|
int iItem = GetBaseItemType(oItem);
|
|
switch(iItem){
|
|
case BASE_ITEM_AMULET:rValue = 1;break;
|
|
case BASE_ITEM_ARMOR:rValue = 1;break;
|
|
case BASE_ITEM_BELT:rValue = 1;break;
|
|
case BASE_ITEM_BRACER:rValue = 1;break;
|
|
case BASE_ITEM_CLOAK:rValue = 1;break;
|
|
case BASE_ITEM_GLOVES:rValue = 1;break;
|
|
case BASE_ITEM_HELMET:rValue = 1;break;
|
|
case BASE_ITEM_LARGESHIELD:rValue = 1;break;
|
|
case BASE_ITEM_MAGICSTAFF:rValue = 1;break;
|
|
case BASE_ITEM_BOOTS:rValue = 1;break;
|
|
case BASE_ITEM_RING:rValue = 1;break;
|
|
case BASE_ITEM_SMALLSHIELD:rValue = 1;break;
|
|
case BASE_ITEM_TOWERSHIELD:rValue = 1;break;
|
|
}
|
|
return rValue;
|
|
}
|
|
|
|
int GetNumberOfMods(object oTarget)
|
|
{
|
|
int Mods = IPGetNumberOfItemProperties(oTarget);
|
|
itemproperty ip = GetFirstItemProperty(oTarget);
|
|
while(GetIsItemPropertyValid(ip)){
|
|
if(GetItemPropertyType(ip) == ITEM_PROPERTY_VISUALEFFECT){Mods -= 1;}
|
|
ip = GetNextItemProperty(oTarget);
|
|
}
|
|
return Mods;
|
|
}
|
|
|
|
int IsModMax(object oTarget)
|
|
{
|
|
int Mods = GetNumberOfMods(oTarget);
|
|
return (Mods >= FORGE_MAX_ENHANCEMENTS);
|
|
}
|
|
|
|
int DmgType(int Token)
|
|
{
|
|
int rValue = 0;
|
|
switch(Token){
|
|
case 2:rValue = IP_CONST_DAMAGETYPE_FIRE;break;
|
|
case 3:rValue = IP_CONST_DAMAGETYPE_COLD;break;
|
|
case 4:rValue = IP_CONST_DAMAGETYPE_ELECTRICAL;break;
|
|
case 5:rValue = IP_CONST_DAMAGETYPE_ACID;break;
|
|
case 6:rValue = IP_CONST_DAMAGETYPE_SONIC;break;
|
|
case 7:rValue = IP_CONST_DAMAGETYPE_BLUDGEONING;break;
|
|
case 8:rValue = IP_CONST_DAMAGETYPE_SLASHING;break;
|
|
case 9:rValue = IP_CONST_DAMAGETYPE_PIERCING;break;
|
|
}
|
|
return rValue;
|
|
}
|
|
|
|
int EnhValue(int Token)
|
|
{
|
|
int rValue = 0;
|
|
switch(Token){
|
|
case 1:rValue = 1;break;
|
|
case 2:rValue = 2;break;
|
|
case 3:rValue = 3;break;
|
|
case 4:rValue = 4;break;
|
|
case 5:rValue = 5;break;
|
|
case 6:rValue = 6;break;
|
|
case 7:rValue = 7;break;
|
|
case 8:rValue = 8;break;
|
|
case 9:rValue = 9;break;
|
|
case 10:rValue = 10;break;
|
|
case 11:rValue = IP_CONST_DAMAGEBONUS_1d4;break;
|
|
case 12:rValue = IP_CONST_DAMAGEBONUS_2d4;break;
|
|
case 13:rValue = IP_CONST_DAMAGEBONUS_2d6;break;
|
|
case 14:rValue = IP_CONST_DAMAGEBONUS_2d8;break;
|
|
case 15:rValue = IP_CONST_DAMAGEBONUS_1d6;break;
|
|
case 16:rValue = IP_CONST_DAMAGEBONUS_1d8;break;
|
|
case 17:rValue = IP_CONST_DAMAGEBONUS_1d10;break;
|
|
case 18:rValue = IP_CONST_DAMAGEBONUS_1d12;break;
|
|
case 19:rValue = IP_CONST_DAMAGEBONUS_2d10;break;
|
|
case 20:rValue = IP_CONST_DAMAGEBONUS_2d12;break;
|
|
}
|
|
return rValue;
|
|
}
|
|
|
|
int FeatValue(int Token)
|
|
{
|
|
int rValue = 0;
|
|
switch(Token){
|
|
case 1:rValue = IP_CONST_FEAT_ALERTNESS;break;
|
|
case 2:rValue = IP_CONST_FEAT_AMBIDEXTROUS;break;
|
|
case 3:rValue = IP_CONST_FEAT_ARMOR_PROF_HEAVY;break;
|
|
case 4:rValue = IP_CONST_FEAT_ARMOR_PROF_LIGHT;break;
|
|
case 5:rValue = IP_CONST_FEAT_ARMOR_PROF_MEDIUM;break;
|
|
case 6:rValue = IP_CONST_FEAT_CLEAVE;break;
|
|
case 7:rValue = IP_CONST_FEAT_COMBAT_CASTING;break;
|
|
case 8:rValue = IP_CONST_FEAT_DODGE;break;
|
|
case 9:rValue = IP_CONST_FEAT_EXTRA_TURNING;break;
|
|
case 10:rValue = IP_CONST_FEAT_IMPCRITUNARM;break;
|
|
case 11:rValue = IP_CONST_FEAT_KNOCKDOWN;break;
|
|
case 12:rValue = IP_CONST_FEAT_POINTBLANK;break;
|
|
case 13:rValue = IP_CONST_FEAT_POWERATTACK;break;
|
|
case 14:rValue = IP_CONST_FEAT_SPELLFOCUSABJ;break;
|
|
case 15:rValue = IP_CONST_FEAT_SPELLFOCUSCON;break;
|
|
case 16:rValue = IP_CONST_FEAT_SPELLFOCUSDIV;break;
|
|
case 17:rValue = IP_CONST_FEAT_SPELLFOCUSENC;break;
|
|
case 18:rValue = IP_CONST_FEAT_SPELLFOCUSEVO;break;
|
|
case 19:rValue = IP_CONST_FEAT_SPELLFOCUSILL;break;
|
|
case 20:rValue = IP_CONST_FEAT_SPELLFOCUSNEC;break;
|
|
case 21:rValue = IP_CONST_FEAT_SPELLPENETRATION;break;
|
|
case 22:rValue = IP_CONST_FEAT_TWO_WEAPON_FIGHTING;break;
|
|
case 23:rValue = IP_CONST_FEAT_WEAPFINESSE;break;
|
|
case 24:rValue = IP_CONST_FEAT_WEAPON_PROF_EXOTIC;break;
|
|
case 25:rValue = IP_CONST_FEAT_WEAPON_PROF_MARTIAL;break;
|
|
case 26:rValue = IP_CONST_FEAT_WEAPON_PROF_SIMPLE;break;
|
|
case 27:rValue = IP_CONST_FEAT_WEAPSPEUNARM;break;
|
|
}
|
|
return rValue;
|
|
}
|
|
|
|
int SoakValue(int Token)
|
|
{
|
|
int rValue = 0;
|
|
switch(Token){
|
|
case 1:rValue = IP_CONST_DAMAGEREDUCTION_1;break;
|
|
case 2:rValue = IP_CONST_DAMAGEREDUCTION_2;break;
|
|
case 3:rValue = IP_CONST_DAMAGEREDUCTION_3;break;
|
|
case 4:rValue = IP_CONST_DAMAGEREDUCTION_4;break;
|
|
case 5:rValue = IP_CONST_DAMAGEREDUCTION_5;break;
|
|
case 6:rValue = IP_CONST_DAMAGEREDUCTION_6;break;
|
|
}
|
|
return rValue;
|
|
}
|
|
|
|
int SoakAmount(int Token)
|
|
{
|
|
int rValue = 0;
|
|
switch(Token){
|
|
case 1:rValue = IP_CONST_DAMAGESOAK_5_HP;break;
|
|
case 2:rValue = IP_CONST_DAMAGESOAK_10_HP;break;
|
|
case 3:rValue = IP_CONST_DAMAGESOAK_15_HP;break;
|
|
case 4:rValue = IP_CONST_DAMAGESOAK_20_HP;break;
|
|
}
|
|
return rValue;
|
|
}
|
|
|
|
int SaveValue(int Token)
|
|
{
|
|
int rValue = 0;
|
|
switch(Token){
|
|
case 1:rValue = IP_CONST_SAVEBASETYPE_FORTITUDE;break;
|
|
case 2:rValue = IP_CONST_SAVEBASETYPE_REFLEX;break;
|
|
case 3:rValue = IP_CONST_SAVEBASETYPE_WILL;break;
|
|
}
|
|
return rValue;
|
|
}
|
|
|
|
int AbilityValue(int Token)
|
|
{
|
|
int rValue = 0;
|
|
switch(Token){
|
|
case 1:rValue = IP_CONST_ABILITY_CHA;break;
|
|
case 2:rValue = IP_CONST_ABILITY_CON;break;
|
|
case 3:rValue = IP_CONST_ABILITY_DEX;break;
|
|
case 4:rValue = IP_CONST_ABILITY_INT;break;
|
|
case 5:rValue = IP_CONST_ABILITY_STR;break;
|
|
case 6:rValue = IP_CONST_ABILITY_WIS;break;
|
|
}
|
|
return rValue;
|
|
}
|
|
|
|
int SkillValue(int Token)
|
|
{
|
|
int rValue = 0;
|
|
switch(Token){
|
|
case 1:rValue = SKILL_ANIMAL_EMPATHY;break;
|
|
case 2:rValue = SKILL_APPRAISE;break;
|
|
case 3:rValue = SKILL_BLUFF;break;
|
|
case 4:rValue = SKILL_CONCENTRATION;break;
|
|
case 5:rValue = SKILL_CRAFT_ARMOR;break;
|
|
case 6:rValue = SKILL_CRAFT_TRAP;break;
|
|
case 7:rValue = SKILL_CRAFT_WEAPON;break;
|
|
case 8:rValue = SKILL_DISABLE_TRAP;break;
|
|
case 9:rValue = SKILL_DISCIPLINE;break;
|
|
case 10:rValue = SKILL_HEAL;break;
|
|
case 11:rValue = SKILL_HIDE;break;
|
|
case 12:rValue = SKILL_INTIMIDATE;break;
|
|
case 13:rValue = SKILL_LISTEN;break;
|
|
case 14:rValue = SKILL_LORE;break;
|
|
case 15:rValue = SKILL_MOVE_SILENTLY;break;
|
|
case 16:rValue = SKILL_OPEN_LOCK;break;
|
|
case 17:rValue = SKILL_PARRY;break;
|
|
case 18:rValue = SKILL_PERFORM;break;
|
|
case 19:rValue = SKILL_PERSUADE;break;
|
|
case 20:rValue = SKILL_PICK_POCKET;break;
|
|
case 21:rValue = SKILL_SEARCH;break;
|
|
case 22:rValue = SKILL_SET_TRAP;break;
|
|
case 23:rValue = SKILL_SPELLCRAFT;break;
|
|
case 24:rValue = SKILL_SPOT;break;
|
|
case 25:rValue = SKILL_TAUNT;break;
|
|
case 26:rValue = SKILL_TUMBLE;break;
|
|
case 27:rValue = SKILL_USE_MAGIC_DEVICE;break;
|
|
}
|
|
return rValue;
|
|
}
|
|
|
|
int SpellResValue(int Token)
|
|
{
|
|
int rValue = 0;
|
|
switch(Token){
|
|
case 1:rValue = IP_CONST_SPELLRESISTANCEBONUS_10;break;
|
|
case 2:rValue = IP_CONST_SPELLRESISTANCEBONUS_12;break;
|
|
case 3:rValue = IP_CONST_SPELLRESISTANCEBONUS_14;break;
|
|
case 4:rValue = IP_CONST_SPELLRESISTANCEBONUS_16;break;
|
|
case 5:rValue = IP_CONST_SPELLRESISTANCEBONUS_18;break;
|
|
case 6:rValue = IP_CONST_SPELLRESISTANCEBONUS_20;break;
|
|
case 7:rValue = IP_CONST_SPELLRESISTANCEBONUS_22;break;
|
|
case 8:rValue = IP_CONST_SPELLRESISTANCEBONUS_24;break;
|
|
case 9:rValue = IP_CONST_SPELLRESISTANCEBONUS_26;break;
|
|
case 10:rValue = IP_CONST_SPELLRESISTANCEBONUS_28;break;
|
|
case 11:rValue = IP_CONST_SPELLRESISTANCEBONUS_30;break;
|
|
case 12:rValue = IP_CONST_SPELLRESISTANCEBONUS_32;break;
|
|
}
|
|
return rValue;
|
|
}
|
|
|
|
int AmmoType(int Token)
|
|
{
|
|
int rValue = 0;
|
|
switch(Token){
|
|
case 1:rValue = IP_CONST_UNLIMITEDAMMO_BASIC;break;
|
|
case 2:rValue = IP_CONST_UNLIMITEDAMMO_1D6COLD;break;
|
|
case 3:rValue = IP_CONST_UNLIMITEDAMMO_1D6FIRE;break;
|
|
case 4:rValue = IP_CONST_UNLIMITEDAMMO_1D6LIGHT;break;
|
|
case 5:rValue = IP_CONST_UNLIMITEDAMMO_PLUS1;break;
|
|
case 6:rValue = IP_CONST_UNLIMITEDAMMO_PLUS2;break;
|
|
case 7:rValue = IP_CONST_UNLIMITEDAMMO_PLUS3;break;
|
|
case 8:rValue = IP_CONST_UNLIMITEDAMMO_PLUS4;break;
|
|
case 9:rValue = IP_CONST_UNLIMITEDAMMO_PLUS5;break;
|
|
}
|
|
return rValue;
|
|
}
|
|
|
|
int VisualType(int Token)
|
|
{
|
|
int rValue = 0;
|
|
switch(Token){
|
|
case 1:rValue = ITEM_VISUAL_ACID;break;
|
|
case 2:rValue = ITEM_VISUAL_COLD;break;
|
|
case 3:rValue = ITEM_VISUAL_ELECTRICAL;break;
|
|
case 4:rValue = ITEM_VISUAL_EVIL;break;
|
|
case 5:rValue = ITEM_VISUAL_FIRE;break;
|
|
case 6:rValue = ITEM_VISUAL_HOLY;break;
|
|
case 7:rValue = ITEM_VISUAL_SONIC;break;
|
|
}
|
|
return rValue;
|
|
}
|
|
|
|
int SpellClass(int Token)
|
|
{
|
|
int rValue = 0;
|
|
switch(Token){
|
|
case 1:rValue = IP_CONST_CLASS_BARD;break;
|
|
case 2:rValue = IP_CONST_CLASS_CLERIC;break;
|
|
case 3:rValue = IP_CONST_CLASS_DRUID;break;
|
|
case 4:rValue = IP_CONST_CLASS_PALADIN;break;
|
|
case 5:rValue = IP_CONST_CLASS_RANGER;break;
|
|
case 6:rValue = IP_CONST_CLASS_SORCERER;break;
|
|
case 7:rValue = IP_CONST_CLASS_WIZARD;break;
|
|
}
|
|
return rValue;
|
|
}
|
|
|
|
int ImmunityPercent(int Token)
|
|
{
|
|
int rValue = 0;
|
|
switch(Token){
|
|
case 1:rValue = IP_CONST_DAMAGEIMMUNITY_5_PERCENT;break;
|
|
case 2:rValue = IP_CONST_DAMAGEIMMUNITY_10_PERCENT;break;
|
|
case 3:rValue = IP_CONST_DAMAGEIMMUNITY_25_PERCENT;break;
|
|
case 4:rValue = IP_CONST_DAMAGEIMMUNITY_50_PERCENT;break;
|
|
case 5:rValue = IP_CONST_DAMAGEIMMUNITY_75_PERCENT;break;
|
|
case 6:rValue = IP_CONST_DAMAGEIMMUNITY_90_PERCENT;break;
|
|
case 7:rValue = IP_CONST_DAMAGEIMMUNITY_100_PERCENT;break;
|
|
}
|
|
return rValue;
|
|
}
|
|
|
|
int ImmunityValue(int Token)
|
|
{
|
|
int rValue = 0;
|
|
switch(Token){
|
|
case 1:rValue = IP_CONST_IMMUNITYMISC_DEATH_MAGIC;break;
|
|
case 2:rValue = IP_CONST_IMMUNITYMISC_DISEASE;break;
|
|
case 3:rValue = IP_CONST_IMMUNITYMISC_FEAR;break;
|
|
case 4:rValue = IP_CONST_IMMUNITYMISC_KNOCKDOWN;break;
|
|
case 5:rValue = IP_CONST_IMMUNITYMISC_LEVEL_ABIL_DRAIN;break;
|
|
case 6:rValue = IP_CONST_IMMUNITYMISC_MINDSPELLS;break;
|
|
case 7:rValue = IP_CONST_IMMUNITYMISC_PARALYSIS;break;
|
|
case 8:rValue = IP_CONST_IMMUNITYMISC_POISON;break;
|
|
}
|
|
return rValue;
|
|
}
|
|
|
|
int IsEnhanced(int Token)
|
|
{
|
|
if(Token >= 2){return 0;}else{return 1;}
|
|
}
|
|
|
|
int IsSpecial(int Token)
|
|
{
|
|
if(Token < 10){return 0;}else{return 1;}
|
|
}
|
|
|
|
int ResValue(int Token)
|
|
{
|
|
int rValue = 0;
|
|
switch(Token){
|
|
case 1:rValue = IP_CONST_DAMAGERESIST_5;break;
|
|
case 2:rValue = IP_CONST_DAMAGERESIST_10;break;
|
|
case 3:rValue = IP_CONST_DAMAGERESIST_15;break;
|
|
case 4:rValue = IP_CONST_DAMAGERESIST_20;break;
|
|
}
|
|
return rValue;
|
|
}
|
|
|
|
int GetHasTokens(object oPC, int Count)
|
|
{
|
|
int Total = 0;
|
|
object oToken = GetFirstItemInInventory(oPC);
|
|
while(GetIsObjectValid(oToken))
|
|
{
|
|
if(GetTag(oToken) == "ldf_token")
|
|
{
|
|
Total = Total + GetItemStackSize(oToken);
|
|
}
|
|
oToken = GetNextItemInInventory(oPC);
|
|
}
|
|
return Total >= Count;
|
|
}
|
|
|
|
void GetTokens(object oPC, int Count)
|
|
{
|
|
int Done = FALSE;
|
|
object oToken = GetFirstItemInInventory(oPC);
|
|
while(GetIsObjectValid(oToken) && !Done)
|
|
{
|
|
if(GetTag(oToken) == "ldf_token")
|
|
{
|
|
int iStack = GetItemStackSize(oToken);
|
|
if(iStack > Count)
|
|
{
|
|
SetItemStackSize(oToken,(iStack-Count));
|
|
Done = TRUE;
|
|
} else {
|
|
Count = Count - iStack;
|
|
DestroyObject(oToken);
|
|
}
|
|
}
|
|
oToken = GetNextItemInInventory(oPC);
|
|
}
|
|
}
|
|
|
|
void ModGauntlets(object oTarget,string sTag)
|
|
{
|
|
string sToken = GetStringRight(sTag,2);
|
|
string sType = GetStringLeft(sToken,1);
|
|
string sValue = GetStringRight(sToken,1);
|
|
string sSpecial = GetStringLeft(sTag,1);
|
|
if(IsSpecial(TagDecode(sType))){
|
|
switch(TagDecode(sType)){
|
|
case 10:IPSafeAddItemProperty(oTarget,Enhancement(10));break;
|
|
case 21:IPSafeAddItemProperty(oTarget,Enhancement(21,ImmunityValue(TagDecode(sValue))));break;
|
|
case 22:IPSafeAddItemProperty(oTarget,Enhancement(22,AbilityValue(TagDecode(sSpecial)),TagDecode(sValue)));break;
|
|
case 23:IPSafeAddItemProperty(oTarget,Enhancement(23));break;
|
|
case 24:IPSafeAddItemProperty(oTarget,Enhancement(24,SkillValue(TagDecode(sSpecial)),TagDecode(sValue)));break;
|
|
case 25:IPSafeAddItemProperty(oTarget,Enhancement(25));break;
|
|
case 26:IPSafeAddItemProperty(oTarget,Enhancement(26,SoakValue(TagDecode(sSpecial)),SoakAmount(TagDecode(sValue))));break;
|
|
case 27:IPSafeAddItemProperty(oTarget,Enhancement(27,SaveValue(TagDecode(sSpecial)),TagDecode(sValue)));break;
|
|
case 28:IPSafeAddItemProperty(oTarget,Enhancement(28,FeatValue(TagDecode(sValue))));break;
|
|
case 29:IPSafeAddItemProperty(oTarget,Enhancement(29,TagDecode(sValue)));break;
|
|
case 31:IPSafeAddItemProperty(oTarget,Enhancement(31,SpellResValue(TagDecode(sValue))));break;
|
|
case 32:IPSafeAddItemProperty(oTarget,Enhancement(32,SpellClass(TagDecode(sSpecial)),TagDecode(sValue)),0.0,X2_IP_ADDPROP_POLICY_IGNORE_EXISTING);break;
|
|
case 33:IPSafeAddItemProperty(oTarget,Enhancement(33));break;
|
|
case 34:IPSafeAddItemProperty(oTarget,Enhancement(34,DmgType(TagDecode(sSpecial)),ImmunityPercent(TagDecode(sValue))));break;
|
|
}
|
|
} else {
|
|
if(IsEnhanced(TagDecode(sType))){
|
|
IPSafeAddItemProperty(oTarget,Enhancement(5,TagDecode(sValue)));
|
|
IPSafeAddItemProperty(oTarget,Enhancement(20,TagDecode(sValue)));
|
|
} else {
|
|
IPSafeAddItemProperty(oTarget,Enhancement(3,
|
|
DmgType(TagDecode(sType)),
|
|
EnhValue(TagDecode(sValue))));
|
|
}}
|
|
}
|
|
|
|
int GetModCost(object oOriginal,object oForge, object oAnvil, string Mods)
|
|
{
|
|
string sToken = GetStringRight(Mods,2);
|
|
string sType = GetStringLeft(sToken,1);
|
|
string sValue = GetStringRight(sToken,1);
|
|
string sSpecial = GetStringLeft(Mods,1);
|
|
|
|
int type = TagDecode(sType);
|
|
int value = TagDecode(sValue);
|
|
int special = TagDecode(sSpecial);
|
|
|
|
int tokenCost = 100000000; // Fallback, effects without a manually overridden price will cost an impossible amount.
|
|
// Determine cost by enhancement type
|
|
if (IsSpecial(type))
|
|
{
|
|
// Special effect
|
|
d("Special effect: type: "+IntToString(type)+", value: "+IntToString(value)+", special: "+IntToString(special));
|
|
switch (type)
|
|
{
|
|
case 10:
|
|
// Haste
|
|
break;
|
|
|
|
case 11:
|
|
// Keen
|
|
tokenCost = 1;
|
|
break;
|
|
|
|
case 12:
|
|
// Unlimited ammo
|
|
break;
|
|
|
|
case 13:
|
|
// Massive critical
|
|
break;
|
|
|
|
case 14:
|
|
// Vampiric regeneration
|
|
break;
|
|
|
|
case 20:
|
|
// Damage bonus (hardcoded to blunt damage type, used internally for enchanting gloves with an "enhancement bonus")
|
|
break;
|
|
|
|
case 21:
|
|
// Immunity
|
|
switch (value)
|
|
{
|
|
case 1: // Death magic
|
|
break;
|
|
|
|
case 2: // Disease
|
|
tokenCost = 1;
|
|
break;
|
|
|
|
case 3: // Fear
|
|
tokenCost = 1;
|
|
break;
|
|
|
|
case 4: // Knockdown
|
|
break;
|
|
|
|
case 5: // Level/Ability drain
|
|
break;
|
|
|
|
case 6: // Mind spells
|
|
break;
|
|
|
|
case 7: // Paralysis
|
|
tokenCost = 1;
|
|
break;
|
|
|
|
case 8: // Poison
|
|
tokenCost = 1;
|
|
break;
|
|
}
|
|
|
|
break;
|
|
|
|
case 22:
|
|
// Ability bonus - ability is in special if prices should differ by type: 1=CHA, 2=CON, 3=DEX, 4=INT, 5=STR, 6=WIS
|
|
switch (value)
|
|
{
|
|
case 1:
|
|
case 2:
|
|
tokenCost = 2;
|
|
break;
|
|
case 3:
|
|
case 4:
|
|
case 5:
|
|
case 6:
|
|
case 7:
|
|
case 8:
|
|
case 9:
|
|
case 10:
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case 23:
|
|
// Free action
|
|
break;
|
|
|
|
case 24:
|
|
// Skill bonus
|
|
break;
|
|
|
|
case 25:
|
|
// True seeing
|
|
tokenCost = 5;
|
|
break;
|
|
|
|
case 26:
|
|
// Damage reduction
|
|
break;
|
|
|
|
case 27:
|
|
// Saving throw bonus (specific type)
|
|
// We don't differentiate price by type, if this should be done, use special: 1=Fortitude, 2=Reflex, 3=Will
|
|
switch (value)
|
|
{
|
|
case 1:
|
|
case 2:
|
|
tokenCost = 1;
|
|
break;
|
|
case 3:
|
|
case 4:
|
|
case 5:
|
|
case 6:
|
|
case 7:
|
|
case 8:
|
|
case 9:
|
|
case 10:
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case 28:
|
|
// Bonus feat
|
|
break;
|
|
|
|
case 29:
|
|
// Universal saving throw bonus
|
|
switch (value)
|
|
{
|
|
case 1:
|
|
case 2:
|
|
tokenCost = 3;
|
|
break;
|
|
case 3:
|
|
case 4:
|
|
case 5:
|
|
case 6:
|
|
case 7:
|
|
case 8:
|
|
case 9:
|
|
case 10:
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case 30:
|
|
// Holy avenger
|
|
break;
|
|
|
|
case 31:
|
|
// Bonus spell resistance
|
|
switch (value)
|
|
{
|
|
case 1: // 10
|
|
tokenCost = 1;
|
|
break;
|
|
case 2: // 12
|
|
case 3: // 14
|
|
case 4: // 16
|
|
case 5: // 18
|
|
case 6: // 20
|
|
tokenCost = 5;
|
|
break;
|
|
case 7: // 22
|
|
case 8: // 24
|
|
case 9: // 26
|
|
tokenCost = 25;
|
|
break;
|
|
case 10:// 28
|
|
case 11:// 30
|
|
case 12:// 32
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case 32:
|
|
// Bonus spell level
|
|
// No price dif per level type. Level type is in special: 1=bard, 2=cleric, 3=druid, 4=paladin, 5=ranger, 6=sorcerer, 7=wizard
|
|
switch (value)
|
|
{
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
case 4:
|
|
case 5:
|
|
case 6:
|
|
tokenCost = 1;
|
|
break;
|
|
case 7:
|
|
case 8:
|
|
case 9:
|
|
tokenCost = 2;
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case 33:
|
|
// Improved evasion
|
|
break;
|
|
|
|
case 34:
|
|
// Damage immunity
|
|
break;
|
|
|
|
case 35:
|
|
// Visual effect
|
|
break;
|
|
}
|
|
} else if (IsEnhanced(type))
|
|
{
|
|
d("Enhanced: type: "+IntToString(type)+", value: "+IntToString(value)+", special: "+IntToString(special));
|
|
// Enhancement bonus
|
|
if (GetBaseItemType(oOriginal) == BASE_ITEM_GLOVES || IPGetIsRangedWeapon(oOriginal) || IPGetIsMeleeWeapon(oOriginal))
|
|
{
|
|
// Weapon enhancement bonus
|
|
switch (value)
|
|
{
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
tokenCost = 1; // 1 Token for +1 to +3
|
|
break;
|
|
case 4:
|
|
case 5:
|
|
tokenCost = 5; // 5 Tokens for +4 to +5
|
|
break;
|
|
case 6:
|
|
case 7:
|
|
case 8:
|
|
case 9:
|
|
case 10:
|
|
break;
|
|
}
|
|
} else
|
|
{
|
|
// AC bonus
|
|
switch (value)
|
|
{
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
tokenCost = 1; // 1 Token for +1 to +3
|
|
break;
|
|
case 4:
|
|
tokenCost = 2; // 2 Tokens for +4
|
|
break;
|
|
case 5:
|
|
tokenCost = 3; // 3 Tokens for +5
|
|
break;
|
|
case 6:
|
|
tokenCost = 10; // 10 Tokens for +6
|
|
break;
|
|
case 7:
|
|
case 8:
|
|
case 9:
|
|
case 10:
|
|
break;
|
|
}
|
|
}
|
|
} else
|
|
{
|
|
d("DMG bonus: type: "+IntToString(type)+", value: "+IntToString(value)+", special: "+IntToString(special));
|
|
|
|
// Damage bonus / damage resistance
|
|
if (GetBaseItemType(oOriginal) == BASE_ITEM_GLOVES || IPGetIsRangedWeapon(oOriginal) || IPGetIsMeleeWeapon(oOriginal))
|
|
{
|
|
// Damage bonus
|
|
// Right now, we do not differentiate prices by damage type - if this should be done, switch on type value: 2=fire, 3=cold, 4=electric, 5=acid, 6=sonic, 7=blunt, 8=slash, 9=pierce
|
|
switch (value)
|
|
{
|
|
case 1:
|
|
case 2:
|
|
case 3:
|
|
case 4:
|
|
case 5:
|
|
case 6:
|
|
case 7:
|
|
case 8:
|
|
case 9:
|
|
case 10:
|
|
case 11: // 1d4
|
|
case 12: // 2d4
|
|
case 13: // 2d6
|
|
break;
|
|
case 14: // 2d8
|
|
tokenCost = 3;
|
|
break;
|
|
case 15: // 1d6
|
|
tokenCost = 1;
|
|
break;
|
|
case 16: // 1d8
|
|
case 17: // 1d10
|
|
case 18: // 1d12
|
|
tokenCost = 2;
|
|
break;
|
|
case 19: // 2d10
|
|
case 20: // 2d12
|
|
break;
|
|
}
|
|
} else
|
|
{
|
|
// Damage resistance
|
|
// Right now, we do not differentiate prices by damage type - if this should be done, switch on type value: 2=fire, 3=cold, 4=electric, 5=acid, 6=sonic, 7=blunt, 8=slash, 9=pierce
|
|
switch (value)
|
|
{
|
|
case 1: // 5/-
|
|
tokenCost = 1;
|
|
break;
|
|
case 2: // 10/-
|
|
tokenCost = 3;
|
|
break;
|
|
case 3: // 15/-
|
|
case 4: // 20/-
|
|
}
|
|
}
|
|
}
|
|
|
|
int numberOfMods = GetNumberOfMods(oOriginal);
|
|
|
|
int extraCost = 0;
|
|
|
|
switch (numberOfMods)
|
|
{
|
|
case 1:
|
|
extraCost = 2;
|
|
break;
|
|
case 2:
|
|
extraCost = 4;
|
|
break;
|
|
case 3:
|
|
extraCost = 6;
|
|
break;
|
|
case 4:
|
|
extraCost = 8;
|
|
break;
|
|
case 5:
|
|
extraCost = 10;
|
|
break;
|
|
}
|
|
|
|
tokenCost = tokenCost + extraCost;
|
|
|
|
return tokenCost;
|
|
/*
|
|
object oModified;
|
|
int x,y,z;
|
|
oModified = CopyItem(oOriginal,oAnvil);
|
|
DoEnhancements(oModified,Mods);
|
|
x = GetGoldPieceValue(oModified);
|
|
y = GetGoldPieceValue(oOriginal);
|
|
DestroyObject(oModified);
|
|
z = (x-y)/FORGE_TOKEN_VALUE;
|
|
if(z < 1){z = 1;}
|
|
return z;
|
|
*/
|
|
}
|
|
|
|
string ForgeSetTag(string sStr, string sValue, int Pos)
|
|
{
|
|
string sTemp = "";
|
|
switch(Pos)
|
|
{
|
|
case 1:{sTemp = sValue+GetStringRight(sStr,2);}break;
|
|
case 2:{sTemp = GetStringLeft(sStr,1)+sValue+GetStringRight(sStr,1);}break;
|
|
case 3:{sTemp = GetStringLeft(sStr,2)+sValue;}break;
|
|
}
|
|
return sTemp;
|
|
}
|
|
|
|
void DoEnhancements(object oTarget,string sTag)
|
|
{
|
|
if(GetBaseItemType(oTarget) == BASE_ITEM_GLOVES){
|
|
ModGauntlets(oTarget,sTag);
|
|
return;}
|
|
string sToken = GetStringRight(sTag,2);
|
|
string sType = GetStringLeft(sToken,1);
|
|
string sValue = GetStringRight(sToken,1);
|
|
string sSpecial = GetStringLeft(sTag,1);
|
|
if(IsSpecial(TagDecode(sType))){
|
|
switch(TagDecode(sType)){
|
|
case 10:IPSafeAddItemProperty(oTarget,Enhancement(10));break;
|
|
case 11:if(IPGetIsMeleeWeapon(oTarget)){
|
|
IPSafeAddItemProperty(oTarget,Enhancement(11));
|
|
return;
|
|
}break;
|
|
case 12:if(IPGetIsRangedWeapon(oTarget)){
|
|
IPSafeAddItemProperty(oTarget,Enhancement(12,AmmoType(TagDecode(sValue))));
|
|
}break;
|
|
case 13:if(IPGetIsRangedWeapon(oTarget) || IPGetIsMeleeWeapon(oTarget)){
|
|
IPSafeAddItemProperty(oTarget,Enhancement(13,EnhValue(TagDecode(sValue))));
|
|
}break;
|
|
case 14:if(IPGetIsMeleeWeapon(oTarget)){
|
|
IPSafeAddItemProperty(oTarget,Enhancement(14,TagDecode(sValue)));
|
|
}break;
|
|
case 21:IPSafeAddItemProperty(oTarget,Enhancement(21,ImmunityValue(TagDecode(sValue))));break;
|
|
case 22:IPSafeAddItemProperty(oTarget,Enhancement(22,AbilityValue(TagDecode(sSpecial)),TagDecode(sValue)));break;
|
|
case 23:IPSafeAddItemProperty(oTarget,Enhancement(23));break;
|
|
case 24:IPSafeAddItemProperty(oTarget,Enhancement(24,SkillValue(TagDecode(sSpecial)),TagDecode(sValue)));break;
|
|
case 25:IPSafeAddItemProperty(oTarget,Enhancement(25));break;
|
|
case 26:IPSafeAddItemProperty(oTarget,Enhancement(26,SoakValue(TagDecode(sSpecial)),SoakAmount(TagDecode(sValue))));break;
|
|
case 27:IPSafeAddItemProperty(oTarget,Enhancement(27,SaveValue(TagDecode(sSpecial)),TagDecode(sValue)));break;
|
|
case 28:IPSafeAddItemProperty(oTarget,Enhancement(28,FeatValue(TagDecode(sValue))));break;
|
|
case 29:IPSafeAddItemProperty(oTarget,Enhancement(29,TagDecode(sValue)));break;
|
|
case 30:if(IPGetIsMeleeWeapon(oTarget)){
|
|
IPSafeAddItemProperty(oTarget,Enhancement(30));
|
|
}break;
|
|
case 31:IPSafeAddItemProperty(oTarget,Enhancement(31,SpellResValue(TagDecode(sValue))));break;
|
|
case 32:IPSafeAddItemProperty(oTarget,Enhancement(32,SpellClass(TagDecode(sSpecial)),TagDecode(sValue)),0.0,X2_IP_ADDPROP_POLICY_IGNORE_EXISTING);break;
|
|
case 33:IPSafeAddItemProperty(oTarget,Enhancement(33));break;
|
|
case 34:IPSafeAddItemProperty(oTarget,Enhancement(34,DmgType(TagDecode(sSpecial)),ImmunityPercent(TagDecode(sValue))));break;
|
|
case 35:if(IPGetIsMeleeWeapon(oTarget)){
|
|
IPSafeAddItemProperty(oTarget,Enhancement(35,VisualType(TagDecode(sValue))));break;
|
|
}break;
|
|
}
|
|
} else {
|
|
if(IsEnhanced(TagDecode(sType))){
|
|
if(IPGetIsRangedWeapon(oTarget)){
|
|
IPSafeAddItemProperty(oTarget,Enhancement(5,TagDecode(sValue)));
|
|
IPSafeAddItemProperty(oTarget,Enhancement(6,TagDecode(sValue)));
|
|
return;
|
|
}
|
|
if(IPGetIsMeleeWeapon(oTarget)){
|
|
IPSafeAddItemProperty(oTarget,Enhancement(1,TagDecode(sValue)));
|
|
} else {
|
|
IPSafeAddItemProperty(oTarget,Enhancement(2,TagDecode(sValue)));
|
|
}
|
|
} else {
|
|
if(IPGetIsMeleeWeapon(oTarget)){
|
|
IPSafeAddItemProperty(oTarget,Enhancement(3,
|
|
DmgType(TagDecode(sType)),
|
|
EnhValue(TagDecode(sValue))));
|
|
} else {
|
|
IPSafeAddItemProperty(oTarget,Enhancement(4,
|
|
DmgType(TagDecode(sType)),
|
|
ResValue(TagDecode(sValue))));
|
|
}
|
|
}}
|
|
SetPlotFlag(oTarget, TRUE);
|
|
return;
|
|
}
|
|
|
|
//void main(){}
|