mmo-ref/gdle
1
0
Fork 0
mirror of https://gitlab.com/Scribble/gdlenhanced.git synced 2026-08-17 14:23:04 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions
gdle/Source/Monster.cpp
Patrick Baggett 09248f8fee Correctly set random heritage group.
2020-09-27 15:36:43 +00:00

3204 lines
89 KiB
C++
Raw Permalink Blame History

#include <StdAfx.h>
#include "WeenieObject.h"
#include "AllegianceManager.h"
#include "Monster.h"
#include "World.h"
#include "GameMode.h"
#include "Lifestone.h"
#include "ChatMsgs.h"
#include "SpellProjectile.h"
#include "MonsterAI.h"
#include "WeenieFactory.h"
#include "InferredPortalData.h"
#include "ObjectMsgs.h"
#include "EmoteManager.h"
#include "Corpse.h"
#include "AttackManager.h"
#include "WClassID.h"
#include "InferredPortalData.h"
#include "Config.h"
#include "DatabaseIO.h"
#include "InferredPortalData.h"
#include "SpellTableExtendedData.h"
#include "Door.h"
#include "Player.h"
#include "House.h"
#include <chrono>
CMonsterWeenie::CMonsterWeenie()
{
SetItemType(TYPE_CREATURE);
m_Qualities.SetInt(LEVEL_INT, 1);
m_Qualities.SetAttribute(STRENGTH_ATTRIBUTE, 100);
m_Qualities.SetAttribute(ENDURANCE_ATTRIBUTE, 100);
m_Qualities.SetAttribute(COORDINATION_ATTRIBUTE, 100);
m_Qualities.SetAttribute(QUICKNESS_ATTRIBUTE, 100);
m_Qualities.SetAttribute(FOCUS_ATTRIBUTE, 100);
m_Qualities.SetAttribute(SELF_ATTRIBUTE, 100);
m_Qualities.SetAttribute2nd(MAX_HEALTH_ATTRIBUTE_2ND, 0);
m_Qualities.SetAttribute2nd(HEALTH_ATTRIBUTE_2ND, 50);
m_Qualities.SetAttribute2nd(MAX_STAMINA_ATTRIBUTE_2ND, 0);
m_Qualities.SetAttribute2nd(STAMINA_ATTRIBUTE_2ND, 100);
m_Qualities.SetAttribute2nd(MAX_MANA_ATTRIBUTE_2ND, 0);
m_Qualities.SetAttribute2nd(MANA_ATTRIBUTE_2ND, 100);
m_Qualities.SetInt(SHOWABLE_ON_RADAR_INT, ShowAlways_RadarEnum);
m_Qualities.SetBool(STUCK_BOOL, TRUE);
m_Qualities.SetBool(ATTACKABLE_BOOL, TRUE);
m_Qualities.SetInt(ITEM_USEABLE_INT, USEABLE_NO);
m_Qualities.SetFloat(HEARTBEAT_INTERVAL_FLOAT, DEFAULT_HEARTBEAT_INTERVAL);
_nextHeartBeat = Timer::cur_time + DEFAULT_HEARTBEAT_INTERVAL;
}
CMonsterWeenie::~CMonsterWeenie()
{
SafeDelete(m_MonsterAI);
}
void CMonsterWeenie::ApplyQualityOverrides()
{
int group = 1;
int gender = 1;
if (!m_Qualities.InqInt(HERITAGE_GROUP_INT, group))
{
int species = 0;
if (m_Qualities.InqInt(CREATURE_TYPE_INT, species) && species == CreatureType::human)
{
group = Random::GenInt(1, 4);
m_Qualities.SetInt(HERITAGE_GROUP_INT, group);
}
else
return;
}
if (!m_Qualities.InqInt(GENDER_INT, gender))
{
std::string sex;
if (!m_Qualities.InqString(SEX_STRING, sex))
return;
if (sex == "Male") gender = 1;
else if (sex == "Female") gender = 2;
m_Qualities.SetInt(GENDER_INT, gender);
}
HeritageGroup_CG *heritage = CachedCharGenData->mHeritageGroupList.lookup(group);
Sex_CG *sex = heritage->mGenderList.lookup(gender);
uint32_t tmp = 0;
uint32_t tmp_default = 0;
int max = 0;
int idx = 0;
ObjDesc *desc = nullptr;
HairStyle_CG *hair = nullptr;
// hair/head
if (m_Qualities.InqDataID(HEAD_OBJECT_DID, tmp))
{
hair = sex->FindHairStyle(tmp);
}
else
{
max = sex->mHairStyleList.num_used / 2;
idx = Random::GenInt(0, max);
hair = &(sex->mHairStyleList.array_data[idx]);
AnimPartChange *change = hair->objDesc.GetAnimPartChange(Head);
if (change)
m_Qualities.SetDataID(HEAD_OBJECT_DID, change->part_id);
}
// eyes
if (!m_Qualities.InqDataID(DEFAULT_EYES_TEXTURE_DID, tmp_default))
{
max = sex->mEyeStripList.num_used / 2;
idx = Random::GenInt(0, max);
EyesStrip_CG *eyes = &(sex->mEyeStripList.array_data[idx]);
desc = hair->bald ? &eyes->objDesc_Bald : &eyes->objDesc;
if (desc->firstTMChange)
{
m_Qualities.SetDataID(DEFAULT_EYES_TEXTURE_DID, desc->firstTMChange->old_tex_id);
m_Qualities.SetDataID(EYES_TEXTURE_DID, desc->firstTMChange->new_tex_id);
}
//if (desc->paletteID)
//{
//
//}
}
// nose
if (!m_Qualities.InqDataID(DEFAULT_NOSE_TEXTURE_DID, tmp_default))
{
max = sex->mNoseStripList.num_used / 2;
idx = Random::GenInt(0, max);
FaceStrip_CG *nose = &(sex->mNoseStripList.array_data[idx]);
desc = &nose->objDesc;
if (desc->firstTMChange)
{
m_Qualities.SetDataID(DEFAULT_NOSE_TEXTURE_DID, desc->firstTMChange->old_tex_id);
m_Qualities.SetDataID(NOSE_TEXTURE_DID, desc->firstTMChange->new_tex_id);
}
}
// mouth
if (!m_Qualities.InqDataID(DEFAULT_MOUTH_TEXTURE_DID, tmp_default))
{
max = sex->mMouthStripList.num_used / 2;
idx = Random::GenInt(0, max);
FaceStrip_CG *mouth = &(sex->mMouthStripList.array_data[idx]);
desc = &mouth->objDesc;
if (desc->firstTMChange)
{
m_Qualities.SetDataID(DEFAULT_MOUTH_TEXTURE_DID, desc->firstTMChange->old_tex_id);
m_Qualities.SetDataID(MOUTH_TEXTURE_DID, desc->firstTMChange->new_tex_id);
}
}
//uint32_t skin_palette_id;
//if (m_Qualities.InqDataID(SKIN_PALETTE_DID, skin_palette_id))
// objDesc.AddSubpalette(new Subpalette(skin_palette_id, 0 << 3, 0x18 << 3));
//uint32_t hair_palette_id;
//if (m_Qualities.InqDataID(HAIR_PALETTE_DID, hair_palette_id))
// objDesc.AddSubpalette(new Subpalette(hair_palette_id, 0x18 << 3, 0x8 << 3));
//uint32_t eye_palette_id;
//if (m_Qualities.InqDataID(EYES_PALETTE_DID, eye_palette_id))
// objDesc.AddSubpalette(new Subpalette(eye_palette_id, 0x20 << 3, 0x8 << 3));
}
void CMonsterWeenie::PreSpawnCreate()
{
if (m_Qualities._create_list)
g_pWeenieFactory->AddFromCreateList(this, m_Qualities._create_list, (DestinationType)(Wield_DestinationType | WieldTreasure_DestinationType));
if (uint32_t wieldedTreasureType = InqDIDQuality(WIELDED_TREASURE_TYPE_DID, 0))
g_pWeenieFactory->GenerateFromTypeOrWcid(this, DestinationType::WieldTreasure_DestinationType, wieldedTreasureType);
if (m_Qualities.GetDID(PHYSICS_SCRIPT_DID, 0))
{
// Add one here or else the wrong script will play. e.g. Frost Breath for Olthoi and Sewer Rats instead of Acid Breath.
m_DefaultScript = m_Qualities.GetDID(PHYSICS_SCRIPT_DID, 0);
m_DefaultScriptIntensity = m_Qualities.GetFloat(PHYSICS_SCRIPT_INTENSITY_FLOAT, 1.0);
}
}
void CMonsterWeenie::PostSpawn()
{
CWeenieObject::PostSpawn();
// check if we need to create a monster AI
if (IsCreature() && !AsPlayer() && !IsVendor() && m_Qualities.GetInt(PLAYER_KILLER_STATUS_INT, 0) != RubberGlue_PKStatus)
{
m_MonsterAI = new MonsterAIManager(this, m_Position);
}
if (!_IsPlayer())
{
EmitEffect(PS_Create, 1.0f);
}
}
CWeenieObject *CMonsterWeenie::SpawnWielded(uint32_t index, SmartArray<Style_CG> possibleStyles, uint32_t color, SmartArray<uint32_t> validColors, double shade)
{
index = max(min(index, (uint32_t)possibleStyles.num_used - 1), (uint32_t)0);
shade = max(min(shade, 1.0), 0.0);
uint32_t wcid = possibleStyles.array_data[index].weenieDefault;
uint32_t clothingTable = possibleStyles.array_data[index].clothingTable;
bool validColor = false;
for (int i = 0; i < validColors.num_used; i++)
{
if (color == validColors.array_data[i])
{
validColor = true;
break;
}
}
if (!validColor)
color = validColors.array_data[0];
CWeenieObject *weenie = SpawnWielded(wcid, color, shade);
weenie->m_Qualities.SetDataID(CLOTHINGBASE_DID, clothingTable);
return weenie;
}
CWeenieObject *CMonsterWeenie::SpawnWielded(uint32_t wcid, int ptid, float shade)
{
CWeenieObject *item = g_pWeenieFactory->CreateWeenieByClassID(wcid, NULL, false);
if (ptid)
item->m_Qualities.SetInt(PALETTE_TEMPLATE_INT, ptid);
if (shade > 0.0)
item->m_Qualities.SetFloat(SHADE_FLOAT, shade);
return SpawnWielded(item);
}
CWeenieObject *CMonsterWeenie::SpawnWielded(CWeenieObject *item, bool deleteItemOnFailure)
{
if (!item)
return NULL;
if (!item->IsEquippable())
{
LOG_PRIVATE(Temp, Warning, "Trying to SpawnWielded an unwieldable item %u\n", item->m_Qualities.id);
delete item;
return NULL;
}
item->SetID(g_pWorld->GenerateGUID(m_Qualities.GetInt(HERITAGE_GROUP_INT, 0) == 0 ? eEphemeral : eDynamicGUID));
if (!g_pWorld->CreateEntity(item, false))
{
//delete item;
return NULL;
}
if (!FinishMoveItemToWield(item, item->m_Qualities.GetInt(LOCATIONS_INT, 0)))
{
g_pWorld->RemoveEntity(item);
item = NULL;
}
return item;
}
CWeenieObject *CMonsterWeenie::FindValidNearbyItem(uint32_t itemId, float maxDistance)
{
//do we have it?
CWeenieObject *item = FindContainedItem(itemId);
if (!item)
{
// maybe it's in an external container
if (_lastOpenedRemoteContainerId != 0)
{
CContainerWeenie *externalContainer = FindContainer(_lastOpenedRemoteContainerId);
if (externalContainer && externalContainer->_openedById == GetID())
{
item = externalContainer->FindContainedItem(itemId);
}
}
if (!item)
{
// maybe it's on the ground
item = g_pWorld->FindObject(itemId, false, true);
if (!item || item->HasOwner() || !item->InValidCell())
{
NotifyInventoryFailedEvent(itemId, WERROR_OBJECT_GONE);
return NULL;
}
if (DistanceTo(item, true) > maxDistance)
{
NotifyInventoryFailedEvent(itemId, WERROR_TOO_FAR);
return NULL;;
}
}
}
if (!item->CanPickup())
{
NotifyInventoryFailedEvent(itemId, WERROR_NONE);
return NULL;
}
return item;
}
CContainerWeenie *CMonsterWeenie::FindValidNearbyContainer(uint32_t containerId, float maxDistance)
{
//do we have it?
CContainerWeenie *container = FindContainer(containerId);
if (!container)
{
// maybe it's in the external container
if (_lastOpenedRemoteContainerId != 0)
{
CContainerWeenie *externalContainer = FindContainer(_lastOpenedRemoteContainerId);
if (externalContainer && externalContainer->_openedById == GetID())
container = externalContainer->FindContainer(containerId);
}
if (!container)
{
// maybe it's on the ground
CWeenieObject *object = g_pWorld->FindObject(containerId);
if (!object)
{
NotifyInventoryFailedEvent(containerId, WERROR_OBJECT_GONE);
return NULL;
}
container = object->AsContainer();
if (!container || container->HasOwner() || !container->InValidCell())
{
NotifyInventoryFailedEvent(containerId, WERROR_OBJECT_GONE);
return NULL;
}
if (DistanceTo(container, true) > maxDistance)
{
NotifyInventoryFailedEvent(containerId, WERROR_TOO_FAR);
return NULL;;
}
}
}
if (container->GetID() != GetID() && container->IsCreature())
{
NotifyInventoryFailedEvent(containerId, WERROR_NONE);
return NULL;
}
return container;
}
bool CMonsterWeenie::GetEquipPlacementAndHoldLocation(CWeenieObject *item, uint32_t location, uint32_t *pPlacementFrame, uint32_t *pHoldLocation)
{
if (location & (MELEE_WEAPON_LOC | TWO_HANDED_LOC))
{
int leftTethered = 0;
if (item->m_Qualities.InqBool(AUTOWIELD_LEFT_BOOL, leftTethered) && leftTethered == 1)
{
*pPlacementFrame = Placement::LeftHand;
*pHoldLocation = PARENT_LEFT_HAND;
}
else
{
*pPlacementFrame = Placement::RightHandCombat;
*pHoldLocation = PARENT_RIGHT_HAND;
}
}
else if (location & MISSILE_WEAPON_LOC)
{
int combatStyle = item->InqIntQuality(DEFAULT_COMBAT_STYLE_INT, 0);
if (combatStyle == ThrownWeapon_CombatStyle || combatStyle == Atlatl_CombatStyle)
{
*pPlacementFrame = Placement::RightHandCombat;
*pHoldLocation = PARENT_RIGHT_HAND;
}
else
{
*pPlacementFrame = Placement::LeftHand;
*pHoldLocation = PARENT_LEFT_HAND;
}
}
else if (location & SHIELD_LOC)
{
if (item->InqIntQuality(LOCATIONS_INT, 0, TRUE) != SHIELD_LOC)
{
int combatStyle = item->InqIntQuality(DEFAULT_COMBAT_STYLE_INT, 0);
*pPlacementFrame = Placement::LeftWeapon;
*pHoldLocation = (combatStyle == Unarmed_CombatStyle) ? PARENT_LEFT_HAND : PARENT_LEFT_WEAPON;
}
else
{
*pPlacementFrame = Placement::Shield;
*pHoldLocation = PARENT_SHIELD;
}
}
else if (location & HELD_LOC)
{
*pPlacementFrame = Placement::RightHandCombat;
*pHoldLocation = PARENT_RIGHT_HAND;
}
else if (location & MISSILE_AMMO_LOC)
{
//*pPlacementFrame = Placement::RightHandCombat;
//*pHoldLocation = PARENT_RIGHT_HAND;
*pPlacementFrame = 0;
*pHoldLocation = 0;
}
else if (location & (ARMOR_LOC | CLOTHING_LOC))
{
*pPlacementFrame = 0;
*pHoldLocation = 0;
return false;
}
else
{
// LOG(Temp, Normal, "Trying to place %s but don't know how with coverage 0x%08X\n", item->GetName().c_str(), location);
*pPlacementFrame = 0;
*pHoldLocation = 0;
return false;
}
return true;
}
BYTE CMonsterWeenie::GetEnchantmentSerialByteForMask(int priority)
{
if (!priority)
return 0;
for (uint32_t i = 0; i < 32; i++)
{
if (priority & 1)
return i + 1;
priority >>= 1;
}
return 0;
}
int CMonsterWeenie::CheckWieldRequirements(CWeenieObject *item, CWeenieObject *wielder, STypeInt requirementStat, STypeInt skillStat, STypeInt difficultyStat)
{
int requirementType = item->InqIntQuality(requirementStat, 0, TRUE);
if (!requirementType)
return WERROR_NONE;
int skillType = item->InqIntQuality(skillStat, 0, TRUE);
int wieldDifficulty = item->InqIntQuality(difficultyStat, 0, TRUE);
switch (requirementType)
{
case 1: // skill
{
uint32_t skillLevel = 0;
if (!wielder->m_Qualities.InqSkill((STypeSkill)skillType, skillLevel, FALSE) || (int)skillLevel < wieldDifficulty)
return WERROR_SKILL_TOO_LOW;
break;
}
case 2: // base skill
{
uint32_t skillLevel = 0;
if (!wielder->m_Qualities.InqSkill((STypeSkill)skillType, skillLevel, TRUE) || (int)skillLevel < wieldDifficulty)
return WERROR_SKILL_TOO_LOW;
break;
}
case 3: // attribute
{
uint32_t skillLevel = 0;
if (!wielder->m_Qualities.InqAttribute((STypeAttribute)skillType, skillLevel, FALSE) || (int)skillLevel < wieldDifficulty)
return WERROR_ACTIVATION_SKILL_TOO_LOW;
break;
}
case 4: // base attribute
{
uint32_t skillLevel = 0;
if (!wielder->m_Qualities.InqAttribute((STypeAttribute)skillType, skillLevel, TRUE) || (int)skillLevel < wieldDifficulty)
return WERROR_ACTIVATION_SKILL_TOO_LOW;
break;
}
case 5: // attribute 2nd
{
uint32_t skillLevel = 0;
if (!wielder->m_Qualities.InqAttribute2nd((STypeAttribute2nd)skillType, skillLevel, FALSE) || (int)skillLevel < wieldDifficulty)
return WERROR_ACTIVATION_SKILL_TOO_LOW;
break;
}
case 6: // attribute 2nd base
{
uint32_t skillLevel = 0;
if (!wielder->m_Qualities.InqAttribute2nd((STypeAttribute2nd)skillType, skillLevel, TRUE) || (int)skillLevel < wieldDifficulty)
return WERROR_ACTIVATION_SKILL_TOO_LOW;
break;
}
case 7: // level
{
if (wielder->InqIntQuality(LEVEL_INT, 1, TRUE) < wieldDifficulty)
return WERROR_LEVEL_TOO_LOW;
break;
}
case 8: // skill advancement class
{
SKILL_ADVANCEMENT_CLASS sac = SKILL_ADVANCEMENT_CLASS::UNDEF_SKILL_ADVANCEMENT_CLASS;
if (!wielder->m_Qualities.InqSkillAdvancementClass((STypeSkill)skillType, sac) || (int)sac < wieldDifficulty)
return WERROR_ACTIVATION_NOT_SPECIALIZED;
break;
}
case 9: // faction
{
return WERROR_NONE; //todo
}
case 10: // unknown
{
return WERROR_NONE; //todo
}
case 11: // type
{
if (wielder->InqIntQuality(CREATURE_TYPE_INT, 0, TRUE) != wieldDifficulty)
return WERROR_ACTIVATION_WRONG_RACE;
break;
}
case 12: // race
{
if (wielder->InqIntQuality(HERITAGE_GROUP_INT, 0, TRUE) != wieldDifficulty)
return WERROR_ACTIVATION_WRONG_RACE;
break;
}
}
return WERROR_NONE;
}
bool CMonsterWeenie::MoveItemToContainer(uint32_t sourceItemId, uint32_t targetContainerId, uint32_t targetSlot, bool animationDone)
{
if (!animationDone && IsBusyOrInAction())
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_ACTIONS_LOCKED);
return false;
}
CWeenieObject *sourceItem = FindValidNearbyItem(sourceItemId, USEDISTANCE_FAR);
if (!sourceItem)
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_OBJECT_GONE);
return false;
}
CContainerWeenie *targetContainer = FindValidNearbyContainer(targetContainerId, USEDISTANCE_FAR);
if (!targetContainer || targetContainer->IsCorpse() || !targetContainer->Container_CanStore(sourceItem))
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_OBJECT_GONE);
return false;
}
if (sourceItem->IsAttunedOrContainsAttuned() && targetContainer->GetTopLevelID() != GetID())
{
NotifyInventoryFailedEvent(sourceItem->id, WERROR_ATTUNED_ITEM);
return false;
}
uint32_t freezer = sourceItem->InqIIDQuality(FREEZER_IID, 0);
if (freezer != 0 && freezer != GetID())
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_FROZEN);
return false;
}
sourceItem->m_Qualities.SetInstanceID(FREEZER_IID, GetID());
bool isExternalTargetContainer = (targetContainer->GetTopLevelID() != GetID());
if (!animationDone && (!FindContainedItem(sourceItem->GetID()) || isExternalTargetContainer))
{
//from ground or external container or to external container.
CPickupInventoryUseEvent *pickupEvent = new CPickupInventoryUseEvent();
pickupEvent->_target_id = sourceItemId;
pickupEvent->_source_item_id = sourceItemId;
pickupEvent->_target_container_id = targetContainerId;
pickupEvent->_target_slot = targetSlot;
ExecuteUseEvent(pickupEvent);
}
else
{
//from our inventory or have already done the animation.
FinishMoveItemToContainer(sourceItem, targetContainer, targetSlot);
}
return true;
}
void CMonsterWeenie::FinishMoveItemToContainer(CWeenieObject *sourceItem, CContainerWeenie *targetContainer, uint32_t targetSlot, bool bSendEvent, bool silent)
{
// Scenarios to consider:
// 1. Item being stored is equipped.
// 2. Item being stored is on the GROUND!
// 3. Item being stored is already in the inventory.
// 4. Item being stored is in an external container (chest) or being moved to an external container (chest)
bool wasWielded = sourceItem->IsWielded();
bool isPickup = sourceItem->GetWorldTopLevelOwner() != this;
uint32_t dwCell = GetLandcell();
//if (!sourceItem->HasOwner())
//{
if (CWeenieObject *generator = g_pWorld->FindObject(sourceItem->InqIIDQuality(GENERATOR_IID, 0)))
generator->NotifyGeneratedPickedUp(sourceItem);
//}
// Take it out of whatever slot it's in.
//if (sourceItem->m_Qualities.m_WeenieType == WeenieType::Caster_WeenieType || sourceItem->m_Qualities.m_WeenieType == WeenieType::Clothing_WeenieType ||
// sourceItem->m_Qualities.m_WeenieType == WeenieType::MeleeWeapon_WeenieType || sourceItem->m_Qualities.m_WeenieType == WeenieType::MissileLauncher_WeenieType ||
// sourceItem->m_Qualities.m_WeenieType == WeenieType::Missile_WeenieType)
//{
//}
if (sourceItem->GetItemType() & (TYPE_VESTEMENTS | TYPE_WEAPON_OR_CASTER))
{
sourceItem->ReleaseFromAnyWeenieParent(true, true);
}
else
{
sourceItem->ReleaseFromAnyWeenieParent(false, true);
}
sourceItem->SetWieldedLocation(INVENTORY_LOC::NONE_LOC);
sourceItem->SetWeenieContainer(targetContainer->GetID());
sourceItem->ReleaseFromBlock();
if(AsPlayer())
sourceItem->m_Qualities.SetInstanceID(OWNER_IID, GetID());
//store the current motion here for use later.
uint32_t oldmotion = get_minterp()->InqStyle();
// The container will auto-correct this slot into a valid range.
targetSlot = targetContainer->Container_InsertInventoryItem(dwCell, sourceItem, targetSlot);
if (!silent)
{
if (wasWielded)
EmitSound(Sound_UnwieldObject, 1.0f);
else
EmitSound(Sound_PickUpItem, 1.0f);
}
if (isPickup)
sourceItem->OnPickedUp(this);
if (bSendEvent)
{
if (sourceItem->AsContainer())
sourceItem->AsContainer()->MakeAwareViewContent(this);
SendNetMessage(InventoryMove(sourceItem->GetID(), targetContainer->GetID(), targetSlot, sourceItem->RequiresPackSlot() ? 1 : 0), PRIVATE_MSG, TRUE);
}
sourceItem->m_Qualities.SetInstanceID(FREEZER_IID, 0);
if (AsPlayer() && wasWielded)
{
int setId = 0;
if (sourceItem->m_Qualities.InqInt(EQUIPMENT_SET_ID_INT, setId))
{
AsPlayer()->UpdateSetSpells(setId, sourceItem->GetID());
}
if (sourceItem->IsAetheria())
{
AsPlayer()->UpdateSigilProcRate();
}
}
if (targetContainer->GetWorldTopLevelOwner() != this)
RecalculateEncumbrance();
if (sourceItem->GetItemType() & (TYPE_ARMOR | TYPE_CLOTHING))
{
if (m_Qualities.GetInt(HERITAGE_GROUP_INT, 1) != Gearknight_HeritageGroup) // TODO: Update JUST cloak on gearknight unequip rather than whole model.
UpdateModel();
}
// Checks the old motion vs Motion_NonCombat to prevent getting stuck while adjusting to the new combat style.
if (wasWielded && oldmotion != Motion_NonCombat)
AdjustToNewCombatMode();
if (AsPlayer() && sourceItem->m_Qualities.id == W_COINSTACK_CLASS)
RecalculateCoinAmount(W_COINSTACK_CLASS);
if (!sourceItem->m_Qualities.GetInt(LIFESPAN_INT, 0))
{
sourceItem->m_Qualities.RemoveFloat(TIME_TO_ROT_FLOAT);
sourceItem->_timeToRot = -1.0;
sourceItem->_beganRot = false;
}
}
bool CMonsterWeenie::MoveItemTo3D(uint32_t sourceItemId, bool animationDone)
{
// Scenarios to consider:
// 1. Item being stored is equipped.
// 3. Item being stored is in the inventory.
if (!animationDone && IsBusyOrInAction())
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_ACTIONS_LOCKED);
return false;
}
CWeenieObject *sourceItem = FindValidNearbyItem(sourceItemId, USEDISTANCE_FAR);
if (!sourceItem)
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_OBJECT_GONE);
return false;
}
if (sourceItem->IsAttunedOrContainsAttuned())
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_ATTUNED_ITEM);
return false;
}
uint32_t freezer = sourceItem->InqIIDQuality(FREEZER_IID, 0);
if (freezer != 0 && freezer != GetID())
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_FROZEN);
return false;
}
sourceItem->m_Qualities.SetInstanceID(FREEZER_IID, GetID());
if (!animationDone)
{
CDropInventoryUseEvent *dropEvent = new CDropInventoryUseEvent();
dropEvent->_target_id = sourceItemId;
ExecuteUseEvent(dropEvent);
}
else
{
FinishMoveItemTo3D(sourceItem);
}
return true;
}
void CMonsterWeenie::FinishMoveItemTo3D(CWeenieObject *sourceItem)
{
// Scenarios to consider:
// 1. Item being dropped is equipped.
// 3. Item being dropped is in the inventory.
BOOL bWasWielded = sourceItem->IsWielded();
//store the current motion here for use later.
uint32_t oldmotion = get_minterp()->InqStyle();
// Take it out of whatever slot it's in.
sourceItem->ReleaseFromAnyWeenieParent(false, true);
sourceItem->SetWeenieContainer(0);
sourceItem->SetWielderID(0);
sourceItem->SetWieldedLocation(INVENTORY_LOC::NONE_LOC);
EmitSound(Sound_DropItem, 1.0f);
SendNetMessage(InventoryDrop(sourceItem->GetID()), PRIVATE_MSG, TRUE);
sourceItem->m_Qualities.SetInt(PARENT_LOCATION_INT, 0);
sourceItem->unset_parent();
sourceItem->enter_world(&m_Position);
if (!sourceItem->m_Qualities.m_PositionStats)
sourceItem->m_Qualities.SetPosition(LOCATION_POSITION, m_Position);
sourceItem->SetPlacementFrame(0x65, FALSE);
//if (!pItem->HasAnims())
// pItem->SetPlacementFrame(pItem->CanPickup() ? 0x65 : 0, 1);
if (sourceItem->AsClothing())
{
if (m_Qualities.GetInt(HERITAGE_GROUP_INT, 1) != Gearknight_HeritageGroup) // TODO: Update JUST cloak on gearknight unequip rather than whole model.
UpdateModel();
}
g_pWorld->InsertEntity(sourceItem);
sourceItem->Movement_Teleport(GetPosition());
if (!sourceItem->m_Qualities.GetInt(LIFESPAN_INT, 0))
{
sourceItem->_timeToRot = Timer::cur_time + 300.0;
sourceItem->_beganRot = false;
sourceItem->m_Qualities.SetFloat(TIME_TO_ROT_FLOAT, sourceItem->_timeToRot);
}
RecalculateEncumbrance();
if (AsPlayer() && sourceItem->m_Qualities.id == W_COINSTACK_CLASS)
RecalculateCoinAmount(W_COINSTACK_CLASS);
// Checks the old motion vs Motion_NonCombat to prevent getting stuck while adjusting to the new combat style.
if (bWasWielded && oldmotion != Motion_NonCombat)
AdjustToNewCombatMode();
if (bWasWielded)
{
sourceItem->OnUnwield(this);
}
if(AsPlayer() && bWasWielded)
{
int setSpell;
if (sourceItem->m_Qualities.InqInt(EQUIPMENT_SET_ID_INT, setSpell))
{
AsPlayer()->UpdateSetSpells(setSpell, sourceItem->GetID());
}
if (sourceItem->IsAetheria())
{
AsPlayer()->UpdateSigilProcRate();
}
}
sourceItem->OnDropped(this);
sourceItem->m_Qualities.SetInstanceID(FREEZER_IID, 0);
sourceItem->m_bDontClear = false;
}
bool CMonsterWeenie::MoveItemToWield(uint32_t sourceItemId, uint32_t targetLoc, bool animationDone)
{
// Scenarios to consider:
// 1. Item being equipped from the GROUND!
// 2. Item being equipped from different equip slot.
// 3. Item being equipped from the player's inventory.
if (!animationDone && IsBusyOrInAction())
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_ACTIONS_LOCKED);
return false;
}
CWeenieObject *sourceItem = FindValidNearbyItem(sourceItemId, USEDISTANCE_FAR);
if (!sourceItem)
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_OBJECT_GONE);
return false;
}
if (!Container_CanEquip(sourceItem, targetLoc))
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_BE_WIELDED_FAILURE);
return false;
}
uint32_t freezer = sourceItem->InqIIDQuality(FREEZER_IID, 0);
if (freezer != 0 && freezer != GetID())
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_FROZEN);
return false;
}
sourceItem->m_Qualities.SetInstanceID(FREEZER_IID, GetID());
if (sourceItem->IsAetheria())
{
int aetheriaUnlock;
if (m_Qualities.InqInt(AETHERIA_BITFIELD_INT, aetheriaUnlock))
{
int aetheriaLevel;
if (sourceItem->m_Qualities.InqInt(WIELD_DIFFICULTY_INT, aetheriaLevel))
{
if (aetheriaLevel == 75 && !(aetheriaUnlock & 0x1))
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_BE_WIELDED_FAILURE);
return false;
}
else if (aetheriaLevel == 150 && !(aetheriaUnlock & 0x2))
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_BE_WIELDED_FAILURE);
return false;
}
else if (aetheriaLevel == 225 && !(aetheriaUnlock & 0x4))
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_BE_WIELDED_FAILURE);
return false;
}
}
}
else
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_BE_WIELDED_FAILURE);
return false;
}
}
if (!animationDone && !FindContainedItem(sourceItem->GetID()))
{
//from ground or external container.
CMoveToWieldInventoryUseEvent *pickupEvent = new CMoveToWieldInventoryUseEvent();
pickupEvent->_target_id = sourceItemId;
pickupEvent->_sourceItemId = sourceItemId;
pickupEvent->_targetLoc = targetLoc;
ExecuteUseEvent(pickupEvent);
}
else
{
//from our inventory or have already done the animation.
return FinishMoveItemToWield(sourceItem, targetLoc);
}
return true;
}
bool CMonsterWeenie::FinishMoveItemToWield(CWeenieObject *sourceItem, uint32_t targetLoc)
{
// Scenarios to consider:
// 1. Item being equipped from the GROUND!
// 2. Item being equipped from different equip slot.
// 3. Item being equipped from the player's inventory.
bool isPickup = sourceItem->GetWorldTopLevelOwner() != this;
if (AsPlayer())
{
int error = CheckWieldRequirements(sourceItem, this, WIELD_REQUIREMENTS_INT, WIELD_SKILLTYPE_INT, WIELD_DIFFICULTY_INT);
if (error != WERROR_NONE)
{
NotifyInventoryFailedEvent(sourceItem->GetID(), error);
return false;
}
error = CheckWieldRequirements(sourceItem, this, WIELD_REQUIREMENTS_2_INT, WIELD_SKILLTYPE_2_INT, WIELD_DIFFICULTY_2_INT);
if (error != WERROR_NONE)
{
NotifyInventoryFailedEvent(sourceItem->GetID(), error);
return false;
}
error = CheckWieldRequirements(sourceItem, this, WIELD_REQUIREMENTS_3_INT, WIELD_SKILLTYPE_3_INT, WIELD_DIFFICULTY_3_INT);
if (error != WERROR_NONE)
{
NotifyInventoryFailedEvent(sourceItem->GetID(), error);
return false;
}
error = CheckWieldRequirements(sourceItem, this, WIELD_REQUIREMENTS_4_INT, WIELD_SKILLTYPE_4_INT, WIELD_DIFFICULTY_4_INT);
if (error != WERROR_NONE)
{
NotifyInventoryFailedEvent(sourceItem->GetID(), error);
return false;
}
if (sourceItem->InqIIDQuality(ALLOWED_WIELDER_IID, 0) && sourceItem->InqIIDQuality(ALLOWED_WIELDER_IID, 0) != GetID())
{
NotifyInventoryFailedEvent(sourceItem->GetID(), WERROR_ATTUNED_ITEM);
return false;
}
if (sourceItem->InqIntQuality(HERITAGE_SPECIFIC_ARMOR_INT, 0) && sourceItem->InqIntQuality(HERITAGE_SPECIFIC_ARMOR_INT, 0) != m_Qualities.GetInt(HERITAGE_GROUP_INT, 1)) // Other heritages cannot wear gearknight armor.
{
NotifyInventoryFailedEvent(sourceItem->GetID(), WERROR_SPECIFIC_ARMOR_REQUIRES_HERITAGE);
return false;
}
if (m_Qualities.GetInt(HERITAGE_GROUP_INT, 1) == Gearknight_HeritageGroup && !sourceItem->InqIntQuality(HERITAGE_SPECIFIC_ARMOR_INT, 0) && sourceItem->m_Qualities.GetInt(LOCATIONS_INT, 0) < 0x8000) // Only restrict Armor, not weapons, cloaks, jewelry, trinkets, etc.
{
NotifyInventoryFailedEvent(sourceItem->GetID(), WERROR_HERITAGE_REQUIRES_SPECIFIC_ARMOR);
return false;
}
}
if (sourceItem->InqIntQuality(ITEM_TYPE_INT, 0) == TYPE_ARMOR && sourceItem->InqIntQuality(LOCATIONS_INT, 0) == SHIELD_LOC)
{
sourceItem->m_Qualities.SetInt(SHIELD_VALUE_INT, sourceItem->InqIntQuality(ARMOR_LEVEL_INT, 0));
}
//if (!sourceItem->HasOwner())
//{
if (CWeenieObject *generator = g_pWorld->FindObject(sourceItem->InqIIDQuality(GENERATOR_IID, 0)))
generator->NotifyGeneratedPickedUp(sourceItem);
//}
uint32_t cell_id = m_Position.objcell_id;
// Take it out of whatever slot it may be in
sourceItem->ReleaseFromAnyWeenieParent(false, false);
uint32_t placement_id, child_location_id;
bool bShouldPlace = GetEquipPlacementAndHoldLocation(sourceItem, targetLoc, &placement_id, &child_location_id);
sourceItem->SetWielderID(GetID());
sourceItem->SetWieldedLocation(targetLoc);
sourceItem->ReleaseFromBlock();
//store the current motion here for use later.
uint32_t oldmotion = get_minterp()->InqStyle();
// The container will auto-correct this slot into a valid range.
Container_EquipItem(cell_id, sourceItem, targetLoc, child_location_id, placement_id);
if (_IsPlayer())
{
SendNetMessage(InventoryEquip(sourceItem->GetID(), targetLoc), PRIVATE_MSG, TRUE);
EmitSound(Sound_WieldObject, 1.0f);
}
if (m_bWorldIsAware)
{
sourceItem->NotifyIIDStatUpdated(CONTAINER_IID, false);
sourceItem->NotifyIIDStatUpdated(WIELDER_IID, false);
sourceItem->NotifyIntStatUpdated(CURRENT_WIELDED_LOCATION_INT, false);
sourceItem->NotifyIntStatUpdated(PARENT_LOCATION_INT, false);
sourceItem->NotifyIntStatUpdated(PLACEMENT_POSITION_INT, false);
}
if (sourceItem->AsClothing() && m_bWorldIsAware)
{
if (m_Qualities.GetInt(HERITAGE_GROUP_INT, 1) != Gearknight_HeritageGroup) // TODO: Update JUST cloak on gearknight equip rather than whole model.
UpdateModel();
}
if (!sourceItem->m_Qualities.GetInt(LIFESPAN_INT, 0))
{
// Remove all loot items with wcid > g_pConfig->WcidForPurge()
if (g_pConfig->InventoryPurgeOnLogin())
{
if (sourceItem->m_Qualities.id > g_pConfig->WcidForPurge() && sourceItem->m_Qualities.GetInt(ITEM_WORKMANSHIP_INT, 0))
{
sourceItem->_timeToRot = Timer::cur_time;
sourceItem->_beganRot = true;
}
}
else
{
sourceItem->m_Qualities.RemoveFloat(TIME_TO_ROT_FLOAT);
sourceItem->_timeToRot = -1.0;
sourceItem->_beganRot = false;
}
}
// Checks the old motion vs Motion_NonCombat to prevent getting stuck while adjusting to the new combat style.
if (oldmotion != Motion_NonCombat)
AdjustToNewCombatMode();
// apply enchantments
if (sourceItem->m_Qualities._spell_book && _IsPlayer())
{
bool bShouldCast = true;
std::string name;
if (sourceItem->m_Qualities.InqString(CRAFTSMAN_NAME_STRING, name))
{
if (!name.empty() && name != InqStringQuality(NAME_STRING, ""))
{
bShouldCast = false;
NotifyWeenieErrorWithString(WERROR_ACTIVATION_NOT_CRAFTSMAN, name.c_str());
}
}
int difficulty;
difficulty = 0;
if (sourceItem->m_Qualities.InqInt(ITEM_DIFFICULTY_INT, difficulty, TRUE, FALSE))
{
uint32_t skillLevel = 0;
if (!m_Qualities.InqSkill(ARCANE_LORE_SKILL, skillLevel, FALSE) || (int)skillLevel < difficulty)
{
bShouldCast = false;
NotifyWeenieError(WERROR_ACTIVATION_ARCANE_LORE_TOO_LOW);
}
}
if (bShouldCast)
{
difficulty = 0;
uint32_t skillActivationTypeDID = 0;
if (sourceItem->m_Qualities.InqInt(ITEM_SKILL_LEVEL_LIMIT_INT, difficulty, TRUE, FALSE) && sourceItem->m_Qualities.InqDataID(ITEM_SKILL_LIMIT_DID, skillActivationTypeDID))
{
STypeSkill skillActivationType = SkillTable::OldToNewSkill((STypeSkill)skillActivationTypeDID);
uint32_t skillLevel = 0;
if (!m_Qualities.InqSkill(skillActivationType, skillLevel, FALSE) || (int)skillLevel < difficulty)
{
bShouldCast = false;
NotifyWeenieErrorWithString(WERROR_ACTIVATION_SKILL_TOO_LOW, CachedSkillTable->GetSkillName(skillActivationType).c_str());
}
}
}
if (bShouldCast && sourceItem->InqIntQuality(ITEM_ALLEGIANCE_RANK_LIMIT_INT, 0) > InqIntQuality(ALLEGIANCE_RANK_INT, 0))
{
bShouldCast = false;
NotifyInventoryFailedEvent(sourceItem->GetID(), WERROR_ACTIVATION_RANK_TOO_LOW);
}
if (bShouldCast)
{
int heritageRequirement = sourceItem->InqIntQuality(HERITAGE_GROUP_INT, -1);
if (heritageRequirement != -1 && heritageRequirement != InqIntQuality(HERITAGE_GROUP_INT, 0))
{
bShouldCast = false;
std::string heritageString = sourceItem->InqStringQuality(ITEM_HERITAGE_GROUP_RESTRICTION_STRING, "of the correct heritage");
NotifyWeenieErrorWithString(WERROR_ACTIVATION_WRONG_RACE, heritageString.c_str());
}
}
int currentMana = 0;
if (bShouldCast && sourceItem->m_Qualities.InqInt(ITEM_CUR_MANA_INT, currentMana, TRUE, FALSE))
{
if (currentMana == 0)
{
bShouldCast = false;
NotifyWeenieError(WERROR_ACTIVATION_NOT_ENOUGH_MANA);
}
else
sourceItem->_nextManaUse = Timer::cur_time;
}
if (bShouldCast)
{
uint32_t serial = 0;
serial |= ((uint32_t)GetEnchantmentSerialByteForMask(sourceItem->InqIntQuality(LOCATIONS_INT, 0, TRUE)) << (uint32_t)0);
serial |= ((uint32_t)GetEnchantmentSerialByteForMask(sourceItem->InqIntQuality(CLOTHING_PRIORITY_INT, 0, TRUE)) << (uint32_t)8);
uint32_t procspellid = sourceItem->InqDIDQuality(PROC_SPELL_DID, 0);
uint32_t spellid = sourceItem->InqDIDQuality(SPELL_DID, 0);
for (auto &spellPage : sourceItem->m_Qualities._spell_book->_spellbook)
{
//ignore the spell and don't cast if it's the Proc_spell_DID or the spell_DID
if (spellid != spellPage.first && procspellid != spellPage.first)
sourceItem->MakeSpellcastingManager()->CastSpellEquipped(GetID(), spellPage.first, (WORD)serial);
}
}
}
int setSpell;
if (AsPlayer() && sourceItem->m_Qualities.InqInt(EQUIPMENT_SET_ID_INT, setSpell))
{
AsPlayer()->UpdateSetSpells(setSpell, sourceItem->GetID());
if (sourceItem->IsAetheria())
{
if (AsPlayer())
{
AsPlayer()->UpdateSigilProcRate();
}
}
}
int gearRating;
for (int i = 370; i < 380; i++)
{
if (sourceItem->m_Qualities.InqInt((STypeInt)i, gearRating))
{
UpdateRatingFromGear((STypeInt)i, gearRating);
}
}
// Damage Rating for Weapon Mastery. Does not apply to quest weapons and loot without WEAPON_TYPE_INT
if (sourceItem->m_Qualities.GetInt(WEAPON_TYPE_INT, 0))
{
int ratingVal;
if (m_Qualities.InqInt(DAMAGE_RATING_INT, ratingVal, true))
{
m_Qualities.SetInt(DAMAGE_RATING_INT, ratingVal + 5);
NotifyIntStatUpdated(DAMAGE_RATING_INT);
}
}
sourceItem->m_Qualities.SetInstanceID(FREEZER_IID, GetID());
if (isPickup)
sourceItem->OnPickedUp(this);
sourceItem->OnWield(this);
return true;
}
void CMonsterWeenie::UpdateRatingFromGear(STypeInt rating, int gearRating)
{
m_Qualities.AdjInt(rating, gearRating);
NotifyIntStatUpdated(rating);
}
bool CMonsterWeenie::MergeItem(uint32_t sourceItemId, uint32_t targetItemId, uint32_t amountToTransfer, bool animationDone)
{
if (!animationDone && IsBusyOrInAction())
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_ACTIONS_LOCKED);
return false;
}
CWeenieObject *sourceItem = FindValidNearbyItem(sourceItemId, USEDISTANCE_FAR);
if (!sourceItem)
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_OBJECT_GONE);
return false;
}
CWeenieObject *targetItem = FindValidNearbyItem(targetItemId, USEDISTANCE_FAR);
if (!targetItem)
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_OBJECT_GONE);
return false;
}
uint32_t freezer = sourceItem->InqIIDQuality(FREEZER_IID, 0);
if (freezer != 0 && freezer != GetID())
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_FROZEN);
return false;
}
if (!animationDone && (!FindContainedItem(sourceItemId) || !FindContainedItem(targetItemId)))
{
sourceItem->m_Qualities.SetInstanceID(FREEZER_IID, GetID());
//from ground or other container or to ground or other container.
CStackMergeInventoryUseEvent *mergeEvent = new CStackMergeInventoryUseEvent();
if (sourceItem->IsContained() || sourceItem->IsWielded())
mergeEvent->_target_id = targetItemId;
else
mergeEvent->_target_id = sourceItemId;
mergeEvent->_sourceItemId = sourceItemId;
mergeEvent->_targetItemId = targetItemId;
mergeEvent->_amountToTransfer = amountToTransfer;
ExecuteUseEvent(mergeEvent);
}
else
{
//check if the items is still in range.
if (FindValidNearbyItem(sourceItemId, 5.0) == NULL || FindValidNearbyItem(targetItemId, 5.0) == NULL)
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_TOO_FAR);
return false;
}
if (sourceItem->m_Qualities.id != targetItem->m_Qualities.id)
{
NotifyInventoryFailedEvent(sourceItem->GetID(), WERROR_NONE);
return false;
}
uint32_t sourceCurrentAmount = sourceItem->InqIntQuality(STACK_SIZE_INT, 1);
if (amountToTransfer > sourceCurrentAmount)
{
NotifyInventoryFailedEvent(sourceItem->GetID(), WERROR_NONE);
return false;
}
uint32_t targetCurrentAmount = targetItem->InqIntQuality(STACK_SIZE_INT, 1);
uint32_t targetMaxStackSize = targetItem->InqIntQuality(MAX_STACK_SIZE_INT, 1);
int maxTransferAmount = targetMaxStackSize - targetCurrentAmount;
if (maxTransferAmount <= 0)
{
NotifyInventoryFailedEvent(sourceItem->GetID(), WERROR_NONE);
return false;
}
if (maxTransferAmount < amountToTransfer)
amountToTransfer = maxTransferAmount;
targetItem->SetStackSize(targetCurrentAmount + amountToTransfer);
bool wasSourceItemWielded = sourceItem->IsWielded();
bool wasTargetItemWielded = targetItem->IsWielded();
uint32_t sourceItemNewStackSize = sourceCurrentAmount - amountToTransfer;
if (sourceItemNewStackSize > 0) //partial stack movement
{
//the client seems to forget about the source item when merging using the "place selected object in inventory" keybind
//to split from a stack so we have to remind it. I don't know how we can determine when the client uses the keybind or dragging
//so just do it regarless.
MakeAware(sourceItem, true);
sourceItem->SetStackSize(sourceItemNewStackSize);
}
else //full stack movement
{
sourceItem->Remove();
}
sourceItem->m_Qualities.SetInstanceID(FREEZER_IID, 0);
if (wasSourceItemWielded)
EmitSound(Sound_UnwieldObject, 1.0f);
else if (wasTargetItemWielded)
EmitSound(Sound_WieldObject, 1.0f);
else if (!FindContainedItem(targetItemId)) //Todo: does placing items in external containers make the drop or pickup sound?
EmitSound(Sound_DropItem, 1.0f);
else
EmitSound(Sound_PickUpItem, 1.0f);
RecalculateEncumbrance();
if (AsPlayer() && sourceItem->m_Qualities.id == W_COINSTACK_CLASS)
RecalculateCoinAmount(W_COINSTACK_CLASS);
}
return true;
}
bool CMonsterWeenie::SplitItemToContainer(uint32_t sourceItemId, uint32_t targetContainerId, uint32_t targetSlot, uint32_t amountToTransfer, bool animationDone)
{
if (!animationDone && IsBusyOrInAction())
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_ACTIONS_LOCKED);
return false;
}
CWeenieObject *sourceItem = FindValidNearbyItem(sourceItemId, USEDISTANCE_FAR);
if (!sourceItem)
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_OBJECT_GONE);
return false;
}
if (sourceItem->m_Qualities.GetInt(MAX_STACK_SIZE_INT, 0) < 1)
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_ACTIONS_LOCKED);
return false;
}
CContainerWeenie *targetContainer = FindValidNearbyContainer(targetContainerId, USEDISTANCE_FAR);
if (!targetContainer || !targetContainer->Container_CanStore(sourceItem))
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_OBJECT_GONE);
return false;
}
bool isExternalTargetContainer = (targetContainer->GetTopLevelID() != GetID());
if (isExternalTargetContainer && sourceItem->IsAttunedOrContainsAttuned())
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_ATTUNED_ITEM);
return false;
}
if (!animationDone && (!FindContainedItem(sourceItemId) || isExternalTargetContainer))
{
//from ground or external container or to external container
CStackSplitToContainerInventoryUseEvent *mergeEvent = new CStackSplitToContainerInventoryUseEvent();
if (sourceItem->IsContained() || sourceItem->IsWielded())
mergeEvent->_target_id = targetContainerId;
else
mergeEvent->_target_id = sourceItemId;
mergeEvent->_sourceItemId = sourceItemId;
mergeEvent->_targetContainerId = targetContainerId;
mergeEvent->_targetSlot = targetSlot;
mergeEvent->_amountToTransfer = amountToTransfer;
ExecuteUseEvent(mergeEvent);
}
else
{
//check if items are still in range.
if (FindValidNearbyItem(sourceItemId, 5.0) == NULL || FindValidNearbyContainer(targetContainerId, 5.0) == NULL)
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_TOO_FAR);
return false;
}
int totalAmount = sourceItem->InqIntQuality(STACK_SIZE_INT, 1, TRUE);
if (amountToTransfer >= totalAmount)
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_OBJECT_GONE);
return false;
}
CWeenieObject *newStackItem = g_pWeenieFactory->CloneWeenie(sourceItem);
if (!newStackItem)
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_OBJECT_GONE);
return false;
}
newStackItem->SetStackSize(amountToTransfer);
newStackItem->SetID(g_pWorld->GenerateGUID(eDynamicGUID));
if (!g_pWorld->CreateEntity(newStackItem))
{
delete newStackItem;
return false;
}
FinishMoveItemToContainer(newStackItem, targetContainer, targetSlot);
MakeAware(newStackItem, true);
//and set original item amount to what remains.
sourceItem->SetStackSize(totalAmount - amountToTransfer);
}
return true;
}
bool CMonsterWeenie::SplitItemto3D(uint32_t sourceItemId, uint32_t amountToTransfer, bool animationDone)
{
if (!animationDone && IsBusyOrInAction())
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_ACTIONS_LOCKED);
return false;
}
CWeenieObject *sourceItem = FindValidNearbyItem(sourceItemId, USEDISTANCE_FAR);
if (!sourceItem)
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_OBJECT_GONE);
return false;
}
if (sourceItem->m_Qualities.GetInt(MAX_STACK_SIZE_INT, 0) < 1)
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_ACTIONS_LOCKED);
return false;
}
if (sourceItem->IsAttunedOrContainsAttuned())
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_ATTUNED_ITEM);
return false;
}
//// Temporarily disallow dropping stackable items.
//if (sourceItem->m_Qualities.GetInt(MAX_STACK_SIZE_INT, 0) > 1)
//{
// NotifyInventoryFailedEvent(sourceItemId, WERROR_ATTUNED_ITEM);
// return false;
//}
if (!animationDone && !FindContainedItem(sourceItem->GetID()))
{
//from ground or other container...
CStackSplitTo3DInventoryUseEvent *splitEvent = new CStackSplitTo3DInventoryUseEvent();
splitEvent->_target_id = sourceItemId;
splitEvent->_sourceItemId = sourceItemId;
splitEvent->_amountToTransfer = amountToTransfer;
ExecuteUseEvent(splitEvent);
}
else
{
//We do this by first splitting the item to our main pack and then dropping it. We could change this to do it directly if this causes any issues.
int totalAmount = sourceItem->InqIntQuality(STACK_SIZE_INT, 1, TRUE);
if (amountToTransfer >= totalAmount)
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_OBJECT_GONE);
return false;
}
CWeenieObject *newStackItem = g_pWeenieFactory->CloneWeenie(sourceItem);
if (!newStackItem)
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_OBJECT_GONE);
return false;
}
newStackItem->SetStackSize(amountToTransfer);
newStackItem->SetID(g_pWorld->GenerateGUID(eDynamicGUID));
if (!g_pWorld->CreateEntity(newStackItem))
{
delete newStackItem;
return false;
}
// move the new stack to our main pack in preparation for dropping it.
FinishMoveItemToContainer(newStackItem, this, 0);
MakeAware(newStackItem, true);
// set original item amount to what remains.
sourceItem->SetStackSize(totalAmount - amountToTransfer);
if (newStackItem->m_Qualities.GetInt(MAX_STACK_SIZE_INT, 0) > 1)
newStackItem->m_Qualities.SetInstanceID(OWNER_IID, GetID());
// and now move on to dropping it
CDropInventoryUseEvent *dropEvent = new CDropInventoryUseEvent();
dropEvent->_target_id = newStackItem->GetID();
ExecuteUseEvent(dropEvent);
}
return true;
}
bool CMonsterWeenie::SplitItemToWield(uint32_t sourceItemId, uint32_t targetLoc, uint32_t amountToTransfer, bool animationDone)
{
if (!animationDone && IsBusyOrInAction())
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_ACTIONS_LOCKED);
return false;
}
CWeenieObject *sourceItem = FindValidNearbyItem(sourceItemId, USEDISTANCE_FAR);
if (!sourceItem)
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_OBJECT_GONE);
return false;
}
if (sourceItem->m_Qualities.GetInt(MAX_STACK_SIZE_INT, 0) < 1)
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_ACTIONS_LOCKED);
return false;
}
if (!Container_CanEquip(sourceItem, targetLoc))
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_BE_WIELDED_FAILURE);
return false;
}
if (!animationDone && !FindContainedItem(sourceItem->GetID()))
{
//from ground or other container...
CStackSplitToWieldInventoryUseEvent *stackSplitEvent = new CStackSplitToWieldInventoryUseEvent();
stackSplitEvent->_target_id = sourceItemId;
stackSplitEvent->_sourceItemId = sourceItemId;
stackSplitEvent->_targetLoc = targetLoc;
stackSplitEvent->_amountToTransfer = amountToTransfer;
ExecuteUseEvent(stackSplitEvent);
}
else
{
int totalAmount = sourceItem->InqIntQuality(STACK_SIZE_INT, 1, TRUE);
if (amountToTransfer >= totalAmount)
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_OBJECT_GONE);
return false;
}
CWeenieObject *newStackItem = g_pWeenieFactory->CloneWeenie(sourceItem);
if (!newStackItem)
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_OBJECT_GONE);
return false;
}
newStackItem->SetStackSize(amountToTransfer);
newStackItem->SetID(g_pWorld->GenerateGUID(eDynamicGUID));
if (!g_pWorld->CreateEntity(newStackItem))
{
NotifyInventoryFailedEvent(newStackItem->GetID(), WERROR_OBJECT_GONE);
return false;
}
if (!FinishMoveItemToWield(newStackItem, targetLoc))
{
g_pWorld->RemoveEntity(newStackItem);
return false; //no need for notifications here as FinishMoveItemToWield takes care of that.
}
MakeAware(newStackItem, true);
//and set original item amount to what remains.
sourceItem->SetStackSize(totalAmount - amountToTransfer);
}
return true;
}
void CMonsterWeenie::GiveItem(uint32_t targetContainerId, uint32_t sourceItemId, uint32_t transferAmount)
{
if (sourceItemId == id)
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_NONE);
return;
}
if (IsExecutingEmote())
{
SendText(csprintf("%s is busy.", GetName().c_str()), LTT_DEFAULT);
NotifyInventoryFailedEvent(sourceItemId, WERROR_GIVE_NOT_ALLOWED);
return;
}
if (IsBusyOrInAction())
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_ACTIONS_LOCKED);
return;
}
CWeenieObject *target = g_pWorld->FindWithinPVS(this, targetContainerId);
CWeenieObject *sourceItem = FindContainedItem(sourceItemId);
if (!sourceItem || !target)
{
if (!sourceItem)
{
CWeenieObject *hackItem = g_pWorld->FindObject(sourceItemId);
if (hackItem && target)
SERVER_ERROR << GetName() << "tried to give" << hackItem->GetName() << "to" << target->GetName();
}
NotifyInventoryFailedEvent(sourceItemId, WERROR_OBJECT_GONE);
return;
}
if (target->IsContained())
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_OBJECT_GONE);
return;
}
if (sourceItem == target || !target->AsContainer())
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_GIVE_NOT_ALLOWED);
return;
}
if (sourceItem->IsAttunedOrContainsAttuned() && target->AsPlayer())
{
NotifyInventoryFailedEvent(sourceItemId, WERROR_ATTUNED_ITEM);
return;
}
CGiveEvent *giveEvent = new CGiveEvent;
giveEvent->_target_id = targetContainerId;
giveEvent->_source_item_id = sourceItemId;
giveEvent->_transfer_amount = transferAmount;
giveEvent->_max_use_distance = 1.0;
giveEvent->_give_event = true;
this->ExecuteUseEvent(giveEvent); //handles moving if needed and does all error checking during this process. At the completion of AnimSuccess FinishGiveItem is called.
}
void CMonsterWeenie::FinishGiveItem(CContainerWeenie *targetContainer, CWeenieObject *sourceItem, uint32_t amountToTransfer)
{
if (amountToTransfer <= 0 || amountToTransfer >= 100000)
{
NotifyInventoryFailedEvent(sourceItem->GetID(), WERROR_GIVE_NOT_ALLOWED);
return;
}
//if (!targetContainer->Container_CanStore(sourceItem))
//{
// NotifyInventoryFailedEvent(sourceItem->GetID(), WERROR_GIVE_NOT_ALLOWED);
// return;
//}
CWeenieObject *targetTopLevel = targetContainer->GetWorldTopLevelOwner();
if (targetTopLevel != sourceItem->GetWorldTopLevelOwner() && targetTopLevel && targetTopLevel->IsExecutingEmote())
{
SendText(csprintf("%s is busy.", targetTopLevel->GetName().c_str()), LTT_DEFAULT);
NotifyInventoryFailedEvent(sourceItem->GetID(), WERROR_GIVE_NOT_ALLOWED);
return;
}
//if (CPlayerWeenie *player = targetContainer->AsPlayer())
//{
// if (!(player->GetCharacterOptions() & AllowGive_CharacterOption))
// {
// NotifyInventoryFailedEvent(sourceItem->GetID(), WERROR_GIVE_NOT_ALLOWED);
// return;
// }
//}
//NOTE: A WCID may only exist in an emote table as refused or accepted (which makes sense logically). You either want it or you don't. Make up your mind.
if (targetTopLevel->m_Qualities._emote_table && targetTopLevel->HasEmoteForID(Refuse_EmoteCategory, sourceItem->m_Qualities.id))
{
//DO REFUSE EMOTE STUFF
CWeenieObject* topLevelOwner = sourceItem->GetWorldTopLevelOwner();
if (topLevelOwner)
{
if (!InqBoolQuality(NPC_INTERACTS_SILENTLY_BOOL, FALSE) && !topLevelOwner->InqBoolQuality(NPC_INTERACTS_SILENTLY_BOOL, FALSE))
topLevelOwner->SendText(csprintf("You allow %s to examine your %s.", targetTopLevel->GetName().c_str(), sourceItem->GetName().c_str()), LTT_DEFAULT);
auto emoteCategory = targetTopLevel->m_Qualities._emote_table->_emote_table.lookup(Refuse_EmoteCategory);
if (emoteCategory)
{
double dice = Random::GenFloat(0.0, 1.0);
double lastProbability = -1.0;
for (auto& emoteSet : *emoteCategory)
{
if (emoteSet.classID == sourceItem->m_Qualities.id)
{
if (dice >= emoteSet.probability)
continue;
if (lastProbability < 0.0 || lastProbability == emoteSet.probability)
{
targetTopLevel->MakeEmoteManager()->ExecuteEmoteSet(emoteSet, topLevelOwner->GetID());
lastProbability = emoteSet.probability;
//There is no point in going through the motions of transfering this object. Fail silently as we triggered what we want.
NotifyInventoryFailedEvent(sourceItem->GetID(), 0);
return;
}
}
}
}
}
}
if (targetTopLevel->AsMonster() && targetTopLevel->AsMonster()->CanAcceptGive(sourceItem))
{
//DO GIVE STUFF HERE
BOOL bWasWielded = sourceItem->IsWielded();
int currentStackSize = sourceItem->InqIntQuality(STACK_SIZE_INT, 1, TRUE);
if (amountToTransfer > currentStackSize)
{
NotifyInventoryFailedEvent(sourceItem->GetID(), WERROR_GIVE_NOT_ALLOWED);
return;
}
CWeenieObject* newStackItem;
if (amountToTransfer < currentStackSize)
{
// partial stack, make a new object
newStackItem = g_pWeenieFactory->CloneWeenie(sourceItem);
newStackItem->SetID(g_pWorld->GenerateGUID(eDynamicGUID));
if (!g_pWorld->CreateEntity(newStackItem, false))
{
NotifyInventoryFailedEvent(sourceItem->GetID(), WERROR_GIVE_NOT_ALLOWED);
return;
}
sourceItem->SetStackSize(currentStackSize - amountToTransfer);
newStackItem->SetStackSize(amountToTransfer);
}
else
{
newStackItem = sourceItem;
sourceItem->ReleaseFromAnyWeenieParent();
sourceItem->SetWeenieContainer(0);
sourceItem->SetWielderID(0);
sourceItem->SetWieldedLocation(INVENTORY_LOC::NONE_LOC);
}
if (AsPlayer() && bWasWielded)
{
int setSpell;
if (sourceItem->m_Qualities.InqInt(EQUIPMENT_SET_ID_INT, setSpell))
{
AsPlayer()->UpdateSetSpells(setSpell, sourceItem->GetID());
}
if (sourceItem->IsAetheria())
{
AsPlayer()->UpdateSigilProcRate();
}
}
// Take it out of whatever slot it's in.
newStackItem->m_Qualities.SetInstanceID(CONTAINER_IID, targetContainer->GetID());
newStackItem->_cachedHasOwner = true;
CWeenieObject* topLevelOwnerObj = newStackItem->GetWorldTopLevelOwner();
assert(topLevelOwnerObj);
assert(topLevelOwnerObj->AsContainer());
if (topLevelOwnerObj)
{
if (CContainerWeenie* topLevelOwner = topLevelOwnerObj->AsContainer())
{
if (newStackItem == sourceItem)
{
SendNetMessage(InventoryMove(sourceItem->GetID(), targetContainer->GetID(), 0, sourceItem->RequiresPackSlot() ? 1 : 0), PRIVATE_MSG, TRUE);
}
if (!InqBoolQuality(NPC_INTERACTS_SILENTLY_BOOL, FALSE) && !topLevelOwner->InqBoolQuality(NPC_INTERACTS_SILENTLY_BOOL, FALSE))
{
targetContainer->EmitSound(Sound_ReceiveItem, 1.0f);
if (amountToTransfer > 1 && !(topLevelOwner->m_Qualities._emote_table && topLevelOwner->HasEmoteForID(Refuse_EmoteCategory, newStackItem->m_Qualities.id)))
{
SendText(csprintf("You give %s %s %s.", topLevelOwner->GetName().c_str(), FormatNumberString(amountToTransfer).c_str(), newStackItem->GetPluralName().c_str()), LTT_DEFAULT);
topLevelOwner->SendText(csprintf("%s gives you %s %s.", GetName().c_str(), FormatNumberString(amountToTransfer).c_str(), newStackItem->GetPluralName().c_str()), LTT_DEFAULT);
}
else
{
SendText(csprintf("You give %s %s.", topLevelOwner->GetName().c_str(), newStackItem->GetName().c_str()), LTT_DEFAULT);
topLevelOwner->SendText(csprintf("%s gives you %s.", GetName().c_str(), newStackItem->GetName().c_str()), LTT_DEFAULT);
}
}
topLevelOwner->MakeAware(newStackItem, true);
if (newStackItem->AsContainer())
{
newStackItem->AsContainer()->MakeAwareViewContent(topLevelOwner);
}
if (AsPlayer() && newStackItem->m_Qualities.id == W_COINSTACK_CLASS)
RecalculateCoinAmount(W_COINSTACK_CLASS);
topLevelOwner->OnReceiveInventoryItem(this, newStackItem, 0);
//topLevelOwner->DebugValidate();
//DebugValidate();
if (AsPlayer())
RecalculateEncumbrance();
return;
}
}
if (AsPlayer())
RecalculateEncumbrance();
}
NotifyInventoryFailedEvent(sourceItem->GetID(), WERROR_GIVE_NOT_ALLOWED);
return;
}
void CMonsterWeenie::Tick()
{
CContainerWeenie::Tick();
Movement_Think();
if (m_MonsterAI)
m_MonsterAI->Update();
}
void CMonsterWeenie::OnDealtDamage(DamageEventData &damageData)
{
CWeenieObject::OnDealtDamage(damageData);
if (m_MonsterAI)
m_MonsterAI->OnDealtDamage(damageData);
}
void CMonsterWeenie::OnTookDamage(DamageEventData &damageData)
{
CWeenieObject::OnTookDamage(damageData);
if (m_MonsterAI)
m_MonsterAI->OnTookDamage(damageData);
}
void CMonsterWeenie::UpdateDamageList(DamageEventData &damageData)
{
if (damageData.source && damageData.outputDamageFinal > 0 && damageData.damage_type != STAMINA_DAMAGE_TYPE && damageData.damage_type != MANA_DAMAGE_TYPE)
{
uint32_t source = damageData.source->GetID();
std::map<uint32_t, int>::iterator itr = m_aDamageSources.find(source);
std::map<uint32_t, int>::iterator itr_high = m_aDamageSources.find(m_highestDamageSource);
if (itr == m_aDamageSources.end())
{
itr = m_aDamageSources.emplace(std::make_pair(source, 0)).first;
}
uint32_t oid = 0;// InqIIDQuality(PET_OWNER_IID, 0);
if (damageData.source && damageData.source->m_Qualities.InqInstanceID(PET_OWNER_IID, oid))
{
itr = m_aDamageSources.find(oid);
if (itr == m_aDamageSources.end())
{
itr = m_aDamageSources.emplace(std::make_pair(oid, 0)).first;
}
source = oid;
}
//m_aDamageSources[source] += damageData.outputDamageFinal;
itr->second += damageData.outputDamageFinal;
m_totalDamageTaken += damageData.outputDamageFinal;
if (m_highestDamageSource == 0 || itr->second > itr_high->second)
{
m_highestDamageSource = source;
if (monster_brawl && m_MonsterAI && !(InqIntQuality(CREATURE_TYPE_INT, 0) == damageData.source->InqIntQuality(CREATURE_TYPE_INT, 0)))
{
m_MonsterAI->SetNewTarget(damageData.source);
return;
}
if (m_MonsterAI && m_MonsterAI->_toleranceType != TolerateEverything && damageData.source->AsPlayer()) // TODO: maths to determine when to setnewtarget not just per attack as it would allow ping-ponging mobs
{
m_MonsterAI->m_fAggroTime = Timer::cur_time + 10.0f;
m_MonsterAI->SetNewTarget(damageData.source);
}
}
}
}
void CMonsterWeenie::OnRegen(STypeAttribute2nd currentAttrib, int newAmount)
{
CWeenieObject::OnRegen(currentAttrib, newAmount);
if (currentAttrib == HEALTH_ATTRIBUTE_2ND)
{
uint32_t maxHealth = 0;
m_Qualities.InqAttribute2nd(MAX_HEALTH_ATTRIBUTE_2ND, maxHealth, FALSE);
if (maxHealth == newAmount)
{
// reset damage sources
m_aDamageSources.clear();
m_highestDamageSource = 0;
m_totalDamageTaken = 0;
}
}
}
void CMonsterWeenie::GivePerksForKill(CWeenieObject *pKilled)
{
// Prevent CWeenieObject::GivePerksForKill from running
}
void CMonsterWeenie::GiveXP(int64_t amount, ExperienceHandlingType flags, bool showText)
{
if (amount <= 0)
return;
if (m_Qualities.GetInt(AUGMENTATION_BONUS_XP_INT, 0))
{
amount = uint64_t((double)amount * 1.05);
}
OnGivenXP(amount, flags);
uint64_t newAvailableXP = (uint64_t)InqInt64Quality(AVAILABLE_EXPERIENCE_INT64, 0) + amount;
uint64_t newTotalXP = (uint64_t)InqInt64Quality(TOTAL_EXPERIENCE_INT64, 0) + amount;
int currentLevel = InqIntQuality(LEVEL_INT, 1);
uint32_t skillCredits = 0;
bool bLeveled = false;
uint64_t xpToNextLevel = ExperienceSystem::ExperienceToLevel(currentLevel + 1);
while (xpToNextLevel <= newTotalXP && currentLevel < ExperienceSystem::GetMaxLevel())
{
currentLevel++;
skillCredits += ExperienceSystem::GetCreditsForLevel(currentLevel);
bLeveled = true;
xpToNextLevel = ExperienceSystem::ExperienceToLevel(currentLevel + 1);
if (!xpToNextLevel)
break;
}
//TODO: When luminance is introduced, move this.
m_Qualities.SetInt64(AVAILABLE_EXPERIENCE_INT64, newAvailableXP);
NotifyInt64StatUpdated(AVAILABLE_EXPERIENCE_INT64);
if (currentLevel < 275) {
m_Qualities.SetInt64(TOTAL_EXPERIENCE_INT64, newTotalXP);
NotifyInt64StatUpdated(TOTAL_EXPERIENCE_INT64);
}
if (bLeveled)
{
GiveSkillCredit(skillCredits);
fellowship_ptr_t fs = GetFellowship();
if (fs)
{
fs->FullUpdate();
}
AllegianceTreeNode *node = g_pAllegianceManager->GetTreeNode(GetID());
if (node)
node->_level = currentLevel;
m_Qualities.SetInt(LEVEL_INT, currentLevel);
NotifyIntStatUpdated(LEVEL_INT);
EmitEffect(PS_LevelUp, 1.0f);
if (currentLevel == 275)
{
m_Qualities.SetInt64(TOTAL_EXPERIENCE_INT64, 191226310247);
NotifyInt64StatUpdated(TOTAL_EXPERIENCE_INT64);
EmitEffect(PS_WeddingBliss, 1.0f);
}
const char *notice = csprintf(
"You are now level %s! You have %s experience points and %s skill credits available to raise skills and attributes.",
FormatNumberString(currentLevel).c_str(),
FormatNumberString(newAvailableXP).c_str(),
FormatNumberString(InqIntQuality(AVAILABLE_SKILL_CREDITS_INT, 0)).c_str());
SendText(notice, LTT_ADVANCEMENT);
// restore vitals
if (!IsDead())
{
SetMaxVitals(true);
}
}
if (showText)
{
const char *notice = csprintf(
"You've earned %s experience.",
FormatNumberString(amount).c_str());
SendText(notice, LTT_DEFAULT);
}
if (flags & ExperienceHandlingType::ShareWithAllegiance)
{
// let allegiance manager pass it up
g_pAllegianceManager->HandleAllegiancePassup(GetID(), amount, true);
}
std::list<CWeenieObject*> equipment;
Container_GetWieldedByMask(equipment, ALL_LOC);
for (CWeenieObject *item : equipment)
{
item->GiveXP(amount, flags, false);
}
}
void CMonsterWeenie::OnIdentifyAttempted(CWeenieObject *other)
{
if (m_MonsterAI)
m_MonsterAI->OnIdentifyAttempted(other);
}
void CMonsterWeenie::OnResistSpell(CWeenieObject *attacker)
{
HandleAggro(attacker);
if (m_MonsterAI)
m_MonsterAI->OnResistSpell(attacker);
}
void CMonsterWeenie::OnEvadeAttack(CWeenieObject *attacker)
{
HandleAggro(attacker);
if (m_MonsterAI)
m_MonsterAI->OnEvadeAttack(attacker);
}
void CMonsterWeenie::HandleAggro(CWeenieObject *attacker)
{
if (m_MonsterAI)
m_MonsterAI->HandleAggro(attacker);
}
bool CMonsterWeenie::IsAttackMotion(uint32_t motion)
{
switch ((WORD)motion)
{
case 0x62:
case 0x63:
case 0x64:
case 0x65:
case 0x66:
case 0x67:
case 0x68:
case 0x69:
case 0x6A:
return true;
}
return false;
}
void CMonsterWeenie::OnMotionDone(uint32_t motion, BOOL success)
{
CWeenieObject::OnMotionDone(motion, success);
if (motion == 0x40000011)
{
OnDeathAnimComplete();
}
if (m_MotionUseData.m_MotionUseType != MUT_UNDEF)
{
bool bUseSuccess = success && !IsDead();
if (motion == m_MotionUseData.m_MotionUseMotionID)
{
switch (m_MotionUseData.m_MotionUseType)
{
case MUT_CONSUME_FOOD:
{
bool bConsumed = false;
MotionUseData useData = m_MotionUseData;
if (bUseSuccess)
{
m_MotionUseData.Reset(); // necessary so this doesn't become infinitely recursive
DoForcedStopCompletely();
CWeenieObject *pItem = FindContainedItem(useData.m_MotionUseTarget);
if (pItem)
{
ReleaseContainedItemRecursive(pItem);
bConsumed = true;
if (uint32_t use_sound_did = pItem->InqDIDQuality(USE_SOUND_DID, 0))
EmitSound(use_sound_did, 1.0f);
uint32_t boost_stat = pItem->InqIntQuality(BOOSTER_ENUM_INT, 0);
uint32_t boost_value = pItem->InqIntQuality(BOOST_VALUE_INT, 0);
switch (boost_stat)
{
case HEALTH_ATTRIBUTE_2ND:
case STAMINA_ATTRIBUTE_2ND:
case MANA_ATTRIBUTE_2ND:
{
STypeAttribute2nd maxStatType = (STypeAttribute2nd)(boost_stat - 1);
STypeAttribute2nd statType = (STypeAttribute2nd)boost_stat;
uint32_t statValue = 0, maxStatValue = 0;
m_Qualities.InqAttribute2nd(statType, statValue, FALSE);
m_Qualities.InqAttribute2nd(maxStatType, maxStatValue, FALSE);
uint32_t newStatValue = min(statValue + boost_value, maxStatValue);
int statChange = newStatValue - statValue;
if (statChange)
{
if (statType == HEALTH_ATTRIBUTE_2ND)
{
AdjustHealth(statChange);
NotifyAttribute2ndStatUpdated(statType);
}
else
{
m_Qualities.SetAttribute2nd(statType, newStatValue);
NotifyAttribute2ndStatUpdated(statType);
}
}
const char *vitalName = "";
switch (boost_stat)
{
case HEALTH_ATTRIBUTE_2ND: vitalName = "health"; break;
case STAMINA_ATTRIBUTE_2ND: vitalName = "stamina"; break;
case MANA_ATTRIBUTE_2ND: vitalName = "mana"; break;
}
SendText(csprintf("The %s restores %d points of your %s.", pItem->GetName().c_str(), max(0, statChange), vitalName), LTT_DEFAULT);
break;
}
}
NotifyContainedItemRemoved(pItem->id);
pItem->MarkForDestroy();
}
}
if (!bConsumed)
NotifyInventoryFailedEvent(useData.m_MotionUseTarget, 0);
break;
}
}
m_MotionUseData.Reset();
}
}
}
CCorpseWeenie *CMonsterWeenie::CreateCorpse(bool visible)
{
if (!InValidCell())
return NULL;
// spawn corpse
CCorpseWeenie *pCorpse = (CCorpseWeenie *)g_pWeenieFactory->CreateWeenieByClassID(W_CORPSE_CLASS);
if (m_Qualities.GetBool(TREASURE_CORPSE_BOOL, false))
{
pCorpse->m_Qualities.SetDataID(SETUP_DID, 33558212);
pCorpse->m_Qualities.SetDataID(MOTION_TABLE_DID, 150995355);
pCorpse->m_Qualities.SetFloat(DEFAULT_SCALE_FLOAT, 0.4);
pCorpse->SetName(csprintf("Treasure of %s", GetName().c_str()));
}
else
{
pCorpse->CopyDIDStat(SETUP_DID, this);
pCorpse->CopyFloatStat(DEFAULT_SCALE_FLOAT, this);
pCorpse->SetName(csprintf("Corpse of %s", GetName().c_str()));
pCorpse->CopyFloatStat(TRANSLUCENCY_FLOAT, this);
pCorpse->CopyDIDStat(MOTION_TABLE_DID, this);
}
// pCorpse->CopyDIDStat(SOUND_TABLE_DID, this);
// pCorpse->CopyDIDStat(PHYSICS_EFFECT_TABLE_DID, this);
pCorpse->CopyIntStat(LEVEL_INT, this); //copy the level so the treasure generator can have access to that value.
ObjDesc desc;
GetObjDesc(desc);
pCorpse->SetObjDesc(desc);
auto initpos = m_Position;
pCorpse->SetInitialPosition(m_Position);
pCorpse->InitPhysicsObj();
//set velocity so that corpses are affected by gravity.
pCorpse->set_velocity(_phys_obj->m_velocityVector, 0);
pCorpse->m_bDontClear = false;
pCorpse->m_Qualities.SetString(LONG_DESC_STRING, csprintf("Killed by %s.", m_DeathKillerNameForCorpse.empty() ? "a mysterious source" : m_DeathKillerNameForCorpse.c_str()));
pCorpse->m_Qualities.SetInstanceID(KILLER_IID, m_DeathKillerIDForCorpse);
pCorpse->m_Qualities.SetInstanceID(VICTIM_IID, GetID());
pCorpse->MakeMovementManager(TRUE);
MovementParameters params;
params.autonomous = 0;
pCorpse->last_move_was_autonomous = false;
pCorpse->DoMotion(GetCommandID(17), &params, 0);
if (!visible)
pCorpse->m_Qualities.SetBool(VISIBILITY_BOOL, false);
if (!g_pWorld->CreateEntity(pCorpse))
{
SERVER_ERROR << "Unable to create corpse of" << GetName().c_str() << "at Landblock:" << csprintf("0x%08X", m_Position.objcell_id) <<
"(X, Y, Z):" << m_Position.frame.m_origin.x << "," << m_Position.frame.m_origin.y << m_Position.frame.m_origin.z;
pCorpse = NULL;
}
m_DeathKillerIDForCorpse = 0;
m_DeathKillerNameForCorpse.clear();
return pCorpse;
}
void CMonsterWeenie::DropAllLoot(CCorpseWeenie *pCorpse)
{
}
void CMonsterWeenie::GenerateDeathLoot(CCorpseWeenie *pCorpse)
{
if (uint32_t deathTreasureType = InqDIDQuality(DEATH_TREASURE_TYPE_DID, 0))
g_pWeenieFactory->GenerateFromTypeOrWcid(pCorpse, DestinationType::ContainTreasure_DestinationType, deathTreasureType);
if (m_Qualities._create_list)
g_pWeenieFactory->AddFromCreateList(pCorpse, m_Qualities._create_list, (DestinationType)(Contain_DestinationType | Treasure_DestinationType));
std::list<CWeenieObject *> removeList;
for (auto item : pCorpse->m_Items)
{
if (item->IsDestroyedOnDeath())
removeList.push_back(item);
}
for (auto item : removeList)
item->Remove();
}
void CMonsterWeenie::OnDeathAnimComplete()
{
if (!m_bWaitingForDeathToFinish)
return;
m_bWaitingForDeathToFinish = false;
CWeenieObject *killer = g_pWorld->FindObject(m_DeathKillerIDForCorpse, false);
if (!_IsPlayer())
{
MarkForDestroy();
}
// create corpse
CPlayerWeenie *player = AsPlayer();
if (!player && !m_Qualities.GetBool(NO_CORPSE_BOOL, false))
{
CCorpseWeenie *pCorpse = CreateCorpse();
if (pCorpse)
GenerateDeathLoot(pCorpse);
if (pCorpse && m_bIsRareEligible && !g_pTreasureFactory->_TreasureProfile->rareTiers.empty() && g_pConfig->RareDropMultiplier() > 0.0)
{
if (killer && killer->_IsPlayer())
g_pWeenieFactory->GenerateRareItem(pCorpse, killer);
}
}
}
void CMonsterWeenie::OnDeath(uint32_t killer_id)
{
if (m_aDamageSources.empty()) // not sure this should ever happen
{
m_highestDamageSource = killer_id;
}
CWeenieObject::OnDeath(m_highestDamageSource);
CheckRareEligible(g_pWorld->FindObject(m_highestDamageSource, false));
int level = InqIntQuality(LEVEL_INT, 0);
int baseXPForKill = 0;
int baseLumForKill = 0;
int64_t xpForKill = 0;
int64_t lumForKill = 0;
if (level <= 0)
baseXPForKill = 0;
else if (!m_Qualities.InqInt(XP_OVERRIDE_INT, baseXPForKill, 0, FALSE))
baseXPForKill = (uint32_t)GetXPForKillLevel(level);
xpForKill = (int64_t)(baseXPForKill * g_pConfig->GetKillXPMultiplier());
if (level <= 0)
lumForKill = 0;
else if (m_Qualities.InqInt(LUMINANCE_AWARD_INT, baseLumForKill, 0, FALSE))
lumForKill = (int64_t)(baseLumForKill * g_pConfig->GetKillXPMultiplier());
if (xpForKill > 0)
{
// hand out xp proportionally
for (auto it = m_aDamageSources.begin(); it != m_aDamageSources.end(); ++it)
{
CWeenieObject *pSource = g_pWorld->FindObject(it->first);
//uint32_t oid = 0;// InqIIDQuality(PET_OWNER_IID, 0);
//if (pSource->m_Qualities.InqInstanceID(PET_OWNER_IID, oid))
//{
// pSource = g_pWorld->FindObject(oid);
//}
double dPercentage = (double)it->second / m_totalDamageTaken;
if (pSource)
{
pSource->GiveSharedXP(dPercentage * xpForKill, false);
if (lumForKill > 0)
pSource->GiveSharedLum(dPercentage * lumForKill, false);
}
}
}
m_DeathKillerIDForCorpse = m_highestDamageSource;
if (!g_pWorld->FindObjectName(m_highestDamageSource, m_DeathKillerNameForCorpse))
m_DeathKillerNameForCorpse = "fate";
if (m_Qualities._generator_registry && m_Qualities.GetInt(GENERATOR_DESTRUCTION_TYPE_INT, 0) && m_Qualities.GetInt(GENERATOR_DESTRUCTION_TYPE_INT, 0) != 1)
{
for (auto entry : m_Qualities._generator_registry->_registry)
{
CWeenieObject *weenie = g_pWorld->FindObject(entry.second.m_objectId);
if (weenie->AsMonster() != nullptr)
weenie->AsMonster()->OnDeath(0);
}
}
MakeMovementManager(TRUE);
StopCompletely(0);
bool bHardcoreDeath = false;
if (g_pConfig->HardcoreMode() && _IsPlayer())
{
if (CWeenieObject *pKiller = g_pWorld->FindObject(m_highestDamageSource))
{
if (!g_pConfig->HardcoreModePlayersOnly() || pKiller->_IsPlayer())
{
bHardcoreDeath = true;
}
}
}
if (!bHardcoreDeath)
{
MovementStruct mvs;
MovementParameters params;
mvs.type = RawCommand;
mvs.motion = Motion_Dead;
mvs.params = &params;
params.action_stamp = ++m_wAnimSequence;
last_move_was_autonomous = 0;
m_bWaitingForDeathToFinish = true;
if (movement_manager->PerformMovement(mvs))
{
// animation failed for some reason
OnDeathAnimComplete();
}
else
{
Animation_Update();
}
}
else
{
if (!m_DeathKillerNameForCorpse.empty())
{
g_pWorld->BroadcastGlobal(ServerText(csprintf("%s has been defeated by %s.", GetName().c_str(), m_DeathKillerNameForCorpse.c_str()), LTT_DEFAULT), PRIVATE_MSG);
}
else
{
g_pWorld->BroadcastGlobal(ServerText(csprintf("%s has been defeated.", GetName().c_str()), LTT_DEFAULT), PRIVATE_MSG);
}
if (CCorpseWeenie *pCorpse = CreateCorpse())
{
DropAllLoot(pCorpse);
}
g_pDBIO->DeleteCharacter(GetID());
BeginLogout();
}
}
bool CMonsterWeenie::IsDead()
{
if (m_bReviveAfterAnim)
return true;
return CWeenieObject::IsDead();
}
void CMonsterWeenie::ChangeCombatMode(COMBAT_MODE mode, bool playerRequested)
{
COMBAT_MODE newCombatMode = (COMBAT_MODE)InqIntQuality(COMBAT_MODE_INT, COMBAT_MODE::NONCOMBAT_COMBAT_MODE, TRUE);
uint32_t new_motion_style = get_minterp()->InqStyle();
//if (_IsPlayer())
//{
switch (mode)
{
case NONCOMBAT_COMBAT_MODE:
new_motion_style = Motion_NonCombat;
newCombatMode = COMBAT_MODE::NONCOMBAT_COMBAT_MODE;
break;
case MELEE_COMBAT_MODE:
{
CWeenieObject *weapon = GetWieldedMelee();
CWeenieObject *shield = GetWieldedShield();
if (!weapon)
weapon = GetWieldedTwoHanded();
CombatStyle default_combat_style = weapon ? (CombatStyle)weapon->InqIntQuality(DEFAULT_COMBAT_STYLE_INT, Undef_CombatStyle) : Undef_CombatStyle;
switch (default_combat_style)
{
case Undef_CombatStyle:
case Unarmed_CombatStyle:
new_motion_style = Motion_HandCombat;
if (shield && shield->InqIntQuality(LOCATIONS_INT, 0, TRUE) != SHIELD_LOC)
new_motion_style = Motion_DualWieldCombat;
newCombatMode = COMBAT_MODE::MELEE_COMBAT_MODE;
break;
case OneHanded_CombatStyle:
{
new_motion_style = Motion_SwordCombat;
if (shield)
{
if (shield->InqIntQuality(LOCATIONS_INT, 0, TRUE) != SHIELD_LOC)
new_motion_style = Motion_DualWieldCombat;
else
new_motion_style = Motion_SwordShieldCombat;
}
newCombatMode = COMBAT_MODE::MELEE_COMBAT_MODE;
break;
}
case TwoHanded_CombatStyle:
new_motion_style = Motion_2HandedSwordCombat;
newCombatMode = COMBAT_MODE::MELEE_COMBAT_MODE;
break;
}
break;
}
case MISSILE_COMBAT_MODE:
{
CWeenieObject *weapon = GetWieldedMissile();
CombatStyle default_combat_style = weapon ? (CombatStyle)weapon->InqIntQuality(DEFAULT_COMBAT_STYLE_INT, Undef_CombatStyle) : Undef_CombatStyle;
switch (default_combat_style)
{
case Bow_CombatStyle:
if (CWeenieObject *ammo = GetWieldedAmmo())
{
new_motion_style = Motion_BowCombat;
newCombatMode = COMBAT_MODE::MISSILE_COMBAT_MODE;
}
else
{
NotifyWeenieError(WERROR_COMBAT_OUT_OF_AMMO);
new_motion_style = Motion_NonCombat;
newCombatMode = COMBAT_MODE::NONCOMBAT_COMBAT_MODE;
}
break;
case Crossbow_CombatStyle:
if (CWeenieObject *ammo = GetWieldedAmmo())
{
new_motion_style = Motion_CrossbowCombat;
newCombatMode = COMBAT_MODE::MISSILE_COMBAT_MODE;
}
else
{
NotifyWeenieError(WERROR_COMBAT_OUT_OF_AMMO);
new_motion_style = Motion_NonCombat;
newCombatMode = COMBAT_MODE::NONCOMBAT_COMBAT_MODE;
}
break;
case ThrownWeapon_CombatStyle:
new_motion_style = Motion_ThrownWeaponCombat;
newCombatMode = COMBAT_MODE::MISSILE_COMBAT_MODE;
break;
case Atlatl_CombatStyle:
if (CWeenieObject *ammo = GetWieldedAmmo())
{
new_motion_style = Motion_AtlatlCombat;
newCombatMode = COMBAT_MODE::MISSILE_COMBAT_MODE;
}
else
{
NotifyWeenieError(WERROR_COMBAT_OUT_OF_AMMO);
new_motion_style = Motion_NonCombat;
newCombatMode = COMBAT_MODE::NONCOMBAT_COMBAT_MODE;
}
break;
}
break;
}
case MAGIC_COMBAT_MODE:
new_motion_style = Motion_Magic;
newCombatMode = COMBAT_MODE::MAGIC_COMBAT_MODE;
break;
}
//}
if (new_motion_style != get_minterp()->InqStyle())
{
MovementParameters params;
get_minterp()->DoMotion(new_motion_style, &params);
_server_control_timestamp++;
last_move_was_autonomous = false;
Animation_Update();
}
m_Qualities.SetInt(COMBAT_MODE_INT, newCombatMode);
if (newCombatMode != mode || !playerRequested)
{
NotifyIntStatUpdated(COMBAT_MODE_INT);
}
}
uint32_t CMonsterWeenie::DoForcedUseMotion(MotionUseType useType, uint32_t motion, uint32_t target, uint32_t childID, uint32_t childLoc, MovementParameters *params)
{
m_MotionUseData.m_MotionUseType = useType;
m_MotionUseData.m_MotionUseMotionID = motion;
m_MotionUseData.m_MotionUseTarget = target;
m_MotionUseData.m_MotionUseChildID = childID;
m_MotionUseData.m_MotionUseChildLocation = childLoc;
return DoForcedMotion(motion, params);
}
//thanks lime!
bool CMonsterWeenie::ClothingPrioritySorter(const CWeenieObject *first, const CWeenieObject *second)
{
if (((CWeenieObject *)first)->InqBoolQuality(TOP_LAYER_PRIORITY_BOOL, 0))
return FALSE;
else if (((CWeenieObject *)second)->InqBoolQuality(TOP_LAYER_PRIORITY_BOOL, 0))
return TRUE;
return ((CWeenieObject *)first)->InqIntQuality(CLOTHING_PRIORITY_INT, 0, TRUE) < ((CWeenieObject *)second)->InqIntQuality(CLOTHING_PRIORITY_INT, 0, TRUE);
}
void CMonsterWeenie::GetObjDesc(ObjDesc &objDesc)
{
std::list<CWeenieObject *> wieldedWearable;
Container_GetWieldedByMask(wieldedWearable, ARMOR_LOC | CLOTHING_LOC);
for (auto wearable : wieldedWearable)
{
if (wearable->IsAvatarJumpsuit())
{
objDesc = wearable->m_WornObjDesc;
return;
}
}
CWeenieObject::GetObjDesc(objDesc);
uint32_t head_object_id = 0;
if (m_Qualities.InqDataID(HEAD_OBJECT_DID, head_object_id))
objDesc.AddAnimPartChange(new AnimPartChange(16, head_object_id));
uint32_t setup_id = 0;
m_Qualities.InqDataID(SETUP_DID, setup_id);
// some heritage groups have alternate setups (undead)
// we need to get the base gender setup or clothing tables won't work
int group = 1;
int gender = 1;
if (m_Qualities.InqInt(HERITAGE_GROUP_INT, group) && m_Qualities.InqInt(GENDER_INT, gender))
{
HeritageGroup_CG *heritage = CachedCharGenData->mHeritageGroupList.lookup(group);
Sex_CG *sex = heritage->mGenderList.lookup(gender);
//objDesc += sex->objDesc;
HairStyle_CG *hair = nullptr;
//if (m_Qualities.InqDataID(HEAD_OBJECT_DID, head_object_id))
// hair = sex->FindHairStyle(head_object_id);
hair = sex->FindHairStyleAltSetup(setup_id);
if (hair)
{
//objDesc += hair->objDesc;
//if (hair->alternateSetup == setup_id)
setup_id = sex->setup;
}
}
uint32_t old_eye_texture_id, new_eye_texture_id;
if (m_Qualities.InqDataID(DEFAULT_EYES_TEXTURE_DID, old_eye_texture_id) && m_Qualities.InqDataID(EYES_TEXTURE_DID, new_eye_texture_id))
objDesc.AddTextureMapChange(new TextureMapChange(16, old_eye_texture_id, new_eye_texture_id));
uint32_t old_nose_texture_id, new_nose_texture_id;
if (m_Qualities.InqDataID(DEFAULT_NOSE_TEXTURE_DID, old_nose_texture_id) && m_Qualities.InqDataID(NOSE_TEXTURE_DID, new_nose_texture_id))
objDesc.AddTextureMapChange(new TextureMapChange(16, old_nose_texture_id, new_nose_texture_id));
uint32_t old_mouth_texture_id, new_mouth_texture_id;
if (m_Qualities.InqDataID(DEFAULT_MOUTH_TEXTURE_DID, old_mouth_texture_id) && m_Qualities.InqDataID(MOUTH_TEXTURE_DID, new_mouth_texture_id))
objDesc.AddTextureMapChange(new TextureMapChange(16, old_mouth_texture_id, new_mouth_texture_id));
uint32_t skin_palette_id;
if (m_Qualities.InqDataID(SKIN_PALETTE_DID, skin_palette_id))
objDesc.AddSubpalette(new Subpalette(skin_palette_id, 0 << 3, 0x18 << 3));
uint32_t hair_palette_id;
if (m_Qualities.InqDataID(HAIR_PALETTE_DID, hair_palette_id))
objDesc.AddSubpalette(new Subpalette(hair_palette_id, 0x18 << 3, 0x8 << 3));
uint32_t eye_palette_id;
if (m_Qualities.InqDataID(EYES_PALETTE_DID, eye_palette_id))
objDesc.AddSubpalette(new Subpalette(eye_palette_id, 0x20 << 3, 0x8 << 3));
std::list<CWeenieObject *> wieldedArmors;
Container_GetWieldedByMask(wieldedArmors, CLOTHING_LOC | ARMOR_LOC);
wieldedArmors.sort(ClothingPrioritySorter);
for (auto armor : wieldedArmors)
{
if (armor->IsHelm())
{
if (!ShowHelm())
continue;
}
if (armor->IsCloak())
{
if (!ShowCloak())
continue;
}
uint32_t clothing_table_id = armor->InqDIDQuality(CLOTHINGBASE_DID, 0);
uint32_t palette_template_key = armor->InqIntQuality(PALETTE_TEMPLATE_INT, 0);
if (clothing_table_id && !armor->IsAvatarJumpsuit())
{
ClothingTable *clothingTable = ClothingTable::Get(clothing_table_id);
if (clothingTable)
{
ObjDesc od;
ShadePackage shades(armor->InqFloatQuality(SHADE_FLOAT, 0.0));
double shadeVal;
if (armor->m_Qualities.InqFloat(SHADE2_FLOAT, shadeVal))
shades._val[1] = shadeVal;
if (armor->m_Qualities.InqFloat(SHADE3_FLOAT, shadeVal))
shades._val[2] = shadeVal;
if (armor->m_Qualities.InqFloat(SHADE4_FLOAT, shadeVal))
shades._val[3] = shadeVal;
if (clothingTable->BuildObjDesc(setup_id, palette_template_key, &shades, &od))
objDesc += od;
ClothingTable::Release(clothingTable);
}
}
else
{
objDesc += armor->m_WornObjDesc;
}
}
}
uint32_t CMonsterWeenie::OnReceiveInventoryItem(CWeenieObject *source, CWeenieObject *item, uint32_t desired_slot)
{
if (source != this)
{
if (!InqBoolQuality(AI_ACCEPT_EVERYTHING_BOOL, false))
{
// Use our emote table to determine what to do with this item.
if (m_Qualities._emote_table)
{
PackableList<EmoteSet>* emoteCategory = m_Qualities._emote_table->_emote_table.lookup(Give_EmoteCategory);
if (emoteCategory)
{
double dice = Random::GenFloat(0.0, 1.0);
double lastProbability = 1.1; // initialize to ensure the first check sets correctly
EmoteSet lastEmoteSet;
// first scan all the probability entries and find the one that is just higher than the dice roll
// assumes the entries are not increasing in values, can be in any order
for (auto& emoteSet : *emoteCategory)
{
if (emoteSet.classID == item->m_Qualities.id)
{
if (dice >= emoteSet.probability) // ignore any that are less than the dice roll
continue;
else
if (emoteSet.probability <= lastProbability) // ignore any that are greater than the current pick
{
lastProbability = emoteSet.probability;
lastEmoteSet = emoteSet;
}
}
}
if (lastProbability <= 1.0) // double check a probability was found
{
if (item->InqIntQuality(STACK_SIZE_INT, 1) > 1)
{
item->DecrementStackNum(1, false);
SimulateGiveObject(source->AsContainer(), item);
}
else
g_pWorld->RemoveEntity(item);
MakeEmoteManager()->ExecuteEmoteSet(lastEmoteSet, source->GetID());
return 0;
}
}
}
}
g_pWorld->RemoveEntity(item);
return 0;
}
else
{
// Unless the source is ourselves, that means the item is spawning.
item->ReleaseFromAnyWeenieParent(false, true);
item->SetWieldedLocation(INVENTORY_LOC::NONE_LOC);
item->SetWeenieContainer(GetID());
item->ReleaseFromBlock();
return Container_InsertInventoryItem(0, item, desired_slot);
}
}
double CMonsterWeenie::GetMeleeDefenseModUsingWielded()
{
double defenseMod = 1.0;
// we don't have an attack manager unless we are in active combat
//if (m_AttackManager)
//{
// defenseMod *= (double)m_AttackManager->GetDefenseMod();
//}
CWeenieObject *main = GetWieldedCombat(COMBAT_USE_MELEE);
CWeenieObject *left = GetWieldedCombat(COMBAT_USE_OFFHAND);
CWeenieObject *bow = GetWieldedCombat(COMBAT_USE_MISSILE);
CWeenieObject *both = GetWieldedCombat(COMBAT_USE_TWO_HANDED);
CWeenieObject *caster = GetWieldedCaster();
if (caster)
defenseMod = caster->GetMeleeDefenseMod();
else if (bow)
defenseMod = bow->GetMeleeDefenseMod();
else if (both)
defenseMod = both->GetMeleeDefenseMod();
else
{
// Calling the weapon::GetMeleeDefenseMod will include buffs, as will calling the base
// Here we check wether or not the main hand is empty, using
// the base defense (probably 1 + buffs) instead
defenseMod = main ? main->GetMeleeDefenseMod() : CWeenieObject::GetMeleeDefenseMod();
if (left)
defenseMod = max(defenseMod, left->GetMeleeDefenseMod());
}
std::list<CWeenieObject *> wielded;
Container_GetWieldedByMask(wielded, ARMOR_LOC);
for (auto item : m_Wielded) //check all armor for appropriate imbue effects
{
if (item->GetImbueEffects() & MeleeDefense_ImbuedEffectType)
defenseMod += 0.01;
}
return defenseMod;
}
double CMonsterWeenie::GetMissileDefenseModUsingWielded()
{
std::list<CWeenieObject *> wielded;
Container_GetWieldedByMask(wielded, WEAPON_LOC | HELD_LOC);
double defenseMod = 1.0;
for (auto item : wielded)
{
defenseMod *= item->GetMissileDefenseMod();
}
defenseMod *= CWeenieObject::GetMissileDefenseMod();
Container_GetWieldedByMask(wielded, ARMOR_LOC);
for (auto item : m_Wielded) //check all armor for appropriate imbue effects
{
if (item->GetImbueEffects() & MissileDefense_ImbuedEffectType)
defenseMod += 0.01;
}
return defenseMod;
}
double CMonsterWeenie::GetMagicDefenseModUsingWielded()
{
std::list<CWeenieObject *> wielded;
Container_GetWieldedByMask(wielded, WEAPON_LOC | HELD_LOC);
double defenseMod = 1.0;
for (auto item : wielded)
{
defenseMod *= item->GetMagicDefenseMod();
}
defenseMod *= CWeenieObject::GetMagicDefenseMod();
/* Container_GetWieldedByMask(wielded, ARMOR_LOC);
for (auto item : m_Wielded) //check all armor for appropriate imbue effects - commented out as this is checked in TryMagicResist and should be adding 1 to skill, not 1%
{
if (item->GetImbueEffects() & MagicDefense_ImbuedEffectType)
defenseMod += 0.01;
}*/
return defenseMod;
}
int CMonsterWeenie::GetAttackTimeUsingWielded()
{
std::list<CWeenieObject *> wielded;
Container_GetWieldedByMask(wielded, WEAPON_LOC);
for (auto item : wielded)
{
return item->GetAttackTime();
}
return CWeenieObject::GetAttackTime();
}
int CMonsterWeenie::GetAttackTime()
{
/*
std::list<CWeenieObject *> wielded;
Container_GetWieldedByMask(wielded, WEAPON_LOC);
int totalTime = CWeenieObject::GetAttackTime();
for (auto item : wielded)
{
totalTime += item->GetAttackTime();
}
return totalTime;
*/
return CWeenieObject::GetAttackTime();
}
int CMonsterWeenie::GetAttackDamage(bool isAssess)
{
/*
std::list<CWeenieObject *> wielded;
Container_GetWieldedByMask(wielded, WEAPON_LOC);
int damage = CWeenieObject::GetAttackDamage();
for (auto item : wielded)
{
damage += item->GetAttackDamage();
}
*/
return CWeenieObject::GetAttackDamage(isAssess);
}
float CMonsterWeenie::GetEffectiveArmorLevel(DamageEventData &damageData, bool bIgnoreMagicArmor)
{
std::list<CWeenieObject *> wielded;
Container_GetWieldedByMask(wielded, ARMOR_LOC | CLOTHING_LOC | SHIELD_LOC);
EnchantedQualityDetails buffDetails;
//body part
GetBodyArmorEnchantmentDetails(damageData.hitPart, damageData.damage_type, &buffDetails);
//body
buffDetails.rawValue += CWeenieObject::GetEffectiveArmorLevel(damageData, bIgnoreMagicArmor);
//equipment
for (auto item : wielded)
buffDetails.rawValue += item->GetEffectiveArmorLevel(damageData, bIgnoreMagicArmor);
if (damageData.isArmorRending && damageData.armorRendingMultiplier < buffDetails.valueDecreasingMultiplier)
buffDetails.valueDecreasingMultiplier = damageData.armorRendingMultiplier;
buffDetails.CalculateEnchantedValue();
if (bIgnoreMagicArmor)
return buffDetails.rawValue; //Take the Raw value for Hollows. Debuffs should not count.
else
return buffDetails.enchantedValue;
}
bool CMonsterWeenie::TryMeleeAttack(uint32_t target_id, ATTACK_HEIGHT height, float power, uint32_t motion)
{
if (IsDead())
{
NotifyAttackDone(WERROR_DEAD);
return true;
}
if (!IsAttacking() && IsBusyOrInAction() || (_blockNewAttacksUntil != -1 && _blockNewAttacksUntil > Timer::cur_time))
{
NotifyAttackDone(WERROR_ACTIONS_LOCKED);
return true;
}
if (AsPlayer())
{
double last_attack_time = 0.0f;
if (AsPlayer()->m_Qualities.InqFloat(ATTACK_TIMESTAMP_FLOAT, last_attack_time))
{
if (last_attack_time > 0.0f) // player has attacked since last login
{
const auto current_time = Timer::cur_time;
if (last_attack_time > current_time)
{
NotifyAttackDone(WERROR_BAD_PARAM);
return true;
}
auto dual_wield_factor = 1.0;
if (get_minterp()->InqStyle() == Motion_DualWieldCombat)
dual_wield_factor = .8f;
const auto attack_delta = ((current_time - last_attack_time) * dual_wield_factor) + .001; // floating point fudge factor
if (power > attack_delta)
{
NotifyAttackDone(WERROR_BAD_PARAM);
return false;
}
}
}
}
if (!m_AttackManager)
{
m_AttackManager = new AttackManager(this);
}
// duplicate attack
m_AttackManager->BeginMeleeAttack(target_id, height, power, m_MonsterAI ? m_MonsterAI->GetChaseDistance() : 15.0f, motion);
m_LastAttackHeight = height;
m_LastAttackPower = power;
m_LastAttackTarget = target_id;
// ensure there's no heartbeat animation
_last_update_pos = Timer::cur_time;
return true;
}
void CMonsterWeenie::TryMissileAttack(uint32_t target_id, ATTACK_HEIGHT height, float power, uint32_t motion)
{
if (IsDead())
{
//NotifyWeenieError(WERROR_DEAD);
NotifyAttackDone(WERROR_DEAD);
return;
}
if (!IsAttacking() && IsBusyOrInAction() || (_blockNewAttacksUntil != -1 && _blockNewAttacksUntil > Timer::cur_time))
{
//NotifyWeenieError(WERROR_ACTIONS_LOCKED);
NotifyAttackDone(WERROR_ACTIONS_LOCKED);
return;
}
if (AsPlayer())
{
double last_attack_time = 0.0f;
if (AsPlayer()->m_Qualities.InqFloat(ATTACK_TIMESTAMP_FLOAT, last_attack_time))
{
if (last_attack_time > 0.0f) // player has attacked since last login
{
std::chrono::time_point<std::chrono::system_clock> now = std::chrono::system_clock::now();
auto duration = now.time_since_epoch();
auto current_time = (double)std::chrono::duration_cast<std::chrono::milliseconds>(duration).count() / 100;
if (last_attack_time > current_time)
{
NotifyAttackDone(WERROR_BAD_PARAM);
return;
}
const auto attack_delta = (current_time - last_attack_time) + .001;;
if (power > attack_delta)
{
NotifyAttackDone(WERROR_BAD_PARAM);
return;
}
}
}
}
if (!m_AttackManager)
m_AttackManager = new AttackManager(this);
m_AttackManager->BeginMissileAttack(target_id, height, power, motion);
m_LastAttackHeight = height;
m_LastAttackPower = power;
m_LastAttackTarget = target_id;
// ensure there's no heartbeat animation
_last_update_pos = Timer::cur_time;
}
BOOL CMonsterWeenie::DoCollision(const class ObjCollisionProfile &prof)
{
if (prof.IsDoor() && !AsPlayer())
{
if (CWeenieObject *weenie = g_pWorld->FindObject(prof.id))
{
if (CBaseDoor *door = weenie->AsDoor())
{
if (!door->IsLocked() && door->IsClosed())
{
door->OpenDoor();
}
}
}
}
return CContainerWeenie::DoCollision(prof);
}
int CMonsterWeenie::AdjustHealth(int amount, bool useRatings)
{
int adjustedAmount = CWeenieObject::AdjustHealth(amount, useRatings);
uint32_t maxHealth = 0;
m_Qualities.InqAttribute2nd(MAX_HEALTH_ATTRIBUTE_2ND, maxHealth, FALSE);
uint32_t currentHealth = 0;
m_Qualities.InqAttribute2nd(HEALTH_ATTRIBUTE_2ND, currentHealth, FALSE);
if (maxHealth == currentHealth)
{
// reset damage sources
m_aDamageSources.clear();
m_highestDamageSource = 0;
m_totalDamageTaken = 0;
}
return adjustedAmount;
}
bool CMonsterWeenie::CheckRareEligible(CWeenieObject *highestDamageDealer)
{
if (!highestDamageDealer)
return false;
if (highestDamageDealer)
{
if (highestDamageDealer->_IsPlayer() && (m_Qualities.GetInt(LEVEL_INT, 0) >= highestDamageDealer->m_Qualities.GetInt(LEVEL_INT, 0)) || (m_Qualities.GetInt(LEVEL_INT, 0) >= 100))
if (m_Qualities.GetDID(DEATH_TREASURE_TYPE_DID, 0))
{
m_bIsRareEligible = true;
return true;
}
}
return false;
}
void CMonsterWeenie::SetDisplayCombatDamage(bool show)
{
m_bGiveCombatData = show;
}
bool CMonsterWeenie::ShowCombatDamage()
{
return m_bGiveCombatData;
}
bool CMonsterWeenie::CanAcceptGive(CWeenieObject* item)
{
if (AsPlayer())
{
if (AsPlayer()->GetCharacterOptions() & AllowGive_CharacterOption)
return Container_CanStore(item);
}
if (InqBoolQuality(ALLOW_GIVE_BOOL, false))
{
if (InqBoolQuality(AI_ACCEPT_EVERYTHING_BOOL, false))
return true;
if (HasEmoteForID(Give_EmoteCategory, item->m_Qualities.id))
return true;
}
return false;
}
int CMonsterWeenie::GetAetheriaSetCount(int setid)
{
int retVal = 0;
auto sigilBlue = GetWielded(SIGIL_ONE_LOC);
if (sigilBlue)
{
int sigilBlueSet;
if (sigilBlue->m_Qualities.InqInt(EQUIPMENT_SET_ID_INT, sigilBlueSet) && sigilBlueSet == setid)
{
retVal += sigilBlue->GetLevel();
}
}
auto sigilYellow = GetWielded(SIGIL_TWO_LOC);
if (sigilYellow)
{
int sigilYellowSet;
if (sigilYellow->m_Qualities.InqInt(EQUIPMENT_SET_ID_INT, sigilYellowSet) && sigilYellowSet == setid)
{
retVal += sigilYellow->GetLevel();
}
}
auto sigilRed = GetWielded(SIGIL_THREE_LOC);
if (sigilRed)
{
int sigilRedSet;
if (sigilRed->m_Qualities.InqInt(EQUIPMENT_SET_ID_INT, sigilRedSet) && sigilRedSet == setid)
{
retVal += sigilRed->GetLevel();
}
}
return retVal;
}
Reference in a new issue View git blame Copy permalink