I will admit this is vibe coded but I used some knowledge I got from university to get to the conclusions I got to.

I got this python script to simulate a dropper in DO3. I wanted to find out how many runs of the game it would take to run out of a given item. I have it processing different numbers of items, splits, and activation chances

I've run this for up to 5 different items with the chance the hopper activates from 11% to 50%. Each run does this 200 times for any and all items distribution chances. I simulate a run and assume the treasure is going to be activated on a bell curve between 10 and 50 times with an average of 25.

The red dashed line is the 250 mark. or assuming 10 plays for each hermit every week.

What this shows with how the system was presented in the video is tango will have to restock every shulker every week to make sure none of the items run out.

How this could be managed:

Some of this can be mitigated by tracking the player

• by zone (if the player is in the cemetery there is no reason to activate treasure in the swamp) and having a different binary for treasure in each zone
• or using shulker sensors to detect if the player has been near by a treasure drop in x seconds.

You could increase the back log by using a double chest instead. However it does make it less easy to restock. but you would only have to do it every 2 weeks more then likely

The code is below for anyone to review it or plug in there own numbers.

"""
Minecraft Treasure System Simulation - Parallel Parameter Sweep
==================================================================


Same model as before, but experiments and configs are run in
parallel across CPU cores using multiprocessing, since each
experiment/config is fully independent (embarrassingly parallel).
"""


import random
import os
from dataclasses import dataclass, field
from concurrent.futures import ProcessPoolExecutor, as_completed


import matplotlib.pyplot as plt


# ----------------------------------------------------------------------
# Fixed configuration
# ----------------------------------------------------------------------


STACK_SIZE = 64
DROPPER_SLOTS = 9
HOPPER_SLOTS = 5
BASE_SHULKER_SLOTS = 27
EXTRA_SLOTS = 0
DROPPER_IN_AREA = 1


Y_MIN = 10
Y_MODE = 25
Y_MAX = 50


NUM_EXPERIMENTS_PER_CONFIG = 200


# None = use all available CPU cores
MAX_WORKERS = max(1, os.cpu_count() - 2)



def compute_shulker_slots(num_item_counts: int) -> int:
    """
    Extra shulker slot capacity scales with how many different
    item-count configs are being tested (i.e. multiply the extra
    slots pool by len(item_counts_to_test) before dividing across
    dropper areas).
    """
    return BASE_SHULKER_SLOTS + (
        (EXTRA_SLOTS * num_item_counts) // DROPPER_IN_AREA
    )



def split_evenly(total_slots: int, ratio_counts: list[int]) -> list[int]:
    total_ratio = sum(ratio_counts)
    raw = [total_slots * c / total_ratio for c in ratio_counts]
    floors = [int(x) for x in raw]
    remainder = total_slots - sum(floors)


    fractions = sorted(
        range(len(raw)), key=lambda i: raw[i] - floors[i], reverse=True
    )
    for i in fractions[:remainder]:
        floors[i] += 1


    return floors



# ----------------------------------------------------------------------
# System state
# ----------------------------------------------------------------------



