xmatic/pepa-pi-bot
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

feat(v0.3.1): real survival patterns — biome-aware scout, wedge-relocate, escape-pit-safe

Browse Source 
Operator reported the bot wandered the same 50×50 patch for 2 hours
without making any progress toward food. Diagnosis showed three root
causes; this commit addresses all five open improvement_requests
the LLM (postmortem + tuner) flagged automatically.

Research basis (`Voyager`, `Plan4MC`, `GITM`, `Mindcraft`):
  - Coverage / commit-to-cardinal exploration when local scan fails
  - Biome-aware strategy switching using a static affordance table
  - Wedge detector above the skill layer that triggers RELOCATE not
    RETRY (per-skill stuck checks reset on re-entry — useless)
  - Time-in-region bbox heuristic + need-duration AND skill-cycle gate

Concrete changes:

1. `runtime/goal/storyline.js`
   - orient_self.completed: added timeout fallback (HP=full + session
     >120s → done) so barren biomes don't block the bot on step 1.
     Closes improvement #2 'Нет навыка оценки когда сменить район'.
   - first_food.suggestSkill: now picks survive.scout-food (new) when
     no passive mob is nearby; falls back to survive.acquire-food only
     when something is in immediate range.

2. `runtime/biome-affordances.js` (new)
   - Static table: 40+ biomes → {has_passive_mobs, has_trees,
     has_water, has_crops, livable}.
   - Unknown biomes return optimistic defaults to avoid regressions.
   - Closes improvement #1 'Нет навыка целевого поиска еды по биому'.

3. `runtime/skills/scout-food.js` (new — survive.scout-food)
   - Tiered strategy: biome check → scan 32 → scan 64 → commit a
     cardinal for 200 blocks rescanning every 16. On cardinal
     exhaustion, returns code:"exhausted" so the curriculum can
     escalate to village.relocate.
   - In barren biomes (desert/ocean/snowy_plains) the scan is
     SKIPPED — bot walks straight toward the nearest neighbour
     biome that affords passive mobs (8-direction biome probe at
     radius 64).

4. `runtime/awareness/wedge-detector.js` (new)
   - Rolling 10-min position bbox tracker. observe() called every
     tick; isWedged() returns true when bbox<50 AND active need
     unmet >5min AND skill cycles ≥3.
   - markRelocationStarted() suppresses further wedge firings
     until the bot has displaced ≥200b — prevents stack overflow
     of relocate calls.
   - Lives ABOVE the skill layer (in runtime/reflex.js), because
     any per-skill stuck check resets on re-entry.

5. `runtime/skills/relocate.js` (new — village.relocate)
   - 300-block walk in least-recently-used cardinal (per-incident
     memory in ctx.recentRelocations).
   - Re-paths every 32 blocks, soft-tolerates pathfinder failures
     (3 consecutive throws → exit with code:"stuck_in_place").
   - Closes improvement #2 + #4 ('low success rate trigger').

6. `runtime/skills/escape-pit-safe.js` (new — recovery.escape-pit-safe)
   - Surveys 4 cardinals AND ceiling height before committing.
     Picks the direction with most open blocks (≥3, no lava).
     Falls through to pillar-up only if ceiling clear ≥4b. Returns
     code:"no_strategy" if both blocked so curriculum can escalate
     to relocate.
   - Closes improvement #3 'Нет навыка для безопасного выхода'.

7. `runtime/reflex.js`
   - Wedge detector wired before manifesto/storyline. If wedge.wedged
     is true, dispatches village.relocate directly and returns —
     bypasses every other branch.
   - ctx.disableWedge flag for tests.

8. `runtime/coach/advisor-trigger.js`
   - LLM provider outage backoff: 3 consecutive http_400 / timeout /
     network_error → suppress advisor for 10 min. Today's TimeWeb
     gpt-5.4-mini was 400'ing for an hour straight; we were spending
     trigger budget on dead calls. Closes improvement implicit gap
     in #5.

