def handle_movement_status(world_session, socket, reader):
movement_fmt = '<QfffffffffI'
try:
transport_guid, transport_x, transport_y, transport_z, transport_o, x, y, z, o, pitch, flags = \
unpack(movement_fmt, reader.data)
movement_data = PacketWriter.get_packet(
OpCode(reader.opcode),
pack(movement_fmt, transport_guid, transport_x, transport_y,
transport_z, transport_o, x, y, z, o, pitch, flags))
socket.sendall(movement_data)
world_session.player_mgr.transport_id = transport_guid
world_session.player_mgr.transport_x = transport_x
world_session.player_mgr.transport_y = transport_y
world_session.player_mgr.transport_z = transport_z
world_session.player_mgr.transport_orientation = transport_o
world_session.player_mgr.location.x = x
world_session.player_mgr.location.y = y
world_session.player_mgr.location.z = z
world_session.player_mgr.orientation = o
world_session.player_mgr.pitch = pitch
world_session.player_mgr.movement_flags = flags
except error:
Logger.error('Error while handling %s, skipping.' %
OpCode(reader.opcode))
return 0
def handle(world_session, socket, reader):
if len(reader.data) >= 8: # Avoid handling empty quest giver status packet.
quest_giver_guid = unpack('<Q', reader.data[:8])[0]
quest_giver = None
# NPC
if quest_giver_guid & HighGuid.HIGHGUID_UNIT:
quest_giver = MapManager.get_surrounding_unit_by_guid(world_session.player_mgr, quest_giver_guid)
# Gameobject
elif quest_giver_guid & HighGuid.HIGHGUID_GAMEOBJECT:
quest_giver = MapManager.get_surrounding_gameobject_by_guid(world_session.player_mgr, quest_giver_guid)
if not quest_giver:
return 0
quest_giver_status = QuestGiverStatus.QUEST_GIVER_NONE
if world_session.player_mgr:
if quest_giver.get_type() == ObjectTypes.TYPE_UNIT:
quest_giver_status = world_session.player_mgr.quest_manager.get_dialog_status(quest_giver)
elif quest_giver.get_type() == ObjectTypes.TYPE_GAMEOBJECT:
# TODO: Proper handling for game object
quest_giver_status = QuestGiverStatus.QUEST_GIVER_NONE
else:
Logger.error(f'Error in CMSG_QUESTGIVER_STATUS_QUERY, quest giver was an unexpected type of: {quest_giver.object_type}')
world_session.player_mgr.quest_manager.send_quest_giver_status(quest_giver_guid, quest_giver_status)
return 0
def handle(world_session, socket, reader):
if len(
reader.data
) >= 12: # Avoid handling empty quest giver request reward 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_REQUEST_REWARD, could not find quest giver with guid: {guid}'
)
return 0
if not is_item and world_session.player_mgr.is_enemy_to(
quest_giver):
return 0
world_session.player_mgr.quest_manager.handle_request_reward(
guid, quest_id)
return 0
async def on_command_error(ctx, error):
if isinstance(error, discord.Forbidden):
pass
elif isinstance(error, commands.CommandNotFound):
pass
elif isinstance(error, commands.BadArgument):
member_not_found = re.match('Member "(.*)" not found', error.args[0])
if member_not_found:
await ctx.send(
f"The requested member `{member_not_found.group(1)}` was not found on this server."
)
elif isinstance(
error,
(commands.MissingRequiredArgument, commands.TooManyArguments)):
await ctx.send(
f"Invalid command usage the proper usage is `{ctx.prefix}{ctx.command.signature}`."
)
elif isinstance(error, commands.CommandOnCooldown):
if ctx.author.id in bot.config["developers"]:
return await ctx.reinvoke()
cooldown_str = f"{error.retry_after:.0f} seconds" if error.retry_after > 1 else f"{error.retry_after:.0f} second"
await ctx.send(f"Ack! This command is on cooldown for {cooldown_str}")
elif isinstance(error, commands.MissingPermissions):
permissions = "\n".join([caps(perm) for perm in error.missing_perms])
await ctx.send(
f"Oh noes, It looks like you are missing the following permissions:\n{permissions}"
)
elif isinstance(error, commands.DisabledCommand):
if ctx.author.id in bot.config["developers"]:
return await ctx.reinvoke()
await ctx.send("Hmm, This command is currently disabled.")
else:
Logger.error(error)
def handle_summon_object(casting_spell, effect, caster, target):
object_entry = effect.misc_value
# Validate go template existence.
go_template = WorldDatabaseManager.gameobject_template_get_by_entry(
object_entry)
if not go_template:
Logger.error(
f'Gameobject with entry {object_entry} not found for spell {casting_spell.spell_entry.ID}.'
)
return
target = None
if isinstance(effect.targets.resolved_targets_a[0], ObjectManager):
target = effect.targets.resolved_targets_a[0].location
elif isinstance(effect.targets.resolved_targets_a[0], Vector):
target = effect.targets.resolved_targets_a[0]
if not target:
Logger.error(
f'Unable to resolve target, go entry {object_entry}, spell {casting_spell.spell_entry.ID}.'
)
return
GameObjectManager.spawn(object_entry,
target,
caster.map_,
summoner=caster,
spell_id=casting_spell.spell_entry.ID,
override_faction=caster.faction)
def handle(world_session, socket, reader):
if len(reader.data
) >= 8: # Avoid handling empty quest giver status packet.
guid = unpack('<Q', reader.data[:8])[0]
high_guid = ObjectManager.extract_high_guid(guid)
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)
if not quest_giver:
Logger.error(
f'Error in CMSG_QUESTGIVER_STATUS_QUERY, could not find quest giver with guid of: {guid}'
)
return 0
# Only units are able to provide quest status.
if world_session.player_mgr and quest_giver.get_type_id(
) == ObjectTypeIds.ID_UNIT:
quest_giver_status = world_session.player_mgr.quest_manager.get_dialog_status(
quest_giver)
world_session.player_mgr.quest_manager.send_quest_giver_status(
guid, quest_giver_status)
return 0
def handle(world_session, socket, reader):
if len(reader.data
) >= 8: # Avoid handling empty quest giver status packet
quest_giver_guid = unpack('<Q', reader.data[:8])[0]
quest_giver = GridManager.get_surrounding_unit_by_guid(
world_session.player_mgr, quest_giver_guid)
quest_giver_status = QuestGiverStatus.QUEST_GIVER_NONE
if not quest_giver:
Logger.error(
"Error in CMSG_QUESTGIVER_STATUS_QUERY, could not find quest giver with guid of: %u"
% quest_giver_guid)
return 0
if world_session.player_mgr:
if quest_giver.get_type() == ObjectTypes.TYPE_UNIT:
quest_giver_status = world_session.player_mgr.quest_manager.get_dialog_status(
quest_giver)
elif quest_giver.get_type() == ObjectTypes.TYPE_GAMEOBJECT:
# TODO: Proper handling for game object, check if this is needed
quest_giver_status = QuestGiverStatus.QUEST_GIVER_NONE
else:
Logger.error(
"Error in CMSG_QUESTGIVER_STATUS_QUERY, quest giver was an unexpected type of: %u"
% quest_giver.object_type)
world_session.player_mgr.quest_manager.send_quest_giver_status(
quest_giver_guid, quest_giver_status)
return 0
def handle(world_session, socket, reader):
if len(reader.data
) >= 8: # Avoid handling empty quest giver hello packet.
guid = unpack('<Q', reader.data[:8])[0]
high_guid = ObjectManager.extract_high_guid(guid)
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)
if not quest_giver:
Logger.error(
f'Error in CMSG_QUESTGIVER_HELLO, could not find quest giver with guid of: {guid}'
)
return 0
if world_session.player_mgr.is_enemy_to(quest_giver):
return 0
# TODO: Stop the npc if it's moving
# TODO: Remove feign death from player (if it even exists in 0.5.3)
# TODO: If the gossip menu is already open, do nothing
if quest_giver.is_within_interactable_distance(
world_session.player_mgr):
world_session.player_mgr.quest_manager.handle_quest_giver_hello(
quest_giver, guid)
return 0
def calculate_z(map_id, x, y, current_z=0.0):
try:
map_tile_x, map_tile_y, tile_local_x, tile_local_y = MapManager.calculate_tile(
x, y, (RESOLUTION_ZMAP - 1))
x_normalized = (RESOLUTION_ZMAP - 1) * (32.0 - (x / SIZE) -
map_tile_x) - tile_local_x
y_normalized = (RESOLUTION_ZMAP - 1) * (32.0 - (y / SIZE) -
map_tile_y) - tile_local_y
if not MapManager._check_tile_load(map_id, x, y, map_tile_x,
map_tile_y):
return current_z if current_z else 0.0
try:
val_1 = MapManager.get_height(map_id, map_tile_x, map_tile_y,
tile_local_x, tile_local_y)
val_2 = MapManager.get_height(map_id, map_tile_x, map_tile_y,
tile_local_x + 1, tile_local_y)
top_height = MapManager._lerp(val_1, val_2, x_normalized)
val_3 = MapManager.get_height(map_id, map_tile_x, map_tile_y,
tile_local_x, tile_local_y + 1)
val_4 = MapManager.get_height(map_id, map_tile_x, map_tile_y,
tile_local_x + 1,
tile_local_y + 1)
bottom_height = MapManager._lerp(val_3, val_4, x_normalized)
return MapManager._lerp(top_height, bottom_height,
y_normalized) # Z
except:
return MAPS[map_id].tiles[map_tile_x][map_tile_y].z_height_map[
tile_local_x][tile_local_x]
except:
Logger.error(traceback.format_exc())
return current_z if current_z else 0.0
def load(self):
filename = f'{self.cell_map:03}{self.cell_x:02}{self.cell_y:02}.map'
maps_path = PathManager.get_map_file_path(filename)
Logger.debug(f'[Maps] Loading map file: {filename}')
if not path.exists(maps_path):
Logger.warning(f'Unable to locate map file: {filename}')
else:
with open(maps_path, "rb") as map_tiles:
version = PacketReader.read_string(map_tiles.read(10), 0)
if version != MapTile.EXPECTED_VERSION:
Logger.error(f'Unexpected map version. Expected "{MapTile.EXPECTED_VERSION}", received "{version}".')
return
# TODO: AreaFlags
# for x in range(0, RESOLUTION_FLAGS + 1):
# for y in range(0, RESOLUTION_FLAGS + 1):
# self.explore_flag[x][y] = unpack('<H', map_tiles.read(2))[0]
#
# TODO: AreaTerrain
# for x in range(0, RESOLUTION_TERRAIN + 1):
# for y in range(0, RESOLUTION_TERRAIN + 1):
# self.area_terrain[x][y] = map_tiles.read(1)[0]
#
# TODO: Liquids
# for x in range(0, RESOLUTION_WATER + 1):
# for y in range(0, RESOLUTION_WATER + 1):
# self.water_level[x][y] = unpack('<f', map_tiles.read(4))[0]
# Height Map
for x in range(0, RESOLUTION_ZMAP + 1):
for y in range(0, RESOLUTION_ZMAP + 1):
self.z_coords[x][y] = unpack('<f', map_tiles.read(4))[0]
def handle(world_session, socket, reader):
guid = unpack('<Q', reader.data)[0]
world_session.player_mgr = PlayerManager(
RealmDatabaseManager.character_get_by_guid(guid))
if not world_session.player_mgr.player:
Logger.error('Character with wrong guid (%u) tried to login.' %
guid)
return -1
socket.sendall(
PacketWriter.get_packet(OpCode.SMSG_LOGIN_SETTIMESPEED,
PlayerLoginHandler._get_login_timespeed()))
socket.sendall(world_session.player_mgr.get_tutorial_packet())
socket.sendall(world_session.player_mgr.get_initial_spells())
socket.sendall(world_session.player_mgr.get_query_details())
# MotD
ChatManager.send_system_message(world_session,
config.Server.General.motd)
socket.sendall(
PacketWriter.get_packet(
OpCode.SMSG_UPDATE_OBJECT,
world_session.player_mgr.create_update_packet(
UpdateTypes.UPDATE_IN_RANGE.value) +
world_session.player_mgr.get_update_packet()))
PlayerLoginHandler.send_cinematic(world_session.player_mgr.player,
socket)
world_session.player_mgr.complete_login()
return 0
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 _allegiance_status_checker(self, target, check_friendly=True):
own_faction = DbcDatabaseManager.FactionTemplateHolder.faction_template_get_by_id(self.faction)
target_faction = DbcDatabaseManager.FactionTemplateHolder.faction_template_get_by_id(target.faction)
if not own_faction:
Logger.error(f'Invalid faction template: {self.faction}.')
return not check_friendly
if not target_faction:
Logger.error(f'Invalid faction template: {target.faction}.')
return not check_friendly
own_enemies = [own_faction.Enemies_1, own_faction.Enemies_2, own_faction.Enemies_3, own_faction.Enemies_4]
own_friends = [own_faction.Friend_1, own_faction.Friend_2, own_faction.Friend_3, own_faction.Friend_4]
if target_faction.Faction > 0:
for enemy in own_enemies:
if enemy == target_faction.Faction:
return not check_friendly
for friend in own_friends:
if friend == target_faction.Faction:
return check_friendly
if check_friendly:
return ((own_faction.FriendGroup & target_faction.FactionGroup) or (own_faction.FactionGroup & target_faction.FriendGroup)) != 0
else:
return ((own_faction.EnemyGroup & target_faction.FactionGroup) or (own_faction.FactionGroup & target_faction.EnemyGroup)) != 0
def handle(world_session, socket, reader):
if len(
reader.data
) >= 12: # Avoid handling empty quest giver complete quest packet.
guid, quest_id = unpack('<QI', reader.data[:12])
high_guid = ObjectManager.extract_high_guid(guid)
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)
if not quest_giver:
Logger.error(
f'Error in CMSG_QUESTGIVER_COMPLETE_QUEST, could not find quest giver with guid of: {guid}'
)
return 0
if world_session.player_mgr.is_enemy_to(quest_giver):
return 0
world_session.player_mgr.quest_manager.handle_complete_quest(
quest_id, guid)
return 0
def load(self):
# Set as initialized to avoid another load() call from another thread.
self.initialized = True
filename = f'{self.cell_map:03}{self.cell_x:02}{self.cell_y:02}.map'
maps_path = PathManager.get_map_file_path(filename)
Logger.debug(
f'[Maps] Loading map file: {filename}, Map:{self.cell_map} Tile:{self.cell_x},{self.cell_y}'
)
if not path.exists(maps_path):
Logger.warning(
f'Unable to locate map file: {filename}, Map:{self.cell_map} Tile:{self.cell_x},{self.cell_y}'
)
return
else:
with open(maps_path, "rb") as map_tiles:
version = PacketReader.read_string(map_tiles.read(10), 0)
if version != MapTile.EXPECTED_VERSION:
Logger.error(
f'Unexpected map version. Expected "{MapTile.EXPECTED_VERSION}", found "{version}".'
)
return
# Height Map
for x in range(RESOLUTION_ZMAP):
for y in range(RESOLUTION_ZMAP):
self.z_height_map[x][y] = unpack(
'<f', map_tiles.read(4))[0]
# ZoneID, AreaNumber, AreaFlags, AreaLevel, AreaExploreFlag(Bit), AreaFactionMask
for x in range(RESOLUTION_AREA_INFO):
for y in range(RESOLUTION_AREA_INFO):
zone_id = unpack('<i', map_tiles.read(4))[0]
if zone_id == -1: # No area information.
continue
area_number = unpack('<I', map_tiles.read(4))[0]
area_flags = unpack('<B', map_tiles.read(1))[0]
area_level = unpack('<B', map_tiles.read(1))[0]
area_explore_bit = unpack('<H', map_tiles.read(2))[0]
area_faction_mask = unpack('<B', map_tiles.read(1))[0]
# noinspection PyTypeChecker
self.area_information[x][y] = AreaInformation(
zone_id, area_number, area_flags, area_level,
area_explore_bit, area_faction_mask)
# Liquids
for x in range(RESOLUTION_LIQUIDS):
for y in range(RESOLUTION_LIQUIDS):
liquid_type = unpack('<b', map_tiles.read(1))[0]
if liquid_type == -1: # No liquid information / not rendered.
continue
height = unpack('<f', map_tiles.read(4))[0]
# noinspection PyTypeChecker
self.liquid_information[x][y] = LiquidInformation(
liquid_type, height)
# This is a valid tile, set as loaded.
self.is_valid = True
def handle_mounted(aura, effect_target, remove): # TODO Summon Nightmare (5784) does not apply for other players ?
if remove:
effect_target.unmount()
return
creature_entry = aura.spell_effect.misc_value
if not effect_target.summon_mount(creature_entry):
Logger.error(f'SPELL_AURA_MOUNTED: Creature template ({creature_entry}) not found in database.')
def get_handler_from_packet(opcode):
try:
opcode_name = OpCode(opcode)
if opcode_name in HANDLER_DEFINITIONS:
return HANDLER_DEFINITIONS.get(OpCode(opcode))
else:
Logger.warning('Received %s OpCode but is not handled.' % opcode_name)
except ValueError:
Logger.error('Received unknown OpCode (%u)' % opcode)
return None
def handle(world_session, socket, reader):
guid = unpack('<Q', reader.data)[0]
res = CharDelete.CHAR_DELETE_SUCCESS.value
if RealmDatabaseManager.character_delete(guid) != 0:
res = CharDelete.CHAR_DELETE_FAILED.value
Logger.error('Error deleting character with guid %s.' % guid)
socket.sendall(
PacketWriter.get_packet(OpCode.SMSG_CHAR_DELETE, pack('<B', res)))
return 0
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 handle(world_session, socket, reader):
if len(reader.data) >= 12: # Avoid handling empty quest giver accept quest packet
quest_giver_guid, quest_id = unpack ('<QI', reader.data[:12])
quest_giver = GridManager.get_surrounding_unit_by_guid(world_session.player_mgr, quest_giver_guid)
if not quest_giver:
Logger.error(f'Error in CMSG_QUESTGIVER_ACCEPT_QUEST, could not find quest giver with guid of: {quest_giver_guid}')
return 0
if world_session.player_mgr.is_enemy_to(quest_giver):
return 0
world_session.player_mgr.quest_manager.handle_add_quest(quest_id, quest_giver_guid)
return 0
def handle_transform(aura, effect_target, remove):
if not remove:
creature_entry = aura.spell_effect.misc_value
creature = WorldDatabaseManager.creature_get_by_entry(creature_entry)
if not creature:
Logger.error(f'SPELL_AURA_TRANSFORM: Creature template ({creature_entry}) not found in database.')
return
if not effect_target.set_display_id(creature.display_id1):
Logger.error(f'SPELL_AURA_TRANSFORM: Invalid display id ({creature.display_id1}) for creature ({creature_entry}).')
else:
effect_target.reset_display_id()
def get_handler_from_packet(world_session, opcode):
try:
opcode_name = OpCode(opcode)
if opcode_name in HANDLER_DEFINITIONS:
return HANDLER_DEFINITIONS.get(OpCode(opcode))
else:
Logger.warning('[%s] Received %s OpCode but is not handled.' %
(world_session.client_address[0], opcode_name))
except ValueError:
Logger.error('[%s] Received unknown OpCode (%u)' %
(world_session.client_address[0], opcode))
return None
def handle(world_session, socket, reader):
if len(reader.data
) >= 8: # Avoid handling empty quest giver query quest packet.
guid, quest_entry = unpack('<QL', reader.data[:12])
high_guid = ObjectManager.extract_high_guid(guid)
# NPC
if high_guid == HighGuid.HIGHGUID_UNIT:
quest_giver = MapManager.get_surrounding_unit_by_guid(
world_session.player_mgr, guid)
if not quest_giver:
return 0
quest_giver_is_related = world_session.player_mgr.quest_manager.check_quest_giver_npc_is_related(
quest_giver.entry, quest_entry)
if not quest_giver_is_related:
return 0
# Gameobject
elif high_guid == HighGuid.HIGHGUID_GAMEOBJECT:
quest_giver = MapManager.get_surrounding_gameobject_by_guid(
world_session, guid)
if not quest_giver:
return 0
# Item
elif high_guid == HighGuid.HIGHGUID_ITEM:
item_info = world_session.player_mgr.inventory.get_item_info_by_guid(
guid)
if not item_info[3]:
return 0
quest_giver = item_info[3].item_template
quest_giver_is_related = quest_giver.start_quest == quest_entry
if not quest_giver_is_related:
return 0
else:
Logger.error(
f'Error in CMSG_QUESTGIVER_QUERY_QUEST, unknown quest giver type.'
)
return 0
quest = WorldDatabaseManager.QuestTemplateHolder.quest_get_by_entry(
quest_entry)
if not quest:
Logger.error(
f'Error in CMSG_QUESTGIVER_QUERY_QUEST, could not find quest with an entry of: {quest_entry}'
)
return 0
world_session.player_mgr.quest_manager.send_quest_giver_quest_details(
quest, guid, True)
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:
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 load_quests(self):
quest_db_states = RealmDatabaseManager.character_get_quests(self.player_mgr.guid)
for quest_db_state in quest_db_states:
if quest_db_state.rewarded > 0:
self.completed_quests.add(quest_db_state.quest)
elif quest_db_state.state == QuestState.QUEST_ACCEPTED or quest_db_state.state == QuestState.QUEST_REWARD:
active_quest = ActiveQuest(quest_db_state, self.player_mgr)
self.active_quests[quest_db_state.quest] = active_quest
# Needed in case the WDB has been deleted, otherwise non cached quests won't appear in the log.
self.send_quest_query_response(active_quest)
else:
Logger.error(
f"Quest database (guid={quest_db_state.guid}, quest_id={quest_db_state.quest}) has state {quest_db_state.state}. No handling.")
def handle(world_session, socket, reader):
guid = 0
if len(reader.data) >= 8: # Avoid handling empty area char delete packet.
guid = unpack('<Q', reader.data[:8])[0]
res = CharDelete.CHAR_DELETE_SUCCESS
if guid == 0 or RealmDatabaseManager.character_delete(guid) != 0:
res = CharDelete.CHAR_DELETE_FAILED
Logger.error(f'Error deleting character with guid {guid}.')
world_session.enqueue_packet(PacketWriter.get_packet(OpCode.SMSG_CHAR_DELETE, pack('<B', res)))
return 0
def get_area_information(map_id, x, y):
try:
map_tile_x, map_tile_y, tile_local_x, tile_local_y = MapManager.calculate_tile(
x, y, RESOLUTION_AREA_INFO - 1)
if not MapManager._check_tile_load(map_id, x, y, map_tile_x,
map_tile_y):
return None
return MAPS[map_id].tiles[map_tile_x][map_tile_y].area_information[
tile_local_x][tile_local_y]
except:
Logger.error(traceback.format_exc())
return None
async def launch(self):
try:
self.ws = await websockets.connect(f"ws://{self.host}:{self.port}",
extra_headers=self._headers())
if self.ws.open:
Logger.info(
f"Node connected with host: {self.host} and port: {self.port}."
)
self._manager.bot.loop.create_task(self._wait_for_ws_message())
self.ready = True
except OSError as error:
Logger.error(
f"Failed to connect to LavaLink with host: {self.host} reason: {error}"
)
def load_quests(self):
quest_db_statuses = RealmDatabaseManager.character_get_quests(
self.player_mgr.guid)
for quest_db_status in quest_db_statuses:
if quest_db_status.rewarded > 0:
self.completed_quests.add(quest_db_status.quest)
elif quest_db_status.state == QuestState.QUEST_ACCEPTED or quest_db_status.state == QuestState.QUEST_REWARD:
self.active_quests[quest_db_status.quest] = ActiveQuest(
quest_db_status)
else:
Logger.error(
f"Quest database (guid={quest_db_status.guid}, quest_id={quest_db_status.quest}) has state {quest_db_status.state}. No handling."
)
def handle_summon_object(casting_spell, effect, caster, target):
object_entry = effect.misc_value
go_manager = GameObjectManager.spawn(object_entry,
target,
caster.map_,
override_faction=caster.faction)
if not go_manager:
Logger.error(
f'Gameobject with entry {object_entry} not found for spell {casting_spell.spell_entry.ID}.'
)
return
if go_manager.gobject_template.type == GameObjectTypes.TYPE_RITUAL:
go_manager.ritual_caster = caster