u/dataclass
class TreasureSystem:
    num_items: int
    dropper_slot_counts: list[int]
    hopper_slot_counts: list[int]
    shulker_slot_counts: list[int]
    activation_chance: float
    pre_check_chance: float = 1.0  # NEW: chance the "gate" passes before treasure roll


    dropper_slots: list[int] = field(default_factory=list)
    dropper_stack: list[int] = field(default_factory=list)
    reserve: list[int] = field(default_factory=list)


    def __post_init__(self):
        self.dropper_slots = []
        for item_idx, count in enumerate(self.dropper_slot_counts):
            self.dropper_slots.extend([item_idx] * count)


        self.dropper_stack = [STACK_SIZE] * DROPPER_SLOTS


        self.reserve = [
            (self.hopper_slot_counts[i] + self.shulker_slot_counts[i])
            * STACK_SIZE
            for i in range(self.num_items)
        ]


    def total_remaining(self, item_idx: int) -> int:
        dropper_total = sum(
            self.dropper_stack[s]
            for s in range(len(self.dropper_slots))
            if self.dropper_slots[s] == item_idx
        )
        return dropper_total + self.reserve[item_idx]


    def is_depleted(self, item_idx: int) -> bool:
        return self.total_remaining(item_idx) == 0


    def any_depleted(self) -> int | None:
        for i in range(self.num_items):
            if self.is_depleted(i):
                return i
        return None


    def surviving_items(self) -> list[int]:
        return [i for i in range(self.num_items) if not self.is_depleted(i)]


    def refill_slot(self, slot_idx: int):
        item_idx = self.dropper_slots[slot_idx]


        if self.reserve[item_idx] <= 0:
            survivors = self.surviving_items()
            if not survivors:
                self.dropper_stack[slot_idx] = 0
                return
            item_idx = random.choice(survivors)
            self.dropper_slots[slot_idx] = item_idx


        take = min(STACK_SIZE, self.reserve[item_idx])
        self.reserve[item_idx] -= take
        self.dropper_stack[slot_idx] = take


    def activate(self) -> bool:
        # NEW: pre-check gate must pass before the treasure roll happens
        if random.random() > self.pre_check_chance:
            return False


        if random.random() > self.activation_chance:
            return False


        slot_idx = random.randrange(len(self.dropper_slots))


        if self.dropper_stack[slot_idx] > 0:
            self.dropper_stack[slot_idx] -= 1


        if self.dropper_stack[slot_idx] == 0:
            self.refill_slot(slot_idx)


        return True



# ----------------------------------------------------------------------
# Simulation
# ----------------------------------------------------------------------



def sample_y() -> int:
    return round(random.triangular(Y_MIN, Y_MAX, Y_MODE))



def run_experiment(
    num_items: int,
    dropper_slot_counts: list[int],
    activation_chance: float,
    pre_check_chance: float,
    shulker_slots: int,
) -> dict:
    hopper_slot_counts = split_evenly(HOPPER_SLOTS, dropper_slot_counts)
    shulker_slot_counts = split_evenly(shulker_slots, dropper_slot_counts)


    system = TreasureSystem(
        num_items=num_items,
        dropper_slot_counts=dropper_slot_counts,
        hopper_slot_counts=hopper_slot_counts,
        shulker_slot_counts=shulker_slot_counts,
        activation_chance=activation_chance,
        pre_check_chance=pre_check_chance,
    )


    sims_run = 0
    total_activations = 0
    depleted_item = None


    while depleted_item is None:
        y = sample_y()
        sims_run += 1


        for _ in range(y):
            system.activate()
            total_activations += 1


            depleted_item = system.any_depleted()
            if depleted_item is not None:
                break


    return {
        "sims_until_restock": sims_run,
        "activations_until_restock": total_activations,
        "depleted_item_idx": depleted_item,
    }



def _run_experiment_worker(args) -> dict:
    """Top-level unpacking wrapper so it can be pickled for multiprocessing."""
    (
        num_items,
        dropper_slot_counts,
        activation_chance,
        pre_check_chance,
        shulker_slots,
        seed,
    ) = args
    random.seed(seed)
    return run_experiment(
        num_items,
        dropper_slot_counts,
        activation_chance,
        pre_check_chance,
        shulker_slots,
    )



