/*
EQ2Emulator: Everquest II Server Emulator
Copyright (C) 2007 EQ2EMulator Development Team (http://www.eq2emulator.net)
This file is part of EQ2Emulator.
EQ2Emulator is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
EQ2Emulator is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with EQ2Emulator. If not, see .
*/
#include "Spawn.h"
#include
#include "../common/timer.h"
#include
#include
#include "Entity.h"
#include "Widget.h"
#include "Sign.h"
#include "../common/MiscFunctions.h"
#include "../common/Log.h"
#include "Rules/Rules.h"
#include "World.h"
#include "LuaInterface.h"
#include "Bots/Bot.h"
#include "Zone/raycast_mesh.h"
#include "RaceTypes/RaceTypes.h"
#include "VisualStates.h"
extern ConfigReader configReader;
extern RuleManager rule_manager;
extern World world;
extern ZoneList zone_list;
extern MasterRaceTypeList race_types_list;
extern LuaInterface* lua_interface;
extern VisualStates visual_states;
Spawn::Spawn(){
loot_coins = 0;
trap_triggered = false;
trap_state = 0;
chest_drop_time = 0;
trap_opened_time = 0;
group_id = 0;
size_offset = 0;
merchant_id = 0;
merchant_type = 0;
merchant_min_level = 0;
merchant_max_level = 0;
memset(&appearance, 0, sizeof(AppearanceData));
memset(&basic_info, 0, sizeof(BasicInfoStruct));
appearance.pos.state = 0x4080;
appearance.difficulty = 6;
size = 32;
appearance.pos.collision_radius = 32;
id = Spawn::NextID();
oversized_packet = 0xFF;
zone = 0;
spawn_location_id = 0;
spawn_entry_id = 0;
spawn_location_spawns_id = 0;
respawn = 0;
expire_time = 0;
expire_offset = 0;
x_offset = 0;
y_offset = 0;
z_offset = 0;
database_id = 0;
packet_num = 1;
changed = false;
vis_changed = false;
position_changed = false;
send_spawn_changes = true;
info_changed = false;
appearance.pos.Speed1 = 0;
last_attacker = 0;
faction_id = 0;
running_to = 0;
tmp_visual_state = -1;
tmp_action_state = -1;
transporter_id = 0;
invulnerable = false;
spawn_group_list = 0;
MSpawnGroup = 0;
movement_locations = 0;
target = 0;
primary_command_list_id = 0;
secondary_command_list_id = 0;
is_pet = false;
m_followTarget = 0;
following = false;
req_quests_continued_access = false;
req_quests_override = 0;
req_quests_private = false;
m_illusionModel = 0;
Cell_Info.CurrentCell = nullptr;
Cell_Info.CellListIndex = -1;
m_addedToWorldTimestamp = 0;
m_spawnAnim = 0;
m_spawnAnimLeeway = 0;
m_Update.SetName("Spawn::m_Update");
m_requiredHistory.SetName("Spawn::m_requiredHistory");
m_requiredQuests.SetName("Spawn::m_requiredQuests");
last_heading_angle = 0.0;
last_grid_update = 0;
last_location_update = 0.0;
last_movement_update = Timer::GetCurrentTime2();
forceMapCheck = false;
m_followDistance = 0;
MCommandMutex.SetName("Entity::MCommandMutex");
has_spawn_proximities = false;
pickup_item_id = 0;
pickup_unique_item_id = 0;
disable_sounds = false;
has_quests_required = false;
has_history_required = false;
is_flying_creature = false;
is_water_creature = false;
region_map = nullptr;
current_map = nullptr;
RegionMutex.SetName("Spawn::RegionMutex");
pause_timer.Disable();
m_SpawnMutex.SetName("Spawn::SpawnMutex");
appearance_equipment_list.SetAppearanceType(1);
is_transport_spawn = false;
rail_id = 0;
is_omitted_by_db_flag = false;
loot_tier = 0;
loot_drop_type = 0;
deleted_spawn = false;
is_collector = false;
trigger_widget_id = 0;
scared_by_strong_players = false;
is_alive = true;
SetLockedNoLoot(ENCOUNTER_STATE_AVAILABLE);
loot_method = GroupLootMethod::METHOD_FFA;
loot_rarity = 0;
loot_group_id = 0;
looter_spawn_id = 0;
is_loot_complete = false;
is_loot_dispensed = false;
reset_movement = false;
ResetKnockedBack();
}
Spawn::~Spawn(){
is_running = false;
vector::iterator itr;
for (itr = loot_items.begin(); itr != loot_items.end(); itr++)
safe_delete(*itr);
loot_items.clear();
RemovePrimaryCommands();
for(int32 i=0;isize()){
safe_delete(movement_locations->front());
movement_locations->pop_front();
}
safe_delete(movement_locations);
}
MMovementLocations.unlock();
MMovementLoop.lock();
for (int32 i = 0; i < movement_loop.size(); i++)
safe_delete(movement_loop.at(i));
movement_loop.clear();
MMovementLoop.unlock();
m_requiredHistory.writelock(__FUNCTION__, __LINE__);
map::iterator lua_itr;
for (lua_itr = required_history.begin(); lua_itr != required_history.end(); lua_itr++) {
safe_delete(lua_itr->second);
}
required_history.clear();
m_requiredHistory.releasewritelock(__FUNCTION__, __LINE__);
m_requiredQuests.writelock(__FUNCTION__, __LINE__);
map* >::iterator rq_itr;
for (rq_itr = required_quests.begin(); rq_itr != required_quests.end(); rq_itr++){
safe_delete(rq_itr->second);
}
required_quests.clear();
m_requiredQuests.releasewritelock(__FUNCTION__, __LINE__);
// just in case to make sure data is destroyed
RemoveSpawnProximities();
Regions.clear();
}
void Spawn::RemovePrimaryCommands()
{
for (int32 i = 0; i < primary_command_list.size(); i++) {
safe_delete(primary_command_list[i]);
}
primary_command_list.clear();
}
void Spawn::InitializeHeaderPacketData(Player* player, PacketStruct* header, int16 index) {
header->setDataByName("index", index);
if (GetSpawnAnim() > 0 && Timer::GetCurrentTime2() < (GetAddedToWorldTimestamp() + GetSpawnAnimLeeway())) {
if (header->GetVersion() >= 57080)
header->setDataByName("spawn_anim", GetSpawnAnim());
else
header->setDataByName("spawn_anim", (int16)GetSpawnAnim());
}
else {
if (header->GetVersion() >= 57080)
header->setDataByName("spawn_anim", 0xFFFFFFFF);
else
header->setDataByName("spawn_anim", 0xFFFF);
}
if (primary_command_list.size() > 0){
if (primary_command_list.size() > 1) {
header->setArrayLengthByName("command_list", primary_command_list.size());
for (int32 i = 0; i < primary_command_list.size(); i++) {
header->setArrayDataByName("command_list_name", primary_command_list[i]->name.c_str(), i);
header->setArrayDataByName("command_list_max_distance", primary_command_list[i]->distance, i);
header->setArrayDataByName("command_list_error", primary_command_list[i]->error_text.c_str(), i);
header->setArrayDataByName("command_list_command", primary_command_list[i]->command.c_str(), i);
}
}
if (header->GetVersion() <= 561) {
header->setMediumStringByName("default_command", primary_command_list[0]->name.c_str());
}
else
header->setMediumStringByName("default_command", primary_command_list[0]->command.c_str());
header->setDataByName("max_distance", primary_command_list[0]->distance);
}
if (spawn_group_list && MSpawnGroup){
MSpawnGroup->readlock(__FUNCTION__, __LINE__);
header->setArrayLengthByName("group_size", spawn_group_list->size());
vector::iterator itr;
int i = 0;
for (itr = spawn_group_list->begin(); itr != spawn_group_list->end(); itr++, i++){
int32 idx = 0;
idx = player->GetIDWithPlayerSpawn((*itr));
header->setArrayDataByName("group_spawn_id", idx, i);
}
MSpawnGroup->releasereadlock(__FUNCTION__, __LINE__);
}
header->setDataByName("spawn_id", player->GetIDWithPlayerSpawn(this));
header->setDataByName("crc", 1);
header->setDataByName("time_stamp", Timer::GetCurrentTime2());
}
void Spawn::InitializeVisPacketData(Player* player, PacketStruct* vis_packet) {
int16 version = vis_packet->GetVersion();
//why?
/*if (IsPlayer()) {
appearance.pos.grid_id = 0xFFFFFFFF;
}*/
int8 tag_icon = 0;
int32 tmp_id = 0;
if(faction_id && (tag_icon = player->MatchGMVisualFilter(GMTagFilterType::GMFILTERTYPE_FACTION, faction_id, "", true)) > 0);
else if(IsGroundSpawn() && (tag_icon = player->MatchGMVisualFilter(GMTagFilterType::GMFILTERTYPE_GROUNDSPAWN, 1, "", true)) > 0);
else if((this->GetSpawnGroupID() && (tag_icon = player->MatchGMVisualFilter(GMTagFilterType::GMFILTERTYPE_SPAWNGROUP, 1, "", true)) > 0) ||
(!this->GetSpawnGroupID() && (tag_icon = player->MatchGMVisualFilter(GMTagFilterType::GMFILTERTYPE_SPAWNGROUP, 0, "", true)) > 0));
else if((this->GetRace() && (tag_icon = player->MatchGMVisualFilter(GMTagFilterType::GMFILTERTYPE_RACE, GetRace(), "", true)) > 0));
else if(((tmp_id = race_types_list.GetRaceType(GetModelType()) > 0) && (tag_icon = player->MatchGMVisualFilter(GMTagFilterType::GMFILTERTYPE_RACE, tmp_id, "", true)) > 0));
else if(((tmp_id = race_types_list.GetRaceBaseType(GetModelType()) > 0) && (tag_icon = player->MatchGMVisualFilter(GMTagFilterType::GMFILTERTYPE_RACE, tmp_id, "", true)) > 0));
else if(IsEntity() && (tag_icon = ((Entity*)this)->GetInfoStruct()->get_tag1()) > 0);
vis_packet->setDataByName("tag1", tag_icon);
if (IsPlayer())
vis_packet->setDataByName("player", 1);
if (version <= 561) {
vis_packet->setDataByName("targetable", appearance.targetable);
vis_packet->setDataByName("show_name", appearance.display_name);
vis_packet->setDataByName("attackable", appearance.attackable);
if(appearance.attackable == 1)
vis_packet->setDataByName("attackable_icon", 1);
if (IsPlayer()) {
if (((Player*)this)->IsGroupMember(player))
vis_packet->setDataByName("group_member", 1);
}
}
if (appearance.targetable == 1 || appearance.show_level == 1 || appearance.display_name == 1) {
if (!IsGroundSpawn()) {
int8 arrow_color = ARROW_COLOR_WHITE;
sint8 npc_con = player->GetFactions()->GetCon(faction_id);
if (IsPlayer() && !((Player*)this)->CanSeeInvis(player))
npc_con = 0;
else if (!IsPlayer() && IsEntity() && !((Entity*)this)->CanSeeInvis(player))
npc_con = 0;
if (appearance.attackable == 1)
arrow_color = player->GetArrowColor(GetLevel());
if (version <= 373) {
if (GetMerchantID() > 0)
arrow_color += 7;
else {
if (primary_command_list.size() > 0) {
int16 len = strlen(primary_command_list[0]->command.c_str());
if(len >= 4 && strncmp(primary_command_list[0]->command.c_str(), "bank", 4) == 0)
arrow_color += 14;
else if (len >= 4 && strncmp(primary_command_list[0]->command.c_str(), "hail", 4) == 0)
arrow_color += 21;
else if (len >= 6 && strncmp(primary_command_list[0]->command.c_str(), "attack", 6) == 0) {
if (arrow_color > 5)
arrow_color = 34;
else
arrow_color += 29;
}
}
}
}
if(IsNPC() && (((Entity*)this)->GetLockedNoLoot() == ENCOUNTER_STATE_BROKEN ||
(((Entity*)this)->GetLockedNoLoot() == ENCOUNTER_STATE_OVERMATCHED) ||
((Entity*)this)->GetLockedNoLoot() == ENCOUNTER_STATE_LOCKED && !((NPC*)this)->Brain()->IsEntityInEncounter(player->GetID()))) {
vis_packet->setDataByName("arrow_color", ARROW_COLOR_GRAY);
}
else {
vis_packet->setDataByName("arrow_color", arrow_color);
}
if (appearance.attackable == 0 || IsPlayer() || IsBot() || (IsEntity() && ((Entity*)this)->GetOwner() &&
(((Entity*)this)->GetOwner()->IsPlayer() || ((Entity*)this)->GetOwner()->IsBot()))) {
vis_packet->setDataByName("locked_no_loot", 1);
}
else {
vis_packet->setDataByName("locked_no_loot", appearance.locked_no_loot);
}
if (player->GetArrowColor(GetLevel()) == ARROW_COLOR_GRAY)
if (npc_con == -4)
npc_con = -3;
vis_packet->setDataByName("npc_con", npc_con);
if (appearance.attackable == 1 && IsNPC() && (player->GetFactions()->GetCon(faction_id) <= -4 || ((NPC*)this)->Brain()->GetHate(player) > 1)) {
vis_packet->setDataByName("npc_hate", ((NPC*)this)->Brain()->GetHatePercentage(player));
vis_packet->setDataByName("show_difficulty_arrows", 1);
}
int8 quest_flag = player->CheckQuestFlag(this);
if (version < 1188 && quest_flag >= 16)
quest_flag = 1;
vis_packet->setDataByName("quest_flag", quest_flag);
if (player->HasQuestUpdateRequirement(this)) {
vis_packet->setDataByName("name_quest_icon", 1);
}
}
}
int8 vis_flags = 0;
if (MeetsSpawnAccessRequirements(player)) {
if (appearance.attackable == 1)
vis_flags += 64; //attackable icon
if (appearance.show_level == 1)
vis_flags += 32;
if (appearance.display_name == 1)
vis_flags += 16;
if (IsPlayer() || appearance.targetable == 1)
vis_flags += 4;
if (appearance.show_command_icon == 1)
vis_flags += 2;
if (this == player) {
//if (version <= 283) {
// vis_flags = 1;
//}
//else
vis_flags += 1;
}
}
else if (req_quests_override > 0)
{
//Check to see if there's an override value set
vis_flags = req_quests_override & 0xFF;
}
if (player->HasGMVision())
{
if ((vis_flags & 16) == 0 && appearance.display_name == 0)
vis_flags += 16;
if ((vis_flags & 4) == 0)
vis_flags += 4;
}
if (version <= 546 && (vis_flags > 1 || appearance.display_hand_icon > 0)) //interactable
vis_flags = 1;
vis_packet->setDataByName("vis_flags", vis_flags);
if (MeetsSpawnAccessRequirements(player)) {
vis_packet->setDataByName("hand_flag", appearance.display_hand_icon);
}
else {
if ((req_quests_override & 256) > 0)
vis_packet->setDataByName("hand_flag", 1);
}
if ((version == 546 || version == 561) && GetMerchantID() > 0) {
vis_packet->setDataByName("guild", "");
}
}
void Spawn::InitializeFooterPacketData(Player* player, PacketStruct* footer) {
if (IsWidget()){
Widget* widget = (Widget*)this;
if (widget->GetMultiFloorLift()) {
footer->setDataByName("widget_x", widget->GetX());
footer->setDataByName("widget_y", widget->GetY());
footer->setDataByName("widget_z", widget->GetZ());
}
else {
footer->setDataByName("widget_x", widget->GetWidgetX());
footer->setDataByName("widget_y", widget->GetWidgetY());
footer->setDataByName("widget_z", widget->GetWidgetZ());
}
footer->setDataByName("widget_id", widget->GetWidgetID());
}
else if (IsSign()){
Sign* sign = (Sign*)this;
footer->setDataByName("widget_id", sign->GetWidgetID());
footer->setDataByName("widget_x", sign->GetWidgetX());
footer->setDataByName("widget_y", sign->GetWidgetY());
footer->setDataByName("widget_z", sign->GetWidgetZ());
int8 showSignText = 1;
if((HasQuestsRequired() || HasHistoryRequired()) && !MeetsSpawnAccessRequirements(player)) {
showSignText = 0;
}
if (sign->GetSignTitle())
footer->setMediumStringByName("title", sign->GetSignTitle());
if (sign->GetSignDescription())
footer->setMediumStringByName("description", sign->GetSignDescription());
footer->setDataByName("sign_distance", sign->GetSignDistance());
footer->setDataByName("show", showSignText);
// in live we see that the language is set when the player does not have it, otherwise its left as 00's.
if(!player->HasLanguage(sign->GetLanguage())) {
footer->setDataByName("language", sign->GetLanguage());
}
}
if ( IsPlayer())
footer->setDataByName("is_player", 1);
if (strlen(appearance.name) < 1)
strncpy(appearance.name,to_string(GetID()).c_str(),128);
footer->setMediumStringByName("name", appearance.name);
footer->setMediumStringByName("guild", appearance.sub_title);
footer->setMediumStringByName("prefix", appearance.prefix_title);
footer->setMediumStringByName("suffix", appearance.suffix_title);
footer->setMediumStringByName("last_name", appearance.last_name);
if (appearance.attackable == 0 && GetLevel() > 0)
footer->setDataByName("spawn_type", 1);
else if (appearance.attackable == 0)
footer->setDataByName("spawn_type", 6);
else
footer->setDataByName("spawn_type", 3);
}
EQ2Packet* Spawn::spawn_serialize(Player* player, int16 version, int16 offset, int32 value, int16 offset2, int16 offset3, int16 offset4, int32 value2) {
// If spawn is NPC AND is pet && owner is a player && owner is the player passed to this function && player's char sheet pet id is 0
m_Update.writelock(__FUNCTION__, __LINE__);
int16 index = 0;
if ((index = player->GetIndexForSpawn(this)) > 0) {
player->SetSpawnMapIndex(this, index);
}
else {
index = player->SetSpawnMapAndIndex(this);
}
// Jabantiz - [Bug] Client Crash on Revive
if (player->GetIDWithPlayerSpawn(this) == 0) {
player->SetSpawnMap(this);
}
PacketStruct* header = player->GetSpawnHeaderStruct();
header->ResetData();
InitializeHeaderPacketData(player, header, index);
PacketStruct* footer = 0;
if (IsWidget())
footer = player->GetWidgetFooterStruct();
else if (IsSign())
footer = player->GetSignFooterStruct();
else if (version > 561)
footer = player->GetSpawnFooterStruct();
if (footer) {
footer->ResetData();
InitializeFooterPacketData(player, footer);
}
PacketStruct* vis_struct = player->GetSpawnVisStruct();
PacketStruct* info_struct = player->GetSpawnInfoStruct();
PacketStruct* pos_struct = player->GetSpawnPosStruct();
player->info_mutex.writelock(__FUNCTION__, __LINE__);
player->vis_mutex.writelock(__FUNCTION__, __LINE__);
player->pos_mutex.writelock(__FUNCTION__, __LINE__);
info_struct->ResetData();
InitializeInfoPacketData(player, info_struct);
vis_struct->ResetData();
InitializeVisPacketData(player, vis_struct);
pos_struct->ResetData();
InitializePosPacketData(player, pos_struct);
if (version <= 283) {
if (offset == 777) {
info_struct->setDataByName("name", "This is a really long name\n");
info_struct->setDataByName("last_name", "This is a really long LAST name\n");
info_struct->setDataByName("name_suffix", "This is a really long SUFFIX\n");
info_struct->setDataByName("name_prefix", "This is a really long PREFIX\n");
info_struct->setDataByName("unknown", "This is a really long UNKNOWN\n");
info_struct->setDataByName("second_suffix", "This is a really long 2nd SUFFIX\n");
}
//info_struct->setDataByName("unknown2", 3, 0); // level
//info_struct->setDataByName("unknown2", 1, 1); //unknown, two down arrows
//info_struct->setDataByName("unknown2", 1, 2); //unknown
//info_struct->setDataByName("unknown2", 1, 3); //unknown
//info_struct->setDataByName("unknown2", 1, 4); //solo fight
//info_struct->setDataByName("unknown2", 1, 5); //unknown
//info_struct->setDataByName("unknown2", 1, 6); //unknown
//info_struct->setDataByName("unknown2", 1, 7); //merchant
//info_struct->setDataByName("unknown2", 1, 8); //unknown
//info_struct->setDataByName("unknown2", 1, 9); //unknown
//info_struct->setDataByName("unknown2", 1, 10);
//112: 00 00 00 01 02 03 04 05 - 06 07 08 09 0A 00 00 00 | ................ merchant, x4
//112: 00 00 00 01 02 03 04 05 - 00 00 00 00 00 00 00 00 | ................ x4, epic, indifferent
//info_struct->setDataByName("body_size", 42);
//for(int i=0;i<8;i++)
// info_struct->setDataByName("persistent_spell_visuals", 329, i);
//info_struct->setDataByName("persistent_spell_levels", 20);
}
string* vis_data = vis_struct->serializeString();
string* pos_data = pos_struct->serializeString();
string* info_data = info_struct->serializeString();
int16 part2_size = pos_data->length() + vis_data->length() + info_data->length();
uchar* part2 = new uchar[part2_size];
player->AddSpawnPosPacketForXOR(id, (uchar*)pos_data->c_str(), pos_data->length());
player->AddSpawnVisPacketForXOR(id, (uchar*)vis_data->c_str(), vis_data->length());
player->AddSpawnInfoPacketForXOR(id, (uchar*)info_data->c_str(), info_data->length());
int32 vislength = vis_data->length();
int32 poslength = pos_data->length();
int32 infolength = info_data->length();
uchar* ptr = part2;
memcpy(ptr, pos_data->c_str(), pos_data->length());
ptr += pos_data->length();
memcpy(ptr, vis_data->c_str(), vis_data->length());
ptr += vis_data->length();
memcpy(ptr, info_data->c_str(), info_data->length());
player->pos_mutex.releasewritelock(__FUNCTION__, __LINE__);
player->info_mutex.releasewritelock(__FUNCTION__, __LINE__);
player->vis_mutex.releasewritelock(__FUNCTION__, __LINE__);
string* part1 = header->serializeString();
string* part3 = 0;
if (footer)
part3 = footer->serializeString();
//uchar blah7[] = {0x01,0x01,0x00,0x00,0x01,0x01,0x00,0x01,0x01,0x00 };
//uchar blah7[] = { 0x03,0x01,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x00 }; base
//uchar blah7[] = { 0x03,0x00,0x00,0x01,0x01,0x01,0x00,0x01,0x01,0x00 }; //no change
//uchar blah7[] = { 0x03,0x00,0x00,0x00,0x01,0x01,0x00,0x01,0x01,0x00 }; //blue instead of green
//uchar blah7[] = { 0x03,0x00,0x00,0x00,0x00,0x01,0x00,0x01,0x01,0x00 }; //no change
//uchar blah7[] = { 0x03,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x01,0x00 }; //not selectable
//uchar blah7[] = { 0x03,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x01,0x00 }; //no change
//uchar blah7[] = { 0x03,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00 }; //no longer have the two down arrows
//uchar blah7[] = { 0x01,0x00,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x00 }; //arrow color green instead of white/gray
//memcpy(part2 + 77, blah7, sizeof(blah7));
//DumpPacket(part2, 885);
if (offset > 0) {
if (offset4 > 0 && offset4 >= offset3) {
uchar* ptr2 = (uchar*)part2;
ptr2 += offset3;
while (offset4 >= offset3) {
int8 jumpsize = 1;
if (value2 > 0xFFFF) {
memcpy(ptr2, (uchar*)&value2, 4);
jumpsize = 4;
}
else if (value2 > 0xFF) {
memcpy(ptr2, (uchar*)&value2, 2);
jumpsize = 2;
}
else {
memcpy(ptr2, (uchar*)&value2, 1);
jumpsize = 1;
}
ptr2 += jumpsize;
offset4 -= jumpsize;
}
}
if (offset2 > 0 && offset2 >= offset) {
uchar* ptr2 = (uchar*)part2;
ptr2 += offset;
while (offset2 >= offset) {
int8 jumpsize = 1;
if (value > 0xFFFF) {
memcpy(ptr2, (uchar*)&value, 4);
jumpsize = 4;
}
else if (value > 0xFF) {
memcpy(ptr2, (uchar*)&value, 2);
jumpsize = 2;
}
else
memcpy(ptr2, (uchar*)&value, 1);
ptr2 += jumpsize;
offset2 -= jumpsize;
}
}
else {
uchar* ptr2 = (uchar*)part2;
ptr2 += offset;
if (value > 0xFFFF)
memcpy(ptr2, (uchar*)&value, 4);
else if (value > 0xFF)
memcpy(ptr2, (uchar*)&value, 2);
else
memcpy(ptr2, (uchar*)&value, 1);
}
cout << "setting offset: " << offset << " to: " << value << endl;
}
//if (offset > 0)
// DumpPacket(part2, part2_size);
uchar tmp[4000];
bool reverse = (version > 373);
part2_size = Pack(tmp, part2, part2_size, 4000, version, reverse);
int32 total_size = part1->length() + part2_size + 3;
if (part3)
total_size += part3->length();
int32 final_packet_size = total_size + 1;
if (version > 373)
final_packet_size += 3;
else {
if (final_packet_size >= 255) {
final_packet_size += 2;
}
}
uchar* final_packet = new uchar[final_packet_size];
ptr = final_packet;
if (version <= 373) {
if ((final_packet_size - total_size) > 1) {
memcpy(ptr, &oversized_packet, sizeof(oversized_packet));
ptr += sizeof(oversized_packet);
memcpy(ptr, &total_size, 2);
ptr += 2;
}
else {
memcpy(ptr, &total_size, 1);
ptr += 1;
}
}
else {
memcpy(ptr, &total_size, sizeof(total_size));
ptr += sizeof(total_size);
}
memcpy(ptr, &oversized_packet, sizeof(oversized_packet));
ptr += sizeof(oversized_packet);
int16 opcode = 0;
if (EQOpcodeManager.count(GetOpcodeVersion(version)) != 0) {
if(IsWidget())
opcode = EQOpcodeManager[GetOpcodeVersion(version)]->EmuToEQ(OP_EqCreateWidgetCmd);
else if(IsSign())
opcode = EQOpcodeManager[GetOpcodeVersion(version)]->EmuToEQ(OP_EqCreateSignWidgetCmd);
else
opcode = EQOpcodeManager[GetOpcodeVersion(version)]->EmuToEQ(OP_EqCreateGhostCmd);
}
memcpy(ptr, &opcode, sizeof(opcode));
ptr += sizeof(opcode);
memcpy(ptr, part1->c_str(), part1->length());
ptr += part1->length();
memcpy(ptr, tmp, part2_size);
ptr += part2_size;
if (part3)
memcpy(ptr, part3->c_str(), part3->length());
delete[] part2;
//printf("SpawnPacket %s (id: %u, index: %u) to %s: p1: %i, p2: %i, p3: %i, ts: %i. poslength: %u, infolength: %u, vislength: %u\n", GetName(), GetID(), index, player->GetName(), part1->length(), part2_size, (part3 != nullptr) ? part3->length() : -1, total_size, poslength, infolength, vislength);
EQ2Packet* ret = new EQ2Packet(OP_ClientCmdMsg, final_packet, final_packet_size);
delete[] final_packet;
m_Update.releasewritelock(__FUNCTION__, __LINE__);
return ret;
}
uchar* Spawn::spawn_info_changes(Player* player, int16 version, int16* info_packet_size){
int16 index = player->GetIndexForSpawn(this);
PacketStruct* packet = player->GetSpawnInfoStruct();
player->info_mutex.writelock(__FUNCTION__, __LINE__);
packet->ResetData();
InitializeInfoPacketData(player, packet);
string* data = packet->serializeString();
int32 size = data->length();
uchar* xor_info_packet = player->GetTempInfoPacketForXOR();
if (!xor_info_packet || size != player->GetTempInfoXorSize())
{
LogWrite(ZONE__DEBUG, 0, "Zone", "InstantiateInfoPacket: %i, %i", size, player->GetTempInfoXorSize());
safe_delete(xor_info_packet);
xor_info_packet = player->SetTempInfoPacketForXOR(size);
}
uchar* orig_packet = player->GetSpawnInfoPacketForXOR(id);
if(orig_packet){
memcpy(xor_info_packet, (uchar*)data->c_str(), size);
Encode(xor_info_packet, orig_packet, size);
}
bool changed = false;
for (int i = 0; i < size; ++i) {
if (xor_info_packet[i]) {
changed = true;
break;
}
}
if (!changed) {
player->info_mutex.releasewritelock(__FUNCTION__, __LINE__);
return nullptr;
}
uchar* tmp = new uchar[size + 1000];
size = Pack(tmp, xor_info_packet, size, size+1000, version);
player->info_mutex.releasewritelock(__FUNCTION__, __LINE__);
int32 orig_size = size;
size-=sizeof(int32);
size+=CheckOverLoadSize(index);
*info_packet_size = size + CheckOverLoadSize(size);
uchar* tmp2 = new uchar[*info_packet_size];
uchar* ptr = tmp2;
ptr += DoOverLoad(size, ptr);
ptr += DoOverLoad(index, ptr);
memcpy(ptr, tmp+sizeof(int32), orig_size - sizeof(int32));
delete[] tmp;
return tmp2;
}
uchar* Spawn::spawn_vis_changes(Player* player, int16 version, int16* vis_packet_size){
PacketStruct* vis_struct = player->GetSpawnVisStruct();
int16 index = player->GetIndexForSpawn(this);
player->vis_mutex.writelock(__FUNCTION__, __LINE__);
uchar* orig_packet = player->GetSpawnVisPacketForXOR(id);
vis_struct->ResetData();
InitializeVisPacketData(player, vis_struct);
string* data = vis_struct->serializeString();
int32 size = data->length();
uchar* xor_vis_packet = player->GetTempVisPacketForXOR();
if (!xor_vis_packet || size != player->GetTempVisXorSize())
{
LogWrite(ZONE__DEBUG, 0, "Zone", "InstantiateVisPacket: %i, %i", size, player->GetTempVisXorSize());
safe_delete(xor_vis_packet);
xor_vis_packet = player->SetTempVisPacketForXOR(size);
}
if(orig_packet){
memcpy(xor_vis_packet, (uchar*)data->c_str(), size);
Encode(xor_vis_packet, orig_packet, size);
}
bool changed = false;
for (int i = 0; i < size; ++i) {
if (xor_vis_packet[i]) {
changed = true;
break;
}
}
if (!changed) {
player->vis_mutex.releasewritelock(__FUNCTION__, __LINE__);
return nullptr;
}
uchar* tmp = new uchar[size + 1000];
size = Pack(tmp, xor_vis_packet, size, size+1000, version);
player->vis_mutex.releasewritelock(__FUNCTION__, __LINE__);
int32 orig_size = size;
size-=sizeof(int32);
size+=CheckOverLoadSize(index);
*vis_packet_size = size + CheckOverLoadSize(size);
uchar* tmp2 = new uchar[*vis_packet_size];
uchar* ptr = tmp2;
ptr += DoOverLoad(size, ptr);
ptr += DoOverLoad(index, ptr);
memcpy(ptr, tmp+sizeof(int32), orig_size - sizeof(int32));
delete[] tmp;
return tmp2;
}
uchar* Spawn::spawn_pos_changes(Player* player, int16 version, int16* pos_packet_size, bool override_) {
int16 index = player->GetIndexForSpawn(this);
PacketStruct* packet = player->GetSpawnPosStruct();
player->pos_mutex.writelock(__FUNCTION__, __LINE__);
uchar* orig_packet = player->GetSpawnPosPacketForXOR(id);
packet->ResetData();
InitializePosPacketData(player, packet, true);
string* data = packet->serializeString();
int32 size = data->length();
uchar* xor_pos_packet = player->GetTempPosPacketForXOR();
if (!xor_pos_packet || size != player->GetTempPosXorSize())
{
LogWrite(ZONE__DEBUG, 0, "Zone", "InstantiatePosPacket: %i, %i", size, player->GetTempPosXorSize());
safe_delete(xor_pos_packet);
xor_pos_packet = player->SetTempPosPacketForXOR(size);
}
if(orig_packet){
memcpy(xor_pos_packet, (uchar*)data->c_str(), size);
Encode(xor_pos_packet, orig_packet, size);
}
bool changed = false;
for (int i = 0; i < size; ++i) {
if (xor_pos_packet[i]) {
changed = true;
break;
}
}
if (!changed && !override_) {
player->pos_mutex.releasewritelock(__FUNCTION__, __LINE__);
return nullptr;
}
int16 newSize = size + 1000;
uchar* tmp = new uchar[newSize];
size = Pack(tmp, xor_pos_packet, size, newSize, version);
player->pos_mutex.releasewritelock(__FUNCTION__, __LINE__);
int32 orig_size = size;
// Needed for CoE+ clients
if (version >= 1188)
size += 1;
if(IsPlayer() && version > 561)
size += 4;
size-=sizeof(int32);
size+=CheckOverLoadSize(index);
*pos_packet_size = size + CheckOverLoadSize(size);
uchar* tmp2 = new uchar[*pos_packet_size];
uchar* ptr = tmp2;
ptr += DoOverLoad(size, ptr);
ptr += DoOverLoad(index, ptr);
// extra byte in coe+ clients, 0 for NPC's 1 for Players
int8 x = 0;
if (IsPlayer() && version > 561) {
if (version >= 1188) {
// set x to 1 and add it to the packet
x = 1;
memcpy(ptr, &x, sizeof(int8));
ptr += sizeof(int8);
}
int32 now = Timer::GetCurrentTime2();
memcpy(ptr, &now, sizeof(int32));
ptr += sizeof(int32);
}
else if (version >= 1188) {
// add x to packet
memcpy(ptr, &x, sizeof(int8));
ptr += sizeof(int8);
}
memcpy(ptr, tmp+sizeof(int32), orig_size - sizeof(int32));
delete[] tmp;
return tmp2;
}
EQ2Packet* Spawn::player_position_update_packet(Player* player, int16 version, bool override_){
if(!player || player->IsPlayer() == false){
LogWrite(SPAWN__ERROR, 0, "Spawn", "Error: Called player_position_update_packet without player!");
return 0;
}
else if(IsPlayer() == false){
LogWrite(SPAWN__ERROR, 0, "Spawn", "Error: Called player_position_update_packet from spawn!");
return 0;
}
static const int8 info_size = 1;
static const int8 vis_size = 1;
int16 pos_packet_size = 0;
m_Update.writelock(__FUNCTION__, __LINE__);
uchar* pos_changes = spawn_pos_changes(player, version, &pos_packet_size, override_);
if (pos_changes == NULL)
{
printf("%s returned null for pos changes\n", GetName());
m_Update.releasewritelock(__FUNCTION__, __LINE__);
return NULL;
}
int32 size = info_size + pos_packet_size + vis_size + 8;
if (version >= 374)
size += 3;
else if (version <= 373 && size >= 255) {//1 byte to 3 for overloaded val
size += 2;
}
static const int8 oversized = 255;
int16 opcode_val = 0;
if (EQOpcodeManager.count(GetOpcodeVersion(version)) != 0) {
opcode_val = EQOpcodeManager[GetOpcodeVersion(version)]->EmuToEQ(OP_EqUpdateGhostCmd);
}
uchar* tmp = new uchar[size];
memset(tmp, 0, size);
uchar* ptr = tmp;
if (version >= 374) {
size -= 4;
memcpy(ptr, &size, sizeof(int32));
size += 4;
ptr += sizeof(int32);
}
else {
if (size >= 255) {
memcpy(ptr, &oversized, sizeof(int8));
ptr += sizeof(int8);
size -= 3;
memcpy(ptr, &size, sizeof(int16));
size += 3;
ptr += 3;
}
else {
size -= 1;
memcpy(ptr, &size, sizeof(int8));
ptr += sizeof(int8);
size += 1;
ptr += 1;
}
}
memcpy(ptr, &oversized, sizeof(int8));
ptr += sizeof(int8);
memcpy(ptr, &opcode_val, sizeof(int16));
ptr += sizeof(int16);
if (version <= 373) {
int32 timestamp = Timer::GetCurrentTime2();
memcpy(ptr, ×tamp, sizeof(int32));
}
ptr += sizeof(int32);
ptr += info_size;
memcpy(ptr, pos_changes, pos_packet_size);
delete[] pos_changes;
m_Update.releasewritelock(__FUNCTION__, __LINE__);
EQ2Packet* ret_packet = new EQ2Packet(OP_ClientCmdMsg, tmp, size);
// DumpPacket(ret_packet);
delete[] tmp;
return ret_packet;
}
EQ2Packet* Spawn::spawn_update_packet(Player* player, int16 version, bool override_changes, bool override_vis_changes){
if(!player || player->IsPlayer() == false){
LogWrite(SPAWN__ERROR, 0, "Spawn", "Error: Called spawn_update_packet without player!");
return 0;
}
else if((IsPlayer() && info_changed == false && vis_changed == false) || (info_changed == false && vis_changed == false && position_changed == false)){
if(!override_changes && !override_vis_changes)
return 0;
}
uchar* info_changes = 0;
uchar* pos_changes = 0;
uchar* vis_changes = 0;
static const int8 oversized = 255;
int16 opcode_val = 0;
if (EQOpcodeManager.count(GetOpcodeVersion(version)) != 0) {
opcode_val = EQOpcodeManager[GetOpcodeVersion(version)]->EmuToEQ(OP_EqUpdateGhostCmd);
}
//We need to lock these variables up to make this thread safe
m_Update.writelock(__FUNCTION__, __LINE__);
//These variables are set in the spawn_info_changes, pos and vis changes functions
int16 info_packet_size = 1;
int16 pos_packet_size = 1;
int16 vis_packet_size = 1;
if (info_changed || override_changes)
info_changes = spawn_info_changes(player, version, &info_packet_size);
if ((position_changed || override_changes) && IsPlayer() == false)
pos_changes = spawn_pos_changes(player, version, &pos_packet_size);
if (vis_changed || override_changes || override_vis_changes)
vis_changes = spawn_vis_changes(player, version, &vis_packet_size);
int32 size = info_packet_size + pos_packet_size + vis_packet_size + 8;
if (version >= 374)
size += 3;
else if (version <= 373 && size >= 255) {//1 byte to 3 for overloaded val
size += 2;
}
uchar* tmp = new uchar[size];
memset(tmp, 0, size);
uchar* ptr = tmp;
if (version >= 374) {
size -= 4;
memcpy(ptr, &size, sizeof(int32));
size += 4;
ptr += sizeof(int32);
}
else {
if (size >= 255) {
memcpy(ptr, &oversized, sizeof(int8));
ptr += sizeof(int8);
size -= 3;
memcpy(ptr, &size, sizeof(int16));
size += 3;
ptr += 3;
}
else {
size -= 1;
memcpy(ptr, &size, sizeof(int8));
ptr += sizeof(int8);
size += 1;
}
}
memcpy(ptr, &oversized, sizeof(int8));
ptr += sizeof(int8);
memcpy(ptr, &opcode_val, sizeof(int16));
ptr += sizeof(int16);
if (IsPlayer() == false || version <= 546) { //this isnt sent for player updates, it is sent on position update
//int32 time = Timer::GetCurrentTime2();
packet_num = Timer::GetCurrentTime2();
memcpy(ptr, &packet_num, sizeof(int32));
}
ptr += sizeof(int32);
if(info_changes)
memcpy(ptr, info_changes, info_packet_size);
ptr += info_packet_size;
if(pos_changes)
memcpy(ptr, pos_changes, pos_packet_size);
ptr += pos_packet_size;
if(vis_changes)
memcpy(ptr, vis_changes, vis_packet_size);
EQ2Packet* ret_packet = 0;
if(info_packet_size + pos_packet_size + vis_packet_size > 0)
ret_packet = new EQ2Packet(OP_ClientCmdMsg, tmp, size);
delete[] tmp;
safe_delete_array(info_changes);
safe_delete_array(vis_changes);
safe_delete_array(pos_changes);
m_Update.releasewritelock(__FUNCTION__, __LINE__);
return ret_packet;
}
uchar* Spawn::spawn_info_changes_ex(Player* player, int16 version, int16* info_packet_size) {
int16 index = player->GetIndexForSpawn(this);
PacketStruct* packet = player->GetSpawnInfoStruct();
player->info_mutex.writelock(__FUNCTION__, __LINE__);
packet->ResetData();
InitializeInfoPacketData(player, packet);
string* data = packet->serializeString();
int32 size = data->length();
uchar* xor_info_packet = player->GetTempInfoPacketForXOR();
if (!xor_info_packet || size != player->GetTempInfoXorSize()) {
LogWrite(ZONE__DEBUG, 0, "Zone", "InstantiateInfoExPacket: %i, %i", size, player->GetTempInfoXorSize());
safe_delete(xor_info_packet);
xor_info_packet = player->SetTempInfoPacketForXOR(size);
}
uchar* orig_packet = player->GetSpawnInfoPacketForXOR(id);
if (orig_packet) {
//if (!IsPlayer() && this->EngagedInCombat())
//packet->PrintPacket();
memcpy(xor_info_packet, (uchar*)data->c_str(), size);
Encode(xor_info_packet, orig_packet, size);
}
bool changed = false;
for (int i = 0; i < size; ++i) {
if (xor_info_packet[i]) {
changed = true;
break;
}
}
if (!changed) {
player->info_mutex.releasewritelock(__FUNCTION__, __LINE__);
return nullptr;
}
uchar* tmp = new uchar[size + 1000];
size = Pack(tmp, xor_info_packet, size, size+1000, version);
player->info_mutex.releasewritelock(__FUNCTION__, __LINE__);
int32 orig_size = size;
size -= sizeof(int32);
size += CheckOverLoadSize(index);
*info_packet_size = size;
uchar* tmp2 = new uchar[size];
uchar* ptr = tmp2;
ptr += DoOverLoad(index, ptr);
memcpy(ptr, tmp + sizeof(int32), orig_size - sizeof(int32));
delete[] tmp;
return move(tmp2);
}
uchar* Spawn::spawn_vis_changes_ex(Player* player, int16 version, int16* vis_packet_size) {
PacketStruct* vis_struct = player->GetSpawnVisStruct();
int16 index = player->GetIndexForSpawn(this);
player->vis_mutex.writelock(__FUNCTION__, __LINE__);
uchar* orig_packet = player->GetSpawnVisPacketForXOR(id);
vis_struct->ResetData();
InitializeVisPacketData(player, vis_struct);
string* data = vis_struct->serializeString();
int32 size = data->length();
uchar* xor_vis_packet = player->GetTempVisPacketForXOR();
if (!xor_vis_packet || size != player->GetTempVisXorSize()) {
LogWrite(ZONE__DEBUG, 0, "Zone", "InstantiateVisExPacket: %i, %i", size, player->GetTempVisXorSize());
safe_delete(xor_vis_packet);
xor_vis_packet = player->SetTempVisPacketForXOR(size);
}
if (orig_packet) {
//if (!IsPlayer() && this->EngagedInCombat())
// vis_struct->PrintPacket();
memcpy(xor_vis_packet, (uchar*)data->c_str(), size);
Encode(xor_vis_packet, orig_packet, size);
}
bool changed = false;
for (int i = 0; i < size; ++i) {
if (xor_vis_packet[i]) {
changed = true;
break;
}
}
if (!changed) {
player->vis_mutex.releasewritelock(__FUNCTION__, __LINE__);
return nullptr;
}
uchar* tmp = new uchar[size + 1000];
size = Pack(tmp, xor_vis_packet, size, size+1000, version);
player->vis_mutex.releasewritelock(__FUNCTION__, __LINE__);
int32 orig_size = size;
size -= sizeof(int32);
size += CheckOverLoadSize(index);
*vis_packet_size = size;
uchar* tmp2 = new uchar[size];
uchar* ptr = tmp2;
ptr += DoOverLoad(index, ptr);
memcpy(ptr, tmp + sizeof(int32), orig_size - sizeof(int32));
delete[] tmp;
return move(tmp2);
}
uchar* Spawn::spawn_pos_changes_ex(Player* player, int16 version, int16* pos_packet_size) {
int16 index = player->GetIndexForSpawn(this);
PacketStruct* packet = player->GetSpawnPosStruct();
player->pos_mutex.writelock(__FUNCTION__, __LINE__);
uchar* orig_packet = player->GetSpawnPosPacketForXOR(id);
packet->ResetData();
InitializePosPacketData(player, packet);
string* data = packet->serializeString();
int32 size = data->length();
uchar* xor_pos_packet = player->GetTempPosPacketForXOR();
if (!xor_pos_packet || size != player->GetTempPosXorSize()) {
LogWrite(ZONE__DEBUG, 0, "Zone", "InstantiatePosExPacket: %i, %i", size, player->GetTempPosXorSize());
safe_delete(xor_pos_packet);
xor_pos_packet = player->SetTempPosPacketForXOR(size);
}
if (orig_packet) {
//if (!IsPlayer() && this->EngagedInCombat())
// packet->PrintPacket();
memcpy(xor_pos_packet, (uchar*)data->c_str(), size);
Encode(xor_pos_packet, orig_packet, size);
}
bool changed = false;
for (int i = 0; i < size; ++i) {
if (xor_pos_packet[i]) {
changed = true;
break;
}
}
if (!changed && version > 561) {
player->pos_mutex.releasewritelock(__FUNCTION__, __LINE__);
return nullptr;
}
int16 newSize = size + 1000;
uchar* tmp = new uchar[newSize];
size = Pack(tmp, xor_pos_packet, size, newSize, version);
player->pos_mutex.releasewritelock(__FUNCTION__, __LINE__);
int32 orig_size = size;
if (version >= 1188) {
size += 1;
}
if (IsPlayer() && version > 561) {
size += 4;
}
size -= sizeof(int32);
size += CheckOverLoadSize(index);
*pos_packet_size = size;
uchar* tmp2 = new uchar[size];
uchar* ptr = tmp2;
ptr += DoOverLoad(index, ptr);
// extra byte in coe+ clients, 0 for NPC's 1 for Players
int8 x = 0;
if (version > 561) {
if (IsPlayer()) {
if (version >= 1188) {
x = 1;
memcpy(ptr, &x, sizeof(int8));
ptr += sizeof(int8);
}
int32 now = Timer::GetCurrentTime2();
memcpy(ptr, &now, sizeof(int32));
ptr += sizeof(int32);
}
else if (version >= 1188) {
memcpy(ptr, &x, sizeof(int8));
ptr += sizeof(int8);
}
}
memcpy(ptr, tmp + sizeof(int32), orig_size - sizeof(int32));
delete[] tmp;
return move(tmp2);
}
EQ2Packet* Spawn::serialize(Player* player, int16 version){
return 0;
}
Spawn* Spawn::GetTarget(){
Spawn* ret = 0;
// only attempt to get a spawn if we had a target stored
if (target != 0)
{
ret = GetZone()->GetSpawnByID(target);
if (!ret)
target = 0;
}
return ret;
}
void Spawn::SetTarget(Spawn* spawn){
SetInfo(&target, spawn ? spawn->GetID() : 0);
}
Spawn* Spawn::GetLastAttacker() {
Spawn* ret = 0;
ret = GetZone()->GetSpawnByID(last_attacker);
if (!ret)
last_attacker = 0;
return ret;
}
void Spawn::SetLastAttacker(Spawn* spawn){
last_attacker = spawn->GetID();
}
void Spawn::SetInvulnerable(bool val){
invulnerable = val;
}
bool Spawn::GetInvulnerable(){
return invulnerable;
}
bool Spawn::TakeDamage(int32 damage){
if(invulnerable)
return false;
if (IsEntity()) {
if (((Entity*)this)->IsMezzed())
((Entity*)this)->RemoveAllMezSpells();
if (damage == 0)
return true;
}
int32 hp = GetHP();
if(damage >= hp) {
SetHP(0);
if (IsPlayer()) {
((Player*)this)->InCombat(false);
((Player*)this)->SetRangeAttack(false);
GetZone()->TriggerCharSheetTimer(); // force char sheet updates now
}
}
else {
SetHP(hp - damage);
// if player flag the char sheet as changed so the ui updates properly
if (IsPlayer())
((Player*)this)->SetCharSheetChanged(true);
}
return true;
}
ZoneServer* Spawn::GetZone(){
return zone;
}
void Spawn::SetZone(ZoneServer* in_zone, int32 version){
zone = in_zone;
if(in_zone)
{
region_map = world.GetRegionMap(std::string(in_zone->GetZoneFile()), version);
current_map = world.GetMap(std::string(in_zone->GetZoneFile()), version);
}
else
{
region_map = nullptr;
current_map = nullptr;
}
}
/*** HIT POINT ***/
void Spawn::SetHP(sint32 new_val, bool setUpdateFlags){
if(new_val == 0){
ClearRunningLocations();
CalculateRunningLocation(true);
if(IsEntity()) {
is_alive = false;
}
}
if(IsNPC() && new_val > 0 && !is_alive) {
is_alive = true;
}
else if(IsPlayer() && new_val > 0 && !is_alive) {
LogWrite(SPAWN__ERROR, 0, "Spawn", "Cannot change player HP > 0 while dead (%s)! Player must revive.", GetName());
return;
}
if(new_val > basic_info.max_hp)
SetInfo(&basic_info.max_hp, new_val, setUpdateFlags);
SetInfo(&basic_info.cur_hp, new_val, setUpdateFlags);
if(/*IsPlayer() &&*/ GetZone() && basic_info.cur_hp > 0 && basic_info.cur_hp < basic_info.max_hp)
GetZone()->AddDamagedSpawn(this);
SendGroupUpdate();
if ( IsPlayer() && new_val == 0 ) // fixes on death not showing hp update for players
((Player*)this)->SetCharSheetChanged(true);
if (IsNPC() && ((NPC*)this)->IsPet() && ((NPC*)this)->GetOwner() && ((NPC*)this)->GetOwner()->IsPlayer()) {
Player* player = (Player*)((NPC*)this)->GetOwner();
if (player->GetPet() && player->GetCharmedPet()) {
if (this == player->GetPet()) {
player->GetInfoStruct()->set_pet_health_pct((float)basic_info.cur_hp / (float)basic_info.max_hp);
player->SetCharSheetChanged(true);
}
}
else {
player->GetInfoStruct()->set_pet_health_pct((float)basic_info.cur_hp / (float)basic_info.max_hp);
player->SetCharSheetChanged(true);
}
}
}
void Spawn::SetTotalHP(sint32 new_val){
if(basic_info.hp_base == 0) {
SetTotalHPBase(new_val);
SetTotalHPBaseInstance(new_val);
}
SetInfo(&basic_info.max_hp, new_val);
if(GetZone() && basic_info.cur_hp > 0 && basic_info.cur_hp < basic_info.max_hp)
GetZone()->AddDamagedSpawn(this);
SendGroupUpdate();
if (IsNPC() && ((NPC*)this)->IsPet() && ((NPC*)this)->GetOwner() != nullptr && ((NPC*)this)->GetOwner()->IsPlayer()) {
Player* player = (Player*)((NPC*)this)->GetOwner();
if (basic_info.max_hp && player->GetPet() && player->GetCharmedPet()) {
if (this == player->GetPet()) {
player->GetInfoStruct()->set_pet_health_pct((float)basic_info.cur_hp / (float)basic_info.max_hp);
player->SetCharSheetChanged(true);
}
}
else if(basic_info.max_hp) {
player->GetInfoStruct()->set_pet_health_pct((float)basic_info.cur_hp / (float)basic_info.max_hp);
player->SetCharSheetChanged(true);
}
}
}
void Spawn::SetTotalHPBase(sint32 new_val)
{
SetInfo(&basic_info.hp_base, new_val);
if(GetZone() && basic_info.cur_hp > 0 && basic_info.cur_hp < basic_info.max_hp)
GetZone()->AddDamagedSpawn(this);
SendGroupUpdate();
}
void Spawn::SetTotalHPBaseInstance(sint32 new_val)
{
SetInfo(&basic_info.hp_base_instance, new_val);
}
sint32 Spawn::GetHP()
{
return basic_info.cur_hp;
}
sint32 Spawn::GetTotalHP()
{
return basic_info.max_hp;
}
sint32 Spawn::GetTotalHPBase()
{
return basic_info.hp_base;
}
sint32 Spawn::GetTotalHPBaseInstance()
{
return basic_info.hp_base_instance;
}
sint32 Spawn::GetTotalPowerBaseInstance()
{
return basic_info.power_base_instance;
}
/*** POWER ***/
void Spawn::SetPower(sint32 power, bool setUpdateFlags){
if(power > basic_info.max_power)
SetInfo(&basic_info.max_power, power, setUpdateFlags);
SetInfo(&basic_info.cur_power, power, setUpdateFlags);
if(/*IsPlayer() &&*/ GetZone() && basic_info.cur_power < basic_info.max_power)
GetZone()->AddDamagedSpawn(this);
SendGroupUpdate();
if (IsNPC() && ((NPC*)this)->IsPet() && ((NPC*)this)->GetOwner() != nullptr && ((NPC*)this)->GetOwner()->IsPlayer()) {
Player* player = (Player*)((NPC*)this)->GetOwner();
if (player->GetPet() && player->GetCharmedPet()) {
if (this == player->GetPet()) {
player->GetInfoStruct()->set_pet_power_pct((float)basic_info.cur_power / (float)basic_info.max_power);
player->SetCharSheetChanged(true);
}
}
else {
player->GetInfoStruct()->set_pet_power_pct((float)basic_info.cur_power / (float)basic_info.max_power);
player->SetCharSheetChanged(true);
}
}
}
void Spawn::SetTotalPower(sint32 new_val)
{
if(basic_info.power_base == 0) {
SetTotalPowerBase(new_val);
SetTotalPowerBaseInstance(new_val);
}
SetInfo(&basic_info.max_power, new_val);
if(GetZone() && basic_info.cur_power < basic_info.max_power)
GetZone()->AddDamagedSpawn(this);
SendGroupUpdate();
if (IsNPC() && ((NPC*)this)->IsPet() && ((NPC*)this)->GetOwner() != nullptr && ((NPC*)this)->GetOwner()->IsPlayer()) {
Player* player = (Player*)((NPC*)this)->GetOwner();
if (player->GetPet() && player->GetCharmedPet()) {
if (this == player->GetPet()) {
player->GetInfoStruct()->set_pet_power_pct((float)basic_info.cur_power / (float)basic_info.max_power);
player->SetCharSheetChanged(true);
}
}
else {
player->GetInfoStruct()->set_pet_power_pct((float)basic_info.cur_power / (float)basic_info.max_power);
player->SetCharSheetChanged(true);
}
}
}
void Spawn::SetTotalPowerBase(sint32 new_val)
{
SetInfo(&basic_info.power_base, new_val);
if(GetZone() && basic_info.cur_power < basic_info.max_power)
GetZone()->AddDamagedSpawn(this);
SendGroupUpdate();
}
void Spawn::SetTotalPowerBaseInstance(sint32 new_val)
{
SetInfo(&basic_info.power_base_instance, new_val);
}
sint32 Spawn::GetPower()
{
return basic_info.cur_power;
}
sint32 Spawn::GetTotalPower(){
return basic_info.max_power;
}
sint32 Spawn::GetTotalPowerBase()
{
return basic_info.power_base;
}
/*** SAVAGERY ***/
void Spawn::SetSavagery(sint32 savagery, bool setUpdateFlags)
{
/* JA: extremely limited functionality until we better understand Savagery */
if(savagery > basic_info.max_savagery)
SetInfo(&basic_info.max_savagery, savagery, setUpdateFlags);
SetInfo(&basic_info.cur_savagery, savagery, setUpdateFlags);
}
void Spawn::SetTotalSavagery(sint32 new_val)
{
/* JA: extremely limited functionality until we better understand Savagery */
if(basic_info.savagery_base == 0)
SetTotalSavageryBase(new_val);
SetInfo(&basic_info.max_savagery, new_val);
}
void Spawn::SetTotalSavageryBase(sint32 new_val){
SetInfo(&basic_info.savagery_base, new_val);
SendGroupUpdate();
}
sint32 Spawn::GetTotalSavagery()
{
return basic_info.max_savagery;
}
sint32 Spawn::GetSavagery()
{
return basic_info.cur_savagery;
}
/*** DISSONANCE ***/
void Spawn::SetDissonance(sint32 dissonance, bool setUpdateFlags)
{
/* JA: extremely limited functionality until we better understand Dissonance */
if(dissonance > basic_info.max_dissonance)
SetInfo(&basic_info.max_dissonance, dissonance, setUpdateFlags);
SetInfo(&basic_info.cur_dissonance, dissonance, setUpdateFlags);
}
void Spawn::SetTotalDissonance(sint32 new_val)
{
/* JA: extremely limited functionality until we better understand Dissonance */
if(basic_info.dissonance_base == 0)
SetTotalDissonanceBase(new_val);
SetInfo(&basic_info.max_dissonance, new_val);
}
void Spawn::SetTotalDissonanceBase(sint32 new_val)
{
SetInfo(&basic_info.dissonance_base, new_val);
SendGroupUpdate();
}
sint32 Spawn::GetTotalDissonance()
{
return basic_info.max_dissonance;
}
sint32 Spawn::GetDissonance()
{
return basic_info.cur_dissonance;
}
/* --< Alternate Advancement Points >-- */
void Spawn::SetAssignedAA(sint16 new_val)
{
SetInfo(&basic_info.assigned_aa, new_val);
}
void Spawn::SetUnassignedAA(sint16 new_val)
{
SetInfo(&basic_info.unassigned_aa, new_val);
}
void Spawn::SetTradeskillAA(sint16 new_val)
{
SetInfo(&basic_info.tradeskill_aa, new_val);
}
void Spawn::SetUnassignedTradeskillAA(sint16 new_val)
{
SetInfo(&basic_info.unassigned_tradeskill_aa, new_val);
}
void Spawn::SetPrestigeAA(sint16 new_val)
{
SetInfo(&basic_info.prestige_aa, new_val);
}
void Spawn::SetUnassignedPrestigeAA(sint16 new_val)
{
SetInfo(&basic_info.unassigned_prestige_aa, new_val);
}
void Spawn::SetTradeskillPrestigeAA(sint16 new_val)
{
SetInfo(&basic_info.tradeskill_prestige_aa, new_val);
}
void Spawn::SetUnassignedTradeskillPrestigeAA(sint16 new_val)
{
SetInfo(&basic_info.unassigned_tradeskill_prestige_aa, new_val);
}
void Spawn::SetAAXPRewards(int32 value)
{
SetInfo(&basic_info.aaxp_rewards, value, false);
}
sint16 Spawn::GetAssignedAA()
{
return basic_info.assigned_aa;
}
sint16 Spawn::GetUnassignedAA()
{
return basic_info.unassigned_aa;
}
sint16 Spawn::GetTradeskillAA()
{
return basic_info.tradeskill_aa;
}
sint16 Spawn::GetUnassignedTradeskillAA()
{
return basic_info.unassigned_tradeskill_aa;
}
sint16 Spawn::GetPrestigeAA()
{
return basic_info.prestige_aa;
}
sint16 Spawn::GetUnassignedPretigeAA()
{
return basic_info.unassigned_prestige_aa;
}
sint16 Spawn::GetTradeskillPrestigeAA()
{
return basic_info.tradeskill_prestige_aa;
}
sint16 Spawn::GetUnassignedTradeskillPrestigeAA()
{
return basic_info.unassigned_tradeskill_prestige_aa;
}
int32 Spawn::GetAAXPRewards()
{
return basic_info.aaxp_rewards;
}
float Spawn::GetDistance(float x1, float y1, float z1, float x2, float y2, float z2){
x1 = x1 - x2;
y1 = y1 - y2;
z1 = z1 - z2;
return sqrt(x1*x1 + y1*y1 + z1*z1);
}
float Spawn::GetDistance(float x, float y, float z, float radius, bool ignore_y) {
if (ignore_y)
return GetDistance(x, y, z, GetX(), y, GetZ()) - radius;
else
return GetDistance(x, y, z, GetX(), GetY(), GetZ()) - radius;
}
float Spawn::GetDistance(float x, float y, float z, bool ignore_y) {
return GetDistance(x, y, z, 0.0f, ignore_y);
}
float Spawn::GetDistance(Spawn* spawn, bool ignore_y, bool includeRadius){
float ret = 0;
if (spawn)
{
float radius = 0.0f;
if (includeRadius)
radius = CalculateRadius(spawn);
ret = GetDistance(spawn->GetX(), spawn->GetY(), spawn->GetZ(), radius, ignore_y);
}
// maybe distance against ourselves, in that case we want to nullify the radius check
if (ret < 0)
ret = 0.0f;
return ret;
}
float Spawn::GetDistance(Spawn* spawn, float x1, float y1, float z1, bool includeRadius) {
float ret = 0;
if (spawn)
{
float radius = 0.0f;
if (includeRadius)
radius = CalculateRadius(spawn);
ret = GetDistance(x1, y1, z1, spawn->GetX(), spawn->GetY(), spawn->GetZ()) - radius;
}
// maybe distance against ourselves, in that case we want to nullify the radius check
if (ret < 0)
ret = 0.0f;
return ret;
}
float Spawn::CalculateRadius(Spawn* target)
{
float srcRadius = short_to_float(appearance.pos.collision_radius);
if (target)
{
float targRadius = short_to_float(target->appearance.pos.collision_radius);
return (targRadius / 32.0f) + (srcRadius / 32.0f);
}
else
return (srcRadius / 32.0f);
}
int32 Spawn::GetRespawnTime(){
return respawn;
}
void Spawn::SetRespawnTime(int32 time){
respawn = time;
}
int32 Spawn::GetExpireOffsetTime(){
return expire_offset;
}
void Spawn::SetExpireOffsetTime(int32 time){
expire_offset = time;
}
int32 Spawn::GetSpawnLocationID(){
return spawn_location_id;
}
void Spawn::SetSpawnLocationID(int32 id){
spawn_location_id = id;
}
int32 Spawn::GetSpawnEntryID(){
return spawn_entry_id;
}
void Spawn::SetSpawnEntryID(int32 id){
spawn_entry_id = id;
}
int32 Spawn::GetSpawnLocationPlacementID(){
return spawn_location_spawns_id;
}
void Spawn::SetSpawnLocationPlacementID(int32 id){
spawn_location_spawns_id = id;
}
const char* Spawn::GetSpawnScript(){
if(spawn_script.length() > 0)
return spawn_script.c_str();
else
return 0;
}
void Spawn::SetSpawnScript(string name){
spawn_script = name;
}
void Spawn::SetPrimaryCommand(const char* name, const char* command, float distance){
EntityCommand* entity_command = CreateEntityCommand(name, distance, command, "", 0, 0);
if(primary_command_list.size() > 0 && primary_command_list[0]){
safe_delete(primary_command_list[0]);
primary_command_list[0] = entity_command;
}
else
primary_command_list.push_back(entity_command);
}
void Spawn::SetSecondaryCommands(vector* commands){
if(commands && commands->size() > 0){
vector::iterator itr;
if(secondary_command_list.size() > 0){
for(itr = secondary_command_list.begin(); itr != secondary_command_list.end(); itr++){
safe_delete(*itr);
}
secondary_command_list.clear();
}
EntityCommand* command = 0;
for(itr = commands->begin(); itr != commands->end(); itr++){
command = CreateEntityCommand(*itr);
secondary_command_list.push_back(command);
}
}
}
void Spawn::SetPrimaryCommands(vector* commands){
if(commands && commands->size() > 0){
vector::iterator itr;
if(primary_command_list.size() > 0){
for(itr = primary_command_list.begin(); itr != primary_command_list.end(); itr++){
safe_delete(*itr);
}
primary_command_list.clear();
}
EntityCommand* command = 0;
for(itr = commands->begin(); itr != commands->end(); itr++){
command = CreateEntityCommand(*itr);
primary_command_list.push_back(command);
}
}
}
EntityCommand* Spawn::FindEntityCommand(string command, bool primaryOnly) {
EntityCommand* entity_command = 0;
if (primary_command_list.size() > 0) {
vector::iterator itr;
for (itr = primary_command_list.begin(); itr != primary_command_list.end(); itr++) {
if ((*itr)->command.compare(command) == 0) {
entity_command = *itr;
break;
}
}
}
if (primaryOnly)
return entity_command;
if (!entity_command && secondary_command_list.size() > 0) {
vector::iterator itr;
for (itr = secondary_command_list.begin(); itr != secondary_command_list.end(); itr++) {
if ((*itr)->command == command) {
entity_command = *itr;
break;
}
}
}
return entity_command;
}
void Spawn::SetSizeOffset(int8 offset){
size_offset = offset;
}
int8 Spawn::GetSizeOffset(){
return size_offset;
}
void Spawn::SetMerchantID(int32 val){
merchant_id = val;
}
int32 Spawn::GetMerchantID(){
return merchant_id;
}
void Spawn::SetMerchantType(int8 val) {
merchant_type = val;
}
int8 Spawn::GetMerchantType() {
return merchant_type;
}
void Spawn::SetMerchantLevelRange(int32 minLvl, int32 maxLvl) {
merchant_min_level = minLvl;
merchant_max_level = maxLvl;
}
int32 Spawn::GetMerchantMinLevel() {
return merchant_min_level;
}
int32 Spawn::GetMerchantMaxLevel() {
return merchant_max_level;
}
bool Spawn::IsClientInMerchantLevelRange(Client* client, bool sendMessageIfDenied)
{
if (!client)
return false;
if (GetMerchantMinLevel() && client->GetPlayer()->GetLevel() < GetMerchantMinLevel())
{
client->Message(CHANNEL_COLOR_RED, "You are unable to interact with this merchant due to a minimum level %u allowed.", GetMerchantMinLevel());
return false;
}
else if (GetMerchantMaxLevel() && client->GetPlayer()->GetLevel() > GetMerchantMaxLevel())
{
client->Message(CHANNEL_COLOR_RED, "You are unable to interact with this merchant due to a maximum level %u allowed.", GetMerchantMaxLevel());
return false;
}
return true;
}
void Spawn::SetQuestsRequired(Spawn* new_spawn){
m_requiredQuests.writelock(__FUNCTION__, __LINE__);
if(required_quests.size() > 0){
map* >::iterator itr;
for(itr = required_quests.begin(); itr != required_quests.end(); itr++){
vector* quest_steps = itr->second;
for (int32 i = 0; i < quest_steps->size(); i++)
new_spawn->SetQuestsRequired(itr->first, quest_steps->at(i));
}
}
m_requiredQuests.releasewritelock(__FUNCTION__, __LINE__);
}
void Spawn::SetQuestsRequired(int32 quest_id, int16 quest_step){
m_requiredQuests.writelock(__FUNCTION__, __LINE__);
if (required_quests.count(quest_id) == 0)
required_quests.insert(make_pair(quest_id, new vector));
else{
for (int32 i = 0; i < required_quests[quest_id]->size(); i++){
if (required_quests[quest_id]->at(i) == quest_step){
m_requiredQuests.releasewritelock(__FUNCTION__, __LINE__);
return;
}
}
}
has_quests_required = true;
required_quests[quest_id]->push_back(quest_step);
m_requiredQuests.releasewritelock(__FUNCTION__, __LINE__);
}
bool Spawn::HasQuestsRequired(){
return has_quests_required;
}
bool Spawn::HasHistoryRequired(){
return has_history_required;
}
void Spawn::SetRequiredHistory(int32 event_id, int32 value1, int32 value2){
LUAHistory* set_value = new LUAHistory();
set_value->Value = value1;
set_value->Value2 = value2;
set_value->SaveNeeded = false;
m_requiredHistory.writelock(__FUNCTION__, __LINE__);
if (required_history.count(event_id) == 0)
required_history.insert(make_pair(event_id, set_value));
else
{
LUAHistory* tmp_value = required_history[event_id];
required_history[event_id] = set_value;
safe_delete(tmp_value);
}
has_history_required = true;
m_requiredHistory.releasewritelock(__FUNCTION__, __LINE__);
}
void Spawn::SetTransporterID(int32 id){
transporter_id = id;
}
int32 Spawn::GetTransporterID(){
return transporter_id;
}
void Spawn::InitializePosPacketData(Player* player, PacketStruct* packet, bool bSpawnUpdate) {
int16 version = packet->GetVersion();
int32 new_grid_id = 0;
int32 new_widget_id = 0;
if(player->GetMap() != nullptr && player->GetMap()->IsMapLoaded())
{
m_GridMutex.writelock(__FUNCTION__, __LINE__);
std::map::iterator itr = established_grid_id.find(version);
if ( itr == established_grid_id.end() || itr->second.timestamp <= (Timer::GetCurrentTime2()))
{
if(itr != established_grid_id.end() && itr->second.x == GetX() && itr->second.z == GetZ() && !itr->second.npc_save) {
itr->second.timestamp = Timer::GetCurrentTime2()+100;
itr->second.npc_save = false;
new_grid_id = itr->second.grid_id;
new_widget_id = itr->second.widget_id;
}
else {
auto loc = glm::vec3(GetX(), GetZ(), GetY());
float new_z = player->FindBestZ(loc, nullptr, &new_grid_id, &new_widget_id);
TimedGridData data;
data.grid_id = new_grid_id;
data.widget_id = new_widget_id;
data.x = GetX();
data.y = GetY();
data.z = GetZ();
data.npc_save = false;
data.timestamp = Timer::GetCurrentTime2()+100;
established_grid_id.insert(make_pair(packet->GetVersion(), data));
}
}
else {
new_grid_id = itr->second.grid_id;
new_widget_id = itr->second.widget_id;
}
m_GridMutex.releasewritelock(__FUNCTION__, __LINE__);
}
if(IsKnockedBack()) {
packet->setDataByName("pos_grid_id", 0);
}
else {
packet->setDataByName("pos_grid_id", new_grid_id != 0 ? new_grid_id : GetLocation());
}
bool include_heading = true;
if (IsWidget() && ((Widget*)this)->GetIncludeHeading() == false)
include_heading = false;
else if (IsSign() && ((Sign*)this)->GetIncludeHeading() == false)
include_heading = false;
if (include_heading){
packet->setDataByName("pos_heading1", appearance.pos.Dir1);
packet->setDataByName("pos_heading2", appearance.pos.Dir2);
}
if (version <= 910) {
packet->setDataByName("pos_collision_radius", appearance.pos.collision_radius > 0 ? appearance.pos.collision_radius : 32);
packet->setDataByName("pos_size", size > 0 ? size : 32);
packet->setDataByName("pos_size_multiplier", 32); //32 is normal
}
else {
if (size == 0)
size = 32;
packet->setDataByName("pos_collision_radius", appearance.pos.collision_radius > 0 ? appearance.pos.collision_radius : 32);
packet->setDataByName("pos_size", 1.0f);
if (!IsPlayer())
packet->setDataByName("pos_size", size > 0 ? (((float)size) / 32.0f) : 1.0f); // float not an integer
else
packet->setDataByName("pos_size", 1.0f);
// please do not remove! This makes it so NPCs for example do not resize large/small when you are in combat with them!
packet->setDataByName("pos_size_ratio", 1.0f);
}
packet->setDataByName("pos_state", appearance.pos.state);
bool include_location = true;
if (IsWidget() && ((Widget*)this)->GetIncludeLocation() == false)
include_location = false;
else if (IsSign() && ((Sign*)this)->GetIncludeLocation() == false)
include_location = false;
if (include_location){
if (IsWidget() && ((Widget*)this)->GetMultiFloorLift()) {
Widget* widget = (Widget*)this;
float x = appearance.pos.X - widget->GetWidgetX();
float y = appearance.pos.Y - widget->GetWidgetY();
float z = appearance.pos.Z - widget->GetWidgetZ();
packet->setDataByName("pos_x", x);
packet->setDataByName("pos_y", y);
packet->setDataByName("pos_z", z);
}
else {
packet->setDataByName("pos_x", appearance.pos.X);
packet->setDataByName("pos_y", appearance.pos.Y);
packet->setDataByName("pos_z", appearance.pos.Z);
}
if (IsSign())
packet->setDataByName("pos_unknown6", 3, 2);
}
if (IsPlayer()) {
Skill* skill = ((Player*)this)->GetSkillByName("Swimming", false);
sint16 swim_modifier = rule_manager.GetGlobalRule(R_Player, SwimmingSkillMinSpeed)->GetSInt16();
if(skill) {
sint16 max_val = 450;
if(skill->max_val > 0)
max_val = skill->max_val;
sint16 max_swim_mod = rule_manager.GetGlobalRule(R_Player, SwimmingSkillMaxSpeed)->GetSInt16();
float diff = (float)(skill->current_val + ((Player*)this)->GetStat(ITEM_STAT_SWIMMING)) / (float)max_val;
sint16 diff_mod = (sint16)(float)max_swim_mod * diff;
if(diff_mod > max_swim_mod)
swim_modifier = max_swim_mod;
else if(diff_mod > swim_modifier)
swim_modifier = diff_mod;
}
packet->setDataByName("pos_swim_speed_modifier", swim_modifier);
packet->setDataByName("pos_x_velocity", TransformFromFloat(GetSpeedX(), 5));
packet->setDataByName("pos_y_velocity", TransformFromFloat(GetSpeedY(), 5));
packet->setDataByName("pos_z_velocity", TransformFromFloat(GetSpeedZ(), 5));
}
if (appearance.pos.X2 == 0 && appearance.pos.Y2 == 0 && appearance.pos.Z2 && (appearance.pos.X != 0 || appearance.pos.Y != 0 || appearance.pos.Z != 0)) {
appearance.pos.X2 = appearance.pos.X;
appearance.pos.Y2 = appearance.pos.Y;
appearance.pos.Z2 = appearance.pos.Z;
}
if (appearance.pos.X3 == 0 && appearance.pos.Y3 == 0 && appearance.pos.Z3 && (appearance.pos.X != 0 || appearance.pos.Y != 0 || appearance.pos.Z != 0)) {
appearance.pos.X3 = appearance.pos.X;
appearance.pos.Y3 = appearance.pos.Y;
appearance.pos.Z3 = appearance.pos.Z;
}
//Transform To/From Float bits (original client)
//pos_loc_offset[3]: 5
//pos_x_velocity: 5
//pos_y_velocity: 5
//pos_z_velocity: 5
//pos_heading1: 6
//pos_heading2: 6
//pos_speed: 8
//pos_dest_loc_offset[3]: 5
//pos_dest_loc_offset2[3]: 5
//pos_heading_speed: 5
//pos_move_type: 5 (speed_modifier)
//pos_swim_speed_modifier: 5
//pos_side_speed: 8
//pos_vert_speed: 8
//pos_requested_pitch: 6
//pos_requested_pitch_speed: 5
//pos_pitch: 6
//pos_collision_radius: 5
//pos_size: 5
//actor_stop_range: 5
//this is for original box client, destinations used to be offsets
if(version <= 373 || version > 561 || !IsPlayer()) {
if (appearance.pos.X2 != 0 || appearance.pos.Y2 != 0 || appearance.pos.Z2 != 0) {
packet->setDataByName("pos_dest_loc_offset", TransformFromFloat(appearance.pos.X2 - appearance.pos.X, 5));
packet->setDataByName("pos_dest_loc_offset", TransformFromFloat(appearance.pos.Y2 - appearance.pos.Y, 5), 1);
packet->setDataByName("pos_dest_loc_offset", TransformFromFloat(appearance.pos.Z2 - appearance.pos.Z, 5), 2);
}
if (appearance.pos.X3 != 0 || appearance.pos.Y3 != 0 || appearance.pos.Z3 != 0) {
packet->setDataByName("pos_dest_loc_offset2", TransformFromFloat(appearance.pos.X3 - appearance.pos.X, 5));
packet->setDataByName("pos_dest_loc_offset2", TransformFromFloat(appearance.pos.Y3 - appearance.pos.Y, 5), 1);
packet->setDataByName("pos_dest_loc_offset2", TransformFromFloat(appearance.pos.Z3 - appearance.pos.Z, 5), 2);
}
}
bool bSendSpeed = true;
if (IsWidget() && ((Widget*)this)->GetMultiFloorLift()) {
Widget* widget = (Widget*)this;
float x;
float y;
float z;
if (IsRunning()){
x = appearance.pos.X2 - widget->GetWidgetX();
y = appearance.pos.Y2 - widget->GetWidgetY();
z = appearance.pos.Z2- widget->GetWidgetZ();
}
else {
x = appearance.pos.X - widget->GetWidgetX();
y = appearance.pos.Y - widget->GetWidgetY();
z = appearance.pos.Z - widget->GetWidgetZ();
}
packet->setDataByName("pos_next_x", x);
packet->setDataByName("pos_next_y", y);
packet->setDataByName("pos_next_z", z);
packet->setDataByName("pos_x3", x);
packet->setDataByName("pos_y3", y);
packet->setDataByName("pos_z3", z);
}
//If this is a spawn update or this spawn is currently moving we can send these values, otherwise set speed and next_xyz to 0
//This fixes the bug where spawns with movement scripts face south when initially spawning if they are at their target location.
else if (bSpawnUpdate || memcmp(&appearance.pos.X, &appearance.pos.X2, sizeof(float) * 3) != 0) {
packet->setDataByName("pos_next_x", appearance.pos.X2);
packet->setDataByName("pos_next_y", appearance.pos.Y2);
packet->setDataByName("pos_next_z", appearance.pos.Z2);
packet->setDataByName("pos_x3", appearance.pos.X3);
packet->setDataByName("pos_y3", appearance.pos.Y3);
packet->setDataByName("pos_z3", appearance.pos.Z3);
}
else
{
bSendSpeed = false;
}
//packet->setDataByName("pos_unknown2", 4, 2);
int16 speed_multiplier = rule_manager.GetGlobalRule(R_Spawn, SpeedMultiplier)->GetInt16(); // was 1280, 600 and now 300... investigating why
int8 movement_mode = 0;
if (IsPlayer()) {
Player* player = static_cast(this);
sint16 pos_packet_speed = player->GetPosPacketSpeed() * speed_multiplier;
sint16 side_speed = player->GetSideSpeed() * speed_multiplier;
packet->setDataByName("pos_speed", pos_packet_speed);
packet->setDataByName("pos_side_speed", side_speed);
if(pos_packet_speed != 0 || side_speed != 0) {
movement_mode = 2;
}
}
else if (bSendSpeed) {
sint16 side_speed = GetSpeed() * speed_multiplier;
packet->setDataByName("pos_speed", side_speed);
if(side_speed != 0) {
movement_mode = 2;
}
}
if (IsNPC() || IsPlayer()) {
packet->setDataByName("pos_move_type", World::newValue);
}
else if (IsWidget() || IsSign()) {
packet->setDataByName("pos_move_type", 11);
}
else if(IsGroundSpawn()) {
packet->setDataByName("pos_move_type", 16);
}
if (!IsPlayer()) { // has to be 2 or NPC's warp around when moving
packet->setDataByName("pos_movement_mode", movement_mode);
}
packet->setDataByName("face_actor_id", 0xFFFFFFFF);
packet->setDataByName("pos_pitch1", appearance.pos.Pitch1);
packet->setDataByName("pos_pitch2", appearance.pos.Pitch2);
packet->setDataByName("pos_roll", appearance.pos.Roll);
}
void Spawn::InitializeInfoPacketData(Player* spawn, PacketStruct* packet) {
int16 version = packet->GetVersion();
bool spawnHiddenFromClient = false;
int8 classicFlags = 0;
// radius of 0 is always seen, -1 is never seen (unless items/spells override), larger than 0 is a defined radius to restrict visibility
sint32 radius = rule_manager.GetGlobalRule(R_PVP, InvisPlayerDiscoveryRange)->GetSInt32();
if (radius != 0 && (Spawn*)spawn != this && this->IsPlayer() && !spawn->CanSeeInvis((Entity*)this))
spawnHiddenFromClient = true;
if (!spawnHiddenFromClient && (appearance.targetable == 1 || appearance.show_level == 1 || appearance.display_name == 1)) {
if (!IsObject() && !IsGroundSpawn() && !IsWidget() && !IsSign()) {
int8 percent = 0;
if (GetHP() > 0)
percent = (int8)(((float)GetHP() / GetTotalHP()) * 100);
if (version >= 373) {
if (percent < 100) {
packet->setDataByName("hp_remaining", 100 ^ percent);
}
else
packet->setDataByName("hp_remaining", 0);
}
else {
if (percent > 100)
percent = 100;
packet->setDataByName("hp_remaining", percent);
}
if (GetTotalPower() > 0) {
percent = (int8)(((float)GetPower() / GetTotalPower()) * 100);
if (percent > 0)
packet->setDataByName("power_percent", percent);
else
packet->setDataByName("power_percent", 0);
}
}
}
if (version <= 561) {
packet->setDataByName("name", appearance.name);
for (int8 i = 0; i < 8; i++)
packet->setDataByName("unknown1", 0xFF, i);
if (appearance.show_level == 0)
packet->setDataByName("hide_health", 1);
}
if (GetHP() <= 0 && IsEntity()) {
packet->setDataByName("corpse", 1);
if(HasLoot())
packet->setDataByName("loot_icon", 1);
}
if (!IsPlayer())
packet->setDataByName("npc", 1);
if (GetMerchantID() > 0)
packet->setDataByName("merchant", 1);
packet->setDataByName("effective_level", IsEntity() && ((Entity*)this)->GetInfoStruct()->get_effective_level() != 0 ? (int8)((Entity*)this)->GetInfoStruct()->get_effective_level() : (int8)GetLevel());
packet->setDataByName("level", (int8)GetLevel());
packet->setDataByName("unknown4", (int8)GetLevel());
packet->setDataByName("difficulty", GetDifficulty()); //6);
packet->setDataByName("unknown6", 1);
packet->setDataByName("heroic_flag", appearance.heroic_flag);
packet->setDataByName("class", appearance.adventure_class);
int16 model_type = appearance.model_type;
if (GetIllusionModel() != 0) {
if (IsPlayer()) {
if (((Player*)this)->get_character_flag(CF_SHOW_ILLUSION)) {
model_type = GetIllusionModel();
}
}
else
model_type = GetIllusionModel();
}
int16 sogaModelType = appearance.soga_model_type;
if (spawnHiddenFromClient)
{
model_type = 0;
sogaModelType = 0;
}
if(version <= 373 && (model_type == 5864 || model_type == 5865 || model_type == 4015)) {
model_type = 4034;
}
packet->setDataByName("model_type", model_type);
if (appearance.soga_model_type == 0)
packet->setDataByName("soga_model_type", model_type);
else
packet->setDataByName("soga_model_type", sogaModelType);
int16 action_state = appearance.action_state;
if(IsEntity()) {
std::string actionState = "";
if (GetTempActionState() >= 0) {
action_state = GetTempActionState();
actionState = ((Entity*)this)->GetInfoStruct()->get_combat_action_state();
}
else {
actionState = ((Entity*)this)->GetInfoStruct()->get_action_state();
}
Client* client = spawn->GetClient();
if(IsEntity() && client) {
if(actionState.size() > 0) {
Emote* emote = visual_states.FindEmote(actionState, client->GetVersion());
if(emote != NULL)
action_state = emote->GetVisualState();
}
}
}
packet->setDataByName("action_state", action_state);
bool scaredOfPlayer = false;
if(IsCollector() && spawn->GetCollectionList()->HasCollectionsToHandIn())
packet->setDataByName("visual_state", VISUAL_STATE_COLLECTION_TURN_IN);
else if(!IsRunning() && IsNPC() && IsScaredByStrongPlayers() && spawn->GetArrowColor(GetLevel()) == ARROW_COLOR_GRAY &&
(GetDistance(spawn)) <= ((NPC*)this)->GetAggroRadius() && CheckLoS(spawn)) {
packet->setDataByName("visual_state", VISUAL_STATE_IDLE_AFRAID);
scaredOfPlayer = true;
}
else if (GetTempVisualState() >= 0)
packet->setDataByName("visual_state", GetTempVisualState());
else
packet->setDataByName("visual_state", appearance.visual_state);
if (IsNPC() && !IsPet() && !scaredOfPlayer)
{
if(((Entity*)this)->GetInfoStruct()->get_interaction_flag()) {
if(((Entity*)this)->GetInfoStruct()->get_interaction_flag() == 255) {
packet->setDataByName("interaction_flag", 0);
classicFlags += INFO_CLASSIC_FLAG_NOLOOK;
}
else {
packet->setDataByName("interaction_flag", ((Entity*)this)->GetInfoStruct()->get_interaction_flag()); //this makes NPCs head turn to look at you (12)
}
}
else {
packet->setDataByName("interaction_flag", 12); //turn head since no other value is set
}
}
packet->setDataByName("emote_state", appearance.emote_state);
packet->setDataByName("mood_state", appearance.mood_state);
packet->setDataByName("gender", appearance.gender);
packet->setDataByName("race", appearance.race);
if (IsEntity()) {
Entity* entity = ((Entity*)this);
packet->setDataByName("combat_voice", entity->GetCombatVoice());
packet->setDataByName("emote_voice", entity->GetEmoteVoice());
for (int i = 0; i < 25; i++) {
if (i == 2) { //don't send helm if hidden flag
if (IsPlayer()) {
if (((Player*)this)->get_character_flag(CF_HIDE_HELM)) {
packet->setDataByName("equipment_types", 0, i);
packet->setColorByName("equipment_colors", 0, i);
packet->setColorByName("equipment_highlights", 0, i);
continue;
}
}
if (IsBot()) {
if (!((Bot*)this)->ShowHelm) {
packet->setDataByName("equipment_types", 0, i);
packet->setColorByName("equipment_colors", 0, i);
packet->setColorByName("equipment_highlights", 0, i);
continue;
}
}
}
else if (i == 19) { //don't send cloak if hidden
if (IsPlayer()) {
if (!((Player*)this)->get_character_flag(CF_SHOW_CLOAK)) {
packet->setDataByName("equipment_types", 0, i);
packet->setColorByName("equipment_colors", 0, i);
packet->setColorByName("equipment_highlights", 0, i);
continue;
}
}
if (IsBot()) {
if (!((Bot*)this)->ShowCloak) {
packet->setDataByName("equipment_types", 0, i);
packet->setColorByName("equipment_colors", 0, i);
packet->setColorByName("equipment_highlights", 0, i);
continue;
}
}
}
entity->MEquipment.lock();
packet->setDataByName("equipment_types", entity->equipment.equip_id[i], i);
packet->setColorByName("equipment_colors", entity->equipment.color[i], i);
packet->setColorByName("equipment_highlights", entity->equipment.highlight[i], i);
entity->MEquipment.unlock();
}
packet->setDataByName("mount_type", entity->GetMount());
// find the visual flags
int8 vis_flag = 0;
//Invis + crouch flag check
if (entity->IsStealthed()) {
vis_flag += (INFO_VIS_FLAG_INVIS + INFO_VIS_FLAG_CROUCH);
classicFlags += INFO_VIS_FLAG_INVIS + INFO_VIS_FLAG_CROUCH;
}
//Invis flag check
else if (entity->IsInvis()) {
vis_flag += INFO_VIS_FLAG_INVIS;
classicFlags += INFO_VIS_FLAG_INVIS;
}
//Mount flag check
if (entity->GetMount() > 0) {
vis_flag += INFO_VIS_FLAG_MOUNTED;
}
//Hide hood check
bool vis_hide_hood = false;
if (IsPlayer() && ((Player*)this)->get_character_flag(CF_HIDE_HOOD)) {
if(version > 561) {
vis_flag += INFO_VIS_FLAG_HIDE_HOOD;
}
vis_hide_hood = true;
}
else if(IsPlayer()) {
classicFlags += INFO_CLASSIC_FLAG_SHOW_HOOD;
}
if(!vis_hide_hood && appearance.hide_hood && version > 561) {
vis_flag += INFO_VIS_FLAG_HIDE_HOOD;
}
if(version <= 561) {
packet->setDataByName("flags", classicFlags);
}
packet->setDataByName("visual_flag", vis_flag);
packet->setColorByName("mount_saddle_color", entity->GetMountSaddleColor());
packet->setColorByName("mount_color", entity->GetMountColor());
packet->setDataByName("hair_type_id", entity->features.hair_type);
packet->setDataByName("chest_type_id", entity->features.chest_type);
packet->setDataByName("wing_type_id", entity->features.wing_type);
packet->setDataByName("legs_type_id", entity->features.legs_type);
packet->setDataByName("soga_hair_type_id", entity->features.soga_hair_type);
packet->setDataByName("facial_hair_type_id", entity->features.hair_face_type);
packet->setDataByName("soga_facial_hair_type_id", entity->features.soga_hair_face_type);
for (int i = 0; i < 3; i++) {
packet->setDataByName("eye_type", entity->features.eye_type[i], i);
packet->setDataByName("ear_type", entity->features.ear_type[i], i);
packet->setDataByName("eye_brow_type", entity->features.eye_brow_type[i], i);
packet->setDataByName("cheek_type", entity->features.cheek_type[i], i);
packet->setDataByName("lip_type", entity->features.lip_type[i], i);
packet->setDataByName("chin_type", entity->features.chin_type[i], i);
packet->setDataByName("nose_type", entity->features.nose_type[i], i);
packet->setDataByName("soga_eye_type", entity->features.soga_eye_type[i], i);
packet->setDataByName("soga_ear_type", entity->features.soga_ear_type[i], i);
packet->setDataByName("soga_eye_brow_type", entity->features.soga_eye_brow_type[i], i);
packet->setDataByName("soga_cheek_type", entity->features.soga_cheek_type[i], i);
packet->setDataByName("soga_lip_type", entity->features.soga_lip_type[i], i);
packet->setDataByName("soga_chin_type", entity->features.soga_chin_type[i], i);
packet->setDataByName("soga_nose_type", entity->features.soga_nose_type[i], i);
}
packet->setColorByName("skin_color", entity->features.skin_color);
packet->setColorByName("model_color", entity->features.model_color);
packet->setColorByName("eye_color", entity->features.eye_color);
packet->setColorByName("hair_type_color", entity->features.hair_type_color);
packet->setColorByName("hair_type_highlight_color", entity->features.hair_type_highlight_color);
packet->setColorByName("hair_face_color", entity->features.hair_face_color);
packet->setColorByName("hair_face_highlight_color", entity->features.hair_face_highlight_color);
packet->setColorByName("hair_highlight", entity->features.hair_highlight_color);
packet->setColorByName("wing_color1", entity->features.wing_color1);
packet->setColorByName("wing_color2", entity->features.wing_color2);
packet->setColorByName("hair_color1", entity->features.hair_color1);
packet->setColorByName("hair_color2", entity->features.hair_color2);
packet->setColorByName("soga_skin_color", entity->features.soga_skin_color);
packet->setColorByName("soga_model_color", entity->features.soga_model_color);
packet->setColorByName("soga_eye_color", entity->features.soga_eye_color);
packet->setColorByName("soga_hair_color1", entity->features.soga_hair_color1);
packet->setColorByName("soga_hair_color2", entity->features.soga_hair_color2);
packet->setColorByName("soga_hair_type_color", entity->features.soga_hair_type_color);
packet->setColorByName("soga_hair_type_highlight_color", entity->features.soga_hair_type_highlight_color);
packet->setColorByName("soga_hair_face_color", entity->features.soga_hair_face_color);
packet->setColorByName("soga_hair_face_highlight_color", entity->features.soga_hair_face_highlight_color);
packet->setColorByName("soga_hair_highlight", entity->features.soga_hair_highlight_color);
packet->setDataByName("body_size", entity->features.body_size);
packet->setDataByName("body_age", entity->features.body_age);
packet->setDataByName("soga_body_size", entity->features.soga_body_size);
packet->setDataByName("soga_body_age", entity->features.soga_body_age);
}
else {
EQ2_Color empty;
empty.red = 255;
empty.blue = 255;
empty.green = 255;
packet->setColorByName("skin_color", empty);
packet->setColorByName("model_color", empty);
packet->setColorByName("eye_color", empty);
packet->setColorByName("soga_skin_color", empty);
packet->setColorByName("soga_model_color", empty);
packet->setColorByName("soga_eye_color", empty);
}
if (appearance.icon == 0) {
if (appearance.attackable == 1)
appearance.icon = 0;
else if (GetDifficulty() > 0)
appearance.icon = 4;
else
appearance.icon = 6;
}
// If Coe+ clients modify the values before we send
// if not then just send the value we have.
int8 temp_icon = appearance.icon;
//Check if we need to add the hand icon..
if ((temp_icon & 6) != 6 && appearance.display_hand_icon) {
temp_icon |= 6;
}
//Icon value 28 for boats, set this without modifying the value
if (version >= 1188 && temp_icon != 28) {
if ((temp_icon & 64) > 0) {
temp_icon -= 64; // remove the DoV value;
temp_icon += 128; // add the CoE value
}
if ((temp_icon & 32) > 0) {
temp_icon -= 32; // remove the DoV value;
temp_icon += 64; // add the CoE value
}
if ((temp_icon & 4) > 0) {
temp_icon -= 4; // remove DoV value
temp_icon += 8; // add the CoE icon
}
if ((temp_icon & 6) > 0) {
temp_icon -= 10; // remove DoV value
temp_icon += 12; // add the CoE icon
}
}
packet->setDataByName("icon", temp_icon);//appearance.icon);
int32 temp_activity_status = 0;
if (!Alive() && GetTotalHP() > 0 && !IsObject() && !IsGroundSpawn())
temp_activity_status = 1;
if(version >= 1188 && GetChestDropTime()) {
temp_activity_status = 0;
}
temp_activity_status += (IsNPC() || IsObject() || IsGroundSpawn()) ? 1 << 1 : 0;
if (version > 561) {
// Fix widget or sign having 'Play Legends of Norrath' or 'Tell' options in right click (client hard-coded entity commands)
if(IsWidget() || IsSign())
temp_activity_status = 2;
if (IsGroundSpawn() || GetShowHandIcon())
temp_activity_status += ACTIVITY_STATUS_INTERACTABLE_1188;
if ((appearance.activity_status & ACTIVITY_STATUS_ROLEPLAYING) > 0)
temp_activity_status += ACTIVITY_STATUS_ROLEPLAYING_1188;
if ((appearance.activity_status & ACTIVITY_STATUS_ANONYMOUS) > 0)
temp_activity_status += ACTIVITY_STATUS_ANONYMOUS_1188;
if ((appearance.activity_status & ACTIVITY_STATUS_LINKDEAD) > 0)
temp_activity_status += ACTIVITY_STATUS_LINKDEAD_1188;
if ((appearance.activity_status & ACTIVITY_STATUS_CAMPING) > 0)
temp_activity_status += ACTIVITY_STATUS_CAMPING_1188;
if ((appearance.activity_status & ACTIVITY_STATUS_LFG) > 0)
temp_activity_status += ACTIVITY_STATUS_LFG_1188;
if ((appearance.activity_status & ACTIVITY_STATUS_LFW) > 0)
temp_activity_status += ACTIVITY_STATUS_LFW_1188;
if ((appearance.activity_status & ACTIVITY_STATUS_SOLID) > 0)
temp_activity_status += ACTIVITY_STATUS_SOLID_1188;
if ((appearance.activity_status & ACTIVITY_STATUS_IMMUNITY_GAINED) > 0)
temp_activity_status += ACTIVITY_STATUS_IMMUNITY_GAINED_1188;
if ((appearance.activity_status & ACTIVITY_STATUS_IMMUNITY_REMAINING) > 0)
temp_activity_status += ACTIVITY_STATUS_IMMUNITY_REMAINING_1188;
if ((appearance.activity_status & ACTIVITY_STATUS_AFK) > 0)
temp_activity_status += ACTIVITY_STATUS_AFK_1188;
if (EngagedInCombat())
temp_activity_status += ACTIVITY_STATUS_INCOMBAT_1188;
// if this is either a boat or lift let the client be manipulated by the object
// doesn't work for DoF client version 546
if (appearance.icon == 28 || appearance.icon == 12 || IsTransportSpawn())
{
// there is some other flags that setting with a transport breaks their solidity/ability to properly transport
// thus we just consider the following flags for now as all necessary
temp_activity_status = ACTIVITY_STATUS_SOLID_1188;
temp_activity_status += ACTIVITY_STATUS_ISTRANSPORT_1188;
}
}
else if (version == 561) {
// Fix widget or sign having 'Play Legends of Norrath' or 'Tell' options in right click (client hard-coded entity commands)
if(IsWidget() || IsSign())
temp_activity_status = 2;
if (IsGroundSpawn() || GetShowHandIcon())
temp_activity_status += ACTIVITY_STATUS_INTERACTABLE_561;
if ((appearance.activity_status & ACTIVITY_STATUS_ROLEPLAYING) > 0)
temp_activity_status += ACTIVITY_STATUS_ROLEPLAYING_561;
if ((appearance.activity_status & ACTIVITY_STATUS_ANONYMOUS) > 0)
temp_activity_status += ACTIVITY_STATUS_ANONYMOUS_561;
if ((appearance.activity_status & ACTIVITY_STATUS_LINKDEAD) > 0)
temp_activity_status += ACTIVITY_STATUS_LINKDEAD_561;
if ((appearance.activity_status & ACTIVITY_STATUS_CAMPING) > 0)
temp_activity_status += ACTIVITY_STATUS_CAMPING_561;
if ((appearance.activity_status & ACTIVITY_STATUS_LFG) > 0)
temp_activity_status += ACTIVITY_STATUS_LFG_561;
if ((appearance.activity_status & ACTIVITY_STATUS_LFW) > 0)
temp_activity_status += ACTIVITY_STATUS_LFW_561;
if ((appearance.activity_status & ACTIVITY_STATUS_SOLID) > 0)
temp_activity_status += ACTIVITY_STATUS_SOLID_561;
if ((appearance.activity_status & ACTIVITY_STATUS_IMMUNITY_GAINED) > 0)
temp_activity_status += ACTIVITY_STATUS_IMMUNITY_GAINED_561;
if ((appearance.activity_status & ACTIVITY_STATUS_IMMUNITY_REMAINING) > 0)
temp_activity_status += ACTIVITY_STATUS_IMMUNITY_REMAINING_561;
if ((appearance.activity_status & ACTIVITY_STATUS_AFK) > 0)
temp_activity_status += ACTIVITY_STATUS_AFK_561;
if (EngagedInCombat())
temp_activity_status += ACTIVITY_STATUS_INCOMBAT_561;
// if this is either a boat or lift let the client be manipulated by the object
// doesn't work for DoF client version 546
if (appearance.icon == 28 || appearance.icon == 12 || IsTransportSpawn())
{
// there is some other flags that setting with a transport breaks their solidity/ability to properly transport
// thus we just consider the following flags for now as all necessary
temp_activity_status = ACTIVITY_STATUS_SOLID_561;
temp_activity_status += ACTIVITY_STATUS_ISTRANSPORT_561;
}
}
else
{
temp_activity_status = appearance.activity_status;
if(IsNPC())
temp_activity_status = 0xFF;
// this only partially fixes lifts in classic 283 client if you move just as the lift starts to move
if (appearance.icon == 28 || appearance.icon == 12)
packet->setDataByName("is_transport", 1);
if (MeetsSpawnAccessRequirements(spawn))
packet->setDataByName("hand_icon", appearance.display_hand_icon);
else {
if ((req_quests_override & 256) > 0)
packet->setDataByName("hand_icon", 1);
}
if (IsPlayer()) {
if (((Player*)this)->get_character_flag(CF_AFK))
packet->setDataByName("afk", 1);
if ((appearance.activity_status & ACTIVITY_STATUS_ROLEPLAYING) > 0)
packet->setDataByName("roleplaying", 1);
if ((appearance.activity_status & ACTIVITY_STATUS_ANONYMOUS) > 0)
packet->setDataByName("anonymous", 1);
if ((appearance.activity_status & ACTIVITY_STATUS_LINKDEAD) > 0)
packet->setDataByName("linkdead", 1);
if ((appearance.activity_status & ACTIVITY_STATUS_CAMPING) > 0)
packet->setDataByName("camping", 1);
if ((appearance.activity_status & ACTIVITY_STATUS_LFG) > 0)
packet->setDataByName("lfg", 1);
}
if (EngagedInCombat()) {
packet->setDataByName("auto_attack", 1);
}
if ((appearance.activity_status & ACTIVITY_STATUS_SOLID) > 0)
packet->setDataByName("solid_object", 1);
}
packet->setDataByName("activity_status", temp_activity_status); //appearance.activity_status);
// If player and player has a follow target
/* Jan 2021 Note!! Setting follow_target 0xFFFFFFFF has the result in causing strange behavior in swimming. Targetting a mob makes you focus down to its swim level, unable to swim above it.
** in the same respect the player will drop like a rock to the bottom of the ocean (seems to be when self set to that flag?)
** for now disabling this, if DoF needs it enabled for whatever reason then we need a version check added.
*/
if (IsPlayer()) {
if (((Player*)this)->GetFollowTarget())
packet->setDataByName("follow_target", version <= 561 ? (((Player*)this)->GetIDWithPlayerSpawn(((Player*)this)->GetFollowTarget())) : ((((Player*)this)->GetIDWithPlayerSpawn(((Player*)this)->GetFollowTarget()) * -1) - 1));
else if(version <= 561) {
packet->setDataByName("follow_target", 0xFFFFFFFF);
}
//else
// packet->setDataByName("follow_target", 0xFFFFFFFF);
}
//else if (!IsPet()) {
// packet->setDataByName("follow_target", 0xFFFFFFFF);
//}
// i think this is used in DoF as a way to make a client say they are in combat with this target and cannot camp, it forces you to stand up if self spawn sends this data
if ((version > 561 || spawn != this) && GetTarget() && GetTarget()->GetTargetable())
packet->setDataByName("target_id", ((spawn->GetIDWithPlayerSpawn(GetTarget()) * -1) - 1));
else
packet->setDataByName("target_id", 0xFFFFFFFF);
//Send spell effects for target window
if(IsEntity()){
InfoStruct* info = ((Entity*)this)->GetInfoStruct();
int8 i = 0;
int16 backdrop = 0;
int16 spell_icon = 0;
int32 spell_id = 0;
LuaSpell* spell = 0;
((Entity*)this)->GetSpellEffectMutex()->readlock(__FUNCTION__, __LINE__);
while(i < 30){
//Change value of spell id for this packet if spell exists
spell_id = info->spell_effects[i].spell_id;
if(spell_id > 0)
spell_id = 0xFFFFFFFF - spell_id;
else
spell_id = 0;
packet->setSubstructDataByName("spell_effects", "spell_id", spell_id, i);
//Change value of spell icon for this packet if spell exists
spell_icon = info->spell_effects[i].icon;
if(spell_icon > 0){
if(!(spell_icon == 0xFFFF))
spell_icon = 0xFFFF - spell_icon;
}
else
spell_icon = 0;
packet->setSubstructDataByName("spell_effects", "spell_icon", spell_icon, i);
//Change backdrop values to match values in this packet
backdrop = info->spell_effects[i].icon_backdrop;
switch(backdrop){
case 312:
backdrop = 33080;
break;
case 313:
backdrop = 33081;
break;
case 314:
backdrop = 33082;
break;
case 315:
backdrop = 33083;
break;
case 316:
backdrop = 33084;
break;
case 317:
backdrop = 33085;
break;
case (318 || 319):
backdrop = 33086;
break;
default:
break;
}
packet->setSubstructDataByName("spell_effects", "spell_icon_backdrop", backdrop, i);
spell = info->spell_effects[i].spell;
if (spell)
packet->setSubstructDataByName("spell_effects", "spell_triggercount", spell->num_triggers, i);
i++;
}
((Entity*)this)->GetSpellEffectMutex()->releasereadlock(__FUNCTION__, __LINE__);
}
}
void Spawn::MoveToLocation(Spawn* spawn, float distance, bool immediate, bool mapped){
if(!spawn)
return;
SetRunningTo(spawn);
FaceTarget(spawn, false);
if (!IsPlayer() && distance > 0.0f)
{
if ((IsFlyingCreature() || IsWaterCreature() || InWater()) && CheckLoS(spawn))
{
if (immediate)
ClearRunningLocations();
AddRunningLocation(spawn->GetX(), spawn->GetY(), spawn->GetZ(), GetSpeed(), distance, true, true, "", true);
}
else if (/*!mapped && */GetZone())
{
GetZone()->movementMgr->NavigateTo((Entity*)this, spawn->GetX(), spawn->GetY(), spawn->GetZ());
last_grid_update = Timer::GetCurrentTime2();
}
else
{
if (immediate)
ClearRunningLocations();
AddRunningLocation(spawn->GetX(), spawn->GetY(), spawn->GetZ(), GetSpeed(), distance, true, true, "", mapped);
}
}
}
void Spawn::ProcessMovement(bool isSpawnListLocked){
CheckProximities();
if(IsBot() && ((Bot*)this)->IsCamping()) {
((Bot*)this)->Begin_Camp();
}
if(IsPlayer()){
//Check if player is riding a boat, if so update pos (boat's current location + XYZ offsets)
Player* player = ((Player*)this);
int32 boat_id = player->GetBoatSpawn();
Spawn* boat = 0;
if(boat_id > 0)
boat = GetZone()->GetSpawnByID(boat_id, isSpawnListLocked);
//TODO: MAYBE do this for real boats, not lifts... GetWidgetTypeNameByTypeID
/*if(boat){
SetX(boat->GetX() + player->GetBoatX());
SetY(boat->GetY() + player->GetBoatY());
SetZ(boat->GetZ() + player->GetBoatZ());
}*/
return;
}
if(IsKnockedBack()) {
if(CalculateSpawnProjectilePosition(GetX(), GetY(), GetZ()))
return; // being launched!
}
if(reset_movement) {
ResetMovement();
reset_movement = false;
}
if (forceMapCheck && GetZone() != nullptr && GetMap() != nullptr && GetMap()->IsMapLoaded())
{
FixZ(true);
forceMapCheck = false;
}
if (GetHP() <= 0 && !IsWidget())
return;
if (EngagedInCombat())
{
if(IsEntity() && (((Entity*)this)->IsMezzedOrStunned() || ((Entity*)this)->IsRooted())) {
SetAppearancePosition(GetX(),GetY(),GetZ());
if ( IsEntity() )
((Entity*)this)->SetSpeed(0.0f);
SetSpeed(0.0f);
position_changed = true;
changed = true;
GetZone()->AddChangedSpawn(this);
StopMovement();
return;
}
int locations = 0;
MMovementLocations.lock_shared();
if (movement_locations) {
locations = movement_locations->size();
}
MMovementLocations.unlock_shared();
if (locations < 1 && GetZone() && ((Entity*)this)->IsFeared())
{
CalculateNewFearpoint();
ValidateRunning(true, true);
}
}
Spawn* followTarget = GetZone()->GetSpawnByID(m_followTarget, isSpawnListLocked);
if (!followTarget && m_followTarget > 0)
m_followTarget = 0;
if (following && !IsPauseMovementTimerActive() && followTarget && !((Entity*)this)->IsFeared()) {
// Need to clear m_followTarget before the zoneserver deletes it
if (followTarget->GetHP() <= 0) {
followTarget = 0;
return;
}
if (!IsEntity() || (!((Entity*)this)->IsCasting() && !((Entity*)this)->IsMezzedOrStunned() && !((Entity*)this)->IsRooted())) {
if (GetBaseSpeed() > 0) {
CalculateRunningLocation();
}
else {
float speed = 4.0f;
if (IsEntity())
speed = ((Entity*)this)->GetMaxSpeed();
if (IsEntity())
((Entity*)this)->SetSpeed(speed);
SetSpeed(speed);
}
MovementLocation tmpLoc;
MovementLocation* loc = 0;
MMovementLocations.lock_shared();
if(movement_locations && movement_locations->size() > 0){
loc = movement_locations->front();
if(loc) {
tmpLoc.attackable = loc->attackable;
tmpLoc.gridid = loc->gridid;
tmpLoc.lua_function = string(loc->lua_function);
tmpLoc.mapped = loc->mapped;
tmpLoc.reset_hp_on_runback = loc->reset_hp_on_runback;
tmpLoc.speed = loc->speed;
tmpLoc.stage = loc->stage;
tmpLoc.x = loc->x;
tmpLoc.y = loc->y;
tmpLoc.z = loc->z;
loc = &tmpLoc;
}
}
MMovementLocations.unlock_shared();
float dist = GetDistance(followTarget, true);
if ((!EngagedInCombat() && m_followDistance > 0 && dist <= m_followDistance) ||
(dist <= rule_manager.GetGlobalRule(R_Combat, MaxCombatRange)->GetFloat())) {
ClearRunningLocations();
CalculateRunningLocation(true);
}
else if (loc) {
float distance = GetDistance(followTarget, loc->x, loc->y, loc->z);
if ( (!EngagedInCombat() && m_followDistance > 0 && distance > m_followDistance) ||
( EngagedInCombat() && distance > rule_manager.GetGlobalRule(R_Combat, MaxCombatRange)->GetFloat())) {
MoveToLocation(followTarget, rule_manager.GetGlobalRule(R_Combat, MaxCombatRange)->GetFloat(), true, loc->mapped);
CalculateRunningLocation();
}
}
else {
MoveToLocation(followTarget, rule_manager.GetGlobalRule(R_Combat, MaxCombatRange)->GetFloat(), false);
CalculateRunningLocation();
}
}
}
bool movementCase = false;
// Movement loop is only for scripted paths
if(!EngagedInCombat() && !IsPauseMovementTimerActive() && !NeedsToResumeMovement() && (!IsNPC() || !((NPC*)this)->m_runningBack)){
MMovementLoop.writelock();
if(movement_loop.size() > 0 && movement_index < movement_loop.size())
{
movementCase = true;
// Get the target location
MovementData* data = movement_loop[movement_index];
// need to resume our movement
if(resume_movement){
MMovementLocations.lock();
if (movement_locations){
while (movement_locations->size()){
safe_delete(movement_locations->front());
movement_locations->pop_front();
}
movement_locations->clear();
}
MMovementLocations.unlock();
data = movement_loop[movement_index];
if(data)
{
if(IsEntity()) {
((Entity*)this)->SetSpeed(data->speed);
}
SetSpeed(data->speed);
if(data->use_movement_location_heading)
SetHeading(data->heading);
else if(!IsWidget())
FaceTarget(data->x, data->z);
// 0 delay at target location, need to set multiple locations
if(data->delay == 0 && movement_loop.size() > 0) {
int16 tmp_index = movement_index+1;
MovementData* data2 = 0;
if(tmp_index < movement_loop.size())
data2 = movement_loop[tmp_index];
else
data2 = movement_loop[0];
AddRunningLocation(data->x, data->y, data->z, data->speed, 0, true, false, "", true);
AddRunningLocation(data2->x, data2->y, data2->z, data2->speed, 0, true, true, "", true);
}
// delay at target location, only need to set 1 location
else
AddRunningLocation(data->x, data->y, data->z, data->speed);
}
movement_start_time = 0;
resume_movement = false;
}
// If we are not moving or we have arrived at our destination
else if(!IsRunning() || (data && data->x == GetX() && data->y == GetY() && data->z == GetZ())){
// If we were moving remove the last running location (the point we just arrived at)
if(IsRunning())
RemoveRunningLocation();
// If this waypoint has a delay and we just arrived here (movement_start_time == 0)
if(data && data->delay > 0 && movement_start_time == 0){
// Set the current time
movement_start_time = Timer::GetCurrentTime2();
// If this waypoint had a lua function then call it
if(data->lua_function.length() > 0)
GetZone()->CallSpawnScript(this, SPAWN_SCRIPT_CUSTOM, 0, data->lua_function.c_str());
int16 nextMove;
if ((int16)(movement_index + 1) < movement_loop.size())
nextMove = movement_index + 1;
else
nextMove = 0;
// Get the next target location
data = movement_loop[nextMove];
//Go ahead and face the next location
if(data)
FaceTarget(data->x, data->z);
}
// If this waypoint has no delay or we have waited the required time (current time >= delay + movement_start_time)
else if(data && data->delay == 0 || (data && data->delay > 0 && Timer::GetCurrentTime2() >= (data->delay+movement_start_time))) {
// if no delay at this waypoint but a lua function for it then call the function
if(data->delay == 0 && data->lua_function.length() > 0)
GetZone()->CallSpawnScript(this, SPAWN_SCRIPT_CUSTOM, 0, data->lua_function.c_str());
// since we ran a lua function make sure the movement loop is still alive and accurate
if(movement_loop.size() > 0)
{
// Advance the current movement loop index
if((int16)(movement_index+1) < movement_loop.size())
movement_index++;
else
movement_index = 0;
// Get the next target location
data = movement_loop[movement_index];
// set the speed for that location
SetSpeed(data->speed);
if(!IsWidget())
// turn towards the location
FaceTarget(data->x, data->z);
// If 0 delay at location get and set data for the point after it
if(data->delay == 0 && movement_loop.size() > 0){
MMovementLocations.lock();
if(movement_locations)
{
while (movement_locations->size()){
safe_delete(movement_locations->front());
movement_locations->pop_front();
}
// clear current target locations
movement_locations->clear();
}
MMovementLocations.unlock();
// get the data for the location after out new location
int16 tmp_index = movement_index+1;
MovementData* data2 = 0;
if(tmp_index < movement_loop.size())
data2 = movement_loop[tmp_index];
else
data2 = movement_loop[0];
// set the first location (adds it to movement_locations that we just cleared)
AddRunningLocation(data->x, data->y, data->z, data->speed, 0, true, false, "", true);
// set the location after that
AddRunningLocation(data2->x, data2->y, data2->z, data2->speed, 0, true, true, "", true);
}
// there is a delay at the next location so we only need to set it
else
AddRunningLocation(data->x, data->y, data->z, data->speed, 0, true, true, "", true);
// reset this timer to 0 now that we are moving again
movement_start_time = 0;
}
}
}
// moving and not at target location yet
else if(GetBaseSpeed() > 0)
CalculateRunningLocation();
// not moving, have a target location but not at it yet
else if (data) {
SetSpeed(data->speed);
AddRunningLocation(data->x, data->y, data->z, data->speed);
}
}
MMovementLoop.releasewritelock();
}
if (!movementCase && IsRunning() && !IsPauseMovementTimerActive()) {
CalculateRunningLocation();
//last_movement_update = Timer::GetCurrentTime2();
}
else if(movementCase)
{
//last_movement_update = Timer::GetCurrentTime2();
}
/*else if (IsNPC() && !IsRunning() && !EngagedInCombat() && ((NPC*)this)->GetRunbackLocation()) {
// Is an npc that is not moving and not engaged in combat but has a run back location set then clear the runback location
LogWrite(NPC_AI__DEBUG, 7, "NPC_AI", "Clear runback location for %s", GetName());
((NPC*)this)->ClearRunback();
resume_movement = true;
NeedsToResumeMovement(false);
}*/
}
void Spawn::ResetMovement(){
MMovementLoop.writelock();
vector::iterator itr;
for(itr = movement_loop.begin(); itr != movement_loop.end(); itr++){
safe_delete(*itr);
}
movement_loop.clear();
movement_index = 0;
resume_movement = true;
ClearRunningLocations();
MMovementLoop.releasewritelock();
ValidateRunning(true, true);
}
void Spawn::AddMovementLocation(float x, float y, float z, float speed, int16 delay, const char* lua_function, float heading, bool include_heading){
LogWrite(LUA__DEBUG, 5, "LUA", "AddMovementLocation: x: %.2f, y: %.2f, z: %.2f, speed: %.2f, delay: %i, lua: %s",
x, y, z, speed, delay, string(lua_function).c_str());
MovementData* data = new MovementData;
data->x = x;
data->y = y;
data->z = z;
data->speed = speed;
data->delay = delay*1000;
if(lua_function)
data->lua_function = string(lua_function);
data->heading = heading;
data->use_movement_location_heading = include_heading;
MMovementLoop.lock();
movement_loop.push_back(data);
MMovementLoop.unlock();
}
bool Spawn::ValidateRunning(bool lockMovementLocation, bool lockMovementLoop) {
bool movement = false;
if(lockMovementLocation) {
MMovementLocations.lock_shared();
}
if(movement_locations) {
movement = movement_locations->size() > 0;
}
if(lockMovementLocation) {
MMovementLocations.unlock_shared();
}
if(IsPauseMovementTimerActive() || (IsEntity() && (((Entity*)this)->IsMezzedOrStunned() || ((Entity*)this)->IsRooted()))) {
is_running = false;
return false;
}
if(movement) {
is_running = true;
return true;
}
if(lockMovementLoop) {
MMovementLoop.lock();
}
movement = movement_loop.size() > 0;
if(movement) {
is_running = true;
}
else {
is_running = false;
}
if(lockMovementLoop) {
MMovementLoop.unlock();
}
return movement;
}
bool Spawn::IsRunning(){
return is_running;
}
void Spawn::RunToLocation(float x, float y, float z, float following_x, float following_y, float following_z){
if(IsPauseMovementTimerActive() || (IsEntity() && (((Entity*)this)->IsMezzedOrStunned() || ((Entity*)this)->IsRooted()))) {
is_running = false;
return;
}
if(!IsWidget())
FaceTarget(x, z);
SetPos(&appearance.pos.X2, x, false);
SetPos(&appearance.pos.Z2, z, false);
SetPos(&appearance.pos.Y2, y, false);
if(following_x == 0 && following_y == 0 && following_z == 0){
SetPos(&appearance.pos.X3, x, false);
SetPos(&appearance.pos.Z3, z, false);
SetPos(&appearance.pos.Y3, y, false);
}
else{
SetPos(&appearance.pos.X3, following_x, false);
SetPos(&appearance.pos.Y3, following_y, false);
SetPos(&appearance.pos.Z3, following_z, false);
}
is_running = true;
position_changed = true;
changed = true;
GetZone()->AddChangedSpawn(this);
}
MovementLocation* Spawn::GetCurrentRunningLocation(){
MovementLocation* ret = 0;
MMovementLocations.lock_shared();
if(movement_locations && movement_locations->size() > 0){
ret = movement_locations->front();
}
MMovementLocations.unlock_shared();
return ret;
}
MovementLocation* Spawn::GetLastRunningLocation(){
MovementLocation* ret = 0;
MMovementLocations.lock_shared();
if(movement_locations && movement_locations->size() > 0){
ret = movement_locations->back();
}
MMovementLocations.unlock_shared();
return ret;
}
void Spawn::AddRunningLocation(float x, float y, float z, float speed, float distance_away, bool attackable, bool finished_adding_locations, string lua_function, bool isMapped){
if(speed == 0)
return;
if ( IsEntity() )
((Entity*)this)->SetSpeed(speed);
else
this->SetSpeed(speed);
MovementLocation* current_location = 0;
float distance = GetDistance(x, y, z, distance_away != 0);
if(distance_away != 0){
distance -= distance_away;
x = x - (GetX() - x)*distance_away/distance;
z = z - (GetZ() - z)*distance_away/distance;
}
MMovementLocations.lock();
if(!movement_locations){
movement_locations = new deque();
}
MMovementLocations.unlock();
MovementLocation* data = new MovementLocation;
data->mapped = isMapped;
data->x = x;
data->y = y;
data->z = z;
data->speed = speed;
data->attackable = attackable;
data->lua_function = lua_function;
data->gridid = 0; // used for runback defaults
data->reset_hp_on_runback = false;
MMovementLocations.lock_shared();
if(movement_locations->size() > 0)
current_location = movement_locations->back();
MMovementLocations.unlock_shared();
if(!current_location){
SetSpawnOrigX(GetX());
SetSpawnOrigY(GetY());
SetSpawnOrigZ(GetZ());
SetSpawnOrigHeading(GetHeading());
}
is_running = true;
MMovementLocations.lock();
movement_locations->push_back(data);
MMovementLocations.unlock();
if(!IsPauseMovementTimerActive() && finished_adding_locations){
MMovementLocations.lock();
current_location = movement_locations->front();
SetSpeed(current_location->speed);
if(movement_locations->size() > 1){
data = movement_locations->at(1);
RunToLocation(current_location->x, current_location->y, current_location->z, data->x, data->y, data->z);
}
else
RunToLocation(current_location->x, current_location->y, current_location->z, 0, 0, 0);
MMovementLocations.unlock();
}
}
bool Spawn::RemoveRunningLocation(){
bool ret = false;
MMovementLocations.lock();
if(movement_locations && movement_locations->size() > 0){
delete movement_locations->front();
movement_locations->pop_front();
ret = true;
}
MMovementLocations.unlock();
ValidateRunning(true, false);
return ret;
}
void Spawn::ClearRunningLocations(){
while(RemoveRunningLocation()){}
}
void Spawn::NewWaypointChange(MovementLocation* data){
if(data){
if(NeedsToResumeMovement()){
resume_movement = true;
NeedsToResumeMovement(false);
}
if(!data->attackable)
SetHeading(GetSpawnOrigHeading());
}
if (data && data->lua_function.length() > 0)
GetZone()->CallSpawnScript(this, SPAWN_SCRIPT_CUSTOM, 0, data->lua_function.c_str());
RemoveRunningLocation();
}
bool Spawn::CalculateChange(){
bool remove_needed = false;
MovementLocation* data = 0;
MovementLocation tmpLoc;
MMovementLocations.lock_shared();
if(movement_locations){
if(movement_locations->size() > 0){
// Target location
data = movement_locations->front();
if(data) {
tmpLoc.attackable = data->attackable;
tmpLoc.gridid = data->gridid;
tmpLoc.lua_function = string(data->lua_function);
tmpLoc.mapped = data->mapped;
tmpLoc.reset_hp_on_runback = data->reset_hp_on_runback;
tmpLoc.speed = data->speed;
tmpLoc.stage = data->stage;
tmpLoc.x = data->x;
tmpLoc.y = data->y;
tmpLoc.z = data->z;
data = &tmpLoc;
}
// If no target or we are at the target location need to remove this point
if(!data || (data->x == GetX() && data->y == GetY() && data->z == GetZ()))
remove_needed = true;
}
}
MMovementLocations.unlock_shared();
if(remove_needed){
NewWaypointChange(data);
}
else if(data){
// Speed is per second so we need a time_step (amount of time since the last update) to modify movement by
float time_step = (Timer::GetCurrentTime2() - last_movement_update) * 0.001; // * 0.001 is the same as / 1000, float muliplications is suppose to be faster though
// Get current location
float nx = GetX();
float ny = GetY();
float nz = GetZ();
// Get Forward vecotr
float tar_vx = data->x - nx;
float tar_vy = data->y - ny;
float tar_vz = data->z - nz;
// Multiply speed by the time_step to get how much should have changed over the last tick
float speed = GetSpeed() * time_step;
// Normalize the forward vector and multiply by speed, this gives us our change in coords, just need to add them to our current coords
float len = sqrtf(tar_vx * tar_vx + tar_vy * tar_vy + tar_vz * tar_vz);
tar_vx = (tar_vx / len) * speed;
tar_vy = (tar_vy / len) * speed;
tar_vz = (tar_vz / len) * speed;
// Distance less then 0.5 just set the npc to the target location
if (GetDistance(data->x, data->y, data->z, IsWidget() ? false : true) <= speed) {
SetX(data->x, false);
SetZ(data->z, false);
SetY(data->y, false, true);
remove_needed = true;
NewWaypointChange(data);
}
else {
SetX(nx + tar_vx, false);
SetZ(nz + tar_vz, false);
if ( IsWidget() )
SetY(ny + tar_vy, false, true);
else
SetY(ny + tar_vy, false);
}
int32 newGrid = GetLocation();
if (GetMap() != nullptr) {
m_GridMutex.writelock(__FUNCTION__, __LINE__);
std::map::iterator itr = established_grid_id.begin();
if ( itr == established_grid_id.end() || itr->second.timestamp <= (Timer::GetCurrentTime2()))
{
if(itr != established_grid_id.end() && itr->second.x == GetX() && itr->second.z == GetZ()) {
itr->second.timestamp = Timer::GetCurrentTime2()+1000;
itr->second.npc_save = true;
newGrid = itr->second.grid_id;
}
else {
auto loc = glm::vec3(GetX(), GetZ(), GetY());
float new_z = FindBestZ(loc, nullptr, &newGrid);
TimedGridData data;
data.grid_id = newGrid;
data.x = GetX();
data.y = GetY();
data.z = GetZ();
data.npc_save = true;
data.timestamp = Timer::GetCurrentTime2()+1000;
established_grid_id.insert(make_pair(0, data));
}
}
else
newGrid = itr->second.grid_id;
m_GridMutex.releasewritelock(__FUNCTION__, __LINE__);
}
if ((!IsFlyingCreature() || IsTransportSpawn()) && newGrid != 0 && newGrid != GetLocation())
SetLocation(newGrid);
}
return remove_needed;
}
void Spawn::CalculateRunningLocation(bool stop){
bool pauseTimerEnabled = IsPauseMovementTimerActive();
if (!pauseTimerEnabled && !stop && (last_location_update + 100) > Timer::GetCurrentTime2())
return;
else if (!pauseTimerEnabled && !stop)
last_location_update = Timer::GetCurrentTime2();
bool continueElseIf = true;
bool removed = CalculateChange();
if (stop || pauseTimerEnabled) {
//following = false;
SetPos(&appearance.pos.X2, GetX(), false);
SetPos(&appearance.pos.Y2, GetY(), false);
SetPos(&appearance.pos.Z2, GetZ(), false);
SetPos(&appearance.pos.X3, GetX(), false);
SetPos(&appearance.pos.Y3, GetY(), false);
SetPos(&appearance.pos.Z3, GetZ(), false);
continueElseIf = false;
}
else if (removed) {
MMovementLocations.lock_shared();
if(movement_locations) {
if(movement_locations->size() > 0) {
MovementLocation* current_location = movement_locations->at(0);
if (movement_locations->size() > 1) {
MovementLocation* data = movement_locations->at(1);
RunToLocation(current_location->x, current_location->y, current_location->z, data->x, data->y, data->z);
}
else
RunToLocation(current_location->x, current_location->y, current_location->z, 0, 0, 0);
continueElseIf = false;
}
}
MMovementLocations.unlock_shared();
}
if (continueElseIf && GetZone() && GetTarget() != NULL && EngagedInCombat())
{
if (GetDistance(GetTarget()) > rule_manager.GetGlobalRule(R_Combat, MaxCombatRange)->GetFloat())
{
if ((IsFlyingCreature() || IsWaterCreature() || InWater()) && CheckLoS(GetTarget()))
AddRunningLocation(GetTarget()->GetX(), GetTarget()->GetY(), GetTarget()->GetZ(), GetSpeed(), 0, false);
else
GetZone()->movementMgr->NavigateTo((Entity*)this, GetTarget()->GetX(), GetTarget()->GetY(), GetTarget()->GetZ());
}
else
((Entity*)this)->HaltMovement();
}
else if (continueElseIf && !following)
{
position_changed = true;
changed = true;
GetZone()->AddChangedSpawn(this);
}
}
float Spawn::GetFaceTarget(float x, float z) {
float angle;
double diff_x = x - GetX();
double diff_z = z - GetZ();
//If we're very close to the same spot don't bother changing heading
if (sqrt(diff_x * diff_x * diff_z * diff_z) < .1) {
return GetHeading();
}
if (diff_z == 0) {
if (diff_x > 0)
angle = 90;
else
angle = 270;
}
else
angle = ((atan(diff_x / diff_z)) * 180) / 3.14159265358979323846;
if (angle < 0)
angle = angle + 360;
else
angle = angle + 180;
if (diff_x < 0)
angle = angle + 180;
if (last_heading_angle == angle) return angle;
return angle;
}
void Spawn::FaceTarget(float x, float z){
float angle;
double diff_x = x - GetX();
double diff_z = z - GetZ();
//If we're very close to the same spot don't bother changing heading
if (sqrt(diff_x * diff_x * diff_z * diff_z) < .1) {
return;
}
if(diff_z==0){
if(diff_x > 0)
angle = 90;
else
angle = 270;
}
else
angle = ((atan(diff_x / diff_z)) * 180) / 3.14159265358979323846;
if(angle < 0)
angle = angle + 360;
else
angle = angle + 180;
if(diff_x < 0)
angle = angle + 180;
if (last_heading_angle == angle) return;
SetHeading(angle);
}
void Spawn::FaceTarget(Spawn* target, bool disable_action_state){
if(!target)
return;
if(GetHP() > 0 && target->IsPlayer() && !EngagedInCombat()){
if(!IsPet() && disable_action_state) {
if(IsNPC()) {
((NPC*)this)->StartRunback();
((NPC*)this)->PauseMovement(30000);
}
SetTempActionState(0);
}
}
FaceTarget(target->GetX(), target->GetZ());
}
bool Spawn::MeetsSpawnAccessRequirements(Player* player){
bool ret = false;
Quest* quest = 0;
//Check if we meet all quest requirements first..
m_requiredQuests.readlock(__FUNCTION__, __LINE__);
if (player && required_quests.size() > 0) {
map* >::iterator itr;
for (itr = required_quests.begin(); itr != required_quests.end(); itr++) {
player->AddQuestRequiredSpawn(this, itr->first);
vector* quest_steps = itr->second;
for (int32 i = 0; i < quest_steps->size(); i++) {
quest = player->GetQuest(itr->first);
if (req_quests_continued_access) {
if (quest) {
if (quest->GetQuestStepCompleted(quest_steps->at(i))) {
ret = true;
break;
}
}
else if (player->HasQuestBeenCompleted(itr->first)) {
ret = true;
break;
}
}
if (quest && quest->QuestStepIsActive(quest_steps->at(i))) {
ret = true;
break;
}
}
}
}
else
ret = true;
m_requiredQuests.releasereadlock(__FUNCTION__, __LINE__);
if (!ret)
return ret;
//Now check if the player meets all history requirements
m_requiredHistory.readlock(__FUNCTION__, __LINE__);
if (required_history.size() > 0){
map::iterator itr;
for (itr = required_history.begin(); itr != required_history.end(); itr++){
player->AddHistoryRequiredSpawn(this, itr->first);
LUAHistory* player_history = player->GetLUAHistory(itr->first);
if (player_history){
if (player_history->Value != itr->second->Value || player_history->Value2 != itr->second->Value2)
ret = false;
}
else
ret = false;
if (!ret)
break;
}
}
m_requiredHistory.releasereadlock(__FUNCTION__, __LINE__);
return ret;
}
vector* Spawn::GetSpawnGroup(){
vector* ret_list = 0;
if(spawn_group_list){
ret_list = new vector();
if(MSpawnGroup)
MSpawnGroup->readlock(__FUNCTION__, __LINE__);
ret_list->insert(ret_list->begin(), spawn_group_list->begin(), spawn_group_list->end());
if(MSpawnGroup)
MSpawnGroup->releasereadlock(__FUNCTION__, __LINE__);
}
return ret_list;
}
bool Spawn::HasSpawnGroup() {
return spawn_group_list && spawn_group_list->size() > 0;
}
bool Spawn::IsInSpawnGroup(Spawn* spawn) {
bool ret = false;
if (HasSpawnGroup() && spawn) {
vector::iterator itr;
for (itr = spawn_group_list->begin(); itr != spawn_group_list->end(); itr++) {
if ((*itr) == spawn) {
ret = true;
break;
}
}
}
return ret;
}
Spawn* Spawn::IsSpawnGroupMembersAlive(Spawn* ignore_spawn, bool npc_only) {
Spawn* ret = nullptr;
if (MSpawnGroup && HasSpawnGroup()) {
MSpawnGroup->readlock(__FUNCTION__, __LINE__);
vector::iterator itr;
for (itr = spawn_group_list->begin(); itr != spawn_group_list->end(); itr++) {
if ((*itr) != ignore_spawn && (*itr)->Alive() && (!npc_only || (npc_only && (*itr)->IsNPC()))) {
ret = (*itr);
break;
}
}
MSpawnGroup->releasereadlock(__FUNCTION__, __LINE__);
}
return ret;
}
void Spawn::UpdateEncounterState(int8 new_state) {
if (MSpawnGroup && HasSpawnGroup()) {
MSpawnGroup->readlock(__FUNCTION__, __LINE__);
vector::iterator itr;
for (itr = spawn_group_list->begin(); itr != spawn_group_list->end(); itr++) {
if ((*itr)->Alive() && (*itr)->IsNPC()) {
NPC* npc = (NPC*)(*itr);
(*itr)->SetLockedNoLoot(new_state);
if(new_state == ENCOUNTER_STATE_BROKEN && npc->Brain()) {
npc->Brain()->ClearEncounter();
}
}
}
MSpawnGroup->releasereadlock(__FUNCTION__, __LINE__);
}
}
void Spawn::CheckEncounterState(Entity* victim, bool test_auto_lock) {
if (!IsEntity() || !victim->IsNPC())
return;
Entity* ent = ((Entity*)this);
if (victim->GetLockedNoLoot() == ENCOUNTER_STATE_AVAILABLE) {
Entity* attacker = nullptr;
if (ent->GetOwner())
attacker = ent->GetOwner();
else
attacker = ent;
bool matchedAutoLock = false;
if (attacker->IsEntity() && ((Entity*)attacker)->GetGroupMemberInfo()) {
world.GetGroupManager()->GroupLock(__FUNCTION__, __LINE__);
GroupMemberInfo* gmi = ((Entity*)attacker)->GetGroupMemberInfo();
if (gmi && gmi->group_id)
{
PlayerGroup* group = world.GetGroupManager()->GetGroup(gmi->group_id);
if (group && ((group->GetGroupOptions()->group_lock_method && group->GetGroupOptions()->group_autolock == 1) || attacker->GetGroupMemberInfo()->leader))
{
matchedAutoLock = true;
group->MGroupMembers.readlock(__FUNCTION__, __LINE__);
deque* members = group->GetMembers();
for (int8 i = 0; i < members->size(); i++) {
Entity* member = members->at(i)->member;
if (!member || member->GetZone() != attacker->GetZone())
continue;
if (member->IsEntity()) {
if (!member->GetInfoStruct()->get_engaged_encounter()) {
member->GetInfoStruct()->set_engaged_encounter(1);
}
if (((NPC*)victim)->Brain()) {
((NPC*)victim)->Brain()->AddHate(member, 0);
((NPC*)victim)->Brain()->AddToEncounter(member);
victim->AddTargetToEncounter(member);
}
}
}
group->MGroupMembers.releasereadlock(__FUNCTION__, __LINE__);
}
}
world.GetGroupManager()->ReleaseGroupLock(__FUNCTION__, __LINE__);
}
else if (attacker->GetInfoStruct()->get_group_solo_autolock()) {
matchedAutoLock = true;
if (((NPC*)victim)->Brain()) {
((NPC*)victim)->Brain()->AddHate(attacker, 0);
((NPC*)victim)->Brain()->AddToEncounter(attacker);
victim->AddTargetToEncounter(attacker);
}
}
if (test_auto_lock && !matchedAutoLock) {
return;
}
if (!ent->GetInfoStruct()->get_engaged_encounter()) {
ent->GetInfoStruct()->set_engaged_encounter(1);
}
if (!attacker->GetInfoStruct()->get_engaged_encounter()) {
attacker->GetInfoStruct()->set_engaged_encounter(1);
}
int8 skip_loot_gray_mob_flag = rule_manager.GetGlobalRule(R_Loot, SkipLootGrayMob)->GetInt8();
int8 difficulty = attacker->GetArrowColor(victim->GetLevel());
int8 new_enc_state = ENCOUNTER_STATE_AVAILABLE;
if (skip_loot_gray_mob_flag && difficulty == ARROW_COLOR_GRAY) {
if (!attacker->IsPlayer() && !attacker->IsBot()) {
new_enc_state = ENCOUNTER_STATE_BROKEN;
}
else {
new_enc_state = ENCOUNTER_STATE_OVERMATCHED;
}
}
else {
if (attacker->IsPlayer() || attacker->IsBot()) {
new_enc_state = ENCOUNTER_STATE_LOCKED;
}
else {
new_enc_state = ENCOUNTER_STATE_BROKEN;
}
}
victim->SetLockedNoLoot(new_enc_state);
victim->UpdateEncounterState(new_enc_state);
}
}
void Spawn::AddTargetToEncounter(Entity* entity) {
if (MSpawnGroup && HasSpawnGroup()) {
MSpawnGroup->readlock(__FUNCTION__, __LINE__);
vector::iterator itr;
for (itr = spawn_group_list->begin(); itr != spawn_group_list->end(); itr++) {
if ((*itr) != this && (*itr)->Alive() && (*itr)->IsNPC()) {
((NPC*)(*itr))->Brain()->AddToEncounter(entity);
}
}
MSpawnGroup->releasereadlock(__FUNCTION__, __LINE__);
}
}
void Spawn::AddSpawnToGroup(Spawn* spawn){
if(!spawn)
return;
if(!spawn_group_list){
spawn_group_list = new vector();
spawn_group_list->push_back(this);
safe_delete(MSpawnGroup);
MSpawnGroup = new Mutex();
MSpawnGroup->SetName("Spawn::MSpawnGroup");
}
vector::iterator itr;
MSpawnGroup->writelock(__FUNCTION__, __LINE__);
for(itr = spawn_group_list->begin(); itr != spawn_group_list->end(); itr++){
if((*itr) == spawn){
MSpawnGroup->releasewritelock(__FUNCTION__, __LINE__);
return;
}
}
spawn_group_list->push_back(spawn);
spawn->SetSpawnGroupList(spawn_group_list, MSpawnGroup);
MSpawnGroup->releasewritelock(__FUNCTION__, __LINE__);
}
void Spawn::SetSpawnGroupList(vector* list, Mutex* mutex){
spawn_group_list = list;
MSpawnGroup = mutex;
}
void Spawn::RemoveSpawnFromGroup(bool erase_all){
SetSpawnGroupID(0);
bool del = false;
if(MSpawnGroup){
MSpawnGroup->writelock(__FUNCTION__, __LINE__);
if(spawn_group_list){
vector::iterator itr;
Spawn* spawn = 0;
if(spawn_group_list->size() == 1)
erase_all = true;
for(itr = spawn_group_list->begin(); itr != spawn_group_list->end(); itr++){
spawn = *itr;
if (spawn) {
if(!erase_all){
if(spawn == this){
spawn_group_list->erase(itr);
MSpawnGroup->releasewritelock(__FUNCTION__, __LINE__);
spawn_group_list = 0;
MSpawnGroup = 0;
return;
}
}
else{
if (spawn != this)
spawn->SetSpawnGroupList(0, 0);
}
}
}
if (erase_all)
spawn_group_list->clear();
del = (spawn_group_list->size() == 0);
}
MSpawnGroup->releasewritelock(__FUNCTION__, __LINE__);
if (del){
safe_delete(MSpawnGroup);
safe_delete(spawn_group_list);
}
}
}
void Spawn::SetSpawnGroupID(int32 id){
m_SpawnMutex.writelock();
group_id = id;
m_SpawnMutex.releasewritelock();
}
int32 Spawn::GetSpawnGroupID(){
int32 groupid = 0;
m_SpawnMutex.readlock();
groupid = group_id;
m_SpawnMutex.releasereadlock();
return groupid;
}
void Spawn::AddChangedZoneSpawn(){
if(send_spawn_changes && GetZone())
GetZone()->AddChangedSpawn(this);
}
void Spawn::RemoveSpawnAccess(Spawn* spawn) {
if (allowed_access.count(spawn->GetID()) > 0) {
allowed_access.erase(spawn->GetID());
GetZone()->HidePrivateSpawn(this);
}
}
void Spawn::SetFollowTarget(Spawn* spawn, int32 follow_distance) {
if (spawn && spawn != this) {
m_followTarget = spawn->GetID();
m_followDistance = follow_distance;
}
else {
m_followTarget = 0;
if (following)
following = false;
m_followDistance = 0;
}
}
void Spawn::AddTempVariable(string var, string val) {
m_tempVariableTypes[var] = 5;
m_tempVariables[var] = val;
}
void Spawn::AddTempVariable(string var, Spawn* val) {
m_tempVariableTypes[var] = 1;
m_tempVariableSpawn[var] = val->GetID();
}
void Spawn::AddTempVariable(string var, ZoneServer* val) {
m_tempVariableTypes[var] = 2;
m_tempVariableZone[var] = val;
}
void Spawn::AddTempVariable(string var, Item* val) {
m_tempVariableTypes[var] = 3;
m_tempVariableItem[var] = val;
}
void Spawn::AddTempVariable(string var, Quest* val) {
m_tempVariableTypes[var] = 4;
m_tempVariableQuest[var] = val;
}
string Spawn::GetTempVariable(string var) {
string ret = "";
if (m_tempVariables.count(var) > 0)
ret = m_tempVariables[var];
return ret;
}
Spawn* Spawn::GetTempVariableSpawn(string var) {
Spawn* ret = 0;
if (m_tempVariableSpawn.count(var) > 0)
ret = GetZone()->GetSpawnByID(m_tempVariableSpawn[var]);
return ret;
}
ZoneServer* Spawn::GetTempVariableZone(string var) {
ZoneServer* ret = 0;
if (m_tempVariableZone.count(var) > 0)
ret = m_tempVariableZone[var];
return ret;
}
Item* Spawn::GetTempVariableItem(string var) {
Item* ret = 0;
if (m_tempVariableItem.count(var) > 0)
ret = m_tempVariableItem[var];
return ret;
}
Quest* Spawn::GetTempVariableQuest(string var) {
Quest* ret = 0;
if (m_tempVariableQuest.count(var) > 0)
ret = m_tempVariableQuest[var];
return ret;
}
int8 Spawn::GetTempVariableType(string var) {
int8 ret = 0;
if (m_tempVariableTypes.count(var) > 0)
ret = m_tempVariableTypes[var];
return ret;
}
void Spawn::DeleteTempVariable(string var) {
int8 type = GetTempVariableType(var);
switch (type) {
case 1:
m_tempVariableSpawn.erase(var);
break;
case 2:
m_tempVariableZone.erase(var);
break;
case 3:
m_tempVariableItem.erase(var);
break;
case 4:
m_tempVariableQuest.erase(var);
break;
case 5:
m_tempVariables.erase(var);
break;
}
m_tempVariableTypes.erase(var);
}
Spawn* Spawn::GetRunningTo() {
return GetZone()->GetSpawnByID(running_to);
}
Spawn* Spawn::GetFollowTarget() {
return GetZone()->GetSpawnByID(m_followTarget);
}
void Spawn::CopySpawnAppearance(Spawn* spawn){
if (!spawn)
return;
//This function copies the appearace of the provided spawn to this one
if (spawn->IsEntity() && IsEntity()){
memcpy(&((Entity*)this)->features, &((Entity*)spawn)->features, sizeof(CharFeatures));
memcpy(&((Entity*)this)->equipment, &((Entity*)spawn)->equipment, sizeof(EQ2_Equipment));
}
SetSize(spawn->GetSize());
SetModelType(spawn->GetModelType());
}
void Spawn::SetY(float y, bool updateFlags, bool disableYMapCheck)
{
SetPos(&appearance.pos.Y, y, updateFlags);
if (!disableYMapCheck)
FixZ();
}
float Spawn::FindDestGroundZ(glm::vec3 dest, float z_offset)
{
float best_z = BEST_Z_INVALID;
if (GetZone() != nullptr && GetMap() != nullptr)
{
dest.z += z_offset;
best_z = FindBestZ(dest, nullptr);
}
return best_z;
}
float Spawn::FindBestZ(glm::vec3 loc, glm::vec3* result, int32* new_grid_id, int32* new_widget_id) {
std::shared_lock lock(MIgnoredWidgets);
if(!GetMap())
return BEST_Z_INVALID;
float new_z = GetMap()->FindBestZ(loc, nullptr, &ignored_widgets, new_grid_id, new_widget_id);
return new_z;
}
float Spawn::GetFixedZ(const glm::vec3& destination, int32 z_find_offset) {
BenchTimer timer;
timer.reset();
float new_z = destination.z;
if (GetZone() != nullptr && GetMap() != nullptr) {
/* if (flymode == GravityBehavior::Flying)
return new_z;
*/
/* if (zone->HasWaterMap() && zone->watermap->InLiquid(glm::vec3(m_Position)))
return new_z;
*/
/*
* Any more than 5 in the offset makes NPC's hop/snap to ceiling in small corridors
*/
new_z = this->FindDestGroundZ(destination, z_find_offset);
if (new_z != BEST_Z_INVALID) {
if (new_z < -2000) {
new_z = GetY();
}
}
auto duration = timer.elapsed();
LogWrite(MAP__DEBUG, 0, "Map", "Mob::GetFixedZ() ([{%s}]) returned [{%f}] at [{%f}], [{%f}], [{%f}] - Took [{%f}]",
this->GetName(),
new_z,
destination.x,
destination.y,
destination.z,
duration);
}
return new_z;
}
void Spawn::FixZ(bool forceUpdate) {
if (!GetZone()) {
return;
}
/*
if (flymode == GravityBehavior::Flying) {
return;
}*/
/*
if (zone->watermap && zone->watermap->InLiquid(m_Position)) {
return;
}*/
// we do the inwater check here manually to avoid double calling for a Z coordinate
glm::vec3 current_loc(GetX(), GetZ(), GetY());
uint32 GridID = 0;
uint32 WidgetID = 0;
float new_z = GetY();
if(GetMap() != nullptr) {
new_z = FindBestZ(current_loc, nullptr, &GridID, &WidgetID);
if ((IsTransportSpawn() || !IsFlyingCreature()) && GridID != 0 && GridID != GetLocation()) {
LogWrite(PLAYER__DEBUG, 0, "Player", "%s left grid %u and entered grid %u", appearance.name, GetLocation(), GridID);
const char* zone_script = world.GetZoneScript(GetZone()->GetZoneID());
if (zone_script && lua_interface) {
lua_interface->RunZoneScript(zone_script, "leave_location", GetZone(), this, GetLocation());
}
SetLocation(GridID);
if (zone_script && lua_interface) {
lua_interface->RunZoneScript(zone_script, "enter_location", GetZone(), this, GridID);
}
}
trigger_widget_id = WidgetID;
}
// no need to go any further for players, flying creatures or objects, just needed the grid id set
if (IsPlayer() || IsFlyingCreature() || IsObject()) {
return;
}
if ( region_map != nullptr )
{
glm::vec3 targPos(GetX(), GetY(), GetZ());
if(region_map->InWater(targPos, GetLocation()))
return;
}
if (new_z == GetY())
return;
if ((new_z > -2000) && new_z != BEST_Z_INVALID) {
SetY(new_z, forceUpdate, true);
}
else {
LogWrite(MAP__DEBUG, 0, "Map", "[{%s}] is failing to find Z [{%f}]", this->GetName(), std::abs(GetY() - new_z));
}
}
bool Spawn::CheckLoS(Spawn* target)
{
float radiusSrc = 2.0f;
float radiusTarg = 2.0f;
glm::vec3 targpos(target->GetX(), target->GetZ(), target->GetY()+radiusTarg);
glm::vec3 pos(GetX(), GetZ(), GetY()+radiusSrc);
return CheckLoS(pos, targpos);
}
bool Spawn::CheckLoS(glm::vec3 myloc, glm::vec3 oloc)
{
bool res = false;
ZoneServer* zone = GetZone();
if (zone == NULL || GetMap() == NULL || !GetMap()->IsMapLoaded())
return true;
else {
MIgnoredWidgets.lock_shared();
res = GetMap()->CheckLoS(myloc, oloc, &ignored_widgets);
MIgnoredWidgets.unlock_shared();
}
return res;
}
void Spawn::CalculateNewFearpoint()
{
if (GetZone() && GetZone()->pathing) {
auto Node = zone->pathing->GetRandomLocation(glm::vec3(GetX(), GetZ(), GetY()));
if (Node.x != 0.0f || Node.y != 0.0f || Node.z != 0.0f) {
AddRunningLocation(Node.x, Node.y, Node.z, GetSpeed(), 0, true, true, "", true);
}
}
}
Item* Spawn::LootItem(int32 id) {
Item* ret = 0;
vector::iterator itr;
MLootItems.lock();
for (itr = loot_items.begin(); itr != loot_items.end(); itr++) {
if ((*itr)->details.item_id == id) {
ret = *itr;
loot_items.erase(itr);
break;
}
}
MLootItems.unlock();
return ret;
}
void Spawn::TransferLoot(Spawn* spawn) {
if(spawn == this || spawn == nullptr)
return; // mmm no
vector::iterator itr;
MLootItems.lock();
for (itr = loot_items.begin(); itr != loot_items.end();) {
if (!(*itr)->IsBodyDrop()) {
spawn->AddLootItem(*itr);
itr = loot_items.erase(itr);
}
else {
itr++;
}
}
MLootItems.unlock();
}
int32 Spawn::GetLootItemID() {
int32 ret = 0;
vector::iterator itr;
MLootItems.lock();
for (itr = loot_items.begin(); itr != loot_items.end(); itr++) {
ret = (*itr)->details.item_id;
break;
}
MLootItems.unlock();
return ret;
}
void Spawn::GetLootItemsList(std::vector* out_entries) {
if(!out_entries)
return;
vector::iterator itr;
for (itr = loot_items.begin(); itr != loot_items.end(); itr++) {
out_entries->push_back((*itr)->details.item_id);
}
}
bool Spawn::HasLootItemID(int32 id) {
bool ret = false;
vector::iterator itr;
MLootItems.readlock(__FUNCTION__, __LINE__);
for (itr = loot_items.begin(); itr != loot_items.end(); itr++) {
if ((*itr)->details.item_id == id) {
ret = true;
break;
}
}
MLootItems.releasereadlock(__FUNCTION__, __LINE__);
return ret;
}
void Spawn::CheckProximities()
{
if (!has_spawn_proximities)
return;
if (spawn_proximities.size() > 0)
{
MutexList::iterator itr = spawn_proximities.begin();
while (itr.Next()) {
SpawnProximity* prox = itr.value;
map::iterator spawnsItr;
for (spawnsItr = prox->spawns_in_proximity.begin(); spawnsItr != prox->spawns_in_proximity.end(); spawnsItr++) {
Spawn* tmpSpawn = 0;
if (spawnsItr->first &&
((prox->spawn_type == SPAWNPROXIMITY_DATABASE_ID && (tmpSpawn = GetZone()->GetSpawnByDatabaseID(spawnsItr->first)) != 0) ||
(prox->spawn_type == SPAWNPROXIMITY_LOCATION_ID && (tmpSpawn = GetZone()->GetSpawnByLocationID(spawnsItr->first)) != 0)))
{
if (!spawnsItr->second && tmpSpawn->GetDistance(this) <= prox->distance)
{
if (prox->in_range_lua_function.size() > 0)
GetZone()->CallSpawnScript(this, SPAWN_SCRIPT_CUSTOM, tmpSpawn, prox->in_range_lua_function.c_str());
spawnsItr->second = true;
}
else if (spawnsItr->second && tmpSpawn->GetDistance(this) > prox->distance)
{
if (prox->leaving_range_lua_function.size() > 0)
GetZone()->CallSpawnScript(this, SPAWN_SCRIPT_CUSTOM, tmpSpawn, prox->leaving_range_lua_function.c_str());
spawnsItr->second = false;
}
}
}
}
}
}
void Spawn::AddSpawnToProximity(int32 spawnValue, SpawnProximityType type)
{
if (!has_spawn_proximities)
return;
if (spawn_proximities.size() > 0)
{
MutexList::iterator itr = spawn_proximities.begin();
while (itr.Next()) {
SpawnProximity* prox = itr->value;
if (prox->spawn_value == spawnValue && prox->spawn_type == type)
prox->spawns_in_proximity.insert(make_pair(spawnValue, false));
}
}
}
void Spawn::RemoveSpawnFromProximity(int32 spawnValue, SpawnProximityType type)
{
if (!has_spawn_proximities)
return;
if (spawn_proximities.size() > 0)
{
MutexList::iterator itr = spawn_proximities.begin();
while (itr.Next()) {
SpawnProximity* prox = itr->value;
if (prox->spawn_value == spawnValue && prox->spawn_type == type &&
prox->spawns_in_proximity.count(spawnValue) > 0)
prox->spawns_in_proximity.erase(spawnValue);
}
}
}
void Spawn::AddPrimaryEntityCommand(const char* name, float distance, const char* command, const char* error_text, int16 cast_time, int32 spell_visual, bool defaultDenyList, Player* player) {
EntityCommand* cmd = FindEntityCommand(string(command), true);
bool newCommand = false;
if (!cmd)
{
newCommand = true;
cmd = CreateEntityCommand(name, distance, command, error_text, cast_time, spell_visual, !defaultDenyList);
}
if (defaultDenyList)
SetPermissionToEntityCommand(cmd, player, true);
if (newCommand)
primary_command_list.push_back(cmd);
}
void Spawn::RemovePrimaryEntityCommand(const char* command) {
vector::iterator itr;
string tmpStr(command);
for (itr = primary_command_list.begin(); itr != primary_command_list.end(); itr++) {
EntityCommand* cmd = *itr;
if (cmd->command.compare(tmpStr) == 0)
{
primary_command_list.erase(itr);
delete cmd;
break;
}
}
}
bool Spawn::SetPermissionToEntityCommand(EntityCommand* command, Player* player, bool permissionValue)
{
if(!player)
return false;
return SetPermissionToEntityCommandByCharID(command, player->GetCharacterID(), permissionValue);
}
bool Spawn::SetPermissionToEntityCommandByCharID(EntityCommand* command, int32 charID, bool permissionValue)
{
map::iterator itr = command->allow_or_deny.find(charID);
if (itr == command->allow_or_deny.end())
command->allow_or_deny.insert(make_pair(charID, permissionValue));
else if (itr->second != permissionValue)
itr->second = permissionValue;
return true;
}
void Spawn::RemoveSpawnFromPlayer(Player* player)
{
m_Update.writelock(__FUNCTION__, __LINE__);
player->RemoveSpawn(this); // sets it as removed
m_Update.releasewritelock(__FUNCTION__, __LINE__);
}
bool Spawn::InWater()
{
bool inWater = false;
if ( region_map != nullptr )
{
glm::vec3 targPos(GetX(), GetY(), GetZ());
if ( IsGroundSpawn() )
targPos.y -= .5f;
if(region_map->InWater(targPos, GetLocation()))
inWater = true;
}
return inWater;
}
bool Spawn::InLava()
{
bool inLava = false;
if ( region_map != nullptr )
{
glm::vec3 targPos(GetX(), GetY(), GetZ());
if ( IsGroundSpawn() )
targPos.y -= .5f;
if(region_map->InLava(targPos, GetLocation()))
inLava = true;
}
return inLava;
}
void Spawn::DeleteRegion(Region_Node* inNode, ZBSP_Node* rootNode)
{
map, Region_Status>::iterator testitr;
for (testitr = Regions.begin(); testitr != Regions.end(); testitr++)
{
map::const_iterator actualItr = testitr->first.begin();
Region_Node* node = actualItr->first;
ZBSP_Node* BSP_Root = actualItr->second;
if(inNode == node && rootNode == BSP_Root )
{
testitr = Regions.erase(testitr);
break;
}
}
}
bool Spawn::InRegion(Region_Node* inNode, ZBSP_Node* rootNode)
{
map, Region_Status>::iterator testitr;
for (testitr = Regions.begin(); testitr != Regions.end(); testitr++)
{
map::const_iterator actualItr = testitr->first.begin();
Region_Node* node = actualItr->first;
ZBSP_Node* BSP_Root = actualItr->second;
if(inNode == node && rootNode == BSP_Root )
{
return testitr->second.inRegion;
}
}
return false;
}
int32 Spawn::GetRegionType(Region_Node* inNode, ZBSP_Node* rootNode)
{
map, Region_Status>::iterator testitr;
for (testitr = Regions.begin(); testitr != Regions.end(); testitr++)
{
map::const_iterator actualItr = testitr->first.begin();
Region_Node* node = actualItr->first;
ZBSP_Node* BSP_Root = actualItr->second;
if(inNode == node && rootNode == BSP_Root )
{
return testitr->second.regionType;
}
}
return false;
}
float Spawn::SpawnAngle(Spawn* target, float selfx, float selfz)
{
if (!target || target == this)
return 0.0f;
float angle, lengthb, vectorx, vectorz, dotp;
float spx = (target->GetX()); // mob xloc (inverse because eq)
float spz = -(target->GetZ()); // mob yloc
float heading = target->GetHeading(); // mob heading
if (heading < 270)
heading += 90;
else
heading -= 270;
heading = heading * 3.1415f / 180.0f; // convert to radians
vectorx = spx + (10.0f * std::cos(heading)); // create a vector based on heading
vectorz = spz + (10.0f * std::sin(heading)); // of spawn length 10
// length of spawn to player vector
lengthb = (float) std::sqrt(((selfx - spx) * (selfx - spx)) + ((-selfz - spz) * (-selfz - spz)));
// calculate dot product to get angle
// Handle acos domain errors due to floating point rounding errors
dotp = ((vectorx - spx) * (selfx - spx) +
(vectorz - spz) * (-selfz - spz)) / (10.0f * lengthb);
if (dotp > 1)
return 0.0f;
else if (dotp < -1)
return 180.0f;
angle = std::acos(dotp);
angle = angle * 180.0f / 3.1415f;
return angle;
}
void Spawn::StopMovement()
{
reset_movement = true;
}
bool Spawn::PauseMovement(int32 period_of_time_ms)
{
if(period_of_time_ms < 1)
period_of_time_ms = 1;
RunToLocation(GetX(),GetY(),GetZ());
pause_timer.Start(period_of_time_ms, true);
return true;
}
bool Spawn::IsPauseMovementTimerActive()
{
if(pause_timer.Check())
pause_timer.Disable();
return pause_timer.Enabled();
}
bool Spawn::IsFlyingCreature()
{
if(!IsEntity())
return false;
return ((Entity*)this)->GetInfoStruct()->get_flying_type();
}
bool Spawn::IsWaterCreature()
{
if(!IsEntity())
return false;
return ((Entity*)this)->GetInfoStruct()->get_water_type();
}
void Spawn::SetFlyingCreature() {
if(!IsEntity() || !rule_manager.GetGlobalRule(R_Spawn, UseHardCodeFlyingModelType)->GetInt8())
return;
if(((Entity*)this)->GetInfoStruct()->get_flying_type() > 0) // DB spawn npc flag already set
return;
switch (GetModelType())
{
case 260:
case 295:
((Entity*)this)->GetInfoStruct()->set_flying_type(1);
is_flying_creature = true;
break;
default:
((Entity*)this)->GetInfoStruct()->set_flying_type(0);
break;
}
}
void Spawn::SetWaterCreature() {
if(!IsEntity() || !rule_manager.GetGlobalRule(R_Spawn, UseHardCodeWaterModelType)->GetInt8())
return;
if(((Entity*)this)->GetInfoStruct()->get_water_type() > 0) // DB spawn npc flag already set
return;
switch (GetModelType())
{
case 194:
case 204:
case 210:
case 241:
case 242:
case 254:
case 10668:
case 20828:
((Entity*)this)->GetInfoStruct()->set_water_type(1);
break;
default:
((Entity*)this)->GetInfoStruct()->set_water_type(0);
break;
}
}
void Spawn::AddRailPassenger(int32 char_id)
{
std::lock_guard lk(m_RailMutex);
rail_passengers.insert(make_pair(char_id,true));
}
void Spawn::RemoveRailPassenger(int32 char_id)
{
std::lock_guard lk(m_RailMutex);
std::map::iterator itr = rail_passengers.find(char_id);
if(itr != rail_passengers.end())
rail_passengers.erase(itr);
}
vector Spawn::GetPassengersOnRail() {
vector tmp_list;
Spawn* spawn;
m_RailMutex.lock();
std::map::iterator itr = rail_passengers.begin();
while(itr != rail_passengers.end()){
Client* client = zone_list.GetClientByCharID(itr->first);
if(!client || !client->GetPlayer())
continue;
tmp_list.push_back(client->GetPlayer());
itr++;
}
m_RailMutex.unlock();
return tmp_list;
}
void Spawn::SetAppearancePosition(float x, float y, float z) {
appearance.pos.X = x;
appearance.pos.Y = y;
appearance.pos.Z = z;
appearance.pos.X2 = appearance.pos.X;
appearance.pos.Y2 = appearance.pos.Y;
appearance.pos.Z2 = appearance.pos.Z;
appearance.pos.X3 = appearance.pos.X;
appearance.pos.Y3 = appearance.pos.Y;
appearance.pos.Z3 = appearance.pos.Z;
SetSpeedX(0);
SetSpeedY(0);
SetSpeedZ(0);
if(IsPlayer()) {
((Player*)this)->SetSideSpeed(0);
((Player*)this)->pos_packet_speed = 0;
}
}
int32 Spawn::InsertRegionToSpawn(Region_Node* node, ZBSP_Node* bsp_root, WaterRegionType regionType, bool in_region) {
std::map newMap;
newMap.insert(make_pair(node, bsp_root));
Region_Status status;
status.inRegion = in_region;
status.regionType = regionType;
int32 returnValue = 0;
if(in_region) {
lua_interface->RunRegionScript(node->regionScriptName, "EnterRegion", GetZone(), this, regionType, &returnValue);
}
status.timerTic = returnValue;
status.lastTimerTic = returnValue ? Timer::GetCurrentTime2() : 0;
Regions.insert(make_pair(newMap, status));
return returnValue;
}
bool Spawn::HasRegionTracked(Region_Node* node, ZBSP_Node* bsp_root, bool in_region) {
map, Region_Status>::iterator testitr;
for (testitr = Regions.begin(); testitr != Regions.end(); testitr++)
{
map::const_iterator actualItr = testitr->first.begin();
Region_Node *node = actualItr->first;
ZBSP_Node *BSP_Root = actualItr->second;
if(node == actualItr->first && BSP_Root == actualItr->second) {
if(testitr->second.inRegion == in_region)
return true;
else
break;
}
}
return false;
}
void Spawn::SetLocation(int32 id, bool setUpdateFlags)
{
if(GetZone()) {
GetZone()->RemoveSpawnFromGrid(this, GetLocation());
SetPos(&appearance.pos.grid_id, id, setUpdateFlags);
GetZone()->AddSpawnToGrid(this, id);
}
else {
SetPos(&appearance.pos.grid_id, id, setUpdateFlags);
}
}
int8 Spawn::GetArrowColor(int8 spawn_level){
int8 color = 0;
sint16 diff = spawn_level - GetLevel();
if(GetLevel() < 10)
diff *= 3;
else if(GetLevel() <= 20)
diff *= 2;
if(diff >= 9)
color = ARROW_COLOR_RED;
else if(diff >= 5)
color = ARROW_COLOR_ORANGE;
else if(diff >= 1)
color = ARROW_COLOR_YELLOW;
else if(diff == 0)
color = ARROW_COLOR_WHITE;
else if(diff <= -11)
color = ARROW_COLOR_GRAY;
else if(diff <= -6)
color = ARROW_COLOR_GREEN;
else //if(diff < 0)
color = ARROW_COLOR_BLUE;
return color;
}
void Spawn::AddIgnoredWidget(int32 id) {
std::unique_lock lock(MIgnoredWidgets);
if(ignored_widgets.find(id) == ignored_widgets.end()) {
ignored_widgets.insert(make_pair(id,true));
}
}
void Spawn::SendGroupUpdate() {
if (IsEntity() && ((Entity*)this)->GetGroupMemberInfo()) {
((Entity*)this)->UpdateGroupMemberInfo();
if (IsPlayer()) {
Client* client = ((Player*)this)->GetClient();
if(client) {
world.GetGroupManager()->SendGroupUpdate(((Entity*)this)->GetGroupMemberInfo()->group_id, client);
}
}
else
world.GetGroupManager()->SendGroupUpdate(((Entity*)this)->GetGroupMemberInfo()->group_id);
}
}
bool Spawn::AddNeedGreedItemRequest(int32 item_id, int32 spawn_id, bool need_item) {
LogWrite(LOOT__INFO, 0, "Loot", "%s: AddNeedGreedItemRequest Item ID: %u, Spawn ID: %u, Need Item: %u", GetName(), item_id, spawn_id, need_item);
if (HasSpawnNeedGreedEntry(item_id, spawn_id)) {
return false;
}
need_greed_items.insert(make_pair(item_id, std::make_pair(spawn_id, need_item)));
AddSpawnLootWindowCompleted(spawn_id, false);
return true;
}
bool Spawn::AddLottoItemRequest(int32 item_id, int32 spawn_id) {
LogWrite(LOOT__INFO, 0, "Loot", "%s: AddLottoItemRequest Item ID: %u, Spawn ID: %u", GetName(), item_id, spawn_id);
if (HasSpawnLottoEntry(item_id, spawn_id)) {
return false;
}
lotto_items.insert(make_pair(item_id, spawn_id));
AddSpawnLootWindowCompleted(spawn_id, false);
return true;
}
void Spawn::AddSpawnLootWindowCompleted(int32 spawn_id, bool status_) {
if (loot_complete.find(spawn_id) == loot_complete.end()) {
loot_complete.insert(make_pair(spawn_id, status_));
}
is_loot_complete = HasLootWindowCompleted();
}
bool Spawn::SetSpawnLootWindowCompleted(int32 spawn_id) {
std::map::iterator itr = loot_complete.find(spawn_id);
if (itr != loot_complete.end()) {
itr->second = true;
is_loot_complete = HasLootWindowCompleted();
return true;
}
return false;
}
bool Spawn::HasSpawnLootWindowCompleted(int32 spawn_id) {
std::map::iterator itr = loot_complete.find(spawn_id);
if (itr != loot_complete.end() && itr->second) {
return true;
}
return false;
}
bool Spawn::HasSpawnNeedGreedEntry(int32 item_id, int32 spawn_id) {
for (auto [itr, rangeEnd] = need_greed_items.equal_range(item_id); itr != rangeEnd; itr++) {
LogWrite(LOOT__DEBUG, 8, "Loot", "%s: HasSpawnNeedGreedEntry Item ID: %u, Spawn ID: %u", GetName(), itr->first, itr->second.first);
if (spawn_id == itr->second.first) {
return true;
}
}
return false;
}
bool Spawn::HasSpawnLottoEntry(int32 item_id, int32 spawn_id) {
for (auto [itr, rangeEnd] = lotto_items.equal_range(item_id); itr != rangeEnd; itr++) {
LogWrite(LOOT__DEBUG, 8, "Loot", "%s: HasSpawnLottoEntry Item ID: %u, Spawn ID: %u", GetName(), itr->first, itr->second);
if (spawn_id == itr->second) {
return true;
}
}
return false;
}
void Spawn::GetSpawnLottoEntries(int32 item_id, std::map* out_entries) {
if (!out_entries)
return;
std::map spawn_matches;
for (auto [itr, endrange] = lotto_items.equal_range(item_id); itr != endrange; itr++) {
out_entries->insert(std::make_pair(itr->second, (int32)MakeRandomInt(0, 100)));
spawn_matches[itr->second] = true;
}
// 0xFFFFFFFF represents selecting "All" on the lotto screen
for (auto [itr, endrange] = lotto_items.equal_range(0xFFFFFFFF); itr != endrange; itr++) {
if (spawn_matches.find(itr->second) == spawn_matches.end()) {
out_entries->insert(std::make_pair(itr->second, (int32)MakeRandomInt(0, 100)));
}
}
}
void Spawn::GetSpawnNeedGreedEntries(int32 item_id, bool need_item, std::map* out_entries) {
if (!out_entries)
return;
for (auto [itr, rangeEnd] = need_greed_items.equal_range(item_id); itr != rangeEnd; itr++) {
out_entries->insert(std::make_pair(itr->second.first, (int32)MakeRandomInt(0, 100)));
}
}
bool Spawn::HasLootWindowCompleted() {
std::map::iterator itr;
for (itr = loot_complete.begin(); itr != loot_complete.end(); itr++) {
if (!itr->second)
return false;
}
return true;
}
void Spawn::StartLootTimer(Spawn* looter) {
if (!IsLootTimerRunning()) {
int32 loot_timer_time = rule_manager.GetGlobalRule(R_Loot, LootDistributionTime)->GetInt32() * 1000;
if(rule_manager.GetGlobalRule(R_Loot, AllowChestUnlockByDropTime)->GetBool() && loot_timer_time > rule_manager.GetGlobalRule(R_Loot, ChestUnlockedTimeDrop)->GetInt32()*1000) {
loot_timer_time = (rule_manager.GetGlobalRule(R_Loot, ChestUnlockedTimeDrop)->GetInt32()*1000) / 2;
}
if(rule_manager.GetGlobalRule(R_Loot, AllowChestUnlockByTrapTime)->GetBool() && loot_timer_time > rule_manager.GetGlobalRule(R_Loot, ChestUnlockedTimeTrap)->GetInt32()*1000) {
loot_timer_time = (rule_manager.GetGlobalRule(R_Loot, ChestUnlockedTimeTrap)->GetInt32()*1000) / 2;
}
if(loot_timer_time < 1000) {
loot_timer_time = 60000; // hardcode assure they aren't setting some really ridiculous low number
}
loot_timer.Start(loot_timer_time, true);
}
if (looter) {
looter_spawn_id = looter->GetID();
}
}
void Spawn::CloseLoot(Spawn* sender) {
if (sender) {
SetSpawnLootWindowCompleted(sender->GetID());
}
if (sender && looter_spawn_id > 0 && sender->GetID() != looter_spawn_id) {
LogWrite(LOOT__ERROR, 0, "Loot", "%s: CloseLoot Looter Spawn ID: %u does not match sender %u.", GetName(), looter_spawn_id, sender->GetID());
return;
}
if (!IsLootTimerRunning() && GetLootMethod() != GroupLootMethod::METHOD_LOTTO && GetLootMethod() != GroupLootMethod::METHOD_NEED_BEFORE_GREED) {
loot_timer.Disable();
}
looter_spawn_id = 0;
}
void Spawn::SetLootMethod(GroupLootMethod method, int8 item_rarity, int32 group_id) {
LogWrite(LOOT__INFO, 0, "Loot", "%s: Set Loot Method : %u, group id : %u", GetName(), (int32)method, group_id);
loot_group_id = group_id;
loot_method = method;
loot_rarity = item_rarity;
if (loot_name.size() < 1) {
loot_name = std::string(GetName());
}
}
bool Spawn::IsItemInLootTier(Item* item) {
if (!item)
return true;
bool skipItem = true;
switch (GetLootRarity()) {
case LootTier::ITEMS_TREASURED_PLUS: {
if (item->details.tier >= ITEM_TAG_TREASURED) {
skipItem = false;
}
break;
}
case LootTier::ITEMS_LEGENDARY_PLUS: {
if (item->details.tier >= ITEM_TAG_LEGENDARY) {
skipItem = false;
}
break;
}
case LootTier::ITEMS_FABLED_PLUS: {
if (item->details.tier >= ITEM_TAG_FABLED) {
skipItem = false;
}
break;
}
default: {
skipItem = false;
break;
}
}
return skipItem;
}
void Spawn::DistributeGroupLoot_RoundRobin(std::vector* item_list, bool roundRobinTrashLoot) {
std::vector::iterator item_itr;
for (item_itr = item_list->begin(); item_itr != item_list->end(); item_itr++) {
int32 item_id = *item_itr;
Item* tmpItem = master_item_list.GetItem(item_id);
Spawn* looter = nullptr;
bool skipItem = IsItemInLootTier(tmpItem);
if ((skipItem && !roundRobinTrashLoot) || (!skipItem && roundRobinTrashLoot))
continue;
world.GetGroupManager()->GroupLock(__FUNCTION__, __LINE__);
PlayerGroup* group = world.GetGroupManager()->GetGroup(GetLootGroupID());
if (group) {
group->MGroupMembers.writelock(__FUNCTION__, __LINE__);
deque* members = group->GetMembers();
int8 index = group->GetLastLooterIndex();
if (index >= members->size()) {
index = 0;
}
GroupMemberInfo* gmi = members->at(index);
if (gmi) {
looter = gmi->member;
}
bool loopAttempted = false;
while (looter) {
if (!looter->IsPlayer()) {
index++;
if (index >= members->size()) {
if (loopAttempted) {
looter = nullptr;
break;
}
loopAttempted = true;
index = 0;
}
gmi = members->at(index);
if (gmi) {
looter = gmi->member;
}
continue;
}
else {
break;
}
}
index += 1;
group->SetNextLooterIndex(index);
group->MGroupMembers.releasewritelock(__FUNCTION__, __LINE__);
}
world.GetGroupManager()->ReleaseGroupLock(__FUNCTION__, __LINE__);
if (looter) {
if (looter->IsPlayer()) {
Item* item = LootItem(item_id);
bool success = false;
success = ((Player*)looter)->GetClient()->HandleLootItem(this, item, ((Player*)looter), roundRobinTrashLoot);
if (!success)
AddLootItem(item);
}
else {
Item* item = LootItem(item_id);
safe_delete(item);
}
}
}
}
const double g = 9.81; // acceleration due to gravity (m/s^2)
void Spawn::CalculateInitialVelocity(float heading, float distanceHorizontal, float distanceVertical, float distanceDepth, float duration) {
float vx = distanceHorizontal / duration;
float vy = (distanceVertical + 0.5 * g * duration * duration) / duration;
float vz = distanceDepth / duration;
// Convert heading angle to radians
knocked_velocity.x = vx * cos(heading);
knocked_velocity.y = vy;
knocked_velocity.z = vz * sin(heading);
}
// Function to calculate the projectile position at a given time
glm::vec3 Spawn::CalculateProjectilePosition(glm::vec3 initialVelocity, float time) {
glm::vec3 position;
position.x = knocked_back_start_x + initialVelocity.x * time;
position.y = knocked_back_start_y + initialVelocity.y * time - 0.5 * g * time * time;
position.z = knocked_back_start_z + initialVelocity.z * time;
auto loc = glm::vec3(position.x, position.z, position.y);
float new_z = FindBestZ(loc, nullptr);
if(new_z > position.y)
position.y = new_z;
return position;
}
bool Spawn::CalculateSpawnProjectilePosition(float x, float y, float z) {
float currentTimeOffset = (Timer::GetCurrentTime2() - last_movement_update) * 0.001; // * 0.001 is the same as / 1000, float muliplications is suppose to be faster though
float stepAheadOne = currentTimeOffset+currentTimeOffset;
knocked_back_time_step += currentTimeOffset;
if(Timer::GetCurrentTime2() >= knocked_back_end_time) {
ResetKnockedBack();
FixZ(true);
return false;
}
glm::vec3 position = CalculateProjectilePosition(knocked_velocity, knocked_back_time_step);
glm::vec3 position_two = position;
if(Timer::GetCurrentTime2() <= knocked_back_end_time+stepAheadOne) {
position_two = CalculateProjectilePosition(knocked_velocity, knocked_back_time_step+stepAheadOne);
}
if(GetMap()) {
glm::vec3 loc(GetX(), GetZ(), GetY() + .5f);
glm::vec3 dest_loc(position_two.x, position_two.z, position_two.y);
MIgnoredWidgets.lock_shared();
glm::vec3 outNorm;
float dist = 0.0f;
bool collide_ = GetMap()->DoCollisionCheck(loc, dest_loc, &ignored_widgets, outNorm, dist);
if(collide_) {
LogWrite(SPAWN__ERROR, 0, "Spawn", "Collision Hit: cur loc x,y,z: %f %f %f. to loc %f %f %f. TimeOffset: %f Total Time: %f Duration: %f", GetX(),GetY(),GetZ(),position_two.x,position_two.y,position_two.z, currentTimeOffset, knocked_back_time_step, knocked_back_duration);
MIgnoredWidgets.unlock_shared();
ResetKnockedBack();
FixZ(true);
return false;
}
MIgnoredWidgets.unlock_shared();
}
LogWrite(SPAWN__ERROR, 0, "Spawn", "x,y,z: %f %f %f. Final %f %f %f. TimeOffset: %f Total Time: %f Duration: %f", GetX(),GetY(),GetZ(),position.x,position.y,position.z, currentTimeOffset, knocked_back_time_step, knocked_back_duration);
SetX(position.x, false);
SetZ(position.z, false);
SetY(position.y, false, true);
SetPos(&appearance.pos.X2, position_two.x, false);
SetPos(&appearance.pos.Z2, position_two.z, false);
SetPos(&appearance.pos.Y2, position_two.y, false);
SetPos(&appearance.pos.X3, position_two.x, false);
SetPos(&appearance.pos.Z3, position_two.z, false);
SetPos(&appearance.pos.Y3, position_two.y, false);
position_changed = true;
changed = true;
GetZone()->AddChangedSpawn(this);
return true;
}
void Spawn::SetKnockback(Spawn* target, int32 duration, float vertical, float horizontal) {
if(knocked_back) {
return; // already being knocked back
}
// Calculate the direction vector from source to destination
glm::vec3 direction = {GetX() - target->GetX(), GetZ() - target->GetZ(), GetY() - target->GetY()};
// Calculate the heading angle in radians
double headingRad = atan2(direction.y, sqrt(direction.x * direction.x + direction.z * direction.z));
knocked_angle = headingRad;
knocked_back_start_x = GetX();
knocked_back_start_y = GetY();
knocked_back_start_z = GetZ();
knocked_back_h_distance = horizontal / 10.0f;
knocked_back_v_distance = vertical / 10.0f;
knocked_back_duration = static_cast(duration) / 1000.0f;
knocked_back_end_time = Timer::GetCurrentTime2() + duration;
CalculateInitialVelocity(knocked_angle, knocked_back_h_distance, knocked_back_h_distance, knocked_back_h_distance, knocked_back_duration);
knocked_back = true;
}
void Spawn::ResetKnockedBack() {
knocked_back = false;
knocked_back_time_step = 0.0f;
knocked_back_h_distance = 0.0f;
knocked_back_v_distance = 0.0f;
knocked_back_duration = 0.0f;
knocked_back_end_time = 0;
knocked_back_start_x = 0.0f;
knocked_back_start_y = 0.0f;
knocked_back_start_z = 0.0f;
knocked_angle = 0.0f;
knocked_velocity.x = 0.0f;
knocked_velocity.y = 0.0f;
knocked_velocity.z = 0.0f;
}