def handle(world_session, socket, reader):
        if len(reader.data) >= 8:  # Avoid handling empty debug AI state packet
            guid = unpack('<Q', reader.data[:8])[0]
            world_object = GridManager.get_surrounding_unit_by_guid(
                world_session.player_mgr, guid, include_players=True)

            # If no Unit or Player, try to get a Gameobject.
            if not world_object:
                world_object = GridManager.get_surrounding_gameobject_by_guid(
                    world_session.player_mgr, guid)

            # Still no object with that Guid? Return.
            if not world_object:
                return 0

            messages = world_object.get_debug_messages()
            data = pack('<QI', guid, len(messages))

            for message in messages:
                message_bytes = PacketWriter.string_to_bytes(
                    message[:127])  # Max length is 128 (127 + null byte).
                data += pack(f'<{len(message_bytes)}s', message_bytes)

            world_session.enqueue_packet(
                PacketWriter.get_packet(OpCode.SMSG_DEBUG_AISTATE, data))

        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 = GridManager.get_surrounding_unit_by_guid(
                    world_session.player_mgr, quest_giver_guid)
            # Gameobject
            elif quest_giver_guid & HighGuid.HIGHGUID_GAMEOBJECT:
                quest_giver = GridManager.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
Beispiel #3
0
    def handle(world_session, socket, reader):
        if len(reader.data) >= 8:  # Avoid handling empty gameobj use packet
            guid = unpack('<Q', reader.data[:8])[0]
            if guid > 0:
                gobject = GridManager.get_surrounding_gameobject_by_guid(
                    world_session.player_mgr, guid)
                if gobject:
                    if gobject.gobject_template.type != GameObjectTypes.TYPE_GENERIC:
                        gobject.use(world_session.player_mgr)

        return 0
Beispiel #4
0
    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])
            # NPC
            if guid & HighGuid.HIGHGUID_UNIT:
                quest_giver = GridManager.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 guid & HighGuid.HIGHGUID_GAMEOBJECT:
                quest_giver = GridManager.get_surrounding_gameobject_by_guid(
                    world_session, guid)
                if not quest_giver:
                    return 0
            # Item
            elif 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
Beispiel #5
0
    def handle(world_session, socket, reader):
        if len(reader.data
               ) >= 12:  # Avoid handling empty gameobject query packet
            entry, guid = unpack('<IQ', reader.data[:12])
            if guid > 0:
                gobject_mgr = GridManager.get_surrounding_gameobject_by_guid(
                    world_session.player_mgr, guid)
                if not gobject_mgr:
                    gobject_spawn, session = WorldDatabaseManager.gameobject_spawn_get_by_guid(
                        guid)
                    if gobject_spawn and gobject_spawn.gameobject.entry == entry:
                        gobject_mgr = GameObjectManager(
                            gobject_template=gobject_spawn.gameobject)
                    session.close()
                if gobject_mgr:
                    world_session.enqueue_packet(gobject_mgr.query_details())

        return 0