The Farmer Was Replaced Kürbis-Code — tote Felder flicken, dann ernten

Für den aktuellen 1.0+-Stand. Kürbisse fusionieren. Einfache Ernte-Schleifen zerstören die Fusion. Tote Felder tracken, nachpflanzen, erst ernten wenn alles lebendig ist.

1.0-Kürbis-Regeln

  • Auf Soil pflanzen. Kosten mit `get_cost(Entities.Pumpkin)` prüfen.
  • Etwa jeder fünfte stirbt als Dead_Pumpkin und blockiert die Fusion.
  • Ertrag: n³ für 1–5, ab 6×6: 6·n² (32×32 → 6144).
  • Wasser beschleunigt, verhindert aber keine Tode. Darüber pflanzen entfernt Dead Pumpkin (Wiki). Optional die neue Pflanze düngen (−2s).

Strategie: pflanzen → Bad-Tiles → flicken → ernten

Nicht ewig das ganze Feld scannen. Nach dem ersten Pass nur leere/tote/unreife Koordinaten anfliegen.

  • Pflanzen: Einmal pflügen und pflanzen.
  • Tracken: `[x, y]` merken wenn nicht erntebereit.
  • Flicken: Darüber pflanzen; optional neue Pflanze düngen.
  • Ernten: Liste leer → einmal harvest().
🎃

Lehrskript (eine Drohne)

Nur dokumentierte APIs. Nach Megafarm Spalten/Sektoren teilen.

python
def go_to(x, y):
	while get_pos_x() != x:
		if get_pos_x() < x:
			move(East)
		else:
			move(West)
	while get_pos_y() != y:
		if get_pos_y() < y:
			move(North)
		else:
			move(South)

def plant_full_field():
	size = get_world_size()
	for y in range(size):
		for x in range(size):
			go_to(x, y)
			if get_ground_type() != Grounds.Soil:
				till()
			# Planting over Dead_Pumpkin removes it (wiki). No harvest needed.
			plant(Entities.Pumpkin)
			if get_water() < 0.75:
				use_item(Items.Water)

def collect_bad_tiles():
	bad = []
	size = get_world_size()
	for y in range(size):
		for x in range(size):
			go_to(x, y)
			ent = get_entity_type()
			if ent == Entities.Dead_Pumpkin or ent != Entities.Pumpkin or not can_harvest():
				bad.append([x, y])
	return bad

def patch_bad(bad):
	# Only revisit problem tiles until the list is empty
	while len(bad) > 0:
		still_bad = []
		for pos in bad:
			x = pos[0]
			y = pos[1]
			go_to(x, y)
			ent = get_entity_type()
			if ent != Entities.Pumpkin:
				# Dead_Pumpkin or empty: planting clears dead (wiki)
				if get_ground_type() != Grounds.Soil:
					till()
				plant(Entities.Pumpkin)
				still_bad.append([x, y])
			elif not can_harvest():
				# Live but still growing — wait
				still_bad.append([x, y])
			# else: live + harvestable — drop from list
		bad = still_bad

clear()
while True:
	plant_full_field()
	bad = collect_bad_tiles()
	patch_bad(bad)
	# Full grid is live pumpkins → giant merge should be ready
	go_to(0, 0)
	harvest()

Kürbisgröße mit measure() prüfen (pumpkin measure)

  • Auf Kürbissen liefert `measure()` eine stabile ID derselben Fusion (gleicher Wert auf jedem Feld).
  • Ganze Quadratfläche fusioniert? Eine Ecke und die gegenüberliegende messen — gleiche Werte → ernten.
  • Zuverlässig auf **quadratischen** Monokultur-Feldern. Rechteck/Mix → weiter Bad-Tile-Liste nutzen.
  • Deckt Suchen nach **pumpkin measure** und **how to check pumpkin size** ab.

Beispiel-Hilfe nach `patch_bad(...)`:

python
def pumpkin_fully_merged():
	size = get_world_size()
	go_to(0, 0)
	if get_entity_type() != Entities.Pumpkin or not can_harvest():
		return False
	a = measure()
	go_to(size - 1, size - 1)
	if get_entity_type() != Entities.Pumpkin or not can_harvest():
		return False
	return measure() == a

# After patch_bad(...):
go_to(0, 0)
if pumpkin_fully_merged():
	harvest()

Weiter skalieren mit Drohnenflotte? Siehe multiple drones -Guide.

Multi-Drohne — Konsens Sep–Okt 2026

  • Keine gemeinsamen Globals. Jede Drohne eigener Sektor.
  • `spawn_drone` + `wait_for`. Muster: `if not spawn_drone(task): task()`.
  • Bestzeiten gießen jedes Feld und halten die Bad-Tile-Schleife eng.
  • Volle Megafarm-Muster: Multiple-Drones-Guide
← Zurück zur Startseite