rngoptimizer 0.1.1__tar.gz

rngoptimizer-0.1.1/PKG-INFO

@@ -0,0 +1,86 @@
+Metadata-Version: 2.3
+Name: rngoptimizer
+Version: 0.1.1
+Summary: Optimize your Tycoon RNG:Optimizer factory
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+
+# Tycoon RNG : Refinery Optimizer 
+TRRO is a tool developed to help you optimize your setup to maximize profit in the game Tycoon RNG: Refinery.
+It uses an asynchronous Genetic Algorithm to find the best value without much computing power and without having to check all 60 quadrillion combinations.
+## Features
+- Random runs to avoid shallow bests
+- A comprehensive and easy way to pass in available buildings
+- An estimated value
+- Handling of complex tag interactions, rarity multipliers, and more through an in-depth class system
+- Future-proof with clear syntax and buildings interactions. Adding a building is done with a single line!
+
+## Installation and use
+1. Download the source code by clicking the green **Code** button on the top right and **Download ZIP**.
+2. Unzip the file.
+3. Write your available buildings in available_buildings.txt or another text file in the same directory using the following syntax:
+
+   **RARITY1 RARITY2 RARITY3 - BUILDING NAME**
+
+   Capitalization is important. For example:
+   - **Negative Overpowered - Slime Duper** is correct
+   - **OP H - Ancient Ruins** is correct
+   - **Hyperspace Electric Dropper** is incorrect
+   - **negative magical tree** is incorrect
+4. run *runme.py*. Make sure you have python installed.
+5. When prompted, enter the number of droppers slots you have on your base, the number of upgraders, and the preset. To use the default value, press enter. *(Default value can also be set in available buildings.txt)*
+6. Wait for the program to finish.
+7. The last line will be the best found buildings and the estimated value produced. It will also be saved to *optimized_buildings.txt*.
+8. Done!
+
+## Frequently Asked Questions
+
+<details>
+<summary><b>Is this safe?</b></summary>
+<br>
+
+Yes. It does not read from any file other than available_buildings.txt and does not write to any file other than optimized_buildings.txt. This is a fully open-source project, and anyone with Python experience can confirm this program does what it says it does.
+
+</details>
+
+
+<details>
+<summary><b>Is this linked to my Roblox Account?</b></summary>
+<br>
+
+No. It requires you to manually add in your own buildings by writing them down. It does not have access to your Roblox account, and requires no login.
+
+</details>
+
+
+<details>
+<summary><b>I can't open runme.py!</b></summary>
+<br>
+
+Make sure you have Python 3.14 installed. you can find it [here.](https://www.python.org/downloads/)
+
+</details>
+
+<details>
+<summary><b>&lt;Building&gt; isn't recognized!</b></summary>
+<br>
+
+The building might've been added in a recent update. You can notify me on the TR:R Discord or DM me: **@Elie07**
+
+</details>
+
+<details>
+<summary><b>The factory found is worse than the one I have right now!</b></summary>
+<br>
+
+The algorithm isn't perfect, and is by definition not very intelligent. It's basically a better trial-and-error. I'm working on upgrading the algorithm to be more performant. 
+
+</details>
+
+<details>
+<summary><b>I built the recommended factory, but it doesn't perform the same!</b></summary>
+<br>
+
+I'm not affiliated with the TR:R developement team and have no way to check if my calculations are accurate. If you run into this issue, please send me your available buildings, the setup the algorithm gave you and what you're getting in game via discord: **@Elie07**
+
+</details>

rngoptimizer-0.1.1/README.md

@@ -0,0 +1,79 @@
+# Tycoon RNG : Refinery Optimizer 
+TRRO is a tool developed to help you optimize your setup to maximize profit in the game Tycoon RNG: Refinery.
+It uses an asynchronous Genetic Algorithm to find the best value without much computing power and without having to check all 60 quadrillion combinations.
+## Features
+- Random runs to avoid shallow bests
+- A comprehensive and easy way to pass in available buildings
+- An estimated value
+- Handling of complex tag interactions, rarity multipliers, and more through an in-depth class system
+- Future-proof with clear syntax and buildings interactions. Adding a building is done with a single line!
+
+## Installation and use
+1. Download the source code by clicking the green **Code** button on the top right and **Download ZIP**.
+2. Unzip the file.
+3. Write your available buildings in available_buildings.txt or another text file in the same directory using the following syntax:
+
+   **RARITY1 RARITY2 RARITY3 - BUILDING NAME**
+
+   Capitalization is important. For example:
+   - **Negative Overpowered - Slime Duper** is correct
+   - **OP H - Ancient Ruins** is correct
+   - **Hyperspace Electric Dropper** is incorrect
+   - **negative magical tree** is incorrect
+4. run *runme.py*. Make sure you have python installed.
+5. When prompted, enter the number of droppers slots you have on your base, the number of upgraders, and the preset. To use the default value, press enter. *(Default value can also be set in available buildings.txt)*
+6. Wait for the program to finish.
+7. The last line will be the best found buildings and the estimated value produced. It will also be saved to *optimized_buildings.txt*.
+8. Done!
+
+## Frequently Asked Questions
+
+<details>
+<summary><b>Is this safe?</b></summary>
+<br>
+
+Yes. It does not read from any file other than available_buildings.txt and does not write to any file other than optimized_buildings.txt. This is a fully open-source project, and anyone with Python experience can confirm this program does what it says it does.
+
+</details>
+
+
+<details>
+<summary><b>Is this linked to my Roblox Account?</b></summary>
+<br>
+
+No. It requires you to manually add in your own buildings by writing them down. It does not have access to your Roblox account, and requires no login.
+
+</details>
+
+
+<details>
+<summary><b>I can't open runme.py!</b></summary>
+<br>
+
+Make sure you have Python 3.14 installed. you can find it [here.](https://www.python.org/downloads/)
+
+</details>
+
+<details>
+<summary><b>&lt;Building&gt; isn't recognized!</b></summary>
+<br>
+
+The building might've been added in a recent update. You can notify me on the TR:R Discord or DM me: **@Elie07**
+
+</details>
+
+<details>
+<summary><b>The factory found is worse than the one I have right now!</b></summary>
+<br>
+
+The algorithm isn't perfect, and is by definition not very intelligent. It's basically a better trial-and-error. I'm working on upgrading the algorithm to be more performant. 
+
+</details>
+
+<details>
+<summary><b>I built the recommended factory, but it doesn't perform the same!</b></summary>
+<br>
+
+I'm not affiliated with the TR:R developement team and have no way to check if my calculations are accurate. If you run into this issue, please send me your available buildings, the setup the algorithm gave you and what you're getting in game via discord: **@Elie07**
+
+</details>

rngoptimizer-0.1.1/pyproject.toml

@@ -0,0 +1,14 @@
+[project]
+name = "rngoptimizer"
+version = "0.1.1"
+description = "Optimize your Tycoon RNG:Optimizer factory"
+readme = "README.md"
+requires-python = ">=3.14"
+dependencies = []
+
+[project.scripts]
+rngoptimizer = "rngoptimizer.cli:main_cli"
+
+[build-system]
+requires = ["uv_build>=0.12.12,<0.13.0"]
+build-backend = "uv_build"

rngoptimizer-0.1.1/pyproject.toml.orig

@@ -0,0 +1,14 @@
+[project]
+name = "rngoptimizer"
+version = "0.1.1"
+description = "Optimize your Tycoon RNG:Optimizer factory"
+readme = "README.md"
+requires-python = ">=3.14"
+dependencies = []
+
+[project.scripts]
+rngoptimizer = "rngoptimizer.cli:main_cli"
+
+[build-system]
+requires = ["uv_build>=0.12.12,<0.13.0"]
+build-backend = "uv_build"

rngoptimizer-0.1.1/src/rngoptimizer/__main__.py

@@ -0,0 +1,5 @@
+if __name__ == "__main__":
+    from rngoptimizer.engine import main
+    import multiprocessing
+    multiprocessing.freeze_support()
+    main()

rngoptimizer-0.1.1/src/rngoptimizer/buildings.py

@@ -0,0 +1,140 @@
+Bonuses = ["Fire", "Wet", "Aired", "Magnetic", "Ancient", "Slimed", "Acid", "Nuclear", "Fueled", "Nebula"]
+Destroy_timers = {"Fire": 7.5, "Acid":8.0, "Nuclear":7.5}
+Rarities = {"Standard": 1, "Overpowered": 2, "Negative": 3.5, "Hyperspace": 6, "":1, "OP": 2, "N": 3.5, "H": 6}
+
+##TODO: Instead of handling tags, vulns, and raritites as strings, handle them as ints for faster runtime
+
+def apply_rarities(rarities, value):
+    for rarity in rarities.split(" "):
+        value *= Rarities[rarity]
+    return value
+
+
+class Item:
+    def __init__(self, bonuses, effects, vulnerabilities, immunities, value, destroy_timers=None):
+        self.bonuses = dict(bonuses)
+        self.effects = list(effects)
+        self.vulnerabilities = list(vulnerabilities)
+        self.immunities = list(immunities)
+        self.value = value
+        self.destroy_timers = {} if destroy_timers is None else dict(destroy_timers)
+
+    #In between machines: removes effects it's immune to (fallback), applies destroy timers, and applies native bonuses (from the dropper)
+    def update(self, time):
+        for effect in self.effects:
+            if effect in self.immunities:
+                self.effects[:] = [active_effect for active_effect in self.effects if active_effect != effect]
+                continue
+            if effect in Destroy_timers:
+                if effect not in self.destroy_timers:
+                    self.destroy_timers[effect] = Destroy_timers[effect] - time
+                else:
+                    self.destroy_timers[effect] -= time
+                if self.destroy_timers[effect] <= 0:
+                    self.value = 0
+            if effect in self.bonuses:
+                self.value *= self.bonuses[effect]
+                self.bonuses.pop(effect)
+        return self
+
+
+class Dropper:
+    def __init__(self, name, eff, rarity="Standard", bonus=None, vulnerabilities=None, immunities=None):
+        self.name = name
+        self.efficiency = eff
+        self.rarity = rarity
+        self.bonus = {} if bonus is None else bonus
+        self.vulnerabilities = [] if vulnerabilities is None else vulnerabilities
+        self.immunities = [] if immunities is None else immunities
+
+    #Returns an Item object with the dropper's bonuses, vulnerabilities, immunities, and value (efficiency * rarity multiplier)
+    def drop(self):
+        value = apply_rarities(self.rarity, self.efficiency)
+        return Item(self.bonus, [], self.vulnerabilities, self.immunities, value)
+
+class Upgrader:
+    def __init__(self, name, mult, rarity="Standard", effect_add=None, effect_remove=None, cond_effect_add=None, trans_effect=None, bonuses=None, destroy_chance=0.0):
+        self.rarity = rarity
+        self.name = name
+        self.mult = mult
+        self.effect_add = [] if effect_add is None else effect_add
+        self.effect_remove = [] if effect_remove is None else effect_remove
+        self.cond_effect_add = {} if cond_effect_add is None else cond_effect_add
+        self.trans_effect = {} if trans_effect is None else trans_effect
+        self.bonuses = {} if bonuses is None else bonuses
+        self.destroy_chance = destroy_chance
+    def upgrade(self, item):
+
+        #Multiply the item's value by the upgrader's multiplier and apply rarity multiplier
+        item.value *= self.mult
+        item.value = apply_rarities(self.rarity, item.value)
+
+
+        #Remove all effects from effect_remove
+        if "All" in self.effect_remove:
+            removed_effects = set(item.effects)
+            item.effects.clear()
+            for effect in removed_effects:
+                item.destroy_timers.pop(effect, None)
+        else:
+            removed_effects = set(self.effect_remove).intersection(item.effects)
+            item.effects[:] = [effect for effect in item.effects if effect not in self.effect_remove]
+            for effect in removed_effects:
+                item.destroy_timers.pop(effect, None)
+
+        #Apply bonuses to the item's value if the item has the corresponding effect
+        for bonus in self.bonuses:
+            if bonus in item.effects:
+                item.value *= self.bonuses[bonus]
+
+        #Add effects from effect_add to the item, and add vulnerabilities if the effect starts with "V-"
+        for effect in self.effect_add:
+            if effect.startswith("V-"):
+                item.vulnerabilities.append(effect[2:])
+            else:
+                item.effects.append(effect)
+
+        #Add conditional effects based on the item's current effects (1 per effect)
+        for effect, additions in self.cond_effect_add.items():
+            for _ in range(item.effects.count(effect)):
+                item.effects.extend(additions)
+
+        #Transform effects based on trans_effect mapping (1 per effect)
+        for index, effect in enumerate(item.effects):
+            if effect in self.trans_effect:
+                item.effects[index] = self.trans_effect[effect]
+
+        #Multiply the item's value by (1 - destroy_chance) to simulate the chance of destruction
+        if self.destroy_chance > 0:
+            item.value *= (1 - self.destroy_chance)
+
+        return item
+        
+class Processor:
+    def __init__(self, name, mult, rarity="Standard", bonus={}, onlyaccept=[], refuse=[]):
+        self.name = name
+        self.mult = mult
+        self.rarity = rarity
+        self.bonus = bonus
+        self.onlyaccept = onlyaccept
+        self.refuse = refuse
+
+    def process(self, item):
+
+        #If the processor has onlyaccept effects and the item does not have any of those effects, set the item's value to 0
+        if self.onlyaccept and not any(effect in item.effects for effect in self.onlyaccept):
+            item.value = 0
+
+        #If the processor has refuse effects and the item has any of those effects, set the item's value to 0
+        if any(effect in item.effects for effect in self.refuse):
+            item.value = 0
+
+        #Multiply the item's value by the processor's multiplier and apply rarity multiplier
+        item.value *= self.mult
+        item.value = apply_rarities(self.rarity, item.value)
+
+        #Apply bonuses to the item's value if the item has the corresponding effect
+        for effect in self.bonus:
+            if effect in item.effects:
+                item.value *= self.bonus[effect]
+        return item

rngoptimizer-0.1.1/src/rngoptimizer/cli.py

@@ -0,0 +1,32 @@
+
+import argparse
+from rngoptimizer.engine import run
+
+def main_cli():
+
+    parser = argparse.ArgumentParser(description="Run the building optimization engine.")
+    parser.add_argument("-p","--path", type=str, default="available_buildings.txt", help="Path to available buildings file")
+    parser.add_argument("-r", "--runs", type=int, default=1, help="Number of runs")
+    parser.add_argument("-d", "--droppers", type=int, default=0, help="Number of droppers")
+    parser.add_argument("-u", "--upgraders", type=int, default=0, help="Number of upgraders")
+
+    args = parser.parse_args()
+    if args.path == "":
+        args.path = "available_buildings.txt"
+    if args.runs < 1:
+        args.runs = 1
+    args.droppers = abs(args.droppers)
+    args.upgraders = abs(args.upgraders)
+
+    print("Calculating...")
+
+    result = run(args.path, args.droppers, args.upgraders, args.runs)
+    print("Optimized buildings:", result)
+    with open("optimized_buildings.txt", "w") as f:
+        f.write(str(result))
+    input("Press Enter to exit...")
+
+if __name__ == "__main__":
+    import multiprocessing
+    multiprocessing.freeze_support()
+    main_cli()

rngoptimizer-0.1.1/src/rngoptimizer/definitions.py

@@ -0,0 +1,63 @@
+try:
+	from . import buildings
+except ImportError:
+	import rngoptimizer.buildings as buildings
+Droppers = []
+Upgraders = []
+Processors = []
+
+Droppers.append(buildings.Dropper(name="Basic Dropper", eff=1))
+Droppers.append(buildings.Dropper(name="Advanced Dropper", eff=2))
+Droppers.append(buildings.Dropper(name="Poisoned Dripper", eff=3, bonus={"Acid": 2}, vulnerabilities=["Wet"]))
+Droppers.append(buildings.Dropper(name="Coal Drill", eff=5, immunities=["Fire"]))
+Droppers.append(buildings.Dropper(name="Electric Dropper", eff=10, vulnerabilities=["Wet"]))
+Droppers.append(buildings.Dropper(name="Ancient Ruins", eff=16, bonus={"Ancient": 1.2}, immunities=["Acid"]))
+Droppers.append(buildings.Dropper(name="Slime Duper", eff=20, bonus={"Slimed": 1.3}))
+Droppers.append(buildings.Dropper(name="Flower Forest", eff=25, bonus={"Nebula": 0.9, "Ice": 0.1}, vulnerabilities=["Fire"]))
+Droppers.append(buildings.Dropper(name="Sea Dropper", eff=37, bonus={"Wet": 1.5}, immunities=["Fire"]))
+Droppers.append(buildings.Dropper(name="Ice Dropper", eff=41))
+Droppers.append(buildings.Dropper(name="Dupe Error", eff=75, bonus={"Nuclear": 1.5}, vulnerabilities=["Acid"]))
+Droppers.append(buildings.Dropper(name="Timmy the Tree", eff=100, bonus={"Aired": 1.2}))
+Droppers.append(buildings.Dropper(name="Shard Harvester", eff=119, bonus={"Nebula": 1.3}, immunities=["Nuclear"]))
+Droppers.append(buildings.Dropper(name="Steampunk Terminator", eff=132, bonus={"Fueled": 1.7}, vulnerabilities=["Acid"]))
+Droppers.append(buildings.Dropper(name="Magical Tree", eff=150, bonus={"Aired": 1.45}, immunities=["Nuclear"]))
+Droppers.append(buildings.Dropper(name="Aegis", eff=183.3333333, bonus={"Nebula": 2}, immunities=["Nuclear"]))
+
+Upgraders.append(buildings.Upgrader(name="Copper Upgrader", mult=1.5))
+Upgraders.append(buildings.Upgrader(name="Ore Scanner", mult=2, bonuses={"Aired": 1.5}))
+Upgraders.append(buildings.Upgrader(name="Fire Laser", mult=2.5, effect_remove=["Wet"], trans_effect={"Wet": "Fire"}))
+Upgraders.append(buildings.Upgrader(name="Blue Simulation", mult=7, effect_add=["Wet"]))
+Upgraders.append(buildings.Upgrader(name="Coral Sea", mult=10, effect_add=["Wet", "Wet"], effect_remove=["Fire"]))
+Upgraders.append(buildings.Upgrader(name="Ice Wind", mult=12, effect_add=["Ice"]))
+Upgraders.append(buildings.Upgrader(name="Nuclear Waste", mult=13, effect_add=["Nuclear"], destroy_chance=0.2))
+Upgraders.append(buildings.Upgrader(name="Surge Light", mult=15, bonuses={"Aired": 1.3}))
+Upgraders.append(buildings.Upgrader(name="Mystical Swamp", mult=17, effect_add=["Slimed"], bonuses={"Slimed": 1.3}, destroy_chance=0.01))
+Upgraders.append(buildings.Upgrader(name="Magnetic Fuser", mult=18, effect_add=["Magnetic", "Nuclear"], cond_effect_add={"Nuclear": ["Nebula"]}))
+Upgraders.append(buildings.Upgrader(name="Sandy Valley", mult=21, effect_add=["Ancient"]))
+Upgraders.append(buildings.Upgrader(name="Water Mountain", mult=25, effect_add=["Wet"], effect_remove=["Fire"], destroy_chance=0.05))
+Upgraders.append(buildings.Upgrader(name="Acid Leak", mult=31, effect_add=["Acid"]))
+Upgraders.append(buildings.Upgrader(name="Northern Lights", mult=33, effect_add=["Aired", "Ice"], effect_remove=["Fire"], bonuses={"Nuclear": 0.5}))
+Upgraders.append(buildings.Upgrader(name="Temple of Silence", mult=25, effect_remove=["All"]))
+Upgraders.append(buildings.Upgrader(name="Death Waste", mult=35, effect_add=["V-Wet"], bonuses={"Nuclear": 2}))
+Upgraders.append(buildings.Upgrader(name="Sunstone", mult=37, effect_add=["Fire", "Fire", "Fire", "Fire", "Fire"]))
+Upgraders.append(buildings.Upgrader(name="Nuclear Lab", mult=43, trans_effect={"Acid": "Nuclear"}, bonuses={"Nuclear": 1.5}))
+Upgraders.append(buildings.Upgrader(name="Amethyst Singularity", mult=50, bonuses={"Nebula": 2}))
+Upgraders.append(buildings.Upgrader(name="Creations Studio", mult=55, effect_add=["Ice", "Magnetic", "Aired"]))
+Upgraders.append(buildings.Upgrader(name="Spring Sunshine", mult=60, effect_remove=["Wet", "Nuclear"]))
+Upgraders.append(buildings.Upgrader(name="Storming Summit", mult=64, effect_add=["Magnetic"], effect_remove=["Acid"], bonuses={"Magnetic": 1.2}, destroy_chance=0.25))
+Upgraders.append(buildings.Upgrader(name="Shinigami Realm", mult=72, bonuses={"Ancient": 1.6}))
+Upgraders.append(buildings.Upgrader(name="Aegis Upgrader", mult=89, effect_add=["Nebula"], bonuses={"Nuclear": 2}))
+Upgraders.append(buildings.Upgrader(name="Infernal Realm", mult=99, effect_add=["Fire", "Fire", "Fire"], effect_remove=["Wet"], bonuses={"Fire": 1.66}))
+Upgraders.append(buildings.Upgrader(name="Ancient Gate", mult=120, effect_add=["Fire"], bonuses={"Ancient": 1.3}))
+
+Processors.append(buildings.Processor(name="Copper Processor", mult=1.5))
+Processors.append(buildings.Processor(name="Cardboard Boxes", mult=2, refuse=["Acid"]))
+Processors.append(buildings.Processor(name="Golden Forge", mult=3, bonus={"Fire": 1.5}))
+Processors.append(buildings.Processor(name="Magnet Staff", mult=5, bonus={"Magnetic": 1.5}))
+Processors.append(buildings.Processor(name="Space Processor", mult=12, bonus={"Nebula": 1.5}, onlyaccept=["Nebula"]))
+Processors.append(buildings.Processor(name="Mushroom Spores", mult=22, bonus={"Acid": 2.5}, onlyaccept=["Acid"]))
+Processors.append(buildings.Processor(name="Vortex Shrine", mult=25, bonus={"Nuclear": 2.5},))
+Processors.append(buildings.Processor(name="Subzero", mult=27, bonus={"Wet": 2}, refuse=["Fire"]))
+Processors.append(buildings.Processor(name="Flying Isles", mult=41, bonus={"Aired": 2.5}))
+Processors.append(buildings.Processor(name="Portal of Blocks", mult=63, bonus={"Fire": 2}, refuse=["Wet"]))
+Processors.append(buildings.Processor(name="Hand of Ancient", mult=91, bonus={"Ancient": 1.5}, refuse=["Fire"]))

rngoptimizer-0.1.1/src/rngoptimizer/engine.py

@@ -0,0 +1,316 @@
+import asyncio
+import copy
+import os
+import random
+from concurrent.futures import ProcessPoolExecutor
+
+from . import buildings
+from . import definitions
+
+#Gets the time between upgraders for destruction effects
+def get_timings(upgrader_count):
+    timings = [2.5, 1.7, 3.1, 3.6, 2.5, 2.1, 2.5, 2.9, 3.3, 2.9, 2.5, 2.5, 2.4, 2.8, 5.2, 4.2, 1.0]
+    if upgrader_count <= 0:
+        return []
+    return timings[-upgrader_count:]
+
+#Evaluates the estimated revenue/sec of a given layout
+def calculate_factory(droppers, upgraders, processor):
+    time_table = get_timings(len(upgraders))
+    final_value = 0
+    
+    for dropper in droppers:
+        item = dropper.drop()
+        
+        for step, upgrader in enumerate(upgraders):
+            item = upgrader.upgrade(item)
+            item = item.update(time_table[step])
+            if item is None or item.value <= 0:
+                break
+                
+        if item is not None and item.value > 0:
+            item = processor.process(item)
+            final_value += item.value
+            
+    return final_value
+
+#Returns the building object based on the name of the building
+def get_building_by_name(name):
+    for dropper in definitions.Droppers:
+        if dropper.name == name:
+            return dropper
+    for upgrader in definitions.Upgraders:
+        if upgrader.name == name:
+            return upgrader
+    for processor in definitions.Processors:
+        if processor.name == name:
+            return processor
+    return None
+
+#Gets buildings from raw text
+def get_available_buildings(building_list):
+    #Words before - are the rarities
+    #Words after - is the building name
+    #\ns are the building list
+    available_droppers = []
+    available_upgraders = []
+    available_processors = []
+    dropper_count = 0
+    upgrader_count = 0
+    for building in building_list.split("\n"):
+        if building.startswith("#"):
+            continue
+        if building.startswith("@"):
+            count = building.split(" ")[-1]
+            if building.startswith("@Dr"):
+                dropper_count = int(count)
+            elif building.startswith("@Up"):
+                upgrader_count = int(count)
+        building = building.strip()
+        if building:
+            parts = building.split("-")
+            if len(parts) == 2:
+                rarity, name = (part.strip() for part in parts)
+            else:
+                rarity = "Standard"
+                name = parts[0].strip()
+            building_obj = get_building_by_name(name)
+            if building_obj:
+                building_obj = copy.deepcopy(building_obj)
+                building_obj.rarity = rarity  
+                if isinstance(building_obj, buildings.Dropper):
+                    available_droppers.append(building_obj)
+                elif isinstance(building_obj, buildings.Upgrader):
+                    available_upgraders.append(building_obj)
+                elif isinstance(building_obj, buildings.Processor):
+                    available_processors.append(building_obj)
+    return available_droppers, available_upgraders, available_processors, dropper_count, upgrader_count
+
+
+#---GENETIC ALGORITHM---
+
+def _random_candidate(droppers, upgraders, processors, dropper_count, upgrader_count):
+    if not processors:
+        return None
+
+    return (
+        tuple(random.sample(droppers, min(dropper_count, len(droppers)))),
+        tuple(random.sample(upgraders, min(upgrader_count, len(upgraders)))),
+        random.choice(processors),
+    )
+
+def _evaluate(candidate):
+    droppers, upgraders, processor = candidate
+    return calculate_factory(droppers, upgraders, processor)
+
+def _evaluate_batch(candidates):
+    return [_evaluate(candidate) for candidate in candidates]
+
+def _mutate(candidate, droppers, upgraders, processors):
+    selected_droppers, selected_upgraders, processor = candidate
+    selected_droppers = list(selected_droppers)
+    selected_upgraders = list(selected_upgraders)
+
+    if selected_droppers and random.random() < 0.35:
+        index = random.randrange(len(selected_droppers))
+        available = [
+            dropper
+            for dropper in droppers
+            if dropper not in selected_droppers or dropper is selected_droppers[index]
+        ]
+        if available:
+            selected_droppers[index] = random.choice(available)
+            
+    if selected_upgraders and random.random() < 0.35:
+        index = random.randrange(len(selected_upgraders))
+        available = [
+            upgrader
+            for upgrader in upgraders
+            if upgrader not in selected_upgraders or upgrader is selected_upgraders[index]
+        ]
+        if available:
+            selected_upgraders[index] = random.choice(available)
+            
+    if len(selected_upgraders) > 1 and random.random() < 0.5:
+        first, second = random.sample(range(len(selected_upgraders)), 2)
+        selected_upgraders[first], selected_upgraders[second] = selected_upgraders[second], selected_upgraders[first]
+        
+    if random.random() < 0.2:
+        processor = random.choice(processors)
+
+    return tuple(selected_droppers), tuple(selected_upgraders), processor
+
+def _describe(candidate, value):
+    selected_droppers, selected_upgraders, processor = candidate
+    return {
+        "droppers": [
+            f"{dropper.rarity} {dropper.name}"
+            for dropper in selected_droppers
+        ],
+        "upgraders": [
+            f"{upgrader.rarity} {upgrader.name}"
+            for upgrader in selected_upgraders
+        ],
+        "processor": f"{processor.rarity} {processor.name}",
+        "value": value,
+    }
+
+async def optimize_buildings(
+    droppers,
+    upgraders,
+    processors,
+    dropper_count=None,
+    upgrader_count=None,
+    generations=100,
+    population_size=64,
+    elite_size=8,
+    seed=None,
+    random_fraction=0.1,
+    stagnation_patience=10,
+    max_random_fraction=0.5,
+    progress_every=None,
+    target_value=None,
+):
+    if not droppers or not upgraders or not processors:
+        raise ValueError("at least one dropper, upgrader, and processor is required")
+    if dropper_count is None:
+        dropper_count = len(droppers)
+    if upgrader_count is None:
+        upgrader_count = len(upgraders)
+    if not 0 <= random_fraction <= 1:
+        raise ValueError("random_fraction must be between 0 and 1")
+    if stagnation_patience < 1:
+        raise ValueError("stagnation_patience must be positive")
+    if not random_fraction <= max_random_fraction <= 1:
+        raise ValueError("max_random_fraction must be between random_fraction and 1")
+    if seed is not None:
+        random.seed(seed)
+
+    population = [
+        _random_candidate(droppers, upgraders, processors, dropper_count, upgrader_count)
+        for _ in range(max(population_size, elite_size))
+    ]
+    best_candidate = None
+    best_value = float("-inf")
+    stagnant_generations = 0
+    immigrant_fraction = random_fraction
+    score_cache = {}
+
+    loop = asyncio.get_running_loop()
+    with ProcessPoolExecutor() as process_executor:
+        for generation in range(1, generations + 1):
+            uncached_candidates = list(dict.fromkeys(population))
+            uncached_candidates = [
+                candidate for candidate in uncached_candidates
+                if candidate not in score_cache
+            ]
+            if uncached_candidates:
+                worker_count = min(len(uncached_candidates), os.cpu_count() or 1)
+                chunk_size = max(
+                    1,
+                    (len(uncached_candidates) + worker_count * 2 - 1) // (worker_count * 2),
+                )
+                candidate_batches = [
+                    uncached_candidates[start:start + chunk_size]
+                    for start in range(0, len(uncached_candidates), chunk_size)
+                ]
+                tasks = [
+                    loop.run_in_executor(process_executor, _evaluate_batch, batch)
+                    for batch in candidate_batches
+                ]
+                score_batches = await asyncio.gather(*tasks)
+                uncached_scores = [score for batch in score_batches for score in batch]
+                score_cache.update(zip(uncached_candidates, uncached_scores))
+
+            scores = [score_cache[candidate] for candidate in population]
+        
+            ranked = sorted(zip(scores, population), key=lambda result: result[0], reverse=True)
+            if ranked[0][0] > best_value:
+                best_value, best_candidate = ranked[0]
+                stagnant_generations = 0
+                immigrant_fraction = random_fraction
+            else:
+                stagnant_generations += 1
+                if stagnant_generations >= stagnation_patience:
+                    immigrant_fraction = min(max_random_fraction, immigrant_fraction + 0.1)
+
+            if progress_every and (generation % progress_every == 0 or generation == 1):
+                print(
+                    f"Generation {generation}: best value = {best_value} "
+                    f"(immigrants: {immigrant_fraction:.0%})"
+                )
+                print(_describe(best_candidate, best_value))
+            
+            if target_value is not None and best_value >= target_value:
+                break
+
+            elites = [candidate for _, candidate in ranked[:max(1, elite_size)]]
+            population = elites[:]
+        
+            while len(population) < population_size:
+                if random.random() < immigrant_fraction:
+                    population.append(
+                        _random_candidate(droppers, upgraders, processors, dropper_count, upgrader_count)
+                    )
+                else:
+                    parent = random.choice(elites)
+                    population.append(_mutate(parent, droppers, upgraders, processors))
+                
+            await asyncio.sleep(0)
+
+    return _describe(best_candidate, best_value)
+
+#----------//-----------
+
+
+#Runs the optimization process with the given parameters and returns the best result
+def run(path, dropper_count, upgrader_count, runs=10, run_stagnation_patience=8):
+    with open(path, "r") as f:
+        building_list = f.read()
+    droppers, upgraders, processors, dropper_count_from_txt, upgrader_count_from_txt = get_available_buildings(building_list)
+    if not droppers or not upgraders or not processors:
+        raise ValueError(
+            "available buildings must contain at least one dropper, upgrader, and processor"
+        )
+    dropper_count = dropper_count_from_txt if dropper_count == 0 else int(dropper_count)
+    upgrader_count = upgrader_count_from_txt if upgrader_count == 0 else int(upgrader_count)
+
+    runs = abs(int(runs))
+    if run_stagnation_patience < 1:
+        raise ValueError("run_stagnation_patience must be positive")
+
+    best_result = None
+    stagnant_runs = 0
+    for run_number in range(1, runs + 1):
+        result = asyncio.run(
+            optimize_buildings(
+                droppers,
+                upgraders,
+                processors,
+                dropper_count=dropper_count,
+                upgrader_count=upgrader_count,
+                generations=150,
+                population_size=64,
+                elite_size=8,
+                random_fraction=0.1,
+                progress_every=0,
+            )
+        )
+        if best_result is None or result["value"] > best_result["value"]:
+            best_result = result
+            stagnant_runs = 0
+        else:
+            stagnant_runs += 1
+        print(f"Run {run_number}/{runs}: {result['value']}")
+        if stagnant_runs >= run_stagnation_patience:
+            print(f"Stopping after {stagnant_runs} runs without improvement.")
+            break
+
+    return best_result
+
+if __name__ == "__main__":
+    AVAILABLE_BUILDINGS_PATH = "available_buildings.txt"
+    DROPPER_COUNT = 5
+    UPGRADER_COUNT = 7
+    RUNS = 20
+    print(run(AVAILABLE_BUILDINGS_PATH, DROPPER_COUNT, UPGRADER_COUNT, RUNS))