def set_leader(self, player_mgr):
self.party_leader.set_group_leader(False)
player_mgr.set_group_leader(True)
leader_name_bytes = PacketWriter.string_to_bytes(
player_mgr.player.name)
data = pack('<%us' % len(leader_name_bytes), leader_name_bytes)
packet = PacketWriter.get_packet(OpCode.SMSG_GROUP_SET_LEADER, data)
self.send_packet_to_members(packet)
self.send_update()
def send_invite_decline(self, player_name):
name_bytes = PacketWriter.string_to_bytes(player_name)
data = pack(
'<%us' % len(name_bytes),
name_bytes,
)
packet = PacketWriter.get_packet(OpCode.SMSG_GROUP_DECLINE, data)
self.party_leader.session.request.sendall(packet)
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_quest_giver_quest_list(self, message, quest_giver_guid, quest):
message_bytes = PacketWriter.string_to_bytes(message)
data = pack(
f'<Q{len(message_bytes)}s2iB',
quest_giver_guid,
message_bytes,
0, # TODO: delay
0, # TODO: emoteID
len(quest))
for entry in quest:
quest_title = PacketWriter.string_to_bytes(
quest[entry].quest.Title)
data += pack(f'<3I{len(quest_title)}s', entry, quest[entry].state,
quest[entry].quest.QuestLevel, quest_title)
self.player_mgr.enqueue_packet(
PacketWriter.get_packet(OpCode.SMSG_QUESTGIVER_QUEST_LIST, data))
def send_quest_giver_quest_list(self, message, quest_giver_guid, quests):
message_bytes = PacketWriter.string_to_bytes(message)
data = pack(
'<Q%us2iB' % len(message_bytes),
quest_giver_guid,
message_bytes,
0, # TODO: Gossip menu count
0, # TODO: Gossip menu items
len(quests))
for entry in quests:
quest_title = PacketWriter.string_to_bytes(
quests[entry].quest.Title)
data += pack('<3I%us' % len(quest_title), entry,
quests[entry].status, quests[entry].quest.QuestLevel,
quest_title)
self.player_mgr.session.request.sendall(
PacketWriter.get_packet(OpCode.SMSG_QUESTGIVER_QUEST_LIST, data))
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 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 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.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 send_update(self):
leader_name_bytes = PacketWriter.string_to_bytes(
self.members[self.group.leader_guid].character.name)
leader = WorldSessionStateHandler.find_player_by_guid(
self.group.leader_guid)
# Header
data = pack(
f'<I{len(leader_name_bytes)}sQB',
len(self.members),
leader_name_bytes,
self.group.leader_guid,
1 if leader and leader.online else
0 # If party leader is online or not
)
# Fill all group members.
for member in self.members.values():
if member.guid == self.group.leader_guid:
continue
player_mgr = WorldSessionStateHandler.find_player_by_guid(
member.guid)
member_name_bytes = PacketWriter.string_to_bytes(
member.character.name)
data += pack(
f'<{len(member_name_bytes)}sQB',
member_name_bytes,
member.guid,
1 if player_mgr and player_mgr.online else
0, # If member is online or not
)
data += pack(
'<BQ',
self.group.loot_method,
self.group.loot_master # Master Looter guid
)
packet = PacketWriter.get_packet(OpCode.SMSG_GROUP_LIST, data)
self.send_packet_to_members(packet)
self.send_party_members_stats()
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 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 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 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 _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_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 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 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 send_quest_giver_request_items(self, active_quest, quest_giver_id, close_on_cancel):
is_complete = active_quest.is_quest_complete(quest_giver_id)
quest_title_bytes = PacketWriter.string_to_bytes(active_quest.quest.Title)
quest = active_quest.quest
if quest.RequestItemsText:
dialog_text_bytes = PacketWriter.string_to_bytes(quest.RequestItemsText)
else:
dialog_text_bytes = PacketWriter.string_to_bytes(quest.Objectives)
data = pack(
f'<QI{len(quest_title_bytes)}s{len(dialog_text_bytes)}s4I',
quest_giver_id,
quest.entry,
quest_title_bytes,
dialog_text_bytes,
0, # Emote delay
0, # Emote id
1 if close_on_cancel else 0, # Close Window after cancel
quest.RewOrReqMoney if quest.RewOrReqMoney >= 0 else -quest.RewOrReqMoney
)
req_items = QuestHelpers.generate_req_item_list(quest)
req_items_count_list = QuestHelpers.generate_req_item_count_list(quest)
data += pack('<I', len(req_items))
for index in range(0, 4):
if req_items[index] == 0:
continue
data += self._gen_item_struct(req_items[index], req_items_count_list[index])
data += pack(
'<4I',
0x02,
0x03 if is_complete else 0x00, # Completable = flags1 && flags2 && flags3 && flags4
0x04, # flags2
0x08 # flags3
)
packet = PacketWriter.get_packet(OpCode.SMSG_QUESTGIVER_REQUEST_ITEMS, data)
self.player_mgr.session.enqueue_packet(packet)
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)
# Emotes
data += pack('<I', 4)
for index in range(1, 5):
detail_emote = int(eval(f'quest_template.DetailsEmote{index}'))
detail_emote_delay = eval(f'quest_template.DetailsEmoteDelay{index}')
data += pack('<2I', detail_emote, detail_emote_delay)
self.player_mgr.enqueue_packet(PacketWriter.get_packet(OpCode.SMSG_QUESTGIVER_QUEST_DETAILS, data))
def send_quest_giver_request_items(self, quest, quest_giver_id, close_on_cancel):
# We can always call to RequestItems, but this packet only goes out if there are actually
# items. Otherwise, we'll skip straight to the OfferReward.
quest_title = quest.Title
request_items_text = quest.RequestItemsText
is_completable = quest.entry in self.active_quests and self.active_quests[quest.entry].is_quest_complete(quest_giver_id)
if not request_items_text or (not QuestHelpers.has_item_requirements(quest) and is_completable):
self.send_quest_giver_offer_reward(quest, quest_giver_id, enable_next=True)
return
quest_title_bytes = PacketWriter.string_to_bytes(quest_title)
request_items_text_bytes = PacketWriter.string_to_bytes(request_items_text)
data = pack(
f'<QI{len(quest_title_bytes)}s{len(request_items_text_bytes)}s3I',
quest_giver_id,
quest.entry,
quest_title_bytes,
request_items_text_bytes,
0, # Emote delay
quest.CompleteEmote if is_completable else quest.IncompleteEmote,
close_on_cancel, # Close Window after cancel
)
req_items = list(filter((0).__ne__, QuestHelpers.generate_req_item_list(quest)))
req_items_count_list = list(filter((0).__ne__, QuestHelpers.generate_req_item_count_list(quest)))
data += pack('<I', len(req_items))
for index in range(len(req_items)):
data += self._gen_item_struct(req_items[index], req_items_count_list[index])
data += pack(
'<3I',
0x02, # MaskMatch
0x03 if is_completable else 0x00, # Completable = Player has items?
0x04, # HasFaction
)
packet = PacketWriter.get_packet(OpCode.SMSG_QUESTGIVER_REQUEST_ITEMS, data)
self.player_mgr.enqueue_packet(packet)
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 remove_member(self, player_guid):
member = self.members[player_guid]
guild_master = self.guild_master
data = pack('<2B', GuildEvents.GUILD_EVENT_REMOVED, 2)
target_name_bytes = PacketWriter.string_to_bytes(member.character.name)
data += pack(f'<{len(target_name_bytes)}s', target_name_bytes)
remover_name_bytes = PacketWriter.string_to_bytes(
guild_master.character.name)
data += pack(f'<{len(remover_name_bytes)}s', remover_name_bytes)
packet = PacketWriter.get_packet(OpCode.SMSG_GUILD_EVENT, data)
self.send_message_to_guild(packet, GuildChatMessageTypes.G_MSGTYPE_ALL)
# Pop it at the end, so he gets the above message.
RealmDatabaseManager.guild_remove_member(member)
player_mgr = WorldSessionStateHandler.find_player_by_guid(player_guid)
self.members.pop(player_guid)
if player_mgr:
self.build_update(player_mgr, unset=True)
player_mgr.guild_manager = None
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 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_update(self):
leader_name_bytes = PacketWriter.string_to_bytes(
self.party_leader.player.name)
# Header
data = pack(
'<I%usQB' % len(leader_name_bytes),
len(self.members),
leader_name_bytes,
self.party_leader.guid,
1 # If party leader is online or not
)
# Fill all group members.
for member in self.members.values():
if member == self.party_leader:
continue
member_name_bytes = PacketWriter.string_to_bytes(
member.player.name)
data += pack(
'<%usQB' % len(member_name_bytes),
member_name_bytes,
member.guid,
1 # If member is online or not
)
data += pack(
'<BQ',
LootMethods.
LOOT_METHOD_FREEFORALL, # TODO proper LootMethod handling
0 # Master Looter guid
)
packet = PacketWriter.get_packet(OpCode.SMSG_GROUP_LIST, data)
self.send_packet_to_members(packet)
self.send_party_members_stats()
def _build_group_list(self, player_mgr):
leader_name_bytes = PacketWriter.string_to_bytes(
self.members[self.group.leader_guid].character.name)
leader = WorldSessionStateHandler.find_player_by_guid(
self.group.leader_guid)
# Members excluding self unless self == leader
member_count = len(
self.members
) if player_mgr.guid == self.group.leader_guid else len(
self.members) - 1
# Header
data = pack(f'<I{len(leader_name_bytes)}sQB', member_count,
leader_name_bytes, self.group.leader_guid,
1 if leader and leader.online else 0)
# Fill all group members except self or leader.
for member in list(self.members.values()):
if member.guid == self.group.leader_guid or member.guid == player_mgr.guid:
continue
member_player = WorldSessionStateHandler.find_player_by_guid(
member.guid)
member_name_bytes = PacketWriter.string_to_bytes(
member.character.name)
data += pack(f'<{len(member_name_bytes)}sQB', member_name_bytes,
member.guid,
1 if member_player and member_player.online else 0)
data += pack(
'<BQ',
self.group.loot_method,
self.group.loot_master # Master Looter guid
)
return PacketWriter.get_packet(OpCode.SMSG_GROUP_LIST, data)
def set_guild_master(self, player_guid):
member = self.members[player_guid]
previous_gm = self.guild_master
member.rank = int(GuildRank.GUILDRANK_GUILD_MASTER)
previous_gm.rank = int(GuildRank.GUILDRANK_OFFICER)
if previous_gm:
data = pack('<2B', GuildEvents.GUILD_EVENT_LEADER_CHANGED, 2)
name_bytes = PacketWriter.string_to_bytes(
previous_gm.character.name)
data += pack(f'<{len(name_bytes)}s', name_bytes)
name_bytes = PacketWriter.string_to_bytes(member.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)
self.update_db_guild_members()
player_mgr = WorldSessionStateHandler.find_player_by_guid(player_guid)
if player_mgr:
player_mgr.set_uint32(PlayerFields.PLAYER_GUILDRANK, member.rank)
def promote_rank(self, player_guid):
member = self.members[player_guid]
if member.rank == int(GuildRank.GUILDRANK_GUILD_MASTER):
return False
if member.rank == int(GuildRank.GUILDRANK_OFFICER):
return False
else:
member.rank -= 1
data = pack('<2B', GuildEvents.GUILD_EVENT_PROMOTION, 2)
target_name_bytes = PacketWriter.string_to_bytes(member.character.name)
data += pack(
f'<{len(target_name_bytes)}s',
target_name_bytes
)
rank_name = GuildRank(member.rank).name.split('_')[1].capitalize()
rank_name_bytes = PacketWriter.string_to_bytes(rank_name)
data += pack(
f'<{len(rank_name_bytes)}s',
rank_name_bytes
)
packet = PacketWriter.get_packet(OpCode.SMSG_GUILD_EVENT, data)
self.send_message_to_guild(packet, GuildChatMessageTypes.G_MSGTYPE_ALL)
player_mgr = WorldSessionStateHandler.find_player_by_guid(member.guid)
if player_mgr:
player_mgr.set_uint32(PlayerFields.PLAYER_GUILDRANK, member.rank)
player_mgr.set_dirty()
self.update_db_guild_members()
return True
def leave(self, player_guid):
member = self.members[player_guid]
data = pack('<2B', GuildEvents.GUILD_EVENT_LEFT, 1)
leaver_name_bytes = PacketWriter.string_to_bytes(member.character.name)
data += pack(f'<{len(leaver_name_bytes)}s', leaver_name_bytes)
packet = PacketWriter.get_packet(OpCode.SMSG_GUILD_EVENT, data)
self.send_message_to_guild(packet, GuildChatMessageTypes.G_MSGTYPE_ALL)
RealmDatabaseManager.guild_remove_member(member)
self.members.pop(player_guid)
player_mgr = WorldSessionStateHandler.find_player_by_guid(player_guid)
if player_mgr:
self.build_update(player_mgr, unset=True)
player_mgr.guild_manager = None
