def commit_prop(self):
sender = self.sender()
prop = sender.property("prop_name")
el = self.properties[prop][0]
try:
self.core.SetPlayerData(prop, el.value())
except Exception as e:
logger.error(f"Failed to set player data: {e}")
def _try_invoke_internal(self, method, try_count, *args):
if isinstance(method, bytes):
method = method.decode('utf-8')
logger.debug(f"Calling {method}")
self.call_id += 1
obj = {
"msg_id": self.call_id,
"data": ["call", {
"method": method,
"args": args
}]
}
packed = msgpack.packb(obj)
try:
self.handler.write(struct.pack("I", len(packed)))
self.handler.write(packed)
# Advance the cursor by reading the packed bytes
# Has to be done because it's not advanced automatically for some reason
# self.handler.read(len(packed) + 4)
response_len = struct.unpack("I", self.handler.read(4))[0]
response_packed = self.handler.read(response_len)
except:
self.close()
return (None, True)
try:
response = msgpack.unpackb(response_packed, raw=False)
except msgpack.ExtraData as e:
if try_count >= self.max_retries:
logger.error(f"Forcing to fail after {try_count} tries.")
return (None, True)
logger.warning(
f"Received extra data! Flushing and retrying. Extra: {e.extra}"
)
self._flush()
return self._try_invoke_internal(method, try_count + 1, *args)
response_type = response["data"][0]
if response_type == "response":
return (response["data"][1]["result"], False)
elif response_type == "error":
error_info = response["data"][1]
raise RemoteError(error_info["err_name"],
error_info["err_message"],
error_info["stack_trace"])
else:
raise RemoteError("InvalidResponse",
"The response from the method is invalid", "")
def close(self):
if self.handler is None:
return
try:
h = self.handler
self.handler = None
h.close()
self.call_id = 0
logger.info("Handler closed!")
except Exception as e:
logger.error(f"Error while closing the handler!: {e}")
def run(self):
self.connecting = True
while self.connecting:
QThread.sleep(1)
try:
self.core.connect("MaidFiddlerService")
if self._connected():
logger.info("Connected!")
return
except Exception as e:
logger.error(
f"Failed to connect because {e}! Retrying in a second!")
self.connection_reset.emit()
def _connected(self):
self.connected.emit()
logger.info("Got connection! Trying to get game data!")
try:
game_data, err = self.core.try_invoke("GetGameInfo")
if game_data is None:
logger.warning(
f"Got empty response! Resetting the connection!")
self.core.close()
self.connection_reset.emit()
return False
except Exception as e:
logger.error(f"Got error while calling GetGameInfo: {e}")
self.connection_reset.emit()
return False
self.connecting = False
self.setup_complete.emit(game_data)
return True