def add_ignore(self, player_guid):
if player_guid not in self.friends:
self.friends[player_guid] = self._create_friend(player_guid, ignored=True)
RealmDatabaseManager.character_add_friend(self.friends[player_guid])
else:
self.friends[player_guid].ignore = True
RealmDatabaseManager.character_update_social([self.friends[player_guid]])
data = pack('<BQ', FriendResults.FRIEND_IGNORE_ADDED, player_guid)
packet = PacketWriter.get_packet(OpCode.SMSG_FRIEND_STATUS, data)
self.owner.session.enqueue_packet(packet)
self.send_ignores()
def load_items(self):
character_inventory = RealmDatabaseManager.character_get_inventory(
self.owner.guid)
# First load bags
for item_instance in character_inventory:
item_template = WorldDatabaseManager.ItemTemplateHolder.item_template_get_by_entry(
item_instance.item_template)
if item_template and item_template.inventory_type == InventoryTypes.BAG:
container_mgr = ContainerManager(owner=self.owner.guid,
item_template=item_template,
item_instance=item_instance)
if self.is_bag_pos(container_mgr.current_slot):
if item_instance.bag > 23:
low_guid = container_mgr.guid & ~HighGuid.HIGHGUID_CONTAINER
Logger.warning(
f'Invalid bag slot {item_instance.bag} for guid {low_guid} owner {self.owner.guid}'
)
continue
self.containers[item_instance.bag].sorted_slots[
container_mgr.current_slot] = container_mgr
self.containers[container_mgr.current_slot] = container_mgr
# Then load items
for item_instance in character_inventory:
item_template = WorldDatabaseManager.ItemTemplateHolder.item_template_get_by_entry(
item_instance.item_template)
if item_template:
if item_template.display_id > MAX_3368_ITEM_DISPLAY_ID and \
self.is_equipment_pos(item_instance.bag, item_instance.slot):
Logger.error(
f'Character {self.owner.player.name} has an equipped item ({item_template.entry} - {item_template.name}) '
f'with out of bounds display_id ({item_template.display_id}), '
f'deleting in order to prevent crashes.')
RealmDatabaseManager.character_inventory_delete(
item_instance)
continue
if item_template.inventory_type == InventoryTypes.BAG:
if self.is_bag_pos(item_instance.slot):
continue
item_mgr = ContainerManager(owner=self.owner.guid,
item_template=item_template,
item_instance=item_instance)
else:
item_mgr = ItemManager(item_template=item_template,
item_instance=item_instance)
if item_instance.bag in self.containers and self.containers[
item_instance.bag]:
self.containers[item_instance.bag].sorted_slots[
item_mgr.current_slot] = item_mgr
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 load_items(self):
# Add backpack
self.containers[InventorySlots.SLOT_INBACKPACK] = ContainerManager(
is_backpack=True, owner=self.owner.guid)
character_inventory = RealmDatabaseManager.character_get_inventory(
self.owner.guid)
# First load bags
for item_instance in character_inventory:
item_template = WorldDatabaseManager.item_template_get_by_entry(
item_instance.item_template)
if item_template and item_template.inventory_type == InventoryTypes.BAG:
container_mgr = ContainerManager(owner=self.owner.guid,
item_template=item_template,
item_instance=item_instance)
if self.is_bag_pos(container_mgr.current_slot):
self.containers[item_instance.bag].sorted_slots[
container_mgr.current_slot] = container_mgr
self.containers[container_mgr.current_slot] = container_mgr
# Then load items
for item_instance in character_inventory:
item_template = WorldDatabaseManager.item_template_get_by_entry(
item_instance.item_template)
if item_template:
if item_template.display_id > MAX_3368_ITEM_DISPLAY_ID and \
self.is_equipment_pos(item_instance.bag, item_instance.slot):
Logger.error(
'Character %s has an equipped item (%u - %s) with out of bounds display_id (%u), '
'deleting in order to prevent crashes.' %
(self.owner.player.name, item_template.entry,
item_template.name, item_template.display_id))
RealmDatabaseManager.character_inventory_delete(
item_instance)
continue
if item_template.inventory_type == InventoryTypes.BAG:
if self.is_bag_pos(item_instance.slot):
continue
item_mgr = ContainerManager(owner=self.owner.guid,
item_template=item_template,
item_instance=item_instance)
else:
item_mgr = ItemManager(item_template=item_template,
item_instance=item_instance)
if item_instance.bag in self.containers:
self.containers[item_instance.bag].sorted_slots[
item_mgr.current_slot] = item_mgr
self.set_base_attack_time()
def _create_guild(motd, name, bg_color, b_color, b_style, e_color, e_style, leader_guid):
guild = Guild()
guild.motd = motd
guild.name = name
guild.background_color = bg_color
guild.border_color = b_color
guild.border_style = b_style
guild.emblem_color = e_color
guild.emblem_style = e_style
guild.leader_guid = leader_guid
guild.creation_date = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
RealmDatabaseManager.guild_create(guild)
return guild
def add_friend(self, player_guid):
if player_guid not in self.friends:
self.friends[player_guid] = self._create_friend(player_guid)
player_mgr = WorldSessionStateHandler.find_player_by_guid(player_guid)
RealmDatabaseManager.character_add_friend(self.friends[player_guid])
status = FriendResults.FRIEND_ADDED_ONLINE if player_mgr else FriendResults.FRIEND_ADDED_OFFLINE
data = pack('<BQ', status, player_guid)
if player_mgr and player_mgr.online: # Player is online.
data += pack('<B3I', 1, player_mgr.zone, player_mgr.level, player_mgr.player.class_)
self.owner.session.enqueue_packet(PacketWriter.get_packet(OpCode.SMSG_FRIEND_STATUS, data))
self.send_friends()
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 handle(world_session, socket, reader):
if len(reader.data) >= 17: # Avoid handling empty sell item packet.
vendor_guid, item_guid, sell_amount = unpack('<QQB', reader.data[:17])
container_slot, container, slot, item = world_session.player_mgr.inventory.get_item_info_by_guid(item_guid)
if vendor_guid > 0:
if not item:
world_session.player_mgr.inventory.send_sell_error(SellResults.SELL_ERR_CANT_FIND_ITEM,
item_guid, vendor_guid)
return 0
owner = world_session.player_mgr.guid
if owner != item.item_instance.owner:
world_session.player_mgr.inventory.send_sell_error(SellResults.SELL_ERR_YOU_DONT_OWN_THAT_ITEM,
item_guid, vendor_guid)
return 0
stack_count = item.item_instance.stackcount
# Client seems to send zero at least when simply right clicking, default to selling whole stack.
if sell_amount <= 0:
sell_amount = stack_count
if sell_amount > stack_count:
world_session.player_mgr.inventory.send_sell_error(SellResults.SELL_ERR_CANT_FIND_ITEM,
item_guid, vendor_guid)
return 0
price = item.item_template.sell_price
if price == 0: # Item is unsellable
world_session.player_mgr.inventory.send_sell_error(SellResults.SELL_ERR_CANT_SELL_ITEM,
item_guid, vendor_guid)
return 0
# Check if player is attempting to sell a bag with something in it
if world_session.player_mgr.inventory.is_bag_pos(slot) and not item.is_empty():
world_session.player_mgr.inventory.send_sell_error(SellResults.SELL_ERR_ONLY_EMPTY_BAG,
item_guid, vendor_guid)
return 0
if sell_amount < stack_count:
item.item_instance.stackcount -= sell_amount
RealmDatabaseManager.character_inventory_update_item(item.item_instance)
else:
world_session.player_mgr.inventory.mark_as_removed(item)
world_session.enqueue_packet(item.get_destroy_packet())
world_session.player_mgr.inventory.containers[container_slot].remove_item_in_slot(slot)
RealmDatabaseManager.character_inventory_delete(item.item_instance)
world_session.player_mgr.mod_money(price * sell_amount, reload_items=True)
return 0
def modify_reputation(self, faction, amount):
if faction.index not in self.reputations:
return
self.reputations[faction.index].standing += amount
RealmDatabaseManager.character_update_reputation(
self.reputations[faction.index])
# Notify the client
data = pack('<3i', 0x1, faction.index,
self.reputations[faction.index].standing)
packet = PacketWriter.get_packet(OpCode.SMSG_SET_FACTION_STANDING,
data)
self.player_mgr.session.enqueue_packet(packet)
def generate_item(item_template, owner, bag, slot, creator=0, count=1):
if item_template and item_template.entry > 0:
item = CharacterInventory(owner=owner,
creator=creator,
item_template=item_template.entry,
stackcount=count,
slot=slot,
bag=bag)
RealmDatabaseManager.character_inventory_add_item(item)
item_mgr = ItemManager(item_template=item_template,
item_instance=item)
return item_mgr
return None
def load_guild_members(self):
members = RealmDatabaseManager.guild_get_members(self.guild)
for member in members:
self.members[member.guid] = member
if member.rank == 0:
self.guild_master = member
# Destroy guilds that for some reason have 0 members.
if not self.has_members(ignore_gm=False):
RealmDatabaseManager.guild_destroy(self.guild)
return False
return True
def try_add_member(self, player_mgr, invite):
# Check if we have space.
if self.is_full():
GroupManager.send_group_operation_result(
player_mgr, PartyOperations.PARTY_OP_INVITE, '',
PartyResults.ERR_GROUP_FULL)
return False
if invite:
self.invites[player_mgr.guid] = player_mgr
player_mgr.group_manager = self
player_mgr.has_pending_group_invite = True
return True
else:
if len(self.members
) == 0: # Party just formed, store the group and params.
leader_player = WorldSessionStateHandler.find_player_by_guid(
self.group.leader_guid)
if leader_player: # If online, we set leader group status.
RealmDatabaseManager.group_create(self.group)
GroupManager.GROUPS[self.group.group_id] = self
leader = GroupManager._create_new_member(
self.group, leader_player)
RealmDatabaseManager.group_add_member(leader)
self.members[self.group.leader_guid] = leader
leader_player.group_status = WhoPartyStatus.WHO_PARTY_STATUS_IN_PARTY
GroupManager._set_leader_flag(leader)
else: # Leader went offline after sending the invite.
return False
new_member = GroupManager._create_new_member(
self.group, player_mgr)
new_member = RealmDatabaseManager.group_add_member(new_member)
self.members[player_mgr.guid] = new_member
# Update newly added member group_manager ref, party status and pending invite flag.
player_mgr.group_manager = self
player_mgr.group_status = WhoPartyStatus.WHO_PARTY_STATUS_IN_PARTY
player_mgr.has_pending_group_invite = False
query_details_packet = NameQueryHandler.get_query_details(
player_mgr.player)
self.send_packet_to_members(query_details_packet)
if len(self.members) > 1:
self.send_update()
self.send_party_members_stats()
return True
def handle_add_quest(self, quest_id, quest_giver_guid):
active_quest = ActiveQuest(self.create_db_quest_status(quest_id))
self.active_quests[quest_id] = active_quest
self.send_quest_query_response(active_quest)
if self.can_complete_quest(active_quest):
self.complete_quest(active_quest)
self.update_surrounding_quest_status()
self.build_update()
self.player_mgr.send_update_self()
RealmDatabaseManager.character_add_quest_status(
active_quest.quest_db_status)
def load_guild_members(self):
members = RealmDatabaseManager.guild_get_members(self.guild)
for member in members:
self.members[member.guid] = member
if member.rank == 0:
self.guild_master = member
def handle(world_session, socket, reader):
if len(reader.data
) >= 8: # Avoid handling empty group uninvite guid packet
guid = unpack('<Q', reader.data[:8])[0]
target_player_mgr = RealmDatabaseManager.character_get_by_guid(
guid)
if not world_session.player_mgr.group_manager:
GroupManager.send_group_operation_result(
world_session.player_mgr, PartyOperations.PARTY_OP_LEAVE,
'', PartyResults.ERR_NOT_IN_GROUP)
elif not target_player_mgr:
GroupManager.send_group_operation_result(
world_session.player_mgr, PartyOperations.PARTY_OP_LEAVE,
'Player', PartyResults.ERR_BAD_PLAYER_NAME_S)
elif not world_session.player_mgr.group_manager.is_party_member(
target_player_mgr.guid):
GroupManager.send_group_operation_result(
world_session.player_mgr, PartyOperations.PARTY_OP_LEAVE,
target_player_mgr.name,
PartyResults.ERR_TARGET_NOT_IN_YOUR_GROUP_S)
else:
world_session.player_mgr.group_manager.un_invite_player(
world_session.player_mgr.guid, target_player_mgr.guid)
return 0
def add_new_member(self, player_mgr, is_guild_master=False):
rank = GuildRank.GUILDRANK_GUILD_MASTER if is_guild_master else GuildRank.GUILDRANK_INITIATE
guild_member = self._create_new_member(player_mgr.guid, rank)
player_mgr.guild_manager = self
self.members[player_mgr.guid] = guild_member
data = pack('<2B', GuildEvents.GUILD_EVENT_JOINED, 1)
name_bytes = PacketWriter.string_to_bytes(player_mgr.player.name)
data += pack(f'<{len(name_bytes)}s', name_bytes)
self.build_update(player_mgr)
packet = PacketWriter.get_packet(OpCode.SMSG_GUILD_EVENT, data)
self.send_message_to_guild(packet, GuildChatMessageTypes.G_MSGTYPE_ALL)
RealmDatabaseManager.character_update(player_mgr.player)
def handle(world_session, socket, reader):
target_name = PacketReader.read_string(reader.data, 0).strip()
online_player = WorldSessionStateHandler.find_player_by_name(
target_name)
offline_player = None
friend_result_error = None
# Try to pull the character from DB.
if not online_player:
offline_player = RealmDatabaseManager.character_get_by_name(
target_name)
target_guid = online_player.guid if online_player else offline_player.guid if offline_player else None
target_team = online_player.team if online_player else PlayerManager.get_team_for_race(
offline_player.race) if offline_player else None
if not online_player and not offline_player:
friend_result_error = FriendResults.FRIEND_NOT_FOUND
elif world_session.player_mgr.team != target_team:
friend_result_error = FriendResults.FRIEND_ENEMY
elif world_session.player_mgr.guid == target_guid:
friend_result_error = FriendResults.FRIEND_SELF
elif world_session.player_mgr.friends_manager.has_friend(target_guid):
friend_result_error = FriendResults.FRIEND_ALREADY
if not friend_result_error:
world_session.player_mgr.friends_manager.add_friend(target_guid)
else:
data = pack('<B', friend_result_error)
world_session.enqueue_packet(
PacketWriter.get_packet(OpCode.SMSG_FRIEND_STATUS, data))
return 0
def handle(world_session, socket, reader):
player = world_session.player_mgr
if not player.guild_manager:
GuildManager.send_guild_command_result(
player, GuildTypeCommand.GUILD_CREATE_S, '',
GuildCommandResults.GUILD_PLAYER_NOT_IN_GUILD)
else:
guild_name = PacketWriter.string_to_bytes(
player.guild_manager.guild.name)
data = pack(f'<{len(guild_name)}s', guild_name)
# Members count
data += pack('<I', len(player.guild_manager.members))
accounts = RealmDatabaseManager.guild_get_accounts(
guild_id=player.guild_manager.guild.guild_id)
data += pack('<I', len(accounts))
for member in player.guild_manager.members.values():
player_name = PacketWriter.string_to_bytes(
member.character.name)
data += pack(f'<{len(player_name)}sI', player_name,
member.rank)
player.enqueue_packet(
PacketWriter.get_packet(OpCode.SMSG_GUILD_ROSTER, data))
return 0
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
def handle(world_session, socket, reader):
if len(reader.data) > 1: # Avoid handling empty Guild Demote packet.
target_name = PacketReader.read_string(reader.data, 0).strip()
target_player_mgr = RealmDatabaseManager.character_get_by_name(
target_name)
player_mgr = world_session.player_mgr
if not player_mgr.guild_manager:
GuildManager.send_guild_command_result(
player_mgr, GuildTypeCommand.GUILD_INVITE_S, '',
GuildCommandResults.GUILD_PLAYER_NOT_IN_GUILD)
elif player_mgr.guild_manager.get_rank(
player_mgr.guid) > GuildRank.GUILDRANK_OFFICER:
GuildManager.send_guild_command_result(
player_mgr, GuildTypeCommand.GUILD_INVITE_S, '',
GuildCommandResults.GUILD_PERMISSIONS)
elif not target_player_mgr:
GuildManager.send_guild_command_result(
player_mgr, GuildTypeCommand.GUILD_INVITE_S, target_name,
GuildCommandResults.GUILD_PLAYER_NOT_FOUND)
elif not player_mgr.guild_manager.has_member(
target_player_mgr.guid):
GuildManager.send_guild_command_result(
player_mgr, GuildTypeCommand.GUILD_INVITE_S, target_name,
GuildCommandResults.GUILD_PLAYER_NOT_IN_GUILD)
elif not player_mgr.guild_manager.demote_rank(
target_player_mgr.guid):
GuildManager.send_guild_command_result(
player_mgr, GuildTypeCommand.GUILD_INVITE_S, '',
GuildCommandResults.GUILD_INTERNAL)
return 0
def handle(world_session, socket, reader):
if len(reader.data
) > 1: # Avoid handling empty Group Set Leader packet.
target_name = PacketReader.read_string(reader.data, 0).strip()
target_player_mgr = RealmDatabaseManager.character_get_by_name(
target_name)
if not world_session.player_mgr.group_manager:
GroupManager.send_group_operation_result(
world_session.player_mgr, PartyOperations.PARTY_OP_LEAVE,
'', PartyResults.ERR_NOT_IN_GROUP)
elif not target_player_mgr:
GroupManager.send_group_operation_result(
world_session.player_mgr, PartyOperations.PARTY_OP_LEAVE,
target_name, PartyResults.ERR_BAD_PLAYER_NAME_S)
elif not world_session.player_mgr.group_manager.is_party_member(
target_player_mgr.guid):
GroupManager.send_group_operation_result(
world_session.player_mgr, PartyOperations.PARTY_OP_LEAVE,
target_name, PartyResults.ERR_TARGET_NOT_IN_YOUR_GROUP_S)
else:
world_session.player_mgr.group_manager.set_party_leader(
world_session.player_mgr.guid, target_player_mgr.guid)
return 0
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 handle(world_session, socket, reader):
if len(reader.data
) >= 12: # Avoid handling empty group loot method packet.
loot_method, loot_master = unpack('<IQ', reader.data[:12])
target_player_mgr = None
if not world_session.player_mgr.group_manager:
GroupManager.send_group_operation_result(
world_session.player_mgr, PartyOperations.PARTY_OP_LEAVE,
'', PartyResults.ERR_NOT_IN_GROUP)
if world_session.player_mgr.guid != world_session.player_mgr.group_manager.group.leader_guid:
GroupManager.send_group_operation_result(
world_session.player_mgr, PartyOperations.PARTY_OP_INVITE,
'', PartyResults.ERR_NOT_LEADER)
if loot_master > 0:
target_player_mgr = RealmDatabaseManager.character_get_by_guid(
loot_master)
if target_player_mgr:
world_session.player_mgr.group_manager.set_loot_method(
loot_method, master_looter_guid=target_player_mgr.guid)
else:
world_session.player_mgr.group_manager.set_loot_method(
loot_method)
return 0
def load_items(self):
# Add backpack
self.containers[InventorySlots.SLOT_INBACKPACK] = ContainerManager(
is_backpack=True, owner=self.owner.guid)
character_inventory = RealmDatabaseManager.character_get_inventory(
self.owner.guid)
# First load bags
for item_instance in character_inventory:
item_template = WorldDatabaseManager.item_template_get_by_entry(
item_instance.item_template)
if item_template and item_template.inventory_type == InventoryTypes.BAG:
container_mgr = ContainerManager(owner=self.owner.guid,
item_template=item_template,
item_instance=item_instance)
if self.is_bag_pos(container_mgr.current_slot):
self.containers[item_instance.bag].sorted_slots[
container_mgr.current_slot] = container_mgr
self.containers[container_mgr.current_slot] = container_mgr
# Then load items
for item_instance in character_inventory:
item_template = WorldDatabaseManager.item_template_get_by_entry(
item_instance.item_template)
if item_template:
item_mgr = ItemManager(item_template=item_template,
item_instance=item_instance)
if item_mgr.is_container() and self.is_bag_pos(
item_mgr.current_slot):
continue
if item_instance.bag in self.containers:
self.containers[item_instance.bag].sorted_slots[
item_mgr.current_slot] = item_mgr
def goplayer(world_session, args):
player_name = args
is_online = True
player = WorldSessionStateHandler.find_player_by_name(player_name)
player_location = None
map_ = 0
if player:
player_location = player.location
map_ = player.map_
else:
is_online = False
player = RealmDatabaseManager.character_get_by_name(player_name)
if player:
if not is_online:
player_location = Vector(float(player.position_x),
float(player.position_y),
float(player.position_z))
map_ = player.map
else:
return -1, 'player not found.'
world_session.player_mgr.teleport(int(map_), player_location)
return 0, 'Teleported to player %s (%s).' % (
player_name.capitalize(), 'Online' if is_online else 'Offline')
def load_petition(player_mgr):
petition = RealmDatabaseManager.guild_petition_get_by_owner(
player_mgr.guid)
if petition:
petition_item = player_mgr.inventory.get_first_item_by_entry(
PetitionManager.CHARTER_ENTRY)
if petition_item:
petition_item.set_enchantment(0, petition.petition_id, 0, 0)
def tickets(world_session, args):
tickets = RealmDatabaseManager.ticket_get_all()
for ticket in tickets:
ticket_color = '|cFFFF0000' if ticket.is_bug else '|cFF00FFFF'
ticket_title = 'Bug report' if ticket.is_bug else 'Suggestion'
ticket_text = f'{ticket_color}[{ticket.id}]|r {ticket.submit_time}: {ticket_title} from {ticket.character_name}.'
ChatManager.send_system_message(world_session, ticket_text)
return 0, f'{len(tickets)} tickets shown.'
def send_update_to_friends(self):
have_me_as_friend = RealmDatabaseManager.character_get_friends_of(
self.owner.guid)
for friend in have_me_as_friend:
player_mgr = WorldSessionStateHandler.find_player_by_guid(
friend.guid)
if player_mgr:
player_mgr.friends_manager.send_friends()
def handle(world_session, socket, reader):
if len(reader.data) >= 8: # Avoid handling empty binder activate packet
binder_guid = unpack('<Q', reader.data[:8])[0]
if binder_guid > 0:
world_session.player_mgr.deathbind.creature_binder_guid = binder_guid & ~HighGuid.HIGHGUID_UNIT
world_session.player_mgr.deathbind.deathbind_map = world_session.player_mgr.map_
world_session.player_mgr.deathbind.deathbind_zone = world_session.player_mgr.zone
world_session.player_mgr.deathbind.deathbind_position_x = world_session.player_mgr.location.x
world_session.player_mgr.deathbind.deathbind_position_y = world_session.player_mgr.location.y
world_session.player_mgr.deathbind.deathbind_position_z = world_session.player_mgr.location.z
RealmDatabaseManager.character_update_deathbind(world_session.player_mgr.deathbind)
socket.sendall(world_session.player_mgr.get_deathbind_packet())
data = pack('<Q', binder_guid)
socket.sendall(PacketWriter.get_packet(OpCode.SMSG_PLAYERBOUND, data))
return 0
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()