9. `runtime/bot.js`
   - Tracks botSpawnedAt; snapshot._sessionMs exposed for storyline
     orient_self timeout fallback.

Tests: 396 green (was 378, +18):
  - runtime/biome-affordances.test.js — 8 tests
  - runtime/awareness/wedge-detector.test.js — 9 tests
  - runtime/goal/storyline.test.js — 1 new test (orient_self timeout)

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
This commit is contained in:
mayatnikov
2026-05-27 23:01:39 +03:00
co-authored by Claude Opus 4.7
parent cf1f895b25
commit 08ac2e1bc1
15 changed files with 1128 additions and 7 deletions
Download Patch File Download Diff File Expand all files Collapse all files
runtime/skills/scout-food.js
+276
View File
@@ -0,0 +1,276 @@
// survive.scout-food — longer-range, biome-aware food search.
//
// Why this exists alongside survive.acquire-food:
//
// acquire-food is the "I see a cow, hunt it" skill. Its precondition
// requires a passive food mob within ~32 blocks; if there isn't one,
// the skill bails immediately. In v0.3.0 that produced two failure
// modes that kept the bot looping for hours:
//
// 1. Biome with NO passive mobs (desert, ocean, snowy peaks, deep
// caves). acquire-food can never succeed there — the bot just
// kept scanning the same 32-block sphere.
//
// 2. Biome WITH passive mobs but the immediate area is empty. The
// bot wandered 1-8 blocks at a time around the same 50×50 patch
// and never committed to a direction long enough to leave it.
//
// scout-food applies the "commit-to-cardinal" pattern (per the v0.3.1
// design research): scan(32) → patrol(64, time-budget) → if still
// nothing, walk a chosen cardinal for ~200 blocks, rescanning every
// 16 blocks. On exhaustion of all 4 cardinals it surrenders to the
// curriculum so the operator-driven `village.relocate` or LLM advisor
// can pick up.
//
// Biome-awareness:
// - If current biome's affordance table has has_passive_mobs=false
// AND has_water=false, skip the local scan entirely and pick the
// most plausible "leave biome" heading: sample neighbour biomes at
// radius 64 in 8 directions, pick the first one whose affordances
// say has_passive_mobs=true.
// - In water-bearing barren biomes (ocean shores, frozen rivers)
// fishing isn't implemented yet — operator-facing improvement.
import pathfinderPkg from "mineflayer-pathfinder";
const { pathfinder, goals, Movements } = pathfinderPkg;
import { info, warn } from "../log.js";
import { foods } from "./groups.js";
import { affordancesFor, hasPassiveMobs, isBarren } from "../biome-affordances.js";
const PASSIVE_FOOD_MOBS = new Set(["cow", "pig", "chicken", "sheep", "rabbit", "mooshroom"]);
const CARDINALS = [
{ name: "N", dx: 0, dz: -1 },
{ name: "E", dx: 1, dz: 0 },
{ name: "S", dx: 0, dz: 1 },
{ name: "W", dx: -1, dz: 0 },
];
const PATROL_TICK_DISTANCE = 16;
const DEFAULT_COMMIT_DISTANCE = 200;
let pluginLoaded = new WeakSet();
function ensurePathfinder(bot) {
if (pluginLoaded.has(bot)) return;
bot.loadPlugin(pathfinder);
pluginLoaded.add(bot);
}
function setMovementsForTravel(bot) {
const m = new Movements(bot);
m.canDig = false;
m.allow1by1towers = false;
bot.pathfinder.setMovements(m);
}
function foodCount(bot) {
const allowed = foods(bot);
return bot.inventory.items().reduce((sum, item) => allowed.has(item.name) ? sum + item.count : sum, 0);
}
function nearestPassiveFoodMob(bot, maxDistance) {
const here = bot?.entity?.position;
if (!here) return null;
let best = null;
for (const e of Object.values(bot.entities ?? {})) {
if (!e?.position || !PASSIVE_FOOD_MOBS.has(e.name)) continue;
const d = e.position.distanceTo(here);
if (d > maxDistance) continue;
if (!best || d < best.distance) best = { entity: e, distance: d };
}
return best;
}
function currentBiomeName(bot) {
try {
const block = bot.blockAt?.(bot.entity?.position);
const b = block?.biome;
if (typeof b === "string") return b;
if (b?.name) return b.name;
return null;
} catch { return null; }
}
function biomeNameAt(bot, x, y, z) {
try {
const block = bot.blockAt?.({ x: Math.floor(x), y: Math.floor(y), z: Math.floor(z) });
const b = block?.biome;
if (typeof b === "string") return b;
if (b?.name) return b.name;
return null;
} catch { return null; }
}
// Sample biomes in 8 compass directions at the given radius; return
// the heading whose biome has passive mobs.
function scanForFoodCapableNeighbourBiome(bot, radius = 64) {
const here = bot?.entity?.position;
if (!here) return null;
const dirs = [
{ name: "N", dx: 0, dz: -1 },
{ name: "NE", dx: 0.71, dz: -0.71 },
{ name: "E", dx: 1, dz: 0 },
{ name: "SE", dx: 0.71, dz: 0.71 },
{ name: "S", dx: 0, dz: 1 },
{ name: "SW", dx: -0.71, dz: 0.71 },
{ name: "W", dx: -1, dz: 0 },
{ name: "NW", dx: -0.71, dz: -0.71 },
];
for (const d of dirs) {
const b = biomeNameAt(bot, here.x + d.dx * radius, here.y, here.z + d.dz * radius);
if (b && hasPassiveMobs(b)) return { heading: d, biome: b };
}
return null;
}
async function patrolCardinal(bot, cardinal, distance, ctx) {
ensurePathfinder(bot);
setMovementsForTravel(bot);
const start = bot.entity.position.clone?.() ?? { ...bot.entity.position };
let travelled = 0;
while (travelled < distance) {
if (ctx?.abortSignal?.aborted) return { aborted: true, travelled };
const tx = start.x + cardinal.dx * (travelled + PATROL_TICK_DISTANCE);
const tz = start.z + cardinal.dz * (travelled + PATROL_TICK_DISTANCE);
const goal = new goals.GoalNear(Math.floor(tx), Math.floor(bot.entity.position.y), Math.floor(tz), 2);
try {
await Promise.race([
bot.pathfinder.goto(goal),
new Promise((_, rej) => setTimeout(() => rej(new Error("patrol step timeout")), 30_000)),
]);
} catch (e) {
return { aborted: false, travelled, error: e?.message ?? String(e) };
}
travelled += PATROL_TICK_DISTANCE;
// Rescan after every step.
const target = nearestPassiveFoodMob(bot, 32);
if (target) return { aborted: false, travelled, target };
}
return { aborted: false, travelled };
}
export const skill = Object.freeze({
id: "survive.scout-food",
title: "Scout for food at long range (biome-aware)",
timeoutMs: 240_000,
preconditions(ctx) {
if (!ctx?.bot) return { ok: false, code: "no_bot", detail: "bot missing" };
if (foodCount(ctx.bot) > 0) {
return { ok: false, code: "already_have", detail: "already carrying edible food" };
}
return { ok: true };
},
async execute(ctx, args = {}) {
const bot = ctx.bot;
const before = foodCount(bot);
const triedCardinals = new Set(args?._triedCardinals ?? []);
// Step 0: biome check. If barren, head toward a food-capable neighbour.
const biome = currentBiomeName(bot);
const aff = affordancesFor(biome);
info("action", `scout-food: biome=${biome ?? "?"} mobs=${aff.has_passive_mobs} barren=${isBarren(biome)}`);
if (!aff.has_passive_mobs) {
const next = scanForFoodCapableNeighbourBiome(bot, 64);
if (next) {
info("action", `scout-food: leaving barren biome ${biome} → ${next.biome} via ${next.heading.name}`);
const result = await patrolCardinal(bot, next.heading, DEFAULT_COMMIT_DISTANCE, ctx);
if (result.aborted) return { ok: false, code: "preempted", worldDelta: null };
if (result.target) {
return await tryHunt(bot, result.target, before);
}
return {
ok: false,
code: "no_target",
detail: `walked ${Math.round(result.travelled)}b ${next.heading.name} toward ${next.biome}, still no food`,
worldDelta: { moved: Math.round(result.travelled), heading: next.heading.name, from_biome: biome, to_biome: next.biome },
};
}
// Ringed by barren biomes; pick the first cardinal not yet tried.
}
// Step 1: scan radius 32 (cheap).
let target = nearestPassiveFoodMob(bot, 32);
if (target) return await tryHunt(bot, target, before);
// Step 2: scan radius 64 — entities frequently spawn just outside
// our local horizon.
target = nearestPassiveFoodMob(bot, 64);
if (target) return await tryHunt(bot, target, before);
// Step 3: commit to a cardinal we haven't tried in this incident.
const untried = CARDINALS.filter((c) => !triedCardinals.has(c.name));
if (untried.length === 0) {
return {
ok: false,
code: "exhausted",
detail: "tried all 4 cardinals without finding a food mob — switch to village.relocate",
worldDelta: null,
};
}
const cardinal = untried[0];
info("action", `scout-food: commit cardinal ${cardinal.name} for ${DEFAULT_COMMIT_DISTANCE}b`);
const result = await patrolCardinal(bot, cardinal, DEFAULT_COMMIT_DISTANCE, ctx);
if (result.aborted) return { ok: false, code: "preempted", worldDelta: null };
if (result.target) return await tryHunt(bot, result.target, before);
return {
ok: false,
code: "no_target",
detail: { tried: cardinal.name, travelled: Math.round(result.travelled), error: result.error ?? null },
worldDelta: { moved: Math.round(result.travelled), heading: cardinal.name, from_biome: biome },
};
},
recover(ctx, result) {
if (result.code === "exhausted") {
return { hint: "relocate", reason: "scout-food exhausted all 4 cardinals; needs a long jump" };
}
if (result.code === "no_target") {
return { hint: "wander", reason: "scout completed leg without finding mob; try another cardinal" };
}
return null;
},
});
async function tryHunt(bot, target, before) {
ensurePathfinder(bot);
setMovementsForTravel(bot);
try {
await Promise.race([
bot.pathfinder.goto(new goals.GoalFollow(target.entity, 2)),
new Promise((_, rej) => setTimeout(() => rej(new Error("path-to-mob timeout")), 30_000)),
]);
} catch (e) {
return { ok: false, code: "no_path", detail: e?.message ?? "path failed", worldDelta: null };
}
info("action", `scout-food: engaging ${target.entity.name}@${target.distance.toFixed(1)}b`);
for (let i = 0; i < 8; i++) {
const current = Object.values(bot.entities ?? {}).find((e) => e.id === target.entity.id);
if (!current) break;
if (current.position.distanceTo(bot.entity.position) > 4) {
try {
await Promise.race([
bot.pathfinder.goto(new goals.GoalFollow(current, 2)),
new Promise((_, rej) => setTimeout(() => rej(new Error("repath timeout")), 8_000)),
]);
} catch {}
}
bot.attack(current);
await new Promise((r) => setTimeout(r, 700));
}
await new Promise((r) => setTimeout(r, 1_000));
const after = foodCount(bot);
if (after <= before) {
return { ok: false, code: "no_drop", detail: `hunted ${target.entity.name} but no edible drop`, worldDelta: null };
}
return {
ok: true,
code: "done",
detail: { source: "hunt", mob: target.entity.name, gained: after - before },
worldDelta: { acquiredFood: after - before, source: "hunt", mob: target.entity.name },
};
}
// Test exports
export const __testing = {
CARDINALS, PATROL_TICK_DISTANCE, DEFAULT_COMMIT_DISTANCE,
nearestPassiveFoodMob, currentBiomeName, scanForFoodCapableNeighbourBiome,
};