async def _plugin_start(self):
client = aiohttp.ClientSession()
while self.work:
try:
self.ws = await client.ws_connect(self.url())
break
except aiohttp.ClientConnectorError:
await asyncio.sleep(3)
except Exception:
self.logger.error(
"error occurred while connecting to act server, \n" +
format_exc())
self.work = False
if self.ws is not None:
self.logger.info("connect to act server success")
while self.work:
msg = await self.ws.receive()
if msg.type == aiohttp.WSMsgType.text:
process_event(ACTLogEvent(msg.data))
elif msg.type == aiohttp.WSMsgType.closed:
self.logger.info("server closed")
break
elif msg.type == aiohttp.WSMsgType.error:
self.logger.info("error occurred")
break
await self.ws.close()
self.ws = None
def process_recv_msg(self, msg_time, msg):
if len(msg) < header_size: return
header = ServerMessageHeader.from_buffer(msg)
if header.msg_type not in recv_events_classes:
recv_events_classes[header.msg_type] = type(
f"NetworkRecv{header.msg_type}RawEvent", (RecvRawEvent, ),
{'id': f'network/recv/{header.msg_type}'})
raw_msg = msg[header_size:]
process_event(recv_events_classes[header.msg_type](msg_time, header,
raw_msg))
event = (recv_processors[header.msg_type] if header.msg_type
in recv_processors else UnkRecvRawEvent)(msg_time, header,
raw_msg)
if header.msg_type in self.wait_response:
waitings = self.wait_response[header.msg_type]
for waiting in waitings.copy():
try:
is_response = waiting[1] is None or waiting[1](event)
except Exception as e:
self.logger.error(
f"error occurred in response: {waiting[1]},an exception will be returned:\n{format_exc()}"
)
self.response_data[waiting[0]] = e
waitings.remove(waiting)
else:
if is_response:
self.response_data[waiting[0]] = event
waitings.remove(waiting)
if not waitings:
del self.wait_response[header.msg_type]
process_event(event)
def process_recv_msg(self, msg_time, msg):
if len(msg) < sizeof(ServerMessageHeader): return
header = ServerMessageHeader.from_buffer(msg)
# self.logger.debug(msg_time,hex(header.msg_type),msg.hex())
event = processors[header.msg_type](
msg_time, msg) if header.msg_type in processors else None
if event is None: event = UnknownOpcodeEvent(msg, msg_time, header)
process_event(event)
def hook_function(self, a1, buffer, size):
try:
self.addr_recall(a1 - 72)
process_event(ChatLogEvent(ChatLog(read_ubytes(buffer, size))))
except Exception:
_logger.error(format_exc())
# self.disable()
return self.original(a1, buffer, size)
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 _craft_next(self, craft: Craft.Craft, skill):
if skill == "观察":
craft.add_effect("观察", 1)
craft.merge_effects()
self.logger.debug(f"use skill:{skill.name}")
self.logger.debug(craft)
process_event(CraftAction(craft, skill))
if self.solver is not None and not craft.is_finished():
ans = self.solver.process(craft, skill)
self.logger.info("suggested skill '%s'" % ans)
if ans and callback is not None:
self.create_mission(callback, ans, limit_sec=0)
def process_recv_msg(self, msg_time, msg):
if len(msg) < header_size: return
header = ServerMessageHeader.from_buffer(msg)
if header.msg_type not in recv_events_classes:
recv_events_classes[header.msg_type] = type(
f"NetworkRecv{header.msg_type}RawEvent", (RecvRawEvent, ),
{'id': f'network/recv_{header.msg_type}'})
process_event(recv_events_classes[header.msg_type](msg[header_size:],
msg_time, header))
event = recv_processors[header.msg_type](
msg_time, msg) if header.msg_type in recv_processors else None
if event is not None: process_event(event)
def process_send_msg(self, msg_time, msg):
if len(msg) < header_size: return
header = ServerMessageHeader.from_buffer(msg)
for key in msg_header_keys.keys():
msg_header_keys[key] = getattr(header, key)
if header.msg_type not in send_events_classes:
send_events_classes[header.msg_type] = type(
f"NetworkSend{header.msg_type}RawEvent", (SendRawEvent, ),
{'id': f'network/send_{header.msg_type}'})
process_event(send_events_classes[header.msg_type](msg[header_size:],
msg_time, header))
if header.msg_type in send_processors:
event = send_processors[header.msg_type](msg_time, msg)
else:
event = UnkSendRawEvent(msg[header_size:], msg_time, header)
process_event(event)
def process_send_msg(self, msg_time, msg):
# self.logger(len(msg),msg.hex())
if len(msg) < header_size: return
header = ServerMessageHeader.from_buffer(msg)
# self.logger(header.msg_type,msg[:24].hex())
for key in msg_header_keys.keys():
msg_header_keys[key] = getattr(header, key)
if header.msg_type not in send_events_classes:
send_events_classes[header.msg_type] = type(
f"NetworkSend{header.msg_type}RawEvent", (SendRawEvent, ),
{'id': f'network/send_{header.msg_type}'})
process_event(send_events_classes[header.msg_type](msg[header_size:],
msg_time, header))
event = send_processors[header.msg_type](
msg_time, msg) if header.msg_type in send_processors else None
if event is not None: process_event(event)
def process_send_msg(self, msg_time, msg):
if len(msg) < header_size: return
header = ServerMessageHeader.from_buffer(msg)
for key in msg_header_keys.keys():
msg_header_keys[key] = getattr(header, key)
if header.msg_type not in send_events_classes:
send_events_classes[header.msg_type] = type(
f"NetworkSend{header.msg_type}RawEvent", (SendRawEvent, ),
{'id': f'network/send/{header.msg_type}'})
raw_msg = msg[header_size:]
process_event(send_events_classes[header.msg_type](msg_time, header,
raw_msg))
event = (send_processors[header.msg_type] if header.msg_type
in send_processors else UnkSendRawEvent)(msg_time, header,
raw_msg)
if event is not None: process_event(event)
def craft_start(self, chat_log, regex_result):
self.name = api.XivMemory.actor_table.get_me().Name
if regex_result.group(1)!=self.name:return
recipe, player = self.base_data = self.get_base_data()
self.logger.info("start recipe:" + recipe.detail_str)
craft = Craft.Craft(recipe=recipe, player=player, current_quality=self.base_quality.value)
process_event(CraftStart(recipe, player, self.base_quality.value))
for solver in registered_solvers:
if solver.suitable(craft):
self.solver = solver(craft=craft, logger=self.logger)
break
if self.solver is not None:
self.logger.info("solver found, starting to solve...")
ans = self.solver.process(craft, None)
if ans is not None and callback is not None: self.create_mission(callback, ans)
else:
self.logger.info("no solver found, please add a solver for this recipe")
def craft_next(self, chat_log, regex_result):
if regex_result.group(1)!=self.name:return
sleep(0.5)
try:
skill = Manager.skills[regex_result.group(2) + ('' if regex_result.group(3) != "失败" else ':fail')]()
except KeyError:
return
craft = self.get_current_craft()
if skill == "观察":
craft.add_effect("观察", 1)
craft.merge_effects()
self.logger.debug(f"use skill:{skill.name}")
self.logger.debug(craft)
process_event(CraftAction(craft, skill))
if self.solver is not None:
ans = self.solver.process(craft, skill)
self.logger.info("suggested skill '%s'" % ans)
if ans and callback is not None: self.create_mission(callback, ans)
def craft_end(self, chat_log, regex_result):
if regex_result.group(1) != self.name: return
process_event(CraftEnd())
self.solver = None
self.logger.info("end craft")
