def summon(world_session, args):
player_name = args
is_online = True
player = WorldSessionStateHandler.find_player_by_name(player_name)
if player:
player.teleport(world_session.player_mgr.map_,
world_session.player_mgr.location)
else:
is_online = False
player = RealmDatabaseManager.character_get_by_name(player_name)
if player:
if not is_online:
player.map = world_session.player_mgr.map_
player.zone = world_session.player_mgr.zone
player.position_x = world_session.player_mgr.location.x
player.position_y = world_session.player_mgr.location.y
player.position_z = world_session.player_mgr.location.z
RealmDatabaseManager.character_update(player)
else:
return -1, 'player not found.'
return 0, 'Summoned player %s (%s).' % (
player_name.capitalize(), 'Online' if is_online else 'Offline')
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 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 handle(world_session, socket, reader):
target_name = PacketReader.read_string(reader.data, 0).strip()
target_player_mgr = WorldSessionStateHandler.find_player_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)
if not target_player_mgr:
GuildManager.send_guild_command_result(
player_mgr, GuildTypeCommand.GUILD_INVITE_S, target_name,
GuildCommandResults.GUILD_PLAYER_NOT_FOUND)
elif player_mgr != player_mgr.guild_manager.guild_master:
GuildManager.send_guild_command_result(
player_mgr, GuildTypeCommand.GUILD_FOUNDER_S, '',
GuildCommandResults.GUILD_PERMISSIONS)
elif not target_player_mgr.guild_manager or not player_mgr.guild_manager.is_member(
target_player_mgr):
GuildManager.send_guild_command_result(
player_mgr, GuildTypeCommand.GUILD_INVITE_S, target_name,
GuildCommandResults.GUILD_PLAYER_NOT_IN_GUILD)
else:
player_mgr.guild_manager.set_guild_master(target_player_mgr)
return 0
def handle(world_session, socket, reader):
target_name = PacketReader.read_string(reader.data, 0).strip()
target_player_mgr = WorldSessionStateHandler.find_player_by_name(
target_name)
friend_result = None
if not target_player_mgr:
friend_result = FriendResults.FRIEND_NOT_FOUND
elif world_session.player_mgr.team != target_player_mgr.team:
friend_result = FriendResults.FRIEND_ENEMY
elif world_session.player_mgr.guid == target_player_mgr.guid:
friend_result = FriendResults.FRIEND_SELF
elif world_session.player_mgr.friends_manager.has_friend(
target_player_mgr):
friend_result = FriendResults.FRIEND_ALREADY
if not friend_result:
world_session.player_mgr.friends_manager.add_friend(
target_player_mgr)
else:
data = pack('<B', friend_result)
world_session.player_mgr.session.request.sendall(
PacketWriter.get_packet(OpCode.SMSG_FRIEND_STATUS, data))
return 0
def handle(world_session, socket, reader):
target_name = PacketReader.read_string(reader.data, 0).strip()
target_player_mgr = WorldSessionStateHandler.find_player_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)
# TODO I guess not only GM should be able to promote?
elif player_mgr != player_mgr.guild_manager.guild_master:
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.is_member(target_player_mgr):
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.promote_rank(target_player_mgr):
GuildManager.send_guild_command_result(
player_mgr, GuildTypeCommand.GUILD_INVITE_S, '',
GuildCommandResults.GUILD_INTERNAL)
return 0
def handle(world_session, socket, reader):
chat_type, lang = unpack('<2I', reader.data[:8])
message = ''
guid = 0
chat_flags = 0
# Return if no player
if not world_session.player_mgr:
return 0
# Override language to universal for GMs
if world_session.player_mgr.is_gm:
lang = Languages.LANG_UNIVERSAL
# Say, Yell, Emote
if chat_type == ChatMsgs.CHAT_MSG_SAY \
or chat_type == ChatMsgs.CHAT_MSG_EMOTE \
or chat_type == ChatMsgs.CHAT_MSG_YELL:
message = PacketReader.read_string(reader.data, 8)
guid = world_session.player_mgr.guid
chat_flags = world_session.player_mgr.chat_flags
# Only send message if it's not a command
if not ChatHandler.check_if_command(world_session, message):
ChatManager.send_chat_message(
world_session, guid, chat_flags, message, chat_type, lang,
ChatHandler.get_range_by_type(chat_type))
# Whisper
elif chat_type == ChatMsgs.CHAT_MSG_WHISPER:
target_name = PacketReader.read_string(reader.data, 8).strip()
target_player_mgr = WorldSessionStateHandler.find_player_by_name(
target_name)
if not target_player_mgr:
ChatManager.send_system_message(
world_session,
'No player named \'%s\' is currently playing.' %
target_name.capitalize())
return 0
message = PacketReader.read_string(reader.data,
8 + len(target_name) + 1)
if not ChatHandler.check_if_command(world_session, message):
# Always whisper in universal language when speaking with a GM
if target_player_mgr.is_gm:
lang = Languages.LANG_UNIVERSAL
ChatManager.send_whisper(world_session.player_mgr,
target_player_mgr, message, lang)
return 0
# Party
elif chat_type == ChatMsgs.CHAT_MSG_PARTY:
message = PacketReader.read_string(reader.data, 8)
ChatManager.send_party(world_session.player_mgr, message, lang)
return 0
# Guild
elif chat_type == ChatMsgs.CHAT_MSG_GUILD:
# TODO: Implement
return 0
return 0
def handle(world_session, socket, reader):
target_name = PacketReader.read_string(reader.data, 0).strip()
target_player_mgr = WorldSessionStateHandler.find_player_by_name(target_name)
if target_player_mgr:
GroupManager.invite_player(world_session.player_mgr, target_player_mgr)
else:
GroupManager.send_group_operation_result(world_session.player_mgr, PartyOperations.PARTY_OP_INVITE,
target_name, PartyResults.ERR_BAD_PLAYER_NAME_S)
return 0
def handle(world_session, socket, reader):
channel = PacketReader.read_string(reader.data, 0).strip().capitalize()
offset = len(channel) + 1
has_player = len(reader.data) == offset + 1
player_name = '' if has_player else PacketReader.read_string(reader.data, offset, 0).strip()[:-1]
target_player_mgr = WorldSessionStateHandler.find_player_by_name(player_name)
if target_player_mgr:
ChannelManager.kick_player(channel, world_session.player_mgr, target_player_mgr)
else:
ChatManager.send_system_message(world_session, f'No player named [{player_name}] is currently playing.')
return 0
def handle(world_session, socket, reader):
target_name = PacketReader.read_string(reader.data, 0).strip()
target_player_mgr = WorldSessionStateHandler.find_player_by_name(target_name)
if not target_player_mgr:
GroupManager.send_group_operation_result(world_session.player_mgr, PartyOperations.PARTY_OP_LEAVE, '',
PartyResults.ERR_BAD_PLAYER_NAME_S)
elif world_session.player_mgr.group_manager:
world_session.player_mgr.group_manager.un_invite_player(world_session.player_mgr, target_player_mgr)
else:
GroupManager.send_group_operation_result(world_session.player_mgr, PartyOperations.PARTY_OP_LEAVE, '',
PartyResults.ERR_NOT_IN_GROUP)
return 0
def handle(world_session, socket, reader):
if len(reader.data) > 1: # Avoid handling empty Guild Invite packet.
target_name = PacketReader.read_string(reader.data, 0).strip()
target_player_mgr = WorldSessionStateHandler.find_player_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 target_player_mgr.guild_manager:
GuildManager.send_guild_command_result(
player_mgr, GuildTypeCommand.GUILD_INVITE_S, target_name,
GuildCommandResults.GUILD_ALREADY_IN_GUILD)
elif target_player_mgr.team != player_mgr.team:
GuildManager.send_guild_command_result(
player_mgr, GuildTypeCommand.GUILD_INVITE_S, '',
GuildCommandResults.GUILD_NOT_ALLIED)
else:
if player_mgr.guild_manager.invite_member(
player_mgr, target_player_mgr):
GuildManager.send_guild_command_result(
player_mgr, GuildTypeCommand.GUILD_INVITE_S,
target_name, GuildCommandResults.GUILD_U_HAVE_INVITED)
name_bytes = PacketWriter.string_to_bytes(
player_mgr.player.name)
data = pack(f'<{len(name_bytes)}s', name_bytes)
guild_name_bytes = PacketWriter.string_to_bytes(
player_mgr.guild_manager.guild.name)
data += pack(f'<{len(guild_name_bytes)}s',
guild_name_bytes)
target_player_mgr.session.enqueue_packet(
PacketWriter.get_packet(OpCode.SMSG_GUILD_INVITE,
data))
return 0
def handle(world_session, socket, reader):
if len(reader.data) > 1: # Avoid handling empty Group Invite packet.
target_name = PacketReader.read_string(reader.data, 0).strip()
target_player_mgr = WorldSessionStateHandler.find_player_by_name(
target_name)
if world_session.player_mgr.has_pending_group_invite:
GroupManager.send_group_operation_result(
world_session.player_mgr, PartyOperations.PARTY_OP_INVITE,
'', PartyResults.ERR_INVITE_RESTRICTED)
elif world_session.player_mgr.group_manager and world_session.player_mgr.group_manager.is_full(
):
GroupManager.send_group_operation_result(
world_session.player_mgr, PartyOperations.PARTY_OP_INVITE,
'', PartyResults.ERR_GROUP_FULL)
elif not target_player_mgr:
GroupManager.send_group_operation_result(
world_session.player_mgr, PartyOperations.PARTY_OP_INVITE,
target_name, PartyResults.ERR_BAD_PLAYER_NAME_S)
elif target_player_mgr.friends_manager.has_ignore(
world_session.player_mgr.guid):
GroupManager.send_group_operation_result(
world_session.player_mgr, PartyOperations.PARTY_OP_INVITE,
target_name, PartyResults.ERR_IGNORING_YOU_S)
elif target_player_mgr and (
target_player_mgr.has_pending_group_invite
or target_player_mgr.group_manager):
GroupManager.send_group_operation_result(
world_session.player_mgr, PartyOperations.PARTY_OP_INVITE,
target_player_mgr.player.name,
PartyResults.ERR_ALREADY_IN_GROUP_S)
elif target_player_mgr and target_player_mgr.guid == world_session.player_mgr.guid:
GroupManager.send_group_operation_result(
world_session.player_mgr, PartyOperations.PARTY_OP_INVITE,
target_player_mgr.player.name,
PartyResults.ERR_INVITE_RESTRICTED)
else:
GroupManager.invite_player(world_session.player_mgr,
target_player_mgr)
return 0
def handle(world_session, socket, reader):
chat_type, lang = unpack('<2I', reader.data[:8])
message = ''
guid = 0
chat_flags = 0
# Say, Yell, Emote
if chat_type == ChatMsgs.CHAT_MSG_SAY \
or chat_type == ChatMsgs.CHAT_MSG_EMOTE \
or chat_type == ChatMsgs.CHAT_MSG_YELL:
message = PacketReader.read_string(reader.data, 8)
guid = world_session.player_mgr.guid
chat_flags = world_session.player_mgr.chat_flags
# Whisper
elif chat_type == ChatMsgs.CHAT_MSG_WHISPER:
target_name = PacketReader.read_string(reader.data, 8).strip()
target_player_mgr = WorldSessionStateHandler.find_player_by_name(
target_name)
if not target_player_mgr:
ChatManager.send_system_message(
world_session,
'No player named \'%s\' is currently playing.' %
target_name.capitalize())
return 0
message = PacketReader.read_string(reader.data,
8 + len(target_name) + 1)
if not ChatHandler.check_if_command(world_session, message):
ChatManager.send_whisper(world_session.player_mgr,
target_player_mgr, message,
0) # TODO: handle lang
return 0
if not ChatHandler.check_if_command(world_session, message):
ChatManager.send_chat_message(
world_session, guid, chat_flags, message, chat_type, lang,
ChatHandler.get_range_by_type(chat_type))
return 0
