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 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)
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)
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)
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__()
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)
from .AddressManager import party_addr
class PartyList(OffsetStruct({
"members": (PartyMember * 28, 0),
'flag': (c_ubyte, 15700),
'main_size': (c_ubyte, 15708),
})):
def main_party(self):
for i in range(self.main_size):
if self.members[i].id != 0xe0000000:
yield self.members[i]
def party_2(self):
for i in range(8, 16):
if self.members[i].id != 0xe0000000:
yield self.members[i]
def party_3(self):
for i in range(16, 24):
if self.members[i].id != 0xe0000000:
yield self.members[i]
def alliance(self):
for i in self.main_party(): yield i
for i in self.party_2(): yield i
for i in self.party_3(): yield i
party = read_memory(PartyList, party_addr)
from . import AddressManager
from FFxivPythonTrigger.memory import read_memory
from ctypes import pointer
class Targets(Target.Target):
@property
def current(self):
return self._current[0] if self._current else None
@property
def mouse_over(self):
return self._mouse_over[0] if self._mouse_over else None
@property
def focus(self):
return self._focus[0] if self._focus else None
@property
def previous(self):
return self._previous[0] if self._previous else None
def set_current(self, actor=None):
self._current = pointer(actor) if actor is not None else None
def set_focus(self, actor=None):
self._focus = pointer(actor) if actor is not None else None
targets = read_memory(Targets, AddressManager.target_ptr_addr)
format: /e @cutscene [p(patch)/d(dispatch)]
"""
command = "@cutscene"
_logger = Logger("CutsceneSkipper")
_storage = get_module_storage("CutsceneSkipper")
sig = "75 33 48 8B 0D ?? ?? ?? ?? BA ?? 00 00 00 48 83 C1 10 E8 ?? ?? ?? ?? 83 78"
addr = AddressManager(_storage.data, _logger).get("addr", scan_pattern, sig)
_storage.save()
_ver_storage = _storage.data[FFxiv_Version]
_code = read_memory(
StructFactory.OffsetStruct({
"mark1": (c_ubyte * 2, 0),
"mark2": (c_ubyte * 2, 0x1b)
}), addr)
def is_patched():
return _code.mark1[:] == [0x90, 0x90]
def patch():
if _code.mark1[:] != [0x90, 0x90]:
_ver_storage["original1"] = _code.mark1[:]
if _code.mark2[:] != [0x90, 0x90]:
_ver_storage["original2"] = _code.mark2[:]
_storage.save()
def check_addr(self, addr):
if self.api_class.chat_log is None:
self.api_class.chat_log = read_memory(ChatLogTable, addr)
from .struct import Movement from . import AddressManager from FFxivPythonTrigger.memory import read_memory movement = read_memory(Movement.Movement, AddressManager.movement_addr)
from .struct import Player, JobGauge
from . import AddressManager
from FFxivPythonTrigger.memory import read_memory
gauges = {
k: read_memory(v, AddressManager.gauge_addr)
for k, v in JobGauge.gauges.items()
}
class PlayerInfo(Player.Player):
@property
def gauge(self):
if self.job.value() in gauges:
return gauges[self.job.value()]
player_info = read_memory(PlayerInfo, AddressManager.player_addr)