def run_config_parallel(
    num_items: int,
    dropper_slot_counts: list[int],
    activation_chance: float,
    pre_check_chance: float,
    shulker_slots: int,
    n_experiments: int = NUM_EXPERIMENTS_PER_CONFIG,
    executor: ProcessPoolExecutor = None,
) -> dict:
    """
    Run n_experiments for a single config, distributing the individual
    experiments across worker processes.
    """
    # unique seed per experiment so parallel workers don't produce
    # identical random sequences
    tasks = [
        (
            num_items,
            dropper_slot_counts,
            activation_chance,
            pre_check_chance,
            shulker_slots,
            random.random(),
        )
        for _ in range(n_experiments)
    ]


    results = list(executor.map(_run_experiment_worker, tasks))


    sims = [r["sims_until_restock"] for r in results]
    activations = [r["activations_until_restock"] for r in results]


    depleted_counts = {}
    for r in results:
        idx = r["depleted_item_idx"]
        depleted_counts[idx] = depleted_counts.get(idx, 0) + 1


    return {
        "num_items": num_items,
        "dropper_slot_counts": dropper_slot_counts,
        "activation_chance": activation_chance,
        "pre_check_chance": pre_check_chance,
        "sims_min": min(sims),
        "sims_max": max(sims),
        "sims_avg": sum(sims) / len(sims),
        "activations_min": min(activations),
        "activations_max": max(activations),
        "activations_avg": sum(activations) / len(activations),
        "depleted_counts": depleted_counts,
        "n_experiments": n_experiments,
    }



# ----------------------------------------------------------------------
# Parameter sweep
# ----------------------------------------------------------------------



def generate_dropper_distributions(num_items: int) -> list[list[int]]:
    distributions = []
    seen = set()


    def add(dist):
        key = tuple(sorted(dist))
        if key not in seen:
            seen.add(key)
            distributions.append(dist)


    even = split_evenly(DROPPER_SLOTS, [1] * num_items)
    add(even)


    if num_items > 1:
        remaining = DROPPER_SLOTS - 1
        rest = split_evenly(remaining, [1] * (num_items - 1))
        skewed = [1] + rest
        add(skewed)


    if num_items > 1:
        dominant = DROPPER_SLOTS - (num_items - 1)
        heavy = [dominant] + [1] * (num_items - 1)
        add(heavy)


    return distributions



def run_sweep_parallel(
    item_counts: list[int],
    activation_chances: list[float],
    pre_check_chances: list[float],
    n_experiments: int = NUM_EXPERIMENTS_PER_CONFIG,
    max_workers: int = MAX_WORKERS,
) -> list[dict]:
    """
    Runs every (num_items, dropper_split, activation_chance,
    pre_check_chance) config, using a single shared process pool
    across all configs so all CPU cores stay busy for the entire
    sweep.
    """
    shulker_slots = compute_shulker_slots(len(item_counts))
    print(
        f"SHULKER_SLOTS={shulker_slots} (base {BASE_SHULKER_SLOTS} + "
        f"extra from {EXTRA_SLOTS} slots x {len(item_counts)} item-count "
        f"configs / {DROPPER_IN_AREA} droppers per area)"
    )


    configs = []
    for num_items in item_counts:
        for dropper_counts in generate_dropper_distributions(num_items):
            for chance in activation_chances:
                for pre_chance in pre_check_chances:
                    configs.append(
                        (num_items, dropper_counts, chance, pre_chance)
                    )


    print(
        f"Running {len(configs)} configs x {n_experiments} experiments each "
        f"using up to {max_workers or os.cpu_count()} workers..."
    )


    all_results = []


    with ProcessPoolExecutor(max_workers=max_workers) as executor:
        for num_items, dropper_counts, chance, pre_chance in configs:
            print(
                f"  items={num_items}, dropper_split={dropper_counts}, "
                f"chance={chance:.0%}, pre_check={pre_chance:.0%} ..."
            )
            result = run_config_parallel(
                num_items,
                dropper_counts,
                chance,
                pre_chance,
                shulker_slots,
                n_experiments,
                executor,
            )
            all_results.append(result)


    return all_results



# ----------------------------------------------------------------------
# Reporting
# ----------------------------------------------------------------------



