e641b42f84
Updated Vow of Poverty. Added Sanctify Ki Strike, Holy Strike, Fist of Heavens, Vow of Abstinence, Vow of Chastity & Gift of Faith. (@fenac). Turned off the Taunt & Parry skills. Re-disabled AC & save bonuses from Tumble & Spellcraft. Updated min() & max() to PRCmin() & PRCmax() to not conflict with similarly named NUI adjacent functions. Set Point Blank Shot to 30' per PnP. Added icon for Chosen of Evil. Started work on Hidden Talent. Created Psionics function cheatsheet. Updated release archive.
2954 lines
114 KiB
Plaintext
2954 lines
114 KiB
Plaintext
/*
|
||
prc_craft_include
|
||
|
||
Include file for forge scripts, currently restricted to equipable items
|
||
|
||
By: Flaming_Sword
|
||
Created: Jul 12, 2006
|
||
Modified: Nov 5, 2007
|
||
|
||
GetItemPropertySubType() returns 0 or 65535, not -1
|
||
on no subtype as in Lexicon
|
||
|
||
Some hardcoded functions for itemprops to avoid looping through
|
||
the 2das multiple times:
|
||
|
||
Get2DALineFromItemprop()
|
||
DisallowType()
|
||
PrereqSpecialHandling()
|
||
PropSpecialHandling()
|
||
|
||
*/
|
||
|
||
itemproperty ConstructIP(int nType, int nSubTypeValue = 0, int nCostTableValue = 0, int nParam1Value = 0);
|
||
|
||
//Partly ripped off the lexicon :P
|
||
int GetItemBaseAC(object oItem);
|
||
|
||
int GetItemArmourCheckPenalty(object oItem);
|
||
|
||
int GetCraftingFeat(object oItem);
|
||
|
||
string GetItemPropertyString(itemproperty ip);
|
||
|
||
struct ipstruct GetIpStructFromString(string sIp);
|
||
|
||
#include "psi_inc_psifunc"
|
||
|
||
//#include "prc_inc_spells" //Most core functions are
|
||
//accessd through psi_inc_core
|
||
//#include "prc_inc_listener"
|
||
#include "prc_inc_chat"
|
||
#include "prc_x2_craft"
|
||
|
||
const int NUM_MAX_PROPERTIES = 200;
|
||
const int NUM_MAX_SUBTYPES = 256;
|
||
//const int NUM_MAX_FEAT_SUBTYPES = 16384; //because iprp_feats is frickin' huge
|
||
const int NUM_MAX_FEAT_SUBTYPES = 397; //because the above screwed the game
|
||
|
||
//const int NUM_MAX_SPELL_SUBTYPES = 540; //restricted to bioware spells
|
||
// to avoid crashes
|
||
const int NUM_MAX_SPELL_SUBTYPES = 1172; //new value for list skipping
|
||
|
||
const int PRC_CRAFT_SIMPLE_WEAPON = 1;
|
||
const int PRC_CRAFT_MARTIAL_WEAPON = 2;
|
||
const int PRC_CRAFT_EXOTIC_WEAPON = 3;
|
||
|
||
const int PRC_CRAFT_MATERIAL_METAL = 1;
|
||
const int PRC_CRAFT_MATERIAL_WOOD = 2;
|
||
const int PRC_CRAFT_MATERIAL_LEATHER = 3;
|
||
const int PRC_CRAFT_MATERIAL_CLOTH = 4;
|
||
|
||
const string PRC_CRAFT_UID_SUFFIX = "_UID_PRC";
|
||
const string PRC_CRAFT_STORAGE_CHEST = "PRC_CRAFT_STORAGE_CHEST";
|
||
const string PRC_CRAFT_TEMPORARY_CHEST = "PRC_CRAFT_TEMPORARY_CHEST";
|
||
const string PRC_CRAFT_ITEMPROP_ARRAY = "PRC_CRAFT_ITEMPROP_ARRAY";
|
||
|
||
const int PRC_CRAFT_FLAG_NONE = 0;
|
||
const int PRC_CRAFT_FLAG_MASTERWORK = 1;
|
||
const int PRC_CRAFT_FLAG_ADAMANTINE = 2;
|
||
const int PRC_CRAFT_FLAG_DARKWOOD = 4;
|
||
const int PRC_CRAFT_FLAG_DRAGONHIDE = 8;
|
||
const int PRC_CRAFT_FLAG_MITHRAL = 16;
|
||
const int PRC_CRAFT_FLAG_COLD_IRON = 32; //not implemented
|
||
const int PRC_CRAFT_FLAG_ALCHEMICAL_SILVER = 64; //not implemented
|
||
const int PRC_CRAFT_FLAG_MUNDANE_CRYSTAL = 128;
|
||
const int PRC_CRAFT_FLAG_DEEP_CRYSTAL = 256;
|
||
|
||
const int PRC_CRAFT_ITEM_TYPE_WEAPON = 1;
|
||
const int PRC_CRAFT_ITEM_TYPE_ARMOUR = 2;
|
||
const int PRC_CRAFT_ITEM_TYPE_SHIELD = 3;
|
||
const int PRC_CRAFT_ITEM_TYPE_AMMO = 4;
|
||
const int PRC_CRAFT_ITEM_TYPE_MISC = 5;
|
||
const int PRC_CRAFT_ITEM_TYPE_CASTSPELL = 6;
|
||
const int PRC_CRAFT_ITEM_TYPE_SPECIAL = 7;
|
||
|
||
const string PRC_CRAFT_SPECIAL_BANE = "PRC_CRAFT_SPECIAL_BANE";
|
||
const string PRC_CRAFT_SPECIAL_BANE_RACE = "PRC_CRAFT_SPECIAL_BANE_RACE";
|
||
|
||
const string PRC_CRAFT_LISTEN = "PRC_CRAFT_LISTEN";
|
||
|
||
const string PRC_CRAFT_APPEARANCE_ARRAY = "PRC_CRAFT_APPEARANCE_ARRAY";
|
||
const string PRC_IP_ARRAY = "PRC_IP_ARRAY";
|
||
|
||
const int PRC_CRAFT_LISTEN_SETNAME = 1;
|
||
const int PRC_CRAFT_LISTEN_SETAPPEARANCE = 2;
|
||
/*
|
||
const int PRC_CRAFT_LISTEN_SETNAME = 1;
|
||
const int PRC_CRAFT_LISTEN_SETNAME = 1;
|
||
const int PRC_CRAFT_LISTEN_SETNAME = 1;
|
||
const int PRC_CRAFT_LISTEN_SETNAME = 1;
|
||
const int PRC_CRAFT_LISTEN_SETNAME = 1;
|
||
*/
|
||
|
||
const string PRC_CRAFT_TOKEN = "PRC_CRAFT_TOKEN";
|
||
|
||
const int CRAFT_COST_TYPE_INVALID = 0;
|
||
const int CRAFT_COST_TYPE_MARKET = 1;
|
||
const int CRAFT_COST_TYPE_CRAFTING = 2;
|
||
const int CRAFT_COST_TYPE_XP = 3;
|
||
|
||
struct itemvars
|
||
{
|
||
object item;
|
||
int enhancement;
|
||
int additionalcost;
|
||
int epic;
|
||
};
|
||
|
||
struct ipstruct
|
||
{
|
||
int type;
|
||
int subtype;
|
||
int costtablevalue;
|
||
int param1value;
|
||
};
|
||
|
||
struct golemhds
|
||
{
|
||
int base;
|
||
int max1;
|
||
int max2;
|
||
};
|
||
|
||
object GetCraftChest()
|
||
{
|
||
return GetObjectByTag(PRC_CRAFT_STORAGE_CHEST);
|
||
}
|
||
|
||
object GetTempCraftChest()
|
||
{
|
||
return GetObjectByTag(PRC_CRAFT_TEMPORARY_CHEST);
|
||
}
|
||
|
||
int GetCraftingSkill(object oItem)
|
||
{
|
||
int nType = StringToInt(Get2DACache("prc_craft_gen_it", "Type", GetBaseItemType(oItem)));
|
||
if((nType == PRC_CRAFT_ITEM_TYPE_WEAPON) ||
|
||
(nType == PRC_CRAFT_ITEM_TYPE_AMMO)
|
||
)
|
||
return SKILL_CRAFT_WEAPON;
|
||
if((nType == PRC_CRAFT_ITEM_TYPE_ARMOUR) ||
|
||
(nType == PRC_CRAFT_ITEM_TYPE_SHIELD)
|
||
)
|
||
return SKILL_CRAFT_ARMOR;
|
||
return SKILL_CRAFT_GENERAL;
|
||
}
|
||
|
||
string GetMaterialString(int nType)
|
||
{
|
||
string sType = IntToString(nType);
|
||
int nLen = GetStringLength(sType);
|
||
switch(nLen)
|
||
{
|
||
case 1: sType = "0" + sType;
|
||
case 2: sType = "0" + sType; break;
|
||
}
|
||
return sType;
|
||
}
|
||
|
||
//Will replace first 3 chars of item's tag with material flags
|
||
string GetNewItemTag(object oItem, int nType)
|
||
{
|
||
string sTag = GetTag(oItem);
|
||
return GetMaterialString(nType) + GetStringRight(sTag, GetStringLength(sTag) - 3);
|
||
}
|
||
|
||
int GetArmourCheckPenaltyReduction(object oItem)
|
||
{
|
||
int nBase = GetBaseItemType(oItem);
|
||
int nBonus = 0;
|
||
if(((nBase == BASE_ITEM_ARMOR) ||
|
||
(nBase == BASE_ITEM_SMALLSHIELD) ||
|
||
(nBase == BASE_ITEM_LARGESHIELD) ||
|
||
(nBase == BASE_ITEM_TOWERSHIELD))
|
||
)
|
||
{
|
||
int nMaterial = StringToInt(GetStringLeft(GetTag(oItem), 3));
|
||
int nACPenalty = GetItemArmourCheckPenalty(oItem);
|
||
if(nMaterial & PRC_CRAFT_FLAG_MASTERWORK)
|
||
{
|
||
nBonus = PRCMin(1, nACPenalty);
|
||
}
|
||
if(nMaterial & PRC_CRAFT_FLAG_DARKWOOD)
|
||
{
|
||
nBonus = PRCMin(2, nACPenalty);
|
||
}
|
||
if(nMaterial & PRC_CRAFT_FLAG_MITHRAL)
|
||
{
|
||
nBonus = PRCMin(3, nACPenalty);
|
||
}
|
||
}
|
||
return nBonus;
|
||
}
|
||
|
||
int SkillHasACPenalty(int nSkill)
|
||
{
|
||
return StringToInt(Get2DACache("skills", "ArmorCheckPenalty", nSkill));
|
||
}
|
||
|
||
//Returns -1 if itemprop is not in the list, -2 if similar and should disallow type,
|
||
// hardcoded to avoid looping through 2das
|
||
int Get2DALineFromItemprop(string sFile, itemproperty ip, object oItem)
|
||
{ //it's either hardcoding or large numbers of 2da reads
|
||
int nType = GetItemPropertyType(ip);
|
||
int nSubType = GetItemPropertySubType(ip);
|
||
int nCostTableValue = GetItemPropertyCostTableValue(ip);
|
||
int nParam1Value = GetItemPropertyParam1Value(ip);
|
||
int nBase = GetBaseItemType(oItem);
|
||
if(sFile == "craft_armour")
|
||
{
|
||
switch(nType)
|
||
{
|
||
case ITEM_PROPERTY_AC_BONUS:
|
||
{
|
||
return (nCostTableValue - 1);
|
||
break;
|
||
}
|
||
case ITEM_PROPERTY_BONUS_FEAT:
|
||
{
|
||
if(nSubType == 201) return 24;
|
||
break;
|
||
}
|
||
case ITEM_PROPERTY_CAST_SPELL:
|
||
{
|
||
switch(nSubType)
|
||
{
|
||
case IP_CONST_CASTSPELL_CONTROL_UNDEAD_13: return 63; break;
|
||
case IP_CONST_CASTSPELL_ETHEREALNESS_18: return 33; break;
|
||
case 928: return (GetItemPropertyCostTableValue(ip) == IP_CONST_CASTSPELL_NUMUSES_1_USE_PER_DAY) ? 43 : 44; break; //spell turning
|
||
}
|
||
break;
|
||
}
|
||
case ITEM_PROPERTY_DAMAGE_REDUCTION:
|
||
{
|
||
if(nSubType == IP_CONST_DAMAGEREDUCTION_1)
|
||
{
|
||
switch(nCostTableValue)
|
||
{
|
||
case IP_CONST_DAMAGESOAK_5_HP: return 38; break;
|
||
case IP_CONST_DAMAGESOAK_10_HP: return 39; break;
|
||
case IP_CONST_DAMAGESOAK_15_HP: return 40; break;
|
||
default: return -2; break;
|
||
}
|
||
}
|
||
else if(nSubType == IP_CONST_DAMAGEREDUCTION_6)
|
||
{
|
||
switch(nCostTableValue)
|
||
{
|
||
case IP_CONST_DAMAGESOAK_5_HP: return 41; break;
|
||
case IP_CONST_DAMAGESOAK_10_HP: return 42; break;
|
||
default: return -2; break;
|
||
}
|
||
}
|
||
else return -2;
|
||
break;
|
||
}
|
||
case ITEM_PROPERTY_DAMAGE_RESISTANCE:
|
||
{
|
||
int nBaseValue = -1;
|
||
switch(nSubType)
|
||
{
|
||
case IP_CONST_DAMAGETYPE_ACID: nBaseValue = 20; break;
|
||
case IP_CONST_DAMAGETYPE_COLD: nBaseValue = 25; break;
|
||
case IP_CONST_DAMAGETYPE_ELECTRICAL: nBaseValue = 29; break;
|
||
case IP_CONST_DAMAGETYPE_FIRE: nBaseValue = 34; break;
|
||
case IP_CONST_DAMAGETYPE_SONIC: nBaseValue = 51; break;
|
||
}
|
||
if(nBaseValue != -1)
|
||
{
|
||
switch(nCostTableValue)
|
||
{
|
||
case IP_CONST_DAMAGERESIST_10: return nBaseValue; break;
|
||
case IP_CONST_DAMAGERESIST_20: return nBaseValue + 1; break;
|
||
case IP_CONST_DAMAGERESIST_30: return nBaseValue + 2; break;
|
||
case IP_CONST_DAMAGERESIST_50: return nBaseValue + 3; break;
|
||
default: return -2; break;
|
||
}
|
||
}
|
||
else return -2;
|
||
break;
|
||
}
|
||
case ITEM_PROPERTY_SPELL_RESISTANCE:
|
||
{
|
||
if((nCostTableValue >= 27) && (nCostTableValue <= 34)) return (nCostTableValue + 28);
|
||
else return -2;
|
||
break;
|
||
}
|
||
case ITEM_PROPERTY_SKILL_BONUS:
|
||
{
|
||
if(nSubType == SKILL_HIDE)
|
||
{
|
||
nCostTableValue -= GetArmourCheckPenaltyReduction(oItem);
|
||
switch(nCostTableValue)
|
||
{
|
||
case 5: return 49; break;
|
||
case 10: return 50; break;
|
||
case 15: return 51; break;
|
||
default: return -1; break;
|
||
}
|
||
}
|
||
else if(nSubType == SKILL_MOVE_SILENTLY)
|
||
{
|
||
nCostTableValue -= GetArmourCheckPenaltyReduction(oItem);
|
||
switch(nCostTableValue)
|
||
{
|
||
case 5: return 52; break;
|
||
case 10: return 53; break;
|
||
case 15: return 54; break;
|
||
default: return -1; break;
|
||
}
|
||
}
|
||
else
|
||
return -2;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
else if(sFile == "craft_weapon")
|
||
{
|
||
switch(nType)
|
||
{
|
||
case ITEM_PROPERTY_ENHANCEMENT_BONUS:
|
||
{
|
||
return (nCostTableValue - 1);
|
||
break;
|
||
}
|
||
case ITEM_PROPERTY_DAMAGE_BONUS:
|
||
{
|
||
int bAmmo = StringToInt(Get2DACache("prc_craft_gen_it", "Type", GetBaseItemType(oItem))) == PRC_CRAFT_ITEM_TYPE_AMMO;
|
||
if(bAmmo && nSubType == ((nBase == BASE_ITEM_BULLET) ? DAMAGE_TYPE_BLUDGEONING : DAMAGE_TYPE_PIERCING))
|
||
return (nCostTableValue - 1);
|
||
if(nSubType == IP_CONST_DAMAGETYPE_ACID)
|
||
{
|
||
if(nCostTableValue == IP_CONST_DAMAGEBONUS_1d6) return 20; //Corrosive
|
||
else if(nCostTableValue == IP_CONST_DAMAGEBONUS_3d6) return 21; //Acidic blast
|
||
else return -2;
|
||
}
|
||
else if(nSubType == IP_CONST_DAMAGETYPE_FIRE)
|
||
{
|
||
if(nCostTableValue == IP_CONST_DAMAGEBONUS_1d6) return 30; //Flaming
|
||
else if(nCostTableValue == IP_CONST_DAMAGEBONUS_3d6) return 31; //Flaming blast
|
||
else return -2;
|
||
}
|
||
else if(nSubType == IP_CONST_DAMAGETYPE_COLD)
|
||
{
|
||
if(nCostTableValue == IP_CONST_DAMAGEBONUS_1d6) return 32; //Frost
|
||
else if(nCostTableValue == IP_CONST_DAMAGEBONUS_3d6) return 33; //Icy Blast
|
||
else return -2;
|
||
}
|
||
else if(nSubType == IP_CONST_DAMAGETYPE_ELECTRICAL)
|
||
{
|
||
if(nCostTableValue == IP_CONST_DAMAGEBONUS_1d6) return 37; //Shock
|
||
else if(nCostTableValue == IP_CONST_DAMAGEBONUS_3d6) return 38; // Lightning Blast
|
||
else return -2;
|
||
}
|
||
else if(nSubType == IP_CONST_DAMAGETYPE_SONIC)
|
||
{
|
||
if(nCostTableValue == IP_CONST_DAMAGEBONUS_1d4) return 39; //Screaming
|
||
else if(nCostTableValue == IP_CONST_DAMAGEBONUS_3d6) return 40; //Sonic Blast
|
||
else return -2;
|
||
}
|
||
else if(nSubType == IP_CONST_DAMAGETYPE_MAGICAL)
|
||
{
|
||
if(nCostTableValue == IP_CONST_DAMAGEBONUS_1d4) return 45; //Psychokinetic
|
||
else return -2;
|
||
}
|
||
|
||
else return -2;
|
||
break;
|
||
}
|
||
case ITEM_PROPERTY_DAMAGE_BONUS_VS_ALIGNMENT_GROUP:
|
||
{
|
||
switch(nSubType)
|
||
{
|
||
case IP_CONST_ALIGNMENTGROUP_LAWFUL:
|
||
{
|
||
if(nCostTableValue == IP_CONST_DAMAGEBONUS_2d6) return 22; // Anarchic
|
||
else if(nCostTableValue == IP_CONST_DAMAGEBONUS_3d6) return 23; // Anarchic Power
|
||
else return -2;
|
||
break;
|
||
}
|
||
case IP_CONST_ALIGNMENTGROUP_CHAOTIC:
|
||
{
|
||
if(nCostTableValue == IP_CONST_DAMAGEBONUS_2d6) return 24; // Axiomatic
|
||
else if(nCostTableValue == IP_CONST_DAMAGEBONUS_3d6) return 25; // Axiomatic Power
|
||
else return -2;
|
||
break;
|
||
}
|
||
case IP_CONST_ALIGNMENTGROUP_EVIL:
|
||
{
|
||
if(nCostTableValue == IP_CONST_DAMAGEBONUS_2d6) return 34; //Holy
|
||
else if(nCostTableValue == IP_CONST_DAMAGEBONUS_3d6) return 35; // Holy Power
|
||
else return -2;
|
||
break;
|
||
}
|
||
case IP_CONST_ALIGNMENTGROUP_GOOD:
|
||
{
|
||
if(nCostTableValue == IP_CONST_DAMAGEBONUS_2d6) return 41; //Unholy
|
||
else if(nCostTableValue == IP_CONST_DAMAGEBONUS_3d6) return 42; //Unholy Power
|
||
else return -2;
|
||
break;
|
||
}
|
||
default: return -2; break;
|
||
}
|
||
break;
|
||
}
|
||
case ITEM_PROPERTY_DAMAGE_BONUS_VS_RACIAL_GROUP:
|
||
{
|
||
switch(nCostTableValue)
|
||
{
|
||
case IP_CONST_DAMAGEBONUS_2d6: return 26; break; //Bane
|
||
case IP_CONST_DAMAGEBONUS_4d6: return 27; break; //Dread
|
||
default: return -2; break;
|
||
}
|
||
break;
|
||
}
|
||
case ITEM_PROPERTY_KEEN: return 36; break; //Keen
|
||
case ITEM_PROPERTY_ON_HIT_PROPERTIES:
|
||
{
|
||
switch(nSubType)
|
||
{
|
||
case IP_CONST_ONHIT_SLAYRACE:
|
||
{
|
||
if(nParam1Value == IP_CONST_RACIALTYPE_UNDEAD)
|
||
{
|
||
if(nCostTableValue == IP_CONST_ONHIT_SAVEDC_14) return 28; //Disruption
|
||
else if(nCostTableValue == 21) return 29; //Mighty Disruption
|
||
else return -2;
|
||
}
|
||
break;
|
||
}
|
||
case IP_CONST_ONHIT_VORPAL: return 43; break; //Vorpal
|
||
case IP_CONST_ONHIT_WOUNDING: return 44; break; //Wounding
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
//Hardcoded properties to disallow, avoids many loops through 2das
|
||
void DisallowType(object oItem, string sFile, itemproperty ip)
|
||
{
|
||
int i;
|
||
int nType = GetItemPropertyType(ip);
|
||
int nSubType = GetItemPropertySubType(ip);
|
||
int nCostTableValue = GetItemPropertyCostTableValue(ip);
|
||
int nParam1Value = GetItemPropertyParam1Value(ip);
|
||
if(sFile == "craft_armour")
|
||
{
|
||
switch(nType)
|
||
{
|
||
/*
|
||
case ITEM_PROPERTY_AC_BONUS:
|
||
{
|
||
}
|
||
case ITEM_PROPERTY_BONUS_FEAT:
|
||
{
|
||
}
|
||
case ITEM_PROPERTY_CAST_SPELL:
|
||
{
|
||
}
|
||
*/
|
||
case ITEM_PROPERTY_DAMAGE_REDUCTION:
|
||
{
|
||
for(i = 38; i <= 42; i++)
|
||
array_set_int(oItem, PRC_CRAFT_ITEMPROP_ARRAY, i, 0);
|
||
break;
|
||
}
|
||
case ITEM_PROPERTY_DAMAGE_RESISTANCE:
|
||
{
|
||
for(i = 20; i <= 23; i++)
|
||
array_set_int(oItem, PRC_CRAFT_ITEMPROP_ARRAY, i, 0);
|
||
for(i = 25; i <= 32; i++)
|
||
array_set_int(oItem, PRC_CRAFT_ITEMPROP_ARRAY, i, 0);
|
||
for(i = 34; i <= 37; i++)
|
||
array_set_int(oItem, PRC_CRAFT_ITEMPROP_ARRAY, i, 0);
|
||
for(i = 51; i <= 54; i++)
|
||
array_set_int(oItem, PRC_CRAFT_ITEMPROP_ARRAY, i, 0);
|
||
break;
|
||
}
|
||
case ITEM_PROPERTY_SPELL_RESISTANCE:
|
||
{
|
||
for(i = 55; i <= 62; i++)
|
||
array_set_int(oItem, PRC_CRAFT_ITEMPROP_ARRAY, i, 0);
|
||
break;
|
||
}
|
||
case ITEM_PROPERTY_SKILL_BONUS:
|
||
{
|
||
for(i = 45; i <= 50; i++)
|
||
array_set_int(oItem, PRC_CRAFT_ITEMPROP_ARRAY, i, 0);
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
else if(sFile == "craft_weapon")
|
||
{
|
||
switch(nType)
|
||
{
|
||
/*
|
||
case ITEM_PROPERTY_ENHANCEMENT_BONUS:
|
||
{
|
||
}
|
||
*/
|
||
case ITEM_PROPERTY_DAMAGE_BONUS:
|
||
{
|
||
array_set_int(oItem, PRC_CRAFT_ITEMPROP_ARRAY, 20, 0);
|
||
for(i = 29; i <= 32; i++)
|
||
array_set_int(oItem, PRC_CRAFT_ITEMPROP_ARRAY, i, 0);
|
||
for(i = 36; i <= 38; i++)
|
||
array_set_int(oItem, PRC_CRAFT_ITEMPROP_ARRAY, i, 0);
|
||
break;
|
||
}
|
||
case ITEM_PROPERTY_DAMAGE_BONUS_VS_ALIGNMENT_GROUP:
|
||
{
|
||
for(i = 22; i <= 25; i++)
|
||
array_set_int(oItem, PRC_CRAFT_ITEMPROP_ARRAY, i, 0);
|
||
array_set_int(oItem, PRC_CRAFT_ITEMPROP_ARRAY, 34, 0);
|
||
array_set_int(oItem, PRC_CRAFT_ITEMPROP_ARRAY, 35, 0);
|
||
array_set_int(oItem, PRC_CRAFT_ITEMPROP_ARRAY, 41, 0);
|
||
array_set_int(oItem, PRC_CRAFT_ITEMPROP_ARRAY, 42, 0);
|
||
break;
|
||
}
|
||
case ITEM_PROPERTY_DAMAGE_BONUS_VS_RACIAL_GROUP:
|
||
{
|
||
array_set_int(oItem, PRC_CRAFT_ITEMPROP_ARRAY, 25, 0);
|
||
array_set_int(oItem, PRC_CRAFT_ITEMPROP_ARRAY, 26, 0);
|
||
break;
|
||
}
|
||
//case ITEM_PROPERTY_KEEN: array_set_int(oItem, PRC_CRAFT_ITEMPROP_ARRAY, 36, 0); break;
|
||
case ITEM_PROPERTY_ON_HIT_PROPERTIES:
|
||
{
|
||
switch(nSubType)
|
||
{
|
||
case IP_CONST_ONHIT_SLAYRACE:
|
||
{
|
||
if(nParam1Value == IP_CONST_RACIALTYPE_UNDEAD)
|
||
{
|
||
array_set_int(oItem, PRC_CRAFT_ITEMPROP_ARRAY, 28, 0);
|
||
array_set_int(oItem, PRC_CRAFT_ITEMPROP_ARRAY, 29, 0);
|
||
}
|
||
break;
|
||
}
|
||
/*
|
||
case IP_CONST_ONHIT_VORPAL: return 43; break;
|
||
case IP_CONST_ONHIT_WOUNDING: return 44; break;
|
||
*/
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
//hardcoding of some prereqs
|
||
int PrereqSpecialHandling(string sFile, object oItem, int nLine)
|
||
{
|
||
int nTemp;
|
||
int nBase = GetBaseItemType(oItem);
|
||
if(StringToInt(Get2DACache(sFile, "Special", nLine)))
|
||
{
|
||
if(sFile == "craft_armour")
|
||
{ //nothing here yet
|
||
}
|
||
else if(sFile == "craft_weapon")
|
||
{
|
||
int nDamageType = StringToInt(Get2DACache("baseitems", "WeaponType", nBase));
|
||
int bRangedType = StringToInt(Get2DACache("baseitems", "RangedWeapon", nBase));
|
||
int bRanged = bRangedType;// && (bRangedType != nBase);
|
||
switch(nLine)
|
||
{
|
||
case 28:
|
||
case 29:
|
||
{
|
||
return (!bRanged && ((nDamageType == 2) || (nDamageType == 5)));
|
||
break;
|
||
}
|
||
case 36:
|
||
{
|
||
return (!bRanged && (nDamageType != 2));
|
||
break;
|
||
}
|
||
case 43:
|
||
{
|
||
return (!bRanged && ((nDamageType == 3) || (nDamageType == 4)));
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
else if(sFile == "craft_wondrous")
|
||
{
|
||
}
|
||
else if(sFile == "craft_golem")
|
||
{
|
||
}
|
||
}
|
||
if(sFile == "craft_wondrous")
|
||
return nBase == StringToInt(Get2DACache(sFile, "BaseItem", nLine));
|
||
return TRUE;
|
||
}
|
||
|
||
//Checks and decrements spells based on property to add
|
||
int CheckCraftingSpells(object oPC, string sFile, int nLine, int bDecrement = FALSE)
|
||
{
|
||
if(GetLevelByClass(CLASS_TYPE_ARTIFICER, oPC)) return TRUE; //artificers roll UMD checks during crafting time
|
||
//if(GetLevelByClass(CLASS_TYPE_BATTLESMITH, oPC)) return TRUE;
|
||
if(nLine == -1) return FALSE;
|
||
string sTemp = Get2DACache(sFile, "Spells", nLine);
|
||
if(sTemp == "")
|
||
return TRUE; //no prereqs, always true
|
||
int nSpellPattern = 0;
|
||
int nSpell1, nSpell2, nSpell3, nSpellOR1, nSpellOR2, nSpellOR3;
|
||
int bOR = FALSE;
|
||
string sSub;
|
||
int nLength = GetStringLength(sTemp);
|
||
int nPosition;
|
||
int nTemp;
|
||
int i;
|
||
|
||
for(i = 0; i < 6; i++)
|
||
{
|
||
nPosition = FindSubString(sTemp, "_");
|
||
sSub = (nPosition == -1) ? sTemp : GetStringLeft(sTemp, nPosition);
|
||
nLength -= (nPosition + 1);
|
||
if(sSub != "*")
|
||
{
|
||
nTemp = StringToInt(sSub);
|
||
nSpellPattern += FloatToInt(pow(2.0, IntToFloat(i)));
|
||
switch(i)
|
||
{
|
||
case 0:
|
||
{
|
||
nSpell1 = nTemp;
|
||
break;
|
||
}
|
||
case 1:
|
||
{
|
||
nSpell2 = nTemp;
|
||
break;
|
||
}
|
||
case 2:
|
||
{
|
||
nSpell3 = nTemp;
|
||
break;
|
||
}
|
||
case 3:
|
||
{
|
||
nSpellOR1 = nTemp;
|
||
break;
|
||
}
|
||
case 4:
|
||
{
|
||
nSpellOR2 = nTemp;
|
||
break;
|
||
}
|
||
case 6:
|
||
{
|
||
nSpellOR3 = nTemp;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
sTemp = GetSubString(sTemp, nPosition + 1, nLength);
|
||
}
|
||
|
||
if (nSpellPattern)
|
||
{
|
||
// ... Existing code for nSpellPattern & 1
|
||
|
||
if (nSpellPattern & 2)
|
||
{
|
||
if (!PRCGetHasSpell(nSpell2, oPC))
|
||
{
|
||
if (!CheckImbueItem(oPC, nSpell2))
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
if (nSpellPattern & 4)
|
||
{
|
||
if (!PRCGetHasSpell(nSpell3, oPC))
|
||
{
|
||
if (!CheckImbueItem(oPC, nSpell3))
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
if (nSpellPattern & 8)
|
||
{
|
||
if (!PRCGetHasSpell(nSpellOR1, oPC))
|
||
{
|
||
if (!CheckImbueItem(oPC, nSpellOR1))
|
||
{
|
||
if (nSpellPattern & 16)
|
||
{
|
||
if (!PRCGetHasSpell(nSpellOR2, oPC))
|
||
{
|
||
// Warlocks don't get two bites at things.
|
||
// if (!CheckImbueItem(oPC, nSpellOR2))
|
||
return FALSE;
|
||
}
|
||
}
|
||
else if (nSpellPattern & 32) // Check for nSpellOR3
|
||
{
|
||
if (!PRCGetHasSpell(nSpellOR3, oPC))
|
||
{
|
||
// Handle nSpellOR3 missing
|
||
return FALSE;
|
||
}
|
||
}
|
||
else
|
||
return FALSE;
|
||
}
|
||
}
|
||
}
|
||
else if (nSpellPattern & 16)
|
||
{
|
||
if (!PRCGetHasSpell(nSpellOR2, oPC))
|
||
{
|
||
if (!CheckImbueItem(oPC, nSpellOR2))
|
||
return FALSE;
|
||
}
|
||
// Check for nSpellOR3
|
||
else if (nSpellPattern & 32)
|
||
{
|
||
if (!PRCGetHasSpell(nSpellOR3, oPC))
|
||
{
|
||
// Handle nSpellOR3 missing
|
||
return FALSE;
|
||
}
|
||
}
|
||
}
|
||
else if (nSpellPattern & 32) // Check for nSpellOR3 alone
|
||
{
|
||
if (!PRCGetHasSpell(nSpellOR3, oPC))
|
||
{
|
||
// Handle nSpellOR3 missing
|
||
return FALSE;
|
||
}
|
||
}
|
||
|
||
// ... Existing code for decrementing spells
|
||
|
||
}
|
||
|
||
return TRUE;
|
||
}
|
||
/* if(nSpellPattern)
|
||
{
|
||
if(nSpellPattern & 1)
|
||
{
|
||
if(sFile == "craft_wondrous")
|
||
{
|
||
switch(nLine)
|
||
{
|
||
case 85:
|
||
{
|
||
bOR = (PRCGetHasSpell(SPELL_DETECT_UNDEAD, oPC) &&
|
||
PRCGetHasSpell(SPELL_FIREBALL, oPC) &&
|
||
PRCGetHasSpell(SPELL_FLAME_WEAPON, oPC) &&
|
||
PRCGetHasSpell(SPELL_LIGHT, oPC) &&
|
||
PRCGetHasSpell(SPELL_PRISMATIC_SPRAY, oPC) &&
|
||
PRCGetHasSpell(SPELL_PROTECTION_FROM_ELEMENTS, oPC) &&
|
||
PRCGetHasSpell(SPELL_WALL_OF_FIRE, oPC));
|
||
if(GetHasFeat(FEAT_IMBUE_ITEM) && bOR == FALSE)
|
||
bOR = GetIsSkillSuccessful(oPC, SKILL_USE_MAGIC_DEVICE, 16) &&
|
||
GetIsSkillSuccessful(oPC, SKILL_USE_MAGIC_DEVICE, 18) &&
|
||
GetIsSkillSuccessful(oPC, SKILL_USE_MAGIC_DEVICE, 17) &&
|
||
GetIsSkillSuccessful(oPC, SKILL_USE_MAGIC_DEVICE, 16) &&
|
||
GetIsSkillSuccessful(oPC, SKILL_USE_MAGIC_DEVICE, 22) &&
|
||
GetIsSkillSuccessful(oPC, SKILL_USE_MAGIC_DEVICE, 18) &&
|
||
GetIsSkillSuccessful(oPC, SKILL_USE_MAGIC_DEVICE, 19);
|
||
if(bDecrement)
|
||
{
|
||
PRCDecrementRemainingSpellUses(oPC, SPELL_DETECT_UNDEAD);
|
||
PRCDecrementRemainingSpellUses(oPC, SPELL_FIREBALL);
|
||
PRCDecrementRemainingSpellUses(oPC, SPELL_FLAME_WEAPON);
|
||
PRCDecrementRemainingSpellUses(oPC, SPELL_LIGHT);
|
||
PRCDecrementRemainingSpellUses(oPC, SPELL_PRISMATIC_SPRAY);
|
||
PRCDecrementRemainingSpellUses(oPC, SPELL_PROTECTION_FROM_ELEMENTS);
|
||
PRCDecrementRemainingSpellUses(oPC, SPELL_WALL_OF_FIRE);
|
||
}
|
||
return bOR;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if(!PRCGetHasSpell(nSpell1, oPC))
|
||
{
|
||
if(!CheckImbueItem(oPC, nSpell1))
|
||
return FALSE;
|
||
}
|
||
}
|
||
if(nSpellPattern & 2)
|
||
{
|
||
if(!PRCGetHasSpell(nSpell2, oPC))
|
||
{
|
||
if(!CheckImbueItem(oPC, nSpell2))
|
||
return FALSE;
|
||
}
|
||
}
|
||
if(nSpellPattern & 4)
|
||
{
|
||
if(!PRCGetHasSpell(nSpell3, oPC))
|
||
{
|
||
if(!CheckImbueItem(oPC, nSpell3))
|
||
return FALSE;
|
||
}
|
||
}
|
||
if(nSpellPattern & 8)
|
||
{
|
||
if(!PRCGetHasSpell(nSpellOR1, oPC))
|
||
{
|
||
if(!CheckImbueItem(oPC, nSpellOR1))
|
||
{
|
||
if(nSpellPattern & 16)
|
||
{
|
||
if(!PRCGetHasSpell(nSpellOR2, oPC))
|
||
{
|
||
// Warlocks don't get two bites at things.
|
||
//if(!CheckImbueItem(oPC, nSpellOR2))
|
||
return FALSE;
|
||
}
|
||
}
|
||
else
|
||
return FALSE;
|
||
}
|
||
}
|
||
}
|
||
else if(nSpellPattern & 16)
|
||
{
|
||
if(!PRCGetHasSpell(nSpellOR2, oPC))
|
||
{
|
||
if(!CheckImbueItem(oPC, nSpellOR2))
|
||
return FALSE;
|
||
}
|
||
}
|
||
if(bDecrement)
|
||
{
|
||
if(nSpellPattern & 1)
|
||
PRCDecrementRemainingSpellUses(oPC, nSpell1);
|
||
if(nSpellPattern & 2)
|
||
PRCDecrementRemainingSpellUses(oPC, nSpell2);
|
||
if(nSpellPattern & 4)
|
||
PRCDecrementRemainingSpellUses(oPC, nSpell3);
|
||
if(nSpellPattern & 8)
|
||
PRCDecrementRemainingSpellUses(oPC, (bOR) ? nSpellOR2 : nSpellOR1);
|
||
else if(nSpellPattern & 16)
|
||
PRCDecrementRemainingSpellUses(oPC, nSpellOR2);
|
||
}
|
||
}
|
||
return TRUE;
|
||
} */
|
||
|
||
//Checks and decrements power points based on property to add
|
||
int CheckCraftingPowerPoints(object oPC, string sFile, int nLine, int bDecrement = FALSE)
|
||
{
|
||
if(nLine == -1) return FALSE;
|
||
string sTemp = Get2DACache(sFile, "Spells", nLine);
|
||
if(sTemp == "")
|
||
return TRUE; //no prereqs, always true
|
||
int nSpellPattern = 0;
|
||
int nSpell1, nSpell2, nSpell3, nSpellOR1, nSpellOR2, nSpellOR3;
|
||
int bOR = FALSE;
|
||
string sSub;
|
||
int nLength = GetStringLength(sTemp);
|
||
int nPosition;
|
||
int nTemp;
|
||
int i;
|
||
int nLoss = 0;
|
||
|
||
for(i = 0; i < 6; i++)
|
||
{
|
||
nPosition = FindSubString(sTemp, "_");
|
||
sSub = (nPosition == -1) ? sTemp : GetStringLeft(sTemp, nPosition);
|
||
nLength -= (nPosition + 1);
|
||
if(sSub != "*")
|
||
{
|
||
nTemp = StringToInt(sSub);
|
||
nSpellPattern += FloatToInt(pow(2.0, IntToFloat(i)));
|
||
switch(i)
|
||
{
|
||
case 0:
|
||
{
|
||
nSpell1 = nTemp;
|
||
break;
|
||
}
|
||
case 1:
|
||
{
|
||
nSpell2 = nTemp;
|
||
break;
|
||
}
|
||
case 2:
|
||
{
|
||
nSpell3 = nTemp;
|
||
break;
|
||
}
|
||
case 3:
|
||
{
|
||
nSpellOR1 = nTemp;
|
||
break;
|
||
}
|
||
case 4:
|
||
{
|
||
nSpellOR2 = nTemp;
|
||
break;
|
||
}
|
||
case 6:
|
||
{
|
||
nSpellOR3 = nTemp;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
sTemp = GetSubString(sTemp, nPosition + 1, nLength);
|
||
}
|
||
if(nSpellPattern)
|
||
{
|
||
if(nSpellPattern & 1)
|
||
{
|
||
if(GetHasPower(nSpell1, oPC))
|
||
nLoss += (StringToInt(lookup_spell_innate(nSpell1)) * 2 - 1);
|
||
else
|
||
return FALSE;
|
||
}
|
||
if(nSpellPattern & 2)
|
||
{
|
||
if(GetHasPower(nSpell2, oPC))
|
||
nLoss += (StringToInt(lookup_spell_innate(nSpell2)) * 2 - 1);
|
||
else
|
||
return FALSE;
|
||
}
|
||
if(nSpellPattern & 4)
|
||
{
|
||
if(GetHasPower(nSpell3, oPC))
|
||
nLoss += (StringToInt(lookup_spell_innate(nSpell3)) * 2 - 1);
|
||
else
|
||
return FALSE;
|
||
}
|
||
if(nSpellPattern & 8)
|
||
{
|
||
if(GetHasPower(nSpellOR1, oPC))
|
||
nLoss += (StringToInt(lookup_spell_innate(nSpellOR1)) * 2 - 1);
|
||
else if(nSpellPattern & 16)
|
||
{
|
||
if(GetHasPower(nSpellOR2, oPC))
|
||
nLoss += (StringToInt(lookup_spell_innate(nSpellOR2)) * 2 - 1);
|
||
else
|
||
return FALSE;
|
||
}
|
||
else
|
||
return FALSE;
|
||
}
|
||
else if(nSpellPattern & 16)
|
||
{
|
||
if(GetHasPower(nSpellOR2, oPC))
|
||
nLoss += (StringToInt(lookup_spell_innate(nSpellOR2)) * 2 - 1);
|
||
else
|
||
return FALSE;
|
||
}
|
||
}
|
||
if(GetCurrentPowerPoints(oPC) < nLoss)
|
||
return FALSE;
|
||
|
||
if(bDecrement) LosePowerPoints(oPC, nLoss, TRUE);
|
||
|
||
return TRUE;
|
||
}
|
||
|
||
int CheckGolemPrereq(object oPC, int nLine, int bEpic)
|
||
{
|
||
if(GetLocalInt(oPC, PRC_CRAFT_TOKEN))
|
||
return TRUE;
|
||
int bBreak = FALSE;
|
||
int nLevel;
|
||
int j = 0;
|
||
//replace the arti level check later when PrCs are added
|
||
int nCasterLevel = PRCMax(PRCMax(PRCMax(GetLevelByTypeArcane(oPC), GetLevelByTypeDivine(oPC)), GetLevelByClass(CLASS_TYPE_ARTIFICER, oPC) + 2), GetLocalInt(oPC, "InvokerLevel"));
|
||
int nManifesterLevel = GetManifesterLevel(oPC);
|
||
int nTemp, nLength, nPosition;
|
||
int bArtificer = (GetLevelByClass(CLASS_TYPE_ARTIFICER, oPC) > 0);
|
||
string sFile = "craft_golem";
|
||
string sPropertyType = Get2DACache(sFile, "CasterType", nLine);
|
||
string sTemp, sSub;
|
||
int nDC = StringToInt(Get2DACache(sFile, "DC", nLine));
|
||
if(sPropertyType == "M")
|
||
nLevel = nCasterLevel;
|
||
else if(sPropertyType == "P")
|
||
nLevel = nManifesterLevel;
|
||
else
|
||
nLevel = PRCMax(nCasterLevel, nManifesterLevel);
|
||
if(!bEpic && Get2DACache(sFile, "Epic", nLine) == "1")
|
||
return FALSE;
|
||
else if(nLevel < StringToInt(Get2DACache(sFile, "Level", nLine)))
|
||
return FALSE;
|
||
else
|
||
{
|
||
if(
|
||
(sPropertyType == "M") &&
|
||
!CheckCraftingSpells(oPC, sFile, nLine)
|
||
)
|
||
return FALSE;
|
||
if(
|
||
(sPropertyType == "P") &&
|
||
!CheckCraftingPowerPoints(oPC, sFile, nLine)
|
||
)
|
||
return FALSE;
|
||
sTemp = Get2DACache(sFile, "Skills", nLine);
|
||
if(sTemp == "")
|
||
bBreak = TRUE;
|
||
nLength = GetStringLength(sTemp);
|
||
for(j = 0; j < 2; j++)
|
||
{
|
||
if(bBreak)
|
||
break;
|
||
nPosition = FindSubString(sTemp, "_");
|
||
sSub = (nPosition == -1) ? sTemp : GetStringLeft(sTemp, nPosition);
|
||
nLength -= (nPosition + 1);
|
||
if(sSub == "*")
|
||
nTemp = -1;
|
||
else
|
||
nTemp = StringToInt(sSub);
|
||
if(nTemp != -1 && !bArtificer)
|
||
{
|
||
if(!GetPRCIsSkillSuccessful(oPC, nTemp, nDC))
|
||
return FALSE;
|
||
}
|
||
sTemp = GetSubString(sTemp, nPosition + 1, nLength);
|
||
}
|
||
sTemp = Get2DACache(sFile, "Skills", nLine);
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
int CheckPrereq(object oPC, int nLine, int bEpic, string sFile, struct itemvars strTemp)
|
||
{
|
||
if(GetLocalInt(oPC, PRC_CRAFT_TOKEN))
|
||
return TRUE;
|
||
int bBreak = FALSE;
|
||
int nLevel;
|
||
int j = 0;
|
||
//replace the arti level check later when PrCs are added
|
||
int nCasterLevel = PRCMax(PRCMax(PRCMax(GetLevelByTypeArcane(oPC), GetLevelByTypeDivine(oPC)), GetLevelByClass(CLASS_TYPE_ARTIFICER, oPC) + 2), GetLocalInt(oPC, "InvokerLevel"));
|
||
nCasterLevel += GetLevelByClass(CLASS_TYPE_BATTLESMITH) * 3;
|
||
nCasterLevel += GetLevelByClass(CLASS_TYPE_IRONSOUL_FORGEMASTER) * 3;
|
||
int nManifesterLevel = GetManifesterLevel(oPC);
|
||
int nTemp, nLength, nPosition;
|
||
int bArtificer = (GetLevelByClass(CLASS_TYPE_ARTIFICER, oPC) > 0);
|
||
string sPropertyType = Get2DACache(sFile, "PropertyType", nLine);
|
||
string sTemp, sSub;
|
||
if(sPropertyType == "M")
|
||
nLevel = nCasterLevel;
|
||
else if(sPropertyType == "P")
|
||
nLevel = nManifesterLevel;
|
||
else
|
||
nLevel = PRCMax(nCasterLevel, nManifesterLevel);
|
||
|
||
if (DEBUG) DoDebug("CheckPrereq: "+GetName(oPC)+" nLevel "+IntToString(nLevel)+" PropType "+sPropertyType+" Epic "+IntToString(bEpic)+" sFile "+sFile);
|
||
|
||
if(!bEpic && Get2DACache(sFile, "Epic", nLine) == "1")
|
||
{
|
||
if (DEBUG) DoDebug("CheckPrereq Failed Epic");
|
||
return FALSE;
|
||
}
|
||
else if(nLevel < StringToInt(Get2DACache(sFile, "Level", nLine)))
|
||
{
|
||
if (DEBUG) DoDebug("CheckPrereq Failed Level");
|
||
return FALSE;
|
||
}
|
||
else if(!bEpic && ((StringToInt(Get2DACache(sFile, "Enhancement", nLine)) + strTemp.enhancement) > 10))
|
||
{
|
||
if (DEBUG) DoDebug("CheckPrereq Failed Enhancement");
|
||
return FALSE;
|
||
}
|
||
else
|
||
{
|
||
if(
|
||
(sPropertyType == "M") && !CheckCraftingSpells(oPC, sFile, nLine))
|
||
{
|
||
if (DEBUG) DoDebug("CheckPrereq Failed Crafting Spells");
|
||
return FALSE;
|
||
}
|
||
if((sPropertyType == "P") && !CheckCraftingPowerPoints(oPC, sFile, nLine))
|
||
{
|
||
if (DEBUG) DoDebug("CheckPrereq Failed Crafting Powers");
|
||
return FALSE;
|
||
}
|
||
|
||
sTemp = Get2DACache(sFile, "PrereqMisc", nLine);
|
||
if(sTemp == "")
|
||
bBreak = TRUE;
|
||
nLength = GetStringLength(sTemp);
|
||
for(j = 0; j < 5; j++)
|
||
{
|
||
if(bBreak)
|
||
break;
|
||
nPosition = FindSubString(sTemp, "_");
|
||
sSub = (nPosition == -1) ? sTemp : GetStringLeft(sTemp, nPosition);
|
||
nLength -= (nPosition + 1);
|
||
if(sSub == "*")
|
||
nTemp = -1;
|
||
else
|
||
nTemp = StringToInt(sSub);
|
||
switch(j)
|
||
{
|
||
case 0:
|
||
{
|
||
if(nTemp != -1 && MyPRCGetRacialType(oPC) != nTemp && !bArtificer)
|
||
{
|
||
if (DEBUG) DoDebug("CheckPrereq Failed Racial Type");
|
||
return FALSE;
|
||
}
|
||
break;
|
||
}
|
||
case 1:
|
||
{
|
||
if(nTemp != -1 && !GetHasFeat(nTemp, oPC)) //artificer can't emulate feat requirements
|
||
{
|
||
if (DEBUG) DoDebug("CheckPrereq Failed Feat");
|
||
return FALSE;
|
||
}
|
||
break;
|
||
}
|
||
case 2:
|
||
{
|
||
if(((sSub == "G" && GetAlignmentGoodEvil(oPC) != ALIGNMENT_GOOD) ||
|
||
(sSub == "E" && GetAlignmentGoodEvil(oPC) != ALIGNMENT_EVIL) ||
|
||
(sSub == "N" && GetAlignmentGoodEvil(oPC) != ALIGNMENT_NEUTRAL)) &&
|
||
!bArtificer)
|
||
{
|
||
if (DEBUG) DoDebug("CheckPrereq Failed Alignment G/E");
|
||
return FALSE;
|
||
}
|
||
break;
|
||
}
|
||
case 3:
|
||
{
|
||
if(((sSub == "L" && GetAlignmentLawChaos(oPC) != ALIGNMENT_LAWFUL) ||
|
||
(sSub == "C" && GetAlignmentLawChaos(oPC) != ALIGNMENT_CHAOTIC) ||
|
||
(sSub == "N" && GetAlignmentLawChaos(oPC) != ALIGNMENT_NEUTRAL)) &&
|
||
!bArtificer)
|
||
{
|
||
if (DEBUG) DoDebug("CheckPrereq Failed Alignment L/C");
|
||
return FALSE;
|
||
}
|
||
break;
|
||
}
|
||
case 4:
|
||
{
|
||
if(nTemp != -1 && !GetLevelByClass(nTemp, oPC) && !bArtificer)
|
||
{
|
||
if (DEBUG) DoDebug("CheckPrereq Failed Class");
|
||
return FALSE;
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
sTemp = GetSubString(sTemp, nPosition + 1, nLength);
|
||
}
|
||
sTemp = Get2DACache(sFile, "Skill", nLine);
|
||
if(sTemp != "" && (GetSkillRank(StringToInt(sTemp), oPC) < StringToInt(Get2DACache(sFile, "SkillRanks", nLine))))
|
||
{
|
||
if (DEBUG) DoDebug("CheckPrereq Failed Skill");
|
||
return FALSE;
|
||
}
|
||
}
|
||
return TRUE;
|
||
}
|
||
|
||
//Returns a struct containing enhancement and additional cost values, don't bother with array when bSet == 0
|
||
struct itemvars GetItemVars(object oPC, object oItem, string sFile, int bEpic = 0, int bSet = 0)
|
||
{
|
||
struct itemvars strTemp;
|
||
int i, bBreak, nTemp;
|
||
int j, k, bEnhanced, count;
|
||
int nEnhancement;
|
||
int nSpellPattern;
|
||
int nSpell1, nSpell2, nSpell3, nSpellOR1, nSpellOR2;
|
||
int nCasterLevel = PRCMax(GetLevelByTypeArcane(oPC), GetLevelByTypeDivine(oPC));
|
||
int nManifesterLevel = GetManifesterLevel(oPC);
|
||
int nLevel;
|
||
int nFileEnd = PRCGetFileEnd(sFile);
|
||
int nRace = MyPRCGetRacialType(oPC);
|
||
int nFeat = GetCraftingFeat(oItem);
|
||
int bArmsArmour = nFeat == FEAT_CRAFT_ARMS_ARMOR;
|
||
string sPropertyType;
|
||
strTemp.item = oItem;
|
||
string sSub;
|
||
int nLength;
|
||
int nPosition;
|
||
if(bSet)
|
||
{
|
||
if(array_exists(oPC, PRC_CRAFT_ITEMPROP_ARRAY))
|
||
array_delete(oPC, PRC_CRAFT_ITEMPROP_ARRAY);
|
||
array_create(oPC, PRC_CRAFT_ITEMPROP_ARRAY);
|
||
//Setup
|
||
for(i = 0; i <= nFileEnd; i++)
|
||
{
|
||
if(!GetPRCSwitch("PRC_CRAFT_DISABLE_" + sFile + "_" + IntToString(i)) && PrereqSpecialHandling(sFile, oItem, i))
|
||
array_set_int(oPC, PRC_CRAFT_ITEMPROP_ARRAY, i, 1);
|
||
}
|
||
if(bArmsArmour)
|
||
{
|
||
int nBase = GetBaseItemType(oItem);
|
||
int bRangedType = StringToInt(Get2DACache("baseitems", "RangedWeapon", nBase));
|
||
if(bRangedType && (bRangedType != nBase))
|
||
{ //disallowed because ranged weapons can't have onhit
|
||
array_set_int(oPC, PRC_CRAFT_ITEMPROP_ARRAY, 22, 0);
|
||
array_set_int(oPC, PRC_CRAFT_ITEMPROP_ARRAY, 24, 0);
|
||
array_set_int(oPC, PRC_CRAFT_ITEMPROP_ARRAY, 26, 0);
|
||
array_set_int(oPC, PRC_CRAFT_ITEMPROP_ARRAY, 34, 0);
|
||
array_set_int(oPC, PRC_CRAFT_ITEMPROP_ARRAY, 40, 0);
|
||
array_set_int(oPC, PRC_CRAFT_ITEMPROP_ARRAY, 42, 0);
|
||
}
|
||
}
|
||
}
|
||
if(bArmsArmour)
|
||
{
|
||
itemproperty ip = GetFirstItemProperty(oItem);
|
||
if(DEBUG) DoDebug("GetItemVars: " + GetName(oItem) + ", before itemprop loop");
|
||
//Checking itemprops
|
||
count = 0;
|
||
while(GetIsItemPropertyValid(ip))
|
||
{ //assumes no duplicated enhancement itemprops
|
||
k = Get2DALineFromItemprop(sFile, ip, oItem); //is causing TMI with armour with skill props
|
||
count++;
|
||
if(DEBUG) DoDebug("GetItemVars: itemprop number " + IntToString(count) +
|
||
" " + IntToString(GetItemPropertyType(ip)) +
|
||
" " + IntToString(GetItemPropertySubType(ip)) +
|
||
" " + IntToString(GetItemPropertyCostTableValue(ip)) +
|
||
" " + IntToString(GetItemPropertyParam1Value(ip))
|
||
);
|
||
|
||
if(k >= 0)
|
||
{
|
||
if(k < 20) bEnhanced = TRUE;
|
||
if(bSet)
|
||
{
|
||
for(j = StringToInt(Get2DACache(sFile, "ReplaceLast", k)); j >= 0; j--)
|
||
{
|
||
array_set_int(oPC, PRC_CRAFT_ITEMPROP_ARRAY, k - j, 0);
|
||
}
|
||
}
|
||
nEnhancement = StringToInt(Get2DACache(sFile, "Enhancement", k));
|
||
strTemp.enhancement += nEnhancement;
|
||
if(nEnhancement > 5) strTemp.epic = TRUE;
|
||
strTemp.additionalcost += StringToInt(Get2DACache(sFile, "AdditionalCost", k));
|
||
|
||
if(DEBUG)
|
||
{
|
||
sPropertyType = GetStringByStrRef(StringToInt(Get2DACache(sFile, "Name", k)));
|
||
if(sPropertyType != "")
|
||
DoDebug("GetItemVars: " + sPropertyType);
|
||
}
|
||
}
|
||
else if(bSet && k == -2)
|
||
{
|
||
DisallowType(oPC, sFile, ip);
|
||
}
|
||
|
||
ip = GetNextItemProperty(oItem);
|
||
}
|
||
if(strTemp.enhancement > 10) strTemp.epic = TRUE;
|
||
if(DEBUG) DoDebug("GetItemVars: " + GetName(oItem) + ", after itemprop loop");
|
||
}
|
||
else
|
||
{
|
||
strTemp.enhancement = 0;
|
||
strTemp.additionalcost = 0;
|
||
strTemp.epic = FALSE;
|
||
}
|
||
|
||
if(DEBUG)
|
||
{
|
||
DoDebug("GetItemVars: " + GetName(oItem) +
|
||
", Enhancement: " + IntToString(strTemp.enhancement) +
|
||
", AdditionalCost: " + IntToString(strTemp.additionalcost));
|
||
}
|
||
if(!bSet) return strTemp; //don't bother with array
|
||
|
||
if(!bEpic && strTemp.epic)
|
||
{ //attempting to craft epic item without epic crafting feat, fails
|
||
for(i = 0; i <= nFileEnd; i++)
|
||
array_set_int(oPC, PRC_CRAFT_ITEMPROP_ARRAY, i, 0);
|
||
return strTemp;
|
||
}
|
||
if(!bEnhanced && bArmsArmour)
|
||
{ //no enhancement value, cannot add more itemprops, stop right there
|
||
array_set_int(oPC, PRC_CRAFT_ITEMPROP_ARRAY, 0, 1);
|
||
for(i = 1; i <= nFileEnd; i++)
|
||
array_set_int(oPC, PRC_CRAFT_ITEMPROP_ARRAY, i, 0);
|
||
return strTemp;
|
||
}
|
||
string sTemp;
|
||
//Checking available spells, epic flag, caster level
|
||
if(!GetLocalInt(oPC, PRC_CRAFT_TOKEN))
|
||
{
|
||
//moved check to confirmation stage
|
||
}
|
||
else if(GetPRCSwitch(PRC_DISABLE_CRAFT_EPIC))
|
||
{ //disabling epic crafting at npc facilities
|
||
for(i = 0; i <= nFileEnd; i++)
|
||
{ //will skip over properties already disallowed
|
||
if(array_get_int(oPC, PRC_CRAFT_ITEMPROP_ARRAY, i) && Get2DACache(sFile, "Epic", i) == "1")
|
||
{
|
||
array_set_int(oPC, PRC_CRAFT_ITEMPROP_ARRAY, i, 0);
|
||
}
|
||
}
|
||
}
|
||
return strTemp;
|
||
}
|
||
|
||
//Returns an int depending on the weapon type
|
||
// returns 0 if not a weapon
|
||
int GetWeaponType(int nBaseItem)
|
||
{
|
||
switch(nBaseItem)
|
||
{
|
||
case BASE_ITEM_BASTARDSWORD:
|
||
case BASE_ITEM_TWOBLADEDSWORD:
|
||
case BASE_ITEM_DIREMACE:
|
||
case BASE_ITEM_DOUBLEAXE:
|
||
case BASE_ITEM_KAMA:
|
||
case BASE_ITEM_KATANA:
|
||
case BASE_ITEM_KUKRI:
|
||
case BASE_ITEM_SCYTHE:
|
||
case BASE_ITEM_SHURIKEN:
|
||
case BASE_ITEM_DWARVENWARAXE:
|
||
case BASE_ITEM_WHIP:
|
||
case BASE_ITEM_ELVEN_LIGHTBLADE:
|
||
case BASE_ITEM_ELVEN_THINBLADE:
|
||
case BASE_ITEM_ELVEN_COURTBLADE:
|
||
case BASE_ITEM_DOUBLE_SCIMITAR:
|
||
case BASE_ITEM_NUNCHAKU:
|
||
case BASE_ITEM_SAI:
|
||
case BASE_ITEM_EAGLE_CLAW:
|
||
return PRC_CRAFT_EXOTIC_WEAPON;
|
||
break;
|
||
|
||
case BASE_ITEM_SHORTSWORD:
|
||
case BASE_ITEM_LONGSWORD:
|
||
case BASE_ITEM_BATTLEAXE:
|
||
case BASE_ITEM_LIGHTFLAIL:
|
||
case BASE_ITEM_WARHAMMER:
|
||
case BASE_ITEM_LONGBOW:
|
||
case BASE_ITEM_HALBERD:
|
||
case BASE_ITEM_SHORTBOW:
|
||
case BASE_ITEM_GREATSWORD:
|
||
case BASE_ITEM_GREATAXE:
|
||
case BASE_ITEM_HEAVYFLAIL:
|
||
case BASE_ITEM_LIGHTHAMMER:
|
||
case BASE_ITEM_HANDAXE:
|
||
case BASE_ITEM_RAPIER:
|
||
case BASE_ITEM_SCIMITAR:
|
||
case BASE_ITEM_THROWINGAXE:
|
||
case BASE_ITEM_TRIDENT:
|
||
case BASE_ITEM_HEAVY_PICK:
|
||
case BASE_ITEM_LIGHT_PICK:
|
||
case BASE_ITEM_FALCHION:
|
||
case BASE_ITEM_SAP:
|
||
case BASE_ITEM_MAUL:
|
||
return PRC_CRAFT_MARTIAL_WEAPON;
|
||
break;
|
||
|
||
case BASE_ITEM_LIGHTMACE:
|
||
case BASE_ITEM_DART:
|
||
case BASE_ITEM_MORNINGSTAR:
|
||
case BASE_ITEM_SHORTSPEAR:
|
||
case BASE_ITEM_SICKLE:
|
||
case BASE_ITEM_SLING:
|
||
case BASE_ITEM_DAGGER:
|
||
case BASE_ITEM_LIGHTCROSSBOW:
|
||
case BASE_ITEM_HEAVYCROSSBOW:
|
||
case BASE_ITEM_CLUB:
|
||
case BASE_ITEM_QUARTERSTAFF:
|
||
case BASE_ITEM_KATAR:
|
||
case BASE_ITEM_HEAVY_MACE:
|
||
case BASE_ITEM_GOAD:
|
||
return PRC_CRAFT_SIMPLE_WEAPON;
|
||
break;
|
||
|
||
default: return 0; break;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
void ApplyBonusToStatBasedChecks(object oItem, int nStat, int nBonus)
|
||
{
|
||
int i;
|
||
string sSkills = "skills";
|
||
string sFilter;
|
||
switch(nStat)
|
||
{
|
||
case ABILITY_STRENGTH: sFilter = "STR"; break;
|
||
case ABILITY_DEXTERITY: sFilter = "DEX"; break;
|
||
case ABILITY_CONSTITUTION: sFilter = "CON"; break;
|
||
case ABILITY_INTELLIGENCE: sFilter = "INT"; break;
|
||
case ABILITY_WISDOM: sFilter = "WIS"; break;
|
||
case ABILITY_CHARISMA: sFilter = "CHA"; break;
|
||
}
|
||
for(i = 0; i <= PRCGetFileEnd(sSkills); i++)
|
||
{
|
||
if(Get2DACache(sSkills, "KeyAbility", i) == sFilter)
|
||
IPSafeAddItemProperty(oItem, ItemPropertySkillBonus(i, nBonus), 0.0, X2_IP_ADDPROP_POLICY_REPLACE_EXISTING);
|
||
}
|
||
}
|
||
|
||
//Hardcoding of some adjustments
|
||
itemproperty PropSpecialHandling(object oItem, string sFile, int nLine, int nIndex)
|
||
{
|
||
itemproperty ip;
|
||
int nTemp;
|
||
string sEntry = Get2DACache(sFile, "IP" + IntToString(nIndex), nLine);
|
||
if(DEBUG) DoDebug("PropSpecialHandling(object, " + sFile + ", " + IntToString(nLine) + ", " + IntToString(nIndex) + ")");
|
||
if(DEBUG) DoDebug("Get2DACache: IP" + IntToString(nIndex) + ", " + sEntry);
|
||
struct ipstruct iptemp = GetIpStructFromString(sEntry);
|
||
string sTemp;
|
||
|
||
int nBase = GetBaseItemType(oItem);
|
||
if(StringToInt(Get2DACache(sFile, "Special", nLine)))
|
||
{
|
||
if(sFile == "craft_armour")
|
||
{
|
||
if(iptemp.type == ITEM_PROPERTY_SKILL_BONUS && SkillHasACPenalty(iptemp.subtype))
|
||
iptemp.costtablevalue += GetArmourCheckPenaltyReduction(oItem);
|
||
}
|
||
else if(sFile == "craft_weapon")
|
||
{
|
||
switch(nLine)
|
||
{
|
||
case 25:
|
||
case 26:
|
||
{
|
||
nTemp = GetLocalInt(GetItemPossessor(oItem), PRC_CRAFT_SPECIAL_BANE_RACE);
|
||
if(nIndex == 1)
|
||
{
|
||
iptemp.subtype = nTemp;
|
||
nTemp = StringToInt(Get2DACache("baseitems", "WeaponType", nBase));
|
||
switch(nTemp)
|
||
{
|
||
case 1: iptemp.param1value = IP_CONST_DAMAGETYPE_PIERCING; break;
|
||
case 2:
|
||
case 5: iptemp.param1value = IP_CONST_DAMAGETYPE_BLUDGEONING; break;
|
||
case 3:
|
||
case 4: iptemp.param1value = IP_CONST_DAMAGETYPE_SLASHING; break;
|
||
}
|
||
}
|
||
else if(nIndex == 2)
|
||
{
|
||
iptemp.subtype = nTemp;
|
||
iptemp.costtablevalue += IPGetWeaponEnhancementBonus(oItem);
|
||
if(iptemp.costtablevalue > 20)
|
||
iptemp.costtablevalue = 20;
|
||
}
|
||
else if(nIndex == 3)
|
||
iptemp.param1value = nTemp;
|
||
break;
|
||
}
|
||
}
|
||
if(iptemp.type == ITEM_PROPERTY_ENHANCEMENT_BONUS &&
|
||
StringToInt(Get2DACache("prc_craft_gen_it", "Type", nBase)) == PRC_CRAFT_ITEM_TYPE_AMMO)
|
||
{
|
||
iptemp.type = ITEM_PROPERTY_DAMAGE_BONUS;
|
||
iptemp.subtype = (nBase == BASE_ITEM_BULLET) ? DAMAGE_TYPE_BLUDGEONING : DAMAGE_TYPE_PIERCING;
|
||
}
|
||
}
|
||
}
|
||
if(DEBUG) DoDebug("Reconstructed: IP" + IntToString(nIndex) + ", " + IntToString(iptemp.type)+"_"+IntToString(iptemp.subtype)+"_"+IntToString(iptemp.costtablevalue)+"_"+IntToString(iptemp.param1value));
|
||
return ConstructIP(iptemp.type, iptemp.subtype, iptemp.costtablevalue, iptemp.param1value);
|
||
}
|
||
|
||
void ApplyItemProps(object oItem, string sFile, int nLine)
|
||
{
|
||
int i;
|
||
itemproperty ip;
|
||
if(StringToInt(Get2DACache(sFile, "Special", nLine)))
|
||
{
|
||
if(sFile == "craft_wondrous")
|
||
{
|
||
switch(nLine)
|
||
{
|
||
case 43:
|
||
{
|
||
ApplyBonusToStatBasedChecks(oItem, ABILITY_CHARISMA, 3);
|
||
SetName(oItem, GetStringByStrRef(StringToInt(Get2DACache(sFile, "Name", nLine))));
|
||
return;
|
||
break;
|
||
}
|
||
case 85: //helm of brilliance
|
||
case 91: //necklace of fireballs
|
||
case 92:
|
||
case 93:
|
||
case 94:
|
||
case 95:
|
||
case 96:
|
||
case 97: SetItemCharges(oItem, 50); break;
|
||
case 108: IPSafeAddItemProperty(oItem, ItemPropertyLimitUseBySAlign(IP_CONST_ALIGNMENT_TN), 0.0, X2_IP_ADDPROP_POLICY_REPLACE_EXISTING); break;
|
||
case 116:
|
||
{
|
||
object oCopy = CopyObject(oItem, GetLocation(oItem), GetItemPossessor(oItem), "prc_turnphyl");
|
||
DestroyObject(oItem);
|
||
oItem = oCopy;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
i = 1; //FUGLY HACK: i doesn't initialise properly in for loop
|
||
for(i = 1; i <= 6; i++)
|
||
{
|
||
if(DEBUG) DoDebug("ApplyItemProps: i = " + IntToString(i));
|
||
ip = PropSpecialHandling(oItem, sFile, nLine, i);
|
||
if(GetIsItemPropertyValid(ip))
|
||
{
|
||
if(DEBUG) DoDebug(GetItemPropertyString(ip));
|
||
IPSafeAddItemProperty(oItem, ip, 0.0, X2_IP_ADDPROP_POLICY_REPLACE_EXISTING);
|
||
}
|
||
else
|
||
break; //no more itemprops, no gaps, assuming no errors
|
||
}
|
||
if(sFile != "craft_weapon" && sFile != "craft_armour")
|
||
SetName(oItem, GetStringByStrRef(StringToInt(Get2DACache(sFile, "Name", nLine))));
|
||
}
|
||
|
||
//Partly ripped off the lexicon :P
|
||
int GetItemBaseAC(object oItem)
|
||
{
|
||
int nAC = -1;
|
||
int nBase = GetBaseItemType(oItem);
|
||
int bID = GetIdentified(oItem);
|
||
if(bID) SetIdentified(oItem, FALSE);
|
||
|
||
if(nBase == BASE_ITEM_ARMOR)
|
||
{
|
||
switch(GetGoldPieceValue(oItem))
|
||
{
|
||
case 1: nAC = 0; break; // None
|
||
case 5: nAC = 1; break; // Padded
|
||
case 10: nAC = 2; break; // Leather
|
||
case 15: nAC = 3; break; // Studded Leather / Hide
|
||
case 100: nAC = 4; break; // Chain Shirt / Scale Mail
|
||
case 150: nAC = 5; break; // Chainmail / Breastplate
|
||
case 200: nAC = 6; break; // Splint Mail / Banded Mail
|
||
case 600: nAC = 7; break; // Half-Plate
|
||
case 1500: nAC = 8; break; // Full Plate
|
||
}
|
||
}
|
||
else if(nBase == BASE_ITEM_SMALLSHIELD)
|
||
nAC = 1;
|
||
else if(nBase == BASE_ITEM_LARGESHIELD)
|
||
nAC = 2;
|
||
else if(nBase == BASE_ITEM_TOWERSHIELD)
|
||
nAC = 3;
|
||
|
||
if(bID) SetIdentified(oItem, TRUE);
|
||
return nAC;
|
||
}
|
||
|
||
int GetItemArmourCheckPenalty(object oItem)
|
||
{
|
||
int nBase = GetBaseItemType(oItem);
|
||
int nPenalty = 0;
|
||
if(nBase == BASE_ITEM_SMALLSHIELD)
|
||
nPenalty = 1;
|
||
else if(nBase == BASE_ITEM_LARGESHIELD)
|
||
nPenalty = 2;
|
||
else if(nBase == BASE_ITEM_TOWERSHIELD)
|
||
nPenalty = 10;
|
||
else if(nBase == BASE_ITEM_ARMOR)
|
||
{
|
||
switch(GetItemBaseAC(oItem))
|
||
{
|
||
case 3: nPenalty = 1; break;
|
||
case 4: nPenalty = 2; break;
|
||
case 5: nPenalty = 5; break;
|
||
case 6: nPenalty = 7; break;
|
||
case 7: nPenalty = 7; break;
|
||
case 8: nPenalty = 8; break;
|
||
}
|
||
}
|
||
return nPenalty;
|
||
}
|
||
|
||
string GetCrafting2DA(object oItem)
|
||
{
|
||
int nBase = GetBaseItemType(oItem);
|
||
int nMaterial = StringToInt(GetStringLeft(GetTag(oItem), 3));
|
||
if(((nBase == BASE_ITEM_ARMOR) ||
|
||
(nBase == BASE_ITEM_SMALLSHIELD) ||
|
||
(nBase == BASE_ITEM_LARGESHIELD) ||
|
||
(nBase == BASE_ITEM_TOWERSHIELD))
|
||
)
|
||
{
|
||
if((GetItemBaseAC(oItem) == 0) && !(nMaterial & PRC_CRAFT_FLAG_MASTERWORK)) return "craft_wondrous";
|
||
return "craft_armour";
|
||
}
|
||
|
||
if(GetWeaponType(nBase) ||
|
||
(nBase == BASE_ITEM_ARROW) ||
|
||
(nBase == BASE_ITEM_BOLT) ||
|
||
(nBase == BASE_ITEM_BULLET)
|
||
)
|
||
return "craft_weapon";
|
||
|
||
if(nBase == BASE_ITEM_RING) return "craft_ring";
|
||
|
||
if(((nBase == BASE_ITEM_HELMET) ||
|
||
(nBase == BASE_ITEM_AMULET) ||
|
||
(nBase == BASE_ITEM_BELT) ||
|
||
(nBase == BASE_ITEM_BOOTS) ||
|
||
(nBase == BASE_ITEM_GLOVES) ||
|
||
(nBase == BASE_ITEM_BRACER) ||
|
||
(nBase == BASE_ITEM_CLOAK))
|
||
)
|
||
return "craft_wondrous";
|
||
|
||
//restrict to castspell itemprops?
|
||
/*
|
||
if(nBase == BASE_ITEM_MAGICROD) return FEAT_CRAFT_ROD;
|
||
if(nBase == BASE_ITEM_MAGICSTAFF) return FEAT_CRAFT_STAFF;
|
||
if(nBase == BASE_ITEM_MAGICWAND) return FEAT_CRAFT_WAND;
|
||
*/
|
||
|
||
//bioware crafting, castspell itemprops only
|
||
return "";
|
||
}
|
||
|
||
int GetCraftingFeat(object oItem)
|
||
{
|
||
int nBase = GetBaseItemType(oItem);
|
||
int nMaterial = StringToInt(GetStringLeft(GetTag(oItem), 3));
|
||
if(((nBase == BASE_ITEM_ARMOR) ||
|
||
(nBase == BASE_ITEM_SMALLSHIELD) ||
|
||
(nBase == BASE_ITEM_LARGESHIELD) ||
|
||
(nBase == BASE_ITEM_TOWERSHIELD)) ||
|
||
(GetWeaponType(nBase) ||
|
||
(nBase == BASE_ITEM_ARROW) ||
|
||
(nBase == BASE_ITEM_BOLT) ||
|
||
(nBase == BASE_ITEM_BULLET)
|
||
)
|
||
)
|
||
{
|
||
if((GetItemBaseAC(oItem) == 0) && !(nMaterial & PRC_CRAFT_FLAG_MASTERWORK)) return FEAT_CRAFT_WONDROUS;
|
||
return FEAT_CRAFT_ARMS_ARMOR;
|
||
}
|
||
|
||
if(nBase == BASE_ITEM_RING) return FEAT_FORGE_RING;
|
||
|
||
//routing bioware feats through this convo
|
||
if((nBase == BASE_ITEM_MAGICROD) ||
|
||
(nBase == BASE_ITEM_CRAFTED_ROD)
|
||
)
|
||
return FEAT_CRAFT_ROD;
|
||
if((nBase == BASE_ITEM_MAGICSTAFF) ||
|
||
(nBase == BASE_ITEM_CRAFTED_STAFF)
|
||
)
|
||
return FEAT_CRAFT_STAFF;
|
||
if((nBase == BASE_ITEM_MAGICWAND) ||
|
||
(nBase == BASE_ITEM_BLANK_WAND)
|
||
)
|
||
return FEAT_CRAFT_WAND;
|
||
if(nBase == BASE_ITEM_BLANK_POTION) return FEAT_BREW_POTION;
|
||
if(nBase == BASE_ITEM_BLANK_SCROLL) return FEAT_SCRIBE_SCROLL;
|
||
|
||
if(((nBase == BASE_ITEM_HELMET) ||
|
||
(nBase == BASE_ITEM_AMULET) ||
|
||
(nBase == BASE_ITEM_BELT) ||
|
||
(nBase == BASE_ITEM_BOOTS) ||
|
||
(nBase == BASE_ITEM_GLOVES) ||
|
||
(nBase == BASE_ITEM_BRACER) ||
|
||
(nBase == BASE_ITEM_CLOAK))
|
||
)
|
||
return FEAT_CRAFT_WONDROUS;
|
||
|
||
return -1;
|
||
}
|
||
|
||
int GetEpicCraftingFeat(int nFeat)
|
||
{
|
||
switch(nFeat)
|
||
{
|
||
case FEAT_CRAFT_WONDROUS: return FEAT_CRAFT_EPIC_WONDROUS_ITEM;
|
||
case FEAT_CRAFT_CONSTRUCT:
|
||
case FEAT_CRAFT_ARMS_ARMOR: return FEAT_CRAFT_EPIC_MAGIC_ARMS_ARMOR;
|
||
case FEAT_CRAFT_ROD: return FEAT_CRAFT_EPIC_ROD;
|
||
case FEAT_CRAFT_STAFF: return FEAT_CRAFT_EPIC_STAFF;
|
||
case FEAT_FORGE_RING: return FEAT_FORGE_EPIC_RING;
|
||
}
|
||
return -1;
|
||
}
|
||
|
||
//Returns whether the item can be made of a material
|
||
int CheckCraftingMaterial(int nBaseItem, int nMaterial, int nBaseAC = -1)
|
||
{
|
||
if(nBaseItem == BASE_ITEM_WHIP || nBaseItem == BASE_ITEM_SAP) return (nMaterial == PRC_CRAFT_MATERIAL_LEATHER);
|
||
|
||
if((nBaseItem == BASE_ITEM_SMALLSHIELD) ||
|
||
(nBaseItem == BASE_ITEM_LARGESHIELD) ||
|
||
(nBaseItem == BASE_ITEM_TOWERSHIELD)
|
||
)
|
||
return ((nMaterial == PRC_CRAFT_MATERIAL_METAL) || (nMaterial == PRC_CRAFT_MATERIAL_WOOD));
|
||
|
||
if(nBaseItem == BASE_ITEM_ARMOR)
|
||
{
|
||
/*
|
||
if(nBaseAC >= 0 && nBaseAC <= 1) return (nMaterial == PRC_CRAFT_MATERIAL_CLOTH);
|
||
if(nBaseAC >= 2 && nBaseAC <= 3) return (nMaterial == PRC_CRAFT_MATERIAL_LEATHER);
|
||
else return (nMaterial == PRC_CRAFT_MATERIAL_METAL);
|
||
*/
|
||
return ((nMaterial == PRC_CRAFT_MATERIAL_METAL) || (nMaterial == PRC_CRAFT_MATERIAL_LEATHER));
|
||
}
|
||
//since you can't make adamantine weapons at the moment
|
||
if((nBaseItem == BASE_ITEM_HEAVYCROSSBOW) ||
|
||
(nBaseItem == BASE_ITEM_LIGHTCROSSBOW) ||
|
||
(nBaseItem == BASE_ITEM_LONGBOW) ||
|
||
(nBaseItem == BASE_ITEM_SHORTBOW) ||
|
||
(nBaseItem == BASE_ITEM_QUARTERSTAFF) ||
|
||
(nBaseItem == BASE_ITEM_CLUB) ||
|
||
(nBaseItem == BASE_ITEM_NUNCHAKU) || //nunchaku
|
||
(nBaseItem == BASE_ITEM_SCYTHE) ||
|
||
(nBaseItem == BASE_ITEM_SHORTSPEAR) ||
|
||
(nBaseItem == BASE_ITEM_TRIDENT) ||
|
||
(nBaseItem == BASE_ITEM_HALBERD) ||
|
||
(nBaseItem == BASE_ITEM_GOAD) || //goad
|
||
(nBaseItem == BASE_ITEM_CLUB)
|
||
)
|
||
{
|
||
return (nMaterial == PRC_CRAFT_MATERIAL_WOOD);
|
||
}
|
||
//assume stuff is made of metal (most of it is)
|
||
return (nMaterial == PRC_CRAFT_MATERIAL_METAL);
|
||
}
|
||
|
||
//Returns the DC for crafting a particular item
|
||
int GetCraftingDC(object oItem)
|
||
{
|
||
int nDC = 0;
|
||
int nBase = GetBaseItemType(oItem);
|
||
int nType = GetWeaponType(nBase);
|
||
if(((nBase == BASE_ITEM_ARMOR) ||
|
||
(nBase == BASE_ITEM_SMALLSHIELD) ||
|
||
(nBase == BASE_ITEM_LARGESHIELD) ||
|
||
(nBase == BASE_ITEM_TOWERSHIELD))
|
||
)
|
||
{
|
||
nDC = 10 + GetItemBaseAC(oItem);
|
||
}
|
||
else if(((nBase == BASE_ITEM_HEAVYCROSSBOW) ||
|
||
(nBase == BASE_ITEM_LIGHTCROSSBOW))
|
||
)
|
||
{
|
||
nDC = 15;
|
||
}
|
||
else if(((nBase == BASE_ITEM_LONGBOW) ||
|
||
(nBase == BASE_ITEM_SHORTBOW))
|
||
)
|
||
{
|
||
nDC = 12;
|
||
itemproperty ip = GetFirstItemProperty(oItem);
|
||
while(GetIsItemPropertyValid(ip))
|
||
{
|
||
if(GetItemPropertyType(ip) == ITEM_PROPERTY_MIGHTY)
|
||
{
|
||
nDC = 15 + 2 * GetItemPropertyCostTableValue(ip);
|
||
break;
|
||
}
|
||
ip = GetNextItemProperty(oItem);
|
||
}
|
||
}
|
||
else if(nType == PRC_CRAFT_SIMPLE_WEAPON)
|
||
nDC = 12;
|
||
else if(nType == PRC_CRAFT_MARTIAL_WEAPON)
|
||
nDC = 15;
|
||
else if(nType == PRC_CRAFT_EXOTIC_WEAPON)
|
||
nDC = 18;
|
||
return nDC;
|
||
}
|
||
|
||
//Applies Masterwork properties to oItem
|
||
void MakeMasterwork(object oItem)
|
||
{
|
||
if(GetPlotFlag(oItem)) return; //sanity check
|
||
int nBase = GetBaseItemType(oItem);
|
||
if((nBase == BASE_ITEM_ARMOR) ||
|
||
(nBase == BASE_ITEM_SMALLSHIELD) ||
|
||
(nBase == BASE_ITEM_LARGESHIELD) ||
|
||
(nBase == BASE_ITEM_TOWERSHIELD)
|
||
)
|
||
{
|
||
//no armour check penalty here
|
||
if(GetItemArmourCheckPenalty(oItem) == 0) return;
|
||
IPSafeAddItemProperty(oItem, ItemPropertySkillBonus(SKILL_HIDE, 1) , 0.0, X2_IP_ADDPROP_POLICY_REPLACE_EXISTING);
|
||
IPSafeAddItemProperty(oItem, ItemPropertySkillBonus(SKILL_MOVE_SILENTLY, 1), 0.0, X2_IP_ADDPROP_POLICY_REPLACE_EXISTING);
|
||
IPSafeAddItemProperty(oItem, ItemPropertySkillBonus(SKILL_PICK_POCKET, 1) , 0.0, X2_IP_ADDPROP_POLICY_REPLACE_EXISTING);
|
||
IPSafeAddItemProperty(oItem, ItemPropertySkillBonus(SKILL_SET_TRAP, 1) , 0.0, X2_IP_ADDPROP_POLICY_REPLACE_EXISTING);
|
||
IPSafeAddItemProperty(oItem, ItemPropertySkillBonus(SKILL_TUMBLE, 1) , 0.0, X2_IP_ADDPROP_POLICY_REPLACE_EXISTING);
|
||
IPSafeAddItemProperty(oItem, ItemPropertySkillBonus(SKILL_JUMP, 1) , 0.0, X2_IP_ADDPROP_POLICY_REPLACE_EXISTING);
|
||
}
|
||
else if(GetWeaponType(nBase))
|
||
{
|
||
IPSafeAddItemProperty(oItem, ItemPropertyAttackBonus(1), 0.0, X2_IP_ADDPROP_POLICY_KEEP_EXISTING);
|
||
}
|
||
else if(StringToInt(Get2DACache("prc_craft_gen_it", "Type", nBase)) == PRC_CRAFT_ITEM_TYPE_AMMO)
|
||
{
|
||
/*
|
||
int nDamageType = (nBase == BASE_ITEM_BULLET) ? DAMAGE_TYPE_BLUDGEONING : DAMAGE_TYPE_PIERCING;
|
||
itemproperty ip1 = ItemPropertyDamageBonus(nDamageType, IP_CONST_DAMAGEBONUS_1);
|
||
*/
|
||
IPSafeAddItemProperty(oItem, ItemPropertyAttackBonus(1), 0.0, X2_IP_ADDPROP_POLICY_KEEP_EXISTING);
|
||
}
|
||
else
|
||
return;
|
||
}
|
||
|
||
void MakeAdamantine(object oItem)
|
||
{
|
||
if(GetPlotFlag(oItem)) return; //sanity check
|
||
if(GetBaseItemType(oItem) == BASE_ITEM_ARMOR)
|
||
{
|
||
int nBonus = 0;
|
||
switch(GetItemBaseAC(oItem))
|
||
{
|
||
case 1:
|
||
case 2:
|
||
case 3: nBonus = IP_CONST_DAMAGERESIST_1; break;
|
||
case 4:
|
||
case 5: nBonus = IP_CONST_DAMAGERESIST_2; break;
|
||
case 6:
|
||
case 7:
|
||
case 8: nBonus = IP_CONST_DAMAGERESIST_3; break;
|
||
}
|
||
if(nBonus)
|
||
{
|
||
IPSafeAddItemProperty(oItem, ItemPropertyDamageResistance(IP_CONST_DAMAGETYPE_BLUDGEONING, nBonus), 0.0, X2_IP_ADDPROP_POLICY_REPLACE_EXISTING);
|
||
IPSafeAddItemProperty(oItem, ItemPropertyDamageResistance(IP_CONST_DAMAGETYPE_PIERCING, nBonus) , 0.0, X2_IP_ADDPROP_POLICY_REPLACE_EXISTING);
|
||
IPSafeAddItemProperty(oItem, ItemPropertyDamageResistance(IP_CONST_DAMAGETYPE_SLASHING, nBonus) , 0.0, X2_IP_ADDPROP_POLICY_REPLACE_EXISTING);
|
||
}
|
||
}
|
||
}
|
||
|
||
void MakeDarkwood(object oItem)
|
||
{
|
||
if(GetPlotFlag(oItem)) return; //sanity check
|
||
IPSafeAddItemProperty(oItem, ItemPropertyWeightReduction(IP_CONST_REDUCEDWEIGHT_50_PERCENT), 0.0, X2_IP_ADDPROP_POLICY_KEEP_EXISTING);
|
||
int nBase = GetBaseItemType(oItem);
|
||
if(((nBase == BASE_ITEM_SMALLSHIELD) ||
|
||
(nBase == BASE_ITEM_LARGESHIELD) ||
|
||
(nBase == BASE_ITEM_TOWERSHIELD))
|
||
)
|
||
{
|
||
int nBonus = 2;
|
||
if(nBase == BASE_ITEM_SMALLSHIELD) nBonus = 1;
|
||
IPSafeAddItemProperty(oItem, ItemPropertySkillBonus(SKILL_HIDE, nBonus) , 0.0, X2_IP_ADDPROP_POLICY_REPLACE_EXISTING);
|
||
IPSafeAddItemProperty(oItem, ItemPropertySkillBonus(SKILL_MOVE_SILENTLY, nBonus), 0.0, X2_IP_ADDPROP_POLICY_REPLACE_EXISTING);
|
||
IPSafeAddItemProperty(oItem, ItemPropertySkillBonus(SKILL_PICK_POCKET, nBonus) , 0.0, X2_IP_ADDPROP_POLICY_REPLACE_EXISTING);
|
||
IPSafeAddItemProperty(oItem, ItemPropertySkillBonus(SKILL_SET_TRAP, nBonus) , 0.0, X2_IP_ADDPROP_POLICY_REPLACE_EXISTING);
|
||
IPSafeAddItemProperty(oItem, ItemPropertySkillBonus(SKILL_TUMBLE, nBonus) , 0.0, X2_IP_ADDPROP_POLICY_REPLACE_EXISTING);
|
||
IPSafeAddItemProperty(oItem, ItemPropertySkillBonus(SKILL_JUMP, nBonus) , 0.0, X2_IP_ADDPROP_POLICY_REPLACE_EXISTING);
|
||
}
|
||
}
|
||
|
||
void MakeDragonhide(object oItem)
|
||
{
|
||
//Does nothing so far
|
||
}
|
||
|
||
void MakeMithral(object oItem)
|
||
{
|
||
if(GetPlotFlag(oItem)) return; //sanity check
|
||
IPSafeAddItemProperty(oItem, ItemPropertyWeightReduction(IP_CONST_REDUCEDWEIGHT_50_PERCENT), 0.0, X2_IP_ADDPROP_POLICY_KEEP_EXISTING);
|
||
int nBase = GetBaseItemType(oItem);
|
||
if(((nBase == BASE_ITEM_ARMOR) ||
|
||
(nBase == BASE_ITEM_SMALLSHIELD) ||
|
||
(nBase == BASE_ITEM_LARGESHIELD) ||
|
||
(nBase == BASE_ITEM_TOWERSHIELD))
|
||
)
|
||
{
|
||
int nBonus = 3;
|
||
int nPenalty = GetItemArmourCheckPenalty(oItem);
|
||
if(nBonus > nPenalty) nBonus = nPenalty;
|
||
IPSafeAddItemProperty(oItem, ItemPropertySkillBonus(SKILL_HIDE, nBonus) , 0.0, X2_IP_ADDPROP_POLICY_REPLACE_EXISTING);
|
||
IPSafeAddItemProperty(oItem, ItemPropertySkillBonus(SKILL_MOVE_SILENTLY, nBonus), 0.0, X2_IP_ADDPROP_POLICY_REPLACE_EXISTING);
|
||
IPSafeAddItemProperty(oItem, ItemPropertySkillBonus(SKILL_PICK_POCKET, nBonus) , 0.0, X2_IP_ADDPROP_POLICY_REPLACE_EXISTING);
|
||
IPSafeAddItemProperty(oItem, ItemPropertySkillBonus(SKILL_SET_TRAP, nBonus) , 0.0, X2_IP_ADDPROP_POLICY_REPLACE_EXISTING);
|
||
IPSafeAddItemProperty(oItem, ItemPropertySkillBonus(SKILL_TUMBLE, nBonus) , 0.0, X2_IP_ADDPROP_POLICY_REPLACE_EXISTING);
|
||
IPSafeAddItemProperty(oItem, ItemPropertySkillBonus(SKILL_JUMP, nBonus) , 0.0, X2_IP_ADDPROP_POLICY_REPLACE_EXISTING);
|
||
IPSafeAddItemProperty(oItem, ItemPropertySkillBonus(SKILL_BALANCE, nBonus) , 0.0, X2_IP_ADDPROP_POLICY_REPLACE_EXISTING);
|
||
IPSafeAddItemProperty(oItem, ItemPropertySkillBonus(SKILL_CLIMB, nBonus) , 0.0, X2_IP_ADDPROP_POLICY_REPLACE_EXISTING);
|
||
if(GetItemBaseAC(oItem) == 1)
|
||
IPSafeAddItemProperty(oItem, ItemPropertyArcaneSpellFailure(IP_CONST_ARCANE_SPELL_FAILURE_MINUS_5_PERCENT), 0.0, X2_IP_ADDPROP_POLICY_REPLACE_EXISTING);
|
||
else
|
||
IPSafeAddItemProperty(oItem, ItemPropertyArcaneSpellFailure(IP_CONST_ARCANE_SPELL_FAILURE_MINUS_10_PERCENT), 0.0, X2_IP_ADDPROP_POLICY_REPLACE_EXISTING);
|
||
}
|
||
}
|
||
|
||
void MakeColdIron(object oItem)
|
||
{
|
||
//Does nothing so far
|
||
}
|
||
|
||
void MakeSilver(object oItem)
|
||
{
|
||
//Does nothing so far
|
||
}
|
||
|
||
void MakeMundaneCrystal(object oItem)
|
||
{
|
||
//Does nothing so far
|
||
}
|
||
|
||
void MakeDeepCrystal(object oItem)
|
||
{
|
||
//Does nothing so far
|
||
}
|
||
|
||
//Creates an item on oOwner, from the baseitemtype and base AC (for armour)
|
||
object CreateStandardItem(object oOwner, int nBaseItemType, int nBaseAC = -1)
|
||
{
|
||
string sResRef = Get2DACache("prc_craft_gen_it", "Blueprint", nBaseItemType);
|
||
int nStackSize = StringToInt(Get2DACache("baseitems", "ILRStackSize", nBaseItemType));
|
||
if(nBaseItemType == BASE_ITEM_ARMOR)
|
||
{
|
||
switch(nBaseAC)
|
||
{
|
||
case 0: sResRef = "x2_cloth008"; break;
|
||
case 1: sResRef = "nw_aarcl009"; break;
|
||
case 2: sResRef = "nw_aarcl001"; break;
|
||
case 3: sResRef = "nw_aarcl002"; break;
|
||
case 4: sResRef = "nw_aarcl012"; break;
|
||
case 5: sResRef = "nw_aarcl004"; break;
|
||
case 6: sResRef = "nw_aarcl005"; break;
|
||
case 7: sResRef = "nw_aarcl006"; break;
|
||
case 8: sResRef = "nw_aarcl007"; break;
|
||
}
|
||
}
|
||
string sTag;
|
||
if (GetLevelByClass(CLASS_TYPE_IRONSOUL_FORGEMASTER, oOwner)) sTag = GetName(oOwner);
|
||
|
||
return CreateItemOnObject(sResRef, oOwner, nStackSize, sTag);
|
||
}
|
||
|
||
int GetEnhancementBaseCost(object oItem)
|
||
{
|
||
string sFile = GetCrafting2DA(oItem);
|
||
if(sFile == "craft_armour") return 1000;
|
||
if(sFile == "craft_weapon") return 2000;
|
||
|
||
return 0;
|
||
}
|
||
|
||
//returns pnp market price of an item
|
||
int GetPnPItemCost(struct itemvars strTemp, int bIncludeBaseCost = TRUE)
|
||
{
|
||
int nMaterial, nEnhancement;
|
||
int nAdd = 0, nTemp = 0;
|
||
int nType = GetBaseItemType(strTemp.item);
|
||
|
||
if(DEBUG)
|
||
{
|
||
DoDebug("nType: " + IntToString(nType));
|
||
FloatingTextStringOnCreature( "nType = " + IntToString(nType), GetFirstPC());
|
||
}
|
||
if(bIncludeBaseCost)
|
||
{
|
||
SetIdentified(strTemp.item, FALSE);
|
||
int nMultiplyer = StringToInt(Get2DACache("baseitems", "ItemMultiplier", nType));
|
||
if(nMultiplyer < 1) nMultiplyer = 1;
|
||
if(DEBUG)
|
||
{
|
||
DoDebug("nMultiplyer: " + IntToString(nMultiplyer));
|
||
FloatingTextStringOnCreature( "nMultiplyer = " + IntToString(nMultiplyer), GetFirstPC());
|
||
}
|
||
|
||
nTemp = GetGoldPieceValue(strTemp.item) / nMultiplyer;
|
||
if(DEBUG)
|
||
{
|
||
DoDebug("nTemp: " + IntToString(nTemp));
|
||
FloatingTextStringOnCreature( "nTemp = " + IntToString(nTemp), GetFirstPC());
|
||
}
|
||
|
||
SetIdentified(strTemp.item, TRUE);
|
||
int nFlag = StringToInt(Get2DACache("prc_craft_gen_it", "Type", nType));
|
||
string sMaterial = GetStringLeft(GetTag(strTemp.item), 3);
|
||
nMaterial = StringToInt(sMaterial);
|
||
if(GetMaterialString(nMaterial) != sMaterial)
|
||
nMaterial = 0;
|
||
if(nMaterial & PRC_CRAFT_FLAG_MASTERWORK)
|
||
{
|
||
switch(nFlag)
|
||
{
|
||
case PRC_CRAFT_ITEM_TYPE_WEAPON: nAdd += 300; break;
|
||
case PRC_CRAFT_ITEM_TYPE_ARMOUR: nAdd += 150; break;
|
||
case PRC_CRAFT_ITEM_TYPE_SHIELD: nAdd += 150; break;
|
||
case PRC_CRAFT_ITEM_TYPE_AMMO: nAdd += 594; break;
|
||
}
|
||
}
|
||
if(nMaterial & PRC_CRAFT_FLAG_ADAMANTINE)
|
||
{
|
||
switch(GetItemBaseAC(strTemp.item))
|
||
{
|
||
case 1:
|
||
case 2:
|
||
case 3: nAdd += 5000; break;
|
||
case 4:
|
||
case 5: nAdd += 10000; break;
|
||
case 6:
|
||
case 7:
|
||
case 8: nAdd += 15000; break;
|
||
}
|
||
}
|
||
if(nMaterial & PRC_CRAFT_FLAG_DARKWOOD)
|
||
{
|
||
nAdd += StringToInt(Get2DACache("baseitems", "TenthLBS", nType));
|
||
}
|
||
if(nMaterial & PRC_CRAFT_FLAG_DRAGONHIDE)
|
||
{
|
||
nAdd += nAdd + nTemp;
|
||
}
|
||
if(nMaterial & PRC_CRAFT_FLAG_MITHRAL)
|
||
{
|
||
if(nType == BASE_ITEM_ARMOR)
|
||
{
|
||
switch(GetItemBaseAC(strTemp.item))
|
||
{
|
||
case 1:
|
||
case 2:
|
||
case 3: nAdd += 1000; break;
|
||
case 4:
|
||
case 5: nAdd += 4000; break;
|
||
case 6:
|
||
case 7:
|
||
case 8: nAdd += 9000; break;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
switch(nFlag)
|
||
{
|
||
case PRC_CRAFT_ITEM_TYPE_WEAPON: nAdd += 50 * StringToInt(Get2DACache("baseitems", "TenthLBS", nType)); break;
|
||
case PRC_CRAFT_ITEM_TYPE_SHIELD: nAdd += 1000; break;
|
||
}
|
||
}
|
||
}
|
||
if(nMaterial & PRC_CRAFT_FLAG_COLD_IRON)
|
||
{
|
||
//not implemented
|
||
}
|
||
if(nMaterial & PRC_CRAFT_FLAG_ALCHEMICAL_SILVER)
|
||
{
|
||
//not implemented
|
||
}
|
||
if(nMaterial & PRC_CRAFT_FLAG_MUNDANE_CRYSTAL)
|
||
{
|
||
//not implemented
|
||
}
|
||
if(nMaterial & PRC_CRAFT_FLAG_DEEP_CRYSTAL)
|
||
{
|
||
//not implemented
|
||
}
|
||
if(((nType == BASE_ITEM_LONGBOW) ||
|
||
(nType == BASE_ITEM_SHORTBOW))
|
||
)
|
||
{
|
||
int nCompMult = (nType == BASE_ITEM_LONGBOW) ? 100 : 75;
|
||
itemproperty ip = GetFirstItemProperty(strTemp.item);
|
||
while(GetIsItemPropertyValid(ip))
|
||
{
|
||
if(GetItemPropertyType(ip) == ITEM_PROPERTY_MIGHTY)
|
||
{
|
||
nAdd += GetItemPropertyCostTableValue(ip) * nCompMult;
|
||
break;
|
||
}
|
||
ip = GetNextItemProperty(strTemp.item);
|
||
}
|
||
}
|
||
}
|
||
if(DEBUG)
|
||
{
|
||
DoDebug("nAdd: " + IntToString(nAdd));
|
||
FloatingTextStringOnCreature( "nAdd = " + IntToString(nAdd), GetFirstPC());
|
||
}
|
||
nTemp += nAdd;
|
||
nEnhancement = GetEnhancementBaseCost(strTemp.item) * strTemp.enhancement * strTemp.enhancement;
|
||
if(strTemp.epic) nEnhancement *= 10;
|
||
nTemp += nEnhancement + strTemp.additionalcost;
|
||
|
||
if(StringToInt(Get2DACache("baseitems", "Stacking", nType)) > 1)
|
||
nTemp = FloatToInt(IntToFloat(nTemp) * IntToFloat(GetItemStackSize(strTemp.item))/ 50.0);
|
||
if(nTemp < 1) nTemp = 1;
|
||
|
||
return nTemp;
|
||
}
|
||
|
||
struct golemhds GetGolemHDsFromString(string sHD)
|
||
{
|
||
struct golemhds hds;
|
||
//initialise variables
|
||
string sTemp = sHD;
|
||
string sSub;
|
||
int nLength = GetStringLength(sTemp);
|
||
int nPosition;
|
||
int nTemp;
|
||
int i;
|
||
|
||
for(i = 0; i < 3; i++)
|
||
{
|
||
nPosition = FindSubString(sTemp, "_");
|
||
sSub = (nPosition == -1) ? sTemp : GetStringLeft(sTemp, nPosition);
|
||
nLength -= (nPosition + 1);
|
||
if(sSub == "*")
|
||
nTemp = -1;
|
||
else
|
||
nTemp = StringToInt(sSub);
|
||
switch(i)
|
||
{
|
||
case 0: hds.base = nTemp; break;
|
||
case 1: hds.max1 = nTemp; break;
|
||
case 2: hds.max2 = nTemp; break;
|
||
}
|
||
sTemp = GetSubString(sTemp, nPosition + 1, nLength);
|
||
}
|
||
return hds;
|
||
}
|
||
|
||
//returns market price in gp,
|
||
int GetPnPGolemCost(int nLine, int nHD, int nCosttype)
|
||
{
|
||
int nCost = StringToInt(Get2DACache("craft_golem", "MarketPrice", nLine));
|
||
struct golemhds ghds = GetGolemHDsFromString(Get2DACache("craft_golem", "HD", nLine));
|
||
|
||
|
||
//sanity checking
|
||
if(nHD < ghds.base) nHD = ghds.base;
|
||
if(nHD > ghds.max2) nHD = ghds.max2;
|
||
|
||
if(nHD > ghds.base)
|
||
{
|
||
nCost += (ghds.base - nHD) * 5000;
|
||
if(nHD > ghds.max1)
|
||
nCost += 50000;
|
||
}
|
||
|
||
if(nCosttype == CRAFT_COST_TYPE_XP)
|
||
{
|
||
if(StringToInt(Get2DACache("craft_golem", "Epic", nLine)))
|
||
{
|
||
nCost /= 100;
|
||
}
|
||
else
|
||
{
|
||
nCost /= 25;
|
||
}
|
||
}
|
||
else if(nCosttype == CRAFT_COST_TYPE_CRAFTING)
|
||
{
|
||
nCost /= 2;
|
||
}
|
||
|
||
if(nCosttype != CRAFT_COST_TYPE_XP)
|
||
nCost += StringToInt(Get2DACache("craft_golem", "SpecialCost", nLine));
|
||
|
||
return nCost;
|
||
}
|
||
|
||
//Creates an item for oPC of nBaseItemType, made of nMaterial
|
||
object MakeMyItem(object oPC, int nBaseItemType, int nBaseAC = -1, int nMaterial = 0, int nMighty = -1)
|
||
{
|
||
object oTemp = CreateStandardItem(GetTempCraftChest(), nBaseItemType, nBaseAC);
|
||
string sMaterial = GetMaterialString(nMaterial);
|
||
string sTag = sMaterial + GetUniqueID() + PRC_CRAFT_UID_SUFFIX;
|
||
object oChest = GetCraftChest();
|
||
while(GetIsObjectValid(GetItemPossessedBy(oChest, sTag)))//make sure there aren't any tag conflicts
|
||
sTag = sMaterial + GetUniqueID() + PRC_CRAFT_UID_SUFFIX;
|
||
if (GetLevelByClass(CLASS_TYPE_IRONSOUL_FORGEMASTER, oPC)) sTag = GetName(oPC);
|
||
object oNew = CopyObject(oTemp, GetLocation(oChest), oChest, sTag);
|
||
string sPrefix = "";
|
||
if(nMighty > 0)
|
||
{
|
||
if(nMighty > 20) nMighty = 20;
|
||
IPSafeAddItemProperty(oNew, ItemPropertyMaxRangeStrengthMod(nMighty), 0.0, X2_IP_ADDPROP_POLICY_REPLACE_EXISTING);
|
||
IPSafeAddItemProperty(oNew, ItemPropertyLimitUseByAbility(ABILITY_STRENGTH, ((nMighty * 2) + 10)), 0.0, X2_IP_ADDPROP_POLICY_REPLACE_EXISTING);
|
||
}
|
||
DestroyObject(oTemp, 0.1);
|
||
if(nMaterial & PRC_CRAFT_FLAG_MASTERWORK) //name prefix will be overridden by materials
|
||
{
|
||
sPrefix = "Masterwork ";
|
||
MakeMasterwork(oNew);
|
||
}
|
||
if(nMaterial & PRC_CRAFT_FLAG_ADAMANTINE) //assumes only 1 material at a time
|
||
{
|
||
sPrefix = "Adamantine ";
|
||
MakeAdamantine(oNew);
|
||
}
|
||
if(nMaterial & PRC_CRAFT_FLAG_DARKWOOD)
|
||
{
|
||
sPrefix = "Darkwood ";
|
||
MakeDarkwood(oNew);
|
||
}
|
||
if(nMaterial & PRC_CRAFT_FLAG_DRAGONHIDE)
|
||
{
|
||
sPrefix = "Dragonhide ";
|
||
MakeDragonhide(oNew);
|
||
}
|
||
if(nMaterial & PRC_CRAFT_FLAG_MITHRAL)
|
||
{
|
||
sPrefix = "Mithral ";
|
||
MakeMithral(oNew);
|
||
}
|
||
if(nMaterial & PRC_CRAFT_FLAG_COLD_IRON)
|
||
{
|
||
sPrefix = "Cold Iron ";
|
||
MakeColdIron(oNew);
|
||
}
|
||
if(nMaterial & PRC_CRAFT_FLAG_ALCHEMICAL_SILVER)
|
||
{
|
||
sPrefix = "Silver ";
|
||
MakeSilver(oNew);
|
||
}
|
||
if(nMaterial & PRC_CRAFT_FLAG_MUNDANE_CRYSTAL)
|
||
{
|
||
sPrefix = "Crystal ";
|
||
MakeMundaneCrystal(oNew);
|
||
}
|
||
if(nMaterial & PRC_CRAFT_FLAG_DEEP_CRYSTAL)
|
||
{
|
||
sPrefix = "Deep Crystal ";
|
||
MakeDeepCrystal(oNew);
|
||
}
|
||
if(nMighty > 0) sPrefix += "Composite ";
|
||
|
||
if((nBaseItemType == BASE_ITEM_ARMOR) && (nBaseAC == 0))
|
||
SetName(oNew, "Robe");
|
||
SetName(oNew, sPrefix + GetName(oNew));
|
||
|
||
return oNew;
|
||
}
|
||
|
||
//Adds action highlight to a conversation string
|
||
string ActionString(string sString)
|
||
{
|
||
return "<c<01>>" + sString + "</c>";
|
||
}
|
||
|
||
//Inserts a space at the end of a string if the string
|
||
// is not empty
|
||
string InsertSpaceAfterString(string sString)
|
||
{
|
||
if(sString != "")
|
||
return sString + " ";
|
||
else return "";
|
||
}
|
||
|
||
string GetItemPropertyString(itemproperty ip)
|
||
{
|
||
int nType = GetItemPropertyType(ip);
|
||
if(nType == -1) return "";
|
||
int nSubType = GetItemPropertySubType(ip);
|
||
int nCostTable = GetItemPropertyCostTable(ip);
|
||
int nCostTableValue = GetItemPropertyCostTableValue(ip);
|
||
int nParam1 = GetItemPropertyParam1(ip);
|
||
int nParam1Value = GetItemPropertyParam1Value(ip);
|
||
string sDesc = InsertSpaceAfterString(
|
||
GetStringByStrRef(StringToInt(Get2DACache("itempropdef", "GameStrRef", nType)))
|
||
);
|
||
string sSubType = Get2DACache("itempropdef", "SubTypeResRef", nType);
|
||
sSubType = Get2DACache(sSubType, "Name", nSubType);
|
||
if(sSubType != "")
|
||
sDesc += InsertSpaceAfterString(GetStringByStrRef(StringToInt(sSubType)));
|
||
string sCostTable = Get2DACache("itempropdef", "CostTableResRef", nType);
|
||
sCostTable = Get2DACache("iprp_costtable", "Name", StringToInt(sCostTable));
|
||
sCostTable = Get2DACache(sCostTable, "Name", nCostTableValue);
|
||
if(sCostTable != "")
|
||
sDesc += InsertSpaceAfterString(GetStringByStrRef(StringToInt(sCostTable)));
|
||
string sParam1;
|
||
if(nType == ITEM_PROPERTY_ON_HIT_PROPERTIES) //Param1 depends on subtype
|
||
{
|
||
sParam1 = Get2DACache(Get2DACache("itempropdef", "SubTypeResRef", nType), "Param1ResRef", nSubType);
|
||
}
|
||
else
|
||
{
|
||
sParam1 = Get2DACache("itempropdef", "Param1ResRef", nType);
|
||
}
|
||
if(sParam1 != "")
|
||
{
|
||
sDesc += InsertSpaceAfterString(GetStringByStrRef(StringToInt(Get2DACache("iprp_paramtable", "Name", StringToInt(sParam1)))));
|
||
sParam1 = Get2DACache("iprp_paramtable", "TableResRef", StringToInt(sParam1));
|
||
sParam1 = Get2DACache(sParam1, "Name", nParam1Value);
|
||
if(sParam1 != "")
|
||
sDesc += InsertSpaceAfterString(GetStringByStrRef(StringToInt(sParam1)));
|
||
}
|
||
sDesc += "\n";
|
||
|
||
return sDesc;
|
||
}
|
||
|
||
//Returns a string describing the item
|
||
string ItemStats(object oItem)
|
||
{
|
||
string sDesc = GetName(oItem) +
|
||
"\n\n" +
|
||
GetStringByStrRef(StringToInt(Get2DACache("baseitems", "Name", GetBaseItemType(oItem)))) +
|
||
"\n\n";
|
||
|
||
itemproperty ip = GetFirstItemProperty(oItem);
|
||
while(GetIsItemPropertyValid(ip))
|
||
{
|
||
if(GetItemPropertyDurationType(ip) == DURATION_TYPE_PERMANENT)
|
||
{
|
||
sDesc += GetItemPropertyString(ip);
|
||
}
|
||
ip = GetNextItemProperty(oItem);
|
||
}
|
||
return sDesc;
|
||
}
|
||
|
||
//Returns TRUE if nBaseItem can have nItemProp
|
||
int ValidProperty(object oItem, int nItemProp)
|
||
{
|
||
int nPropColumn = StringToInt(Get2DACache("baseitems", "PropColumn", GetBaseItemType(oItem)));
|
||
string sPropCloumn = "";
|
||
switch(nPropColumn)
|
||
{
|
||
case 0: sPropCloumn = "0_Melee"; break;
|
||
case 1: sPropCloumn = "1_Ranged"; break;
|
||
case 2: sPropCloumn = "2_Thrown"; break;
|
||
case 3: sPropCloumn = "3_Staves"; break;
|
||
case 4: sPropCloumn = "4_Rods"; break;
|
||
case 5: sPropCloumn = "5_Ammo"; break;
|
||
case 6: sPropCloumn = "6_Arm_Shld"; break;
|
||
case 7: sPropCloumn = "7_Helm"; break;
|
||
case 8: sPropCloumn = "8_Potions"; break;
|
||
case 9: sPropCloumn = "9_Scrolls"; break;
|
||
case 10: sPropCloumn = "10_Wands"; break;
|
||
case 11: sPropCloumn = "11_Thieves"; break;
|
||
case 12: sPropCloumn = "12_TrapKits"; break;
|
||
case 13: sPropCloumn = "13_Hide"; break;
|
||
case 14: sPropCloumn = "14_Claw"; break;
|
||
case 15: sPropCloumn = "15_Misc_Uneq"; break;
|
||
case 16: sPropCloumn = "16_Misc"; break;
|
||
case 17: sPropCloumn = "17_No_Props"; break;
|
||
case 18: sPropCloumn = "18_Containers"; break;
|
||
case 19: sPropCloumn = "19_HealerKit"; break;
|
||
case 20: sPropCloumn = "20_Torch"; break;
|
||
case 21: sPropCloumn = "21_Glove"; break;
|
||
}
|
||
return(Get2DACache("itemprops", sPropCloumn, nItemProp) == "1");
|
||
}
|
||
|
||
//Makes an item property from values - total pain in the arse, need 1 per itemprop
|
||
itemproperty ConstructIP(int nType, int nSubTypeValue = 0, int nCostTableValue = 0, int nParam1Value = 0)
|
||
{
|
||
itemproperty ip;
|
||
switch(nType)
|
||
{
|
||
case ITEM_PROPERTY_ABILITY_BONUS: return ItemPropertyAbilityBonus(nSubTypeValue, nCostTableValue);
|
||
case ITEM_PROPERTY_AC_BONUS: return ItemPropertyACBonus(nCostTableValue);
|
||
case ITEM_PROPERTY_AC_BONUS_VS_ALIGNMENT_GROUP: return ItemPropertyACBonusVsAlign(nSubTypeValue, nCostTableValue);
|
||
case ITEM_PROPERTY_AC_BONUS_VS_DAMAGE_TYPE: return ItemPropertyACBonusVsDmgType(nSubTypeValue, nCostTableValue);
|
||
case ITEM_PROPERTY_AC_BONUS_VS_RACIAL_GROUP: return ItemPropertyACBonusVsRace(nSubTypeValue, nCostTableValue);
|
||
case ITEM_PROPERTY_AC_BONUS_VS_SPECIFIC_ALIGNMENT: return ItemPropertyACBonusVsSAlign(nSubTypeValue, nCostTableValue);
|
||
case ITEM_PROPERTY_ENHANCEMENT_BONUS: return ItemPropertyEnhancementBonus(nCostTableValue);
|
||
case ITEM_PROPERTY_ENHANCEMENT_BONUS_VS_ALIGNMENT_GROUP: return ItemPropertyEnhancementBonusVsAlign(nSubTypeValue, nCostTableValue);
|
||
case ITEM_PROPERTY_ENHANCEMENT_BONUS_VS_RACIAL_GROUP: return ItemPropertyEnhancementBonusVsRace(nSubTypeValue, nCostTableValue);
|
||
case ITEM_PROPERTY_ENHANCEMENT_BONUS_VS_SPECIFIC_ALIGNEMENT: return ItemPropertyEnhancementBonusVsSAlign(nSubTypeValue, nCostTableValue);
|
||
case ITEM_PROPERTY_DECREASED_ENHANCEMENT_MODIFIER: return ItemPropertyEnhancementPenalty(nCostTableValue);
|
||
case ITEM_PROPERTY_BASE_ITEM_WEIGHT_REDUCTION: return ItemPropertyWeightReduction(nCostTableValue);
|
||
case ITEM_PROPERTY_BONUS_FEAT: return ItemPropertyBonusFeat(nSubTypeValue);
|
||
case ITEM_PROPERTY_BONUS_SPELL_SLOT_OF_LEVEL_N: return ItemPropertyBonusLevelSpell(nSubTypeValue, nCostTableValue);
|
||
case ITEM_PROPERTY_CAST_SPELL: return ItemPropertyCastSpell(nSubTypeValue, nCostTableValue);
|
||
case ITEM_PROPERTY_DAMAGE_BONUS: return ItemPropertyDamageBonus(nSubTypeValue, nCostTableValue);
|
||
case ITEM_PROPERTY_DAMAGE_BONUS_VS_ALIGNMENT_GROUP: return ItemPropertyDamageBonusVsAlign(nSubTypeValue, nParam1Value, nCostTableValue);
|
||
case ITEM_PROPERTY_DAMAGE_BONUS_VS_RACIAL_GROUP: return ItemPropertyDamageBonusVsRace(nSubTypeValue, nParam1Value, nCostTableValue);
|
||
case ITEM_PROPERTY_DAMAGE_BONUS_VS_SPECIFIC_ALIGNMENT: return ItemPropertyDamageBonusVsSAlign(nSubTypeValue, nCostTableValue, nParam1Value);
|
||
case ITEM_PROPERTY_IMMUNITY_DAMAGE_TYPE: return ItemPropertyDamageImmunity(nSubTypeValue, nCostTableValue);
|
||
case ITEM_PROPERTY_DECREASED_DAMAGE: return ItemPropertyDamagePenalty(nCostTableValue);
|
||
case ITEM_PROPERTY_DAMAGE_REDUCTION: return ItemPropertyDamageReduction(nSubTypeValue, nCostTableValue);
|
||
case ITEM_PROPERTY_DAMAGE_RESISTANCE: return ItemPropertyDamageResistance(nSubTypeValue, nCostTableValue);
|
||
case ITEM_PROPERTY_DAMAGE_VULNERABILITY: return ItemPropertyDamageVulnerability(nSubTypeValue, nCostTableValue);
|
||
case ITEM_PROPERTY_DARKVISION: return ItemPropertyDarkvision();
|
||
case ITEM_PROPERTY_DECREASED_ABILITY_SCORE: return ItemPropertyDecreaseAbility(nSubTypeValue, nCostTableValue);
|
||
case ITEM_PROPERTY_DECREASED_AC: return ItemPropertyDecreaseAC(nSubTypeValue, nCostTableValue);
|
||
case ITEM_PROPERTY_DECREASED_SKILL_MODIFIER: return ItemPropertyDecreaseSkill(nSubTypeValue, nCostTableValue);
|
||
case ITEM_PROPERTY_ENHANCED_CONTAINER_REDUCED_WEIGHT: return ItemPropertyContainerReducedWeight(nCostTableValue);
|
||
case ITEM_PROPERTY_EXTRA_MELEE_DAMAGE_TYPE: return ItemPropertyExtraMeleeDamageType(nSubTypeValue);
|
||
case ITEM_PROPERTY_EXTRA_RANGED_DAMAGE_TYPE: return ItemPropertyExtraRangeDamageType(nSubTypeValue);
|
||
case ITEM_PROPERTY_HASTE: return ItemPropertyHaste();
|
||
case ITEM_PROPERTY_HOLY_AVENGER: return ItemPropertyHolyAvenger();
|
||
case ITEM_PROPERTY_IMMUNITY_MISCELLANEOUS: return ItemPropertyImmunityMisc(nSubTypeValue);
|
||
case ITEM_PROPERTY_IMPROVED_EVASION: return ItemPropertyImprovedEvasion();
|
||
case ITEM_PROPERTY_SPELL_RESISTANCE: return ItemPropertyBonusSpellResistance(nCostTableValue);
|
||
case ITEM_PROPERTY_SAVING_THROW_BONUS: return ItemPropertyBonusSavingThrowVsX(nSubTypeValue, nCostTableValue);
|
||
case ITEM_PROPERTY_SAVING_THROW_BONUS_SPECIFIC: return ItemPropertyBonusSavingThrow(nSubTypeValue, nCostTableValue);
|
||
case ITEM_PROPERTY_KEEN: return ItemPropertyKeen();
|
||
case ITEM_PROPERTY_LIGHT: return ItemPropertyLight(nCostTableValue, nParam1Value);
|
||
case ITEM_PROPERTY_MIGHTY: return ItemPropertyMaxRangeStrengthMod(nCostTableValue);
|
||
case ITEM_PROPERTY_NO_DAMAGE: return ItemPropertyNoDamage();
|
||
case ITEM_PROPERTY_ON_HIT_PROPERTIES:{
|
||
if(nParam1Value == -1)
|
||
return ItemPropertyOnHitProps(nSubTypeValue, nCostTableValue);
|
||
else
|
||
return ItemPropertyOnHitProps(nSubTypeValue, nCostTableValue, nParam1Value);}
|
||
case ITEM_PROPERTY_DECREASED_SAVING_THROWS: return ItemPropertyReducedSavingThrowVsX(nSubTypeValue, nCostTableValue);
|
||
case ITEM_PROPERTY_DECREASED_SAVING_THROWS_SPECIFIC: return ItemPropertyReducedSavingThrow(nSubTypeValue, nCostTableValue);
|
||
case ITEM_PROPERTY_REGENERATION: return ItemPropertyRegeneration(nCostTableValue);
|
||
case ITEM_PROPERTY_SKILL_BONUS: return ItemPropertySkillBonus(nSubTypeValue, nCostTableValue);
|
||
case ITEM_PROPERTY_IMMUNITY_SPECIFIC_SPELL: return ItemPropertySpellImmunitySpecific(nCostTableValue);
|
||
case ITEM_PROPERTY_IMMUNITY_SPELL_SCHOOL: return ItemPropertySpellImmunitySchool(nSubTypeValue);
|
||
case ITEM_PROPERTY_THIEVES_TOOLS: return ItemPropertyThievesTools(nCostTableValue);
|
||
case ITEM_PROPERTY_ATTACK_BONUS: return ItemPropertyAttackBonus(nCostTableValue);
|
||
case ITEM_PROPERTY_ATTACK_BONUS_VS_ALIGNMENT_GROUP: return ItemPropertyAttackBonusVsAlign(nSubTypeValue, nCostTableValue);
|
||
case ITEM_PROPERTY_ATTACK_BONUS_VS_RACIAL_GROUP: return ItemPropertyAttackBonusVsRace(nSubTypeValue, nCostTableValue);
|
||
case ITEM_PROPERTY_ATTACK_BONUS_VS_SPECIFIC_ALIGNMENT: return ItemPropertyAttackBonusVsSAlign(nSubTypeValue, nCostTableValue);
|
||
case ITEM_PROPERTY_DECREASED_ATTACK_MODIFIER: return ItemPropertyAttackPenalty(nCostTableValue);
|
||
//IP_CONST_UNLIMITEDAMMO_* is costtablevalue, not subtype
|
||
case ITEM_PROPERTY_UNLIMITED_AMMUNITION: return ItemPropertyUnlimitedAmmo(nCostTableValue);
|
||
case ITEM_PROPERTY_USE_LIMITATION_ALIGNMENT_GROUP: return ItemPropertyLimitUseByAlign(nSubTypeValue);
|
||
case ITEM_PROPERTY_USE_LIMITATION_CLASS: return ItemPropertyLimitUseByClass(nSubTypeValue);
|
||
case ITEM_PROPERTY_USE_LIMITATION_RACIAL_TYPE: return ItemPropertyLimitUseByRace(nSubTypeValue);
|
||
case ITEM_PROPERTY_USE_LIMITATION_SPECIFIC_ALIGNMENT: return ItemPropertyLimitUseBySAlign(nSubTypeValue);
|
||
case ITEM_PROPERTY_REGENERATION_VAMPIRIC: return ItemPropertyVampiricRegeneration(nCostTableValue);
|
||
case ITEM_PROPERTY_TRAP: return ItemPropertyTrap(nSubTypeValue, nCostTableValue);
|
||
case ITEM_PROPERTY_TRUE_SEEING: return ItemPropertyTrueSeeing();
|
||
case ITEM_PROPERTY_ON_MONSTER_HIT: return ItemPropertyOnMonsterHitProperties(nSubTypeValue);
|
||
case ITEM_PROPERTY_TURN_RESISTANCE: return ItemPropertyTurnResistance(nCostTableValue);
|
||
case ITEM_PROPERTY_MASSIVE_CRITICALS: return ItemPropertyMassiveCritical(nCostTableValue);
|
||
case ITEM_PROPERTY_FREEDOM_OF_MOVEMENT: return ItemPropertyFreeAction();
|
||
case ITEM_PROPERTY_MONSTER_DAMAGE: return ItemPropertyMonsterDamage(nCostTableValue);
|
||
case ITEM_PROPERTY_IMMUNITY_SPELLS_BY_LEVEL: return ItemPropertyImmunityToSpellLevel(nCostTableValue);
|
||
case ITEM_PROPERTY_SPECIAL_WALK: return ItemPropertySpecialWalk(nSubTypeValue);
|
||
case ITEM_PROPERTY_HEALERS_KIT: return ItemPropertyHealersKit(nCostTableValue);
|
||
case ITEM_PROPERTY_WEIGHT_INCREASE: return ItemPropertyWeightIncrease(nParam1Value);
|
||
case ITEM_PROPERTY_ONHITCASTSPELL: return ItemPropertyOnHitCastSpell(nSubTypeValue, nCostTableValue);
|
||
case ITEM_PROPERTY_VISUALEFFECT: return ItemPropertyVisualEffect(nSubTypeValue);
|
||
case ITEM_PROPERTY_ARCANE_SPELL_FAILURE: return ItemPropertyArcaneSpellFailure(nCostTableValue);
|
||
case ITEM_PROPERTY_USE_LIMITATION_ABILITY_SCORE: return ItemPropertyLimitUseByAbility(nSubTypeValue, nCostTableValue);
|
||
case ITEM_PROPERTY_USE_LIMITATION_SKILL_RANKS: return ItemPropertyLimitUseBySkill(nSubTypeValue, nCostTableValue);
|
||
case ITEM_PROPERTY_USE_LIMITATION_SPELL_LEVEL: return ItemPropertyLimitUseBySpellcasting(nCostTableValue);
|
||
case ITEM_PROPERTY_USE_LIMITATION_ARCANE_SPELL_LEVEL: return ItemPropertyLimitUseByArcaneSpellcasting(nCostTableValue);
|
||
case ITEM_PROPERTY_USE_LIMITATION_DIVINE_SPELL_LEVEL: return ItemPropertyLimitUseByDivineSpellcasting(nCostTableValue);
|
||
case ITEM_PROPERTY_USE_LIMITATION_SNEAK_ATTACK: return ItemPropertyLimitUseBySneakAttackDice(nCostTableValue);
|
||
case ITEM_PROPERTY_USE_LIMITATION_GENDER:
|
||
{ //no Use Limitation: Gender function entry
|
||
//return ItemPropertyAbilityBonus(nSubTypeValue);
|
||
break;
|
||
}
|
||
case ITEM_PROPERTY_SPEED_INCREASE:
|
||
{ //no Speed Increase function entry
|
||
//return ItemPropertyAbilityBonus(nCostTableValue);
|
||
break;
|
||
}
|
||
case ITEM_PROPERTY_SPEED_DECREASE:
|
||
//no Speed Decrease function entry
|
||
//return ItemPropertyAbilityBonus(nCostTableValue);
|
||
case ITEM_PROPERTY_AREA_OF_EFFECT: return ItemPropertyAreaOfEffect(nSubTypeValue, nCostTableValue);
|
||
//requires spellid passed as subtype instead of actual subtype
|
||
case ITEM_PROPERTY_CAST_SPELL_CASTER_LEVEL: return ItemPropertyCastSpellCasterLevel(nSubTypeValue, nCostTableValue);
|
||
//requires spellid passed as subtype instead of actual subtype
|
||
case ITEM_PROPERTY_CAST_SPELL_METAMAGIC: return ItemPropertyCastSpellMetamagic(nSubTypeValue, nCostTableValue);
|
||
//requires spellid passed as subtype instead of actual subtype
|
||
case ITEM_PROPERTY_CAST_SPELL_DC: return ItemPropertyCastSpellDC(nSubTypeValue, nCostTableValue);
|
||
case ITEM_PROPERTY_PNP_HOLY_AVENGER: return ItemPropertyPnPHolyAvenger();
|
||
case ITEM_PROPERTY_WIZARDRY: return ItemPropertyWizardry(nCostTableValue);
|
||
case ITEM_PROPERTY_DIVINITY: return ItemPropertyDivinity(nCostTableValue);
|
||
case ITEM_PROPERTY_MATERIAL: return ItemPropertyMaterial(nCostTableValue);
|
||
case ITEM_PROPERTY_QUALITY: return ItemPropertyQuality(nCostTableValue);
|
||
case ITEM_PROPERTY_ADDITIONAL: return ItemPropertyAdditional(nCostTableValue);
|
||
case ITEM_PROPERTY_ECHOBLADE: return ItemPropertyEchoblade();
|
||
|
||
|
||
//ROOM FOR MORE - 89 so far, need increase/decrease cost
|
||
/*
|
||
case ITEM_PROPERTY_ABILITY_BONUS:
|
||
{
|
||
return ItemPropertyAbilityBonus(nSubTypeValue, nCostTableValue);
|
||
break;
|
||
}
|
||
*/
|
||
}
|
||
return ip;
|
||
}
|
||
|
||
struct ipstruct GetIpStructFromString(string sIp)
|
||
{
|
||
struct ipstruct iptemp;
|
||
//initialise variables
|
||
string sTemp = sIp;
|
||
string sSub;
|
||
int nLength = GetStringLength(sTemp);
|
||
int nPosition;
|
||
int nTemp;
|
||
int i;
|
||
|
||
for(i = 0; i < 4; i++)
|
||
{
|
||
nPosition = FindSubString(sTemp, "_");
|
||
sSub = (nPosition == -1) ? sTemp : GetStringLeft(sTemp, nPosition);
|
||
nLength -= (nPosition + 1);
|
||
if(sSub == "*")
|
||
nTemp = -1;
|
||
else
|
||
nTemp = StringToInt(sSub);
|
||
switch(i)
|
||
{
|
||
case 0: iptemp.type = nTemp; break;
|
||
case 1: iptemp.subtype = nTemp; break;
|
||
case 2: iptemp.costtablevalue = nTemp; break;
|
||
case 3: iptemp.param1value = nTemp; break;
|
||
}
|
||
sTemp = GetSubString(sTemp, nPosition + 1, nLength);
|
||
}
|
||
return iptemp;
|
||
}
|
||
|
||
string PRCGetItemAppearanceString(object oPC, object oItem)
|
||
{
|
||
int nBase = GetBaseItemType(oItem);
|
||
int nModelType = StringToInt(Get2DACache("baseitems", "ModelType", nBase));
|
||
//PRCSetAppearanceArray(oPC, sString);
|
||
string sReturn = "";
|
||
|
||
switch(nModelType)
|
||
{
|
||
case 0:
|
||
{ //simple model, 1 value
|
||
sReturn = IntToString(GetItemAppearance(oItem, ITEM_APPR_TYPE_SIMPLE_MODEL, 0));
|
||
break;
|
||
}
|
||
case 1:
|
||
{ //helmet, cloak, model + 6 colours, 7 values
|
||
sReturn = IntToString(GetItemAppearance(oItem, ITEM_APPR_TYPE_SIMPLE_MODEL, 0)) + "-" +
|
||
IntToString(GetItemAppearance(oItem, ITEM_APPR_TYPE_ARMOR_COLOR, ITEM_APPR_ARMOR_COLOR_LEATHER1)) + "-" +
|
||
IntToString(GetItemAppearance(oItem, ITEM_APPR_TYPE_ARMOR_COLOR, ITEM_APPR_ARMOR_COLOR_LEATHER2)) + "-" +
|
||
IntToString(GetItemAppearance(oItem, ITEM_APPR_TYPE_ARMOR_COLOR, ITEM_APPR_ARMOR_COLOR_CLOTH1)) + "-" +
|
||
IntToString(GetItemAppearance(oItem, ITEM_APPR_TYPE_ARMOR_COLOR, ITEM_APPR_ARMOR_COLOR_CLOTH2)) + "-" +
|
||
IntToString(GetItemAppearance(oItem, ITEM_APPR_TYPE_ARMOR_COLOR, ITEM_APPR_ARMOR_COLOR_METAL1)) + "-" +
|
||
IntToString(GetItemAppearance(oItem, ITEM_APPR_TYPE_ARMOR_COLOR, ITEM_APPR_ARMOR_COLOR_METAL2))
|
||
;
|
||
break;
|
||
}
|
||
case 2:
|
||
{ //weapon, 3 sections + 3 colours, 6 values
|
||
sReturn = IntToString(GetItemAppearance(oItem, ITEM_APPR_TYPE_WEAPON_COLOR, ITEM_APPR_WEAPON_COLOR_BOTTOM)) + "-" +
|
||
IntToString(GetItemAppearance(oItem, ITEM_APPR_TYPE_WEAPON_COLOR, ITEM_APPR_WEAPON_COLOR_MIDDLE)) + "-" +
|
||
IntToString(GetItemAppearance(oItem, ITEM_APPR_TYPE_WEAPON_COLOR, ITEM_APPR_WEAPON_COLOR_TOP)) + "-" +
|
||
IntToString(GetItemAppearance(oItem, ITEM_APPR_TYPE_WEAPON_MODEL, ITEM_APPR_WEAPON_MODEL_BOTTOM)) + "-" +
|
||
IntToString(GetItemAppearance(oItem, ITEM_APPR_TYPE_WEAPON_MODEL, ITEM_APPR_WEAPON_MODEL_MIDDLE)) + "-" +
|
||
IntToString(GetItemAppearance(oItem, ITEM_APPR_TYPE_WEAPON_MODEL, ITEM_APPR_WEAPON_MODEL_TOP))
|
||
;
|
||
break;
|
||
}
|
||
case 3:
|
||
{ //armour, 19 sections + 6 colours, 25 values
|
||
sReturn = IntToString(GetItemAppearance(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, ITEM_APPR_ARMOR_MODEL_RFOOT)) + "-" +
|
||
IntToString(GetItemAppearance(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, ITEM_APPR_ARMOR_MODEL_LFOOT)) + "-" +
|
||
IntToString(GetItemAppearance(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, ITEM_APPR_ARMOR_MODEL_RSHIN)) + "-" +
|
||
IntToString(GetItemAppearance(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, ITEM_APPR_ARMOR_MODEL_LSHIN)) + "-" +
|
||
IntToString(GetItemAppearance(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, ITEM_APPR_ARMOR_MODEL_LTHIGH)) + "-" +
|
||
IntToString(GetItemAppearance(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, ITEM_APPR_ARMOR_MODEL_RTHIGH)) + "-" +
|
||
IntToString(GetItemAppearance(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, ITEM_APPR_ARMOR_MODEL_PELVIS)) + "-" +
|
||
IntToString(GetItemAppearance(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, ITEM_APPR_ARMOR_MODEL_TORSO)) + "-" +
|
||
IntToString(GetItemAppearance(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, ITEM_APPR_ARMOR_MODEL_BELT)) + "-" +
|
||
IntToString(GetItemAppearance(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, ITEM_APPR_ARMOR_MODEL_NECK)) + "-" +
|
||
IntToString(GetItemAppearance(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, ITEM_APPR_ARMOR_MODEL_RFOREARM)) + "-" +
|
||
IntToString(GetItemAppearance(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, ITEM_APPR_ARMOR_MODEL_LFOREARM)) + "-" +
|
||
IntToString(GetItemAppearance(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, ITEM_APPR_ARMOR_MODEL_RBICEP)) + "-" +
|
||
IntToString(GetItemAppearance(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, ITEM_APPR_ARMOR_MODEL_LBICEP)) + "-" +
|
||
IntToString(GetItemAppearance(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, ITEM_APPR_ARMOR_MODEL_RSHOULDER)) + "-" +
|
||
IntToString(GetItemAppearance(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, ITEM_APPR_ARMOR_MODEL_LSHOULDER)) + "-" +
|
||
IntToString(GetItemAppearance(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, ITEM_APPR_ARMOR_MODEL_RHAND)) + "-" +
|
||
IntToString(GetItemAppearance(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, ITEM_APPR_ARMOR_MODEL_LHAND)) + "-" +
|
||
IntToString(GetItemAppearance(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, ITEM_APPR_ARMOR_MODEL_ROBE)) + "-" +
|
||
IntToString(GetItemAppearance(oItem, ITEM_APPR_TYPE_ARMOR_COLOR, ITEM_APPR_ARMOR_COLOR_LEATHER1)) + "-" +
|
||
IntToString(GetItemAppearance(oItem, ITEM_APPR_TYPE_ARMOR_COLOR, ITEM_APPR_ARMOR_COLOR_LEATHER2)) + "-" +
|
||
IntToString(GetItemAppearance(oItem, ITEM_APPR_TYPE_ARMOR_COLOR, ITEM_APPR_ARMOR_COLOR_CLOTH1)) + "-" +
|
||
IntToString(GetItemAppearance(oItem, ITEM_APPR_TYPE_ARMOR_COLOR, ITEM_APPR_ARMOR_COLOR_CLOTH2)) + "-" +
|
||
IntToString(GetItemAppearance(oItem, ITEM_APPR_TYPE_ARMOR_COLOR, ITEM_APPR_ARMOR_COLOR_METAL1)) + "-" +
|
||
IntToString(GetItemAppearance(oItem, ITEM_APPR_TYPE_ARMOR_COLOR, ITEM_APPR_ARMOR_COLOR_METAL2))
|
||
;
|
||
break;
|
||
}
|
||
}
|
||
return sReturn;
|
||
}
|
||
|
||
//reads a string with ints delimited by "-", then set the appearance
|
||
// of an item accordingly
|
||
object PRCSetItemAppearance(object oPC, object oItem, string sArray, string sName = PRC_CRAFT_APPEARANCE_ARRAY)
|
||
{
|
||
//initialise array
|
||
if(array_exists(oPC, sName))
|
||
array_delete(oPC, sName);
|
||
array_create(oPC, sName);
|
||
//initialise variables
|
||
string sTemp = sArray;
|
||
string sSub;
|
||
int nLength = GetStringLength(sTemp);
|
||
int nPosition;
|
||
int nTemp;
|
||
int nIndex = 0;
|
||
object oChest = GetTempCraftChest();
|
||
object oTemp;
|
||
while(nLength > 0)
|
||
{
|
||
nPosition = FindSubString(sTemp, "-");
|
||
if(nPosition == -1)
|
||
{ //last value
|
||
sSub = sTemp;
|
||
nLength = 0;
|
||
}
|
||
else
|
||
{
|
||
sSub = GetStringLeft(sTemp, nPosition);
|
||
nLength -= (nPosition + 1);
|
||
}
|
||
if(sSub == "*")
|
||
nTemp = -1;
|
||
else
|
||
nTemp = StringToInt(sSub);
|
||
array_set_int(oPC, sName, nIndex, nTemp);
|
||
nIndex++;
|
||
if(nPosition == -1) break; //last value
|
||
if(nLength < 0)
|
||
{
|
||
if(DEBUG) DoDebug("PRCSetItemAppearanceString: Error processing string");
|
||
return oItem; //something went wrong
|
||
}
|
||
sTemp = GetSubString(sTemp, nPosition + 1, nLength);
|
||
}
|
||
int nBase = GetBaseItemType(oItem);
|
||
int nModelType = StringToInt(Get2DACache("baseitems", "ModelType", nBase));
|
||
DestroyObject(oItem);
|
||
oItem = CopyItem(oItem, oChest, TRUE);
|
||
switch(nModelType)
|
||
{
|
||
case 0:
|
||
{ //simple model, 1 value
|
||
nTemp = array_get_int(oPC, sName, 0);
|
||
if(nTemp != -1)
|
||
{
|
||
DestroyObject(oItem);
|
||
oItem = CopyItemAndModify(oItem, ITEM_APPR_TYPE_SIMPLE_MODEL, 0, nTemp, TRUE);
|
||
}
|
||
break;
|
||
}
|
||
case 1:
|
||
{ //helmet, cloak, model + 6 colours, 7 values, cloak model change doesn't work in 1.68
|
||
nTemp = array_get_int(oPC, sName, 0);
|
||
if(nTemp != -1)
|
||
{
|
||
DestroyObject(oItem);
|
||
oItem = CopyItemAndModify(oItem, ITEM_APPR_TYPE_SIMPLE_MODEL, 0, nTemp, TRUE);
|
||
}
|
||
nTemp = array_get_int(oPC, sName, 1);
|
||
if(nTemp != -1)
|
||
{
|
||
DestroyObject(oItem);
|
||
oItem = CopyItemAndModify(oItem, ITEM_APPR_TYPE_ARMOR_COLOR, ITEM_APPR_ARMOR_COLOR_LEATHER1, nTemp, TRUE);
|
||
}
|
||
nTemp = array_get_int(oPC, sName, 2);
|
||
if(nTemp != -1)
|
||
{
|
||
DestroyObject(oItem);
|
||
oItem = CopyItemAndModify(oItem, ITEM_APPR_TYPE_ARMOR_COLOR, ITEM_APPR_ARMOR_COLOR_LEATHER2, nTemp, TRUE);
|
||
}
|
||
nTemp = array_get_int(oPC, sName, 3);
|
||
if(nTemp != -1)
|
||
{
|
||
DestroyObject(oItem);
|
||
oItem = CopyItemAndModify(oItem, ITEM_APPR_TYPE_ARMOR_COLOR, ITEM_APPR_ARMOR_COLOR_CLOTH1, nTemp, TRUE);
|
||
}
|
||
nTemp = array_get_int(oPC, sName, 4);
|
||
if(nTemp != -1)
|
||
{
|
||
DestroyObject(oItem);
|
||
oItem = CopyItemAndModify(oItem, ITEM_APPR_TYPE_ARMOR_COLOR, ITEM_APPR_ARMOR_COLOR_CLOTH2, nTemp, TRUE);
|
||
}
|
||
nTemp = array_get_int(oPC, sName, 5);
|
||
if(nTemp != -1)
|
||
{
|
||
DestroyObject(oItem);
|
||
oItem = CopyItemAndModify(oItem, ITEM_APPR_TYPE_ARMOR_COLOR, ITEM_APPR_ARMOR_COLOR_METAL1, nTemp, TRUE);
|
||
}
|
||
nTemp = array_get_int(oPC, sName, 6);
|
||
if(nTemp != -1)
|
||
{
|
||
DestroyObject(oItem);
|
||
oItem = CopyItemAndModify(oItem, ITEM_APPR_TYPE_ARMOR_COLOR, ITEM_APPR_ARMOR_COLOR_METAL2, nTemp, TRUE);
|
||
}
|
||
break;
|
||
}
|
||
case 2:
|
||
{ //weapon, 3 sections + 3 colours, 6 values
|
||
nTemp = array_get_int(oPC, sName, 0);
|
||
if(nTemp != -1)
|
||
{
|
||
DestroyObject(oItem);
|
||
oItem = CopyItemAndModify(oItem, ITEM_APPR_TYPE_WEAPON_COLOR, ITEM_APPR_WEAPON_COLOR_BOTTOM, nTemp, TRUE);
|
||
}
|
||
nTemp = array_get_int(oPC, sName, 1);
|
||
if(nTemp != -1)
|
||
{
|
||
DestroyObject(oItem);
|
||
oItem = CopyItemAndModify(oItem, ITEM_APPR_TYPE_WEAPON_COLOR, ITEM_APPR_WEAPON_COLOR_MIDDLE, nTemp, TRUE);
|
||
}
|
||
nTemp = array_get_int(oPC, sName, 2);
|
||
if(nTemp != -1)
|
||
{
|
||
DestroyObject(oItem);
|
||
oItem = CopyItemAndModify(oItem, ITEM_APPR_TYPE_WEAPON_COLOR, ITEM_APPR_WEAPON_COLOR_TOP, nTemp, TRUE);
|
||
}
|
||
nTemp = array_get_int(oPC, sName, 3);
|
||
if(nTemp != -1)
|
||
{
|
||
DestroyObject(oItem);
|
||
oItem = CopyItemAndModify(oItem, ITEM_APPR_TYPE_WEAPON_MODEL, ITEM_APPR_WEAPON_MODEL_BOTTOM, nTemp, TRUE);
|
||
}
|
||
nTemp = array_get_int(oPC, sName, 4);
|
||
if(nTemp != -1)
|
||
{
|
||
DestroyObject(oItem);
|
||
oItem = CopyItemAndModify(oItem, ITEM_APPR_TYPE_WEAPON_MODEL, ITEM_APPR_WEAPON_MODEL_MIDDLE, nTemp, TRUE);
|
||
}
|
||
nTemp = array_get_int(oPC, sName, 5);
|
||
if(nTemp != -1)
|
||
{
|
||
DestroyObject(oItem);
|
||
oItem = CopyItemAndModify(oItem, ITEM_APPR_TYPE_WEAPON_MODEL, ITEM_APPR_WEAPON_MODEL_TOP, nTemp, TRUE);
|
||
}
|
||
break;
|
||
}
|
||
case 3:
|
||
{ //armour, 19 sections + 6 colours, 25 values
|
||
nTemp = array_get_int(oPC, sName, 0);
|
||
if(nTemp != -1)
|
||
{
|
||
DestroyObject(oItem);
|
||
oItem = CopyItemAndModify(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, ITEM_APPR_ARMOR_MODEL_RFOOT, nTemp, TRUE);
|
||
}
|
||
nTemp = array_get_int(oPC, sName, 1);
|
||
if(nTemp != -1)
|
||
{
|
||
DestroyObject(oItem);
|
||
oItem = CopyItemAndModify(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, ITEM_APPR_ARMOR_MODEL_LFOOT, nTemp, TRUE);
|
||
}
|
||
nTemp = array_get_int(oPC, sName, 2);
|
||
if(nTemp != -1)
|
||
{
|
||
DestroyObject(oItem);
|
||
oItem = CopyItemAndModify(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, ITEM_APPR_ARMOR_MODEL_RSHIN, nTemp, TRUE);
|
||
}
|
||
nTemp = array_get_int(oPC, sName, 3);
|
||
if(nTemp != -1)
|
||
{
|
||
DestroyObject(oItem);
|
||
oItem = CopyItemAndModify(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, ITEM_APPR_ARMOR_MODEL_LSHIN, nTemp, TRUE);
|
||
}
|
||
nTemp = array_get_int(oPC, sName, 4);
|
||
if(nTemp != -1)
|
||
{
|
||
DestroyObject(oItem);
|
||
oItem = CopyItemAndModify(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, ITEM_APPR_ARMOR_MODEL_LTHIGH, nTemp, TRUE);
|
||
}
|
||
nTemp = array_get_int(oPC, sName, 5);
|
||
if(nTemp != -1)
|
||
{
|
||
DestroyObject(oItem);
|
||
oItem = CopyItemAndModify(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, ITEM_APPR_ARMOR_MODEL_RTHIGH, nTemp, TRUE);
|
||
}
|
||
nTemp = array_get_int(oPC, sName, 6);
|
||
if(nTemp != -1)
|
||
{
|
||
DestroyObject(oItem);
|
||
oItem = CopyItemAndModify(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, ITEM_APPR_ARMOR_MODEL_PELVIS, nTemp, TRUE);
|
||
}
|
||
nTemp = array_get_int(oPC, sName, 7);
|
||
if(nTemp != -1)
|
||
{
|
||
if(FloatToInt(StringToFloat(Get2DACache("parts_chest", "ACBONUS", GetItemAppearance(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, ITEM_APPR_ARMOR_MODEL_TORSO)))) == FloatToInt(StringToFloat(Get2DACache("parts_chest", "ACBONUS", nTemp))))
|
||
{ //won't allow change to armour with different AC
|
||
DestroyObject(oItem);
|
||
oItem = CopyItemAndModify(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, ITEM_APPR_ARMOR_MODEL_TORSO, nTemp, TRUE);
|
||
}
|
||
else
|
||
{
|
||
SendMessageToPC(oPC, "This torso appearance has a different AC value to the current appearance, aborting torso change.");
|
||
}
|
||
}
|
||
nTemp = array_get_int(oPC, sName, 8);
|
||
if(nTemp != -1)
|
||
{
|
||
DestroyObject(oItem);
|
||
oItem = CopyItemAndModify(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, ITEM_APPR_ARMOR_MODEL_BELT, nTemp, TRUE);
|
||
}
|
||
nTemp = array_get_int(oPC, sName, 9);
|
||
if(nTemp != -1)
|
||
{
|
||
DestroyObject(oItem);
|
||
oItem = CopyItemAndModify(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, ITEM_APPR_ARMOR_MODEL_NECK, nTemp, TRUE);
|
||
}
|
||
nTemp = array_get_int(oPC, sName, 10);
|
||
if(nTemp != -1)
|
||
{
|
||
DestroyObject(oItem);
|
||
oItem = CopyItemAndModify(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, ITEM_APPR_ARMOR_MODEL_RFOREARM, nTemp, TRUE);
|
||
}
|
||
nTemp = array_get_int(oPC, sName, 11);
|
||
if(nTemp != -1)
|
||
{
|
||
DestroyObject(oItem);
|
||
oItem = CopyItemAndModify(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, ITEM_APPR_ARMOR_MODEL_LFOREARM, nTemp, TRUE);
|
||
}
|
||
nTemp = array_get_int(oPC, sName, 12);
|
||
if(nTemp != -1)
|
||
{
|
||
DestroyObject(oItem);
|
||
oItem = CopyItemAndModify(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, ITEM_APPR_ARMOR_MODEL_RBICEP, nTemp, TRUE);
|
||
}
|
||
nTemp = array_get_int(oPC, sName, 13);
|
||
if(nTemp != -1)
|
||
{
|
||
DestroyObject(oItem);
|
||
oItem = CopyItemAndModify(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, ITEM_APPR_ARMOR_MODEL_LBICEP, nTemp, TRUE);
|
||
}
|
||
nTemp = array_get_int(oPC, sName, 14);
|
||
if(nTemp != -1)
|
||
{
|
||
DestroyObject(oItem);
|
||
oItem = CopyItemAndModify(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, ITEM_APPR_ARMOR_MODEL_RSHOULDER, nTemp, TRUE);
|
||
}
|
||
nTemp = array_get_int(oPC, sName, 15);
|
||
if(nTemp != -1)
|
||
{
|
||
DestroyObject(oItem);
|
||
oItem = CopyItemAndModify(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, ITEM_APPR_ARMOR_MODEL_LSHOULDER, nTemp, TRUE);
|
||
}
|
||
nTemp = array_get_int(oPC, sName, 16);
|
||
if(nTemp != -1)
|
||
{
|
||
DestroyObject(oItem);
|
||
oItem = CopyItemAndModify(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, ITEM_APPR_ARMOR_MODEL_RHAND, nTemp, TRUE);
|
||
}
|
||
nTemp = array_get_int(oPC, sName, 17);
|
||
if(nTemp != -1)
|
||
{
|
||
DestroyObject(oItem);
|
||
oItem = CopyItemAndModify(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, ITEM_APPR_ARMOR_MODEL_LHAND, nTemp, TRUE);
|
||
}
|
||
nTemp = array_get_int(oPC, sName, 18);
|
||
if(nTemp != -1)
|
||
{
|
||
DestroyObject(oItem);
|
||
oItem = CopyItemAndModify(oItem, ITEM_APPR_TYPE_ARMOR_MODEL, ITEM_APPR_ARMOR_MODEL_ROBE, nTemp, TRUE);
|
||
}
|
||
nTemp = array_get_int(oPC, sName, 19);
|
||
if(nTemp != -1)
|
||
{
|
||
DestroyObject(oItem);
|
||
oItem = CopyItemAndModify(oItem, ITEM_APPR_TYPE_ARMOR_COLOR, ITEM_APPR_ARMOR_COLOR_LEATHER1, nTemp, TRUE);
|
||
}
|
||
nTemp = array_get_int(oPC, sName, 20);
|
||
if(nTemp != -1)
|
||
{
|
||
DestroyObject(oItem);
|
||
oItem = CopyItemAndModify(oItem, ITEM_APPR_TYPE_ARMOR_COLOR, ITEM_APPR_ARMOR_COLOR_LEATHER2, nTemp, TRUE);
|
||
}
|
||
nTemp = array_get_int(oPC, sName, 21);
|
||
if(nTemp != -1)
|
||
{
|
||
DestroyObject(oItem);
|
||
oItem = CopyItemAndModify(oItem, ITEM_APPR_TYPE_ARMOR_COLOR, ITEM_APPR_ARMOR_COLOR_CLOTH1, nTemp, TRUE);
|
||
}
|
||
nTemp = array_get_int(oPC, sName, 22);
|
||
if(nTemp != -1)
|
||
{
|
||
DestroyObject(oItem);
|
||
oItem = CopyItemAndModify(oItem, ITEM_APPR_TYPE_ARMOR_COLOR, ITEM_APPR_ARMOR_COLOR_CLOTH2, nTemp, TRUE);
|
||
}
|
||
nTemp = array_get_int(oPC, sName, 23);
|
||
if(nTemp != -1)
|
||
{
|
||
DestroyObject(oItem);
|
||
oItem = CopyItemAndModify(oItem, ITEM_APPR_TYPE_ARMOR_COLOR, ITEM_APPR_ARMOR_COLOR_METAL1, nTemp, TRUE);
|
||
}
|
||
nTemp = array_get_int(oPC, sName, 24);
|
||
if(nTemp != -1)
|
||
{
|
||
DestroyObject(oItem);
|
||
oItem = CopyItemAndModify(oItem, ITEM_APPR_TYPE_ARMOR_COLOR, ITEM_APPR_ARMOR_COLOR_METAL2, nTemp, TRUE);
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
DestroyObject(oItem);
|
||
oItem = CopyItem(oItem, oPC, TRUE);
|
||
return oItem;
|
||
}
|
||
/*
|
||
int ITEM_APPR_TYPE_SIMPLE_MODEL = 0;
|
||
int ITEM_APPR_TYPE_WEAPON_COLOR = 1;
|
||
int ITEM_APPR_TYPE_WEAPON_MODEL = 2;
|
||
int ITEM_APPR_TYPE_ARMOR_MODEL = 3;
|
||
int ITEM_APPR_TYPE_ARMOR_COLOR = 4;
|
||
int ITEM_APPR_NUM_TYPES = 5;
|
||
|
||
int ITEM_APPR_ARMOR_COLOR_LEATHER1 = 0;
|
||
int ITEM_APPR_ARMOR_COLOR_LEATHER2 = 1;
|
||
int ITEM_APPR_ARMOR_COLOR_CLOTH1 = 2;
|
||
int ITEM_APPR_ARMOR_COLOR_CLOTH2 = 3;
|
||
int ITEM_APPR_ARMOR_COLOR_METAL1 = 4;
|
||
int ITEM_APPR_ARMOR_COLOR_METAL2 = 5;
|
||
int ITEM_APPR_ARMOR_NUM_COLORS = 6;
|
||
|
||
int ITEM_APPR_ARMOR_MODEL_RFOOT = 0;
|
||
int ITEM_APPR_ARMOR_MODEL_LFOOT = 1;
|
||
int ITEM_APPR_ARMOR_MODEL_RSHIN = 2;
|
||
int ITEM_APPR_ARMOR_MODEL_LSHIN = 3;
|
||
int ITEM_APPR_ARMOR_MODEL_LTHIGH = 4;
|
||
int ITEM_APPR_ARMOR_MODEL_RTHIGH = 5;
|
||
int ITEM_APPR_ARMOR_MODEL_PELVIS = 6;
|
||
int ITEM_APPR_ARMOR_MODEL_TORSO = 7;
|
||
int ITEM_APPR_ARMOR_MODEL_BELT = 8;
|
||
int ITEM_APPR_ARMOR_MODEL_NECK = 9;
|
||
int ITEM_APPR_ARMOR_MODEL_RFOREARM = 10;
|
||
int ITEM_APPR_ARMOR_MODEL_LFOREARM = 11;
|
||
int ITEM_APPR_ARMOR_MODEL_RBICEP = 12;
|
||
int ITEM_APPR_ARMOR_MODEL_LBICEP = 13;
|
||
int ITEM_APPR_ARMOR_MODEL_RSHOULDER = 14;
|
||
int ITEM_APPR_ARMOR_MODEL_LSHOULDER = 15;
|
||
int ITEM_APPR_ARMOR_MODEL_RHAND = 16;
|
||
int ITEM_APPR_ARMOR_MODEL_LHAND = 17;
|
||
int ITEM_APPR_ARMOR_MODEL_ROBE = 18;
|
||
int ITEM_APPR_ARMOR_NUM_MODELS = 19;
|
||
|
||
int ITEM_APPR_WEAPON_MODEL_BOTTOM = 0;
|
||
int ITEM_APPR_WEAPON_MODEL_MIDDLE = 1;
|
||
int ITEM_APPR_WEAPON_MODEL_TOP = 2;
|
||
|
||
int ITEM_APPR_WEAPON_COLOR_BOTTOM = 0;
|
||
int ITEM_APPR_WEAPON_COLOR_MIDDLE = 1;
|
||
int ITEM_APPR_WEAPON_COLOR_TOP = 2;
|
||
*/
|
||
|
||
// void main () {}
|