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)