pa/eqemu-server
2
0
Fork 0
mirror of https://github.com/EQEmu/Server.git synced 2026-04-04 18:32:25 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Merge branch 'master' of github.com:EQEmu/Server into wp

Browse Source
This commit is contained in:
KimLS 2017-08-31 17:47:33 -07:00
commit 6a79694fa1
22 changed files with 717 additions and 552 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
common/patches/rof2_structs.h
View File

@ -617,7 +617,7 @@ struct NewZone_Struct {
/*0704*/ char zone_short_name2[32]; //zone file name? excludes instance number which can be in previous version. /*0704*/ char zone_short_name2[32]; //zone file name? excludes instance number which can be in previous version.
/*0736*/ char WeatherString[32]; /*0736*/ char WeatherString[32];
/*0768*/ char SkyString2[32]; /*0768*/ char SkyString2[32];
/*0800*/ int32 SkyRelated2; //seen -1 /*0800*/ int32 SkyRelated2; //seen -1 -- maybe some default sky time?
/*0804*/ char WeatherString2[32]; // /*0804*/ char WeatherString2[32]; //
/*0836*/ float WeatherChangeTime; // not sure :P /*0836*/ float WeatherChangeTime; // not sure :P
/*0840*/ uint32 Climate; /*0840*/ uint32 Climate;

2
common/ruletypes.h
View File

@ -563,6 +563,8 @@ RULE_INT(Range, DamageMessages, 50)
RULE_INT(Range, SpellMessages, 75) RULE_INT(Range, SpellMessages, 75)
RULE_INT(Range, SongMessages, 75) RULE_INT(Range, SongMessages, 75)
RULE_INT(Range, MobPositionUpdates, 600) RULE_INT(Range, MobPositionUpdates, 600)
RULE_INT(Range, ClientPositionUpdates, 300)
RULE_INT(Range, ClientForceSpawnUpdateRange, 1000)
RULE_INT(Range, CriticalDamage, 80) RULE_INT(Range, CriticalDamage, 80)
RULE_INT(Range, ClientNPCScan, 300) RULE_INT(Range, ClientNPCScan, 300)
RULE_CATEGORY_END() RULE_CATEGORY_END()

2
utils/sql/db_update_manifest.txt
View File

@ -357,7 +357,7 @@
9101|2016_12_01_pcnpc_only.sql|SHOW COLUMNS FROM `spells_new` LIKE 'pcnpc_only_flag'|empty| 9101|2016_12_01_pcnpc_only.sql|SHOW COLUMNS FROM `spells_new` LIKE 'pcnpc_only_flag'|empty|
9102|2017_01_10_book_languages.sql|SHOW COLUMNS FROM `books` LIKE 'language'|empty| 9102|2017_01_10_book_languages.sql|SHOW COLUMNS FROM `books` LIKE 'language'|empty|
9103|2017_01_30_book_languages_fix.sql|SELECT `language` from `books` WHERE `language` IS NULL|not_empty| 9103|2017_01_30_book_languages_fix.sql|SELECT `language` from `books` WHERE `language` IS NULL|not_empty|
9104|2017_02_09_npc_spells_entries_type_update.sql|SHOW COLUMNS IN `npc_spells_entries` LIKE `type`|contains|smallint(5) unsigned 9104|2017_02_09_npc_spells_entries_type_update.sql|SHOW COLUMNS IN `npc_spells_entries` LIKE 'type'|contains|smallint(5) unsigned
9105|2017_02_15_bot_spells_entries.sql|SELECT `id` FROM `npc_spells_entries` WHERE `npc_spells_id` >= 701 AND `npc_spells_id` <= 712|not_empty| 9105|2017_02_15_bot_spells_entries.sql|SELECT `id` FROM `npc_spells_entries` WHERE `npc_spells_id` >= 701 AND `npc_spells_id` <= 712|not_empty|
9106|2017_02_26_npc_spells_update_for_bots.sql|SELECT * FROM `npc_spells` WHERE `id` = '701' AND `name` = 'Cleric Bot'|not_empty| 9106|2017_02_26_npc_spells_update_for_bots.sql|SELECT * FROM `npc_spells` WHERE `id` = '701' AND `name` = 'Cleric Bot'|not_empty|
9107|2017_03_09_inventory_version.sql|SHOW TABLES LIKE 'inventory_version'|empty| 9107|2017_03_09_inventory_version.sql|SHOW TABLES LIKE 'inventory_version'|empty|

14
zone/bonuses.cpp
View File

@ -1003,6 +1003,15 @@ void Mob::ApplyAABonuses(const AA::Rank &rank, StatBonuses *newbon)
case SE_RiposteChance: case SE_RiposteChance:
newbon->RiposteChance += base1; newbon->RiposteChance += base1;
break; break;
case SE_DodgeChance:
newbon->DodgeChance += base1;
break;
case SE_ParryChance:
newbon->ParryChance += base1;
break;
case SE_IncreaseBlockChance:
newbon->IncreaseBlockChance += base1;
break;
case SE_Flurry: case SE_Flurry:
newbon->FlurryChance += base1; newbon->FlurryChance += base1;
break; break;
@ -2495,7 +2504,12 @@ void Mob::ApplySpellsBonuses(uint16 spell_id, uint8 casterlevel, StatBonuses *ne
break; break;
case SE_IncreaseBlockChance: case SE_IncreaseBlockChance:
if (AdditiveWornBonus)
new_bonus->IncreaseBlockChance += effect_value; new_bonus->IncreaseBlockChance += effect_value;
else if (effect_value < 0 && new_bonus->IncreaseBlockChance > effect_value)
new_bonus->IncreaseBlockChance = effect_value;
else if (new_bonus->IncreaseBlockChance < effect_value)
new_bonus->IncreaseBlockChance = effect_value;
break; break;
case SE_PersistantCasting: case SE_PersistantCasting:

2
zone/client.h
View File

@ -1489,7 +1489,9 @@ private:
Timer hp_self_update_throttle_timer; /* This is to prevent excessive packet sending under trains/fast combat */ Timer hp_self_update_throttle_timer; /* This is to prevent excessive packet sending under trains/fast combat */
Timer hp_other_update_throttle_timer; /* This is to keep clients from DOSing the server with macros that change client targets constantly */ Timer hp_other_update_throttle_timer; /* This is to keep clients from DOSing the server with macros that change client targets constantly */
Timer position_update_timer; /* Timer used when client hasn't updated within a 10 second window */ Timer position_update_timer; /* Timer used when client hasn't updated within a 10 second window */
glm::vec3 m_Proximity; glm::vec3 m_Proximity;
glm::vec4 last_major_update_position;
void BulkSendInventoryItems(); void BulkSendInventoryItems();

723
zone/client_packet.cpp
View File

@ -4635,7 +4635,19 @@ void Client::Handle_OP_ClientUpdate(const EQApplicationPacket *app)
entity_list.QueueClientsStatus(this, outapp, true, Admin(), 250); entity_list.QueueClientsStatus(this, outapp, true, Admin(), 250);
} }
else { else {
entity_list.QueueCloseClients(this, outapp, true, 300, nullptr, true); entity_list.QueueCloseClients(this, outapp, true, RuleI(Range, ClientPositionUpdates), nullptr, true);
}
/* Always send position updates to group - send when beyond normal ClientPositionUpdate range */
Group *group = this->GetGroup();
Raid *raid = this->GetRaid();
if (raid) {
raid->QueueClients(this, outapp, true, true, (RuleI(Range, ClientPositionUpdates) * -1));
}
else if (group) {
group->QueueClients(this, outapp, true, true, (RuleI(Range, ClientPositionUpdates) * -1));
} }
safe_delete(outapp); safe_delete(outapp);
@ -10932,289 +10944,307 @@ void Client::Handle_OP_RaidCommand(const EQApplicationPacket *app)
return; return;
} }
RaidGeneral_Struct *ri = (RaidGeneral_Struct*)app->pBuffer; RaidGeneral_Struct *raid_command_packet = (RaidGeneral_Struct*)app->pBuffer;
switch (ri->action) switch (raid_command_packet->action)
{ {
case RaidCommandInviteIntoExisting: case RaidCommandInviteIntoExisting:
case RaidCommandInvite: { case RaidCommandInvite: {
Client *i = entity_list.GetClientByName(ri->player_name);
if (!i) Client *player_to_invite = entity_list.GetClientByName(raid_command_packet->player_name);
if (!player_to_invite)
break; break;
Group *g = i->GetGroup();
// These two messages should be generated by the client I think, just do this for now Group *player_to_invite_group = player_to_invite->GetGroup();
if (i->HasRaid()) {
Message(13, "%s is already in a raid.", i->GetName()); if (player_to_invite->HasRaid()) {
Message(13, "%s is already in a raid.", player_to_invite->GetName());
break; break;
} }
if (g && !g->IsLeader(i)) {
if (player_to_invite_group && !player_to_invite_group->IsLeader(player_to_invite)) {
Message(13, "You can only invite an ungrouped player or group leader to join your raid."); Message(13, "You can only invite an ungrouped player or group leader to join your raid.");
break; break;
} }
//This sends an "invite" to the client in question.
auto outapp = new EQApplicationPacket(OP_RaidUpdate, sizeof(RaidGeneral_Struct));
RaidGeneral_Struct *rg = (RaidGeneral_Struct*)outapp->pBuffer;
strn0cpy(rg->leader_name, ri->leader_name, 64);
strn0cpy(rg->player_name, ri->player_name, 64);
rg->parameter = 0; /* Send out invite to the client */
rg->action = 20; auto outapp = new EQApplicationPacket(OP_RaidUpdate, sizeof(RaidGeneral_Struct));
i->QueuePacket(outapp); RaidGeneral_Struct *raid_command = (RaidGeneral_Struct*)outapp->pBuffer;
strn0cpy(raid_command->leader_name, raid_command_packet->leader_name, 64);
strn0cpy(raid_command->player_name, raid_command_packet->player_name, 64);
raid_command->parameter = 0;
raid_command->action = 20;
player_to_invite->QueuePacket(outapp);
safe_delete(outapp); safe_delete(outapp);
break; break;
} }
case RaidCommandAcceptInvite: { case RaidCommandAcceptInvite: {
Client *i = entity_list.GetClientByName(ri->player_name); Client *player_accepting_invite = entity_list.GetClientByName(raid_command_packet->player_name);
if (i) { if (player_accepting_invite) {
if (IsRaidGrouped()) { if (IsRaidGrouped()) {
i->Message_StringID(0, ALREADY_IN_RAID, GetName()); //group failed, must invite members not in raid... player_accepting_invite->Message_StringID(0, ALREADY_IN_RAID, GetName()); //group failed, must invite members not in raid...
return; return;
} }
Raid *r = entity_list.GetRaidByClient(i); Raid *raid = entity_list.GetRaidByClient(player_accepting_invite);
if (r) { if (raid) {
r->VerifyRaid(); raid->VerifyRaid();
Group *g = GetGroup(); Group *group = GetGroup();
if (g) { if (group) {
if (g->GroupCount() + r->RaidCount() > MAX_RAID_MEMBERS) if (group->GroupCount() + raid->RaidCount() > MAX_RAID_MEMBERS) {
{ player_accepting_invite->Message(13, "Invite failed, group invite would create a raid larger than the maximum number of members allowed.");
i->Message(13, "Invite failed, group invite would create a raid larger than the maximum number of members allowed.");
return; return;
} }
} }
else { else {
if (1 + r->RaidCount() > MAX_RAID_MEMBERS) if (1 + raid->RaidCount() > MAX_RAID_MEMBERS) {
{ player_accepting_invite->Message(13, "Invite failed, member invite would create a raid larger than the maximum number of members allowed.");
i->Message(13, "Invite failed, member invite would create a raid larger than the maximum number of members allowed.");
return; return;
} }
} }
if (g) {//add us all if (group) {//add us all
uint32 freeGroup = r->GetFreeGroup(); uint32 free_group_id = raid->GetFreeGroup();
Client *addClient = nullptr; Client *addClient = nullptr;
for (int x = 0; x < 6; x++) for (int x = 0; x < 6; x++) {
{ if (group->members[x]) {
if (g->members[x]) {
Client *c = nullptr; Client *c = nullptr;
if (g->members[x]->IsClient()) if (group->members[x]->IsClient())
c = g->members[x]->CastToClient(); c = group->members[x]->CastToClient();
else else
continue; continue;
if (!addClient) if (!addClient)
{ {
addClient = c; addClient = c;
r->SetGroupLeader(addClient->GetName()); raid->SetGroupLeader(addClient->GetName());
} }
r->SendRaidCreate(c); raid->SendRaidCreate(c);
r->SendMakeLeaderPacketTo(r->leadername, c); raid->SendMakeLeaderPacketTo(raid->leadername, c);
if (g->IsLeader(g->members[x])) if (group->IsLeader(group->members[x]))
r->AddMember(c, freeGroup, false, true); raid->AddMember(c, free_group_id, false, true);
else else
r->AddMember(c, freeGroup); raid->AddMember(c, free_group_id);
r->SendBulkRaid(c); raid->SendBulkRaid(c);
if (r->IsLocked()) { if (raid->IsLocked()) {
r->SendRaidLockTo(c); raid->SendRaidLockTo(c);
} }
} }
} }
g->JoinRaidXTarget(r); group->JoinRaidXTarget(raid);
g->DisbandGroup(true); group->DisbandGroup(true);
r->GroupUpdate(freeGroup); raid->GroupUpdate(free_group_id);
} }
else { else {
r->SendRaidCreate(this); raid->SendRaidCreate(this);
r->SendMakeLeaderPacketTo(r->leadername, this); raid->SendMakeLeaderPacketTo(raid->leadername, this);
r->AddMember(this); raid->AddMember(this);
r->SendBulkRaid(this); raid->SendBulkRaid(this);
if (r->IsLocked()) { if (raid->IsLocked()) {
r->SendRaidLockTo(this); raid->SendRaidLockTo(this);
} }
} }
} }
else else
{ {
Group *ig = i->GetGroup(); Group *player_invited_group = player_accepting_invite->GetGroup();
Group *g = GetGroup(); Group *group = GetGroup();
if (g) //if our target has a group if (group) //if our target has a group
{ {
r = new Raid(i); raid = new Raid(player_accepting_invite);
entity_list.AddRaid(r); entity_list.AddRaid(raid);
r->SetRaidDetails(); raid->SetRaidDetails();
uint32 groupFree = r->GetFreeGroup(); //get a free group uint32 raid_free_group_id = raid->GetFreeGroup();
if (ig) { //if we already have a group then cycle through adding us...
Client *addClientig = nullptr; /* If we already have a group then cycle through adding us... */
for (int x = 0; x < 6; x++) if (player_invited_group) {
{ Client *client_to_be_leader = nullptr;
if (ig->members[x]) { for (int x = 0; x < 6; x++) {
if (!addClientig) { if (player_invited_group->members[x]) {
if (ig->members[x]->IsClient()) { if (!client_to_be_leader) {
addClientig = ig->members[x]->CastToClient(); if (player_invited_group->members[x]->IsClient()) {
r->SetGroupLeader(addClientig->GetName()); client_to_be_leader = player_invited_group->members[x]->CastToClient();
raid->SetGroupLeader(client_to_be_leader->GetName());
} }
} }
if (ig->IsLeader(ig->members[x])) { if (player_invited_group->IsLeader(player_invited_group->members[x])) {
Client *c = nullptr; Client *c = nullptr;
if (ig->members[x]->IsClient())
c = ig->members[x]->CastToClient(); if (player_invited_group->members[x]->IsClient())
c = player_invited_group->members[x]->CastToClient();
else else
continue; continue;
r->SendRaidCreate(c);
r->SendMakeLeaderPacketTo(r->leadername, c); raid->SendRaidCreate(c);
r->AddMember(c, groupFree, true, true, true); raid->SendMakeLeaderPacketTo(raid->leadername, c);
r->SendBulkRaid(c); raid->AddMember(c, raid_free_group_id, true, true, true);
if (r->IsLocked()) { raid->SendBulkRaid(c);
r->SendRaidLockTo(c);
if (raid->IsLocked()) {
raid->SendRaidLockTo(c);
} }
} }
else { else {
Client *c = nullptr; Client *c = nullptr;
if (ig->members[x]->IsClient())
c = ig->members[x]->CastToClient(); if (player_invited_group->members[x]->IsClient())
c = player_invited_group->members[x]->CastToClient();
else else
continue; continue;
r->SendRaidCreate(c);
r->SendMakeLeaderPacketTo(r->leadername, c); raid->SendRaidCreate(c);
r->AddMember(c, groupFree); raid->SendMakeLeaderPacketTo(raid->leadername, c);
r->SendBulkRaid(c); raid->AddMember(c, raid_free_group_id);
if (r->IsLocked()) { raid->SendBulkRaid(c);
r->SendRaidLockTo(c);
if (raid->IsLocked()) {
raid->SendRaidLockTo(c);
} }
} }
} }
} }
ig->JoinRaidXTarget(r, true); player_invited_group->JoinRaidXTarget(raid, true);
ig->DisbandGroup(true); player_invited_group->DisbandGroup(true);
r->GroupUpdate(groupFree); raid->GroupUpdate(raid_free_group_id);
groupFree = r->GetFreeGroup(); raid_free_group_id = raid->GetFreeGroup();
} }
else { //else just add the inviter else {
r->SendRaidCreate(i); raid->SendRaidCreate(player_accepting_invite);
r->AddMember(i, 0xFFFFFFFF, true, false, true); raid->AddMember(player_accepting_invite, 0xFFFFFFFF, true, false, true);
} }
Client *addClient = nullptr; Client *client_to_add = nullptr;
//now add the existing group /* Add client to an existing group */
for (int x = 0; x < 6; x++) for (int x = 0; x < 6; x++) {
{ if (group->members[x]) {
if (g->members[x]) { if (!client_to_add) {
if (!addClient) if (group->members[x]->IsClient()) {
{ client_to_add = group->members[x]->CastToClient();
if (g->members[x]->IsClient()) { raid->SetGroupLeader(client_to_add->GetName());
addClient = g->members[x]->CastToClient();
r->SetGroupLeader(addClient->GetName());
} }
} }
if (g->IsLeader(g->members[x])) if (group->IsLeader(group->members[x])) {
{
Client *c = nullptr; Client *c = nullptr;
if (g->members[x]->IsClient())
c = g->members[x]->CastToClient(); if (group->members[x]->IsClient())
c = group->members[x]->CastToClient();
else else
continue; continue;
r->SendRaidCreate(c);
r->SendMakeLeaderPacketTo(r->leadername, c); raid->SendRaidCreate(c);
r->AddMember(c, groupFree, false, true); raid->SendMakeLeaderPacketTo(raid->leadername, c);
r->SendBulkRaid(c); raid->AddMember(c, raid_free_group_id, false, true);
if (r->IsLocked()) { raid->SendBulkRaid(c);
r->SendRaidLockTo(c);
if (raid->IsLocked()) {
raid->SendRaidLockTo(c);
} }
} }
else else
{ {
Client *c = nullptr; Client *c = nullptr;
if (g->members[x]->IsClient())
c = g->members[x]->CastToClient(); if (group->members[x]->IsClient())
c = group->members[x]->CastToClient();
else else
continue; continue;
r->SendRaidCreate(c);
r->SendMakeLeaderPacketTo(r->leadername, c); raid->SendRaidCreate(c);
r->AddMember(c, groupFree); raid->SendMakeLeaderPacketTo(raid->leadername, c);
r->SendBulkRaid(c); raid->AddMember(c, raid_free_group_id);
if (r->IsLocked()) { raid->SendBulkRaid(c);
r->SendRaidLockTo(c);
if (raid->IsLocked()) {
raid->SendRaidLockTo(c);
} }
} }
} }
} }
g->JoinRaidXTarget(r); group->JoinRaidXTarget(raid);
g->DisbandGroup(true); group->DisbandGroup(true);
r->GroupUpdate(groupFree);
raid->GroupUpdate(raid_free_group_id);
} }
else // target does not have a group /* Target does not have a group */
{ else {
if (ig) { if (player_invited_group) {
r = new Raid(i);
entity_list.AddRaid(r); raid = new Raid(player_accepting_invite);
r->SetRaidDetails();
entity_list.AddRaid(raid);
raid->SetRaidDetails();
Client *addClientig = nullptr; Client *addClientig = nullptr;
for (int x = 0; x < 6; x++) for (int x = 0; x < 6; x++) {
{ if (player_invited_group->members[x]) {
if (ig->members[x])
{
if (!addClientig) { if (!addClientig) {
if (ig->members[x]->IsClient()) { if (player_invited_group->members[x]->IsClient()) {
addClientig = ig->members[x]->CastToClient(); addClientig = player_invited_group->members[x]->CastToClient();
r->SetGroupLeader(addClientig->GetName()); raid->SetGroupLeader(addClientig->GetName());
} }
} }
if (ig->IsLeader(ig->members[x])) if (player_invited_group->IsLeader(player_invited_group->members[x])) {
{
Client *c = nullptr; Client *c = nullptr;
if (ig->members[x]->IsClient())
c = ig->members[x]->CastToClient(); if (player_invited_group->members[x]->IsClient())
c = player_invited_group->members[x]->CastToClient();
else else
continue; continue;
r->SendRaidCreate(c); raid->SendRaidCreate(c);
r->SendMakeLeaderPacketTo(r->leadername, c); raid->SendMakeLeaderPacketTo(raid->leadername, c);
r->AddMember(c, 0, true, true, true); raid->AddMember(c, 0, true, true, true);
r->SendBulkRaid(c); raid->SendBulkRaid(c);
if (r->IsLocked()) {
r->SendRaidLockTo(c); if (raid->IsLocked()) {
raid->SendRaidLockTo(c);
} }
} }
else else
{ {
Client *c = nullptr; Client *c = nullptr;
if (ig->members[x]->IsClient()) if (player_invited_group->members[x]->IsClient())
c = ig->members[x]->CastToClient(); c = player_invited_group->members[x]->CastToClient();
else else
continue; continue;
r->SendRaidCreate(c); raid->SendRaidCreate(c);
r->SendMakeLeaderPacketTo(r->leadername, c); raid->SendMakeLeaderPacketTo(raid->leadername, c);
r->AddMember(c, 0); raid->AddMember(c, 0);
r->SendBulkRaid(c); raid->SendBulkRaid(c);
if (r->IsLocked()) { if (raid->IsLocked()) {
r->SendRaidLockTo(c); raid->SendRaidLockTo(c);
} }
} }
} }
} }
r->SendRaidCreate(this); raid->SendRaidCreate(this);
r->SendMakeLeaderPacketTo(r->leadername, this); raid->SendMakeLeaderPacketTo(raid->leadername, this);
r->SendBulkRaid(this); raid->SendBulkRaid(this);
ig->JoinRaidXTarget(r, true); player_invited_group->JoinRaidXTarget(raid, true);
r->AddMember(this); raid->AddMember(this);
ig->DisbandGroup(true); player_invited_group->DisbandGroup(true);
r->GroupUpdate(0); raid->GroupUpdate(0);
if (r->IsLocked()) { if (raid->IsLocked()) {
r->SendRaidLockTo(this); raid->SendRaidLockTo(this);
} }
} }
else { // neither has a group else { // neither has a group
r = new Raid(i); raid = new Raid(player_accepting_invite);
entity_list.AddRaid(r); entity_list.AddRaid(raid);
r->SetRaidDetails(); raid->SetRaidDetails();
r->SendRaidCreate(i); raid->SendRaidCreate(player_accepting_invite);
r->SendRaidCreate(this); raid->SendRaidCreate(this);
r->SendMakeLeaderPacketTo(r->leadername, this); raid->SendMakeLeaderPacketTo(raid->leadername, this);
r->AddMember(i, 0xFFFFFFFF, true, false, true); raid->AddMember(player_accepting_invite, 0xFFFFFFFF, true, false, true);
r->SendBulkRaid(this); raid->SendBulkRaid(this);
r->AddMember(this); raid->AddMember(this);
if (r->IsLocked()) { if (raid->IsLocked()) {
r->SendRaidLockTo(this); raid->SendRaidLockTo(this);
} }
} }
} }
@ -11223,43 +11253,42 @@ void Client::Handle_OP_RaidCommand(const EQApplicationPacket *app)
break; break;
} }
case RaidCommandDisband: { case RaidCommandDisband: {
Raid *r = entity_list.GetRaidByClient(this); Raid *raid = entity_list.GetRaidByClient(this);
if (r) { if (raid) {
//if(this == r->GetLeader()){ uint32 group = raid->GetGroup(raid_command_packet->leader_name);
uint32 grp = r->GetGroup(ri->leader_name);
if (grp < 12) { if (group < 12) {
uint32 i = r->GetPlayerIndex(ri->leader_name); uint32 i = raid->GetPlayerIndex(raid_command_packet->leader_name);
if (r->members[i].IsGroupLeader) { //assign group leader to someone else if (raid->members[i].IsGroupLeader) { //assign group leader to someone else
for (int x = 0; x < MAX_RAID_MEMBERS; x++) { for (int x = 0; x < MAX_RAID_MEMBERS; x++) {
if (strlen(r->members[x].membername) > 0 && i != x) { if (strlen(raid->members[x].membername) > 0 && i != x) {
if (r->members[x].GroupNumber == grp) { if (raid->members[x].GroupNumber == group) {
r->SetGroupLeader(ri->leader_name, false); raid->SetGroupLeader(raid_command_packet->leader_name, false);
r->SetGroupLeader(r->members[x].membername); raid->SetGroupLeader(raid->members[x].membername);
r->UpdateGroupAAs(grp); raid->UpdateGroupAAs(group);
break; break;
} }
} }
} }
} }
if (r->members[i].IsRaidLeader) { if (raid->members[i].IsRaidLeader) {
for (int x = 0; x < MAX_RAID_MEMBERS; x++) { for (int x = 0; x < MAX_RAID_MEMBERS; x++) {
if (strlen(r->members[x].membername) > 0 && strcmp(r->members[x].membername, r->members[i].membername) != 0) if (strlen(raid->members[x].membername) > 0 && strcmp(raid->members[x].membername, raid->members[i].membername) != 0)
{ {
r->SetRaidLeader(r->members[i].membername, r->members[x].membername); raid->SetRaidLeader(raid->members[i].membername, raid->members[x].membername);
r->UpdateRaidAAs(); raid->UpdateRaidAAs();
r->SendAllRaidLeadershipAA(); raid->SendAllRaidLeadershipAA();
break; break;
} }
} }
} }
} }
r->RemoveMember(ri->leader_name); raid->RemoveMember(raid_command_packet->leader_name);
Client *c = entity_list.GetClientByName(ri->leader_name); Client *c = entity_list.GetClientByName(raid_command_packet->leader_name);
if (c) if (c)
r->SendGroupDisband(c); raid->SendGroupDisband(c);
else { else {
auto pack = auto pack =
new ServerPacket(ServerOP_RaidGroupDisband, sizeof(ServerRaidGeneralAction_Struct)); new ServerPacket(ServerOP_RaidGroupDisband, sizeof(ServerRaidGeneralAction_Struct));
@ -11267,66 +11296,64 @@ void Client::Handle_OP_RaidCommand(const EQApplicationPacket *app)
rga->rid = GetID(); rga->rid = GetID();
rga->zoneid = zone->GetZoneID(); rga->zoneid = zone->GetZoneID();
rga->instance_id = zone->GetInstanceID(); rga->instance_id = zone->GetInstanceID();
strn0cpy(rga->playername, ri->leader_name, 64); strn0cpy(rga->playername, raid_command_packet->leader_name, 64);
worldserver.SendPacket(pack); worldserver.SendPacket(pack);
safe_delete(pack); safe_delete(pack);
} }
//r->SendRaidGroupRemove(ri->leader_name, grp); //r->SendRaidGroupRemove(ri->leader_name, grp);
r->GroupUpdate(grp);// break raid->GroupUpdate(group);// break
//} //}
} }
break; break;
} }
case RaidCommandMoveGroup: case RaidCommandMoveGroup:
{ {
Raid *r = entity_list.GetRaidByClient(this); Raid *raid = entity_list.GetRaidByClient(this);
if (r) if (raid) {
{ /* Moving to group */
if (ri->parameter < 12) //moving to a group if (raid_command_packet->parameter < 12) {
{ uint8 group_count = raid->GroupCount(raid_command_packet->parameter);
uint8 grpcount = r->GroupCount(ri->parameter);
if (grpcount < 6) if (group_count < 6) {
{ Client *c = entity_list.GetClientByName(raid_command_packet->leader_name);
Client *c = entity_list.GetClientByName(ri->leader_name); uint32 old_group = raid->GetGroup(raid_command_packet->leader_name);
uint32 oldgrp = r->GetGroup(ri->leader_name); if (raid_command_packet->parameter == old_group) //don't rejoin grp if we order to join same group.
if (ri->parameter == oldgrp) //don't rejoin grp if we order to join same group.
break; break;
if (r->members[r->GetPlayerIndex(ri->leader_name)].IsGroupLeader) if (raid->members[raid->GetPlayerIndex(raid_command_packet->leader_name)].IsGroupLeader) {
{ raid->SetGroupLeader(raid_command_packet->leader_name, false);
r->SetGroupLeader(ri->leader_name, false);
if (oldgrp < 12) { //we were the leader of our old grp /* We were the leader of our old group */
for (int x = 0; x < MAX_RAID_MEMBERS; x++) //assign a new grp leader if we can if (old_group < 12) {
{ /* Assign new group leader if we can */
if (r->members[x].GroupNumber == oldgrp) for (int x = 0; x < MAX_RAID_MEMBERS; x++) {
{ if (raid->members[x].GroupNumber == old_group) {
if (strcmp(ri->leader_name, r->members[x].membername) != 0 && strlen(ri->leader_name) > 0) if (strcmp(raid_command_packet->leader_name, raid->members[x].membername) != 0 && strlen(raid_command_packet->leader_name) > 0) {
{ raid->SetGroupLeader(raid->members[x].membername);
r->SetGroupLeader(r->members[x].membername); raid->UpdateGroupAAs(old_group);
r->UpdateGroupAAs(oldgrp);
Client *cgl = entity_list.GetClientByName(r->members[x].membername); Client *client_to_update = entity_list.GetClientByName(raid->members[x].membername);
if (cgl) { if (client_to_update) {
r->SendRaidRemove(r->members[x].membername, cgl); raid->SendRaidRemove(raid->members[x].membername, client_to_update);
r->SendRaidCreate(cgl); raid->SendRaidCreate(client_to_update);
r->SendMakeLeaderPacketTo(r->leadername, cgl); raid->SendMakeLeaderPacketTo(raid->leadername, client_to_update);
r->SendRaidAdd(r->members[x].membername, cgl); raid->SendRaidAdd(raid->members[x].membername, client_to_update);
r->SendBulkRaid(cgl); raid->SendBulkRaid(client_to_update);
if (r->IsLocked()) { if (raid->IsLocked()) {
r->SendRaidLockTo(cgl); raid->SendRaidLockTo(client_to_update);
} }
} }
else { else {
auto pack = new ServerPacket( auto pack = new ServerPacket(ServerOP_RaidChangeGroup, sizeof(ServerRaidGeneralAction_Struct));
ServerOP_RaidChangeGroup, ServerRaidGeneralAction_Struct *raid_command_packet = (ServerRaidGeneralAction_Struct*)pack->pBuffer;
sizeof(
ServerRaidGeneralAction_Struct)); raid_command_packet->rid = raid->GetID();
ServerRaidGeneralAction_Struct *rga = (ServerRaidGeneralAction_Struct*)pack->pBuffer; raid_command_packet->zoneid = zone->GetZoneID();
rga->rid = r->GetID(); raid_command_packet->instance_id = zone->GetInstanceID();
strn0cpy(rga->playername, r->members[x].membername, 64); strn0cpy(raid_command_packet->playername, raid->members[x].membername, 64);
rga->zoneid = zone->GetZoneID();
rga->instance_id = zone->GetInstanceID();
worldserver.SendPacket(pack); worldserver.SendPacket(pack);
safe_delete(pack); safe_delete(pack);
} }
break; break;
@ -11335,69 +11362,67 @@ void Client::Handle_OP_RaidCommand(const EQApplicationPacket *app)
} }
} }
} }
if (grpcount == 0) { if (group_count == 0) {
r->SetGroupLeader(ri->leader_name); raid->SetGroupLeader(raid_command_packet->leader_name);
r->UpdateGroupAAs(ri->parameter); raid->UpdateGroupAAs(raid_command_packet->parameter);
} }
r->MoveMember(ri->leader_name, ri->parameter); raid->MoveMember(raid_command_packet->leader_name, raid_command_packet->parameter);
if (c) { if (c) {
r->SendGroupDisband(c); raid->SendGroupDisband(c);
} }
else { else {
auto pack = new ServerPacket(ServerOP_RaidGroupDisband, auto pack = new ServerPacket(ServerOP_RaidGroupDisband, sizeof(ServerRaidGeneralAction_Struct));
sizeof(ServerRaidGeneralAction_Struct)); ServerRaidGeneralAction_Struct* raid_command = (ServerRaidGeneralAction_Struct*)pack->pBuffer;
ServerRaidGeneralAction_Struct* rga = (ServerRaidGeneralAction_Struct*)pack->pBuffer; raid_command->rid = raid->GetID();
rga->rid = r->GetID(); raid_command->zoneid = zone->GetZoneID();
rga->zoneid = zone->GetZoneID(); raid_command->instance_id = zone->GetInstanceID();
rga->instance_id = zone->GetInstanceID(); strn0cpy(raid_command->playername, raid_command_packet->leader_name, 64);
strn0cpy(rga->playername, ri->leader_name, 64);
worldserver.SendPacket(pack); worldserver.SendPacket(pack);
safe_delete(pack); safe_delete(pack);
} }
//r->SendRaidGroupAdd(ri->leader_name, ri->parameter);
//r->SendRaidGroupRemove(ri->leader_name, oldgrp);
//r->SendGroupUpdate(c);
//break
r->GroupUpdate(ri->parameter); //send group update to our new group
if (oldgrp < 12) //if our old was a group send update there too
r->GroupUpdate(oldgrp);
//r->SendMakeGroupLeaderPacketAll(); /* Send group update to our new group */
raid->GroupUpdate(raid_command_packet->parameter);
/* If our old was a group send update there too */
if (old_group < 12)
raid->GroupUpdate(old_group);
} }
} }
else //moving to ungrouped /* Move player to ungrouped bank */
{ else {
Client *c = entity_list.GetClientByName(ri->leader_name); Client *c = entity_list.GetClientByName(raid_command_packet->leader_name);
uint32 oldgrp = r->GetGroup(ri->leader_name); uint32 oldgrp = raid->GetGroup(raid_command_packet->leader_name);
if (r->members[r->GetPlayerIndex(ri->leader_name)].IsGroupLeader) { if (raid->members[raid->GetPlayerIndex(raid_command_packet->leader_name)].IsGroupLeader) {
r->SetGroupLeader(ri->leader_name, false); raid->SetGroupLeader(raid_command_packet->leader_name, false);
for (int x = 0; x < MAX_RAID_MEMBERS; x++) for (int x = 0; x < MAX_RAID_MEMBERS; x++) {
{ if (raid->members[x].GroupNumber == oldgrp && strlen(raid->members[x].membername) > 0 && strcmp(raid->members[x].membername, raid_command_packet->leader_name) != 0){
if (r->members[x].GroupNumber == oldgrp && strlen(r->members[x].membername) > 0 && strcmp(r->members[x].membername, ri->leader_name) != 0)
{ raid->SetGroupLeader(raid->members[x].membername);
r->SetGroupLeader(r->members[x].membername); raid->UpdateGroupAAs(oldgrp);
r->UpdateGroupAAs(oldgrp);
Client *cgl = entity_list.GetClientByName(r->members[x].membername); Client *client_leaving_group = entity_list.GetClientByName(raid->members[x].membername);
if (cgl) { if (client_leaving_group) {
r->SendRaidRemove(r->members[x].membername, cgl); raid->SendRaidRemove(raid->members[x].membername, client_leaving_group);
r->SendRaidCreate(cgl); raid->SendRaidCreate(client_leaving_group);
r->SendMakeLeaderPacketTo(r->leadername, cgl); raid->SendMakeLeaderPacketTo(raid->leadername, client_leaving_group);
r->SendRaidAdd(r->members[x].membername, cgl); raid->SendRaidAdd(raid->members[x].membername, client_leaving_group);
r->SendBulkRaid(cgl); raid->SendBulkRaid(client_leaving_group);
if (r->IsLocked()) { if (raid->IsLocked()) {
r->SendRaidLockTo(cgl); raid->SendRaidLockTo(client_leaving_group);
} }
} }
else { else {
auto pack = new ServerPacket( auto pack = new ServerPacket( ServerOP_RaidChangeGroup, sizeof(ServerRaidGeneralAction_Struct));
ServerOP_RaidChangeGroup, ServerRaidGeneralAction_Struct *raid_command = (ServerRaidGeneralAction_Struct*)pack->pBuffer;
sizeof(ServerRaidGeneralAction_Struct));
ServerRaidGeneralAction_Struct *rga = (ServerRaidGeneralAction_Struct*)pack->pBuffer; raid_command->rid = raid->GetID();
rga->rid = r->GetID(); strn0cpy(raid_command->playername, raid->members[x].membername, 64);
strn0cpy(rga->playername, r->members[x].membername, 64); raid_command->zoneid = zone->GetZoneID();
rga->zoneid = zone->GetZoneID(); raid_command->instance_id = zone->GetInstanceID();
rga->instance_id = zone->GetInstanceID();
worldserver.SendPacket(pack); worldserver.SendPacket(pack);
safe_delete(pack); safe_delete(pack);
} }
@ -11405,60 +11430,72 @@ void Client::Handle_OP_RaidCommand(const EQApplicationPacket *app)
} }
} }
} }
r->MoveMember(ri->leader_name, 0xFFFFFFFF); raid->MoveMember(raid_command_packet->leader_name, 0xFFFFFFFF);
if (c) { if (c) {
r->SendGroupDisband(c); raid->SendGroupDisband(c);
} }
else { else {
auto pack = new ServerPacket(ServerOP_RaidGroupDisband, auto pack = new ServerPacket(ServerOP_RaidGroupDisband, sizeof(ServerRaidGeneralAction_Struct));
sizeof(ServerRaidGeneralAction_Struct)); ServerRaidGeneralAction_Struct* raid_command = (ServerRaidGeneralAction_Struct*)pack->pBuffer;
ServerRaidGeneralAction_Struct* rga = (ServerRaidGeneralAction_Struct*)pack->pBuffer;
rga->rid = r->GetID(); raid_command->rid = raid->GetID();
rga->zoneid = zone->GetZoneID(); raid_command->zoneid = zone->GetZoneID();
rga->instance_id = zone->GetInstanceID(); raid_command->instance_id = zone->GetInstanceID();
strn0cpy(rga->playername, ri->leader_name, 64); strn0cpy(raid_command->playername, raid_command_packet->leader_name, 64);
worldserver.SendPacket(pack); worldserver.SendPacket(pack);
safe_delete(pack); safe_delete(pack);
} }
//r->SendRaidGroupRemove(ri->leader_name, oldgrp);
r->GroupUpdate(oldgrp); raid->GroupUpdate(oldgrp);
//r->SendMakeGroupLeaderPacketAll();
} }
} }
Client *client_moved = entity_list.GetClientByName(raid_command_packet->leader_name);
if (client_moved) {
client_moved->GetRaid()->SendHPManaEndPacketsTo(client_moved);
client_moved->GetRaid()->SendHPManaEndPacketsFrom(client_moved);
Log(Logs::General, Logs::HP_Update,
"Client::Handle_OP_RaidCommand :: %s sending and recieving HP/Mana/End updates",
client_moved->GetCleanName()
);
}
break; break;
} }
case RaidCommandRaidLock: case RaidCommandRaidLock:
{ {
Raid *r = entity_list.GetRaidByClient(this); Raid *raid = entity_list.GetRaidByClient(this);
if (r) if (raid) {
{ if (!raid->IsLocked())
if (!r->IsLocked()) raid->LockRaid(true);
r->LockRaid(true);
else else
r->SendRaidLockTo(this); raid->SendRaidLockTo(this);
} }
break; break;
} }
case RaidCommandRaidUnlock: case RaidCommandRaidUnlock:
{ {
Raid *r = entity_list.GetRaidByClient(this); Raid *raid = entity_list.GetRaidByClient(this);
if (r) if (raid)
{ {
if (r->IsLocked()) if (raid->IsLocked())
r->LockRaid(false); raid->LockRaid(false);
else else
r->SendRaidUnlockTo(this); raid->SendRaidUnlockTo(this);
} }
break; break;
} }
case RaidCommandLootType2: case RaidCommandLootType2:
case RaidCommandLootType: case RaidCommandLootType:
{ {
Raid *r = entity_list.GetRaidByClient(this); Raid *raid = entity_list.GetRaidByClient(this);
if (r) if (raid) {
{ Message(15, "Loot type changed to: %d.", raid_command_packet->parameter);
Message(15, "Loot type changed to: %d.", ri->parameter); raid->ChangeLootType(raid_command_packet->parameter);
r->ChangeLootType(ri->parameter);
} }
break; break;
} }
@ -11466,11 +11503,10 @@ void Client::Handle_OP_RaidCommand(const EQApplicationPacket *app)
case RaidCommandAddLooter2: case RaidCommandAddLooter2:
case RaidCommandAddLooter: case RaidCommandAddLooter:
{ {
Raid *r = entity_list.GetRaidByClient(this); Raid *raid = entity_list.GetRaidByClient(this);
if (r) if (raid) {
{ Message(15, "Adding %s as a raid looter.", raid_command_packet->leader_name);
Message(15, "Adding %s as a raid looter.", ri->leader_name); raid->AddRaidLooter(raid_command_packet->leader_name);
r->AddRaidLooter(ri->leader_name);
} }
break; break;
} }
@ -11478,24 +11514,22 @@ void Client::Handle_OP_RaidCommand(const EQApplicationPacket *app)
case RaidCommandRemoveLooter2: case RaidCommandRemoveLooter2:
case RaidCommandRemoveLooter: case RaidCommandRemoveLooter:
{ {
Raid *r = entity_list.GetRaidByClient(this); Raid *raid = entity_list.GetRaidByClient(this);
if (r) if (raid) {
{ Message(15, "Removing %s as a raid looter.", raid_command_packet->leader_name);
Message(15, "Removing %s as a raid looter.", ri->leader_name); raid->RemoveRaidLooter(raid_command_packet->leader_name);
r->RemoveRaidLooter(ri->leader_name);
} }
break; break;
} }
case RaidCommandMakeLeader: case RaidCommandMakeLeader:
{ {
Raid *r = entity_list.GetRaidByClient(this); Raid *raid = entity_list.GetRaidByClient(this);
if (r) if (raid) {
{ if (strcmp(raid->leadername, GetName()) == 0) {
if (strcmp(r->leadername, GetName()) == 0) { raid->SetRaidLeader(GetName(), raid_command_packet->leader_name);
r->SetRaidLeader(GetName(), ri->leader_name); raid->UpdateRaidAAs();
r->UpdateRaidAAs(); raid->SendAllRaidLeadershipAA();
r->SendAllRaidLeadershipAA();
} }
} }
break; break;
@ -11503,19 +11537,19 @@ void Client::Handle_OP_RaidCommand(const EQApplicationPacket *app)
case RaidCommandSetMotd: case RaidCommandSetMotd:
{ {
Raid *r = entity_list.GetRaidByClient(this); Raid *raid = entity_list.GetRaidByClient(this);
if (!r) if (!raid)
break; break;
// we don't use the RaidGeneral here! // we don't use the RaidGeneral here!
RaidMOTD_Struct *motd = (RaidMOTD_Struct *)app->pBuffer; RaidMOTD_Struct *motd = (RaidMOTD_Struct *)app->pBuffer;
r->SetRaidMOTD(std::string(motd->motd)); raid->SetRaidMOTD(std::string(motd->motd));
r->SaveRaidMOTD(); raid->SaveRaidMOTD();
r->SendRaidMOTDToWorld(); raid->SendRaidMOTDToWorld();
break; break;
} }
default: { default: {
Message(13, "Raid command (%d) NYI", ri->action); Message(13, "Raid command (%d) NYI", raid_command_packet->action);
break; break;
} }
} }
@ -13352,10 +13386,9 @@ void Client::Handle_OP_TargetCommand(const EQApplicationPacket *app)
} }
QueuePacket(app); QueuePacket(app);
EQApplicationPacket hp_app;
GetTarget()->IsTargeted(1); GetTarget()->IsTargeted(1);
GetTarget()->CreateHPPacket(&hp_app); SendHPUpdate();
QueuePacket(&hp_app, false);
} }
else else
{ {

18
zone/client_process.cpp
View File

@ -243,15 +243,21 @@ bool Client::Process() {
/* Build a close range list of NPC's */ /* Build a close range list of NPC's */
if (npc_close_scan_timer.Check()) { if (npc_close_scan_timer.Check()) {
close_mobs.clear(); close_mobs.clear();
auto &mob_list = entity_list.GetMobList(); /* Force spawn updates when traveled far */
float scan_range = (RuleI(Range, ClientNPCScan) * RuleI(Range, ClientNPCScan)); bool force_spawn_updates = false;
float client_update_range = (RuleI(Range, MobPositionUpdates) * RuleI(Range, MobPositionUpdates)); float client_update_range = (RuleI(Range, ClientForceSpawnUpdateRange) * RuleI(Range, ClientForceSpawnUpdateRange));
if (DistanceSquared(last_major_update_position, m_Position) >= client_update_range) {
last_major_update_position = m_Position;
force_spawn_updates = true;
}
float scan_range = (RuleI(Range, ClientNPCScan) * RuleI(Range, ClientNPCScan));
auto &mob_list = entity_list.GetMobList();
for (auto itr = mob_list.begin(); itr != mob_list.end(); ++itr) { for (auto itr = mob_list.begin(); itr != mob_list.end(); ++itr) {
Mob* mob = itr->second; Mob* mob = itr->second;
float distance = DistanceSquared(m_Position, mob->GetPosition()); float distance = DistanceSquared(m_Position, mob->GetPosition());
if (mob->IsNPC()) { if (mob->IsNPC()) {
if (distance <= scan_range) { if (distance <= scan_range) {
@ -261,6 +267,10 @@ bool Client::Process() {
close_mobs.insert(std::pair<Mob *, float>(mob, distance)); close_mobs.insert(std::pair<Mob *, float>(mob, distance));
} }
} }
if (force_spawn_updates && mob != this && distance <= client_update_range)
mob->SendPositionUpdateToClient(this);
} }
} }

10
zone/command.cpp
View File

@ -3894,6 +3894,8 @@ void command_depopzone(Client *c, const Seperator *sep)
void command_repop(Client *c, const Seperator *sep) void command_repop(Client *c, const Seperator *sep)
{ {
int timearg = 1; int timearg = 1;
int delay = 0;
if (sep->arg[1] && strcasecmp(sep->arg[1], "force") == 0) { if (sep->arg[1] && strcasecmp(sep->arg[1], "force") == 0) {
timearg++; timearg++;
@ -3912,13 +3914,19 @@ void command_repop(Client *c, const Seperator *sep)
} }
if (!sep->IsNumber(timearg)) { if (!sep->IsNumber(timearg)) {
c->Message(0, "Zone depoped. Repoping now."); c->Message(0, "Zone depopped - repopping now.");
zone->Repop(); zone->Repop();
/* Force a spawn2 timer trigger so we don't delay actually spawning the NPC's */
zone->spawn2_timer.Trigger();
return; return;
} }
c->Message(0, "Zone depoped. Repop in %i seconds", atoi(sep->arg[timearg])); c->Message(0, "Zone depoped. Repop in %i seconds", atoi(sep->arg[timearg]));
zone->Repop(atoi(sep->arg[timearg]) * 1000); zone->Repop(atoi(sep->arg[timearg]) * 1000);
zone->spawn2_timer.Trigger();
} }
void command_repopclose(Client *c, const Seperator *sep) void command_repopclose(Client *c, const Seperator *sep)

2
zone/effects.cpp
View File

@ -613,7 +613,7 @@ bool Client::UseDiscipline(uint32 spell_id, uint32 target) {
//Check the disc timer //Check the disc timer
pTimerType DiscTimer = pTimerDisciplineReuseStart + spell.EndurTimerIndex; pTimerType DiscTimer = pTimerDisciplineReuseStart + spell.EndurTimerIndex;
if(!p_timers.Expired(&database, DiscTimer)) { if(!p_timers.Expired(&database, DiscTimer, false)) { // lets not set the reuse timer in case CastSpell fails (or we would have to turn off the timer, but CastSpell will set it as well)
/*char val1[20]={0};*/ //unused /*char val1[20]={0};*/ //unused
/*char val2[20]={0};*/ //unused /*char val2[20]={0};*/ //unused
uint32 remain = p_timers.GetRemainingTime(DiscTimer); uint32 remain = p_timers.GetRemainingTime(DiscTimer);

4
zone/embperl.cpp
View File

@ -237,6 +237,7 @@ void Embperl::init_eval_file(void)
{ {
eval_pv( eval_pv(
"our %Cache;" "our %Cache;"
"no warnings;"
"use Symbol qw(delete_package);" "use Symbol qw(delete_package);"
"sub eval_file {" "sub eval_file {"
"my($package, $filename) = @_;" "my($package, $filename) = @_;"
@ -247,7 +248,8 @@ void Embperl::init_eval_file(void)
" return;" " return;"
"} else {" "} else {"
// we 'my' $filename,$mtime,$package,$sub to prevent them from changing our state up here. // we 'my' $filename,$mtime,$package,$sub to prevent them from changing our state up here.
" eval(\"package $package; my(\\$filename,\\$mtime,\\$package,\\$sub); \\$isloaded = 1; require '$filename'; \");" " eval(\"package $package; my(\\$filename,\\$mtime,\\$package,\\$sub); \\$isloaded = 1; require './$filename'; \");"
// " print $@ if $@;"
/* "local *FH;open FH, $filename or die \"open '$filename' $!\";" /* "local *FH;open FH, $filename or die \"open '$filename' $!\";"
"local($/) = undef;my $sub = <FH>;close FH;" "local($/) = undef;my $sub = <FH>;close FH;"
"my $eval = qq{package $package; sub handler { $sub; }};" "my $eval = qq{package $package; sub handler { $sub; }};"

4
zone/embxs.cpp
View File

@ -99,6 +99,10 @@ XS(XS_EQEmuIO_PRINT)
/* Strip newlines from log message 'str' */ /* Strip newlines from log message 'str' */
*std::remove(str, str + strlen(str), '\n') = '\0'; *std::remove(str, str + strlen(str), '\n') = '\0';
std::string log_string = str;
if (log_string.find("did not return a true") != std::string::npos)
return;;
int i; int i;
int pos = 0; int pos = 0;
int len = 0; int len = 0;

2
zone/entity.cpp
View File

@ -648,6 +648,8 @@ void EntityList::AddNPC(NPC *npc, bool SendSpawnPacket, bool dontqueue)
parse->EventNPC(EVENT_SPAWN, npc, nullptr, "", 0); parse->EventNPC(EVENT_SPAWN, npc, nullptr, "", 0);
npc->FixZ();
uint16 emoteid = npc->GetEmoteID(); uint16 emoteid = npc->GetEmoteID();
if (emoteid != 0) if (emoteid != 0)
npc->DoNPCEmote(ONSPAWN, emoteid); npc->DoNPCEmote(ONSPAWN, emoteid);

27
zone/groups.cpp
View File

@ -2464,3 +2464,30 @@ bool Group::HasRole(Mob *m, uint8 Role)
return false; return false;
} }
void Group::QueueClients(Mob *sender, const EQApplicationPacket *app, bool ack_required /*= true*/, bool ignore_sender /*= true*/, float distance /*= 0*/) {
if (sender && sender->IsClient()) {
for (uint32 i = 0; i < MAX_GROUP_MEMBERS; i++) {
if (!members[i])
continue;
if (ignore_sender && members[i] == sender)
continue;
/* If we don't have a distance requirement - send to all members */
if (distance == 0) {
members[i]->CastToClient()->QueuePacket(app, ack_required);
}
else {
/* If negative distance - we check if current distance is greater than X */
if (distance <= 0 && DistanceSquared(sender->GetPosition(), members[i]->GetPosition()) >= (distance * distance)) {
members[i]->CastToClient()->QueuePacket(app, ack_required);
}
/* If positive distance - we check if current distance is less than X */
else if (distance >= 0 && DistanceSquared(sender->GetPosition(), members[i]->GetPosition()) <= (distance * distance)) {
members[i]->CastToClient()->QueuePacket(app, ack_required);
}
}
}
}
}

1
zone/groups.h
View File

@ -140,6 +140,7 @@ public:
inline int GetLeadershipAA(int AAID) { return LeaderAbilities.ranks[AAID]; } inline int GetLeadershipAA(int AAID) { return LeaderAbilities.ranks[AAID]; }
void ClearAllNPCMarks(); void ClearAllNPCMarks();
void QueueHPPacketsForNPCHealthAA(Mob* sender, const EQApplicationPacket* app); void QueueHPPacketsForNPCHealthAA(Mob* sender, const EQApplicationPacket* app);
void QueueClients(Mob *sender, const EQApplicationPacket *app, bool ack_required = true, bool ignore_sender = true, float distance = 0);
void ChangeLeader(Mob* newleader); void ChangeLeader(Mob* newleader);
const char *GetClientNameByIndex(uint8 index); const char *GetClientNameByIndex(uint8 index);
void UpdateXTargetMarkedNPC(uint32 Number, Mob *m); void UpdateXTargetMarkedNPC(uint32 Number, Mob *m);

18
zone/mob.cpp
View File

@ -1375,7 +1375,7 @@ void Mob::SendHPUpdate(bool skip_self /*= false*/, bool force_update_all /*= fal
if(IsClient()){ if(IsClient()){
Raid *raid = entity_list.GetRaidByClient(CastToClient()); Raid *raid = entity_list.GetRaidByClient(CastToClient());
if (raid) if (raid)
raid->SendHPPacketsFrom(this); raid->SendHPManaEndPacketsFrom(this);
} }
/* Pet - Update master - group and raid if exists */ /* Pet - Update master - group and raid if exists */
@ -1388,7 +1388,7 @@ void Mob::SendHPUpdate(bool skip_self /*= false*/, bool force_update_all /*= fal
Raid *raid = entity_list.GetRaidByClient(GetOwner()->CastToClient()); Raid *raid = entity_list.GetRaidByClient(GetOwner()->CastToClient());
if(raid) if(raid)
raid->SendHPPacketsFrom(this); raid->SendHPManaEndPacketsFrom(this);
} }
/* Send to pet */ /* Send to pet */
@ -1447,6 +1447,20 @@ void Mob::SendPosition() {
safe_delete(app); safe_delete(app);
} }
void Mob::SendPositionUpdateToClient(Client *client) {
auto app = new EQApplicationPacket(OP_ClientUpdate, sizeof(PlayerPositionUpdateServer_Struct));
PlayerPositionUpdateServer_Struct* spawn_update = (PlayerPositionUpdateServer_Struct*)app->pBuffer;
if(this->IsMoving())
MakeSpawnUpdate(spawn_update);
else
MakeSpawnUpdateNoDelta(spawn_update);
client->QueuePacket(app, false);
safe_delete(app);
}
/* Position updates for mobs on the move */ /* Position updates for mobs on the move */
void Mob::SendPositionUpdate(uint8 iSendToSelf) { void Mob::SendPositionUpdate(uint8 iSendToSelf) {
auto app = new EQApplicationPacket(OP_ClientUpdate, sizeof(PlayerPositionUpdateServer_Struct)); auto app = new EQApplicationPacket(OP_ClientUpdate, sizeof(PlayerPositionUpdateServer_Struct));

1
zone/mob.h
View File

@ -543,6 +543,7 @@ public:
virtual void GMMove(float x, float y, float z, float heading = 0.01, bool SendUpdate = true); virtual void GMMove(float x, float y, float z, float heading = 0.01, bool SendUpdate = true);
void SetDelta(const glm::vec4& delta); void SetDelta(const glm::vec4& delta);
void SetTargetDestSteps(uint8 target_steps) { tar_ndx = target_steps; } void SetTargetDestSteps(uint8 target_steps) { tar_ndx = target_steps; }
void SendPositionUpdateToClient(Client *client);
void SendPositionUpdate(uint8 iSendToSelf = 0); void SendPositionUpdate(uint8 iSendToSelf = 0);
void MakeSpawnUpdateNoDelta(PlayerPositionUpdateServer_Struct* spu); void MakeSpawnUpdateNoDelta(PlayerPositionUpdateServer_Struct* spu);
void MakeSpawnUpdate(PlayerPositionUpdateServer_Struct* spu); void MakeSpawnUpdate(PlayerPositionUpdateServer_Struct* spu);

5
zone/mob_ai.cpp
View File

@ -997,10 +997,9 @@ void Mob::AI_Process() {
if (this->GetTarget()) { if (this->GetTarget()) {
/* If we are engaged, moving and following client, let's look for best Z more often */ /* If we are engaged, moving and following client, let's look for best Z more often */
float target_distance = DistanceNoZ(this->GetPosition(), this->GetTarget()->GetPosition()); float target_distance = DistanceNoZ(this->GetPosition(), this->GetTarget()->GetPosition());
if (target_distance >= 25) {
this->FixZ(); this->FixZ();
}
else if (!this->CheckLosFN(this->GetTarget())) { if (target_distance <= 15 && !this->CheckLosFN(this->GetTarget())) {
Mob* target = this->GetTarget(); Mob* target = this->GetTarget();
m_Position.x = target->GetX(); m_Position.x = target->GetX();

43
zone/raids.cpp
View File

@ -149,7 +149,7 @@ void Raid::AddMember(Client *c, uint32 group, bool rleader, bool groupleader, bo
raid_update = c->GetRaid(); raid_update = c->GetRaid();
if (raid_update) { if (raid_update) {
raid_update->SendHPManaEndPacketsTo(c); raid_update->SendHPManaEndPacketsTo(c);
raid_update->SendHPPacketsFrom(c); raid_update->SendHPManaEndPacketsFrom(c);
} }
auto pack = new ServerPacket(ServerOP_RaidAdd, sizeof(ServerRaidGeneralAction_Struct)); auto pack = new ServerPacket(ServerOP_RaidAdd, sizeof(ServerRaidGeneralAction_Struct));
@ -1591,7 +1591,7 @@ void Raid::SendHPManaEndPacketsTo(Client *client)
} }
} }
void Raid::SendHPPacketsFrom(Mob *mob) void Raid::SendHPManaEndPacketsFrom(Mob *mob)
{ {
if(!mob) if(!mob)
return; return;
@ -1779,3 +1779,42 @@ void Raid::SetDirtyAutoHaters()
} }
void Raid::QueueClients(Mob *sender, const EQApplicationPacket *app, bool ack_required /*= true*/, bool ignore_sender /*= true*/, float distance /*= 0*/, bool group_only /*= true*/) {
if (sender && sender->IsClient()) {
uint32 group_id = this->GetGroup(sender->CastToClient());
/* If this is a group only packet and we're not in a group -- return */
if (!group_id == 0xFFFFFFFF && group_only)
return;
for (uint32 i = 0; i < MAX_RAID_MEMBERS; i++) {
if (!members[i].member)
continue;
if (!members[i].member->IsClient())
continue;
if (ignore_sender && members[i].member == sender)
continue;
if (group_only && members[i].GroupNumber != group_id)
continue;
/* If we don't have a distance requirement - send to all members */
if (distance == 0) {
members[i].member->CastToClient()->QueuePacket(app, ack_required);
}
else {
/* If negative distance - we check if current distance is greater than X */
if (distance <= 0 && DistanceSquared(sender->GetPosition(), members[i].member->GetPosition()) >= (distance * distance)) {
members[i].member->CastToClient()->QueuePacket(app, ack_required);
}
/* If positive distance - we check if current distance is less than X */
else if (distance >= 0 && DistanceSquared(sender->GetPosition(), members[i].member->GetPosition()) <= (distance * distance)) {
members[i].member->CastToClient()->QueuePacket(app, ack_required);
}
}
}
}
}

4
zone/raids.h
View File

@ -174,7 +174,7 @@ public:
void VerifyRaid(); void VerifyRaid();
void MemberZoned(Client *c); void MemberZoned(Client *c);
void SendHPManaEndPacketsTo(Client *c); void SendHPManaEndPacketsTo(Client *c);
void SendHPPacketsFrom(Mob *mob); void SendHPManaEndPacketsFrom(Mob *mob);
void SendManaPacketFrom(Mob *mob); void SendManaPacketFrom(Mob *mob);
void SendEndurancePacketFrom(Mob *mob); void SendEndurancePacketFrom(Mob *mob);
void RaidSay(const char *msg, Client *c); void RaidSay(const char *msg, Client *c);
@ -237,6 +237,8 @@ public:
void SetDirtyAutoHaters(); void SetDirtyAutoHaters();
inline XTargetAutoHaters *GetXTargetAutoMgr() { return &m_autohatermgr; } inline XTargetAutoHaters *GetXTargetAutoMgr() { return &m_autohatermgr; }
void QueueClients(Mob *sender, const EQApplicationPacket *app, bool ack_required = true, bool ignore_sender = true, float distance = 0, bool group_only = true);
RaidMember members[MAX_RAID_MEMBERS]; RaidMember members[MAX_RAID_MEMBERS];
char leadername[64]; char leadername[64];
protected: protected:

4
zone/spells.cpp
View File

@ -1427,8 +1427,10 @@ void Mob::CastedSpellFinished(uint16 spell_id, uint32 target_id, CastingSlot slo
ZeroCastingVars(); ZeroCastingVars();
// set the rapid recast timer for next time around // set the rapid recast timer for next time around
// Why do we have this? It mostly just causes issues when things are working correctly
// It also needs to be <users's ping to not cause issues
delaytimer = true; delaytimer = true;
spellend_timer.Start(400,true); spellend_timer.Start(10, true);
Log(Logs::Detail, Logs::Spells, "Spell casting of %d is finished.", spell_id); Log(Logs::Detail, Logs::Spells, "Spell casting of %d is finished.", spell_id);

7
zone/zone.cpp
View File

@ -1170,10 +1170,13 @@ bool Zone::Process() {
spawn_conditions.Process(); spawn_conditions.Process();
if(spawn2_timer.Check()) { if(spawn2_timer.Check()) {
LinkedListIterator<Spawn2*> iterator(spawn2_list); LinkedListIterator<Spawn2*> iterator(spawn2_list);
EQEmu::InventoryProfile::CleanDirty(); EQEmu::InventoryProfile::CleanDirty();
Log(Logs::Detail, Logs::Spawns, "Running Zone::Process -> Spawn2::Process");
iterator.Reset(); iterator.Reset();
while (iterator.MoreElements()) { while (iterator.MoreElements()) {
if (iterator.GetData()->Process()) { if (iterator.GetData()->Process()) {
@ -1183,10 +1186,10 @@ bool Zone::Process() {
iterator.RemoveCurrent(); iterator.RemoveCurrent();
} }
} }
if(adv_data && !did_adventure_actions) if(adv_data && !did_adventure_actions)
{
DoAdventureActions(); DoAdventureActions();
}
} }
if(initgrids_timer.Check()) { if(initgrids_timer.Check()) {
//delayed grid loading stuff. //delayed grid loading stuff.

2
zone/zone.h
View File

@ -106,6 +106,7 @@ public:
inline const uint8 GetZoneType() const { return zone_type; } inline const uint8 GetZoneType() const { return zone_type; }
inline Timer* GetInstanceTimer() { return Instance_Timer; } inline Timer* GetInstanceTimer() { return Instance_Timer; }
Timer spawn2_timer;
inline glm::vec3 GetSafePoint() { return m_SafePoint; } inline glm::vec3 GetSafePoint() { return m_SafePoint; }
inline const uint32& graveyard_zoneid() { return pgraveyard_zoneid; } inline const uint32& graveyard_zoneid() { return pgraveyard_zoneid; }
@ -336,7 +337,6 @@ private:
Timer autoshutdown_timer; Timer autoshutdown_timer;
Timer clientauth_timer; Timer clientauth_timer;
Timer spawn2_timer;
Timer qglobal_purge_timer; Timer qglobal_purge_timer;
Timer* Weather_Timer; Timer* Weather_Timer;
Timer* Instance_Timer; Timer* Instance_Timer;