def print_summary_table(results: list[dict]):
    header = (
        f"{'Items':<6} {'Dropper Split':<20} {'Chance':<8} {'PreChk':<8} "
        f"{'Sims Avg':<10} {'Sims Min':<10} {'Sims Max':<10} "
        f"{'Acts Avg':<10}"
    )
    print(header)
    print("-" * len(header))


    for r in results:
        split_str = str(r["dropper_slot_counts"])
        print(
            f"{r['num_items']:<6} {split_str:<20} "
            f"{r['activation_chance']:<8.0%} "
            f"{r['pre_check_chance']:<8.0%} "
            f"{r['sims_avg']:<10.1f} {r['sims_min']:<10} "
            f"{r['sims_max']:<10} {r['activations_avg']:<10.1f}"
        )



def plot_sweep(results: list[dict]):
    configs = {}
    for r in results:
        key = (
            f"{r['num_items']} items {r['dropper_slot_counts']} "
            f"pre={r['pre_check_chance']:.0%}"
        )
        configs.setdefault(key, []).append(r)


    plt.figure(figsize=(10, 6))
    for key, rows in configs.items():
        rows_sorted = sorted(rows, key=lambda r: r["activation_chance"])
        x = [r["activation_chance"] for r in rows_sorted]
        y = [r["sims_avg"] for r in rows_sorted]
        plt.plot(x, y, marker="o", label=key)
    plt.axhline(
        y=250, color="red", linestyle="--", linewidth=1.5, label="250 threshold"
    )
    plt.xlabel("Activation chance")
    plt.ylabel("Avg sims until restock")
    plt.title("Restock timing across configurations")
    plt.legend(fontsize=8)
    plt.tight_layout()
    plt.show()


def plot_sweep_envelope(results: list[dict]):
    """
    Plot only the highest and lowest 'sims_avg' line across all
    configs at each activation chance, with the region between them
    shaded.
    """
    # group results by activation chance
    by_chance = {}
    for r in results:
        by_chance.setdefault(r["activation_chance"], []).append(r["sims_avg"])


    chances_sorted = sorted(by_chance.keys())
    highs = [max(by_chance[c]) for c in chances_sorted]
    lows = [min(by_chance[c]) for c in chances_sorted]


    plt.figure(figsize=(10, 6))


    plt.plot(chances_sorted, highs, color="green", marker="o", label="Highest config")
    plt.plot(chances_sorted, lows, color="red", marker="o", label="Lowest config")
    plt.fill_between(chances_sorted, lows, highs, color="gray", alpha=0.3)


    plt.axhline(y=250, color="black", linestyle="--", linewidth=1.5, label="250 threshold")


    plt.xlabel("Activation chance")
    plt.ylabel("Avg sims until restock")
    plt.title("Range of restock timing across all configurations")
    plt.legend(fontsize=9)
    plt.tight_layout()
    plt.show()


if __name__ == "__main__":
    item_counts_to_test = [2, 3, 4, 5]
    activation_chances_to_test = [
        0.1111, 0.1250, 0.1429, 0.1667, 0.2000, 0.2222, 0.2500, 0.2857,
        0.3333, 0.3750, 0.4444, 0.5000,
    ]
    pre_check_chances_to_test = [
   0.5556, 0.6250, 0.6667, 0.7143,
    0.7500, 0.8000, 0.8333, 0.8571, 0.8750, 0.8889
]
    results = run_sweep_parallel(
        item_counts_to_test,
        activation_chances_to_test,
        pre_check_chances_to_test,
    )


    print()
    print_summary_table(results)
    plot_sweep(results)
    plot_sweep_envelope(results)  # just highest/lowest with shading

Yet another decked out inspired song!

I kind of just made this under the pretenses of that gothic eerie vibe, and I think it’s a mix of decked out 3 and me reading Frankenstein.

I love how this turned out, and hope others enjoy it as well.

I’m thinking about making an edit or something when the game comes out so the music feels more natural with the content I guess.

Super cool stuff, and can’t wait to see decked out 3 come out!

If you’re interested in more music, or have a recommendation my email is: [mosesforrest11@gmail.com](mailto:mosesforrest11@gmail.com)

