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):
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.session.enqueue_packet(PacketWriter.get_packet(OpCode.SMSG_GUILD_ROSTER, data))
return 0
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):
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('<%us' % len(guild_name), guild_name)
# Members count
data += pack('<I', len(player.guild_manager.members))
# TODO: Nº of accounts
data += pack('<I', 0)
for member in player.guild_manager.members.values():
player_name = PacketWriter.string_to_bytes(member.player.name)
data += pack('<%usI' % len(player_name), player_name,
member.guild_manager.get_guild_rank(member))
player.session.request.sendall(
PacketWriter.get_packet(OpCode.SMSG_GUILD_ROSTER, data))
return 0
def send_guild(sender, message, lang, chat_type):
if sender.guild_manager:
sender_packet = ChatManager._get_message_packet(
sender.guid, sender.chat_flags, message, chat_type, lang)
if chat_type == ChatMsgs.CHAT_MSG_GUILD:
sender.guild_manager.send_message_to_guild(
sender_packet,
GuildChatMessageTypes.G_MSGTYPE_ALL,
source=sender)
else:
if sender.guild_manager.get_rank(
sender.guid) > GuildRank.GUILDRANK_OFFICER:
GuildManager.send_guild_command_result(
sender, GuildTypeCommand.GUILD_CREATE_S, '',
GuildCommandResults.GUILD_PERMISSIONS)
else:
sender.guild_manager.send_message_to_guild(
sender_packet,
GuildChatMessageTypes.G_MSGTYPE_OFFICERCHAT,
source=sender)
else:
GuildManager.send_guild_command_result(
sender, GuildTypeCommand.GUILD_CREATE_S, '',
GuildCommandResults.GUILD_PLAYER_NOT_IN_GUILD)
def handle(world_session, socket, reader):
if len(reader.data) > 1: # Avoid handling empty Guild Create packet.
guild_name = PacketReader.read_string(reader.data, 0).strip()
player_mgr = world_session.player_mgr
GuildManager.create_guild(player_mgr, guild_name)
return 0
def load_guilds():
guilds = RealmDatabaseManager.guild_get_all()
length = len(guilds)
count = 0
for guild in guilds:
if guild.name not in GuildManager.GUILDS:
GuildManager.load_guild(guild)
count += 1
Logger.progress('Loading guilds...', count, length)
return length
def handle(world_session, socket, reader):
player_mgr = world_session.player_mgr
if player_mgr.guid in GuildManager.PENDING_INVITES:
inviter = GuildManager.PENDING_INVITES[player_mgr.guid].inviter
GuildManager.PENDING_INVITES.pop(player_mgr.guid)
inviter.guild_manager.add_new_member(player_mgr)
else:
GuildManager.send_guild_command_result(
player_mgr, GuildTypeCommand.GUILD_INVITE_S, '',
GuildCommandResults.GUILD_INTERNAL)
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)
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):
player = world_session.player_mgr
if not player.guild_manager:
GuildManager.send_guild_command_result(
player, GuildTypeCommand.GUILD_INVITE_S, '',
GuildCommandResults.GUILD_PLAYER_NOT_IN_GUILD)
elif player.guild_manager.guild_master == player: # GM should use disband.
GuildManager.send_guild_command_result(
player, GuildTypeCommand.GUILD_INVITE_S, '',
GuildCommandResults.GUILD_INTERNAL)
else:
player.guild_manager.leave(player)
return 0
def handle(world_session, socket, reader):
player_mgr = world_session.player_mgr
if not player_mgr.guild_manager:
GuildManager.send_guild_command_result(
player_mgr, GuildTypeCommand.GUILD_CREATE_S, '',
GuildCommandResults.GUILD_PLAYER_NOT_IN_GUILD)
elif player_mgr != player_mgr.guild_manager.guild_master:
GuildManager.send_guild_command_result(
player_mgr, GuildTypeCommand.GUILD_FOUNDER_S, '',
GuildCommandResults.GUILD_PERMISSIONS)
else:
player_mgr.guild_manager.disband()
return 0
def turn_in_petition(player_mgr, petition_owner, petition):
if petition and petition_owner:
if petition_owner != player_mgr.guid:
PetitionManager.send_petition_sign_result(
player_mgr, PetitionError.PETITION_CHARTER_CREATOR)
elif len(petition.characters) < 9:
PetitionManager.send_petition_sign_result(
player_mgr, PetitionError.PETITION_NOT_ENOUGH_SIGNATURES)
elif player_mgr.guild_manager:
PetitionManager.send_petition_sign_result(
player_mgr, PetitionError.PETITION_ALREADY_IN_GUILD)
else:
# If not able to create a guild, GuildManager will report the error.
if GuildManager.create_guild(player_mgr,
petition.name,
petition=petition):
data = pack('<I', PetitionError.PETITION_SUCCESS)
packet = PacketWriter.get_packet(
OpCode.SMSG_TURN_IN_PETITION_RESULTS, data)
player_mgr.session.enqueue_packet(packet)
player_mgr.inventory.remove_item(
PetitionManager.CHARTER_ENTRY, 1)
RealmDatabaseManager.guild_petition_destroy(petition)
else:
PetitionManager.send_petition_sign_result(
player_mgr, PetitionError.PETITION_UNKNOWN_ERROR)
def handle(world_session, socket, reader):
if reader.data: # Handle null data.
motd = PacketReader.read_string(reader.data, 0).strip()
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)
else:
player_mgr.guild_manager.set_motd(motd)
elif world_session.player_mgr.guild_manager:
world_session.player_mgr.guild_manager.send_motd(world_session.player_mgr)
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
name_bytes = PacketWriter.string_to_bytes(
player.guild_manager.guild_name)
data = pack('<%us' % len(name_bytes), name_bytes)
# TODO: Handle proper data and nº of accounts
# Day, Month, Years, Players, Nº Accounts
data += pack('<5I', 0, 0, 0, len(player.guild_manager.members), 0)
player.session.request.sendall(
PacketWriter.get_packet(OpCode.SMSG_GUILD_INFO, data))
return 0
def handle(world_session, socket, reader):
# TODO: TabardVendor wont allow you to define a new emblem after you have already one. Intended?
if len(reader.data
) >= 20: # Avoid handling empty guild save emblem packet.
style, color, border_style, border_color, background_color = unpack(
'<5I', reader.data[:20])
if not world_session.player_mgr.guild_manager:
GuildManager.send_emblem_result(
world_session.player_mgr,
GuildEmblemResult.ERR_GUILDEMBLEM_NOGUILD)
elif world_session.player_mgr.guild_manager.get_rank(
world_session.player_mgr.guid
) != GuildRank.GUILDRANK_GUILD_MASTER:
GuildManager.send_emblem_result(
world_session.player_mgr,
GuildEmblemResult.ERR_GUILDEMBLEM_NOTGUILDMASTER)
elif world_session.player_mgr.coinage <= EMBLEM_COST:
GuildManager.send_emblem_result(
world_session.player_mgr,
GuildEmblemResult.ERR_GUILDEMBLEM_NOTENOUGHMONEY)
else:
world_session.player_mgr.guild_manager.modify_emblem(
world_session.player_mgr, style, color, border_style,
border_color, background_color)
world_session.player_mgr.mod_money(-EMBLEM_COST)
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
name_bytes = PacketWriter.string_to_bytes(
player.guild_manager.guild.name)
data = pack(f'<{len(name_bytes)}s', name_bytes)
accounts = RealmDatabaseManager.guild_get_accounts(
guild_id=player.guild_manager.guild.guild_id)
# TODO: Parse DB DT.
# Day, Month, Years, Players, Nº Accounts
data += pack('<5I', 0, 0, 0, len(player.guild_manager.members),
len(accounts))
player.session.enqueue_packet(
PacketWriter.get_packet(OpCode.SMSG_GUILD_INFO, data))
return 0
def handle(world_session, socket, reader):
if len(reader.data) >= 28: # Avoid handling empty petition buy packet.
npc_guid = unpack('<Q', reader.data[:8])[0]
guild_name = PacketReader.read_string(reader.data, 20)
if npc_guid > 0:
if world_session.player_mgr.guild_manager:
GuildManager.send_guild_command_result(
world_session.player_mgr,
GuildTypeCommand.GUILD_CREATE_S, '',
GuildCommandResults.GUILD_ALREADY_IN_GUILD)
elif not TextChecker.valid_text(guild_name, is_guild=True):
GuildManager.send_guild_command_result(
world_session.player_mgr,
GuildTypeCommand.GUILD_CREATE_S, '',
GuildCommandResults.GUILD_NAME_INVALID)
elif guild_name in GuildManager.GUILDS or RealmDatabaseManager.guild_petition_get_by_name(
guild_name):
GuildManager.send_guild_command_result(
world_session.player_mgr,
GuildTypeCommand.GUILD_CREATE_S, guild_name,
GuildCommandResults.GUILD_NAME_EXISTS)
elif world_session.player_mgr.inventory.get_item_count(
PetitionManager.CHARTER_ENTRY) > 0:
world_session.player_mgr.inventory.send_buy_error(
BuyResults.BUY_ERR_CANT_CARRY_MORE,
PetitionManager.CHARTER_ENTRY, npc_guid)
elif world_session.player_mgr.coinage <= PetitionManager.CHARTER_COST:
world_session.player_mgr.inventory.send_buy_error(
BuyResults.BUY_ERR_NOT_ENOUGH_MONEY,
PetitionManager.CHARTER_ENTRY, npc_guid)
elif world_session.player_mgr.inventory.add_item(
PetitionManager.CHARTER_ENTRY, handle_error=False):
petition_item = world_session.player_mgr.inventory.get_first_item_by_entry(
PetitionManager.CHARTER_ENTRY)
petition = PetitionManager.create_petition(
world_session.player_mgr.guid, guild_name,
petition_item.guid)
# We bind this petition to the charter guild item, else its just a dummy item for the client.
petition_item.set_enchantment(0, petition.petition_id, 0,
0)
world_session.player_mgr.mod_money(
-PetitionManager.CHARTER_COST, reload_items=True)
return 0
def handle(world_session, socket, reader):
if len(reader.data
) >= 16: # Avoid handling empty petition offer packet.
petition_item_guid, target_player_guid = unpack(
'<2Q', reader.data[:16])
target_player_mgr = WorldSessionStateHandler.find_player_by_guid(
target_player_guid)
if petition_item_guid > 0:
if not target_player_mgr:
GuildManager.send_guild_command_result(
world_session.player_mgr,
GuildTypeCommand.GUILD_INVITE_S, 'Player',
GuildCommandResults.GUILD_PLAYER_NOT_FOUND)
elif target_player_mgr.guild_manager:
GuildManager.send_guild_command_result(
world_session.player_mgr,
GuildTypeCommand.GUILD_INVITE_S,
target_player_mgr.player.name,
GuildCommandResults.GUILD_ALREADY_IN_GUILD)
if target_player_mgr.team != world_session.player_mgr.team:
GuildManager.send_guild_command_result(
world_session.player_mgr,
GuildTypeCommand.GUILD_INVITE_S, '',
GuildCommandResults.GUILD_NOT_ALLIED)
else:
petition = PetitionManager.get_petition(petition_item_guid)
if petition:
packet = PetitionManager.build_signatures_packet(
petition)
target_player_mgr.session.enqueue_packet(packet)
else:
PetitionManager.send_petition_sign_result(
world_session.player_mgr,
PetitionError.PETITION_UNKNOWN_ERROR)
return 0
def __init__(
self,
player=None,
session=None,
num_inv_slots=0x89, # Paperdoll + Bag slots + Bag space
player_bytes=0, # skin, face, hair style, hair color
xp=0,
next_level_xp=0,
player_bytes_2=0, # player flags, facial hair, bank slots, 0
block_percentage=0,
dodge_percentage=0,
parry_percentage=0,
base_hp=0,
base_mana=0,
combo_points=0,
chat_flags=0,
is_online=False,
current_selection=0,
deathbind=None,
**kwargs):
super().__init__(**kwargs)
self.session = session
self.is_teleporting = False
self.objects_in_range = dict()
self.player = player
self.is_online = is_online
self.num_inv_slots = num_inv_slots
self.xp = xp
self.next_level_xp = next_level_xp
self.block_percentage = block_percentage
self.dodge_percentage = dodge_percentage
self.parry_percentage = parry_percentage
self.base_hp = base_hp
self.base_mana = base_mana
self.combo_points = combo_points
self.current_selection = current_selection
self.chat_flags = chat_flags
self.group_status = WhoPartyStatuses.WHO_PARTY_STATUS_NOT_IN_PARTY
self.race_mask = 0
self.class_mask = 0
self.deathbind = deathbind
self.team = PlayerManager.get_team_for_race(self.race_mask)
self.trade_data = None
self.last_regen = 0
self.spirit_release_timer = 0
self.dirty_inventory = False
self.pending_taxi_destination = None
if self.player:
self.set_player_variables()
self.guid = self.player.guid | HighGuid.HIGHGUID_PLAYER
self.inventory = InventoryManager(self)
self.level = self.player.level
self.bytes_0 = unpack(
'<I',
pack('<4B', self.player.race, self.player.class_,
self.player.gender, self.power_type))[0]
self.bytes_1 = unpack(
'<I',
pack('<4B', self.stand_state, 0, self.shapeshift_form,
self.sheath_state))[0]
self.bytes_2 = unpack('<I', pack('<4B', self.combo_points, 0, 0,
0))[0]
self.player_bytes = unpack(
'<I',
pack('<4B', self.player.skin, self.player.face,
self.player.hairstyle, self.player.haircolour))[0]
self.player_bytes_2 = unpack(
'<I',
pack('<4B', self.player.extra_flags, self.player.facialhair,
self.player.bankslots, 0))[0]
self.xp = player.xp
self.talent_points = self.player.talentpoints
self.skill_points = self.player.skillpoints
self.map_ = self.player.map
self.zone = self.player.zone
self.location.x = self.player.position_x
self.location.y = self.player.position_y
self.location.z = self.player.position_z
self.location.o = self.player.orientation
self.health = self.player.health
self.max_health = self.player.health
self.max_power_1 = self.player.power1
self.power_1 = self.player.power1
self.max_power_2 = 1000
self.power_2 = self.player.power2
self.max_power_3 = 100
self.power_3 = self.player.power3
self.max_power_4 = 100
self.power_4 = self.player.power4
self.coinage = self.player.money
self.is_gm = self.session.account_mgr.account.gmlevel > 0
if self.is_gm:
self.set_gm()
self.object_type.append(ObjectTypes.TYPE_PLAYER)
self.update_packet_factory.init_values(PlayerFields.PLAYER_END)
self.next_level_xp = Formulas.PlayerFormulas.xp_to_level(
self.level)
self.is_alive = self.health > 0
self.guild_manager = GuildManager()
self.stat_manager = StatManager(self)
self.talent_manager = TalentManager(self)
self.skill_manager = SkillManager(self)
self.spell_manager = SpellManager(self)
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):
guild_name = PacketReader.read_string(reader.data, 0).strip()
player_mgr = world_session.player_mgr
GuildManager.create_guild(player_mgr, guild_name)
return 0
def guildcreate(world_session, args):
GuildManager.create_guild(world_session.player_mgr, args)
return 0, ''
def handle(world_session, socket, reader):
if len(reader.data) < 8: # Avoid handling wrong player login packet.
return -1
guid = unpack('<Q', reader.data[:8])[0]
world_session.player_mgr = PlayerManager(
RealmDatabaseManager.character_get_by_guid(guid), world_session)
world_session.player_mgr.session = world_session
if not world_session.player_mgr.player:
Logger.anticheat(
f'Character with wrong guid ({guid}) tried to login.')
return -1
else:
WorldSessionStateHandler.push_active_player_session(world_session)
# Disabled race & class checks (only if not a GM)
if not world_session.player_mgr.is_gm:
disabled_race_mask = config.Server.General.disabled_race_mask
disabled = disabled_race_mask & world_session.player_mgr.race_mask == world_session.player_mgr.race_mask
if not disabled:
disabled_class_mask = config.Server.General.disabled_class_mask
disabled = disabled_class_mask & world_session.player_mgr.class_mask == world_session.player_mgr.class_mask
if disabled:
# Not 100% sure if CHAR_LOGIN_DISABLED matters here, but I don't know where else to send it
data = pack('<B', CharLogin.CHAR_LOGIN_DISABLED)
world_session.enqueue_packet(
PacketWriter.get_packet(OpCode.SMSG_CHARACTER_LOGIN_FAILED,
data))
return 0
# Class & race allowed, continue with the login process
world_session.enqueue_packet(
PacketWriter.get_packet(OpCode.SMSG_LOGIN_SETTIMESPEED,
PlayerLoginHandler._get_login_timespeed()))
world_session.player_mgr.skill_manager.load_proficiencies()
world_session.player_mgr.spell_manager.load_spells()
world_session.player_mgr.deathbind = RealmDatabaseManager.character_get_deathbind(
world_session.player_mgr.guid)
world_session.player_mgr.friends_manager.load_from_db(
RealmDatabaseManager.character_get_social(
world_session.player_mgr.guid))
world_session.enqueue_packet(
world_session.player_mgr.get_deathbind_packet())
# Tutorials aren't implemented in 0.5.3
# world_session.enqueue_packet(world_session.player_mgr.get_tutorial_packet())
world_session.player_mgr.skill_manager.init_proficiencies()
world_session.enqueue_packet(
world_session.player_mgr.spell_manager.get_initial_spells())
world_session.enqueue_packet(
world_session.player_mgr.get_action_buttons())
# MotD
ChatManager.send_system_message(world_session,
config.Server.General.motd)
world_session.player_mgr.inventory.load_items()
world_session.player_mgr.stat_manager.init_stats()
world_session.player_mgr.stat_manager.apply_bonuses()
world_session.player_mgr.skill_manager.load_skills()
world_session.player_mgr.quest_manager.load_quests()
world_session.player_mgr.reputation_manager.load_reputations()
GuildManager.set_character_guild(world_session.player_mgr)
GroupManager.set_character_group(world_session.player_mgr)
PetitionManager.load_petition(world_session.player_mgr)
# First login
if world_session.player_mgr.player.totaltime == 0:
# Replenish health, and mana if needed.
world_session.player_mgr.set_health(
world_session.player_mgr.max_health)
if world_session.player_mgr.power_type == PowerTypes.TYPE_MANA:
world_session.player_mgr.set_mana(
world_session.player_mgr.max_power_1)
# Load self before sending cinematic
PlayerLoginHandler._load_self(world_session.player_mgr)
# Send cinematic
PlayerLoginHandler._send_cinematic(world_session,
world_session.player_mgr.player,
socket)
else:
PlayerLoginHandler._load_self(world_session.player_mgr)
world_session.player_mgr.complete_login()
return 0
def __init__(
self,
player=None,
session=None,
num_inv_slots=0x89, # Paperdoll + Bag slots + Bag space
player_bytes=0, # skin, face, hair style, hair color
xp=0,
next_level_xp=0,
player_bytes_2=0, # player flags, facial hair, bank slots, 0
talent_points=0,
skill_points=0,
block_percentage=0,
dodge_percentage=0,
parry_percentage=0,
base_mana=0,
sheath_state=0,
combo_points=0,
chat_flags=0,
is_online=False,
current_target=0,
current_selection=0,
deathbind=None,
**kwargs):
super().__init__(**kwargs)
self.update_packet_factory = UpdatePacketFactory([
ObjectTypes.TYPE_OBJECT, ObjectTypes.TYPE_UNIT,
ObjectTypes.TYPE_PLAYER
])
self.session = session
self.flagged_for_update = False
self.is_teleporting = False
self.objects_in_range = dict()
self.player = player
self.is_online = is_online
self.num_inv_slots = num_inv_slots
self.xp = xp
self.next_level_xp = next_level_xp
self.talent_points = talent_points
self.skill_points = skill_points
self.block_percentage = block_percentage
self.dodge_percentage = dodge_percentage
self.parry_percentage = parry_percentage
self.base_mana = base_mana
self.sheath_state = sheath_state
self.combo_points = combo_points
self.current_target = current_target
self.current_selection = current_selection
self.chat_flags = chat_flags
self.group_status = WhoPartyStatuses.WHO_PARTY_STATUS_NOT_IN_PARTY
self.race_mask = 0
self.class_mask = 0
self.spells = []
self.skills = []
self.deathbind = deathbind
if self.player:
self.set_player_variables()
self.guid = self.player.guid | HighGuid.HIGHGUID_PLAYER
self.inventory = InventoryManager(self)
self.level = self.player.level
self.object_type.append(ObjectTypes.TYPE_PLAYER)
self.bytes_0 = unpack(
'<I',
pack('<4B', self.player.race, self.player.class_,
self.player.gender, self.power_type))[0]
self.bytes_1 = unpack(
'<I',
pack('<4B', self.stand_state, 0, self.shapeshift_form,
self.sheath_state))[0]
self.bytes_2 = unpack('<I', pack('<4B', self.combo_points, 0, 0,
0))[0]
self.player_bytes = unpack(
'<I',
pack('<4B', self.player.skin, self.player.face,
self.player.hairstyle, self.player.haircolour))[0]
self.player_bytes_2 = unpack(
'<I',
pack('<4B', self.player.extra_flags, self.player.facialhair,
self.player.bankslots, 0))[0]
self.map_ = self.player.map
self.zone = self.player.zone
self.location.x = self.player.position_x
self.location.y = self.player.position_y
self.location.z = self.player.position_z
self.location.o = self.player.orientation
self.health = self.player.health
self.max_health = self.player.health
self.max_power_1 = self.player.power1
self.power_1 = self.player.power1
self.max_power_2 = 1000
self.power_2 = self.player.power2
self.max_power_3 = self.player.power3
self.power_3 = self.player.power3
self.max_power_4 = self.player.power4
self.power_4 = self.player.power4
self.coinage = self.player.money
self.is_gm = self.session.account_mgr.account.gmlevel > 0
if self.is_gm:
self.set_gm()
# test
self.xp = 0
self.next_level_xp = 200
self.guild_manager = GuildManager()
