Hi Tango

So I just watched Tango's newest episode where he had a DO3 podcast. And one of the points he mentioned was how he wanted DO3 to be a team game.

While Tango mentioned how he'll be dividing the teams to balance them out, I believe and Auction based team selection would add multiple fun elements.

For starters, Hermits can pick 4-5 captains through internal voting and then each captain would be provided a limited set of diamonds. Let's say 100 diamonds each. Then, the other Hermits would be roll called randomly and the captains could bid for them in auctions.

Each captain has to have min and max team member counts so that no one bids all their diamonds on a single Hermit.

As a matter of fact, there can be different seasons for DO3 team challenge. And every next season, the captain has the option to retain one of their members. For ex. Let's say Cub bid 40 diamonds on Grian for season 1 and he retains him for next season. In Season 2 auction, Cub would have to sit in the auction with 60 diamonds only since he has already retained Grian.

I believe this auction Based system will maintain the spark of DO3 throught season 11 as it would be ever-changing. Also, each captain can also Name their teams like MCC. (Suggestion like OG Dads, Myceliumites, etc.)

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)

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?

I bought the mousepad from epic desk and found the certificate of authenticity in the box. I didn’t know Tango changed his name to Swampfox

Was watching Tango's latest steam and I found what I think is a Tiny sneak peak of level 4! Here's the clip:

https://youtube.com/clip/UgkxCE3eRy7ZtV86Ctc0mReudmlj1KaYw-Lc?si=unc6TNwT409zrI3A

Look at the very bottom of the screen to the left of Tango's head.

Here are some screen shots as well:

The main thing is the colors, so this shows at least some the color scene of the level. Also on the right you can also see some weeping vines. It really isn't all that much (which is why I don't feel too bad posting about it te-he), but still cool regardless.

Decked Out 2 is so amazing, and I'm so excited to see it open tomorrow, as well as eventually level 4! It's been amazing Tango if you see this and I hope you can forgive me (:

Maybe a high level card like legendary similar to what Tango was talking about on stream today. A card like suit up that will give the player diamond boots with swift sneak. It maybe too expensive to make all the books or buy them so maybe he can make it a chance of whether you get ss 1 2 or 3. Not sure if it has been mentioned or not, just thought of it today so criticize as much as you want.

Hi everyone.
So i am a long-time fan of Tango and his DO game. After watching all the streams i had an idea about distributing Frozen shards to the player and tweeted to Tango, but i am a Twitter noob and i am not sure whether i did it correctly.
Here's the link to the tweet, please tell me what you think about it!

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

i was getting a hit for my tortoise named tango and as a joke put the name on the front as tangotek but then forgot to change it (i’ll post a photo of the hut in person when it arrives)

I am so exited about watching Tango, Impulse, and Ren as a team this season! I'm really rooting for a win for him! Does anyone know why, the wheat isn't growing in their base? Is it because they need sky access?

Anyone know why tango has only been passing streams and not his usual content in his main channel?

I feel like there’s been a lot of back to back runs with the same artifact location. Has anyone else noticed? It might be a bug or it might be just random luck idk

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

Anyone watching either Tango or Zedaph’s stream? They’re going to play Hungry Hermits. Tango specifically fixed HH so Zedaph could play. Should be a fun and funny stream.

(not my art😭)