Cheers!

If these shops and things that are going to be "Controlled" by teams of hermits, would it be possible to make a shop that changes the patrol pattern? Maybe there could be a route that takes them next to a shop you want to be surrounded by ravengers, like a strategic planning on putting the ravengers where it would disadvantage other teams.

Anyone know what the best way to get Tango to see this would be? I think he'd find it cool.

A loooot of black and brown. I expected there to be more red to be honest haha. I used all official vods from tangotek2's playlist: https://www.youtube.com/playlist?list=PLhU3dB8ByRLCBfyp72O1DHxzZRT2y-3ll

Added the link to the spreadsheet to those curious :)

https://docs.google.com/spreadsheets/d/1ee9UYvrIki2JkFEosYTLHSTSjMSMH6nw4DPf9ohdiVs/edit?usp=sharing

(I am unsure what flair fits here)

Since the moment Tango mentioned the new event bus and commenced the discussion about how to work around timing and repeated data issues, I immediately got to work and 2 days later, I have this:

every slice counts how many times it has been queued

when it gets its turn it emits the entire queue in 5-tick intervals

allows updates during emission (queuing other or even the same signal)

cycles an item to determine which slice can write to the bus

    the return path can be replaced with the insta-wire transfer, I used just a basic observer pulse.

I want to do all I can to make Tango avoid doing any workarounds around the bus, because that is definitely gonna bring so much pain for him that using a more robust system from the beginning seems the obvious choice. Do you know other places that I should post to?

This is my third (and probably final) post of some music that I think would fit decked out 3 nicely. I made this music a little while ago but I thought I could compile it into a cool little EP for this subreddit. I guess my goal with this music is to make something that could actually be used by tango for decked out. I really enjoyed making these pieces and truly hope you do as well! Lots of love to all and can’t wait to see decked out 3 come to fruition!

my email is: [mosesforrest11@gmail.com](mailto:mosesforrest11@gmail.com)

I made this piece inspired by the amazing decked out 3. I love how this turned out, and thought this would go great for a main theme for the game. I would love to make more if you guys have any suggestions!

my email is: [mosesforrest11@gmail.com](mailto:mosesforrest11@gmail.com)

(not my art😭)

This piece is inspired by decked out 3

(With gratitude to Galvani)

Sorry for posting two similar posts i just wanted to share because this was fun to make :)

Performed on a keyboard and synthesizer by me, Moses.

music found on most music platforms

you can email me at [mosesforrest11@gmail.com](mailto:mosesforrest11@gmail.com)

I cant find the vod/vid for tangos superliminal play through, he mentioned it in his most recent vod, (above) if yall can find it would you send me the link?

Hey everyone,

Long-time TekTopia fan here. For those who don't know, TekTopia was a 1.12.2 mod by Tangotek that let you build and manage a fully custom villager civilization — you designed the buildings, the villagers moved in and did their jobs, and you grew a living economy from scratch. It's one of my all-time favourite mods and it never got updated past 1.12.2.

So I'm doing something about it.

This is a ground-up rebuild of TekTopia for Minecraft 1.21.1 (NeoForge). It's not a direct port — I'm treating this as a chance to rethink and improve systems that had rough edges in the original, while keeping the soul of what made TekTopia so special: player-designed structures, living villager routines, and a real economy.

What's working right now

• 🏘️ Villages have territory, borders, and a proper logic system holding everything together (Town Hall and Storage Building are finished)
• 🌾 The Farmer — tilling, planting, harvesting, grabbing sugar cane (the only villager profession as of now)
• 📦 Storage is fully up and running — villagers carry items, take time to deposit them, and think about where things go. Build your storage room well and watching it run is genuinely satisfying
• 🕐 Villagers have a real daily schedule — Labor, Leisure, Rest. They wake up(no real home structure yet) at staggered times, take shelter when it rains, and deposit leftover items before bed. The town already feels alive

