226 lines
8.6 KiB
Python
226 lines
8.6 KiB
Python
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__)
|
|
|
|
|
|
def compute_chain(targets: Dict[Items, float]) -> Tuple[Dict[str, float], List[dict], Dict[str, float], Dict[str, float]]:
|
|
"""
|
|
Given desired output rates (item -> units/min), compute:
|
|
- required raw input rates (raw item -> units/min)
|
|
- a flat list of steps with building counts and per-building utilization
|
|
- 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 -> 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():
|
|
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] = {}
|
|
|
|
def add_demand(item: Items, rate: float) -> None:
|
|
if rate == 0:
|
|
return
|
|
demand[item] = demand.get(item, 0.0) + rate
|
|
|
|
for item, rate in targets.items():
|
|
add_demand(item, rate)
|
|
|
|
# Work lists
|
|
steps: List[dict] = []
|
|
raw_requirements: Dict[str, float] = {}
|
|
|
|
# Track produced and consumed rates to calculate unused byproducts
|
|
produced: Dict[Items, float] = {}
|
|
consumed: Dict[Items, float] = {}
|
|
|
|
# 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_recipes),
|
|
None,
|
|
)
|
|
if craftable_item is None:
|
|
break
|
|
|
|
needed_rate = demand[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 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
|
|
|
|
# Record the step (as display-friendly strings)
|
|
steps.append({
|
|
"item": craftable_item.value.name,
|
|
"recipe": recipe.name,
|
|
"building": recipe.building.value.name,
|
|
"target_rate": needed_rate,
|
|
"per_building_output": per_building_output,
|
|
"buildings_float": buildings,
|
|
"buildings": buildings_ceiled,
|
|
"utilization": utilization,
|
|
})
|
|
|
|
# Consume this demand and add input demands
|
|
demand[craftable_item] -= needed_rate
|
|
|
|
scale = buildings # exact fractional buildings to match demand exactly
|
|
|
|
# Account for all outputs produced by this recipe at the chosen scale
|
|
for out_item, out_rate_per_build in (recipe.outputs or {}).items():
|
|
produced[out_item] = produced.get(out_item, 0.0) + out_rate_per_build * scale
|
|
|
|
# Add input demands and track consumption
|
|
for in_item, in_rate_per_build in (recipe.inputs or {}).items():
|
|
rate_needed = in_rate_per_build * scale
|
|
add_demand(in_item, rate_needed)
|
|
consumed[in_item] = consumed.get(in_item, 0.0) + rate_needed
|
|
|
|
# What's left in demand are raw items
|
|
for item, rate in demand.items():
|
|
if rate <= 1e-9:
|
|
continue
|
|
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] = {}
|
|
for s in steps:
|
|
key = (s["item"], s["building"])
|
|
if key not in merged:
|
|
merged[key] = {**s}
|
|
else:
|
|
m = merged[key]
|
|
m["target_rate"] += s["target_rate"]
|
|
m["buildings_float"] += s["buildings_float"]
|
|
m["buildings"] += s["buildings"]
|
|
total_buildings = m["buildings"]
|
|
m["utilization"] = 0.0 if total_buildings == 0 else m["buildings_float"] / total_buildings
|
|
|
|
merged_steps = sorted(merged.values(), key=lambda x: (x["building"], x["item"]))
|
|
|
|
# Echo total outputs (same as targets possibly aggregated), as item-name -> rate
|
|
total_outputs: Dict[str, float] = {}
|
|
for item, rate in targets.items():
|
|
total_outputs[item.value.name] = total_outputs.get(item.value.name, 0.0) + rate
|
|
|
|
# Compute unused byproducts: produced but not consumed and not part of explicit targets
|
|
unused_byproducts: Dict[str, float] = {}
|
|
for item, qty_produced in produced.items():
|
|
qty_consumed = consumed.get(item, 0.0)
|
|
qty_targeted = targets.get(item, 0.0)
|
|
unused = qty_produced - qty_consumed - qty_targeted
|
|
if unused > 1e-9:
|
|
unused_byproducts[item.value.name] = unused
|
|
|
|
return raw_requirements, merged_steps, total_outputs, unused_byproducts
|
|
|
|
|
|
@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])
|
|
name_to_item = {i.value.name: i for i in Items}
|
|
|
|
result = None
|
|
error = None
|
|
selected_item = item_names[0] if item_names else ""
|
|
selected_rate = 60.0
|
|
|
|
# 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:
|
|
raise ValueError
|
|
except (TypeError, ValueError):
|
|
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
|
|
|
|
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",
|
|
items=item_names,
|
|
result=result,
|
|
error=error,
|
|
selected_item=selected_item,
|
|
selected_rate=selected_rate,
|
|
)
|
|
|
|
|
|
def create_app():
|
|
return app
|
|
|
|
|
|
if __name__ == "__main__":
|
|
# For local dev: python main.py
|
|
app.run(host="0.0.0.0", port=5000, debug=True)
|