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()