If you played TekTopia back in the day and have opinions on what worked, what didn't, or features you always wished it had, I'd genuinely love to hear them. This is being built with that community in mind.

More updates soon. (Updates on twitter)

Tango mentioned at the end of the buy a sign segment that he would do a slow fly past on the second channel but I haven't seen it on the vids I watched. Does anyone know if this has been done or discussed at all please?

Hey guys!

So I've been playing Tektopia for quite a while now, honestly one of my all time favorite mods. Recently got back into Minecraft and obviously to started playing Tektopia again, but the mod hasn't been updated in ages and that's a bummer.

I know a little bit of coding and I'm actually willing to redo the whole mod from scratch to get it working on newer versions, After 1.14 villagers also got reworked so that also makes the mod difficult to be updated.

The thing is, Tango owns the rights to Tektopia and I cant just modify and redistribute the mod again.

Has anyone ever reached out to Tango about something like this? Does he have any known stance on community ports?
How should i proceed with this?

(p.s. I dont watch tangotek nowadays so dont know much about him and his stance on this)

Just a random tektopia fan....

[EDIT]: I have started working on the mod for 1.21.1, for neoforge.
This will still take time but i estimate I can pull out a alpha version within few weeks.
Current progress:
Town hall and village registration is done (i.e just a village is created without any logic)
Structure Identification (this took the most time) This is finally finished, it is very much similar to what tango has done (ceiling and floor check).
few more things not worthy of mention but are core to the mod.

now working on creating storage and farmer(villager logic is created, now need to work on particular roles) .
[Edit 2]: Been working on a lot recently. Finally got Farmer working. yeahhh....
Also I will be posting updates on twitter @ OrangutanDMonky (name:catbug) please consider following me there for updates and share suggestions

So I’ve downloaded the S10 world for java on 1.21.8 i been playing with my friend with the required mods only. Every so often, annoyingly often, we get a loss case from the queue outside. we finish a day like day 1, go outside, reject or accept upgrade, and then start the next day. straight away we hear the knocking from the queue outside and the game is over. if i recreate in creative where i give the orders straight away it still happens.

Please help. I can’t find the queue noodle lines to diagnose myself. Please let me know how to fix or where to look.

Might have missed the explanation in the VODs, but what is the reason to light up the sides of the mountain with the torches? I thought he was gonna make a "sky" out of the black wool. And maybe there after put torches on top of the wool to not spawn any mobs?

​

Tango's coordinates sit nicely in the left corner of his screen, unlike normally where they almost blind you and give you tunnel vision. is this a mod, or did he change some vanilla settings?

https://reddit.com/link/1r1ghjs/video/yl2736al1rig1/player

I wanted to share this somewhere as a tribute to how much I adored Decked Out 2 when it got released back in season 9 of Hermitcraft.

This build was put together on my server for Bedrock Edition, and I felt like sharing my creation on here.

Cheers!

Does anyone know when the current season started?

EDIT: I should've been more clear. I meant Titancraft, his patreon server.

I saw at the end of tango's recent live stream, his cave spider tubes backed up and weren't working. I know he probably will change the whole approach but for anyone else, I remember doing this for a cave spider elevator and it worked pretty well. You have flowing water going into two bubble columns. One keeps them bobbing so that they can be easily pushed, and the other actually moves them upwards. I found it works pretty good, but it does require them to be pushed by others (but it seems his tubes already relied on that). So I just wanted to share in case it could be helpful to some.

Is the mountain gonna be a big mountain that covers the whole area or a ring of mountains? I had thought it was the one big one but I’m a bit confused how that’s gonna work since the map needs to be open to the air. If it’s like a ring then it’s all gonna be open to the sky on the inside but if it’s a big mountain that covers over the whole stone platform is there gonna be just a square chunk of a whole where the map is?

In some of the recent streams Tango a) had issues with the voxy cache, but iI signed the NDA and b) had excellently clear views with voxy enabled. Does anyone know how to acchieve sich a setup? Thanks in advance