def __init__(self): super(XivCraft, self).__init__() class ChatLogRegexProcessor(object): def __init__(_self): _self.data = dict() def register(_self, channel_id, regex, callback): if channel_id not in _self.data: _self.data[channel_id] = set() _self.data[channel_id].add((re.compile(regex), callback)) def process(_self, chat_log): if chat_log.channel_id in _self.data: for regex, callback in _self.data[chat_log.channel_id]: result = regex.search(chat_log.message) if result: self.create_mission(callback, chat_log, result) class CraftStartHook(Hook): restype = c_int64 argtypes = [c_int64] def hook_function(_self, a1): ans = _self.original(a1) recipe_id = read_ushort(a1 + 880) try: self._recipe = recipe_sheet[recipe_id] if recipe_id else None except Exception: self.logger.error("error in craft start hook:\n" + format_exc()) return ans am = AddressManager(self.storage.data, self.logger) self.craft_start_hook = CraftStartHook(am.get('craft_start', scan_pattern, craft_start_sig)) self.craft_status = read_memory(CraftStatus, am.get('craft_status', scan_address, craft_status_sig, cmd_len=6)) self.base_quality = read_memory(BaseQualityPtr, am.get('base_quality_ptr', scan_address, base_quality_ptr_sig, cmd_len=8, ptr_idx=3)) self.storage.save() self.chat_log_processor = ChatLogRegexProcessor() self.chat_log_processor.register(2114, "^(.+)开始练习制作\ue0bb(.+)。$", self.craft_start) self.chat_log_processor.register(2114, "^(.+)开始制作“\ue0bb(.+)”(×\d+)?。$", self.craft_start) self.chat_log_processor.register(2091, "^(.+)发动了“(.+)”(。)$", self.craft_next) self.chat_log_processor.register(2114, "^(.+)发动“(.+)” \ue06f (成功|失败)$", self.craft_next) # self.chat_log_processor.register(56, "^@Craft next$", self.craft_next) self.chat_log_processor.register(2114, "^(.+)练习制作\ue0bb(.+)成功了!$", self.craft_end) self.chat_log_processor.register(2114, "^(.+)练习制作\ue0bb(.+)失败了……$", self.craft_end) self.chat_log_processor.register(2114, "^(.+)停止了练习。$", self.craft_end) self.chat_log_processor.register(2242, "^(.+)制作“\ue0bb(.+)”(×\d+)?成功!$", self.craft_end) self.chat_log_processor.register(2114, "^(.+)制作失败了……$", self.craft_end) self.chat_log_processor.register(2114, "^(.+)中止了制作作业。$", self.craft_end) self._recipe = None self.solver = None self.base_data = None self.name = None self.register_event("log_event", self.chat_log_processor.process)
def __init__(self): super().__init__() am = AddressManager(self.storage.data, self.logger) addrMain = am.get('main', scan_pattern, sig_main) addrFly = am.get('fly', scan_pattern, sig_fly) self.storage.save() self.hook_main = SpeedHookMain(addrMain) self.hook_fly = SpeedHookFly(addrFly) api.command.register(command, self.process_command)
def __init__(self): super().__init__() self.send_decoder = BundleDecoder(self.process_send_msg) self.recv_decoder = BundleDecoder(self.process_recv_msg) class SendHook(WebActionHook): def hook_function(_self, socket, buffer, size): if size > 64: _self.socket = socket # self.logger(hex(socket), hex(cast(buffer, c_void_p).value), size) return _self.send(self.makeup_data(bytearray(buffer[:size])), return_size=size, socket=socket) def send(_self, data: bytearray, process=True, return_size=None, socket=None): # self.logger('*', data.hex()) if socket is None: if _self.socket is None: raise Exception("No socket record") socket = _self.socket size = len(data) new_data = (c_ubyte * size).from_buffer(data) success_size = _self.original(socket, new_data, size) if success_size and process: self.send_decoder.store_data(data[:success_size]) return success_size if return_size is None else return_size class RecvHook(WebActionHook): def hook_function(_self, socket, buffer, size): _self.socket = socket success_size = _self.original(socket, buffer, size) if success_size: self.recv_decoder.store_data( bytearray(buffer[:success_size]).copy()) return success_size am = AddressManager(self.storage.data, self.logger) self.recv_hook1 = RecvHook(am.get('recv', scan_pattern, recv_sig)) self.recv_hook2 = RecvHook(am.get('recv2', find_recv2, sig2)) self.send_hook1 = SendHook(am.get('send', scan_pattern, send_sig)) self.send_hook2 = SendHook(am.get('send2', find_send2, sig2)) self.storage.save() self.makeups = dict() self.register_api( 'XivNetwork', type( 'obj', (object, ), { 'register_makeup': self.register_makeup, 'unregister_makeup': self.unregister_makeup, 'send_messages': self.send_messages, }))
def __init__(self): super().__init__() self.send_decoder = BundleDecoder() self.recv_decoder = BundleDecoder() class SendHook(WebActionHook): def hook_function(_self, socket, buffer, size): _self.socket = socket new_data = self.makeup_data(bytearray(buffer[:size])) size = len(new_data) new_data = (c_ubyte * size).from_buffer(new_data) success_size = _self.original(socket, new_data, size) if success_size: self.create_mission( self.send_data, bytearray(new_data[:success_size]).copy()) return success_size def send(_self, data: bytearray): # self.logger('*', data.hex()) size = len(data) new_data = (c_ubyte * size).from_buffer(data) success_size = _self.original(_self.socket, new_data, size) if success_size: self.create_mission( self.send_data, bytearray(new_data[:success_size]).copy()) return success_size class RecvHook(WebActionHook): def hook_function(_self, socket, buffer, size): _self.socket = socket success_size = _self.original(socket, buffer, size) if success_size: self.create_mission( self.recv_data, bytearray(buffer[:success_size]).copy()) return success_size am = AddressManager(self.storage.data, self.logger) self.recv_hook1 = RecvHook(am.get('recv', scan_pattern, recv_sig)) self.recv_hook2 = RecvHook(am.get('recv2', find_recv2, sig2)) self.send_hook1 = SendHook(am.get('send', scan_pattern, send_sig)) self.send_hook2 = SendHook(am.get('send2', find_send2, sig2)) self.storage.save() self.makeups = dict() self.register_api( 'XivNetwork', type( 'obj', (object, ), { 'register_makeup': self.register_makeup, 'unregister_makeup': self.unregister_makeup, 'send_messages': self.send_messages, }))
def __init__(self): global _logger super().__init__() _logger = self.logger am = AddressManager(self.storage.data, self.logger) get_icon_addr = am.get("get icon", scan_pattern, get_icon_sig) is_icon_replaceable_addr = am.get("is icon replaceable", scan_pattern, is_icon_replaceable_sig) self.storage.save() self.on_get_icon_hook = OnGetIconHook(get_icon_addr) self.on_is_icon_replaceable_hook = OnCheckIsIconReplaceableHook( is_icon_replaceable_addr)
def __init__(self): super(ChatLogPlugin, self).__init__() _am = AddressManager(self.storage.data.setdefault('addr', dict()), self.logger) addr = _am.get("hook addr", scan_pattern, sig) self.storage.save() class LogHook(Hook): restype = c_int64 argtypes = [c_int64, POINTER(c_ubyte), c_int] def hook_function(_self, a1, buffer, size): try: if self.api_class.chat_log is None: self.api_class.chat_log = read_memory( ChatLogTable, a1 - 72) process_event( ChatLogEvent( ChatLog.from_buffer(bytearray(buffer[:size])))) except Exception: self.logger.error(format_exc()) return _self.original(a1, buffer, size) self.hook = LogHook(addr) self.api_class = type('', (object, ), {'chat_log': None}) self.register_api('ChatLog', self.api_class)
def __init__(self): super().__init__() am = AddressManager(self.storage.data, self.logger) self.is_casting_addr = am.get('is_casting', scan_address, is_casting_sig, cmd_len=7, ptr_idx=2, add=1) self.storage.save() self.is_casting = read_ubyte(self.is_casting_addr) self.enable = False api.PosLock.register_statement(self.get_result) api.command.register(command, self.process_command)
def __init__(self): global _logger super(ChatLogPlugin, self).__init__() _logger = self.logger _am = AddressManager(self.storage.data.setdefault('addr', dict()), self.logger) addr = _am.get("hook addr", scan_pattern, sig) self.storage.save() self.hook = LogHook(addr, self.check_addr) self.api_class = _ApiClass() self.register_api('ChatLog', self.api_class)
def __init__(self): super().__init__() class TalkHook(Hook): restype = c_uint64 argtypes = [c_uint64, c_uint64] def hook_function(_self, a1, a2): r = _self.original(a1, a2) if self.stage and read_ushort(a2 + 10) == 0x9: talk_finish(read_ushort(a2 + 8)) return r am = AddressManager(self.storage.data, self.logger) self.card_check_module = am.get('card_check_module', scan_address, card_check_module_sig, cmd_len=7) self._card_exist_func = card_exist_func( am.get('card_check_func', scan_pattern, card_check_func_sig)) self.talk_hook = TalkHook( am.get('talk_hook', scan_address, talk_hook_sig, cmd_len=5)) self.storage.save() self.register_event(f"network/recv/{recv_game_data_opcode}", self.start_game) self.register_event(f"network/recv/{recv_place_card_opcode}", self.place_card) self.register_event(f"network/recv/{recv_duel_desc_opcode}", self.init_rules) self.register_event(f"network/recv/{recv_duel_action_finish_opcode}", self.duel_next_step) self.register_event(f"network/recv_event_finish", self.reset) self.solvers = [Sample.SampleSolver] self.solver_used = None self.game = None self.card_event = None self.stage = 0 self.available_cards = [] self.auto_next = False self.mode = FOCUS self.lock = Lock() self.refresh_available_cards() api.command.register(command, self.process_command_entrance)
def __init__(self): super().__init__() am = AddressManager(self.storage.data, self.logger) ptr_main = am.get("main ptr", scan_address, pattern_main, add=0x14, cmd_len=8) addr_fly = am.get("fly addr", scan_address, pattern_fly, cmd_len=7, add=16) self.storage.save() self._coor_main = read_memory(MainCoor, ptr_main) self.coor_fly = read_memory(Vector, addr_fly) api.command.register(command, self.process_command) self.lock_coor = None self.register_api('Coordinate', lambda: self.coor_main)
def __init__(self): super().__init__() am = AddressManager(self.storage.data, self.logger) ptr_main = am.get("main ptr", scan_address, pattern_main, add=0x14, cmd_len=8) addr_fly = am.get("fly addr", scan_address, pattern_fly, cmd_len=7, add=16) self.storage.save() self._coor_main = read_memory(MainCoor, ptr_main) self.coor_fly = read_memory(Vector, addr_fly) api.command.register(command, self.process_command) frame_inject.register_continue_call(self.lock_action) self.lock_coor = None
def __init__(self): super().__init__() am = AddressManager(self.storage.data, self.logger) self.addr1 = am.get('addr1', scan_pattern, sig1) self.addr2 = am.get('addr2', scan_pattern, sig2) self.storage.save() self.originals = [ bytes(read_ubytes(self.addr1, 8)), bytes(read_ubytes(self.addr1 + 0x15, 8)), bytes(read_ubytes(self.addr2, 8)), bytes(read_ubytes(self.addr2 + 0xA, 8)), ] api.command.register(command, self.process_command)
def __init__(self): super().__init__() self.statements = set() am = AddressManager(self.storage.data, self.logger) ptr_main = am.get("main ptr", scan_address, pattern_main, add=0x14, cmd_len=8) addr_move_func = am.get("move func addr", scan_pattern, pattern_actor_move) self.storage.save() self.main_addr = cast(ptr_main, POINTER(c_int64)) self.main_coor = read_memory(PointerStruct(c_float * 3, 160), ptr_main) self._enable = False class ActorMoveHook(Hook): restype = c_int64 argtypes = [c_int64, c_float, c_float, c_float] def hook_function(_self, addr, x, z, y): if self.main_addr[0] == addr and (self._enable or self.get_result()): return _self.original(addr, *self.main_coor.value) return _self.original(addr, x, z, y) self.hook = ActorMoveHook(addr_move_func) api.command.register(command, self.process_command) self.register_api( 'PosLock', type( 'obj', (object, ), { 'enable': self.enable, 'disable': self.disable, 'register_statement': self.register_statement, 'remove_statement': self.remove_statement, }))
def __init__(self): super(Markings, self).__init__() am = AddressManager(self.storage.data, self.logger) marking_func = am.get('marking_func', scan_pattern, marking_func_sig) self.marking_controller_addr = am.get('marking_controller', scan_address, marking_controller_sig, cmd_len=7) self.storage.save() self.way_marks = read_memory(WayMarksStruct, self.marking_controller_addr + 432) self.marking_func = MarkingFunc(marking_func) self.register_api( 'Markings', type( 'obj', (object, ), { 'mark_actor': self.mark_actor, 'place_way_mark': self.place_way_mark, 'disable_way_mark': self.disable_way_mark, 'get_way_marks': self.get_way_marks, })) api.HttpApi.register_post_route('place', self.way_mark_handler) api.HttpApi.register_post_route('mark', self.actor_mark_handler)
def __init__(self): super().__init__() am = AddressManager(self.storage.data, self.logger) class MoEntityHook(Hook): argtypes = [c_int64, c_int64] def hook_function(_self, a1, actor_addr): try: self._mo_entity = read_memory( api.XivMemory.struct.Actor.Actor, actor_addr) if actor_addr else None except Exception: self.logger.error("error occurred in MoEntityHook:\n" + format_exc()) _self.original(a1, actor_addr) class api_class(object): @property def entity(_): if self._mo_entity is not None: return self._mo_entity return api.XivMemory.targets.mouse_over @property def item(_): return None @property def world_position(_): return None self._mo_entity = None self._mo_item = None self.entity_hook = MoEntityHook( am.get("mo_entity_addr", scan_address, "E8 ? ? ? ? 48 8B ? ? ? 48 8B ? ? ? 4C 8B ? ? ? 41 83 FC", cmd_len=5)) # global get_matrix_singleton, screen_to_world_native # addr1 = am.get("get_matrix_singleton", scan_address, "E8 ?? ?? ?? ?? 48 8D 4C 24 ?? 48 89 4c 24 ?? 4C 8D 4D ?? 4C 8D 44 24 ??", cmd_len=5) # get_matrix_singleton = get_matrix_singleton_type(addr1) # self.logger.info(hex(get_matrix_singleton())) # addr2 = am.get("screen_to_world_native", scan_pattern, "48 83 EC 48 48 8B 05 ?? ?? ?? ?? 4D 8B D1") # screen_to_world_native = screen_to_world_native_type(addr2) self._api_class = api_class() self.register_api("MoPlus", self._api_class)
def __init__(self): super().__init__() self.send_decoder = BundleDecoder() self.recv_decoder = BundleDecoder() class SendHook(WebActionHook): def hook_function(_self, socket, buffer, size): success_size = _self.original(socket, buffer, size) self.create_mission(self.send_data, bytearray(buffer[:success_size]).copy()) return success_size class RecvHook(WebActionHook): def hook_function(_self, socket, buffer, size): success_size = _self.original(socket, buffer, size) self.create_mission(self.recv_data, bytearray(buffer[:success_size]).copy()) return success_size am = AddressManager(self.storage.data, self.logger) self.recv_hook1 = RecvHook(am.get('recv', scan_pattern, recv_sig)) self.send_hook1 = SendHook(am.get('send', scan_pattern, send_sig)) self.storage.save()
def __init__(self): super().__init__() am = AddressManager(self.storage.data, self.logger) self.cam_ptr = am.get('cam_ptr', scan_address, cam_sig, cmd_len=7) self.cam_collision_jmp_addr = am.get('cam_collision_jmp', scan_pattern, cam_collision_jmp_sig) zoom_offset = read_int( am.get('zoom_offset_addr', scan_pattern, zoom_offset_sig, add=4)) fov_offset = read_int( am.get('fov_offset_addr', scan_pattern, fov_offset_sig, add=4)) angle_offset = read_int( am.get('angle_offset_addr', scan_pattern, angle_offset_sig, add=4)) self.cam_distance_reset_addr = am.get('cam_distance_reset', scan_pattern, cam_distance_reset_func_sig) version_data = self.storage.data[FFxiv_Version] if 'cam_distance_reset_original' not in version_data: version_data['cam_distance_reset_original'] = base64.b64encode( read_ubytes(self.cam_distance_reset_addr, 8)).decode('ascii') self.cam_distance_reset_original = base64.b64decode( version_data['cam_distance_reset_original'].encode('ascii')) self.storage.data.setdefault('user_default', DEFAULT) self.storage.data.setdefault('user_default_no_collision', False) self.storage.save() self.cam = read_memory( PointerStruct( OffsetStruct({ 'zoom': (MinMax, zoom_offset + 4), 'fov': (MinMax, fov_offset + 4), 'angle': (MinMax, angle_offset), }), 0), self.cam_ptr).value api.command.register(command, self.process_command)
from FFxivPythonTrigger.memory import scan_address from FFxivPythonTrigger.Logger import Logger from FFxivPythonTrigger.Storage import get_module_storage from FFxivPythonTrigger.AddressManager import AddressManager _logger = Logger("XivMem/AddressManager") _storage = get_module_storage("XivMem") _am = AddressManager(_storage.data, _logger) ########## # actor table ########## actor_table_sig = "48 8d ?? ?? ?? ?? ?? e8 ?? ?? ?? ?? 48 8b ?? 48 8b ?? 48 8d ?? ?? ?? ?? ?? " \ "e8 ?? ?? ?? ?? 48 8d ?? ?? ?? ?? ?? ba ?? ?? ?? ?? e8 ?? ?? ?? ?? 89 2f" actor_table_addr = _am.get("actor table", scan_address, actor_table_sig, cmd_len=7) ########## # combat data ########## combo_state_sig = "f3 0f ?? ?? ?? ?? ?? ?? f3 0f ?? ?? ?? e8 ?? ?? ?? ?? 48 8b ?? 48 8b ?? 0f b7" combo_state_addr = _am.get("combo state", scan_address, combo_state_sig, cmd_len=8) skill_queue_sig = "44 89 2d ?? ?? ?? ?? f3 0f 11 05 ?? ?? ?? ??" skill_queue_addr = _am.get("skill queue", scan_address, skill_queue_sig,
from FFxivPythonTrigger.memory import scan_address, scan_pattern from FFxivPythonTrigger.Logger import Logger from FFxivPythonTrigger.Storage import get_module_storage from FFxivPythonTrigger.AddressManager import AddressManager _logger = Logger("XivMagic/AddressManager") _storage = get_module_storage("XivMagic") _am = AddressManager(_storage.data, _logger) ########## # do text command ########## do_text_command_sig = "48 89 5C 24 ?? 57 48 83 EC 20 48 8B FA 48 8B D9 45 84 C9" do_text_command_addr = _am.get("text command function", scan_pattern, do_text_command_sig) text_command_ui_module_ptr_sig = "48 8B 05 ?? ?? ?? ?? 48 8B D9 8B 40 14 85 C0" text_command_ui_module_ptr_addr = _am.get("text command ui module pointer", scan_address, text_command_ui_module_ptr_sig, cmd_len=7) ########## # do action ########## do_action_func_sig = "40 53 55 57 41 54 41 57 48 83 EC ? 83 BC 24 ? ? ? ? ?" do_action_func_addr = _am.get("do action func", scan_pattern, do_action_func_sig) do_action_location_sig = "44 89 44 24 ? 89 54 24 ? 55 53 57" do_action_location_addr = _am.get("do action location", scan_pattern,