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,
