1116 lines
41 KiB
Plaintext
1116 lines
41 KiB
Plaintext
///////////////////////////////////////////////////////////////////////////////
|
|
// lgs_inc
|
|
// written by: eyesolated
|
|
// written at: July 5, 2004
|
|
//
|
|
// Notes:
|
|
|
|
///////////
|
|
// Includes
|
|
//
|
|
// Needs
|
|
#include "ip_inc"
|
|
//#include "x0_i0_treasure"
|
|
#include "mod_cfg"
|
|
#include "lgs_cfg"
|
|
#include "pat_cfg"
|
|
|
|
///////////////////////
|
|
// Function Declaration
|
|
//
|
|
|
|
// Help
|
|
void lgs_Help();
|
|
|
|
// Clears the inventory of oMonster
|
|
void lgs_ClearInventory(object oMonster);
|
|
|
|
// Creates the specified item on oTarget
|
|
// if iInventorySlot is set to -1, the item won't be equipped
|
|
// These items are named and unidentified if CI_LGS_DROPEQUIPMENT = TRUE,
|
|
// unnamed and identified if CI_LGS_DROPEQUIPMENT = FALSE
|
|
//
|
|
// Setting iMaxWeaponSize to anything but -1 for items that are not weapons
|
|
// will cause NO ITEMS to be found
|
|
object lgs_CreateEquipmentOnTarget(int iMainCategory, int iSubCategory, int iBaseItem, object oTarget, int iInventorySlot, int iLevel, int iMaxWeaponSize = -1);
|
|
|
|
// Creates the specified item on oTarget
|
|
// if iInventorySlot is set to -1, the item won't be equipped
|
|
// These items always are named and unidentified
|
|
//
|
|
// Setting iMaxWeaponSize to anything but -1 for items that are not weapons
|
|
// will cause NO ITEMS to be found
|
|
object lgs_CreateItemOnTarget(int iMainCategory, int iSubCategory, int iBaseItem, object oTarget, int iInventorySlot, int iLevel, int iOverrideMaxMagicLevel = -1, int iForceMagical = FALSE, int iDisallowMagical = FALSE, int iMaxWeaponSize = -1);
|
|
|
|
// Adds nProperty to oItem with a chance based on creature CR if Equipment is
|
|
// set to not drop
|
|
void lgs_AdditionalChance(object oItem, int iLevel, int nProperty, int nPolicy = X2_IP_ADDPROP_POLICY_KEEP_EXISTING);
|
|
|
|
// Equip monster oMonster
|
|
// iAddedDropChance gets added to every DropChance-Check.
|
|
// Set to 100 to ensure every possible item will be created
|
|
// Set to -500 to ensure no item will be created
|
|
void lgs_EquipMonster(object oMonster, int iAddedDropChance = 0);
|
|
|
|
// Create loot for oMonster on oLootContainer according to it's difficulty/CR
|
|
// If oLootContainer isn't a valid object, oMonster will be used as loot container
|
|
//
|
|
// iFixedLootOnly: if this is set to true, the method only checks for fixed loot and
|
|
// ignores it's random ways of generating loot
|
|
// iNumberOfLootItems: sets the number of loot items to generate. If this is set to -1
|
|
// LGS handles the number of loot items.
|
|
//
|
|
// NOTE: if oMonster refers to a placeable, the System looks for a variabla named "LGS_CR" on that placeable to
|
|
// determine difficulty/CR
|
|
void lgs_CreateLoot(object oMonster, object oLootContainer = OBJECT_INVALID, object oLootContainer_Self = OBJECT_INVALID, int iFixedLootOnly = FALSE, int iNumberOfLootItems = -1);
|
|
|
|
////////////////
|
|
// Function Code
|
|
//
|
|
|
|
void lgs_Help()
|
|
{
|
|
}
|
|
|
|
void lgs_ClearInventory(object oMonster)
|
|
{
|
|
int nAmtGold = GetGold(oMonster); //Get any gold from the dead creature
|
|
if(nAmtGold) TakeGoldFromCreature(nAmtGold, oMonster, TRUE);
|
|
|
|
DestroyObject(GetItemInSlot(INVENTORY_SLOT_ARMS, oMonster));
|
|
DestroyObject(GetItemInSlot(INVENTORY_SLOT_ARROWS, oMonster));
|
|
DestroyObject(GetItemInSlot(INVENTORY_SLOT_BELT, oMonster));
|
|
DestroyObject(GetItemInSlot(INVENTORY_SLOT_BOLTS, oMonster));
|
|
DestroyObject(GetItemInSlot(INVENTORY_SLOT_BOOTS, oMonster));
|
|
DestroyObject(GetItemInSlot(INVENTORY_SLOT_BULLETS, oMonster));
|
|
DestroyObject(GetItemInSlot(INVENTORY_SLOT_CARMOUR, oMonster));
|
|
DestroyObject(GetItemInSlot(INVENTORY_SLOT_CHEST, oMonster));
|
|
DestroyObject(GetItemInSlot(INVENTORY_SLOT_CLOAK, oMonster));
|
|
DestroyObject(GetItemInSlot(INVENTORY_SLOT_CWEAPON_B, oMonster));
|
|
DestroyObject(GetItemInSlot(INVENTORY_SLOT_CWEAPON_L, oMonster));
|
|
DestroyObject(GetItemInSlot(INVENTORY_SLOT_CWEAPON_R, oMonster));
|
|
DestroyObject(GetItemInSlot(INVENTORY_SLOT_HEAD, oMonster));
|
|
DestroyObject(GetItemInSlot(INVENTORY_SLOT_LEFTHAND, oMonster));
|
|
DestroyObject(GetItemInSlot(INVENTORY_SLOT_LEFTRING, oMonster));
|
|
DestroyObject(GetItemInSlot(INVENTORY_SLOT_NECK, oMonster));
|
|
DestroyObject(GetItemInSlot(INVENTORY_SLOT_RIGHTHAND, oMonster));
|
|
DestroyObject(GetItemInSlot(INVENTORY_SLOT_RIGHTRING, oMonster));
|
|
|
|
object oLootEQ = GetFirstItemInInventory(oMonster);
|
|
while(GetIsObjectValid(oLootEQ))
|
|
{
|
|
DestroyObject(oLootEQ);
|
|
oLootEQ = GetNextItemInInventory(oMonster);
|
|
}
|
|
}
|
|
|
|
void lgs_EquipItem(object oTarget, object oItem, int iInventorySlot)
|
|
{
|
|
// Get currently equipped item
|
|
object oEquippedItem = GetItemInSlot(iInventorySlot, oTarget);
|
|
|
|
// If the item is set to not be replaced, don't even generate a replacement item
|
|
if (GetLocalInt(oEquippedItem, CS_LGS_EQUIP_DONTREPLACE) == 1)
|
|
return;
|
|
|
|
AssignCommand(oTarget, ActionEquipItem(oItem, iInventorySlot));
|
|
}
|
|
|
|
object lgs_CreateEquipmentOnTarget(int iMainCategory, int iSubCategory, int iBaseItem, object oTarget, int iInventorySlot, int iLevel, int iMaxWeaponSize = -1)
|
|
{
|
|
// Get currently equipped item
|
|
object oEquippedItem = GetItemInSlot(iInventorySlot, oTarget);
|
|
|
|
// If the item is set to not be replaced, don't even generate a replacement item
|
|
if (GetLocalInt(oEquippedItem, CS_LGS_EQUIP_DONTREPLACE) == 1)
|
|
return OBJECT_INVALID;
|
|
|
|
int iMagical = FALSE;
|
|
int iIdentify = FALSE;
|
|
int iForceLevel = FALSE;
|
|
int iIncludeMonsterOnlyProps = FALSE;
|
|
string sItem;
|
|
int iMagicChance = d100();
|
|
|
|
// If the equipment isn't dropped, no harm in givin more magic items to the monsters
|
|
// to be competitive, besides, we'll force the magic level to help that even more
|
|
int iChance = CI_LGS_CHANCE_MAGICAL_EQ;
|
|
if (CI_LGS_DROPEQUIPMENT == FALSE)
|
|
{
|
|
iIdentify = TRUE;
|
|
iForceLevel = TRUE;
|
|
iIncludeMonsterOnlyProps = TRUE;
|
|
iChance += 2*iLevel;
|
|
}
|
|
|
|
if (iMagicChance <= iChance)
|
|
{
|
|
iMagical = TRUE;
|
|
sItem = egs_GetRandomItem(iMainCategory, iSubCategory, iBaseItem, iLevel, iMaxWeaponSize, TRUE);
|
|
}
|
|
else
|
|
{
|
|
sItem = egs_GetRandomItem(iMainCategory, iSubCategory, iBaseItem, iLevel, iMaxWeaponSize);
|
|
}
|
|
int nStackSize = (iMainCategory == CI_EGS_ITEM_MAIN_AMMO) ? Random(50) + 20 : 1;
|
|
object oItem = CreateItemOnObject(sItem, oTarget, nStackSize);
|
|
if (GetIsObjectValid(oItem))
|
|
{
|
|
SetDroppableFlag(oItem, CI_LGS_DROPEQUIPMENT);
|
|
SetIdentified(oItem, TRUE);
|
|
|
|
if (iMagical)
|
|
{
|
|
if (iLevel < CI_LGS_CR_BOOST_UNTIL)
|
|
{
|
|
iLevel += CI_LGS_CR_BOOST_VALUE;
|
|
if (iLevel > CI_LGS_CR_BOOST_UNTIL)
|
|
iLevel = CI_LGS_CR_BOOST_UNTIL;
|
|
}
|
|
|
|
ip_InfuseItemWithMagic(oItem, iLevel, iForceLevel, iIdentify, TRUE, iIncludeMonsterOnlyProps, -1);
|
|
}
|
|
if (iInventorySlot != -1)
|
|
DelayCommand(3.0f, lgs_EquipItem(oTarget, oItem, iInventorySlot));
|
|
}
|
|
return (oItem);
|
|
}
|
|
|
|
object lgs_CreateItemOnTarget(int iMainCategory, int iSubCategory, int iBaseItem, object oTarget, int iInventorySlot, int iLevel, int iOverrideMaxMagicLevel = -1, int iForceMagical = FALSE, int iDisallowMagical = FALSE, int iMaxWeaponSize = -1)
|
|
{
|
|
int iMagical = FALSE;
|
|
string sItem;
|
|
|
|
int iMagicChance = d100();
|
|
if (
|
|
(iMagicChance <= (CI_LGS_CHANCE_MAGICAL_LOOT_BASE + FloatToInt(iLevel * CF_LGS_CHANCE_MAGICAL_LOOT_MODIFIER)) || iForceMagical) &&
|
|
(!iDisallowMagical)
|
|
)
|
|
{
|
|
iMagical = TRUE;
|
|
sItem = egs_GetRandomItem(iMainCategory, iSubCategory, iBaseItem, iLevel, iMaxWeaponSize, TRUE);
|
|
}
|
|
else
|
|
{
|
|
sItem = egs_GetRandomItem(iMainCategory, iSubCategory, iBaseItem, iLevel, iMaxWeaponSize);
|
|
}
|
|
|
|
object oItem = CreateItemOnObject(sItem, oTarget);
|
|
if (GetIsObjectValid(oItem))
|
|
{
|
|
//SendMessageToAllDMs("Loot Item created");
|
|
SetDroppableFlag(oItem, TRUE);
|
|
SetIdentified(oItem, TRUE);
|
|
if (iMagical)
|
|
{
|
|
int iIdentified = FALSE;
|
|
if (d100(1) <= CI_LGS_CHANCE_LOOT_IDENTIFIED)
|
|
iIdentified = TRUE;
|
|
ip_InfuseItemWithMagic(oItem, iLevel, FALSE, iIdentified, TRUE, FALSE, -1, iOverrideMaxMagicLevel);
|
|
}
|
|
if (iInventorySlot != -1)
|
|
DelayCommand(3.0, AssignCommand(oTarget, ActionEquipItem(oItem, iInventorySlot)));
|
|
}
|
|
else
|
|
{
|
|
// SendMessageToAllDMs("Error creating loot item");
|
|
}
|
|
return (oItem);
|
|
}
|
|
|
|
void lgs_AdditionalChance(object oItem, int iLevel, int nProperty, int nPolicy = X2_IP_ADDPROP_POLICY_KEEP_EXISTING)
|
|
{
|
|
if (CI_LGS_DROPEQUIPMENT ||
|
|
oItem == OBJECT_INVALID)
|
|
return;
|
|
|
|
struct STRUCT_IP_PropertyDetails strIP;
|
|
|
|
int iChance = (iLevel * iLevel) / 10; // Level 10 -> 10%, Level 15 -> 22,5%, Level 20 -> 40%, Level 25 -> 62,5%, Level 30 -> 90%
|
|
int iRandom = Random(100) + 1;
|
|
iLevel -= Random(3);
|
|
if (iLevel < 1)
|
|
iLevel = 1;
|
|
|
|
if (iRandom < iChance)
|
|
{
|
|
strIP = ip_GetProperty(-1, -1, -1, iLevel, CI_IP_TYPE_POSITIVE, -1, nProperty);
|
|
IPSafeAddItemProperty(oItem, strIP.IP, 0.0f, nPolicy);
|
|
}
|
|
}
|
|
|
|
object lgs_CreateRingOfXtraDifficulty(object oTarget, int iLevel)
|
|
{
|
|
string sItem = egs_GetRandomItem(CI_EGS_ITEM_MAIN_MONSTERRING, -1, -1, iLevel);
|
|
object oItem = CreateItemOnObject(sItem, oTarget);
|
|
if (GetIsObjectValid(oItem))
|
|
{
|
|
SetDroppableFlag(oItem, FALSE);
|
|
SetIdentified(oItem, FALSE);
|
|
|
|
// Find out the number of additional properties, on top of the
|
|
// standard properties for this difficulty level if the monster is level 5
|
|
// or higher
|
|
if (iLevel > 4)
|
|
{
|
|
int iNumberOfProps = (iLevel / 8) + 1;
|
|
ip_InfuseItemWithMagic(oItem, iLevel, TRUE, TRUE, FALSE, TRUE, iNumberOfProps);
|
|
}
|
|
|
|
AssignCommand(oTarget, ActionEquipItem(oItem, INVENTORY_SLOT_RIGHTRING));
|
|
}
|
|
return oItem;
|
|
}
|
|
|
|
object lgs_CreateArmorBody(object oTarget, int iLevel)
|
|
{
|
|
int iRandom;
|
|
if (GetHasFeat(FEAT_ARMOR_PROFICIENCY_HEAVY, oTarget))
|
|
iRandom = Random(2) + 2;
|
|
else if (GetHasFeat(FEAT_ARMOR_PROFICIENCY_MEDIUM, oTarget))
|
|
iRandom = Random(2) + 1;
|
|
else if (GetHasFeat(FEAT_ARMOR_PROFICIENCY_LIGHT, oTarget))
|
|
iRandom = Random(2);
|
|
else
|
|
iRandom = 0;
|
|
|
|
object oItem;
|
|
switch (iRandom)
|
|
{
|
|
case 0: oItem = lgs_CreateEquipmentOnTarget(-1, CI_EGS_ITEM_SUB_ARMOR_BODY_CLOTHING, -1, oTarget, INVENTORY_SLOT_CHEST, iLevel);
|
|
break;
|
|
case 1: oItem = lgs_CreateEquipmentOnTarget(-1, CI_EGS_ITEM_SUB_ARMOR_BODY_LIGHT, -1, oTarget, INVENTORY_SLOT_CHEST, iLevel);
|
|
break;
|
|
case 2: oItem = lgs_CreateEquipmentOnTarget(-1, CI_EGS_ITEM_SUB_ARMOR_BODY_MEDIUM, -1, oTarget, INVENTORY_SLOT_CHEST, iLevel);
|
|
break;
|
|
case 3: oItem = lgs_CreateEquipmentOnTarget(-1, CI_EGS_ITEM_SUB_ARMOR_BODY_HEAVY, -1, oTarget, INVENTORY_SLOT_CHEST, iLevel);
|
|
break;
|
|
}
|
|
|
|
// We want a good chance of AC Bonus and Damage Reduction on higher levels if we are not set to drop equipment
|
|
lgs_AdditionalChance(oItem, iLevel, CI_IP_DamageReduction);
|
|
|
|
return oItem;
|
|
}
|
|
|
|
object lgs_CreateHelmet(object oTarget, int iLevel)
|
|
{
|
|
return lgs_CreateEquipmentOnTarget(-1, CI_EGS_ITEM_SUB_ARMOR_HELMET, -1, oTarget, INVENTORY_SLOT_HEAD, iLevel);
|
|
}
|
|
|
|
object lgs_CreateWeaponMelee(object oTarget, int iLevel, int iSlot = INVENTORY_SLOT_RIGHTHAND, int iMaxWeaponSize = -1)
|
|
{
|
|
object oItem = lgs_CreateEquipmentOnTarget(-1, CI_EGS_ITEM_SUB_WEAPON_MELEE, -1, oTarget, iSlot, iLevel, iMaxWeaponSize);
|
|
|
|
// We need a good chance of getting an Enhancement Bonus at higher levels
|
|
lgs_AdditionalChance(oItem, iLevel, CI_IP_EnhancementBonus);
|
|
|
|
return oItem;
|
|
}
|
|
|
|
object lgs_CreateShield(object oTarget, int iLevel, int iMaxWeaponSize = -1)
|
|
{
|
|
return lgs_CreateEquipmentOnTarget(-1, CI_EGS_ITEM_SUB_ARMOR_SHIELD, -1, oTarget, INVENTORY_SLOT_LEFTHAND, iLevel, iMaxWeaponSize);
|
|
}
|
|
|
|
object lgs_CreateArrows(object oTarget, int iLevel)
|
|
{
|
|
object oAmmo = lgs_CreateEquipmentOnTarget(-1, -1, BASE_ITEM_ARROW, oTarget, -1, iLevel);
|
|
SetItemStackSize(oAmmo, Random(50) + 40);
|
|
return oAmmo;
|
|
}
|
|
|
|
object lgs_CreateBolts(object oTarget, int iLevel)
|
|
{
|
|
object oAmmo = lgs_CreateEquipmentOnTarget(-1, -1, BASE_ITEM_BOLT, oTarget, -1, iLevel);
|
|
SetItemStackSize(oAmmo, Random(50) + 40);
|
|
return oAmmo;
|
|
}
|
|
|
|
object lgs_CreateBullets(object oTarget, int iLevel)
|
|
{
|
|
object oAmmo = lgs_CreateEquipmentOnTarget(-1, -1, BASE_ITEM_BULLET, oTarget, -1, iLevel);
|
|
SetItemStackSize(oAmmo, Random(50) + 40);
|
|
return oAmmo;
|
|
}
|
|
|
|
object lgs_CreateWeaponRanged(object oTarget, int iLevel, int iSlot = INVENTORY_SLOT_RIGHTHAND, int iMaxWeaponSize = -1)
|
|
{
|
|
int iRandom;
|
|
if (iMaxWeaponSize == -1)
|
|
iRandom = Random(5);
|
|
else if (iMaxWeaponSize < CI_EGS_WEAPONSIZE_MEDIUM)
|
|
iRandom = 0;
|
|
else if (iMaxWeaponSize < CI_EGS_WEAPONSIZE_LARGE)
|
|
iRandom = Random(3);
|
|
else
|
|
iRandom = Random(5);
|
|
|
|
int iAmmoCount = Random(3) + 1 + FloatToInt(IntToFloat(iLevel) / 8);
|
|
int iCount;
|
|
object oItem;
|
|
switch (iRandom)
|
|
{
|
|
case 0:
|
|
oItem = lgs_CreateEquipmentOnTarget(-1, -1, BASE_ITEM_SLING, oTarget, iSlot, iLevel);
|
|
for (iCount = 0; iCount < iAmmoCount; iCount++)
|
|
lgs_CreateBullets(oTarget, iLevel);
|
|
break;
|
|
case 1:
|
|
oItem = lgs_CreateEquipmentOnTarget(-1, -1, BASE_ITEM_LIGHTCROSSBOW, oTarget, iSlot, iLevel);
|
|
for (iCount = 0; iCount < iAmmoCount; iCount++)
|
|
lgs_CreateBolts(oTarget, iLevel);
|
|
break;
|
|
case 2:
|
|
oItem = lgs_CreateEquipmentOnTarget(-1, -1, BASE_ITEM_SHORTBOW, oTarget, iSlot, iLevel);
|
|
for (iCount = 0; iCount < iAmmoCount; iCount++)
|
|
lgs_CreateArrows(oTarget, iLevel);
|
|
break;
|
|
case 3:
|
|
oItem = lgs_CreateEquipmentOnTarget(-1, -1, BASE_ITEM_HEAVYCROSSBOW, oTarget, iSlot, iLevel);
|
|
for (iCount = 0; iCount < iAmmoCount; iCount++)
|
|
lgs_CreateBolts(oTarget, iLevel);
|
|
break;
|
|
case 4:
|
|
oItem = lgs_CreateEquipmentOnTarget(-1, -1, BASE_ITEM_LONGBOW, oTarget, iSlot, iLevel);
|
|
for (iCount = 0; iCount < iAmmoCount; iCount++)
|
|
lgs_CreateArrows(oTarget, iLevel);
|
|
break;
|
|
}
|
|
|
|
// We need a good chance of getting an attack bonus on ranged weapons on higher levels
|
|
lgs_AdditionalChance(oItem, iLevel, CI_IP_AttackBonus);
|
|
|
|
return oItem;
|
|
}
|
|
|
|
object lgs_CreateWeaponThrown(object oTarget, int iLevel, int iMaxWeaponSize = -1)
|
|
{
|
|
object oThrown;
|
|
int iStacks = Random(3) + 1;
|
|
int iCount;
|
|
|
|
// Create the stack used
|
|
oThrown = lgs_CreateEquipmentOnTarget(-1, CI_EGS_ITEM_SUB_WEAPON_THROWN, -1, oTarget, INVENTORY_SLOT_RIGHTHAND, iLevel, iMaxWeaponSize);
|
|
SetItemStackSize(oThrown, Random(30) + 20);
|
|
|
|
// We need a good chance of an enhancement bonus on thrown weapons on higher levels
|
|
lgs_AdditionalChance(oThrown, iLevel, CI_IP_EnhancementBonus);
|
|
|
|
return oThrown;
|
|
}
|
|
|
|
object lgs_CreateAmulet(object oTarget, int iLevel)
|
|
{
|
|
return lgs_CreateEquipmentOnTarget(-1, -1, BASE_ITEM_AMULET, oTarget, INVENTORY_SLOT_NECK, iLevel);
|
|
}
|
|
|
|
object lgs_CreateRing(object oTarget, int iLevel)
|
|
{
|
|
return lgs_CreateEquipmentOnTarget(-1, -1, BASE_ITEM_RING, oTarget, INVENTORY_SLOT_LEFTRING, iLevel);
|
|
}
|
|
|
|
object lgs_CreateBelt(object oTarget, int iLevel)
|
|
{
|
|
return lgs_CreateEquipmentOnTarget(-1, -1, BASE_ITEM_BELT, oTarget, INVENTORY_SLOT_BELT, iLevel);
|
|
}
|
|
|
|
object lgs_CreateGlovesOrBracers(object oTarget, int iLevel)
|
|
{
|
|
return lgs_CreateEquipmentOnTarget(-1, -1, BASE_ITEM_GLOVES, oTarget, INVENTORY_SLOT_ARMS, iLevel);
|
|
}
|
|
|
|
object lgs_CreateCloak(object oTarget, int iLevel)
|
|
{
|
|
return lgs_CreateEquipmentOnTarget(-1, -1, BASE_ITEM_CLOAK, oTarget, INVENTORY_SLOT_CLOAK, iLevel);
|
|
}
|
|
|
|
object lgs_CreateBoots(object oTarget, int iLevel)
|
|
{
|
|
return lgs_CreateEquipmentOnTarget(-1, -1, BASE_ITEM_BOOTS, oTarget, INVENTORY_SLOT_BOOTS, iLevel);
|
|
}
|
|
|
|
float lgs_GetChallengeRating(object oCreature)
|
|
{
|
|
return GetChallengeRating(oCreature);
|
|
}
|
|
|
|
void lgs_EquipMonster(object oMonster, int iAddedDropChance = 0)
|
|
{
|
|
// Check if our oMonster is valid or set to not be equipped
|
|
if (!GetIsObjectValid(oMonster) ||
|
|
GetLocalInt(oMonster, CS_LGS_EQUIP_DISABLE) == 1)
|
|
{
|
|
// SendMessageToAllDMs("Monster to be equipped is invalid!");
|
|
return;
|
|
}
|
|
|
|
// Get the Difficulty of our Monster
|
|
string sMonsterResRef = GetResRef(oMonster);
|
|
|
|
int iDifficulty = FloatToInt (lgs_GetChallengeRating (oMonster));
|
|
|
|
// Get the Size of our Monster
|
|
int iSize = GetCreatureSize(oMonster);
|
|
|
|
int iChance;
|
|
|
|
// Create a Ring of Xtra Difficulty for our monster
|
|
lgs_CreateRingOfXtraDifficulty(oMonster, iDifficulty);
|
|
|
|
// Body Armor
|
|
iChance = d100() - iAddedDropChance;
|
|
if (iChance < (iDifficulty * CI_LGS_CHANCE_BODYARMOR) + (CI_LGS_CHANCE_BODYARMOR * 20))
|
|
lgs_CreateArmorBody(oMonster, iDifficulty);
|
|
|
|
// Helmet
|
|
iChance = d100() - iAddedDropChance;
|
|
if (iChance < (iDifficulty * CI_LGS_CHANCE_HELMET) + (CI_LGS_CHANCE_HELMET * 20))
|
|
lgs_CreateHelmet(oMonster, iDifficulty);
|
|
|
|
|
|
// Force Ranged Fighting Style for Archer Types
|
|
int iFightingStyle;
|
|
// Determine if this monster is:
|
|
// .) Going for Weapon + Shield - 45%
|
|
// .) One/Two-Handed Fighting - 45%
|
|
// .) Ranged Fighting - 10%
|
|
iFightingStyle = d100();
|
|
if (iFightingStyle <= 45)
|
|
iFightingStyle = 0;
|
|
else if (iFightingStyle <= 90)
|
|
iFightingStyle = 1;
|
|
else
|
|
iFightingStyle = 2;
|
|
|
|
int nDualWield = 0;
|
|
|
|
switch(iFightingStyle)
|
|
{
|
|
// Weapon + Shield
|
|
case 0: iChance = d100() - iAddedDropChance;
|
|
if (iChance < (iDifficulty * CI_LGS_CHANCE_WEAPON) + (CI_LGS_CHANCE_WEAPON * 20))
|
|
{
|
|
lgs_CreateWeaponMelee(oMonster, iDifficulty, INVENTORY_SLOT_RIGHTHAND, iSize);
|
|
|
|
iChance = d100() - iAddedDropChance;
|
|
if (iChance < (iDifficulty * CI_LGS_CHANCE_SHIELD) + (CI_LGS_CHANCE_SHIELD * 20))
|
|
{
|
|
lgs_CreateShield(oMonster, iDifficulty, iSize);
|
|
}
|
|
|
|
// Create a Ranged Reserve just in case it could be needed ;)
|
|
if (iChance < (iDifficulty * CI_LGS_CHANCE_RANGEDRESERVE) + (CI_LGS_CHANCE_RANGEDRESERVE * 20))
|
|
{
|
|
lgs_CreateWeaponRanged(oMonster, iDifficulty, -1);
|
|
}
|
|
}
|
|
break;
|
|
// One-Handed / Two-Handed
|
|
case 1: iChance = d100() - iAddedDropChance;
|
|
if (iChance < (iDifficulty * CI_LGS_CHANCE_WEAPON) + (CI_LGS_CHANCE_WEAPON * 20))
|
|
{
|
|
iChance = d100();
|
|
if (GetHasFeat(FEAT_AMBIDEXTERITY, oMonster))
|
|
nDualWield += 10;
|
|
if (GetHasFeat(FEAT_TWO_WEAPON_FIGHTING, oMonster))
|
|
nDualWield += 20;
|
|
if (GetHasFeat(FEAT_IMPROVED_TWO_WEAPON_FIGHTING, oMonster))
|
|
nDualWield += 40;
|
|
|
|
if (iChance < CI_LGS_CHANCE_DUALWIELD + nDualWield)
|
|
{
|
|
lgs_CreateWeaponMelee(oMonster, iDifficulty, INVENTORY_SLOT_RIGHTHAND, iSize);
|
|
lgs_CreateWeaponMelee(oMonster, iDifficulty, INVENTORY_SLOT_LEFTHAND, iSize);
|
|
}
|
|
else
|
|
{
|
|
lgs_CreateWeaponMelee(oMonster, iDifficulty, INVENTORY_SLOT_RIGHTHAND, iSize + 1);
|
|
}
|
|
}
|
|
break;
|
|
// Ranged / Thrown
|
|
case 2: int iRangedOrThrown = Random(3);
|
|
switch (iRangedOrThrown)
|
|
{
|
|
// Ranged
|
|
case 0:
|
|
case 1: iChance = d100() - iAddedDropChance;
|
|
if (iChance < (iDifficulty * CI_LGS_CHANCE_WEAPON) + (CI_LGS_CHANCE_WEAPON * 20))
|
|
{
|
|
lgs_CreateWeaponRanged(oMonster, iDifficulty);
|
|
}
|
|
break;
|
|
// Thrown
|
|
case 2: iChance = d100() - iAddedDropChance;
|
|
if (iChance < (iDifficulty * CI_LGS_CHANCE_WEAPON) + (CI_LGS_CHANCE_WEAPON * 20))
|
|
{
|
|
lgs_CreateWeaponThrown(oMonster, iDifficulty, iSize);
|
|
}
|
|
// Doods with Thrown Weapons should have at least a reserve melee weapon
|
|
// This weapon should be of size Tiny or Small
|
|
lgs_CreateWeaponMelee(oMonster, iDifficulty, INVENTORY_SLOT_RIGHTHAND, CI_EGS_WEAPONSIZE_SMALL);
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
// Amulet
|
|
iChance = d100() - iAddedDropChance;
|
|
if (iChance < (iDifficulty * CI_LGS_CHANCE_AMULET) + (CI_LGS_CHANCE_AMULET * 20))
|
|
lgs_CreateAmulet(oMonster, iDifficulty);
|
|
|
|
// Ring
|
|
iChance = d100() - iAddedDropChance;
|
|
if (iChance < (iDifficulty * CI_LGS_CHANCE_RING) + (CI_LGS_CHANCE_RING * 20))
|
|
lgs_CreateRing(oMonster, iDifficulty);
|
|
|
|
// Belt
|
|
iChance = d100() - iAddedDropChance;
|
|
if (iChance < (iDifficulty * CI_LGS_CHANCE_BELT) + (CI_LGS_CHANCE_BELT * 20))
|
|
lgs_CreateBelt(oMonster, iDifficulty);
|
|
|
|
// Gloves or Bracers
|
|
iChance = d100() - iAddedDropChance;
|
|
if (iChance < (iDifficulty * CI_LGS_CHANCE_BRACERS_OR_GLOVES) + (CI_LGS_CHANCE_BRACERS_OR_GLOVES * 20))
|
|
lgs_CreateGlovesOrBracers(oMonster, iDifficulty);
|
|
|
|
// Cloak
|
|
iChance = d100() - iAddedDropChance;
|
|
if (iChance < (iDifficulty * CI_LGS_CHANCE_CLOAK) + (CI_LGS_CHANCE_CLOAK * 20))
|
|
lgs_CreateCloak(oMonster, iDifficulty);
|
|
|
|
// Boots
|
|
iChance = d100() - iAddedDropChance;
|
|
if (iChance < (iDifficulty * CI_LGS_CHANCE_BOOTS) + (CI_LGS_CHANCE_BOOTS * 20))
|
|
lgs_CreateBoots(oMonster, iDifficulty);
|
|
}
|
|
|
|
int lgs_DropOnSelf(object oItem)
|
|
{
|
|
string sTag = GetTag(oItem);
|
|
string sTag_Wild_One = GetStringLeft(sTag, GetStringLength(sTag) - 1) + "*";
|
|
string sTag_Wild_Two = GetStringLeft(sTag, GetStringLength(sTag) - 2) + "*";
|
|
string sTag_Wild_Three = GetStringLeft(sTag, GetStringLength(sTag) - 3) + "*";
|
|
if (GetLocalInt(oItem, CS_LGS_VAR_DROPONSELF) == 1 ||
|
|
FindSubString(CS_LGS_DROPONSELF_TAGS, sTag) >= 0 ||
|
|
FindSubString(CS_LGS_DROPONSELF_TAGS_WILD, sTag_Wild_One) >= 0 ||
|
|
FindSubString(CS_LGS_DROPONSELF_TAGS_WILD, sTag_Wild_Two) >= 0 ||
|
|
FindSubString(CS_LGS_DROPONSELF_TAGS_WILD, sTag_Wild_Three) >= 0)
|
|
return TRUE;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
void lgs_GetFixedLoot(object oMonster, object oLootContainer, object oLootContainer_Self, object oContainer_FixedLoot)
|
|
{
|
|
// Find out the number of items to be dropped by checking for a local override variable or
|
|
// using the default setting.
|
|
int nLootCount = GetLocalInt(oMonster, "FixedLoot_Count");
|
|
if (nLootCount == 0)
|
|
nLootCount = CS_LGS_FIXEDLOOT_COUNT_DEFAULT;
|
|
|
|
// Add a random number of loot
|
|
if (CS_LGS_FIXEDLOOT_COUNT_RANDOM != 0)
|
|
{
|
|
int nRandom = Random(2);
|
|
if (nRandom == 0)
|
|
{
|
|
nLootCount += Random(CS_LGS_FIXEDLOOT_COUNT_RANDOM + 1);
|
|
}
|
|
else if (nRandom == 1)
|
|
{
|
|
nLootCount -= Random(CS_LGS_FIXEDLOOT_COUNT_RANDOM + 1);
|
|
}
|
|
}
|
|
|
|
// Count the number of items in this monster's loot container
|
|
object oLoot;
|
|
int nWeight;
|
|
int nth;
|
|
if (!eas_Array_Exists(oContainer_FixedLoot, CS_LGS_FIXEDLOOT_ARRAY))
|
|
{
|
|
eas_Array_Create(oContainer_FixedLoot, CS_LGS_FIXEDLOOT_ARRAY, EAS_ARRAY_TYPE_OBJECT);
|
|
oLoot = GetFirstItemInInventory(oContainer_FixedLoot);
|
|
while (GetIsObjectValid(oLoot))
|
|
{
|
|
// Retrieve the weight of this item
|
|
nWeight = GetLocalInt(oLoot, CS_LGS_FIXEDLOOT_WEIGHT);
|
|
if (nWeight == 0)
|
|
nWeight = 1;
|
|
|
|
for (nth = 1; nth <= nWeight; nth++)
|
|
eas_OArray_Entry_Add(oContainer_FixedLoot, CS_LGS_FIXEDLOOT_ARRAY, oLoot);
|
|
|
|
oLoot = GetNextItemInInventory(oContainer_FixedLoot);
|
|
}
|
|
}
|
|
|
|
// Create loot and name it purple
|
|
object oCopy;
|
|
int n;
|
|
for (n = 1; n <= nLootCount; n++)
|
|
{
|
|
oLoot = eas_OArray_Entry_Get(oContainer_FixedLoot, CS_LGS_FIXEDLOOT_ARRAY, Random(eas_Array_GetSize(oContainer_FixedLoot, CS_LGS_FIXEDLOOT_ARRAY)));
|
|
if (GetIsObjectValid(oLootContainer_Self) &&
|
|
lgs_DropOnSelf(oLoot))
|
|
oCopy = CopyItem(oLoot, oLootContainer_Self, TRUE);
|
|
else
|
|
oCopy = CopyItem(oLoot, oLootContainer, TRUE);
|
|
|
|
int nRarity = GetLocalInt(oCopy, "Rarity");
|
|
string sColor;
|
|
switch (nRarity)
|
|
{
|
|
case 1: sColor = COLOR_PREDEFINED_ITEM_COMMON; break;
|
|
case 2: sColor = COLOR_PREDEFINED_ITEM_UNCOMMON; break;
|
|
case 3: sColor = COLOR_PREDEFINED_ITEM_RARE; break;
|
|
case 4: sColor = COLOR_PREDEFINED_ITEM_EPIC; break;
|
|
case 5: sColor = COLOR_PREDEFINED_ITEM_LEGENDARY; break;
|
|
default: sColor = COLOR_PREDEFINED_ITEM_RARE; break;
|
|
}
|
|
SetName(oCopy, color_ConvertString(GetName(oCopy), sColor));
|
|
}
|
|
}
|
|
|
|
void lgs_MoveEquipment(object oItem, object oLootContainer, object oLootContainer_Self)
|
|
{
|
|
// Some items aren't allowed to be transferred and have to be deleted instantly
|
|
if(FindSubString(GetTag(oItem),"NW_IT_CRE")>-1 ||
|
|
GetName(oItem) == "PC Properties")
|
|
{
|
|
DestroyObject(oItem);
|
|
return;
|
|
}
|
|
|
|
if (GetDroppableFlag(oItem))
|
|
{
|
|
// Copy the item to the loot container
|
|
int nLGS_DropChance = GetLocalInt(oItem, CS_LGS_EQUIP_DROPCHANCE);
|
|
if (nLGS_DropChance == 0 || d100(1) <= nLGS_DropChance)
|
|
{
|
|
if (GetIsObjectValid(oLootContainer_Self) &&
|
|
lgs_DropOnSelf(oItem))
|
|
CopyItem(oItem, oLootContainer_Self, TRUE);
|
|
else
|
|
CopyItem(oItem, oLootContainer, TRUE);
|
|
}
|
|
|
|
// Flag the original item undroppable
|
|
SetDroppableFlag(oItem, FALSE);
|
|
}
|
|
}
|
|
|
|
void lgs_CreateLoot(object oMonster, object oLootContainer = OBJECT_INVALID, object oLootContainer_Self = OBJECT_INVALID, int iFixedLootOnly = FALSE, int iNumberOfLootItems = -1)
|
|
{
|
|
// Check if our oMonster is valid
|
|
if (!GetIsObjectValid(oMonster))
|
|
{
|
|
// SendMessageToAllDMs("Monster to create loot for is invalid!");
|
|
return;
|
|
}
|
|
|
|
// If the monster is set to NoLoot, return
|
|
if (GetLocalInt(oMonster, CS_LGS_LOOT_DISABLE) == 1)
|
|
return;
|
|
|
|
// If LootContainer isn't valid, the Monster will be the Loot Container
|
|
if (!GetIsObjectValid(oLootContainer))
|
|
oLootContainer = oMonster;
|
|
|
|
// Move inventory items to the lootcontainer
|
|
// if the monster is not the container
|
|
if (oLootContainer != oMonster)
|
|
{
|
|
// Move equipped items
|
|
lgs_MoveEquipment(GetItemInSlot(INVENTORY_SLOT_ARMS, oMonster), oLootContainer, oLootContainer_Self);
|
|
lgs_MoveEquipment(GetItemInSlot(INVENTORY_SLOT_ARROWS, oMonster), oLootContainer, oLootContainer_Self);
|
|
lgs_MoveEquipment(GetItemInSlot(INVENTORY_SLOT_BELT, oMonster), oLootContainer, oLootContainer_Self);
|
|
lgs_MoveEquipment(GetItemInSlot(INVENTORY_SLOT_BOLTS, oMonster), oLootContainer, oLootContainer_Self);
|
|
lgs_MoveEquipment(GetItemInSlot(INVENTORY_SLOT_BOOTS, oMonster), oLootContainer, oLootContainer_Self);
|
|
lgs_MoveEquipment(GetItemInSlot(INVENTORY_SLOT_BULLETS, oMonster), oLootContainer, oLootContainer_Self);
|
|
lgs_MoveEquipment(GetItemInSlot(INVENTORY_SLOT_CHEST, oMonster), oLootContainer, oLootContainer_Self);
|
|
lgs_MoveEquipment(GetItemInSlot(INVENTORY_SLOT_CLOAK, oMonster), oLootContainer, oLootContainer_Self);
|
|
lgs_MoveEquipment(GetItemInSlot(INVENTORY_SLOT_HEAD, oMonster), oLootContainer, oLootContainer_Self);
|
|
lgs_MoveEquipment(GetItemInSlot(INVENTORY_SLOT_LEFTHAND, oMonster), oLootContainer, oLootContainer_Self);
|
|
lgs_MoveEquipment(GetItemInSlot(INVENTORY_SLOT_LEFTRING, oMonster), oLootContainer, oLootContainer_Self);
|
|
lgs_MoveEquipment(GetItemInSlot(INVENTORY_SLOT_NECK, oMonster), oLootContainer, oLootContainer_Self);
|
|
lgs_MoveEquipment(GetItemInSlot(INVENTORY_SLOT_RIGHTHAND, oMonster), oLootContainer, oLootContainer_Self);
|
|
lgs_MoveEquipment(GetItemInSlot(INVENTORY_SLOT_RIGHTRING, oMonster), oLootContainer, oLootContainer_Self);
|
|
|
|
object oInventoryItem = GetFirstItemInInventory(oMonster);
|
|
while(GetIsObjectValid(oInventoryItem))
|
|
{
|
|
// Move it
|
|
lgs_MoveEquipment(oInventoryItem, oLootContainer, oLootContainer_Self);
|
|
|
|
oInventoryItem = GetNextItemInInventory(oMonster);
|
|
}
|
|
}
|
|
|
|
// Get the Difficulty of our Monster
|
|
int iDifficulty;
|
|
int iSize;
|
|
if (GetObjectType(oMonster) == OBJECT_TYPE_PLACEABLE) // PLACEABLE
|
|
{
|
|
iDifficulty = GetLocalInt(oMonster, CS_LGS_PLACEABLE_CR);
|
|
iSize = -1; // Size doesn't matter ;)
|
|
}
|
|
else
|
|
{
|
|
string sMonsterResRef = GetResRef(oMonster); // MONSTER
|
|
iDifficulty = FloatToInt (lgs_GetChallengeRating (oMonster));
|
|
// Get the Size of our Monster
|
|
iSize = GetCreatureSize(oMonster);
|
|
}
|
|
|
|
// Will it drop gold?
|
|
int iChance = d100();
|
|
if (iChance < CI_LGS_CHANCE_GOLD + iDifficulty)
|
|
{
|
|
int iGold = Random(2 * iDifficulty + iDifficulty * iDifficulty);
|
|
//GiveGoldToCreature(oMonster, (iGold) + Random(iGold));
|
|
CreateItemOnObject("nw_it_gold001", oLootContainer, iGold);
|
|
}
|
|
|
|
// Then, let's see if our Monster has fixed loot table, i.e. a loot container
|
|
string sMonsterTag = GetTag(oMonster);
|
|
object oWaypoint_FixedLoot = GetObjectByTag(CS_LGS_FIXEDLOOT_WAYPOINT);
|
|
object oContainer_FixedLoot = GetNearestObjectByTag(sMonsterTag, oWaypoint_FixedLoot);
|
|
|
|
if (GetIsObjectValid(oContainer_FixedLoot))
|
|
{
|
|
lgs_GetFixedLoot(oMonster, oLootContainer, oLootContainer_Self, oContainer_FixedLoot);
|
|
return;
|
|
}
|
|
|
|
// If we are only to check for fixed loot, leave now
|
|
if (iFixedLootOnly)
|
|
return;
|
|
|
|
// Add additional iLvl as per CFG
|
|
iDifficulty += CI_LGS_ILVL_ADDEDVALUE;
|
|
|
|
if (iDifficulty < CI_LGS_CR_BOOST_UNTIL)
|
|
{
|
|
iDifficulty += CI_LGS_CR_BOOST_VALUE;
|
|
if (iDifficulty > CI_LGS_CR_BOOST_UNTIL)
|
|
iDifficulty = CI_LGS_CR_BOOST_UNTIL;
|
|
}
|
|
|
|
// First, we'll determine IF the monster will drop anything at all
|
|
iChance = d100();
|
|
//SendMessageToAllDMs("Loot Roll for [" + GetName(oMonster) + "]: " + IntToString(iChance));
|
|
if (iChance > CI_LGS_CHANCE_LOOT &&
|
|
iNumberOfLootItems == -1)
|
|
return;
|
|
|
|
/*
|
|
// we'll set a 15% chance of using Bioware Treasure instead of ours
|
|
iChance = d100();
|
|
if (iChance <= 15)
|
|
{
|
|
CTG_GenerateNPCTreasure(TREASURE_TYPE_MONSTER, oMonster);
|
|
return;
|
|
}
|
|
*/
|
|
|
|
// Now, for our proprietary stuff...
|
|
|
|
// Maybe our monster is set to use loot container that's not linked to it's tag
|
|
string sContainer_CustomLoot = GetLocalString(oMonster, CS_LGS_VAR_CUSTOMLOOT_CHEST);
|
|
if (sContainer_CustomLoot != "")
|
|
{
|
|
object oContainer_CustomLoot = GetNearestObjectByTag(sContainer_CustomLoot, oWaypoint_FixedLoot);
|
|
if (GetIsObjectValid(oContainer_CustomLoot))
|
|
{
|
|
// Retrieve custom loot chance and set to default if not set on monster
|
|
int nCustomLootChance = GetLocalInt(oMonster, CS_LGS_VAR_CUSTOMLOOT_CHANCE);
|
|
if (nCustomLootChance == 0)
|
|
nCustomLootChance = CI_LGS_VAR_CUSTOMLOOT_CHANCE_DEFAULT;
|
|
|
|
// Roll for using the custom loot container
|
|
int nCustomLootRoll = d100();
|
|
if (nCustomLootRoll <= nCustomLootChance)
|
|
{
|
|
lgs_GetFixedLoot(oMonster, oLootContainer, oLootContainer_Self, oContainer_FixedLoot);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// For Random loot, first check how many items will be dropped
|
|
if (iNumberOfLootItems == -1)
|
|
{
|
|
iNumberOfLootItems = 1;
|
|
iChance = d100();
|
|
if (iChance < CI_LGS_CHANCE_LOOT)
|
|
iNumberOfLootItems++;
|
|
iChance = d100();
|
|
if (iChance < CI_LGS_CHANCE_LOOT / 2)
|
|
iNumberOfLootItems++;
|
|
}
|
|
|
|
//SendMessageToAllDMs("Number of Items: " + IntToString(iNumberOfLootItems));
|
|
|
|
// PAT Creatures use another MAX Magic level for Loot
|
|
int iOverrideMaxMagicLevel = -1;
|
|
if (GetLocalInt(oMonster, PAT_VAR_APPLIED) == 1)
|
|
iOverrideMaxMagicLevel = PAT_IP_MAXMAGICLEVEL;
|
|
|
|
int iCheck;
|
|
int iCount;
|
|
int iSubSelection;
|
|
object oCreatedLoot;
|
|
|
|
int iLootRandomizer = CI_LGS_LOOT_CLOTHING + CI_LGS_LOOT_ARMOR_LIGHT + CI_LGS_LOOT_ARMOR_MEDIUM +
|
|
CI_LGS_LOOT_ARMOR_HEAVY + CI_LGS_LOOT_SHIELD_SMALL + CI_LGS_LOOT_SHIELD_LARGE +
|
|
CI_LGS_LOOT_SHIELD_TOWER + CI_LGS_LOOT_HELMET + CI_LGS_LOOT_WEAPON_MELEE +
|
|
CI_LGS_LOOT_WEAPON_RANGED + CI_LGS_LOOT_WEAPON_THROWN + CI_LGS_LOOT_AMMO +
|
|
CI_LGS_LOOT_JEWELRY_RING + CI_LGS_LOOT_JEWELRY_AMULET + CI_LGS_LOOT_ACCESSORY_BRACERS +
|
|
CI_LGS_LOOT_ACCESSORY_GLOVES + CI_LGS_LOOT_ACCESSORY_BELT + CI_LGS_LOOT_ACCESSORY_CLOAK +
|
|
CI_LGS_LOOT_ACCESSORY_BOOTS + CI_LGS_LOOT_SCROLL + CI_LGS_LOOT_BOOK + CI_LGS_LOOT_POTION +
|
|
CI_LGS_LOOT_WAND + CI_LGS_LOOT_MEDKIT + CI_LGS_LOOT_TRAPKIT + CI_LGS_LOOT_THIEVESTOOLS +
|
|
CI_LGS_LOOT_CONTAINER + CI_LGS_LOOT_MISC + CI_LGS_LOOT_BOMB + CI_LGS_LOOT_FOOD;
|
|
|
|
for (iCount = 0; iCount < iNumberOfLootItems; iCount++)
|
|
{
|
|
iChance = Random(iLootRandomizer);
|
|
|
|
// Clothing
|
|
iCheck = CI_LGS_LOOT_CLOTHING;
|
|
if (CI_LGS_LOOT_CLOTHING != 0 && iChance <= iCheck)
|
|
{
|
|
lgs_CreateItemOnTarget(-1, CI_EGS_ITEM_SUB_ARMOR_BODY_CLOTHING, -1, oLootContainer, -1, iDifficulty, iOverrideMaxMagicLevel);
|
|
continue;
|
|
}
|
|
// Light Armor
|
|
iCheck += CI_LGS_LOOT_ARMOR_LIGHT;
|
|
if (CI_LGS_LOOT_ARMOR_LIGHT != 0 && iChance <= iCheck)
|
|
{
|
|
lgs_CreateItemOnTarget(-1, CI_EGS_ITEM_SUB_ARMOR_BODY_LIGHT, -1, oLootContainer, -1, iDifficulty, iOverrideMaxMagicLevel);
|
|
continue;
|
|
}
|
|
// Medium Armor
|
|
iCheck += CI_LGS_LOOT_ARMOR_MEDIUM;
|
|
if (CI_LGS_LOOT_ARMOR_MEDIUM != 0 && iChance <= iCheck)
|
|
{
|
|
lgs_CreateItemOnTarget(-1, CI_EGS_ITEM_SUB_ARMOR_BODY_MEDIUM, -1, oLootContainer, -1, iDifficulty, iOverrideMaxMagicLevel);
|
|
continue;
|
|
}
|
|
// Heavy Armor
|
|
iCheck += CI_LGS_LOOT_ARMOR_HEAVY;
|
|
if (CI_LGS_LOOT_ARMOR_HEAVY != 0 && iChance <= iCheck)
|
|
{
|
|
lgs_CreateItemOnTarget(-1, CI_EGS_ITEM_SUB_ARMOR_BODY_HEAVY, -1, oLootContainer, -1, iDifficulty, iOverrideMaxMagicLevel);
|
|
continue;
|
|
}
|
|
// Small Shield
|
|
iCheck += CI_LGS_LOOT_SHIELD_SMALL;
|
|
if (CI_LGS_LOOT_SHIELD_SMALL != 0 && iChance <= iCheck)
|
|
{
|
|
lgs_CreateItemOnTarget(-1, -1, BASE_ITEM_SMALLSHIELD, oLootContainer, -1, iDifficulty, iOverrideMaxMagicLevel);
|
|
continue;
|
|
}
|
|
// Large Shield
|
|
iCheck += CI_LGS_LOOT_SHIELD_LARGE;
|
|
if (CI_LGS_LOOT_SHIELD_LARGE != 0 && iChance <= iCheck)
|
|
{
|
|
lgs_CreateItemOnTarget(-1, -1, BASE_ITEM_LARGESHIELD, oLootContainer, -1, iDifficulty, iOverrideMaxMagicLevel);
|
|
continue;
|
|
}
|
|
// Tower Shield
|
|
iCheck += CI_LGS_LOOT_SHIELD_TOWER;
|
|
if (CI_LGS_LOOT_SHIELD_TOWER != 0 && iChance <= iCheck)
|
|
{
|
|
lgs_CreateItemOnTarget(-1, -1, BASE_ITEM_TOWERSHIELD, oLootContainer, -1, iDifficulty, iOverrideMaxMagicLevel);
|
|
continue;
|
|
}
|
|
// Helmet
|
|
iCheck += CI_LGS_LOOT_HELMET;
|
|
if (CI_LGS_LOOT_HELMET != 0 && iChance <= iCheck)
|
|
{
|
|
lgs_CreateItemOnTarget(-1, CI_EGS_ITEM_SUB_ARMOR_HELMET, -1, oLootContainer, -1, iDifficulty, iOverrideMaxMagicLevel);
|
|
continue;
|
|
}
|
|
// Weapon Melee
|
|
iCheck += CI_LGS_LOOT_WEAPON_MELEE;
|
|
if (CI_LGS_LOOT_WEAPON_MELEE != 0 && iChance <= iCheck)
|
|
{
|
|
lgs_CreateItemOnTarget(-1, CI_EGS_ITEM_SUB_WEAPON_MELEE, -1, oLootContainer, -1, iDifficulty, iOverrideMaxMagicLevel, FALSE, FALSE, iSize);
|
|
continue;
|
|
}
|
|
// Weapon Ranged
|
|
iCheck += CI_LGS_LOOT_WEAPON_RANGED;
|
|
if (CI_LGS_LOOT_WEAPON_RANGED != 0 && iChance <= iCheck)
|
|
{
|
|
lgs_CreateItemOnTarget(-1, CI_EGS_ITEM_SUB_WEAPON_RANGED, -1, oLootContainer, -1, iDifficulty, iOverrideMaxMagicLevel, FALSE, FALSE, iSize);
|
|
continue;
|
|
}
|
|
// Weapon Thrown
|
|
iCheck += CI_LGS_LOOT_WEAPON_THROWN;
|
|
if (CI_LGS_LOOT_WEAPON_THROWN != 0 && iChance <= iCheck)
|
|
{
|
|
oCreatedLoot = lgs_CreateItemOnTarget(-1, CI_EGS_ITEM_SUB_WEAPON_THROWN, -1, oLootContainer, -1, iDifficulty, iOverrideMaxMagicLevel, FALSE, FALSE, iSize);
|
|
SetItemStackSize(oCreatedLoot, Random(30) + 15);
|
|
continue;
|
|
}
|
|
// Ammunition
|
|
iCheck += CI_LGS_LOOT_AMMO;
|
|
if (CI_LGS_LOOT_AMMO != 0 && iChance <= iCheck)
|
|
{
|
|
oCreatedLoot = lgs_CreateItemOnTarget(CI_EGS_ITEM_MAIN_AMMO, -1, -1, oLootContainer, -1, iDifficulty, iOverrideMaxMagicLevel);
|
|
SetItemStackSize(oCreatedLoot, Random(50) + 30);
|
|
continue;
|
|
}
|
|
// Ring
|
|
iCheck += CI_LGS_LOOT_JEWELRY_RING;
|
|
if (CI_LGS_LOOT_JEWELRY_RING != 0 && iChance <= iCheck)
|
|
{
|
|
lgs_CreateItemOnTarget(-1, -1, BASE_ITEM_RING, oLootContainer, -1, iDifficulty, iOverrideMaxMagicLevel);
|
|
continue;
|
|
}
|
|
// Amulet
|
|
iCheck += CI_LGS_LOOT_JEWELRY_AMULET;
|
|
if (CI_LGS_LOOT_JEWELRY_AMULET != 0 && iChance <= iCheck)
|
|
{
|
|
lgs_CreateItemOnTarget(-1, -1, BASE_ITEM_AMULET, oLootContainer, -1, iDifficulty, iOverrideMaxMagicLevel);
|
|
continue;
|
|
}
|
|
// Bracers
|
|
iCheck += CI_LGS_LOOT_ACCESSORY_BRACERS;
|
|
if (CI_LGS_LOOT_ACCESSORY_BRACERS != 0 && iChance <= iCheck)
|
|
{
|
|
iSubSelection = Random(2);
|
|
switch (iSubSelection)
|
|
{
|
|
case 0: lgs_CreateItemOnTarget(-1, -1, BASE_ITEM_BRACER, oLootContainer, -1, iDifficulty, iOverrideMaxMagicLevel); break;
|
|
case 1: lgs_CreateItemOnTarget(-1, -1, BASE_ITEM_BRACER_SHIELD, oLootContainer, -1, iDifficulty, iOverrideMaxMagicLevel); break;
|
|
}
|
|
continue;
|
|
}
|
|
// Gloves
|
|
iCheck += CI_LGS_LOOT_ACCESSORY_GLOVES;
|
|
if (CI_LGS_LOOT_ACCESSORY_GLOVES != 0 && iChance <= iCheck)
|
|
{
|
|
lgs_CreateItemOnTarget(-1, -1, BASE_ITEM_GLOVES, oLootContainer, -1, iDifficulty, iOverrideMaxMagicLevel);
|
|
continue;
|
|
}
|
|
// Belt
|
|
iCheck += CI_LGS_LOOT_ACCESSORY_BELT;
|
|
if (CI_LGS_LOOT_ACCESSORY_BELT != 0 && iChance <= iCheck)
|
|
{
|
|
lgs_CreateItemOnTarget(-1, -1, BASE_ITEM_BELT, oLootContainer, -1, iDifficulty, iOverrideMaxMagicLevel);
|
|
continue;
|
|
}
|
|
// Cloak
|
|
iCheck += CI_LGS_LOOT_ACCESSORY_CLOAK;
|
|
if (CI_LGS_LOOT_ACCESSORY_CLOAK != 0 && iChance <= iCheck)
|
|
{
|
|
lgs_CreateItemOnTarget(-1, -1, BASE_ITEM_CLOAK, oLootContainer, -1, iDifficulty, iOverrideMaxMagicLevel);
|
|
continue;
|
|
}
|
|
// Boots
|
|
iCheck += CI_LGS_LOOT_ACCESSORY_BOOTS;
|
|
if (CI_LGS_LOOT_ACCESSORY_BOOTS != 0 && iChance <= iCheck)
|
|
{
|
|
lgs_CreateItemOnTarget(-1, -1, BASE_ITEM_BOOTS, oLootContainer, -1, iDifficulty, iOverrideMaxMagicLevel);
|
|
continue;
|
|
}
|
|
// Scroll
|
|
iCheck += CI_LGS_LOOT_SCROLL;
|
|
if (CI_LGS_LOOT_SCROLL != 0 && iChance <= iCheck)
|
|
{
|
|
int iScrollLevel = (iDifficulty / 2) - 1;
|
|
if (iScrollLevel > 9)
|
|
{
|
|
iScrollLevel = 9;
|
|
}
|
|
else if (iScrollLevel < 0)
|
|
{
|
|
iScrollLevel = 0;
|
|
}
|
|
|
|
object oScroll = CreateItemOnObject(ip_GetRandomScroll(iScrollLevel), oLootContainer);
|
|
SetDroppableFlag(oScroll, TRUE);
|
|
|
|
int iIdentified = FALSE;
|
|
if (d100(1) <= CI_LGS_CHANCE_LOOT_IDENTIFIED)
|
|
iIdentified = TRUE;
|
|
|
|
SetIdentified(oScroll, iIdentified);
|
|
continue;
|
|
}
|
|
// Book
|
|
iCheck += CI_LGS_LOOT_BOOK;
|
|
if (CI_LGS_LOOT_BOOK != 0 && iChance <= iCheck)
|
|
{
|
|
lgs_CreateItemOnTarget(-1, -1, BASE_ITEM_BOOK, oLootContainer, -1, iDifficulty, iOverrideMaxMagicLevel, TRUE);
|
|
continue;
|
|
}
|
|
// Potion
|
|
iCheck += CI_LGS_LOOT_POTION;
|
|
if (CI_LGS_LOOT_POTION != 0 && iChance <= iCheck)
|
|
{
|
|
lgs_CreateItemOnTarget(-1, -1, BASE_ITEM_POTIONS, oLootContainer, -1, iDifficulty, iOverrideMaxMagicLevel, TRUE);
|
|
continue;
|
|
}
|
|
// Wand
|
|
iCheck += CI_LGS_LOOT_WAND;
|
|
if (CI_LGS_LOOT_WAND != 0 && iChance <= iCheck)
|
|
{
|
|
lgs_CreateItemOnTarget(CI_EGS_ITEM_MAIN_RODWAND, -1, -1, oLootContainer, -1, iDifficulty, iOverrideMaxMagicLevel, TRUE);
|
|
continue;
|
|
}
|
|
// Medkit
|
|
iCheck += CI_LGS_LOOT_MEDKIT;
|
|
if (CI_LGS_LOOT_MEDKIT != 0 && iChance <= iCheck)
|
|
{
|
|
lgs_CreateItemOnTarget(-1, -1, BASE_ITEM_HEALERSKIT, oLootContainer, -1, iDifficulty, iOverrideMaxMagicLevel, TRUE);
|
|
continue;
|
|
}
|
|
// Trapkit
|
|
iCheck += CI_LGS_LOOT_TRAPKIT;
|
|
if (CI_LGS_LOOT_TRAPKIT != 0 && iChance <= iCheck)
|
|
{
|
|
lgs_CreateItemOnTarget(-1, -1, BASE_ITEM_TRAPKIT, oLootContainer, -1, iDifficulty, iOverrideMaxMagicLevel, TRUE);
|
|
continue;
|
|
}
|
|
// Thieve's Tools
|
|
iCheck += CI_LGS_LOOT_THIEVESTOOLS;
|
|
if (CI_LGS_LOOT_THIEVESTOOLS != 0 && iChance <= iCheck)
|
|
{
|
|
lgs_CreateItemOnTarget(-1, -1, BASE_ITEM_THIEVESTOOLS, oLootContainer, -1, iDifficulty, iOverrideMaxMagicLevel, TRUE);
|
|
continue;
|
|
}
|
|
// Container
|
|
iCheck += CI_LGS_LOOT_CONTAINER;
|
|
if (CI_LGS_LOOT_CONTAINER != 0 && iChance <= iCheck)
|
|
{
|
|
lgs_CreateItemOnTarget(CI_EGS_ITEM_MAIN_CONTAINER, -1, -1, oLootContainer, -1, iDifficulty, iOverrideMaxMagicLevel);
|
|
continue;
|
|
}
|
|
// Misc
|
|
iCheck += CI_LGS_LOOT_MISC;
|
|
if (CI_LGS_LOOT_MISC != 0 && iChance <= iCheck)
|
|
{
|
|
lgs_CreateItemOnTarget(CI_EGS_ITEM_MAIN_MISC, -1, -1, oLootContainer, -1, iDifficulty, iOverrideMaxMagicLevel, FALSE, TRUE);
|
|
continue;
|
|
}
|
|
// Bomb
|
|
iCheck += CI_LGS_LOOT_BOMB;
|
|
if (CI_LGS_LOOT_BOMB != 0 && iChance <= iCheck)
|
|
{
|
|
lgs_CreateItemOnTarget(CI_EGS_ITEM_MAIN_BOMB, -1, -1, oLootContainer, -1, iDifficulty, iOverrideMaxMagicLevel, FALSE, TRUE);
|
|
continue;
|
|
}
|
|
// Food
|
|
iCheck += CI_LGS_LOOT_FOOD;
|
|
if (CI_LGS_LOOT_FOOD != 0 && iChance <= iCheck)
|
|
{
|
|
lgs_CreateItemOnTarget(CI_EGS_ITEM_MAIN_FOOD, -1, -1, oLootContainer, -1, iDifficulty, iOverrideMaxMagicLevel, FALSE, TRUE);
|
|
continue;
|
|
}
|
|
}
|
|
}
|