ajurna/pysatcalc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Introduce enums for items, machines, and recipes, and integrate recipe selection logic. Add .gitignore and improve Flask app for query-based input handling.

Browse Source
This commit is contained in:
Ajurna
2025-11-06 20:36:26 +00:00
parent 5536485a8c
commit 562b33dff9
6 changed files with 721 additions and 224 deletions
Download Patch File Download Diff File Expand all files Collapse all files

290
main.py
View File

@@ -1,201 +1,12 @@
from __future__ import annotations
from dataclasses import dataclass
from enum import Enum
from math import ceil
from typing import Dict, List, Tuple, Optional
from flask import Flask, render_template, request
from pydantic import BaseModel, Field
from plus import Items, Machines, Recipes, Recipe
app = Flask(__name__)
class Item(BaseModel):
name: str
class Machine(BaseModel):
name: str
class Machines(Enum):
Miner = Machine(name="Miner")
Smelter = Machine(name="Smelter")
Constructor = Machine(name="Constructor")
Assembler = Machine(name="Assembler")
Sorter = Machine(name="Sorter")
Crusher = Machine(name="Crusher")
Foundry = Machine(name="Foundry")
class Items(Enum):
IronIngot = Item(name="Iron Ingot")
CopperIngot = Item(name="Copper Ingot")
Limestone = Item(name="Limestone")
IronOre = Item(name="Iron Ore")
CopperOre = Item(name="Copper Ore")
IronPlate = Item(name="Iron Plate")
IronRod = Item(name="Iron Rod")
Wire = Item(name="Wire")
Cable = Item(name="Cable")
Concrete = Item(name="Concrete")
ReinforcedIronPlate = Item(name="Reinforced Iron Plate")
ModularFrame = Item(name="Modular Frame")
BronzeBeam = Item(name="Bronze Beam")
TinPlate = Item(name="Tin Plate")
TinIngot = Item(name="Tin Ingot")
CrushedTin = Item(name="Crushed Tin")
CrushedIron = Item(name="Crushed Iron")
CrushedGangue = Item(name="Crushed Gangue")
CrushedSiterite = Item(name="Crushed Siterite")
SiteriteOre = Item(name="Siterite Ore")
Screws = Item(name="Screws")
BronzeIngot = Item(name="Bronze Ingot")
CrushedCopper = Item(name="Crushed Copper")
CrushedMagnesium = Item(name="Crushed Magnesium")
CrushedCallanite = Item(name="Crushed Callanite")
CallaniteOre = Item(name="Callanite Ore")
class RawResources(Enum):
IronOre = Items.IronOre
CopperOre = Items.CopperOre
Limestone = Items.Limestone
# --- Domain model (minimal, extensible) ---
class Recipe(BaseModel):
name: str # Human-friendly name
building: Machines # e.g., "Smelter", "Constructor"
outputs: Dict[Items, float] # Produced item name
inputs: Dict[Items, float] = Field(default_factory=dict)
# A very small starter dataset (default, non-alternate recipes)
# Rates are per building per minute, matching Satisfactory default recipes.
class Recipes(Enum):
ModularFrame = Recipe(
name="Modular Frame",
building=Machines.Assembler,
outputs={Items.ModularFrame: 6.0},
inputs={
Items.ReinforcedIronPlate: 7.5,
Items.BronzeBeam: 7.5,
},
)
ReinforcedIronPlate = Recipe(
name="Reinforced Iron Plate",
building=Machines.Assembler,
outputs={Items.ReinforcedIronPlate: 5.0},
inputs={
Items.TinPlate: 20.0,
Items.Screws: 37.5,
},
)
TinPlate = Recipe(
name="Tin Plate",
building=Machines.Assembler,
outputs={Items.TinPlate: 40.0},
inputs={
Items.IronPlate: 20.0,
Items.TinIngot: 30.0,
},
)
TinIngot = Recipe(
name="Tin Ingot",
building=Machines.Smelter,
outputs={Items.TinIngot: 15.0},
inputs={Items.CrushedTin: 15.0},
)
CrushedIron = Recipe(
name="Crushed Iron",
building=Machines.Sorter,
outputs={
Items.CrushedIron: 90.0,
Items.CrushedTin: 60.0,
Items.CrushedGangue: 40.0,
},
inputs={Items.CrushedSiterite: 120.0},
)
CrushedSiterite = Recipe(
name="Crushed Siterite",
building=Machines.Crusher,
outputs={
Items.CrushedSiterite: 60.0,
Items.CrushedGangue: 25.0,
},
inputs={Items.SiteriteOre: 60.0},
)
IronPlate = Recipe(
name="Iron Plate",
building=Machines.Constructor,
outputs={Items.IronPlate: 20.0},
inputs={Items.IronIngot: 30.0},
)
IronIngot = Recipe(
name="Iron Ingot",
building=Machines.Smelter,
outputs={Items.IronIngot: 30.0},
inputs={Items.CrushedIron: 30.0},
)
Screws = Recipe(
name="Screws",
building=Machines.Constructor,
outputs={Items.Screws: 50.0},
inputs={Items.IronRod: 20.0},
)
IronRod = Recipe(
name="Iron Rod",
building=Machines.Constructor,
outputs={Items.IronRod: 15.0},
inputs={Items.IronIngot: 15.0},
)
BronzeBeam = Recipe(
name="Bronze Beam",
building=Machines.Constructor,
outputs={Items.BronzeBeam: 7.5},
inputs={Items.BronzeIngot: 22.5},
)
BronzeIngot = Recipe(
name="Bronze Ingot",
building=Machines.Foundry,
outputs={Items.BronzeIngot: 45.0},
inputs={
Items.CopperIngot: 36.0,
Items.TinIngot: 15.0,
},
)
CopperIngot = Recipe(
name="Copper Ingot",
building=Machines.Smelter,
outputs={Items.CopperIngot: 48.0},
inputs={Items.CrushedCopper: 48.0},
)
CrushedCopper = Recipe(
name="Crushed Copper",
building=Machines.Sorter,
outputs={
Items.CrushedCopper: 96.0,
Items.CrushedMagnesium: 80.0,
Items.CrushedGangue: 40.0,
},
inputs={Items.CrushedCallanite: 120.0},
)
CrushedCallanite = Recipe(
name="Crushed Callanite",
building=Machines.Sorter,
outputs={
Items.CrushedCallanite: 60.0,
Items.CrushedGangue: 25.0,
},
inputs={Items.CallaniteOre: 60.0},
)
# Items which are considered raw resources (mined); they have no crafting recipes here
RAW_RESOURCES = {
Items.IronOre,
Items.CopperOre,
Items.Limestone,
Items.SiteriteOre,
}
def compute_chain(targets: Dict[Items, float]) -> Tuple[Dict[str, float], List[dict], Dict[str, float], Dict[str, float]]:
"""
@@ -205,14 +16,43 @@ def compute_chain(targets: Dict[Items, float]) -> Tuple[Dict[str, float], List[d
- total production rates (echo of targets summed if multiple entries per item)
- unused byproducts (items/min) produced by multi-output recipes but not consumed or targeted
Uses the Recipes enum and Items objects.
Now supports alternate recipes: when multiple recipes produce the same output item,
a selection heuristic is used unless an explicit preference is configured.
"""
# Build a mapping from output item -> recipe that produces it (default recipe set)
output_to_recipe: Dict[Items, Recipe] = {}
# Build a mapping from output item -> list of recipes that produce it
output_to_recipes: Dict[Items, List[Recipe]] = {}
for r in Recipes:
recipe = r.value
for out_item in recipe.outputs.keys():
# prefer the first seen; can be extended to handle alternates later
output_to_recipe.setdefault(out_item, recipe)
output_to_recipes.setdefault(out_item, []).append(recipe)
# Optional explicit preferences: map output Item -> recipe name to prefer
# Users can populate/modify this mapping elsewhere if desired.
PREFERRED_RECIPE_BY_OUTPUT: Dict[Items, str] = {}
# Heuristic to select a recipe when multiple alternatives exist
def select_recipe_for(item: Items) -> Optional[Recipe]:
candidates = output_to_recipes.get(item, [])
if not candidates:
return None
# If explicit preference exists and matches a candidate, use it
pref_name = PREFERRED_RECIPE_BY_OUTPUT.get(item)
if pref_name:
for c in candidates:
if c.name == pref_name:
return c
# Otherwise pick the candidate with the highest per-building output for this item
# Tie-breaker 1: smallest total input per unit of this output
# Tie-breaker 2: deterministic by name
def score(c: Recipe) -> Tuple[float, float, str]:
per_build_out = c.outputs.get(item, 0.0)
total_input = sum(c.inputs.values())
# Lower input per unit is better; we express as (total_input/per_build_out)
# Protect against division by zero
eff = float('inf') if per_build_out <= 0 else (total_input / per_build_out)
return (per_build_out, -eff, c.name)
return sorted(candidates, key=score, reverse=True)[0]
# Aggregate demands for each item
demand: Dict[Items, float] = {}
@@ -236,18 +76,24 @@ def compute_chain(targets: Dict[Items, float]) -> Tuple[Dict[str, float], List[d
# Expand demanded craftable items into their inputs until only raw remain
while True:
craftable_item = next(
(i for i, r in demand.items() if r > 1e-9 and i in output_to_recipe),
(i for i, r in demand.items() if r > 1e-9 and i in output_to_recipes),
None,
)
if craftable_item is None:
break
needed_rate = demand[craftable_item]
recipe = output_to_recipe[craftable_item]
recipe = select_recipe_for(craftable_item)
if recipe is None:
# Should not happen because craftable_item is in output_to_recipes,
# but guard anyway: treat as raw if selection failed.
demand[craftable_item] = 0.0
raw_requirements[craftable_item.value.name] = raw_requirements.get(craftable_item.value.name, 0.0) + needed_rate
continue
per_building_output = recipe.outputs[craftable_item]
# Buildings needed
buildings = needed_rate / per_building_output
buildings = needed_rate / per_building_output if per_building_output > 0 else 0.0
buildings_ceiled = ceil(buildings - 1e-9)
utilization = 0.0 if buildings_ceiled == 0 else buildings / buildings_ceiled
@@ -282,11 +128,7 @@ def compute_chain(targets: Dict[Items, float]) -> Tuple[Dict[str, float], List[d
for item, rate in demand.items():
if rate <= 1e-9:
continue
if item in RAW_RESOURCES or item not in output_to_recipe:
raw_requirements[item.value.name] = raw_requirements.get(item.value.name, 0.0) + rate
else:
# Shouldn't happen, but guard
raw_requirements[item.value.name] = raw_requirements.get(item.value.name, 0.0) + rate
raw_requirements[item.value.name] = raw_requirements.get(item.value.name, 0.0) + rate
# Merge steps for same item/building
merged: Dict[Tuple[str, str], dict] = {}
@@ -321,7 +163,7 @@ def compute_chain(targets: Dict[Items, float]) -> Tuple[Dict[str, float], List[d
return raw_requirements, merged_steps, total_outputs, unused_byproducts
@app.route("/", methods=["GET", "POST"])
@app.route("/", methods=["GET"])
def index():
# Build selectable items list from Items enum (display names)
item_names = sorted([i.value.name for i in Items])
@@ -332,9 +174,11 @@ def index():
selected_item = item_names[0] if item_names else ""
selected_rate = 60.0
if request.method == "POST":
item_name = request.form.get("item") or selected_item
rate_str = request.form.get("rate")
# Read from query parameters for bookmarkable URLs
item_name = request.args.get("item") or selected_item
rate_str = request.args.get("rate")
rate = None
if rate_str is not None and rate_str != "":
try:
rate = float(rate_str)
if rate < 0:
@@ -343,24 +187,24 @@ def index():
error = "Please enter a valid non-negative number for rate (items per minute)."
rate = None
selected_item = item_name
if rate is not None:
selected_rate = rate
selected_item = item_name
if rate is not None:
selected_rate = rate
if not error and item_name and rate is not None:
item_obj = name_to_item.get(item_name)
if item_obj is None:
error = "Unknown item selected."
else:
targets = {item_obj: rate}
raw, steps, outputs, unused = compute_chain(targets)
result = {
"targets": {item_name: rate},
"raw": raw,
"steps": steps,
"outputs": outputs,
"unused": unused,
}
if not error and item_name and rate is not None:
item_obj = name_to_item.get(item_name)
if item_obj is None:
error = "Unknown item selected."
else:
targets = {item_obj: rate}
raw, steps, outputs, unused = compute_chain(targets)
result = {
"targets": {item_name: rate},
"raw": raw,
"steps": steps,
"outputs": outputs,
"unused": unused,
}
return render_template(
"index.html",