//::///////////////////////////////////////////////
//:: prc_x2_craft
//:: Copyright (c) 2003 Bioare Corp.
//:://////////////////////////////////////////////
/*
Central include for crafting feat and
crafting skill system.
*/
//:://////////////////////////////////////////////
//:: Created By: Georg Zoeller
//:: Created On: 2003-05-09
//:: Last Updated On: 2003-10-14
//:://////////////////////////////////////////////
struct craft_struct
{
int nRow;
string sResRef;
int nDC;
int nCost;
string sLabel;
};
struct craft_receipe_struct
{
int nMode;
object oMajor;
object oMinor;
};
struct craft_cost_struct
{
int nGoldCost;
int nXPCost;
int nTimeCost;
};
const string X2_CI_CRAFTSKILL_CONV ="x2_p_craftskills";
// Brew Potion related Constants
/* moved to be code switches
const int X2_CI_BREWPOTION_MAXLEVEL = 3; // Max Level for potions
const int X2_CI_BREWPOTION_COSTMODIFIER = 50; // gp Brew Potion XPCost Modifier
// Scribe Scroll related constants
const int X2_CI_SCRIBESCROLL_COSTMODIFIER = 25; // Scribescroll Cost Modifier
// Craft Wand related constants
const int X2_CI_CRAFTWAND_MAXLEVEL = 4;
const int X2_CI_CRAFTWAND_COSTMODIFIER = 750;
*/
const int X2_CI_BREWPOTION_FEAT_ID = 944; // Brew Potion feat simulation
const int X2_CI_SCRIBESCROLL_FEAT_ID = 945;
const int X2_CI_CRAFTWAND_FEAT_ID = 946;
const int X2_CI_CRAFTROD_FEAT_ID = 2927;
const int X2_CI_CRAFTROD_EPIC_FEAT_ID = 3490;
const int X2_CI_CRAFTSTAFF_FEAT_ID = 2928;
const int X2_CI_CRAFTSTAFF_EPIC_FEAT_ID = 3491;
const string X2_CI_BREWPOTION_NEWITEM_RESREF = "x2_it_pcpotion"; // ResRef for new potion item
const string X2_CI_SCRIBESCROLL_NEWITEM_RESREF = "x2_it_pcscroll"; // ResRef for new scroll item
const string X2_CI_CRAFTWAND_NEWITEM_RESREF = "x2_it_pcwand";
//const string X2_CI_CRAFTROD_NEWITEM_RESREF = "x2_it_pcwand";
//const string X2_CI_CRAFTSTAFF_NEWITEM_RESREF = "x2_it_pcwand";
// 2da for the craftskills
const string X2_CI_CRAFTING_WP_2DA = "des_crft_weapon" ;
const string X2_CI_CRAFTING_AR_2DA = "des_crft_armor" ;
const string X2_CI_CRAFTING_MAT_2DA = "des_crft_mat";
// 2da for matching spells to properties
const string X2_CI_CRAFTING_SP_2DA = "des_crft_spells" ;
// Base custom token for item modification conversations (do not change unless you want to change the conversation too)
const int X2_CI_CRAFTINGSKILL_CTOKENBASE = 13220;
// Base custom token for DC item modification conversations (do not change unless you want to change the conversation too)
const int X2_CI_CRAFTINGSKILL_DC_CTOKENBASE = 14220;
// Base custom token for DC item modification conversations (do not change unless you want to change the conversation too)
const int X2_CI_CRAFTINGSKILL_GP_CTOKENBASE = 14320;
// Base custom token for DC item modification conversations (do not change unless you want to change the conversation too)
const int X2_CI_MODIFYARMOR_GP_CTOKENBASE = 14420;
//How many items per 2da row in X2_IP_CRAFTING_2DA, do not change>4 until you want to create more conversation condition scripts as well
const int X2_CI_CRAFTING_ITEMS_PER_ROW = 5;
// name of the scroll 2da
const string X2_CI_2DA_SCROLLS = "des_crft_scroll";
const int X2_CI_CRAFTMODE_INVALID = 0;
const int X2_CI_CRAFTMODE_CONTAINER = 1; // no longer used, but left in for the community to reactivate
const int X2_CI_CRAFTMODE_BASE_ITEM = 2;
const int X2_CI_CRAFTMODE_ASSEMBLE = 3;
const int X2_CI_MAGICTYPE_INVALID = 0;
const int X2_CI_MAGICTYPE_ARCANE = 1;
const int X2_CI_MAGICTYPE_DIVINE = 2;
const int X2_CI_MODMODE_INVALID = 0;
const int X2_CI_MODMODE_ARMOR = 1;
const int X2_CI_MODMODE_WEAPON = 2;
// Runecrafting constants
const int PRC_RUNE_BASECOST = 0;
const int PRC_RUNE_CHARGES = 1;
const int PRC_RUNE_PERDAY = 2;
const int PRC_RUNE_MAXCHARGES = 3;
const int PRC_RUNE_MAXUSESPERDAY = 4;
// Attune Gem constants
const int PRC_GEM_BASECOST = 5;
const int PRC_GEM_PERLEVEL = 6;
// Craft Skull Talisman constants
const int PRC_SKULL_BASECOST = 7;
// * Returns TRUE if an item is a Craft Base Item
// * to be used in spellscript that can be cast on items - i.e light
int CIGetIsCraftFeatBaseItem( object oItem );
// * Checks if the last spell cast was used to brew potion and will do the brewing process.
// * Returns TRUE if the spell was indeed used to brew a potion (regardless of the actual outcome of the brewing process)
// * Meant to be used in spellscripts only
int CICraftCheckBrewPotion(object oSpellTarget, object oCaster, int nID = 0);
// * Checks if the last spell cast was used to scribe a scroll and handles the scribe scroll process
// * Returns TRUE if the spell was indeed used to scribe a scroll (regardless of the actual outcome)
// * Meant to be used in spellscripts only
int CICraftCheckScribeScroll(object oSpellTarget, object oCaster, int nID = 0);
// * Create a new potion item based on the spell nSpellID on the creator
object CICraftBrewPotion(object oCreator, int nSpellID );
// * Create a new scroll item based on the spell nSpellID on the creator
object CICraftScribeScroll(object oCreator, int nSpellID);
// * Checks if the caster intends to use his item creation feats and
// * calls appropriate item creation subroutine if conditions are met (spell cast on correct item, etc).
// * Returns TRUE if the spell was used for an item creation feat
int CIGetSpellWasUsedForItemCreation(object oSpellTarget);
// This function checks whether Inscribe Rune is turned on
// and if so, deducts the appropriate experience and gold
// then creates the rune in the caster's inventory.
// This will also cause the spell to fail if turned on.
int InscribeRune(object oTarget = OBJECT_INVALID, object oCaster = OBJECT_INVALID, int nSpell = 0);
// This function checks whether Attune Gem is turned on
// and if so, deducts the appropriate experience and gold
// then creates the gem in the caster's inventory.
// This will also cause the spell to fail if turned on.
int AttuneGem(object oTarget = OBJECT_INVALID, object oCaster = OBJECT_INVALID, int nSpell = 0);
// Gets the Magical Artisan feat given a particular crafting feat
int GetMagicalArtisanFeat(int nCraftingFeat);
// Gets the modified gold cost taking cost reduction feats and cost
// scaling switches into account
int GetModifiedGoldCost(int nCost, object oPC, int nCraftingFeat);
// Gets the modified xp cost taking cost reduction feats and cost
// scaling switches into account
int GetModifiedXPCost(int nCost, object oPC, int nCraftingFeat);
// Gets the modified time cost taking cost reduction feats and cost
// scaling switches into account
int GetModifiedTimeCost(int nCost, object oPC, int nCraftingFeat);
// Imbue item check for warlocks, returns TRUE if a spell requirement is met
int CheckImbueItem(object oPC, int nSpell);
// Gets PnP xp cost given a gold cost and whether the item is epic
int GetPnPItemXPCost(int nCost, int bEpic);
// Returns a struct containing gold, xp and time costs given the base cost and other arguments
struct craft_cost_struct GetModifiedCostsFromBase(int nCost, object oPC, int nCraftingFeat, int bEpic);
// Additional checking for emulating spells during crafting
int CheckAlternativeCrafting(object oPC, int nSpell, struct craft_cost_struct costs);
// Returns the maximum of caster level used and other effective levels from emulating spells
int GetAlternativeCasterLevel(object oPC, int nLevel);
//////////////////////////////////////////////////
/* Include section */
//////////////////////////////////////////////////
//#include "prc_x2_itemprop"
//#include "x2_inc_switches"
#include "prc_inc_newip"
#include "prc_inc_spells"
#include "prc_add_spell_dc"
//////////////////////////////////////////////////
/* Function definitions */
//////////////////////////////////////////////////
// * Returns the innate level of a spell. If bDefaultZeroToOne is given
// * Level 0 spell will be returned as level 1 spells
int CIGetSpellInnateLevel(int nSpellID, int bDefaultZeroToOne = FALSE)
{
int nRet = StringToInt(Get2DACache(X2_CI_CRAFTING_SP_2DA, "Level", nSpellID));
if (nRet == 0 && bDefaultZeroToOne == TRUE) // Was missing the "bDefaultZeroToOne == TRUE" check, fixed to match specification - Ornedan
nRet = 1;
return nRet;
}
// * Makes oPC do a Craft check using nSkill to create the item supplied in sResRe
// * If oContainer is specified, the item will be created there.
// * Throwing weapons are created with stack sizes of 10, ammo with 20
// * oPC - The player crafting
// * nSkill - SKILL_CRAFT_WEAPON or SKILL_CRAFT_ARMOR,
// * sResRef - ResRef of the item to be crafted
// * nDC - DC to beat to succeed
// * oContainer - if a container is specified, create item inside
object CIUseCraftItemSkill(object oPC, int nSkill, string sResRef, int nDC, object oContainer = OBJECT_INVALID);
// * Returns TRUE if a spell is prevented from being used with one of the crafting feats
int CIGetIsSpellRestrictedFromCraftFeat(int nSpellID, int nFeatID);
// * Return craftitemstructdata
struct craft_struct CIGetCraftItemStructFrom2DA(string s2DA, int nRow, int nItemNo);
// * Return the type of magic as one of the following constants
// * const int X2_CI_MAGICTYPE_INVALID = 0;
// * const int X2_CI_MAGICTYPE_ARCANE = 1;
// * const int X2_CI_MAGICTYPE_DIVINE = 2;
// * Parameters:
// * nClass - CLASS_TYPE_* constant
int CI_GetClassMagicType(int nClass)
{
if(GetIsArcaneClass(nClass))
return X2_CI_MAGICTYPE_ARCANE;
else if(GetIsDivineClass(nClass))
return X2_CI_MAGICTYPE_DIVINE;
return X2_CI_MAGICTYPE_INVALID;
}
string GetMaterialComponentTag(int nPropID)
{
string sRet = Get2DACache("des_matcomp","comp_tag",nPropID);
return sRet;
}
// -----------------------------------------------------------------------------
// Return true if oItem is a crafting target item
// -----------------------------------------------------------------------------
int CIGetIsCraftFeatBaseItem(object oItem)
{
int nBt = GetBaseItemType(oItem);
// blank scroll, empty potion, wand
if (nBt == BASE_ITEM_BLANK_POTION ||
nBt == BASE_ITEM_BLANK_SCROLL ||
nBt == BASE_ITEM_BLANK_WAND ||
nBt == BASE_ITEM_CRAFTED_ROD ||
nBt == BASE_ITEM_CRAFTED_STAFF)
return TRUE;
else
return FALSE;
}
// -----------------------------------------------------------------------------
// Georg, 2003-06-12
// Create a new playermade potion object with properties matching nSpellID and return it
// -----------------------------------------------------------------------------
object CICraftBrewPotion(object oCreator, int nSpellID )
{
int nPropID = IPGetIPConstCastSpellFromSpellID(nSpellID);
object oTarget;
// * GZ 2003-09-11: If the current spell cast is not acid fog, and
// * returned property ID is 0, bail out to prevent
// * creation of acid fog items.
if (nPropID == 0 && nSpellID != 0)
{
FloatingTextStrRefOnCreature(84544,oCreator);
return OBJECT_INVALID;
}
/* //just a tad retarded, don't you think? other crafting feats are not similarly restricted
//Uses per day
int nUsesAllowed;
if(GetHasFeat(FEAT_BREW_4PERDAY,oCreator)) nUsesAllowed = 4;
else if(GetHasFeat(FEAT_BREW_3PERDAY, oCreator)) nUsesAllowed = 3;
else if(GetHasFeat(FEAT_BREW_2PERDAY, oCreator)) nUsesAllowed = 2;
else nUsesAllowed = 1;
int nUsed = GetLocalInt(oCreator, "PRC_POTIONS_BREWED");
if(nUsed >= nUsesAllowed)
{
SendMessageToPC(oCreator, "You must rest before you can brew any more potions");
return OBJECT_INVALID;
}
*/
int nCasterLevel = GetAlternativeCasterLevel(oCreator, PRCGetCasterLevel(oCreator));
if (nPropID != -1)
{
itemproperty ipProp = ItemPropertyCastSpell(nPropID,IP_CONST_CASTSPELL_NUMUSES_SINGLE_USE);
oTarget = CreateItemOnObject(X2_CI_BREWPOTION_NEWITEM_RESREF,oCreator);
AddItemProperty(DURATION_TYPE_PERMANENT,ipProp,oTarget);
if(GetPRCSwitch(PRC_BREW_POTION_CASTER_LEVEL))
{
itemproperty ipLevel = ItemPropertyCastSpellCasterLevel(nSpellID, nCasterLevel);
AddItemProperty(DURATION_TYPE_PERMANENT,ipLevel,oTarget);
itemproperty ipMeta = ItemPropertyCastSpellMetamagic(nSpellID, PRCGetMetaMagicFeat());
AddItemProperty(DURATION_TYPE_PERMANENT,ipMeta,oTarget);
itemproperty ipDC = ItemPropertyCastSpellDC(nSpellID, PRCGetSaveDC(PRCGetSpellTargetObject(), OBJECT_SELF));
AddItemProperty(DURATION_TYPE_PERMANENT,ipDC,oTarget);
}
//Increment usage
//SetLocalInt(oCreator, "PRC_POTIONS_BREWED", nUsed++);
}
return oTarget;
}
// -----------------------------------------------------------------------------
// Wrapper for the crafting cost calculation, returns GP required
// -----------------------------------------------------------------------------
int CIGetCraftGPCost(int nLevel, int nMod, string sCasterLevelSwitch)
{
int nLvlRow = IPGetIPConstCastSpellFromSpellID(PRCGetSpellId());
int nCLevel;// = StringToInt(Get2DACache("iprp_spells","CasterLvl",nLvlRow));
//PRC modification
if(GetPRCSwitch(sCasterLevelSwitch))
{
nCLevel = PRCGetCasterLevel();
}
else
{
nCLevel = StringToInt(Get2DACache("iprp_spells","CasterLvl",nLvlRow));
}
// -------------------------------------------------------------------------
// in case we don't get a valid CLevel, use spell level instead
// -------------------------------------------------------------------------
if (nCLevel ==0)
{
nCLevel = nLevel;
}
int nRet = nCLevel * nLevel * nMod;
return nRet;
}
// -----------------------------------------------------------------------------
// Georg, 2003-06-12
// Create a new playermade wand object with properties matching nSpellID
// and return it
// -----------------------------------------------------------------------------
object CICraftCraftWand(object oCreator, int nSpellID )
{
int nPropID = IPGetIPConstCastSpellFromSpellID(nSpellID);
object oTarget;
// * GZ 2003-09-11: If the current spell cast is not acid fog, and
// * returned property ID is 0, bail out to prevent
// * creation of acid fog items.
if (nPropID == 0 && nSpellID != 0)
{
FloatingTextStrRefOnCreature(84544,oCreator);
return OBJECT_INVALID;
}
//int nClass = PRCGetLastSpellCastClass();
int nCasterLevel = GetAlternativeCasterLevel(oCreator, PRCGetCasterLevel(oCreator));
if (nPropID != -1)
{
itemproperty ipProp = ItemPropertyCastSpell(nPropID,IP_CONST_CASTSPELL_NUMUSES_1_CHARGE_PER_USE);
oTarget = CreateItemOnObject(X2_CI_CRAFTWAND_NEWITEM_RESREF,oCreator);
AddItemProperty(DURATION_TYPE_PERMANENT,ipProp,oTarget);
if(GetPRCSwitch(PRC_CRAFT_WAND_CASTER_LEVEL))
{
itemproperty ipLevel = ItemPropertyCastSpellCasterLevel(nSpellID, nCasterLevel);
AddItemProperty(DURATION_TYPE_PERMANENT,ipLevel,oTarget);
itemproperty ipMeta = ItemPropertyCastSpellMetamagic(nSpellID, PRCGetMetaMagicFeat());
AddItemProperty(DURATION_TYPE_PERMANENT,ipMeta,oTarget);
itemproperty ipDC = ItemPropertyCastSpellDC(nSpellID, PRCGetSaveDC(PRCGetSpellTargetObject(), OBJECT_SELF));
AddItemProperty(DURATION_TYPE_PERMANENT,ipDC,oTarget);
}
//int nType = CI_GetClassMagicType(nClass);
//itemproperty ipLimit;
/* //this is a bit silly, really, removed in line with other crafting types
if (nType == X2_CI_MAGICTYPE_DIVINE)
{
ipLimit = ItemPropertyLimitUseByClass(CLASS_TYPE_PALADIN);
AddItemProperty(DURATION_TYPE_PERMANENT,ipLimit,oTarget);
ipLimit = ItemPropertyLimitUseByClass(CLASS_TYPE_RANGER);
AddItemProperty(DURATION_TYPE_PERMANENT,ipLimit,oTarget);
ipLimit = ItemPropertyLimitUseByClass(CLASS_TYPE_DRUID);
AddItemProperty(DURATION_TYPE_PERMANENT,ipLimit,oTarget);
ipLimit = ItemPropertyLimitUseByClass(CLASS_TYPE_CLERIC);
AddItemProperty(DURATION_TYPE_PERMANENT,ipLimit,oTarget);
}
else if (nType == X2_CI_MAGICTYPE_ARCANE)
{
ipLimit = ItemPropertyLimitUseByClass(CLASS_TYPE_WIZARD);
AddItemProperty(DURATION_TYPE_PERMANENT,ipLimit,oTarget);
ipLimit = ItemPropertyLimitUseByClass(CLASS_TYPE_SORCERER);
AddItemProperty(DURATION_TYPE_PERMANENT,ipLimit,oTarget);
ipLimit = ItemPropertyLimitUseByClass(CLASS_TYPE_BARD);
AddItemProperty(DURATION_TYPE_PERMANENT,ipLimit,oTarget);
}
if(nClass != CLASS_TYPE_WARLOCK)
{
ipLimit = ItemPropertyLimitUseByClass(nClass);
AddItemProperty(DURATION_TYPE_PERMANENT,ipLimit,oTarget);
}
*/
int nCharges = nCasterLevel + d20();
if (nCharges == 0) // stupi cheaters
{
nCharges = 10+d20();
}
// Hard core rule mode enabled
if (GetModuleSwitchValue(MODULE_SWITCH_ENABLE_CRAFT_WAND_50_CHARGES))
{
SetItemCharges(oTarget,50);
}
else
{
SetItemCharges(oTarget,nCharges);
}
// TODOL Add use restrictions there when item becomes available
}
return oTarget;
}
// -----------------------------------------------------------------------------
// Georg, 2003-06-12
// Create and Return a magic wand with an item property
// matching nSpellID. Charges are set to d20 + casterlevel
// capped at 50 max
// -----------------------------------------------------------------------------
object CICraftScribeScroll(object oCreator, int nSpellID)
{
int nPropID = IPGetIPConstCastSpellFromSpellID(nSpellID);
object oTarget;
// Handle optional material components
string sMat = GetMaterialComponentTag(nPropID);
if (sMat != "")
{
object oMat = GetItemPossessedBy(oCreator,sMat);
if (oMat== OBJECT_INVALID)
{
FloatingTextStrRefOnCreature(83374, oCreator); // Missing material component
return OBJECT_INVALID;
}
else
{
DestroyObject (oMat);
}
}
// get scroll resref from scrolls lookup 2da
int nClass =PRCGetLastSpellCastClass ();
string sClass = "";
switch (nClass)
{
case CLASS_TYPE_WIZARD:
sClass = "Wiz_Sorc";
break;
case CLASS_TYPE_SORCERER:
sClass = "Wiz_Sorc";
break;
case CLASS_TYPE_CLERIC:
case CLASS_TYPE_UR_PRIEST:
sClass = "Cleric";
break;
case CLASS_TYPE_PALADIN:
sClass = "Paladin";
break;
case CLASS_TYPE_DRUID:
case CLASS_TYPE_BLIGHTER:
sClass = "Druid";
break;
case CLASS_TYPE_RANGER:
sClass = "Ranger";
break;
case CLASS_TYPE_BARD:
sClass = "Bard";
break;
}
string sResRef;
if (sClass != "")
{
sResRef = Get2DACache(X2_CI_2DA_SCROLLS,sClass,nSpellID);
if (sResRef != "")
{
oTarget = CreateItemOnObject(sResRef,oCreator);
}
}
else
{
sResRef = "craft_scroll";
oTarget = CreateItemOnObject(sResRef ,oCreator);
RemoveItemProperty(oTarget, GetFirstItemProperty(oTarget));
itemproperty ipSpell = ItemPropertyCastSpell(nPropID, IP_CONST_CASTSPELL_NUMUSES_SINGLE_USE);
AddItemProperty(DURATION_TYPE_PERMANENT,ipSpell,oTarget);
}
if(GetPRCSwitch(PRC_SCRIBE_SCROLL_CASTER_LEVEL))
{
int nCasterLevel = GetAlternativeCasterLevel(oCreator, PRCGetCasterLevel(oCreator));
itemproperty ipLevel = ItemPropertyCastSpellCasterLevel(nSpellID, nCasterLevel);
AddItemProperty(DURATION_TYPE_PERMANENT,ipLevel,oTarget);
itemproperty ipMeta = ItemPropertyCastSpellMetamagic(nSpellID, PRCGetMetaMagicFeat());
AddItemProperty(DURATION_TYPE_PERMANENT,ipMeta,oTarget);
itemproperty ipDC = ItemPropertyCastSpellDC(nSpellID, PRCGetSaveDC(PRCGetSpellTargetObject(), OBJECT_SELF));
AddItemProperty(DURATION_TYPE_PERMANENT,ipDC,oTarget);
}
if (oTarget == OBJECT_INVALID)
{
WriteTimestampedLogEntry("prc_x2_craft::CICraftScribeScroll failed - Resref: " + sResRef + " Class: " + sClass + "(" +IntToString(nClass) +") " + " SpellID " + IntToString (nSpellID));
}
return oTarget;
}
// -----------------------------------------------------------------------------
// Returns TRUE if the player used the last spell to brew a potion
// -----------------------------------------------------------------------------
int CICraftCheckBrewPotion(object oSpellTarget, object oCaster, int nID = 0)
{
if(nID == 0) nID = PRCGetSpellId();
object oSpellTarget = PRCGetSpellTargetObject();
object oCaster = OBJECT_SELF;
int nLevel = CIGetSpellInnateLevel(nID,TRUE);
if(GetPRCSwitch(PRC_BREW_POTION_CASTER_LEVEL))
{
int nMetaMagic = PRCGetMetaMagicFeat();
switch(nMetaMagic)
{
case METAMAGIC_EMPOWER:
nLevel += 2;
break;
case METAMAGIC_EXTEND:
nLevel += 1;
break;
case METAMAGIC_MAXIMIZE:
nLevel += 3;
break;
/* case METAMAGIC_QUICKEN:
nLevel += 1;
break;
case METAMAGIC_SILENT:
nLevel += 5;
break;
case METAMAGIC_STILL:
nLevel += 6;
break;
These dont work as IPs since they are hardcoded */
}
}
// -------------------------------------------------------------------------
// check if brew potion feat is there
// -------------------------------------------------------------------------
if (GetHasFeat(X2_CI_BREWPOTION_FEAT_ID, oCaster) != TRUE)
{
FloatingTextStrRefOnCreature(40487, oCaster); // Item Creation Failed - Don't know how to create that type of item
return TRUE;
}
// -------------------------------------------------------------------------
// check if spell is below maxlevel for brew potions
// -------------------------------------------------------------------------
int nPotionMaxLevel = GetPRCSwitch(X2_CI_BREWPOTION_MAXLEVEL);
if(nPotionMaxLevel == 0)
nPotionMaxLevel = 3;
//Master Alchemist
if(GetHasFeat(FEAT_BREW_POTION_9TH, oCaster)) nPotionMaxLevel = 9;
else if(GetHasFeat(FEAT_BREW_POTION_8TH, oCaster)) nPotionMaxLevel = 8;
else if(GetHasFeat(FEAT_BREW_POTION_7TH, oCaster)) nPotionMaxLevel = 7;
else if(GetHasFeat(FEAT_BREW_POTION_6TH, oCaster)) nPotionMaxLevel = 6;
else if(GetHasFeat(FEAT_BREW_POTION_5TH, oCaster)) nPotionMaxLevel = 5;
else if(GetHasFeat(FEAT_BREW_POTION_4TH, oCaster)) nPotionMaxLevel = 4;
if (nLevel > nPotionMaxLevel)
{
FloatingTextStrRefOnCreature(76416, oCaster);
return TRUE;
}
// -------------------------------------------------------------------------
// Check if the spell is allowed to be used with Brew Potions
// -------------------------------------------------------------------------
if (CIGetIsSpellRestrictedFromCraftFeat(nID, X2_CI_BREWPOTION_FEAT_ID))
{
FloatingTextStrRefOnCreature(83450, oCaster);
return TRUE;
}
// -------------------------------------------------------------------------
// XP/GP Cost Calculation
// -------------------------------------------------------------------------
int nCostModifier = GetPRCSwitch(X2_CI_BREWPOTION_COSTMODIFIER);
if(nCostModifier == 0)
nCostModifier = 50;
int nCost = CIGetCraftGPCost(nLevel, nCostModifier, PRC_BREW_POTION_CASTER_LEVEL);
struct craft_cost_struct costs = GetModifiedCostsFromBase(nCost, oCaster, FEAT_BREW_POTION, FALSE);
// -------------------------------------------------------------------------
// Does Player have enough gold?
// -------------------------------------------------------------------------
//if (GetGold(oCaster) < nGoldCost)
if(!GetHasGPToSpend(oCaster, costs.nGoldCost))
{
FloatingTextStrRefOnCreature(3786, oCaster); // Item Creation Failed - not enough gold!
return TRUE;
}
int nHD = GetHitDice(oCaster);
int nMinXPForLevel = ((nHD * (nHD - 1)) / 2) * 1000;
int nNewXP = GetXP(oCaster) - costs.nXPCost;
// -------------------------------------------------------------------------
// check for sufficient XP to cast spell
// -------------------------------------------------------------------------
//if (nMinXPForLevel > nNewXP || nNewXP == 0 )
if (!GetHasXPToSpend(oCaster, costs.nXPCost))
{
FloatingTextStrRefOnCreature(3785, oCaster); // Item Creation Failed - Not enough XP
return TRUE;
}
//check spell emulation
if(!CheckAlternativeCrafting(oCaster, nID, costs))
{
FloatingTextStringOnCreature("*Crafting failed!*", oCaster, FALSE);
return TRUE;
}
// -------------------------------------------------------------------------
// Here we brew the new potion
// -------------------------------------------------------------------------
object oPotion = CICraftBrewPotion(oCaster, nID);
// -------------------------------------------------------------------------
// Verify Results
// -------------------------------------------------------------------------
if (GetIsObjectValid(oPotion))
{
//TakeGoldFromCreature(nGoldCost, oCaster, TRUE);
//SetXP(oCaster, nNewXP);
SpendXP(oCaster, costs.nXPCost);
SpendGP(oCaster, costs.nGoldCost);
DestroyObject (oSpellTarget);
FloatingTextStrRefOnCreature(8502, oCaster); // Item Creation successful
//advance time here
if(!costs.nTimeCost) costs.nTimeCost = 1;
AdvanceTimeForPlayer(oCaster, RoundsToSeconds(costs.nTimeCost));
string sName;
sName = Get2DACache("spells", "Name", nID);
sName = "Potion of "+GetStringByStrRef(StringToInt(sName));
SetName(oPotion, sName);
return TRUE;
}
else
{
FloatingTextStrRefOnCreature(76417, oCaster); // Item Creation Failed
return TRUE;
}
}
// -----------------------------------------------------------------------------
// Returns TRUE if the player used the last spell to create a scroll
// -----------------------------------------------------------------------------
int CICraftCheckScribeScroll(object oSpellTarget, object oCaster, int nID = 0)
{
if(nID == 0) nID = PRCGetSpellId();
// -------------------------------------------------------------------------
// check if scribe scroll feat is there
// -------------------------------------------------------------------------
if (GetHasFeat(X2_CI_SCRIBESCROLL_FEAT_ID, oCaster) != TRUE)
{
FloatingTextStrRefOnCreature(40487, oCaster); // Item Creation Failed - Don't know how to create that type of item
return TRUE;
}
// -------------------------------------------------------------------------
// Check if the spell is allowed to be used with Scribe Scroll
// -------------------------------------------------------------------------
if (CIGetIsSpellRestrictedFromCraftFeat(nID, X2_CI_SCRIBESCROLL_FEAT_ID))
{
FloatingTextStrRefOnCreature(83451, oCaster); // can not be used with this feat
return TRUE;
}
// -------------------------------------------------------------------------
// XP/GP Cost Calculation
// -------------------------------------------------------------------------
int nLevel = CIGetSpellInnateLevel(nID,TRUE);
int nCostModifier = GetPRCSwitch(X2_CI_SCRIBESCROLL_COSTMODIFIER);
if(nCostModifier == 0)
nCostModifier = 25;
int nCost = CIGetCraftGPCost(nLevel, nCostModifier, PRC_SCRIBE_SCROLL_CASTER_LEVEL);
struct craft_cost_struct costs = GetModifiedCostsFromBase(nCost, oCaster, FEAT_SCRIBE_SCROLL, FALSE);
if(GetPRCSwitch(PRC_SCRIBE_SCROLL_CASTER_LEVEL))
{
int nMetaMagic = PRCGetMetaMagicFeat();
switch(nMetaMagic)
{
case METAMAGIC_EMPOWER:
nLevel += 2;
break;
case METAMAGIC_EXTEND:
nLevel += 1;
break;
case METAMAGIC_MAXIMIZE:
nLevel += 3;
break;
/* case METAMAGIC_QUICKEN:
nLevel += 1;
break;
case METAMAGIC_SILENT:
nLevel += 5;
break;
case METAMAGIC_STILL:
nLevel += 6;
break;
These dont work as IPs since they are hardcoded */
}
}
// -------------------------------------------------------------------------
// Does Player have enough gold?
// -------------------------------------------------------------------------
if(!GetHasGPToSpend(oCaster, costs.nGoldCost))
{
FloatingTextStrRefOnCreature(3786, oCaster); // Item Creation Failed - not enough gold!
return TRUE;
}
int nHD = GetHitDice(oCaster);
int nMinXPForLevel = ((nHD * (nHD - 1)) / 2) * 1000;
int nNewXP = GetXP(oCaster) - costs.nXPCost;
// -------------------------------------------------------------------------
// check for sufficient XP to cast spell
// -------------------------------------------------------------------------
//if (nMinXPForLevel > nNewXP || nNewXP == 0 )
if (!GetHasXPToSpend(oCaster, costs.nXPCost))
{
FloatingTextStrRefOnCreature(3785, oCaster); // Item Creation Failed - Not enough XP
return TRUE;
}
//check spell emulation
if(!CheckAlternativeCrafting(oCaster, nID, costs))
{
FloatingTextStringOnCreature("*Crafting failed!*", oCaster, FALSE);
return TRUE;
}
// -------------------------------------------------------------------------
// Here we scribe the scroll
// -------------------------------------------------------------------------
object oScroll = CICraftScribeScroll(oCaster, nID);
// -------------------------------------------------------------------------
// Verify Results
// -------------------------------------------------------------------------
if (GetIsObjectValid(oScroll))
{
//----------------------------------------------------------------------
// Some scrollsare ar not identified ... fix that here
//----------------------------------------------------------------------
SetIdentified(oScroll,TRUE);
ActionPlayAnimation (ANIMATION_FIREFORGET_READ,1.0);
SpendXP(oCaster, costs.nXPCost);
SpendGP(oCaster, costs.nGoldCost);
DestroyObject (oSpellTarget);
FloatingTextStrRefOnCreature(8502, oCaster); // Item Creation successful
//advance time here
if(!costs.nTimeCost) costs.nTimeCost = 1;
AdvanceTimeForPlayer(oCaster, RoundsToSeconds(costs.nTimeCost));
return TRUE;
}
else
{
FloatingTextStrRefOnCreature(76417, oCaster); // Item Creation Failed
return TRUE;
}
return FALSE;
}
// -----------------------------------------------------------------------------
// Returns TRUE if the player used the last spell to craft a wand
// -----------------------------------------------------------------------------
int CICraftCheckCraftWand(object oSpellTarget, object oCaster, int nID = 0)
{
if(nID == 0) nID = PRCGetSpellId();
// -------------------------------------------------------------------------
// check if craft wand feat is there
// -------------------------------------------------------------------------
if (GetHasFeat(X2_CI_CRAFTWAND_FEAT_ID, oCaster) != TRUE)
{
FloatingTextStrRefOnCreature(40487, oCaster); // Item Creation Failed - Don't know how to create that type of item
return TRUE; // tried item creation but do not know how to do it
}
// -------------------------------------------------------------------------
// Check if the spell is allowed to be used with Craft Wand
// -------------------------------------------------------------------------
if (CIGetIsSpellRestrictedFromCraftFeat(nID, X2_CI_CRAFTWAND_FEAT_ID))
{
FloatingTextStrRefOnCreature(83452, oCaster); // can not be used with this feat
return TRUE;
}
int nLevel = CIGetSpellInnateLevel(nID,TRUE);
if(GetPRCSwitch(PRC_CRAFT_WAND_CASTER_LEVEL))
{
int nMetaMagic = PRCGetMetaMagicFeat();
switch(nMetaMagic)
{
case METAMAGIC_EMPOWER:
nLevel += 2;
break;
case METAMAGIC_EXTEND:
nLevel += 1;
break;
case METAMAGIC_MAXIMIZE:
nLevel += 3;
break;
/* case METAMAGIC_QUICKEN:
nLevel += 1;
break;
case METAMAGIC_SILENT:
nLevel += 5;
break;
case METAMAGIC_STILL:
nLevel += 6;
break;
These dont work as IPs since they are hardcoded */
}
}
// -------------------------------------------------------------------------
// check if spell is below maxlevel for craft want
// -------------------------------------------------------------------------
int nMaxLevel = GetPRCSwitch(X2_CI_CRAFTWAND_MAXLEVEL);
if(nMaxLevel == 0)
nMaxLevel = 4;
if (nLevel > nMaxLevel)
{
FloatingTextStrRefOnCreature(83623, oCaster);
return TRUE;
}
// -------------------------------------------------------------------------
// XP/GP Cost Calculation
// -------------------------------------------------------------------------
int nCostMod = GetPRCSwitch(X2_CI_CRAFTWAND_COSTMODIFIER);
if(nCostMod == 0)
nCostMod = 750;
int nCost = CIGetCraftGPCost(nLevel, nCostMod, PRC_CRAFT_WAND_CASTER_LEVEL);
struct craft_cost_struct costs = GetModifiedCostsFromBase(nCost, oCaster, FEAT_CRAFT_WAND, FALSE);
// -------------------------------------------------------------------------
// Does Player have enough gold?
// -------------------------------------------------------------------------
if(!GetHasGPToSpend(oCaster, costs.nGoldCost))
{
FloatingTextStrRefOnCreature(3786, oCaster); // Item Creation Failed - not enough gold!
return TRUE;
}
// more calculations on XP cost
int nHD = GetHitDice(oCaster);
int nMinXPForLevel = ((nHD * (nHD - 1)) / 2) * 1000;
int nNewXP = GetXP(oCaster) - costs.nXPCost;
// -------------------------------------------------------------------------
// check for sufficient XP to cast spell
// -------------------------------------------------------------------------
if (!GetHasXPToSpend(oCaster, costs.nXPCost))
{
FloatingTextStrRefOnCreature(3785, oCaster); // Item Creation Failed - Not enough XP
return TRUE;
}
//check spell emulation
if(!CheckAlternativeCrafting(oCaster, nID, costs))
{
FloatingTextStringOnCreature("*Crafting failed!*", oCaster, FALSE);
return TRUE;
}
// -------------------------------------------------------------------------
// Here we craft the wand
// -------------------------------------------------------------------------
object oWand = CICraftCraftWand(oCaster, nID);
// -------------------------------------------------------------------------
// Verify Results
// -------------------------------------------------------------------------
if (GetIsObjectValid(oWand))
{
SpendXP(oCaster, costs.nXPCost);
SpendGP(oCaster, costs.nGoldCost);
DestroyObject (oSpellTarget);
FloatingTextStrRefOnCreature(8502, oCaster); // Item Creation successful
//advance time here
if(!costs.nTimeCost) costs.nTimeCost = 1;
AdvanceTimeForPlayer(oCaster, RoundsToSeconds(costs.nTimeCost));
string sName;
sName = Get2DACache("spells", "Name", nID);
sName = "Wand of "+GetStringByStrRef(StringToInt(sName));
SetName(oWand, sName);
return TRUE;
}
else
{
FloatingTextStrRefOnCreature(76417, oCaster); // Item Creation Failed
return TRUE;
}
return FALSE;
}
int CICraftCheckCraftStaff(object oSpellTarget, object oCaster, int nSpellID = 0)
{
if(nSpellID == 0) nSpellID = PRCGetSpellId();
int nCasterLevel = GetAlternativeCasterLevel(oCaster, PRCGetCasterLevel(oCaster));
int bSuccess = TRUE;
int nCount = 0;
itemproperty ip = GetFirstItemProperty(oSpellTarget);
while(GetIsItemPropertyValid(ip))
{
if(GetItemPropertyType(ip) == ITEM_PROPERTY_CAST_SPELL)
nCount++;
ip = GetNextItemProperty(oSpellTarget);
}
if(nCount >= 8)
{
FloatingTextStringOnCreature("* Failure - Too many castspell itemproperties *", oCaster);
return TRUE;
}
if(!GetHasFeat(X2_CI_CRAFTSTAFF_FEAT_ID, oCaster))
{
FloatingTextStrRefOnCreature(40487, oCaster); // Item Creation Failed - Don't know how to create that type of item
return TRUE; // tried item creation but do not know how to do it
}
int nMetaMagic = PRCGetMetaMagicFeat();
if(nMetaMagic && !GetHasFeat(X2_CI_CRAFTSTAFF_EPIC_FEAT_ID, oCaster))
{
FloatingTextStringOnCreature("* Failure - You must be able to craft epic staffs to apply metamagic *", oCaster);
return TRUE; // tried item creation but do not know how to do it
}
if(CIGetIsSpellRestrictedFromCraftFeat(nSpellID, X2_CI_CRAFTSTAFF_FEAT_ID))
{
FloatingTextStrRefOnCreature(16829169, oCaster); // can not be used with this feat
return TRUE;
}
int nLevel = CIGetSpellInnateLevel(nSpellID,TRUE);
if(GetPRCSwitch(PRC_CRAFT_STAFF_CASTER_LEVEL))
{
switch(nMetaMagic)
{
case METAMAGIC_EMPOWER:
nLevel += 2;
break;
case METAMAGIC_EXTEND:
nLevel += 1;
break;
case METAMAGIC_MAXIMIZE:
nLevel += 3;
break;
/* case METAMAGIC_QUICKEN:
nLevel += 1;
break;
case METAMAGIC_SILENT:
nLevel += 5;
break;
case METAMAGIC_STILL:
nLevel += 6;
break;
These dont work as IPs since they are hardcoded */
}
}
int nCostMod = GetPRCSwitch(X2_CI_CRAFTSTAFF_COSTMODIFIER);
if(!nCostMod) nCostMod = 750;
int nLvlRow = IPGetIPConstCastSpellFromSpellID(nSpellID);
int nCLevel = StringToInt(Get2DACache("iprp_spells","CasterLvl",nLvlRow));
int nCost = CIGetCraftGPCost(nLevel, nCostMod, PRC_CRAFT_STAFF_CASTER_LEVEL);
//discount for second or 3+ spells
if(nCount+1 == 2)
nCost = (nCost*3)/4;
else if(nCount+1 >= 3)
nCost = nCost/2;
//takes epic xp costs into account
struct craft_cost_struct costs = GetModifiedCostsFromBase(nCost, oCaster, FEAT_CRAFT_STAFF, (nMetaMagic > 0));
if(costs.nGoldCost < 1) costs.nXPCost = 1;
if(costs.nXPCost < 1) costs.nXPCost = 1;
//if(GetGold(oCaster) < nGoldCost) // enough gold?
if (!GetHasGPToSpend(oCaster, costs.nGoldCost))
{
FloatingTextStrRefOnCreature(3786, oCaster); // Item Creation Failed - not enough gold!
return TRUE;
}
int nHD = GetHitDice(oCaster);
int nMinXPForLevel = (nHD * (nHD - 1)) * 500;
int nNewXP = GetXP(oCaster) - costs.nXPCost;
//if (nMinXPForLevel > nNewXP || nNewXP == 0 )
if (!GetHasXPToSpend(oCaster, costs.nXPCost))
{
FloatingTextStrRefOnCreature(3785, oCaster); // Item Creation Failed - Not enough XP
return TRUE;
}
//check spell emulation
if(!CheckAlternativeCrafting(oCaster, nSpellID, costs))
{
FloatingTextStringOnCreature("*Crafting failed!*", oCaster, FALSE);
return TRUE;
}
int nPropID = IPGetIPConstCastSpellFromSpellID(nSpellID);
if (nPropID == 0 && nSpellID != 0)
{
FloatingTextStrRefOnCreature(84544,oCaster);
return TRUE;
}
if (nPropID != -1)
{
AddItemProperty(DURATION_TYPE_PERMANENT,ItemPropertyCastSpell(nPropID,IP_CONST_CASTSPELL_NUMUSES_1_CHARGE_PER_USE),oSpellTarget);
if(GetPRCSwitch(PRC_CRAFT_STAFF_CASTER_LEVEL))
{
AddItemProperty(DURATION_TYPE_PERMANENT,ItemPropertyCastSpellCasterLevel(nSpellID, nCasterLevel),oSpellTarget);
AddItemProperty(DURATION_TYPE_PERMANENT,ItemPropertyCastSpellMetamagic(nSpellID, PRCGetMetaMagicFeat()),oSpellTarget);
AddItemProperty(DURATION_TYPE_PERMANENT,ItemPropertyCastSpellDC(nSpellID, PRCGetSaveDC(PRCGetSpellTargetObject(), OBJECT_SELF)),oSpellTarget);
}
}
else
bSuccess = FALSE;
if(bSuccess)
{
//TakeGoldFromCreature(nGoldCost, oCaster, TRUE);
//SetXP(oCaster, nNewXP);
SpendXP(oCaster, costs.nXPCost);
SpendGP(oCaster, costs.nGoldCost);
//DestroyObject (oSpellTarget);
FloatingTextStrRefOnCreature(8502, oCaster); // Item Creation successful
//advance time here
if(!costs.nTimeCost) costs.nTimeCost = 1;
AdvanceTimeForPlayer(oCaster, RoundsToSeconds(costs.nTimeCost));
string sName;
sName = GetName(oCaster)+"'s Magic Staff";
//sName = Get2DACache("spells", "Name", nID);
//sName = "Wand of "+GetStringByStrRef(StringToInt(sName));
SetName(oSpellTarget, sName);
SetItemCursedFlag(oSpellTarget, FALSE);
SetDroppableFlag(oSpellTarget, TRUE);
return TRUE;
}
else
{
FloatingTextStrRefOnCreature(76417, oCaster); // Item Creation Failed
return TRUE;
}
return TRUE;
}
int CICraftCheckCraftRod(object oSpellTarget, object oCaster, int nSpellID = 0)
{
if(nSpellID == 0) nSpellID = PRCGetSpellId();
int nCasterLevel = GetAlternativeCasterLevel(oCaster, PRCGetCasterLevel(oCaster));
int bSuccess = TRUE;
int nCount = 0;
itemproperty ip = GetFirstItemProperty(oSpellTarget);
while(GetIsItemPropertyValid(ip))
{
if(GetItemPropertyType(ip) == ITEM_PROPERTY_CAST_SPELL)
nCount++;
ip = GetNextItemProperty(oSpellTarget);
}
if(nCount >= 8)
{
FloatingTextStringOnCreature("* Failure - Too many castspell itemproperties *", oCaster);
return TRUE;
}
if(!GetHasFeat(X2_CI_CRAFTROD_FEAT_ID, oCaster))
{
FloatingTextStrRefOnCreature(40487, oCaster); // Item Creation Failed - Don't know how to create that type of item
return TRUE; // tried item creation but do not know how to do it
}
int nMetaMagic = PRCGetMetaMagicFeat();
if(nMetaMagic && !GetHasFeat(X2_CI_CRAFTROD_EPIC_FEAT_ID, oCaster))
{
FloatingTextStringOnCreature("* Failure - You must be able to craft epic rods to apply metamagic *", oCaster);
return TRUE; // tried item creation but do not know how to do it
}
if(CIGetIsSpellRestrictedFromCraftFeat(nSpellID, X2_CI_CRAFTROD_FEAT_ID))
{
FloatingTextStrRefOnCreature(16829169, oCaster); // can not be used with this feat
return TRUE;
}
int nLevel = CIGetSpellInnateLevel(nSpellID,TRUE);
if(GetPRCSwitch(PRC_CRAFT_ROD_CASTER_LEVEL))
{
switch(nMetaMagic)
{
case METAMAGIC_EMPOWER:
nLevel += 2;
break;
case METAMAGIC_EXTEND:
nLevel += 1;
break;
case METAMAGIC_MAXIMIZE:
nLevel += 3;
break;
/* case METAMAGIC_QUICKEN:
nLevel += 1;
break;
case METAMAGIC_SILENT:
nLevel += 5;
break;
case METAMAGIC_STILL:
nLevel += 6;
break;
These dont work as IPs since they are hardcoded */
}
}
int nCostMod = GetPRCSwitch(X2_CI_CRAFTROD_COSTMODIFIER);
if(!nCostMod) nCostMod = 750;
int nLvlRow = IPGetIPConstCastSpellFromSpellID(nSpellID);
int nCLevel = StringToInt(Get2DACache("iprp_spells","CasterLvl",nLvlRow));
int nCost = CIGetCraftGPCost(nLevel, nCostMod, PRC_CRAFT_ROD_CASTER_LEVEL);
//discount for second or 3+ spells
if(nCount+1 == 2)
nCost = (nCost*3)/4;
else if(nCount+1 >= 3)
nCost = nCost/2;
//takes epic xp costs into account
struct craft_cost_struct costs = GetModifiedCostsFromBase(nCost, oCaster, FEAT_CRAFT_ROD, (nMetaMagic > 0));
if(costs.nGoldCost < 1) costs.nXPCost = 1;
if(costs.nXPCost < 1) costs.nXPCost = 1;
//if(GetGold(oCaster) < nGoldCost) // enough gold?
if (!GetHasGPToSpend(oCaster, costs.nGoldCost))
{
FloatingTextStrRefOnCreature(3786, oCaster); // Item Creation Failed - not enough gold!
return TRUE;
}
int nHD = GetHitDice(oCaster);
int nMinXPForLevel = (nHD * (nHD - 1)) * 500;
int nNewXP = GetXP(oCaster) - costs.nXPCost;
//if (nMinXPForLevel > nNewXP || nNewXP == 0 )
if (!GetHasXPToSpend(oCaster, costs.nXPCost))
{
FloatingTextStrRefOnCreature(3785, oCaster); // Item Creation Failed - Not enough XP
return TRUE;
}
//check spell emulation
if(!CheckAlternativeCrafting(oCaster, nSpellID, costs))
{
FloatingTextStringOnCreature("*Crafting failed!*", oCaster, FALSE);
return TRUE;
}
int nPropID = IPGetIPConstCastSpellFromSpellID(nSpellID);
if (nPropID == 0 && nSpellID != 0)
{
FloatingTextStrRefOnCreature(84544,oCaster);
return TRUE;
}
if (nPropID != -1)
{
AddItemProperty(DURATION_TYPE_PERMANENT,ItemPropertyCastSpell(nPropID,IP_CONST_CASTSPELL_NUMUSES_1_CHARGE_PER_USE),oSpellTarget);
if(GetPRCSwitch(PRC_CRAFT_ROD_CASTER_LEVEL))
{
AddItemProperty(DURATION_TYPE_PERMANENT,ItemPropertyCastSpellMetamagic(nSpellID, PRCGetMetaMagicFeat()),oSpellTarget);
}
}
else
bSuccess = FALSE;
if(bSuccess)
{
//TakeGoldFromCreature(nGoldCost, oCaster, TRUE);
//SetXP(oCaster, nNewXP);
SpendXP(oCaster, costs.nXPCost);
SpendGP(oCaster, costs.nGoldCost);
//DestroyObject (oSpellTarget);
FloatingTextStrRefOnCreature(8502, oCaster); // Item Creation successful
//advance time here
if(!costs.nTimeCost) costs.nTimeCost = 1;
AdvanceTimeForPlayer(oCaster, RoundsToSeconds(costs.nTimeCost));
string sName;
sName = GetName(oCaster)+"'s Magic Rod";
//sName = Get2DACache("spells", "Name", nID);
//sName = "Wand of "+GetStringByStrRef(StringToInt(sName));
SetName(oSpellTarget, sName);
SetItemCursedFlag(oSpellTarget, FALSE);
SetDroppableFlag(oSpellTarget, TRUE);
return TRUE;
}
else
{
FloatingTextStrRefOnCreature(76417, oCaster); // Item Creation Failed
return TRUE;
}
return TRUE;
}
int InscribeRune(object oTarget = OBJECT_INVALID, object oCaster = OBJECT_INVALID, int nSpell = 0)
{
if(!GetIsObjectValid(oCaster)) oCaster = OBJECT_SELF;
// Get the item used to cast the spell
object oItem = GetSpellCastItem();
if(GetResRef(oItem) == "prc_rune_1")
{
string sName = GetName(GetItemPossessor(oItem));
if (DEBUG) FloatingTextStringOnCreature(sName + " has just cast a rune spell", oCaster, FALSE);
if(DEBUG) DoDebug("Checking for One Use runes");
// This check is used to clear up the one use runes
itemproperty ip = GetFirstItemProperty(oItem);
while(GetIsItemPropertyValid(ip))
{
if(GetItemPropertyType(ip) == ITEM_PROPERTY_CAST_SPELL)
{
if(DEBUG) DoDebug("Rune can cast spells");
if (GetItemPropertyCostTableValue(ip) == 5) // Only one use runes have 2 charges per use
{
if(DEBUG) DoDebug("Rune has 2 charges a use, marking it a one use rune");
// Give it enough time for the spell to finish casting
DestroyObject(oItem, 1.0);
if(DEBUG) DoDebug("Rune destroyed.");
}
}
ip = GetNextItemProperty(oItem);
}
}
// If Inscribing is turned off, the spell functions as normal
if(!GetLocalInt(oCaster, "InscribeRune")) return TRUE;
// No point being in here if you don't have runes.
if(!GetHasFeat(FEAT_INSCRIBE_RUNE, oCaster))
{
FloatingTextStrRefOnCreature(40487, oCaster); // Item Creation Failed - Don't know how to create that type of item
return TRUE; // tried item creation but do not know how to do it
}
// No point scribing runes from items, and its not allowed.
if (oItem != OBJECT_INVALID)
{
FloatingTextStringOnCreature("You cannot scribe a rune from an item.", oCaster, FALSE);
return TRUE;
}
if(!GetIsObjectValid(oTarget)) oTarget = PRCGetSpellTargetObject();
int nCaster = GetAlternativeCasterLevel(oCaster, PRCGetCasterLevel(oCaster));
int nDC = PRCGetSaveDC(oTarget, oCaster);
if(!nSpell) nSpell = PRCGetSpellId();
int nSpellLevel = 0;
int nClass = GetLevelByClass(CLASS_TYPE_RUNECASTER, oCaster);
// This accounts for the fact that there is no bonus to runecraft at level 10
// Also adjusts it to fit the epic progression, which starts at 13
if (nClass >= 10) nClass -= 3;
// Bonus to Runecrafting checks from the Runecaster class
int nRuneCraft = (nClass + 2)/3;
// Runecraft local int that counts uses/charges
int nCount = GetLocalInt(oCaster, "RuneCounter");
int nLastClass = PRCGetLastSpellCastClass();
if (nLastClass == CLASS_TYPE_CLERIC || nLastClass == CLASS_TYPE_UR_PRIEST) nSpellLevel = StringToInt(lookup_spell_cleric_level(nSpell));
else if (nLastClass == CLASS_TYPE_DRUID) nSpellLevel = StringToInt(lookup_spell_druid_level(nSpell));
else if (nLastClass == CLASS_TYPE_WIZARD || nLastClass == CLASS_TYPE_SORCERER) nSpellLevel = StringToInt(lookup_spell_level(nSpell));
// If none of these work, check the innate level of the spell
if (nSpellLevel == 0) nSpellLevel = StringToInt(lookup_spell_innate(nSpell));
// Minimum level.
if (nSpellLevel == 0) nSpellLevel = 1;
// This will be modified with Runecaster code later.
int nCharges = 1;
if (GetLocalInt(oCaster, "RuneCharges")) nCharges = nCount;
if (GetLocalInt(oCaster, "RuneUsesPerDay"))
{
// 5 is the max uses per day
if (nCount > 5) nCount = 5;
int nMaxUses = StringToInt(Get2DACache("prc_rune_craft", "Cost", PRC_RUNE_MAXUSESPERDAY));
if (nCount > nMaxUses) nCount = nMaxUses;
nCharges = nCount;
}
// Can't have no charges
if (nCharges == 0) nCharges = 1;
int nMaxCharges = StringToInt(Get2DACache("prc_rune_craft", "Cost", PRC_RUNE_MAXCHARGES));
if (nCount > nMaxCharges) nCharges = nMaxCharges;
FloatingTextStringOnCreature("Spell Level: " + IntToString(nSpellLevel), OBJECT_SELF, FALSE);
FloatingTextStringOnCreature("Caster Level: " + IntToString(nCaster), OBJECT_SELF, FALSE);
FloatingTextStringOnCreature("Number of Charges: " + IntToString(nCharges), OBJECT_SELF, FALSE);
// Gold cost multipler, varies depending on the ability used to craft
int nMultiplier = StringToInt(Get2DACache("prc_rune_craft", "Cost", PRC_RUNE_BASECOST));
if (nClass > 0) nMultiplier /= 2;
if (GetLocalInt(oCaster, "RuneCharges")) nMultiplier = StringToInt(Get2DACache("prc_rune_craft", "Cost", PRC_RUNE_CHARGES));
if (GetLocalInt(oCaster, "RuneUsesPerDay")) nMultiplier = StringToInt(Get2DACache("prc_rune_craft", "Cost", PRC_RUNE_PERDAY));
// Cost of the rune in gold and XP
int nCost = nSpellLevel * nCaster * nCharges * nMultiplier;
struct craft_cost_struct costs = GetModifiedCostsFromBase(nCost, oCaster, FEAT_INSCRIBE_RUNE, FALSE);
FloatingTextStringOnCreature("Gold Cost: " + IntToString(costs.nGoldCost), OBJECT_SELF, FALSE);
FloatingTextStringOnCreature("XP Cost: " + IntToString(costs.nXPCost), OBJECT_SELF, FALSE);
// See if the caster has enough gold and XP to scribe a rune, and that he passes the skill check.
int nHD = GetHitDice(oCaster);
int nMinXPForLevel = ((nHD * (nHD - 1)) / 2) * 1000;
int nNewXP = GetXP(oCaster) - costs.nXPCost;
int nGold = GetGold(oCaster);
int nNewGold = nGold - costs.nGoldCost;
int nCheck = FALSE;
// Does the PC have Maximize Rune turned on?
int nMaximize = 0;
if (GetLocalInt(oCaster, "MaximizeRune")) nMaximize = 5;
// The check does not use GetIsSkillSuccessful so it doesn't show on the PC
if ((GetSkillRank(SKILL_CRAFT_ARMOR, oCaster) + d20() + nRuneCraft) >= (20 + nSpellLevel + nMaximize)) nCheck = TRUE;
if (!GetHasGPToSpend(oCaster, costs.nGoldCost))
{
FloatingTextStringOnCreature("You do not have enough gold to scribe this rune.", oCaster, FALSE);
// Since they don't have enough, the spell casts normally
return TRUE;
}
if (!GetHasXPToSpend(oCaster, costs.nXPCost) )
{
FloatingTextStringOnCreature("You do not have enough experience to scribe this rune.", oCaster, FALSE);
// Since they don't have enough, the spell casts normally
return TRUE;
}
if (!nCheck)
{
FloatingTextStringOnCreature("You have failed the craft check to scribe this rune.", oCaster, FALSE);
// Since they don't have enough, the spell casts normally
return TRUE;
}
// Steal all the code from craft wand.
// The reason craft wand is used is because it is possible to create runes with charges using the Runecaster class.
int nPropID = IPGetIPConstCastSpellFromSpellID(nSpell);
// * GZ 2003-09-11: If the current spell cast is not acid fog, and
// * returned property ID is 0, bail out to prevent
// * creation of acid fog items.
if (nPropID == 0 && nSpell != 0)
{
FloatingTextStrRefOnCreature(84544,oCaster);
return TRUE;
}
//check spell emulation
if(!CheckAlternativeCrafting(oCaster, nSpell, costs))
{
FloatingTextStringOnCreature("*Crafting failed!*", oCaster, FALSE);
return TRUE;
}
if (nPropID != -1)
{
// This part is always done
int nRuneChant = 0;
if (nClass >= 30) nRuneChant = 10;
else if (nClass >= 27) nRuneChant = 9;
else if (nClass >= 24) nRuneChant = 8;
else if (nClass >= 21) nRuneChant = 7;
else if (nClass >= 18) nRuneChant = 6;
else if (nClass >= 15) nRuneChant = 5;
else if (nClass >= 12) nRuneChant = 4;
else if (nClass >= 9) nRuneChant = 3;
else if (nClass >= 5) nRuneChant = 2;
else if (nClass >= 2) nRuneChant = 1;
// Since we know they can now pay for it, create the rune stone
object oRune = CreateItemOnObject("prc_rune_1", oCaster, 1, IntToString(nRuneChant));
// If they have this active, the bonuses are already added, so skip
// If they don't, add the bonuses down below
if(GetHasSpellEffect(SPELL_RUNE_CHANT))
nRuneChant = 0;
itemproperty ipLevel = ItemPropertyCastSpellCasterLevel(nSpell, PRCGetCasterLevel());
AddItemProperty(DURATION_TYPE_PERMANENT,ipLevel,oRune);
itemproperty ipMeta = ItemPropertyCastSpellMetamagic(nSpell, PRCGetMetaMagicFeat());
AddItemProperty(DURATION_TYPE_PERMANENT,ipMeta,oRune);
itemproperty ipDC = ItemPropertyCastSpellDC(nSpell, PRCGetSaveDC(PRCGetSpellTargetObject(), OBJECT_SELF) + nRuneChant);
AddItemProperty(DURATION_TYPE_PERMANENT,ipDC,oRune);
// If Maximize Rune is turned on and we pass the check, add the Maximize IProp
if (GetLocalInt(oCaster, "MaximizeRune"))
{
itemproperty ipMax = ItemPropertyCastSpellMetamagic(nSpell, METAMAGIC_MAXIMIZE);
AddItemProperty(DURATION_TYPE_PERMANENT,ipMax,oRune);
}
// If its uses per day instead of charges, we do some different stuff here
if (GetLocalInt(oCaster, "RuneUsesPerDay"))
{
int nIPUses;
if (nCount == 1) nIPUses = IP_CONST_CASTSPELL_NUMUSES_1_USE_PER_DAY;
else if (nCount == 2) nIPUses = IP_CONST_CASTSPELL_NUMUSES_2_USES_PER_DAY;
else if (nCount == 3) nIPUses = IP_CONST_CASTSPELL_NUMUSES_3_USES_PER_DAY;
else if (nCount == 4) nIPUses = IP_CONST_CASTSPELL_NUMUSES_4_USES_PER_DAY;
// Caps out at 5 per day
else if (nCount >= 5) nIPUses = IP_CONST_CASTSPELL_NUMUSES_5_USES_PER_DAY;
itemproperty ipProp = ItemPropertyCastSpell(nPropID,nIPUses);
AddItemProperty(DURATION_TYPE_PERMANENT,ipProp,oRune);
}
else if (nCharges == 1) // This is to handle one use runes so the spellhooking works
{
itemproperty ipProp = ItemPropertyCastSpell(nPropID,IP_CONST_CASTSPELL_NUMUSES_2_CHARGES_PER_USE);
AddItemProperty(DURATION_TYPE_PERMANENT,ipProp,oRune);
// This is done so the item exists when it is used for the game to read data off of
nCharges = 3;
}
else // Do the normal charges
{
itemproperty ipProp = ItemPropertyCastSpell(nPropID,IP_CONST_CASTSPELL_NUMUSES_1_CHARGE_PER_USE);
AddItemProperty(DURATION_TYPE_PERMANENT,ipProp,oRune);
}
SetItemCharges(oRune,nCharges);
SetXP(oCaster,nNewXP);
TakeGoldFromCreature(costs.nGoldCost, oCaster, TRUE);
//advance time here
if(!costs.nTimeCost) costs.nTimeCost = 1;
AdvanceTimeForPlayer(oCaster, RoundsToSeconds(costs.nTimeCost));
string sName;
sName = Get2DACache("spells", "Name", nSpell);
sName = "Rune of "+GetStringByStrRef(StringToInt(sName));
if(GetLocalInt(oCaster, "MaximizeRune"))
sName = "Maximized "+sName;
SetName(oRune, sName);
}
// If we have made it this far, they have crafted the rune and the spell has been used up, so it returns false.
return FALSE;
}
int AttuneGem(object oTarget = OBJECT_INVALID, object oCaster = OBJECT_INVALID, int nSpell = 0)
{
if(!GetIsObjectValid(oCaster)) oCaster = OBJECT_SELF;
// Get the item used to cast the spell
object oItem = GetSpellCastItem();
if (GetTag(oItem) == "prc_attunegem")
{
string sName = GetName(GetItemPossessor(oItem));
if (DEBUG) FloatingTextStringOnCreature(sName + " has just cast a gem spell", oCaster, FALSE);
if(DEBUG) DoDebug("Checking for One Use Gems");
// This check is used to clear up the one use Gems
itemproperty ip = GetFirstItemProperty(oItem);
while(GetIsItemPropertyValid(ip))
{
if(GetItemPropertyType(ip) == ITEM_PROPERTY_CAST_SPELL)
{
if(DEBUG) DoDebug("Gem can cast spells");
if (GetItemPropertyCostTableValue(ip) == 5) // Only one use Gems have 2 charges per use
{
if(DEBUG) DoDebug("Gem has 2 charges a use, marking it a one use Gem");
// Give it enough time for the spell to finish casting
DestroyObject(oItem, 1.0);
if(DEBUG) DoDebug("Gem destroyed.");
}
}
ip = GetNextItemProperty(oItem);
}
}
// If Inscribing is turned off, the spell functions as normal
if(!GetLocalInt(oCaster, "AttuneGem")) return TRUE;
// No point being in here if you don't have Gems.
if(!GetHasFeat(FEAT_ATTUNE_GEM, oCaster))
{
FloatingTextStrRefOnCreature(40487, oCaster); // Item Creation Failed - Don't know how to create that type of item
return TRUE; // tried item creation but do not know how to do it
}
// No point scribing Gems from items, and its not allowed.
if (oItem != OBJECT_INVALID)
{
FloatingTextStringOnCreature("You cannot scribe a Gem from an item.", oCaster, FALSE);
return TRUE;
}
// oTarget here should be the gem. If it's not, fail.
if(!GetIsObjectValid(oTarget)) oTarget = PRCGetSpellTargetObject();
// Only accepts bioware gems
if (GetStringLeft(GetResRef(oTarget), 5) == "it_gem")
{
FloatingTextStringOnCreature("Spell target is not a valid gem.", oCaster, FALSE);
// And out we go
return TRUE;
}
int nCaster = GetAlternativeCasterLevel(oCaster, PRCGetCasterLevel(oCaster));
int nDC = PRCGetSaveDC(oTarget, oCaster);
if(!nSpell) nSpell = PRCGetSpellId();
int nSpellLevel;
if (PRCGetLastSpellCastClass() == CLASS_TYPE_CLERIC || PRCGetLastSpellCastClass() == CLASS_TYPE_UR_PRIEST) nSpellLevel = StringToInt(lookup_spell_cleric_level(nSpell));
else if (PRCGetLastSpellCastClass() == CLASS_TYPE_DRUID) nSpellLevel = StringToInt(lookup_spell_druid_level(nSpell));
else if (PRCGetLastSpellCastClass() == CLASS_TYPE_WIZARD || PRCGetLastSpellCastClass() == CLASS_TYPE_SORCERER) nSpellLevel = StringToInt(lookup_spell_level(nSpell));
// If none of these work, check the innate level of the spell
if (nSpellLevel == 0) nSpellLevel = StringToInt(lookup_spell_innate(nSpell));
// Minimum level.
if (nSpellLevel == 0) nSpellLevel = 1;
int nCharges = 1;
FloatingTextStringOnCreature("Spell Level: " + IntToString(nSpellLevel), OBJECT_SELF, FALSE);
FloatingTextStringOnCreature("Caster Level: " + IntToString(nCaster), OBJECT_SELF, FALSE);
FloatingTextStringOnCreature("Number of Charges: " + IntToString(nCharges), OBJECT_SELF, FALSE);
// Gold cost multipler, varies depending on the ability used to craft
int nMultiplier = StringToInt(Get2DACache("prc_rune_craft", "Cost", PRC_GEM_BASECOST));
// Cost of the Gem in gold and XP
int nCost = nSpellLevel * nCaster * nMultiplier;
struct craft_cost_struct costs = GetModifiedCostsFromBase(nCost, oCaster, FEAT_ATTUNE_GEM, FALSE);
FloatingTextStringOnCreature("Gold Cost: " + IntToString(costs.nGoldCost), OBJECT_SELF, FALSE);
FloatingTextStringOnCreature("XP Cost: " + IntToString(costs.nXPCost), OBJECT_SELF, FALSE);
// See if the caster has enough gold and XP to scribe a Gem, and that he passes the skill check.
int nHD = GetHitDice(oCaster);
int nMinXPForLevel = ((nHD * (nHD - 1)) / 2) * 1000;
int nNewXP = GetXP(oCaster) - costs.nXPCost;
int nGold = GetGold(oCaster);
int nNewGold = nGold - costs.nGoldCost;
int nCheck = FALSE;
if (!GetHasGPToSpend(oCaster, costs.nGoldCost))
{
FloatingTextStringOnCreature("You do not have enough gold to scribe this Gem.", oCaster, FALSE);
// Since they don't have enough, the spell casts normally
return TRUE;
}
if (!GetHasXPToSpend(oCaster, costs.nXPCost) )
{
FloatingTextStringOnCreature("You do not have enough experience to scribe this Gem.", oCaster, FALSE);
// Since they don't have enough, the spell casts normally
return TRUE;
}
// Is the gem worth enough?
int nGemGold = GetGoldPieceValue(oTarget);
int nGemLevel = nGemGold / StringToInt(Get2DACache("prc_rune_craft", "Cost", PRC_GEM_PERLEVEL));
if (nGemLevel > 9) nGemLevel = 9;
if (nSpellLevel > nGemLevel)
{
FloatingTextStringOnCreature("Gem is not high enough level for this spell", oCaster, FALSE);
// The spell casts normally
return TRUE;
}
// Steal all the code from craft wand.
int nPropID = IPGetIPConstCastSpellFromSpellID(nSpell);
// * GZ 2003-09-11: If the current spell cast is not acid fog, and
// * returned property ID is 0, bail out to prevent
// * creation of acid fog items.
if (nPropID == 0 && nSpell != 0)
{
FloatingTextStrRefOnCreature(84544,oCaster);
return TRUE;
}
//check spell emulation
if(!CheckAlternativeCrafting(oCaster, nSpell, costs))
{
FloatingTextStringOnCreature("*Crafting failed!*", oCaster, FALSE);
return TRUE;
}
if (nPropID != -1)
{
itemproperty ipLevel = ItemPropertyCastSpellCasterLevel(nSpell, PRCGetCasterLevel());
AddItemProperty(DURATION_TYPE_PERMANENT,ipLevel,oTarget);
itemproperty ipMeta = ItemPropertyCastSpellMetamagic(nSpell, PRCGetMetaMagicFeat());
AddItemProperty(DURATION_TYPE_PERMANENT,ipMeta,oTarget);
itemproperty ipDC = ItemPropertyCastSpellDC(nSpell, PRCGetSaveDC(PRCGetSpellTargetObject(), OBJECT_SELF));
AddItemProperty(DURATION_TYPE_PERMANENT,ipDC,oTarget);
if (nCharges == 1) // This is to handle one use Gems so the spellhooking works
{
itemproperty ipProp = ItemPropertyCastSpell(nPropID,IP_CONST_CASTSPELL_NUMUSES_2_CHARGES_PER_USE);
AddItemProperty(DURATION_TYPE_PERMANENT,ipProp,oTarget);
// This is done so the item exists when it is used for the game to read data off of
nCharges = 3;
}
SetItemCharges(oTarget, nCharges);
SetXP(oCaster, nNewXP);
TakeGoldFromCreature(costs.nGoldCost, oCaster, TRUE);
string sName;
sName = Get2DACache("spells", "Name", nSpell);
sName = "Gem of "+GetStringByStrRef(StringToInt(sName));
SetName(oTarget, sName);
// This is done to allow the item to be set properly, and then alter the tag
CopyObject(oTarget, GetLocation(oCaster), oCaster, "prc_attunegem");
DestroyObject(oTarget, 0.1);
}
// If we have made it this far, they have crafted the Gem and the spell has been used up, so it returns false.
return FALSE;
}
int CraftSkullTalisman(object oTarget = OBJECT_INVALID, object oCaster = OBJECT_INVALID, int nSpell = 0)
{
if(!GetIsObjectValid(oCaster)) oCaster = OBJECT_SELF;
// Get the item used to cast the spell
object oItem = GetSpellCastItem();
if (GetTag(oItem) == "prc_skulltalis")
{
string sName = GetName(GetItemPossessor(oItem));
if (DEBUG) FloatingTextStringOnCreature(sName + " has just cast a skull talisman spell", oCaster, FALSE);
if (DEBUG) DoDebug("Checking for One Use Skulls");
// This check is used to clear up the one use SkullTalismans
itemproperty ip = GetFirstItemProperty(oItem);
while(GetIsItemPropertyValid(ip))
{
if(GetItemPropertyType(ip) == ITEM_PROPERTY_CAST_SPELL)
{
if (DEBUG) DoDebug("Skull Talisman can cast spells");
if (GetItemPropertyCostTableValue(ip) == 5) // Only one use Skull Talismans have 2 charges per use
{
if(DEBUG) DoDebug("Skull Talisman has 2 charges a use, marking it a one use Skull Talisman");
// Give it enough time for the spell to finish casting
DestroyObject(oItem, 1.0);
if(DEBUG) DoDebug("Skull Talisman destroyed.");
}
}
ip = GetNextItemProperty(oItem);
}
}
// If Inscribing is turned off, the spell functions as normal
if(!GetLocalInt(oCaster, "CraftSkullTalisman")) return TRUE;
// No point being in here if you don't have SkullTalismans.
if(!GetHasFeat(FEAT_CRAFT_SKULL_TALISMAN, oCaster))
{
FloatingTextStrRefOnCreature(40487, oCaster); // Item Creation Failed - Don't know how to create that type of item
return TRUE; // tried item creation but do not know how to do it
}
// No point scribing SkullTalismans from items, and its not allowed.
if (oItem != OBJECT_INVALID)
{
FloatingTextStringOnCreature("You cannot scribe a Skull Talisman from an item.", oCaster, FALSE);
return TRUE;
}
// oTarget here should be the Caster.
if(!GetIsObjectValid(oTarget)) oTarget = PRCGetSpellTargetObject();
int nCaster = GetAlternativeCasterLevel(oCaster, PRCGetCasterLevel(oCaster));
int nDC = PRCGetSaveDC(oTarget, oCaster);
if(!nSpell) nSpell = PRCGetSpellId();
int nSpellLevel;
if (PRCGetLastSpellCastClass() == CLASS_TYPE_CLERIC || PRCGetLastSpellCastClass() == CLASS_TYPE_UR_PRIEST) nSpellLevel = StringToInt(lookup_spell_cleric_level(nSpell));
else if (PRCGetLastSpellCastClass() == CLASS_TYPE_DRUID) nSpellLevel = StringToInt(lookup_spell_druid_level(nSpell));
else if (PRCGetLastSpellCastClass() == CLASS_TYPE_WIZARD || PRCGetLastSpellCastClass() == CLASS_TYPE_SORCERER) nSpellLevel = StringToInt(lookup_spell_level(nSpell));
// If none of these work, check the innate level of the spell
if (nSpellLevel == 0) nSpellLevel = StringToInt(lookup_spell_innate(nSpell));
// Minimum level.
if (nSpellLevel == 0) nSpellLevel = 1;
int nCharges = 1;
FloatingTextStringOnCreature("Spell Level: " + IntToString(nSpellLevel), OBJECT_SELF, FALSE);
FloatingTextStringOnCreature("Caster Level: " + IntToString(nCaster), OBJECT_SELF, FALSE);
// Gold cost multipler, varies depending on the ability used to craft
int nMultiplier = StringToInt(Get2DACache("prc_rune_craft", "Cost", PRC_SKULL_BASECOST));
// Cost of the Skull Talisman in gold and XP
int nCost = nSpellLevel * nCaster * nMultiplier;
struct craft_cost_struct costs = GetModifiedCostsFromBase(nCost, oCaster, FEAT_CRAFT_SKULL_TALISMAN, FALSE);
FloatingTextStringOnCreature("Gold Cost: " + IntToString(costs.nGoldCost), OBJECT_SELF, FALSE);
FloatingTextStringOnCreature("XP Cost: " + IntToString(costs.nXPCost), OBJECT_SELF, FALSE);
// See if the caster has enough gold and XP to scribe a Skull Talisman, and that he passes the skill check.
int nHD = GetHitDice(oCaster);
int nMinXPForLevel = ((nHD * (nHD - 1)) / 2) * 1000;
int nNewXP = GetXP(oCaster) - costs.nXPCost;
int nGold = GetGold(oCaster);
int nNewGold = nGold - costs.nGoldCost;
int nCheck = FALSE;
if (!GetHasGPToSpend(oCaster, costs.nGoldCost))
{
FloatingTextStringOnCreature("You do not have enough gold to scribe this SkullTalisman.", oCaster, FALSE);
// Since they don't have enough, the spell casts normally
return TRUE;
}
if (!GetHasXPToSpend(oCaster, costs.nXPCost) )
{
FloatingTextStringOnCreature("You do not have enough experience to scribe this SkullTalisman.", oCaster, FALSE);
// Since they don't have enough, the spell casts normally
return TRUE;
}
// Create the item to have all the effects applied to
oTarget = CreateItemOnObject("prc_skulltalis", oCaster, 1);
// Steal all the code from craft wand.
int nPropID = IPGetIPConstCastSpellFromSpellID(nSpell);
// * GZ 2003-09-11: If the current spell cast is not acid fog, and
// * returned property ID is 0, bail out to prevent
// * creation of acid fog items.
if (nPropID == 0 && nSpell != 0)
{
FloatingTextStrRefOnCreature(84544,oCaster);
return TRUE;
}
//check spell emulation
if(!CheckAlternativeCrafting(oCaster, nSpell, costs))
{
FloatingTextStringOnCreature("*Crafting failed!*", oCaster, FALSE);
return TRUE;
}
if (nPropID != -1)
{
itemproperty ipLevel = ItemPropertyCastSpellCasterLevel(nSpell, PRCGetCasterLevel());
AddItemProperty(DURATION_TYPE_PERMANENT,ipLevel,oTarget);
itemproperty ipMeta = ItemPropertyCastSpellMetamagic(nSpell, PRCGetMetaMagicFeat());
AddItemProperty(DURATION_TYPE_PERMANENT,ipMeta,oTarget);
itemproperty ipDC = ItemPropertyCastSpellDC(nSpell, PRCGetSaveDC(PRCGetSpellTargetObject(), OBJECT_SELF));
AddItemProperty(DURATION_TYPE_PERMANENT,ipDC,oTarget);
if (nCharges == 1) // This is to handle one use Skull Talismans so the spellhooking works
{
itemproperty ipProp = ItemPropertyCastSpell(nPropID,IP_CONST_CASTSPELL_NUMUSES_2_CHARGES_PER_USE);
AddItemProperty(DURATION_TYPE_PERMANENT,ipProp,oTarget);
// This is done so the item exists when it is used for the game to read data off of
nCharges = 3;
}
SetItemCharges(oTarget, nCharges);
SetXP(oCaster, nNewXP);
TakeGoldFromCreature(costs.nGoldCost, oCaster, TRUE);
string sName;
sName = Get2DACache("spells", "Name", nSpell);
sName = "Skull Talisman of "+ GetStringByStrRef(StringToInt(sName));
SetName(oTarget, sName);
// This is done to allow the item to be set properly, and then alter the tag
CopyObject(oTarget, GetLocation(oCaster), oCaster, "prc_skulltalis");
DestroyObject(oTarget, 0.1);
}
// If we have made it this far, they have crafted the Skull Talisman and the spell has been used up, so it returns false.
return FALSE;
}
// -----------------------------------------------------------------------------
// Georg, July 2003
// Checks if the caster intends to use his item creation feats and
// calls appropriate item creation subroutine if conditions are met
// (spell cast on correct item, etc).
// Returns TRUE if the spell was used for an item creation feat
// -----------------------------------------------------------------------------
int CIGetSpellWasUsedForItemCreation(object oSpellTarget)
{
object oCaster = OBJECT_SELF;
// -------------------------------------------------------------------------
// Spell cast on crafting base item (blank scroll, etc) ?
// -------------------------------------------------------------------------
if (!CIGetIsCraftFeatBaseItem(oSpellTarget))
{
return FALSE; // not blank scroll baseitem
}
else
{
// ---------------------------------------------------------------------
// Check Item Creation Feats were disabled through x2_inc_switches
// ---------------------------------------------------------------------
if (GetModuleSwitchValue(MODULE_SWITCH_DISABLE_ITEM_CREATION_FEATS) == TRUE)
{
FloatingTextStrRefOnCreature(83612, oCaster); // * Item creation feats are not enabled in this module *
return FALSE;
}
if (GetLocalInt(GetArea(oCaster), PRC_AREA_DISABLE_CRAFTING))
{
FloatingTextStrRefOnCreature(16832014, oCaster); // * Item creation feats are not enabled in this area *
return FALSE;
}
// ---------------------------------------------------------------------
// Ensure that item creation does not work one item was cast on another
// ---------------------------------------------------------------------
if (GetSpellCastItem() != OBJECT_INVALID)
{
FloatingTextStrRefOnCreature(83373, oCaster); // can not use one item to enchant another
return TRUE;
}
// ---------------------------------------------------------------------
// Ok, what kind of feat the user wants to use by examining the base itm
// ---------------------------------------------------------------------
int nBt = GetBaseItemType(oSpellTarget);
int nRet = FALSE;
switch (nBt)
{
case BASE_ITEM_BLANK_POTION :
// -------------------------------------------------
// Brew Potion
// -------------------------------------------------
nRet = CICraftCheckBrewPotion(oSpellTarget,oCaster);
break;
case BASE_ITEM_BLANK_SCROLL :
// -------------------------------------------------
// Scribe Scroll
// -------------------------------------------------
nRet = CICraftCheckScribeScroll(oSpellTarget,oCaster);
break;
case BASE_ITEM_BLANK_WAND :
// -------------------------------------------------
// Craft Wand
// -------------------------------------------------
nRet = CICraftCheckCraftWand(oSpellTarget,oCaster);
break;
case BASE_ITEM_CRAFTED_ROD :
// -------------------------------------------------
// Craft Rod
// -------------------------------------------------
nRet = CICraftCheckCraftRod(oSpellTarget,oCaster);
break;
case BASE_ITEM_CRAFTED_STAFF :
// -------------------------------------------------
// Craft Staff
// -------------------------------------------------
nRet = CICraftCheckCraftStaff(oSpellTarget,oCaster);
break;
// you could add more crafting basetypes here....
}
return nRet;
}
}
// -----------------------------------------------------------------------------
// Makes oPC do a Craft check using nSkill to create the item supplied in sResRe
// If oContainer is specified, the item will be created there.
// Throwing weapons are created with stack sizes of 10, ammo with 20
// -----------------------------------------------------------------------------
object CIUseCraftItemSkill(object oPC, int nSkill, string sResRef, int nDC, object oContainer = OBJECT_INVALID)
{
int bSuccess = GetIsSkillSuccessful(oPC, nSkill, nDC);
object oNew;
if (bSuccess)
{
// actual item creation
// if a crafting container was specified, create inside
int bFix;
if (oContainer == OBJECT_INVALID)
{
//------------------------------------------------------------------
// We create the item in the work container to get rid of the
// stackable item problems that happen when we create the item
// directly on the player
//------------------------------------------------------------------
if (GetLevelByClass(CLASS_TYPE_IRONSOUL_FORGEMASTER, oPC))
oNew = CreateItemOnObject(sResRef,IPGetIPWorkContainer(oPC),1,GetName(oPC));
else
oNew = CreateItemOnObject(sResRef,IPGetIPWorkContainer(oPC));
bFix = TRUE;
}
else
{
if (GetLevelByClass(CLASS_TYPE_IRONSOUL_FORGEMASTER, oPC))
oNew = CreateItemOnObject(sResRef,oContainer,1,GetName(oPC));
else
oNew = CreateItemOnObject(sResRef,oContainer);
}
int nBase = GetBaseItemType(oNew);
if (nBase == BASE_ITEM_BOLT || nBase == BASE_ITEM_ARROW || nBase == BASE_ITEM_BULLET)
{
SetItemStackSize(oNew, 20);
}
else if (nBase == BASE_ITEM_THROWINGAXE || nBase == BASE_ITEM_SHURIKEN || nBase == BASE_ITEM_DART)
{
SetItemStackSize(oNew, 10);
}
//----------------------------------------------------------------------
// Get around the whole stackable item mess...
//----------------------------------------------------------------------
if (bFix)
{
object oRet = CopyObject(oNew,GetLocation(oPC),oPC);
DestroyObject(oNew);
oNew = oRet;
}
}
else
{
oNew = OBJECT_INVALID;
}
return oNew;
}
// -----------------------------------------------------------------------------
// georg, 2003-06-13 (
// Craft an item. This is only to be called from the crafting conversation
// spawned by x2_s2_crafting!!!
// -----------------------------------------------------------------------------
int CIDoCraftItemFromConversation(int nNumber)
{
string sNumber = IntToString(nNumber);
object oPC = GetPCSpeaker();
//object oMaterial = GetLocalObject(oPC,"X2_CI_CRAFT_MATERIAL");
object oMajor = GetLocalObject(oPC,"X2_CI_CRAFT_MAJOR");
object oMinor = GetLocalObject(oPC,"X2_CI_CRAFT_MINOR");
int nSkill = GetLocalInt(oPC,"X2_CI_CRAFT_SKILL");
int nMode = GetLocalInt(oPC,"X2_CI_CRAFT_MODE");
string sResult;
string s2DA;
int nDC;
DeleteLocalObject(oPC,"X2_CI_CRAFT_MAJOR");
DeleteLocalObject(oPC,"X2_CI_CRAFT_MINOR");
if (!GetIsObjectValid(oMajor))
{
FloatingTextStrRefOnCreature(83374,oPC); //"Invalid target"
DeleteLocalInt(oPC,"X2_CRAFT_SUCCESS");
return FALSE;
}
else
{
if (GetItemPossessor(oMajor) != oPC)
{
FloatingTextStrRefOnCreature(83354,oPC); //"Invalid target"
DeleteLocalInt(oPC,"X2_CRAFT_SUCCESS");
return FALSE;
}
}
// If we are in container mode,
if (nMode == X2_CI_CRAFTMODE_CONTAINER)
{
if (!GetIsObjectValid(oMinor))
{
FloatingTextStrRefOnCreature(83374,oPC); //"Invalid target"
DeleteLocalInt(oPC,"X2_CRAFT_SUCCESS");
return FALSE;
}
else if (GetItemPossessor(oMinor) != oPC)
{
FloatingTextStrRefOnCreature(83354,oPC); //"Invalid target"
DeleteLocalInt(oPC,"X2_CRAFT_SUCCESS");
return FALSE;
}
}
if (nSkill == 26) // craft weapon
{
s2DA = X2_CI_CRAFTING_WP_2DA;
}
else if (nSkill == 25)
{
s2DA = X2_CI_CRAFTING_AR_2DA;
}
int nRow = GetLocalInt(oPC,"X2_CI_CRAFT_RESULTROW");
struct craft_struct stItem = CIGetCraftItemStructFrom2DA(s2DA,nRow,nNumber);
object oContainer = OBJECT_INVALID;
// ---------------------------------------------------------------------------
// We once used a crafting container, but found it too complicated. Code is still
// left in here for the community
// ---------------------------------------------------------------------------
if (nMode == X2_CI_CRAFTMODE_CONTAINER)
{
oContainer = GetItemPossessedBy(oPC,"x2_it_craftcont");
}
// Do the crafting...
object oRet = CIUseCraftItemSkill( oPC, nSkill, stItem.sResRef, stItem.nDC, oContainer) ;
// * If you made an item, it should always be identified;
SetIdentified(oRet,TRUE);
if (GetIsObjectValid(oRet))
{
// -----------------------------------------------------------------------
// Copy all item properties from the major object on the resulting item
// Through we problably won't use this, its a neat thing to have for the
// community
// to enable magic item creation from the crafting system
// -----------------------------------------------------------------------
//if (GetGold(oPC)<stItem.nCost)
if (!GetHasGPToSpend(oPC, stItem.nCost))
{
DeleteLocalInt(oPC,"X2_CRAFT_SUCCESS");
FloatingTextStrRefOnCreature(86675,oPC);
DestroyObject(oRet);
return FALSE;
}
else
{
//TakeGoldFromCreature(stItem.nCost, oPC,TRUE);
SpendGP(oPC, stItem.nCost);
IPCopyItemProperties(oMajor,oRet);
}
// set success variable for conversation
SetLocalInt(oPC,"X2_CRAFT_SUCCESS",TRUE);
}
else
{
//TakeGoldFromCreature(stItem.nCost / 4, oPC,TRUE);
SpendGP(oPC, stItem.nCost/4);
// make sure there is no success
DeleteLocalInt(oPC,"X2_CRAFT_SUCCESS");
}
// Destroy first material component
DestroyObject (oMajor);
// if we are running in a container, destroy the second material component as well
if (nMode == X2_CI_CRAFTMODE_CONTAINER || nMode == X2_CI_CRAFTMODE_ASSEMBLE)
{
DestroyObject (oMinor);
}
int nRet = (oRet != OBJECT_INVALID);
return nRet;
}
// -----------------------------------------------------------------------------
// Retrieve craft information on a certain item
// -----------------------------------------------------------------------------
struct craft_struct CIGetCraftItemStructFrom2DA(string s2DA, int nRow, int nItemNo)
{
struct craft_struct stRet;
string sNumber = IntToString(nItemNo);
stRet.nRow = nRow;
string sLabel = Get2DACache(s2DA,"Label"+ sNumber, nRow);
if (sLabel == "")
{
return stRet; // empty, no need to read further
}
int nStrRef = StringToInt(sLabel);
if (nStrRef != 0) // Handle bioware StrRefs
{
sLabel = GetStringByStrRef(nStrRef);
}
stRet.sLabel = sLabel;
stRet.nDC = StringToInt(Get2DACache(s2DA,"DC"+ sNumber, nRow));
stRet.nCost = StringToInt(Get2DACache(s2DA,"CostGP"+ sNumber, nRow));
stRet.sResRef = Get2DACache(s2DA,"ResRef"+ sNumber, nRow);
return stRet;
}
// -----------------------------------------------------------------------------
// Return the cost
// -----------------------------------------------------------------------------
int CIGetItemPartModificationCost(object oOldItem, int nPart)
{
int nRet = StringToInt(Get2DACache(X2_IP_ARMORPARTS_2DA,"CraftCost",nPart));
nRet = (GetGoldPieceValue(oOldItem) / 100 * nRet);
// minimum cost for modification is 1 gp
if (nRet == 0)
{
nRet =1;
}
return nRet;
}
// -----------------------------------------------------------------------------
// Return the DC for modifying a certain armor part on oOldItem
// -----------------------------------------------------------------------------
int CIGetItemPartModificationDC(object oOldItem, int nPart)
{
int nRet = StringToInt(Get2DACache(X2_IP_ARMORPARTS_2DA,"CraftDC",nPart));
// minimum cost for modification is 1 gp
return nRet;
}
// -----------------------------------------------------------------------------
// returns the dc
// dc to modify oOlditem to look like oNewItem
// -----------------------------------------------------------------------------
int CIGetArmorModificationCost(object oOldItem, object oNewItem)
{
int nTotal = 0;
int nPart;
for (nPart = 0; nPart<ITEM_APPR_ARMOR_NUM_MODELS; nPart++)
{
if (GetItemAppearance(oOldItem,ITEM_APPR_TYPE_ARMOR_MODEL, nPart) !=GetItemAppearance(oNewItem,ITEM_APPR_TYPE_ARMOR_MODEL, nPart))
{
nTotal+= CIGetItemPartModificationCost(oOldItem,nPart);
}
}
// Modification Cost should not exceed value of old item +1 GP
if (nTotal > GetGoldPieceValue(oOldItem))
{
nTotal = GetGoldPieceValue(oOldItem)+1;
}
return nTotal;
}
// -----------------------------------------------------------------------------
// returns the cost in gold piece that it would
// cost to modify oOlditem to look like oNewItem
// -----------------------------------------------------------------------------
int CIGetArmorModificationDC(object oOldItem, object oNewItem)
{
int nTotal = 0;
int nPart;
int nDC =0;
for (nPart = 0; nPart<ITEM_APPR_ARMOR_NUM_MODELS; nPart++)
{
if (GetItemAppearance(oOldItem,ITEM_APPR_TYPE_ARMOR_MODEL, nPart) !=GetItemAppearance(oNewItem,ITEM_APPR_TYPE_ARMOR_MODEL, nPart))
{
nDC = CIGetItemPartModificationDC(oOldItem,nPart);
if (nDC>nTotal)
{
nTotal = nDC;
}
}
}
nTotal = GetItemACValue(oOldItem) + nTotal + 5;
return nTotal;
}
// -----------------------------------------------------------------------------
// returns TRUE if the spell matching nSpellID is prevented from being used
// with the CraftFeat matching nFeatID
// This is controlled in des_crft_spells.2da
// -----------------------------------------------------------------------------
int CIGetIsSpellRestrictedFromCraftFeat(int nSpellID, int nFeatID)
{
string sCol;
switch(nFeatID)
{
case X2_CI_BREWPOTION_FEAT_ID: sCol = "NoPotion"; break;
case X2_CI_SCRIBESCROLL_FEAT_ID: sCol = "NoScroll"; break;
case X2_CI_CRAFTWAND_FEAT_ID:
case X2_CI_CRAFTROD_FEAT_ID:
case X2_CI_CRAFTSTAFF_FEAT_ID: sCol = "NoWand"; break;
}
return !!StringToInt(Get2DACache(X2_CI_CRAFTING_SP_2DA,sCol,nSpellID));
}
// -----------------------------------------------------------------------------
// Retrieve the row in des_crft_bmat too look up receipe
// -----------------------------------------------------------------------------
int CIGetCraftingReceipeRow(int nMode, object oMajor, object oMinor, int nSkill)
{
if (nMode == X2_CI_CRAFTMODE_CONTAINER || nMode == X2_CI_CRAFTMODE_ASSEMBLE )
{
int nMinorId = StringToInt(Get2DACache("des_crft_amat",GetTag(oMinor),1));
int nMajorId = StringToInt(Get2DACache("des_crft_bmat",GetTag(oMajor),nMinorId));
return nMajorId;
}
else if (nMode == X2_CI_CRAFTMODE_BASE_ITEM)
{
int nLookUpRow;
string sTag = GetTag(oMajor);
switch (nSkill)
{
case 26: nLookUpRow =1 ; break;
case 25: nLookUpRow= 2 ; break;
}
int nRet = StringToInt(Get2DACache(X2_CI_CRAFTING_MAT_2DA,sTag,nLookUpRow));
return nRet;
}
else
{
return 0; // error
}
}
// -----------------------------------------------------------------------------
// used to set all variable required for the crafting conversation
// (Used materials, number of choises, 2da row, skill and mode)
// -----------------------------------------------------------------------------
void CISetupCraftingConversation(object oPC, int nNumber, int nSkill, int nReceipe, object oMajor, object oMinor, int nMode)
{
SetLocalObject(oPC,"X2_CI_CRAFT_MAJOR",oMajor);
if (nMode == X2_CI_CRAFTMODE_CONTAINER || nMode == X2_CI_CRAFTMODE_ASSEMBLE )
{
SetLocalObject(oPC,"X2_CI_CRAFT_MINOR", oMinor);
}
SetLocalInt(oPC,"X2_CI_CRAFT_NOOFITEMS",nNumber); // number of crafting choises for this material
SetLocalInt(oPC,"X2_CI_CRAFT_SKILL",nSkill); // skill used (craft armor or craft waeapon)
SetLocalInt(oPC,"X2_CI_CRAFT_RESULTROW",nReceipe); // number of crafting choises for this material
SetLocalInt(oPC,"X2_CI_CRAFT_MODE",nMode);
}
// -----------------------------------------------------------------------------
// oItem - The item used for crafting
// -----------------------------------------------------------------------------
struct craft_receipe_struct CIGetCraftingModeFromTarget(object oPC,object oTarget, object oItem = OBJECT_INVALID)
{
struct craft_receipe_struct stStruct;
if (GetBaseItemType(oItem) == 112 ) // small
{
stStruct.oMajor = oItem;
stStruct.nMode = X2_CI_CRAFTMODE_BASE_ITEM;
return stStruct;
}
if (!GetIsObjectValid(oTarget))
{
stStruct.nMode = X2_CI_CRAFTMODE_INVALID;
return stStruct;
}
// A small craftitem was used on a large one
if (GetBaseItemType(oItem) == 110 ) // small
{
if (GetBaseItemType(oTarget) == 109) // large
{
stStruct.nMode = X2_CI_CRAFTMODE_ASSEMBLE; // Mode is ASSEMBLE
stStruct.oMajor = oTarget;
stStruct.oMinor = oItem;
return stStruct;
}
else
{
FloatingTextStrRefOnCreature(84201,oPC);
}
}
// -----------------------------------------------------------------------------
// *** CONTAINER IS NO LONGER USED IN OFFICIAL CAMPAIGN
// BUT CODE LEFT IN FOR COMMUNITY.
// THE FOLLOWING CONDITION IS NEVER TRUE FOR THE OC (no crafting container)
// To reactivate, create a container with tag x2_it_craftcont
int bCraftCont = (GetTag(oTarget) == "x2_it_craftcont");
if (bCraftCont == TRUE)
{
// First item in container is baseitem .. mode = baseitem
if ( GetBaseItemType(GetFirstItemInInventory(oTarget)) == 112)
{
stStruct.nMode = X2_CI_CRAFTMODE_BASE_ITEM;
stStruct.oMajor = GetFirstItemInInventory(oTarget);
return stStruct;
}
else
{
object oTest = GetFirstItemInInventory(oTarget);
int nCount =1;
int bMajor = FALSE;
int bMinor = FALSE;
// No item in inventory ... mode = fail
if (!GetIsObjectValid(oTest))
{
FloatingTextStrRefOnCreature(84200,oPC);
stStruct.nMode = X2_CI_CRAFTMODE_INVALID;
return stStruct;
}
else
{
while (GetIsObjectValid(oTest) && nCount <3)
{
if (GetBaseItemType(oTest) == 109)
{
stStruct.oMajor = oTest;
bMajor = TRUE;
}
else if (GetBaseItemType(oTest) == 110)
{
stStruct.oMinor = oTest;
bMinor = TRUE;
}
else if ( GetBaseItemType(oTest) == 112)
{
stStruct.nMode = X2_CI_CRAFTMODE_BASE_ITEM;
stStruct.oMajor = oTest;
return stStruct;
}
oTest = GetNextItemInInventory(oTarget);
if (GetIsObjectValid(oTest))
{
nCount ++;
}
}
if (nCount >2)
{
FloatingTextStrRefOnCreature(84356,oPC);
stStruct.nMode = X2_CI_CRAFTMODE_INVALID;
return stStruct;
}
else if (nCount <2)
{
FloatingTextStrRefOnCreature(84356,oPC);
stStruct.nMode = X2_CI_CRAFTMODE_INVALID;
return stStruct;
}
if (bMajor && bMinor)
{
stStruct.nMode = X2_CI_CRAFTMODE_CONTAINER;
return stStruct;
}
else
{
FloatingTextStrRefOnCreature(84356,oPC);
//FloatingTextStringOnCreature("Temp: Wrong combination of items in the crafting container",oPC);
stStruct.nMode = X2_CI_CRAFTMODE_INVALID;
return stStruct;
}
}
}
}
else
{
// not a container but a baseitem
if (GetBaseItemType(oTarget) == 112)
{
stStruct.nMode = X2_CI_CRAFTMODE_BASE_ITEM;
stStruct.oMajor = oTarget;
return stStruct;
}
else
{
if (GetBaseItemType(oTarget) == 109 || GetBaseItemType(oTarget) == 110)
{
FloatingTextStrRefOnCreature(84357,oPC);
stStruct.nMode = X2_CI_CRAFTMODE_INVALID;
return stStruct;
}
else
{
FloatingTextStrRefOnCreature(84357,oPC);
// not a valid item
stStruct.nMode = X2_CI_CRAFTMODE_INVALID;
return stStruct;
}
}
}
}
// -----------------------------------------------------------------------------
// *** Crafting Conversation Functions ***
// -----------------------------------------------------------------------------
int CIGetInModWeaponOrArmorConv(object oPC)
{
return GetLocalInt(oPC,"X2_L_CRAFT_MODIFY_CONVERSATION");
}
void CISetCurrentModMode(object oPC, int nMode)
{
if (nMode == X2_CI_MODMODE_INVALID)
{
DeleteLocalInt(oPC,"X2_L_CRAFT_MODIFY_MODE");
}
else
{
SetLocalInt(oPC,"X2_L_CRAFT_MODIFY_MODE",nMode);
}
}
int CIGetCurrentModMode(object oPC)
{
return GetLocalInt(oPC,"X2_L_CRAFT_MODIFY_MODE");
}
object CIGetCurrentModBackup(object oPC)
{
return GetLocalObject(GetPCSpeaker(),"X2_O_CRAFT_MODIFY_BACKUP");
}
object CIGetCurrentModItem(object oPC)
{
return GetLocalObject(GetPCSpeaker(),"X2_O_CRAFT_MODIFY_ITEM");
}
void CISetCurrentModBackup(object oPC, object oBackup)
{
SetLocalObject(GetPCSpeaker(),"X2_O_CRAFT_MODIFY_BACKUP",oBackup);
}
void CISetCurrentModItem(object oPC, object oItem)
{
SetLocalObject(GetPCSpeaker(),"X2_O_CRAFT_MODIFY_ITEM",oItem);
}
// -----------------------------------------------------------------------------
// * This does multiple things:
// - store the part currently modified
// - setup the custom token for the conversation
// - zoom the camera to that part
// -----------------------------------------------------------------------------
void CISetCurrentModPart(object oPC, int nPart, int nStrRef)
{
SetLocalInt(oPC,"X2_TAILOR_CURRENT_PART",nPart);
if (CIGetCurrentModMode(oPC) == X2_CI_MODMODE_ARMOR)
{
// * Make the camera float near the PC
float fFacing = GetFacing(oPC) + 180.0;
if (nPart == ITEM_APPR_ARMOR_MODEL_LSHOULDER || nPart == ITEM_APPR_ARMOR_MODEL_LFOREARM ||
nPart == ITEM_APPR_ARMOR_MODEL_LHAND || nPart == ITEM_APPR_ARMOR_MODEL_LBICEP)
{
fFacing += 80.0;
}
if (nPart == ITEM_APPR_ARMOR_MODEL_RSHOULDER || nPart == ITEM_APPR_ARMOR_MODEL_RFOREARM ||
nPart == ITEM_APPR_ARMOR_MODEL_RHAND || nPart == ITEM_APPR_ARMOR_MODEL_RBICEP)
{
fFacing -= 80.0;
}
float fPitch = 75.0;
if (fFacing > 359.0)
{
fFacing -=359.0;
}
float fDistance = 3.5f;
if (nPart == ITEM_APPR_ARMOR_MODEL_PELVIS || nPart == ITEM_APPR_ARMOR_MODEL_BELT )
{
fDistance = 2.0f;
}
if (nPart == ITEM_APPR_ARMOR_MODEL_LSHOULDER || nPart == ITEM_APPR_ARMOR_MODEL_RSHOULDER )
{
fPitch = 50.0f;
fDistance = 3.0f;
}
else if (nPart == ITEM_APPR_ARMOR_MODEL_LFOREARM || nPart == ITEM_APPR_ARMOR_MODEL_LHAND)
{
fDistance = 2.0f;
fPitch = 60.0f;
}
else if (nPart == ITEM_APPR_ARMOR_MODEL_NECK)
{
fPitch = 90.0f;
}
else if (nPart == ITEM_APPR_ARMOR_MODEL_RFOOT || nPart == ITEM_APPR_ARMOR_MODEL_LFOOT )
{
fDistance = 3.5f;
fPitch = 47.0f;
}
else if (nPart == ITEM_APPR_ARMOR_MODEL_LTHIGH || nPart == ITEM_APPR_ARMOR_MODEL_RTHIGH )
{
fDistance = 2.5f;
fPitch = 65.0f;
}
else if ( nPart == ITEM_APPR_ARMOR_MODEL_RSHIN || nPart == ITEM_APPR_ARMOR_MODEL_LSHIN )
{
fDistance = 3.5f;
fPitch = 95.0f;
}
if (GetRacialType(oPC) == RACIAL_TYPE_HALFORC)
{
fDistance += 1.0f;
}
SetCameraFacing(fFacing, fDistance, fPitch,CAMERA_TRANSITION_TYPE_VERY_FAST) ;
}
int nCost = GetLocalInt(oPC,"X2_TAILOR_CURRENT_COST");
int nDC = GetLocalInt(oPC,"X2_TAILOR_CURRENT_DC");
SetCustomToken(X2_CI_MODIFYARMOR_GP_CTOKENBASE,IntToString(nCost));
SetCustomToken(X2_CI_MODIFYARMOR_GP_CTOKENBASE+1,IntToString(nDC));
SetCustomToken(XP_IP_ITEMMODCONVERSATION_CTOKENBASE,GetStringByStrRef(nStrRef));
}
int CIGetCurrentModPart(object oPC)
{
return GetLocalInt(oPC,"X2_TAILOR_CURRENT_PART");
}
void CISetDefaultModItemCamera(object oPC)
{
float fDistance = 3.5f;
float fPitch = 75.0f;
float fFacing;
if (CIGetCurrentModMode(oPC) == X2_CI_MODMODE_ARMOR)
{
fFacing = GetFacing(oPC) + 180.0;
if (fFacing > 359.0)
{
fFacing -=359.0;
}
}
else if (CIGetCurrentModMode(oPC) == X2_CI_MODMODE_WEAPON)
{
fFacing = GetFacing(oPC) + 180.0;
fFacing -= 90.0;
if (fFacing > 359.0)
{
fFacing -=359.0;
}
}
SetCameraFacing(fFacing, fDistance, fPitch,CAMERA_TRANSITION_TYPE_VERY_FAST) ;
}
void CIUpdateModItemCostDC(object oPC, int nDC, int nCost)
{
SetLocalInt(oPC,"X2_TAILOR_CURRENT_COST", nCost);
SetLocalInt(oPC,"X2_TAILOR_CURRENT_DC",nDC);
SetCustomToken(X2_CI_MODIFYARMOR_GP_CTOKENBASE,IntToString(nCost));
SetCustomToken(X2_CI_MODIFYARMOR_GP_CTOKENBASE+1,IntToString(nDC));
}
// dc to modify oOlditem to look like oNewItem
int CIGetWeaponModificationCost(object oOldItem, object oNewItem)
{
int nTotal = 0;
int nPart;
for (nPart = 0; nPart<=2; nPart++)
{
if (GetItemAppearance(oOldItem,ITEM_APPR_TYPE_WEAPON_MODEL, nPart) !=GetItemAppearance(oNewItem,ITEM_APPR_TYPE_WEAPON_MODEL, nPart))
{
nTotal+= (GetGoldPieceValue(oOldItem)/4)+1;
}
}
// Modification Cost should not exceed value of old item +1 GP
if (nTotal > GetGoldPieceValue(oOldItem))
{
nTotal = GetGoldPieceValue(oOldItem)+1;
}
return nTotal;
}
int GetMagicalArtisanFeat(int nCraftingFeat)
{
int nReturn = 0;
switch(nCraftingFeat)
{
case FEAT_BREW_POTION:
{
nReturn = FEAT_MAGICAL_ARTISAN_BREW_POTION;
break;
}
case FEAT_SCRIBE_SCROLL:
{
nReturn = FEAT_MAGICAL_ARTISAN_SCRIBE_SCROLL;
break;
}
case FEAT_INSCRIBE_RUNE:
{
nReturn = FEAT_MAGICAL_ARTISAN_INSCRIBE_RUNE;
break;
}
case FEAT_ATTUNE_GEM:
{
nReturn = FEAT_MAGICAL_ARTISAN_ATTUNE_GEM;
break;
}
case FEAT_CRAFT_ARMS_ARMOR:
{
nReturn = FEAT_MAGICAL_ARTISAN_CRAFT_MAGIC_ARMS;
break;
}
case FEAT_CRAFT_ROD:
{
nReturn = FEAT_MAGICAL_ARTISAN_CRAFT_ROD;
break;
}
case FEAT_CRAFT_STAFF:
{
nReturn = FEAT_MAGICAL_ARTISAN_CRAFT_STAFF;
break;
}
case FEAT_CRAFT_WAND:
{
nReturn = FEAT_MAGICAL_ARTISAN_CRAFT_WAND;
break;
}
case FEAT_CRAFT_WONDROUS:
{
nReturn = FEAT_MAGICAL_ARTISAN_CRAFT_WONDROUS;
break;
}
case FEAT_FORGE_RING:
{
nReturn = FEAT_MAGICAL_ARTISAN_FORGE_RING;
break;
}
case FEAT_CRAFT_SKULL_TALISMAN:
{
nReturn = FEAT_MAGICAL_ARTISAN_CRAFT_SKULL_TALISMAN;
break;
}
default:
{
if(DEBUG) DoDebug("GetMagicalArtisanFeat: invalid crafting feat");
break;
}
}
return nReturn;
}
int GetPnPItemXPCost(int nCost, int bEpic)
{
int nXP = nCost / 25;
if(bEpic) nXP = (nCost / 100) + 10000;
return nXP;
}
int GetCraftingTime(int nCost)
{
int nTemp = nCost / 1000;
if(nCost % 1000) nTemp++;
float fDelay;
switch(GetPRCSwitch(PRC_CRAFTING_TIME_SCALE))
{
case 0: fDelay = HoursToSeconds(nTemp); break; //1 hour/1000gp, default
case 1: fDelay = 0.0; break; //off, no delay
case 2: fDelay = RoundsToSeconds(nTemp); break; //1 round/1000gp
case 3: fDelay = TurnsToSeconds(nTemp); break; //1 turn/1000gp
case 4: fDelay = HoursToSeconds(nTemp); break; //1 hour/1000gp
case 5: fDelay = 24 * HoursToSeconds(nTemp); break; //1 day/1000gp
}
int nMultiplyer = GetPRCSwitch(PRC_CRAFT_TIMER_MULTIPLIER);
if(nMultiplyer)
fDelay *= (IntToFloat(nMultiplyer) / 100.0);
return FloatToInt(fDelay / 6);
}
int GetModifiedGoldCost(int nCost, object oPC, int nCraftingFeat)
{
if(nCost == 0)
return nCost;
float fCost = IntToFloat(nCost);
if(GetHasFeat(FEAT_EXTRAORDINARY_ARTISAN_I , oPC)) fCost *= 0.75;
if(GetHasFeat(FEAT_EXTRAORDINARY_ARTISAN_II , oPC)) fCost *= 0.75;
if(GetHasFeat(FEAT_EXTRAORDINARY_ARTISAN_III , oPC)) fCost *= 0.75;
if(GetHasFeat(GetMagicalArtisanFeat(nCraftingFeat), oPC)) fCost *= 0.75;
if(GetHasFeat(FEAT_SHIELD_DWARF_WARDER, oPC) && FEAT_CRAFT_ARMS_ARMOR == nCraftingFeat) fCost *= 0.95;
int nScale = GetPRCSwitch(PRC_CRAFTING_COST_SCALE);
if(nScale > 0)
{ //you're not getting away with negative values that easily :P
fCost = fCost * IntToFloat(nScale) / 100.0;
}
return FloatToInt(fCost);
}
int GetModifiedXPCost(int nCost, object oPC, int nCraftingFeat)
{
if(nCost == 0)
return nCost;
float fCost = IntToFloat(nCost);
if(GetHasFeat(FEAT_LEGENDARY_ARTISAN_I , oPC)) fCost *= 0.75;
if(GetHasFeat(FEAT_LEGENDARY_ARTISAN_II , oPC)) fCost *= 0.75;
if(GetHasFeat(FEAT_LEGENDARY_ARTISAN_III , oPC)) fCost *= 0.75;
if(GetHasFeat(GetMagicalArtisanFeat(nCraftingFeat), oPC)) fCost *= 0.75;
int nScale = GetPRCSwitch(PRC_CRAFTING_COST_SCALE);
if(nScale > 0)
{ //you're not getting away with negative values that easily :P
fCost = fCost * IntToFloat(nScale) / 100.0;
}
return FloatToInt(fCost);
}
int GetModifiedTimeCost(int nCost, object oPC, int nCraftingFeat)
{
if(nCost == 0)
return nCost;
float fCost = IntToFloat(nCost);
if(GetLevelByClass(CLASS_TYPE_MAESTER, oPC)) fCost /= 2;
if(GetHasFeat(FEAT_EXCEPTIONAL_ARTISAN_I , oPC)) fCost *= 0.75;
if(GetHasFeat(FEAT_EXCEPTIONAL_ARTISAN_II , oPC)) fCost *= 0.75;
if(GetHasFeat(FEAT_EXCEPTIONAL_ARTISAN_III , oPC)) fCost *= 0.75;
if(GetHasFeat(GetMagicalArtisanFeat(nCraftingFeat), oPC)) fCost *= 0.75;
if(nCraftingFeat == FEAT_BREW_POTION)
{ //master alchemist stuff here
if(GetHasFeat(FEAT_BREW_4PERDAY , oPC)) fCost /= 4;
else if(GetHasFeat(FEAT_BREW_3PERDAY , oPC)) fCost /= 3;
else if(GetHasFeat(FEAT_BREW_2PERDAY , oPC)) fCost /= 2;
}
int nScale = GetPRCSwitch(PRC_CRAFTING_COST_SCALE);
if(nScale > 0)
{ //you're not getting away with negative values that easily :P
fCost = fCost * IntToFloat(nScale) / 100.0;
}
return FloatToInt(fCost);
}
struct craft_cost_struct GetModifiedCostsFromBase(int nCost, object oPC, int nCraftingFeat, int bEpic)
{
struct craft_cost_struct costs;
costs.nGoldCost = GetModifiedGoldCost(nCost / 2, oPC, nCraftingFeat);
costs.nXPCost = GetModifiedXPCost(GetPnPItemXPCost(nCost, bEpic), oPC, nCraftingFeat);
costs.nTimeCost = GetModifiedTimeCost(GetCraftingTime(nCost), oPC, nCraftingFeat);
return costs;
}
//Checks crafting prereqs for warlocks
int CheckImbueItem(object oPC, int nSpell)
{
if(!GetHasFeat(FEAT_IMBUE_ITEM, oPC)) return FALSE;
int nImbueDC;
int bArcane = TRUE;
int nLevel;
int nArcaneSpellLevel;
int nDivineSpellLevel;
string sTemp;
sTemp = Get2DACache("spells", "Wiz_Sorc", nSpell);
if(sTemp == "")
{
sTemp = Get2DACache("spells", "Bard", nSpell);
if(sTemp == "")
{
bArcane = FALSE; //now checking the divine classes
sTemp = Get2DACache("spells", "Cleric", nSpell);
if(sTemp == "")
{
sTemp = Get2DACache("spells", "Druid", nSpell);
if(sTemp == "")
{
sTemp = Get2DACache("spells", "Paladin", nSpell);
if(sTemp == "")
{
sTemp = Get2DACache("spells", "Ranger", nSpell);
if(sTemp == "")
{
if(DEBUG) DoDebug("CheckImbueItem: ERROR - spell is neither arcane nor divine");
return FALSE;
}
}
}
}
}
}
//warlocks with deceive item get to take 10
return GetPRCIsSkillSuccessful(oPC, SKILL_USE_MAGIC_DEVICE, StringToInt(sTemp) + (bArcane ? 15 : 25), GetHasFeat(FEAT_DECEIVE_ITEM, oPC) ? 10 : -1);
}
// checks alternative crafting, eg. warlock, artificer
int CheckAlternativeCrafting(object oPC, int nSpell, struct craft_cost_struct costs)
{
//nSpell1 = (PRCGetHasSpell(nTemp, oPC)) ? -1 : StringToInt(Get2DACache("spells", "Innate", nTemp)) + 20;
//if(nSpell1 == -1) nSpell1 = (GetPRCIsSkillSuccessful(oPC, SKILL_USE_MAGIC_DEVICE, nSpell1, bTake10)) ? -1 : nSpell1;
int bChecked = FALSE;
int bSuccess = FALSE;
int i;
int bTake10 = GetHasFeat(FEAT_SKILL_MASTERY_ARTIFICER, oPC) ? 10 : -1;
//artificer crafting check
if(!bSuccess && GetLocalInt(oPC, "ArtificerCrafting"))
{
bChecked = TRUE;
//bSuccess = CheckImbueItem(oPC, nSpell);
for(i = 0; i < costs.nTimeCost; i++)
{
bSuccess = GetPRCIsSkillSuccessful(oPC, SKILL_USE_MAGIC_DEVICE, StringToInt(Get2DACache("spells", "Innate", nSpell)) + 20, bTake10);
if(bSuccess)
break;
}
}
//warlock crafting check
if(!bSuccess && GetLocalInt(oPC, "UsingImbueItem"))
{
bChecked = TRUE;
bSuccess = CheckImbueItem(oPC, nSpell);
}
if(!bChecked)
return TRUE; //we never checked because we had the actual spell, so successful
else
return bSuccess;
}
int GetAlternativeCasterLevel(object oPC, int nLevel)
{
// Battlesmith adds 3x class level to caster level for casting
nLevel += GetLevelByClass(CLASS_TYPE_BATTLESMITH) * 3;
nLevel += GetLevelByClass(CLASS_TYPE_IRONSOUL_FORGEMASTER) * 3;
if(GetLocalInt(oPC, "UsingImbueItem"))
{
nLevel = max(GetLocalInt(oPC, "InvokerLevel"), nLevel);
}
if(GetLocalInt(oPC, "ArtificerCrafting"))
{
nLevel = max(GetLevelByClass(CLASS_TYPE_ARTIFICER, oPC), nLevel);
}
return nLevel;
}
// Test main
//void main(){}