731 lines
32 KiB
Python
Executable File
731 lines
32 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
|
|
import re
|
|
import sys
|
|
from concurrent.futures import Future
|
|
from typing import Callable
|
|
|
|
import click
|
|
import sqlalchemy
|
|
from NodeGraphQt import BaseNode, NodeBaseWidget
|
|
from NodeGraphQt import NodeGraph, Port
|
|
from NodeGraphQt.constants import PortTypeEnum, NodePropWidgetEnum, ViewerEnum
|
|
from NodeGraphQt.widgets.node_widgets import _NodeGroupBox, NodeLineEdit, NodeCheckBox
|
|
from PySide2 import QtGui
|
|
from PySide2.QtCore import Qt, QObject, QThread, Slot, Signal
|
|
from PySide2.QtWidgets import QSlider, QLineEdit, QCheckBox, QGraphicsItem, QInputDialog, QDialog, QLabel, QSizePolicy
|
|
from Qt import QtWidgets
|
|
from sqlalchemy import create_engine
|
|
from sqlalchemy.orm import Session
|
|
|
|
from factorygame.data.common import chose_resource, resource_needs_update, chose_recipe
|
|
from factorygame.data.sfp import SatisfactoryPlus, DEFAULT_IGNORE_FACTORIES
|
|
from .models import Recipe, Resource, ResourceFlow, Base
|
|
|
|
WORLD_INPUT_PORT_NAME = "World Input"
|
|
WORLD_OUTPUT_PORT_NAME = "World Output"
|
|
WORLD_PORT_COLOR = (0, 139, 41)
|
|
|
|
CREATE_MACHINE_PORT_NAME = "Create Machine"
|
|
|
|
INPUT_COLOR = (249, 169, 0)
|
|
OUTPUT_COLOR = (204, 44, 36)
|
|
OTHER_COLOR = (0, 83, 135)
|
|
|
|
|
|
def generate_fgbg_stylesheet(bg_alpha: float = 1.0) -> str:
|
|
dark_bg = QtGui.QColor(*ViewerEnum.BACKGROUND_COLOR.value).darker(120)
|
|
dark_bg.setAlphaF(bg_alpha)
|
|
bg_color = dark_bg.getRgb()
|
|
text_color = tuple(map(str, map(lambda i, j: i - j, (255, 255, 255), bg_color)))
|
|
return (
|
|
"* {"
|
|
" background-color: rgba(" + ",".join(map(str, bg_color)) + ");"
|
|
" color: rgb(" + ",".join(text_color) + ");"
|
|
"}"
|
|
)
|
|
|
|
|
|
def in_amount_name(label: str) -> str:
|
|
return f"In {label} amount"
|
|
|
|
|
|
def out_amount_name(label: str) -> str:
|
|
return f"Out {label} amount"
|
|
|
|
|
|
def port_amount_name(port: Port) -> str:
|
|
if port.type_() == PortTypeEnum.IN:
|
|
return in_amount_name(port.name())
|
|
elif port.type_() == PortTypeEnum.OUT:
|
|
return out_amount_name(port.name())
|
|
else:
|
|
raise TypeError(f"Invalid port type {port.type_()}")
|
|
|
|
|
|
def add_resource_text(
|
|
node: BaseNode, name: str, text: str, border_color: tuple, readonly: bool = False
|
|
) -> NodeLineEdit:
|
|
node.add_text_input(name=name, label=name, text=text)
|
|
widget: NodeLineEdit = node.get_widget(name)
|
|
line_edit_widget: QLineEdit = widget.get_custom_widget()
|
|
if readonly:
|
|
line_edit_widget.setReadOnly(True)
|
|
group: _NodeGroupBox = widget.widget()
|
|
group.setMaximumWidth(220)
|
|
group.adjustSize()
|
|
if border_color:
|
|
stylesheet = line_edit_widget.styleSheet()
|
|
match = Machine.STYLESHEET_BORDER_COLOR_REGEX.match(stylesheet)
|
|
stylesheet = (
|
|
stylesheet[: match.start(1)] + f"rgb({','.join(map(str, border_color))})" + stylesheet[match.end(1) :]
|
|
)
|
|
line_edit_widget.setStyleSheet(stylesheet)
|
|
line_edit_widget.update()
|
|
return widget
|
|
|
|
|
|
def parse_resource_amount(text: str) -> float:
|
|
return float(text.strip().rstrip("min").rstrip().rstrip("/").rstrip())
|
|
|
|
|
|
def resource_amount_to_text(amount: float):
|
|
return f"{amount:.2f} / min"
|
|
|
|
|
|
class AsyncResourceFetcher(QThread):
|
|
def __init__(self, parent, resource_label: str, engine: sqlalchemy.Engine, debug: bool):
|
|
super().__init__(parent=parent)
|
|
self.resource_label = resource_label
|
|
self.engine = engine
|
|
self.debug = debug
|
|
|
|
def run(self):
|
|
with Session(self.engine) as session, SatisfactoryPlus(
|
|
ignore_factories=DEFAULT_IGNORE_FACTORIES, debug=self.debug
|
|
) as data_provider:
|
|
resource = session.scalars(Resource.by_label(self.resource_label)).one()
|
|
resource = data_provider.update_resource_recipes(session=session, resource=resource)
|
|
if self.debug:
|
|
print("AsyncResourceFetcher updated resource in separate thread", resource)
|
|
session.commit()
|
|
|
|
|
|
class AsyncResourceFinder(QThread):
|
|
def __init__(self, parent, resource_label: str, engine: sqlalchemy.Engine, prompt: Callable, debug: bool):
|
|
super().__init__(parent=parent)
|
|
self.resource_label = resource_label
|
|
self.engine = engine
|
|
self.debug = debug
|
|
self.prompt = prompt
|
|
self.result = Future()
|
|
|
|
def run(self):
|
|
try:
|
|
with (
|
|
Session(self.engine) as session,
|
|
SatisfactoryPlus(ignore_factories=DEFAULT_IGNORE_FACTORIES, debug=self.debug) as data_provider,
|
|
):
|
|
search_result_future = data_provider.search_for_resource(
|
|
session=session, search=self.resource_label, prompt=self.prompt
|
|
)
|
|
search_result = search_result_future.result(timeout=60)
|
|
if search_result is None:
|
|
if self.debug:
|
|
print("AsyncResourceFinder search completed, but no result")
|
|
self.result.set_result(None)
|
|
return
|
|
|
|
resource, exists_in_db = search_result
|
|
if not exists_in_db or resource_needs_update(resource):
|
|
resource = data_provider.update_resource_recipes(session=session, resource=resource)
|
|
if self.debug:
|
|
print("AsyncResourceFinder updated resource", resource)
|
|
session.commit()
|
|
session.refresh(resource)
|
|
self.result.set_result(resource)
|
|
except:
|
|
self.result.set_exception(sys.exception())
|
|
|
|
|
|
class NodeSlider(NodeBaseWidget):
|
|
MIN_VALUE = 1
|
|
MAX_VALUE = 250
|
|
DEFAULT_VALUE = 100
|
|
|
|
def __init__(self, name: str, label: str = "", parent: QGraphicsItem = None, readonly: bool = False):
|
|
super(NodeSlider, self).__init__(parent)
|
|
self.set_name(name)
|
|
self.pure_label = label or name
|
|
slider = QSlider(Qt.Horizontal)
|
|
slider.setEnabled(not readonly)
|
|
slider.setRange(self.MIN_VALUE, self.MAX_VALUE)
|
|
slider.setValue(self.DEFAULT_VALUE)
|
|
slider.setSingleStep(1)
|
|
slider.setTickInterval(10)
|
|
slider.setTickPosition(QSlider.TicksBelow)
|
|
slider.valueChanged.connect(self.on_value_changed)
|
|
slider.valueChanged.connect(self._update_label)
|
|
self.set_custom_widget(slider)
|
|
self._update_label()
|
|
|
|
def get_custom_widget(self) -> QSlider:
|
|
widget = super().get_custom_widget()
|
|
assert isinstance(widget, QSlider), f"Unexpected widget, not a QSlider: {widget}"
|
|
return widget
|
|
|
|
def get_value(self) -> int:
|
|
return self.get_custom_widget().value()
|
|
|
|
def set_value(self, value: int):
|
|
self.get_custom_widget().setValue(max(self.MIN_VALUE, min(self.MAX_VALUE, value)))
|
|
|
|
def _update_label(self):
|
|
self.set_label(f"{self.pure_label} ({self.get_value()}%)")
|
|
|
|
|
|
class GlobalInput(BaseNode):
|
|
__identifier__ = "factorygame"
|
|
NODE_NAME = "Global Input"
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
self.model.width = 240
|
|
self.set_port_deletion_allowed(True)
|
|
self.add_special_ports()
|
|
self.output_resources: dict[str, float] = {}
|
|
|
|
def add_special_ports(self):
|
|
self.add_output(WORLD_OUTPUT_PORT_NAME, multi_output=False, color=WORLD_PORT_COLOR)
|
|
self.add_output(CREATE_MACHINE_PORT_NAME, multi_output=False, color=OTHER_COLOR)
|
|
|
|
def reorder_ports(self):
|
|
self.delete_output(WORLD_OUTPUT_PORT_NAME)
|
|
self.delete_output(CREATE_MACHINE_PORT_NAME)
|
|
self.add_special_ports()
|
|
|
|
def update_x_pos(self, graph: NodeGraph):
|
|
min_x_pos = min(map(lambda node: node.x_pos(), filter(lambda node: node != self, graph.all_nodes())))
|
|
self.set_x_pos(min_x_pos - self.view.width - 150)
|
|
|
|
def create_global_output(self, graph: NodeGraph, resource_label: str, initial_resource_amount: float) -> Port:
|
|
# FIXME: support multiple resource outputs or add splitters
|
|
new_output_port = self.add_output(name=resource_label, multi_output=False, color=OUTPUT_COLOR)
|
|
widget = add_resource_text(
|
|
node=self,
|
|
name=out_amount_name(resource_label),
|
|
text=resource_amount_to_text(initial_resource_amount),
|
|
border_color=OUTPUT_COLOR,
|
|
)
|
|
self.output_resources[resource_label] = initial_resource_amount
|
|
widget.value_changed.connect(lambda: self.update_resource_output(resource_label))
|
|
self.reorder_ports()
|
|
self.update_x_pos(graph=graph)
|
|
return new_output_port
|
|
|
|
def update_resource_output(self, resource_label: str):
|
|
assert resource_label in self.output_resources
|
|
widget: NodeLineEdit = self.get_widget(out_amount_name(resource_label))
|
|
new_amount = parse_resource_amount(widget.get_value())
|
|
if self.output_resources[resource_label] != new_amount:
|
|
self.output_resources[resource_label] = new_amount
|
|
widget.set_value(resource_amount_to_text(self.output_resources[resource_label]))
|
|
resource_port = self.get_output(resource_label)
|
|
for connected_port in resource_port.connected_ports():
|
|
node = connected_port.node()
|
|
assert isinstance(node, Machine), f"Connected node must be a machine: {node}"
|
|
node.update_input(resource_label, new_amount)
|
|
|
|
|
|
class GlobalOutput(BaseNode):
|
|
__identifier__ = "factorygame"
|
|
NODE_NAME = "Global Output"
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
self.model.width = 240
|
|
self.set_port_deletion_allowed(True)
|
|
self.add_special_ports()
|
|
self.input_resources: dict[str, float] = {}
|
|
|
|
def add_special_ports(self):
|
|
self.add_input(WORLD_INPUT_PORT_NAME, multi_input=False, color=WORLD_PORT_COLOR)
|
|
self.add_input(CREATE_MACHINE_PORT_NAME, multi_input=False, color=OTHER_COLOR)
|
|
|
|
def reorder_ports(self):
|
|
self.delete_input(WORLD_INPUT_PORT_NAME)
|
|
self.delete_input(CREATE_MACHINE_PORT_NAME)
|
|
self.add_special_ports()
|
|
|
|
def update_x_pos(self, graph: NodeGraph):
|
|
other_nodes = filter(lambda node: node != self, graph.all_nodes())
|
|
max_x = max(map(lambda node: node.x_pos() + node.view.width, other_nodes))
|
|
self.set_x_pos(max_x + 150)
|
|
|
|
def create_global_input(self, graph: NodeGraph, resource_label: str, initial_resource_amount: float) -> Port:
|
|
# FIXME: support multiple resource inputs or add mergers
|
|
new_input_port = self.add_input(name=resource_label, multi_input=False, color=INPUT_COLOR)
|
|
widget = add_resource_text(
|
|
node=self,
|
|
name=in_amount_name(resource_label),
|
|
text=resource_amount_to_text(initial_resource_amount),
|
|
border_color=INPUT_COLOR,
|
|
)
|
|
line_edit_widget: QLineEdit = widget.get_custom_widget()
|
|
line_edit_widget.setReadOnly(True)
|
|
self.input_resources[resource_label] = initial_resource_amount
|
|
self.reorder_ports()
|
|
return new_input_port
|
|
|
|
def update_input(self, resource_label: str, value: float):
|
|
assert resource_label in self.input_resources
|
|
widget: NodeLineEdit = self.get_widget(in_amount_name(resource_label))
|
|
if self.input_resources[resource_label] != value:
|
|
self.input_resources[resource_label] = value
|
|
widget.set_value(resource_amount_to_text(self.input_resources[resource_label]))
|
|
|
|
|
|
class Machine(BaseNode):
|
|
__identifier__ = "factorygame"
|
|
NODE_NAME = "FactoryGame Machine"
|
|
|
|
MAXIMUM_PERFORMANCE_PROP = "machine max perf"
|
|
ACTUAL_PERFORMANCE_PROP = "machine actual perf"
|
|
AUTOMATIC_PERFORMANCE_PROP = "machine automatic"
|
|
|
|
STYLESHEET_BORDER_COLOR_REGEX = re.compile(
|
|
r"QLineEdit\s*{[^{}]*\s*border:[^;]*(rgb\([^)]+\))", re.MULTILINE | re.DOTALL
|
|
)
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
self.model.width = 240
|
|
self.input_resources: dict[str, float] = {}
|
|
self.possible_input_resources: dict[str, float] = {}
|
|
self.output_resources: dict[str, float] = {}
|
|
self.add_checkbox(Machine.AUTOMATIC_PERFORMANCE_PROP, text="Automatic Mode", state=True)
|
|
widget: NodeCheckBox = self.get_widget(Machine.AUTOMATIC_PERFORMANCE_PROP)
|
|
widget.value_changed.connect(self.recalculate_factor)
|
|
checkbox_widget: QCheckBox = widget.get_custom_widget()
|
|
checkbox_widget.setStyleSheet(
|
|
checkbox_widget.styleSheet() + "\nQCheckBox {\n" f"background-color: transparent;\n" "}"
|
|
)
|
|
self.add_text_input(
|
|
name=Machine.ACTUAL_PERFORMANCE_PROP,
|
|
label="Overall Production",
|
|
text="100",
|
|
)
|
|
widget: NodeLineEdit = self.get_widget(Machine.ACTUAL_PERFORMANCE_PROP)
|
|
line_edit_widget: QLineEdit = widget.get_custom_widget()
|
|
line_edit_widget.setReadOnly(True)
|
|
|
|
def max_performance_changed(self):
|
|
self.set_property(Machine.AUTOMATIC_PERFORMANCE_PROP, False)
|
|
self.recalculate_factor()
|
|
|
|
def recalculate_factor(self):
|
|
max_factor: float = self.get_property(Machine.MAXIMUM_PERFORMANCE_PROP) / 100.0
|
|
if max_factor < 1.0 and self.get_property(Machine.AUTOMATIC_PERFORMANCE_PROP):
|
|
per_machine_factor = 1.0
|
|
else:
|
|
per_machine_factor = max_factor
|
|
all_machines_factor = None
|
|
for resource_label, wanted_resource in self.input_resources.items():
|
|
if len(self.get_input(resource_label).connected_ports()) != 0:
|
|
new_factor = self.possible_input_resources[resource_label] / wanted_resource / per_machine_factor
|
|
if all_machines_factor is None:
|
|
all_machines_factor = new_factor
|
|
elif new_factor < all_machines_factor:
|
|
all_machines_factor = new_factor
|
|
if all_machines_factor is None:
|
|
all_machines_factor = per_machine_factor
|
|
new_perf = int(all_machines_factor * 100.0)
|
|
if int(self.get_property(Machine.ACTUAL_PERFORMANCE_PROP)) != new_perf:
|
|
self.get_widget(name=Machine.ACTUAL_PERFORMANCE_PROP).set_value(str(new_perf))
|
|
self.actual_performance_changed(name=Machine.ACTUAL_PERFORMANCE_PROP, factor=all_machines_factor)
|
|
if self.get_property(Machine.AUTOMATIC_PERFORMANCE_PROP):
|
|
self.set_property(name=Machine.MAXIMUM_PERFORMANCE_PROP, value=100, push_undo=False)
|
|
|
|
def update_input(self, resource_label: str, value: float):
|
|
self.possible_input_resources[resource_label] = value
|
|
self.recalculate_factor()
|
|
|
|
def actual_performance_changed(self, name: str, factor: float):
|
|
if name == Machine.ACTUAL_PERFORMANCE_PROP:
|
|
for ingredient_label, amount in self.input_resources.items():
|
|
resource_text_widget = self.get_widget(in_amount_name(ingredient_label))
|
|
assert (
|
|
resource_text_widget is not None
|
|
), f"No ingredient resource text widget found for {ingredient_label}"
|
|
resource_text_widget.set_value(resource_amount_to_text(amount * factor))
|
|
for result_label, amount in self.output_resources.items():
|
|
resource_text_widget = self.get_widget(out_amount_name(result_label))
|
|
assert resource_text_widget is not None, f"No result resource text widget found for {result_label}"
|
|
new_output_value = amount * factor
|
|
resource_text_widget.set_value(resource_amount_to_text(new_output_value))
|
|
|
|
for port in self.get_output(result_label).connected_ports():
|
|
node = port.node()
|
|
node.update_input(
|
|
resource_label=result_label,
|
|
value=new_output_value,
|
|
)
|
|
|
|
def assign_recipe(self, recipe: Recipe):
|
|
for port_idx in range(len(self._inputs)):
|
|
self.delete_input(port_idx)
|
|
|
|
for port_idx in range(len(self._outputs)):
|
|
self.delete_output(port_idx)
|
|
|
|
self.set_property("name", recipe.join_factories(), push_undo=False)
|
|
|
|
for ingredient in recipe.ingredients:
|
|
resource_label = ingredient.resource.label
|
|
if resource_label in self.input_resources:
|
|
self.input_resources[resource_label] += ingredient.amount_per_minute()
|
|
self.get_widget(in_amount_name(resource_label)).set_value(
|
|
resource_amount_to_text(self.input_resources[resource_label])
|
|
)
|
|
else:
|
|
port = self.add_input(resource_label, multi_input=False, color=INPUT_COLOR)
|
|
port.add_accept_port_type(resource_label, PortTypeEnum.OUT.value, "factorygame.Machine")
|
|
port.add_accept_port_type(resource_label, PortTypeEnum.OUT.value, "factorygame.GlobalInput")
|
|
port.add_accept_port_type(CREATE_MACHINE_PORT_NAME, PortTypeEnum.OUT.value, "factorygame.GlobalInput")
|
|
port.add_accept_port_type(WORLD_OUTPUT_PORT_NAME, PortTypeEnum.OUT.value, "factorygame.GlobalInput")
|
|
self._add_readonly_resource_text(
|
|
in_amount_name(resource_label),
|
|
ingredient,
|
|
self.input_resources,
|
|
resource_label,
|
|
border_color=INPUT_COLOR,
|
|
)
|
|
|
|
for result in recipe.results:
|
|
resource_label = result.resource.label
|
|
if resource_label in self.output_resources:
|
|
self.output_resources[resource_label] += result.amount_per_minute()
|
|
self.get_widget(out_amount_name(resource_label)).set_value(
|
|
resource_amount_to_text(self.output_resources[resource_label])
|
|
)
|
|
else:
|
|
port = self.add_output(resource_label, multi_output=False, color=OUTPUT_COLOR)
|
|
port.add_accept_port_type(resource_label, PortTypeEnum.IN.value, "factorygame.Machine")
|
|
port.add_accept_port_type(resource_label, PortTypeEnum.IN.value, "factorygame.GlobalOutput")
|
|
port.add_accept_port_type(CREATE_MACHINE_PORT_NAME, PortTypeEnum.IN.value, "factorygame.GlobalOutput")
|
|
port.add_accept_port_type(WORLD_INPUT_PORT_NAME, PortTypeEnum.IN.value, "factorygame.GlobalOutput")
|
|
self._add_readonly_resource_text(
|
|
out_amount_name(resource_label),
|
|
result,
|
|
self.output_resources,
|
|
resource_label,
|
|
border_color=OUTPUT_COLOR,
|
|
)
|
|
|
|
self.possible_input_resources.update(self.input_resources)
|
|
|
|
slider = NodeSlider(name=Machine.MAXIMUM_PERFORMANCE_PROP, label="Overclocking Performance", parent=self.view)
|
|
self.add_custom_widget(widget=slider, widget_type=NodePropWidgetEnum.SLIDER.value)
|
|
slider.value_changed.connect(self.max_performance_changed)
|
|
|
|
def _add_readonly_resource_text(
|
|
self,
|
|
name: str,
|
|
flow: ResourceFlow,
|
|
resource_amounts: dict[str, float],
|
|
resource_label: str,
|
|
border_color: tuple,
|
|
) -> NodeLineEdit:
|
|
resource_amounts[resource_label] = flow.amount_per_minute()
|
|
text = resource_amount_to_text(resource_amounts[resource_label])
|
|
return add_resource_text(node=self, name=name, text=text, border_color=border_color, readonly=True)
|
|
|
|
def get_resource_output(self, resource_label: str) -> float:
|
|
return self.output_resources[resource_label] * (int(self.get_property(Machine.ACTUAL_PERFORMANCE_PROP)) / 100.0)
|
|
|
|
|
|
class GraphController(QObject):
|
|
prompt_dialog_show = Signal(str, list, str)
|
|
loading_dialog_show = Signal()
|
|
loading_dialog_hide = Signal()
|
|
|
|
def __init__(self, debug: bool, parent=None):
|
|
super().__init__(parent=parent)
|
|
self.debug = debug
|
|
|
|
self.engine = create_engine("sqlite:///file.db", echo=debug)
|
|
Base.metadata.create_all(bind=self.engine)
|
|
self.graph = NodeGraph(parent=self)
|
|
self.graph.widget.resize(1280, 720)
|
|
self.graph.register_node(Machine)
|
|
self.graph.register_node(GlobalInput)
|
|
self.graph.register_node(GlobalOutput)
|
|
|
|
self.global_input: GlobalInput = self.graph.create_node("factorygame.GlobalInput", push_undo=False)
|
|
self.global_output: GlobalOutput = self.graph.create_node("factorygame.GlobalOutput", push_undo=False)
|
|
|
|
self.graph.port_connected.connect(self.on_port_connected)
|
|
|
|
self._prompt_dialog = QInputDialog(parent=self.graph.widget)
|
|
self._prompt_dialog.setStyleSheet(generate_fgbg_stylesheet())
|
|
self._prompt_dialog.setModal(True)
|
|
self._dialog_future = Future()
|
|
self._prompt_dialog.rejected.connect(lambda: self._dialog_future.set_result(None))
|
|
self._prompt_dialog.accepted.connect(lambda: self._dialog_future.set_result(self._prompt_dialog.textValue()))
|
|
self.prompt_dialog_show.connect(self.show_prompt_dialog)
|
|
|
|
self._loading_dialog = QDialog(parent=self.graph.widget, f=(Qt.Dialog | Qt.ToolTip))
|
|
self._loading_dialog.setStyleSheet(generate_fgbg_stylesheet(0.5))
|
|
self._loading_dialog.setModal(True)
|
|
self._loading_dialog.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
|
|
label = QLabel("Loading…", self._loading_dialog)
|
|
label.setAlignment(Qt.AlignCenter)
|
|
self.loading_dialog_show.connect(self.show_loading_dialog)
|
|
self.loading_dialog_hide.connect(self.hide_loading_dialog)
|
|
|
|
@Slot(str, list, str)
|
|
def show_prompt_dialog(self, text: str, options: list, default: str = ""):
|
|
assert self._prompt_dialog.isHidden(), "Prompt dialog already visible"
|
|
self._prompt_dialog.setLabelText(text)
|
|
self._prompt_dialog.setComboBoxItems(options)
|
|
if default:
|
|
self._prompt_dialog.setTextValue(default)
|
|
self._prompt_dialog.show()
|
|
|
|
@Slot()
|
|
def show_loading_dialog(self):
|
|
self._loading_dialog.show()
|
|
|
|
@Slot()
|
|
def hide_loading_dialog(self):
|
|
self._loading_dialog.hide()
|
|
|
|
def add_machine_from_search(self, search: str):
|
|
recipe_selected_future = Future()
|
|
|
|
def resource_found_db(resource: Resource | None):
|
|
if resource is None:
|
|
return
|
|
|
|
def chose_recipe_async():
|
|
with Session(self.engine) as session:
|
|
chose_recipe(session=session, resource=resource, prompt=self.dialog_prompt).add_done_callback(
|
|
lambda fut: recipe_selected_future.set_result(fut.result())
|
|
)
|
|
|
|
if resource_needs_update(resource):
|
|
fetch_future = self.fetch_recipes_async(resource_label=resource.label)
|
|
fetch_future.add_done_callback(lambda fut: chose_recipe_async)
|
|
else:
|
|
chose_recipe_async()
|
|
|
|
def resource_selected_or_search_cb(resource_future: Future[Resource | None]):
|
|
resource = resource_future.result()
|
|
if resource is None:
|
|
search_future = self.search_resource_async(resource_label=search)
|
|
search_future.add_done_callback(lambda fut: resource_found_db(fut.result()))
|
|
else:
|
|
resource_found_db(resource)
|
|
|
|
def recipe_selected_cb(recipe_future: Future[Recipe | None]):
|
|
recipe = recipe_future.result()
|
|
if recipe is not None:
|
|
recipe_machine: Machine = self.graph.create_node("factorygame.Machine", push_undo=False)
|
|
recipe_machine.assign_recipe(recipe)
|
|
recipe_machine.update()
|
|
self.graph.auto_layout_nodes([self.global_input, recipe_machine, self.global_output])
|
|
self.global_input.set_y_pos(recipe_machine.y_pos())
|
|
self.global_output.set_y_pos(recipe_machine.y_pos())
|
|
self.global_input.update_x_pos(graph=self.graph)
|
|
self.global_output.update_x_pos(graph=self.graph)
|
|
self.graph.center_on([self.global_input, recipe_machine, self.global_output])
|
|
|
|
recipe_selected_future.add_done_callback(recipe_selected_cb)
|
|
with Session(self.engine) as session:
|
|
resource_future = chose_resource(session=session, resource_label=search, prompt=self.dialog_prompt)
|
|
resource_future.add_done_callback(resource_selected_or_search_cb)
|
|
|
|
def show(self):
|
|
self.graph.widget.show()
|
|
|
|
def on_port_connected(self, input_port: Port, output_port: Port):
|
|
if self.debug:
|
|
print(f"Port {output_port} connected to {input_port}")
|
|
output_node = output_port.node()
|
|
if output_node == self.global_input:
|
|
resource_label = input_port.name()
|
|
input_node = input_port.node()
|
|
if output_port.name() == CREATE_MACHINE_PORT_NAME:
|
|
output_port.clear_connections(push_undo=False, emit_signal=False)
|
|
|
|
def recipe_selected_cb(recipe_future: Future[Recipe | None]):
|
|
recipe = recipe_future.result()
|
|
if recipe is not None:
|
|
recipe_machine: Machine = self.graph.create_node("factorygame.Machine", push_undo=True)
|
|
recipe_machine.assign_recipe(recipe)
|
|
recipe_machine.update()
|
|
recipe_machine.set_x_pos(input_node.x_pos() - recipe_machine.view.width - 100)
|
|
recipe_machine.get_output(resource_label).connect_to(input_port)
|
|
self.global_input.update_x_pos(graph=self.graph)
|
|
if isinstance(input_node, Machine):
|
|
input_node.update_input(resource_label, recipe_machine.get_resource_output(resource_label))
|
|
|
|
with Session(self.engine) as session:
|
|
resource = session.scalars(Resource.by_label(resource_label)).one_or_none()
|
|
|
|
def chose_recipe_async():
|
|
with Session(self.engine) as session:
|
|
chose_recipe(
|
|
session=session,
|
|
resource=resource,
|
|
prompt=self.dialog_prompt,
|
|
).add_done_callback(recipe_selected_cb)
|
|
|
|
if resource_needs_update(resource):
|
|
fetch_future = self.fetch_recipes_async(resource_label)
|
|
fetch_future.add_done_callback(lambda fut: chose_recipe_async())
|
|
else:
|
|
chose_recipe_async()
|
|
|
|
elif output_port.name() == WORLD_OUTPUT_PORT_NAME:
|
|
output_port.clear_connections(push_undo=False, emit_signal=False)
|
|
for idx, port in enumerate(self.global_input.output_ports()):
|
|
assert port.name() != resource_label, f"Duplicate output port for {resource_label}"
|
|
# if port.name() == resource_label:
|
|
# port.connect_to(input_port, push_undo=True, emit_signal=False)
|
|
# return
|
|
if isinstance(input_node, Machine):
|
|
resource_amount = parse_resource_amount(
|
|
str(input_node.get_property(in_amount_name(resource_label)))
|
|
)
|
|
new_output_port = self.global_input.create_global_output(
|
|
graph=self.graph,
|
|
resource_label=resource_label,
|
|
initial_resource_amount=resource_amount,
|
|
)
|
|
new_output_port.connect_to(input_port, push_undo=True, emit_signal=False)
|
|
input_node.update_input(resource_label, resource_amount)
|
|
elif isinstance(output_node, Machine):
|
|
input_node = input_port.node()
|
|
resource_label = output_port.name()
|
|
if input_node == self.global_output:
|
|
if input_port.name() == CREATE_MACHINE_PORT_NAME:
|
|
input_port.clear_connections(push_undo=False, emit_signal=False)
|
|
|
|
def recipe_selected_cb(recipe_future: Future[Recipe | None]):
|
|
recipe = recipe_future.result()
|
|
if recipe is not None:
|
|
recipe_machine: Machine = self.graph.create_node("factorygame.Machine", push_undo=True)
|
|
recipe_machine.assign_recipe(recipe)
|
|
recipe_machine.update()
|
|
recipe_machine.set_x_pos(output_node.x_pos() + output_node.view.width + 100)
|
|
output_port.connect_to(recipe_machine.get_input(resource_label))
|
|
self.global_output.update_x_pos(graph=self.graph)
|
|
|
|
with Session(self.engine) as session:
|
|
resource = session.scalars(Resource.by_label(resource_label)).one_or_none()
|
|
|
|
def chose_recipe_async():
|
|
chose_recipe(
|
|
session=session, resource=resource, prompt=self.dialog_prompt, ingredient=True
|
|
).add_done_callback(recipe_selected_cb)
|
|
|
|
if resource_needs_update(resource):
|
|
fetch_future = self.fetch_recipes_async(resource_label=resource_label)
|
|
fetch_future.add_done_callback(lambda fut: chose_recipe_async())
|
|
else:
|
|
chose_recipe_async()
|
|
|
|
elif input_port.name() == WORLD_INPUT_PORT_NAME:
|
|
input_port.clear_connections(push_undo=False, emit_signal=False)
|
|
for idx, port in enumerate(self.global_output.output_ports()):
|
|
assert port.name() != resource_label, f"Duplicate output port for {resource_label}"
|
|
# if port.name() == resource_label:
|
|
# port.connect_to(input_port, push_undo=True, emit_signal=False)
|
|
# return
|
|
resource_amount = output_node.get_resource_output(resource_label)
|
|
new_input_port = self.global_output.create_global_input(
|
|
graph=self.graph,
|
|
resource_label=resource_label,
|
|
initial_resource_amount=resource_amount,
|
|
)
|
|
output_port.connect_to(new_input_port, push_undo=True, emit_signal=False)
|
|
elif isinstance(input_node, Machine):
|
|
resource_amount = output_node.get_resource_output(resource_label)
|
|
input_node.update_input(
|
|
resource_label,
|
|
resource_amount,
|
|
)
|
|
|
|
def fetch_recipes_async(self, resource_label):
|
|
if self.debug:
|
|
print("Fetching recipes for resource", resource_label)
|
|
fetcher_thread = AsyncResourceFetcher(
|
|
parent=self.graph,
|
|
resource_label=resource_label,
|
|
engine=self.engine,
|
|
debug=self.debug,
|
|
)
|
|
fetch_future = Future()
|
|
self.loading_dialog_show.emit()
|
|
fetch_future.add_done_callback(lambda fut: self.loading_dialog_hide.emit())
|
|
fetcher_thread.finished.connect(lambda: fetch_future.set_result(None))
|
|
fetcher_thread.start()
|
|
return fetch_future
|
|
|
|
def search_resource_async(self, resource_label) -> Future[Resource]:
|
|
if self.debug:
|
|
print("Searching resource", resource_label)
|
|
|
|
loading_future = Future()
|
|
|
|
def show_prompt(*args, **kwargs):
|
|
loading_future.set_result(None)
|
|
return self.dialog_prompt(*args, **kwargs)
|
|
|
|
fetcher_thread = AsyncResourceFinder(
|
|
parent=self.graph,
|
|
resource_label=resource_label,
|
|
engine=self.engine,
|
|
prompt=show_prompt,
|
|
debug=self.debug,
|
|
)
|
|
self.loading_dialog_show.emit()
|
|
loading_future.add_done_callback(lambda fut: self.loading_dialog_hide.emit())
|
|
fetcher_thread.start()
|
|
return fetcher_thread.result
|
|
|
|
def dialog_prompt(self, options: dict[int, str], text: str, default: int) -> Future[int | None]:
|
|
if self.debug:
|
|
print("Displaying QInputDialog with options:", ", ".join(options.values()))
|
|
|
|
reversed_options: dict[str, int] = {value: key for key, value in options.items()}
|
|
ret = Future()
|
|
self._dialog_future = Future()
|
|
|
|
def map_result(fut: Future):
|
|
result = fut.result()
|
|
if result is None:
|
|
ret.set_result(None)
|
|
else:
|
|
ret.set_result(reversed_options[result])
|
|
|
|
self._dialog_future.add_done_callback(map_result)
|
|
self.prompt_dialog_show.emit(text, list(reversed_options.keys()), options.get(default, ""))
|
|
return ret
|
|
|
|
|
|
@click.command
|
|
@click.option("--debug", is_flag=True)
|
|
@click.argument("search")
|
|
def main(debug: bool, search: str):
|
|
app = QtWidgets.QApplication([])
|
|
graph_controller = GraphController(debug=debug)
|
|
graph_controller.show()
|
|
graph_controller.add_machine_from_search(search=search)
|
|
app.exec_()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|