6ec137a24e
Updated AMS marker feats. Removed arcane & divine marker feats. Updated Dread Necromancer for epic progression. Updated weapon baseitem models. Updated new weapons for crafting & npc equip. Updated prefix. Updated release archive.
2955 lines
114 KiB
Plaintext
2955 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 = min(1, nACPenalty);
|
||
}
|
||
if(nMaterial & PRC_CRAFT_FLAG_DARKWOOD)
|
||
{
|
||
nBonus = min(2, nACPenalty);
|
||
}
|
||
if(nMaterial & PRC_CRAFT_FLAG_MITHRAL)
|
||
{
|
||
nBonus = min(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 = max(max(max(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 = max(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 = max(max(max(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 = max(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 = max(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_KATAR:
|
||
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_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_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 () {}
|