def send_invite_decline(self, player_name):
player_mgr = WorldSessionStateHandler.find_player_by_guid(
self.group.leader_guid)
if player_mgr:
name_bytes = PacketWriter.string_to_bytes(player_name)
data = pack(f'<{len(name_bytes)}s', name_bytes)
packet = PacketWriter.get_packet(OpCode.SMSG_GROUP_DECLINE, data)
player_mgr.enqueue_packet(packet)
def send_motd(self):
data = pack('<2B', GuildEvents.GUILD_EVENT_MOTD, 1)
motd_bytes = PacketWriter.string_to_bytes(self.motd)
data += pack(
'<%us' % len(motd_bytes),
motd_bytes,
)
packet = PacketWriter.get_packet(OpCode.SMSG_GUILD_EVENT, data)
self.send_message_to_guild(packet, GuildChatMessageTypes.G_MSGTYPE_ALL)
def query_details(self):
name_bytes = PacketWriter.string_to_bytes(self.creature_template.name)
subname_bytes = PacketWriter.string_to_bytes(
self.creature_template.subname)
data = pack(f'<I{len(name_bytes)}ssss{len(subname_bytes)}s3I',
self.entry, name_bytes, b'\x00', b'\x00', b'\x00',
subname_bytes, self.creature_template.type_flags,
self.creature_type, self.creature_template.beast_family)
return PacketWriter.get_packet(OpCode.SMSG_CREATURE_QUERY_RESPONSE,
data)
def leave_party(self, player_guid, force_disband=False, is_kicked=False):
disband = player_guid == self.group.leader_guid or len(
self.members) == 2 or force_disband
was_formed = self.is_party_formed()
# Group was disbanded before even existing.
if disband and player_guid == self.group.leader_guid and len(
self.members) == 0:
leader_player = WorldSessionStateHandler.find_player_by_guid(
self.group.leader_guid)
if leader_player:
leader_player.group_manager = None
leader_player.has_pending_invite = False
else:
for member in list(self.members.values()): # Avoid mutability.
if disband or member.guid == player_guid:
member_player = WorldSessionStateHandler.find_player_by_guid(
member.guid)
if member_player:
member_player.has_pending_group_invite = False
member_player.group_manager = None
member_player.group_status = WhoPartyStatus.WHO_PARTY_STATUS_NOT_IN_PARTY
if member.guid == self.group.leader_guid:
GroupManager._remove_leader_flag(member)
if not disband:
self._set_previous_looter(member.guid)
RealmDatabaseManager.group_remove_member(member)
self.members.pop(member.guid)
if was_formed and member_player and disband and not is_kicked and member.guid != player_guid:
disband_packet = PacketWriter.get_packet(
OpCode.SMSG_GROUP_DESTROYED)
member_player.enqueue_packet(disband_packet)
elif was_formed and member_player and disband and member.guid != player_guid:
disband_packet = PacketWriter.get_packet(
OpCode.SMSG_GROUP_DESTROYED)
member_player.enqueue_packet(disband_packet)
elif was_formed and member_player and not is_kicked:
GroupManager.send_group_operation_result(
member_player, PartyOperations.PARTY_OP_LEAVE,
member_player.player.name,
PartyResults.ERR_PARTY_RESULT_OK)
if member_player and is_kicked and member.guid == player_guid: # 'You have been removed from the group.' message
packet = PacketWriter.get_packet(
OpCode.SMSG_GROUP_UNINVITE)
member_player.enqueue_packet(packet)
if disband:
self.flush()
else:
self.send_update()
def invite_player(player_mgr, target_player_mgr):
if player_mgr.is_enemy_to(target_player_mgr):
GroupManager.send_group_operation_result(
player_mgr, PartyOperations.PARTY_OP_INVITE,
target_player_mgr.player.name,
PartyResults.ERR_PLAYER_WRONG_FACTION)
return
if target_player_mgr.friends_manager.has_ignore(player_mgr.guid):
GroupManager.send_group_operation_result(
player_mgr, PartyOperations.PARTY_OP_INVITE,
target_player_mgr.player.name, PartyResults.ERR_IGNORING_YOU_S)
return
if target_player_mgr.group_manager and target_player_mgr.group_manager.is_party_formed(
):
GroupManager.send_group_operation_result(
player_mgr, PartyOperations.PARTY_OP_INVITE,
target_player_mgr.player.name,
PartyResults.ERR_ALREADY_IN_GROUP_S)
return
if player_mgr.group_manager:
if player_mgr.group_manager.group.leader_guid != player_mgr.guid:
GroupManager.send_group_operation_result(
player_mgr, PartyOperations.PARTY_OP_INVITE,
target_player_mgr.player.name, PartyResults.ERR_NOT_LEADER)
return
if player_mgr.group_manager.is_full():
GroupManager.send_group_operation_result(
player_mgr, PartyOperations.PARTY_OP_INVITE,
target_player_mgr.player.name, PartyResults.ERR_GROUP_FULL)
return
if not player_mgr.group_manager.try_add_member(
target_player_mgr, True):
return
else:
new_group = GroupManager._create_group(player_mgr)
player_mgr.group_manager = GroupManager(new_group)
if not player_mgr.group_manager.try_add_member(target_player_mgr,
invite=True):
return
target_player_mgr.has_pending_group_invite = True
name_bytes = PacketWriter.string_to_bytes(player_mgr.player.name)
data = pack(f'<{len(name_bytes)}s', name_bytes)
packet = PacketWriter.get_packet(OpCode.SMSG_GROUP_INVITE, data)
target_player_mgr.enqueue_packet(packet)
GroupManager.send_group_operation_result(
player_mgr, PartyOperations.PARTY_OP_INVITE,
target_player_mgr.player.name, PartyResults.ERR_PARTY_RESULT_OK)
def _get_message_packet(guid, chat_flags, message, chat_type, lang):
message_bytes = PacketWriter.string_to_bytes(message)
data = pack(
'<BIQ%usB' % len(message_bytes),
chat_type,
lang,
guid,
message_bytes,
chat_flags
)
return PacketWriter.get_packet(OpCode.SMSG_MESSAGECHAT, data)
def send_group_operation_result(player, group_operation, name, result):
name_bytes = PacketWriter.string_to_bytes(name)
data = pack(
f'<I{len(name_bytes)}sI',
group_operation,
name_bytes,
result
)
packet = PacketWriter.get_packet(OpCode.SMSG_PARTY_COMMAND_RESULT, data)
player.enqueue_packet(packet)
def send_guild_command_result(player_mgr, command_type, message, command):
message_bytes = PacketWriter.string_to_bytes(message)
data = pack(
f'<I{len(message_bytes)}sI',
command_type,
message_bytes,
command
)
packet = PacketWriter.get_packet(OpCode.SMSG_GUILD_COMMAND_RESULT, data)
player_mgr.session.enqueue_packet(packet)
def get_query_details(player):
name_bytes = PacketWriter.string_to_bytes(player.name)
player_data = pack(
f'<Q{len(name_bytes)}s3I',
player.guid,
name_bytes,
player.race,
player.gender,
player.class_
)
return PacketWriter.get_packet(OpCode.SMSG_NAME_QUERY_RESPONSE, player_data)
def send_chat_message(world_session, message, chat_type, lang):
message_bytes = PacketWriter.string_to_bytes(message)
data = pack(
'<BIQ%usB' % len(message_bytes),
chat_type.value,
0, # lang, disregard for now––not implemented
world_session.player_mgr.guid,
message_bytes,
ChatFlags.CHAT_TAG_NONE.value)
world_session.request.sendall(
PacketWriter.get_packet(OpCode.SMSG_MESSAGECHAT, data))
def query_details(self):
item_name_bytes = PacketWriter.string_to_bytes(self.item_template.name)
data = pack(
f'<3I{len(item_name_bytes)}ssss6I2i7I', self.item_template.entry,
self.item_template.class_, self.item_template.subclass,
item_name_bytes, b'\x00', b'\x00', b'\x00',
self.item_template.display_id, self.item_template.quality,
self.item_instance.item_flags if self.item_instance else
self.item_template.flags, self.item_template.buy_price,
self.item_template.sell_price, self.item_template.inventory_type,
self.item_template.allowable_class,
self.item_template.allowable_race, self.item_template.item_level,
self.item_template.required_level,
self.item_template.required_skill,
self.item_template.required_skill_rank,
self.item_template.max_count, self.item_template.stackable,
self.item_template.container_slots)
for stat in self.stats:
data += pack('<2i', stat.stat_type, stat.value)
for damage_stat in self.damage_stats:
data += pack('<3i', int(damage_stat.minimum),
int(damage_stat.maximum), damage_stat.stat_type)
data += pack(
'<6i3I',
self.item_template.armor,
self.item_template.holy_res,
self.item_template.fire_res,
self.item_template.nature_res,
self.item_template.frost_res,
self.item_template.shadow_res,
self.item_template.delay,
self.item_template.ammo_type,
0 # Durability, not implemented
)
for spell_stat in self.spell_stats:
data += pack('<Q4i', spell_stat.spell_id, spell_stat.trigger,
spell_stat.charges, spell_stat.cooldown,
spell_stat.category_cooldown)
description_bytes = PacketWriter.string_to_bytes(
self.item_template.description)
data += pack(
f'<I{len(description_bytes)}s5IiI', self.item_template.bonding,
description_bytes, self.item_template.page_text,
self.item_template.page_language, self.item_template.page_material,
self.item_template.start_quest, self.item_template.lock_id,
self.item_template.material, self.item_template.sheath)
return PacketWriter.get_packet(OpCode.SMSG_ITEM_QUERY_SINGLE_RESPONSE,
data)
def send_group_operation_result(player, group_operation, name, result):
name_bytes = PacketWriter.string_to_bytes(name)
data = pack(
'<I%usI' % len(name_bytes),
group_operation,
name_bytes,
result,
)
packet = PacketWriter.get_packet(OpCode.SMSG_PARTY_COMMAND_RESULT, data)
player.session.request.sendall(packet)
def build_guild_query(self):
data = pack('<I', self.guild.guild_id)
name_bytes = PacketWriter.string_to_bytes(self.guild.name)
data += pack(f'<{len(name_bytes)}s', name_bytes)
data += pack('<5i', self.guild.emblem_style, self.guild.emblem_color,
self.guild.border_style, self.guild.border_color,
self.guild.background_color)
return PacketWriter.get_packet(OpCode.SMSG_GUILD_QUERY_RESPONSE, data)
def query_details(self):
name_bytes = PacketWriter.string_to_bytes(self.gobject_template.name)
data = pack('<3I%ussss10I' % len(name_bytes),
self.gobject_template.entry, self.gobject_template.type,
self.display_id, name_bytes, b'\x00', b'\x00', b'\x00',
self.gobject_template.data0, self.gobject_template.data1,
self.gobject_template.data2, self.gobject_template.data3,
self.gobject_template.data4, self.gobject_template.data5,
self.gobject_template.data6, self.gobject_template.data7,
self.gobject_template.data8, self.gobject_template.data9)
return PacketWriter.get_packet(OpCode.SMSG_GAMEOBJECT_QUERY_RESPONSE,
data)
def send_quest_giver_offer_reward(self,
active_quest,
quest_giver_guid,
enable_next=True):
# CGPlayer_C::OnQuestGiverChooseReward
quest = active_quest.quest
quest_title = PacketWriter.string_to_bytes(quest.Title)
quest_offer_reward_text = PacketWriter.string_to_bytes(
quest.OfferRewardText)
data = pack(
f'<QI{len(quest_title)}s{len(quest_offer_reward_text)}sI',
quest_giver_guid,
quest.entry,
quest_title,
quest_offer_reward_text,
1 if enable_next else 0 # enable_next
)
# TODO Handle emotes
# Emote count
data += pack('<I', 0)
# for i in range(4):
# data += pack('<2I', 0, 0)
# Reward choices
rew_choice_item_list = list(
filter((0).__ne__, self.generate_rew_choice_item_list(quest)))
rew_choice_count_list = list(
filter((0).__ne__, self.generate_rew_choice_count_list(quest)))
data += pack('<I', len(rew_choice_item_list))
for index, item in enumerate(rew_choice_item_list):
data += self._gen_item_struct(item, rew_choice_count_list[index])
# Required items
req_item_list = list(
filter((0).__ne__, self.generate_req_item_list(quest)))
req_count_list = list(
filter((0).__ne__, self.generate_req_item_count_list(quest)))
data += pack('<I', len(req_item_list))
for index, item in enumerate(req_item_list):
data += self._gen_item_struct(item,
req_count_list[index],
include_display_id=False)
# Reward
data += pack(
'<I', quest.RewOrReqMoney
if quest.RewOrReqMoney >= 0 else -quest.RewOrReqMoney)
data += pack('<I', quest.RewSpell)
data += pack('<I', quest.RewSpellCast)
self.player_mgr.session.enqueue_packet(
PacketWriter.get_packet(OpCode.SMSG_QUESTGIVER_OFFER_REWARD, data))
def send_quest_giver_offer_reward(self, active_quest, quest_giver_guid, enable_next=True):
# CGPlayer_C::OnQuestGiverChooseReward
quest = active_quest.quest
quest_title_bytes = PacketWriter.string_to_bytes(quest.Title)
display_dialog_text = quest.OfferRewardText
dialog_text_bytes = PacketWriter.string_to_bytes(display_dialog_text)
data = pack(
f'<QI{len(quest_title_bytes)}s{len(dialog_text_bytes)}sI',
quest_giver_guid,
active_quest.quest.entry,
quest_title_bytes,
dialog_text_bytes,
1 if enable_next else 0 # enable_next
)
# Emote count, always 4.
data += pack('<I', 4)
for i in range(1, 5):
emote = eval(f'active_quest.quest.OfferRewardEmote{i}')
delay = eval(f'active_quest.quest.OfferRewardEmoteDelay{i}')
data += pack('<2I', emote, delay)
if active_quest.has_pick_reward():
# Reward choices
rew_choice_item_list = list(filter((0).__ne__, QuestHelpers.generate_rew_choice_item_list(quest)))
rew_choice_count_list = list(filter((0).__ne__, QuestHelpers.generate_rew_choice_count_list(quest)))
data += pack('<I', len(rew_choice_item_list))
for index, item in enumerate(rew_choice_item_list):
data += self._gen_item_struct(item, rew_choice_count_list[index])
else:
data += pack('<I', 0)
# Apart from available rewards to pick from, sometimes there are rewards you will also get, no matter what.
if active_quest.has_item_reward():
# Required items
rew_item_list = list(filter((0).__ne__, QuestHelpers.generate_rew_item_list(quest)))
rew_count_list = list(filter((0).__ne__, QuestHelpers.generate_rew_count_list(quest)))
data += pack('<I', len(rew_item_list))
for index, item in enumerate(rew_item_list):
data += self._gen_item_struct(item, rew_count_list[index])
else:
data += pack('<I', 0)
# Reward
data += pack(
'<3I',
quest.RewOrReqMoney if quest.RewOrReqMoney >= 0 else -quest.RewOrReqMoney,
quest.RewSpell,
quest.RewSpellCast,
)
self.player_mgr.session.enqueue_packet(PacketWriter.get_packet(OpCode.SMSG_QUESTGIVER_OFFER_REWARD, data))
def add_new_offline_member(self, character):
rank = GuildRank.GUILDRANK_INITIATE
guild_member = self._create_new_member(character.guid, rank)
self.members[character.guid] = guild_member
data = pack('<2B', GuildEvents.GUILD_EVENT_JOINED, 1)
name_bytes = PacketWriter.string_to_bytes(character.name)
data += pack(f'<{len(name_bytes)}s', name_bytes)
packet = PacketWriter.get_packet(OpCode.SMSG_GUILD_EVENT, data)
self.send_message_to_guild(packet, GuildChatMessageTypes.G_MSGTYPE_ALL)
RealmDatabaseManager.character_update(character)
def set_leader(self, player_guid):
# First, demote previous leader.
GroupManager._remove_leader_flag(self.members[self.group.leader_guid])
# Second, promote new leader.
GroupManager._set_leader_flag(self.members[player_guid])
self.group.leader_guid = player_guid
RealmDatabaseManager.group_update(self.group)
leader_name_bytes = PacketWriter.string_to_bytes(self.members[player_guid].character.name)
data = pack(f'<{len(leader_name_bytes)}s', leader_name_bytes)
packet = PacketWriter.get_packet(OpCode.SMSG_GROUP_SET_LEADER, data)
self.send_packet_to_members(packet)
self.send_update()
def discover_taxi(self, node, flight_master_guid=0):
if not self.has_node(node):
self.available_taxi_nodes[node - 1] = True
# Notify new taxi path discovered.
self.owner.enqueue_packet(
PacketWriter.get_packet(OpCode.SMSG_NEW_TAXI_PATH))
if flight_master_guid > 0:
# Update flight master status.
data = pack('<QB', flight_master_guid, 1)
self.owner.enqueue_packet(
PacketWriter.get_packet(OpCode.SMSG_TAXINODE_STATUS, data))
return True
return False
def send_quest_giver_quest_details(self, quest_template, quest_giver_guid, activate_accept):
# Quest information
quest_title = PacketWriter.string_to_bytes(quest_template.Title)
quest_details = PacketWriter.string_to_bytes(quest_template.Details)
quest_objectives = PacketWriter.string_to_bytes(quest_template.Objectives)
data = pack(
f'<QI{len(quest_title)}s{len(quest_details)}s{len(quest_objectives)}sI',
quest_giver_guid,
quest_template.entry,
quest_title,
quest_details,
quest_objectives,
1 if activate_accept else 0
)
# Reward choices
rew_choice_item_list = list(filter((0).__ne__, QuestHelpers.generate_rew_choice_item_list(quest_template)))
rew_choice_count_list = list(filter((0).__ne__, QuestHelpers.generate_rew_choice_count_list(quest_template)))
data += pack('<I', len(rew_choice_item_list))
for index, item in enumerate(rew_choice_item_list):
data += self._gen_item_struct(item, rew_choice_count_list[index])
# Reward items
rew_item_list = list(filter((0).__ne__, QuestHelpers.generate_rew_item_list(quest_template)))
rew_count_list = list(filter((0).__ne__, QuestHelpers.generate_rew_count_list(quest_template)))
data += pack('<I', len(rew_item_list))
for index, item in enumerate(rew_item_list):
data += self._gen_item_struct(item, rew_count_list[index])
# Reward money
data += pack('<I', quest_template.RewOrReqMoney)
# Required items
req_item_list = list(filter((0).__ne__, QuestHelpers.generate_req_item_list(quest_template)))
req_count_list = list(filter((0).__ne__, QuestHelpers.generate_req_item_count_list(quest_template)))
data += pack('<I', len(req_item_list))
for index, item in enumerate(req_item_list):
data += self._gen_item_struct(item, req_count_list[index])
# Required kill / go count
req_creature_or_go_list = list(filter((0).__ne__, QuestHelpers.generate_req_creature_or_go_list(quest_template)))
req_creature_or_go_count_list = list(filter((0).__ne__, QuestHelpers.generate_req_creature_or_go_count_list(quest_template)))
data += pack('<I', len(req_creature_or_go_list))
for index, creature_or_go in enumerate(req_creature_or_go_list):
data += pack(
'<2I',
creature_or_go if creature_or_go >= 0 else (creature_or_go * -1) | 0x80000000,
req_creature_or_go_count_list[index]
)
self.player_mgr.session.enqueue_packet(PacketWriter.get_packet(OpCode.SMSG_QUESTGIVER_QUEST_DETAILS, data))
def invite_player(player_mgr, target_player_mgr):
# TODO Not send invite if target is ignoring player
if player_mgr.is_enemy_to(target_player_mgr):
GroupManager.send_group_operation_result(
player_mgr, PartyOperations.PARTY_OP_INVITE,
target_player_mgr.player.name,
PartyResults.ERR_PLAYER_WRONG_FACTION)
return
if target_player_mgr.group_manager:
GroupManager.send_group_operation_result(
player_mgr, PartyOperations.PARTY_OP_INVITE,
target_player_mgr.player.name,
PartyResults.ERR_ALREADY_IN_GROUP_S)
return
if player_mgr.group_manager:
if player_mgr.group_manager.party_leader != player_mgr:
GroupManager.send_group_operation_result(
player_mgr, PartyOperations.PARTY_OP_INVITE,
target_player_mgr.player.name, PartyResults.ERR_NOT_LEADER)
return
if len(player_mgr.group_manager.members) == MAX_GROUP_SIZE:
GroupManager.send_group_operation_result(
player_mgr, PartyOperations.PARTY_OP_INVITE,
target_player_mgr.player.name, PartyResults.ERR_GROUP_FULL)
return
if not player_mgr.group_manager.try_add_member(
target_player_mgr, True):
return
else:
player_mgr.group_manager = GroupManager(player_mgr)
if not player_mgr.group_manager.try_add_member(
target_player_mgr, True):
return
name_bytes = PacketWriter.string_to_bytes(player_mgr.player.name)
data = pack(
'<%us' % len(name_bytes),
name_bytes,
)
packet = PacketWriter.get_packet(OpCode.SMSG_GROUP_INVITE, data)
target_player_mgr.session.request.sendall(packet)
GroupManager.send_group_operation_result(
player_mgr, PartyOperations.PARTY_OP_INVITE,
target_player_mgr.player.name, PartyResults.ERR_PARTY_RESULT_OK)
def send_motd(self, player_mgr=None):
data = pack('<2B', GuildEvents.GUILD_EVENT_MOTD, 1)
motd_bytes = PacketWriter.string_to_bytes(self.guild.motd)
data += pack(
f'<{len(motd_bytes)}s',
motd_bytes,
)
packet = PacketWriter.get_packet(OpCode.SMSG_GUILD_EVENT, data)
if player_mgr:
player_mgr.session.enqueue_packet(packet)
else:
self.send_message_to_guild(packet, GuildChatMessageTypes.G_MSGTYPE_ALL)
def build_notify_packet(channel, notification_type, target1=None, target2=None, player_name=None, flags=None):
channel_name_bytes = PacketWriter.string_to_bytes(channel)
data = pack(f'<B{len(channel_name_bytes)}s', notification_type, channel_name_bytes)
if target1:
data += pack('<Q', target1.guid)
if target2:
data += pack('<Q', target2.guid)
if player_name:
sender_name_bytes = PacketWriter.string_to_bytes(player_name)
data += pack(f'<{len(sender_name_bytes)}s', sender_name_bytes)
if flags:
data += pack('<2B', flags[0], flags[1])
return PacketWriter.get_packet(OpCode.SMSG_CHANNEL_NOTIFY, data)
def end_duel(self, duel_winner_flag, duel_complete_flag, winner):
if not self.arbiter or self.duel_state == DuelState.DUEL_STATE_FINISHED or not self.players:
return
if self.duel_state == DuelState.DUEL_STATE_STARTED:
duel_complete_flag = DuelComplete.DUEL_FINISHED
# Set this first to prevent next tick to trigger.
self.duel_state = DuelState.DUEL_STATE_FINISHED
if duel_winner_flag == DuelWinner.DUEL_WINNER_KNOCKOUT:
# TODO: Should trigger EMOTE BEG on loser?
# TODO: Should root loser for 3 secs?
pass
# Send either the duel ended by natural means or if it was canceled/interrupted
packet = PacketWriter.get_packet(OpCode.SMSG_DUEL_COMPLETE,
pack('<B', duel_complete_flag))
MapManager.send_surrounding(packet, self.arbiter)
# Was not interrupted, broadcast duel result.
if duel_complete_flag == DuelComplete.DUEL_FINISHED:
winner_name_bytes = PacketWriter.string_to_bytes(
winner.player.name)
loser_name_bytes = PacketWriter.string_to_bytes(
self.players[winner.guid].target.player.name)
data = pack(f'<B{len(winner_name_bytes)}s{len(loser_name_bytes)}s',
duel_winner_flag, winner_name_bytes, loser_name_bytes)
packet = PacketWriter.get_packet(OpCode.SMSG_DUEL_WINNER, data)
MapManager.send_surrounding(packet, self.arbiter)
packet = PacketWriter.get_packet(OpCode.SMSG_CANCEL_COMBAT)
for entry in self.players.values():
entry.player.enqueue_packet(packet)
entry.player.leave_combat()
self.build_update(entry.player)
entry.player.set_dirty()
entry.player.spell_manager.remove_unit_from_all_cast_targets(
entry.target.guid)
entry.player.aura_manager.remove_harmful_auras_by_caster(
entry.target.guid)
# Clean up arbiter go and cleanup.
MapManager.remove_object(self.arbiter)
# Finally, flush this DualManager instance.
self.flush()
def _build_party_member_stats(group_member):
player_mgr = WorldSessionStateHandler.find_player_by_guid(
group_member.guid)
character = None
# If player is offline, build stats based on db information.
if not player_mgr or not player_mgr.online:
player_mgr = None
character = RealmDatabaseManager.character_get_by_guid(
group_member.guid)
data = pack(
'<Q2IB6I3f',
player_mgr.guid if player_mgr else character.guid,
player_mgr.health if player_mgr else 0,
player_mgr.max_health if player_mgr else 0,
player_mgr.power_type if player_mgr else 0,
player_mgr.get_power_type_value() if player_mgr else 0,
player_mgr.get_max_power_value() if player_mgr else 0,
player_mgr.level if player_mgr else character.level,
player_mgr.map_ if player_mgr else character.map,
# Client expects an AreaNumber from AreaTable, not a zone id.
MapManager.get_area_number_by_zone_id(
player_mgr.zone if player_mgr else character.zone),
player_mgr.class_ if player_mgr else character.class_,
player_mgr.location.x if player_mgr else character.position_x,
player_mgr.location.y if player_mgr else character.position_y,
player_mgr.location.z if player_mgr else character.position_z,
)
return PacketWriter.get_packet(OpCode.SMSG_PARTY_MEMBER_STATS, data)
def send_quest_giver_status(self, quest_giver_guid, quest_status):
data = pack(
'<QI',
quest_giver_guid if quest_giver_guid > 0 else self.player_mgr.guid,
quest_status)
self.player_mgr.session.request.sendall(
PacketWriter.get_packet(OpCode.SMSG_QUESTGIVER_STATUS, data))
def handle(world_session, socket, reader):
if len(
reader.data
) >= 12: # Avoid handling empty quest giver accept quest packet.
guid, quest_id = unpack('<QI', reader.data[:12])
high_guid = ObjectManager.extract_high_guid(guid)
is_item = False
quest_giver = None
if high_guid == HighGuid.HIGHGUID_UNIT:
quest_giver = MapManager.get_surrounding_unit_by_guid(
world_session.player_mgr, guid)
elif high_guid == HighGuid.HIGHGUID_GAMEOBJECT:
quest_giver = MapManager.get_surrounding_gameobject_by_guid(
world_session.player_mgr, guid)
elif high_guid == HighGuid.HIGHGUID_ITEM:
is_item = True
quest_giver = world_session.player_mgr.inventory.get_item_by_guid(
guid)
if not quest_giver:
Logger.error(
f'Error in CMSG_QUESTGIVER_ACCEPT_QUEST, could not find quest giver with guid of: {guid}'
)
return 0
elif not is_item and world_session.player_mgr.is_enemy_to(
quest_giver):
return 0
elif world_session.player_mgr.quest_manager.is_quest_log_full():
world_session.enqueue_packet(
PacketWriter.get_packet(OpCode.SMSG_QUESTLOG_FULL))
else:
world_session.player_mgr.quest_manager.handle_accept_quest(
quest_id, guid, shared=False)
return 0
def generate_proper_update_packet(self, is_self=False, create=False):
update_packet = UpdatePacketFactory.compress_if_needed(
PacketWriter.get_packet(
OpCode.SMSG_UPDATE_OBJECT,
self.get_full_update_packet(is_self=is_self)
if create else self.get_partial_update_packet()))
return update_packet
def send_attack_stop(self, victim_guid):
# Last uint32 is "deceased"; can be either 1 (self is dead), or 0, (self is alive).
# Forces the unit to face the corpse and disables clientside
# turning (UnitFlags.DisableMovement) CGUnit_C::OnAttackStop
data = pack('<2QI', self.guid, victim_guid, 0 if self.is_alive else 1)
MapManager.send_surrounding(
PacketWriter.get_packet(OpCode.SMSG_ATTACKSTOP, data), self)
def remove_ignore(self, player_guid):
if player_guid in self.friends:
RealmDatabaseManager.character_social_delete_friend(self.friends[player_guid])
self.friends.pop(player_guid)
data = pack('<BQ', FriendResults.FRIEND_IGNORE_REMOVED, player_guid)
self.owner.session.enqueue_packet(PacketWriter.get_packet(OpCode.SMSG_FRIEND_STATUS, data))
self.send_ignores()
