127 lines
5.6 KiB
Python
127 lines
5.6 KiB
Python
#!/usr/bin/env python3
|
|
|
|
"""
|
|
Standardized Flyff Character Status Node:
|
|
- Polls an API for character stats and updates values dynamically.
|
|
- Uses a global update timer for processing.
|
|
- Immediately transmits updated values to connected nodes.
|
|
- If the API is unreachable, it will wait for 5 seconds before retrying
|
|
and log the error only once per retry period.
|
|
- Calls self.view.draw_node() after updating the node name, ensuring
|
|
the node's bounding box recalculates even when the API is disconnected.
|
|
- Port colors adjusted to match earlier styling.
|
|
"""
|
|
|
|
from OdenGraphQt import BaseNode
|
|
from Qt import QtCore
|
|
import requests
|
|
import traceback
|
|
import time
|
|
|
|
class FlyffCharacterStatusNode(BaseNode):
|
|
__identifier__ = 'bunny-lab.io.flyff_character_status_node'
|
|
NODE_NAME = 'Flyff - Character Status'
|
|
|
|
def __init__(self):
|
|
super(FlyffCharacterStatusNode, self).__init__()
|
|
self.values = {
|
|
"HP: Current": "N/A",
|
|
"HP: Total": "N/A",
|
|
"MP: Current": "N/A",
|
|
"MP: Total": "N/A",
|
|
"FP: Current": "N/A",
|
|
"FP: Total": "N/A",
|
|
"EXP": "N/A"
|
|
}
|
|
|
|
# Set each output with a custom color:
|
|
# (Choose values close to the screenshot for each port.)
|
|
self.add_output('HP: Current', color=(126, 36, 57))
|
|
self.add_output('HP: Total', color=(126, 36, 57))
|
|
self.add_output('MP: Current', color=(35, 89, 144))
|
|
self.add_output('MP: Total', color=(35, 89, 144))
|
|
self.add_output('FP: Current', color=(36, 116, 32))
|
|
self.add_output('FP: Total', color=(36, 116, 32))
|
|
self.add_output('EXP', color=(48, 116, 143))
|
|
|
|
self.set_name("Flyff - Character Status (API Disconnected)")
|
|
self.view.draw_node() # ensure bounding box updates initially
|
|
|
|
# Variables to handle API downtime gracefully:
|
|
self._api_down = False
|
|
self._last_api_attempt = 0
|
|
self._retry_interval = 5 # seconds to wait before retrying after a failure
|
|
self._last_error_printed = 0
|
|
|
|
def process_input(self):
|
|
current_time = time.time()
|
|
# If the API is down, only retry after _retry_interval seconds
|
|
if self._api_down and (current_time - self._last_api_attempt < self._retry_interval):
|
|
return
|
|
|
|
self._last_api_attempt = current_time
|
|
try:
|
|
response = requests.get("http://127.0.0.1:5000/data", timeout=1)
|
|
if response.status_code == 200:
|
|
data = response.json()
|
|
if isinstance(data, dict):
|
|
mapping = {
|
|
"hp_current": "HP: Current",
|
|
"hp_total": "HP: Total",
|
|
"mp_current": "MP: Current",
|
|
"mp_total": "MP: Total",
|
|
"fp_current": "FP: Current",
|
|
"fp_total": "FP: Total",
|
|
"exp": "EXP"
|
|
}
|
|
updated = False
|
|
for key, value in data.items():
|
|
if key in mapping:
|
|
formatted_key = mapping[key]
|
|
if str(value) != self.values.get(formatted_key, None):
|
|
self.values[formatted_key] = str(value)
|
|
updated = True
|
|
self._api_down = False
|
|
if updated:
|
|
self.set_name("Flyff - Character Status (API Connected)")
|
|
self.view.draw_node() # recalc bounding box on connect
|
|
self.transmit_data()
|
|
else:
|
|
if current_time - self._last_error_printed >= self._retry_interval:
|
|
print("[ERROR] Unexpected API response format (not a dict):", data)
|
|
self._last_error_printed = current_time
|
|
self.set_name("Flyff - Character Status (API Disconnected)")
|
|
self.view.draw_node() # recalc bounding box on disconnect
|
|
self._api_down = True
|
|
else:
|
|
if current_time - self._last_error_printed >= self._retry_interval:
|
|
print(f"[ERROR] API request failed with status code {response.status_code}")
|
|
self._last_error_printed = current_time
|
|
self.set_name("Flyff - Character Status (API Disconnected)")
|
|
self.view.draw_node()
|
|
self._api_down = True
|
|
except Exception as e:
|
|
if current_time - self._last_error_printed >= self._retry_interval:
|
|
print("[ERROR] Error polling API in CharacterStatusNode:", str(e))
|
|
self._last_error_printed = current_time
|
|
self.set_name("Flyff - Character Status (API Disconnected)")
|
|
self.view.draw_node()
|
|
self._api_down = True
|
|
|
|
def transmit_data(self):
|
|
for stat, value in self.values.items():
|
|
port = self.get_output(stat)
|
|
if port and port.connected_ports():
|
|
for connected_port in port.connected_ports():
|
|
connected_node = connected_port.node()
|
|
if hasattr(connected_node, 'receive_data'):
|
|
try:
|
|
connected_node.receive_data(value, stat)
|
|
except Exception as e:
|
|
print(f"[ERROR] Error transmitting data to {connected_node}: {e}")
|
|
print("[ERROR] Stack Trace:\n", traceback.format_exc())
|
|
|
|
def receive_data(self, data, source_port_name=None):
|
|
# This node only transmits data; it does not receive external data.
|
|
pass
|