From 70e78a1ffc1ba62d4f2091193e28d9625564fc05 Mon Sep 17 00:00:00 2001
From: dayfine <difancpa@gmail.com>
Date: Thu, 29 Oct 2026 17:38:29 -0700
Subject: [PATCH 01/10] Pokemon navigation: grid types and a leg planner over a
 game's step model

The planner searches for the cheapest legs (hold one direction, then the
next) and prefers legs that end against a wall. Each game supplies what
one press of a direction does; the planner doesn't know any tile legend.
Tested on a small made-up game.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AKYzhrMnPK61XHWEch4a6E
---
 .../ComputerPrograms_UnitTestRunner.cpp       |   2 +
 .../Pokemon/Navigation/Pokemon_Grid.cpp       |  49 +++
 .../Source/Pokemon/Navigation/Pokemon_Grid.h  |  57 ++++
 .../Pokemon/Navigation/Pokemon_LegPlanner.h   | 285 ++++++++++++++++++
 .../Navigation/Pokemon_LegPlanner_Tests.cpp   | 259 ++++++++++++++++
 .../Navigation/Pokemon_LegPlanner_Tests.h     |  22 ++
 SerialPrograms/cmake/SourceFiles.cmake        |   5 +
 7 files changed, 679 insertions(+)
 create mode 100644 SerialPrograms/Source/Pokemon/Navigation/Pokemon_Grid.cpp
 create mode 100644 SerialPrograms/Source/Pokemon/Navigation/Pokemon_Grid.h
 create mode 100644 SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegPlanner.h
 create mode 100644 SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegPlanner_Tests.cpp
 create mode 100644 SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegPlanner_Tests.h

diff --git a/SerialPrograms/Source/ComputerPrograms/ComputerPrograms_UnitTestRunner.cpp b/SerialPrograms/Source/ComputerPrograms/ComputerPrograms_UnitTestRunner.cpp
index 1c19573466..0024cd1902 100644
--- a/SerialPrograms/Source/ComputerPrograms/ComputerPrograms_UnitTestRunner.cpp
+++ b/SerialPrograms/Source/ComputerPrograms/ComputerPrograms_UnitTestRunner.cpp
@@ -27,6 +27,7 @@
 #include "NintendoSwitch/Inference/NintendoSwitch_UpdatePopupDetector.h"
 #include "NintendoSwitch/Programs/Typewriter/NintendoSwitch_Typewriter_Tests.h"
 
+#include "Pokemon/Navigation/Pokemon_LegPlanner_Tests.h"
 #include "VideoGames/PokemonHome/PokemonHome_Tests.h"
 #include "VideoGames/PokemonSwSh/PokemonSwSh_Tests.h"
 #include "VideoGames/PokemonLA/PokemonLA_Tests.h"
@@ -58,6 +59,7 @@ UnitTestDatabase make_UNIT_TESTS_ALL(){
     add_tests_AudioFileLoader(ret);
     OCR::add_tests(ret);
     Kernels::add_tests(ret);
+    Pokemon::add_tests_LegPlanner(ret);
     NintendoSwitch::add_tests_CheckOnlineDetector(ret);
     NintendoSwitch::add_tests_FailedToConnectDetector(ret);
     NintendoSwitch::add_tests_UpdatePopupDetector(ret);
diff --git a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_Grid.cpp b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_Grid.cpp
new file mode 100644
index 0000000000..fb4d5fb037
--- /dev/null
+++ b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_Grid.cpp
@@ -0,0 +1,49 @@
+/*  Grid
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ */
+
+#include "Pokemon_Grid.h"
+
+namespace PokemonAutomation{
+namespace Pokemon{
+
+
+const char* direction_name(Direction direction){
+    switch (direction){
+    case Direction::NORTH:
+        return "north";
+    case Direction::EAST:
+        return "east";
+    case Direction::SOUTH:
+        return "south";
+    case Direction::WEST:
+        return "west";
+    }
+    return "?";
+}
+
+
+TilePos TilePos::next(Direction direction) const{
+    switch (direction){
+    case Direction::NORTH:
+        return {x, y - 1};
+    case Direction::EAST:
+        return {x + 1, y};
+    case Direction::SOUTH:
+        return {x, y + 1};
+    case Direction::WEST:
+        return {x - 1, y};
+    }
+    return *this;
+}
+
+std::string to_string(const TilePos& pos){
+    return "(" + std::to_string(pos.x) + ", " + std::to_string(pos.y) + ")";
+}
+
+
+
+}
+}
diff --git a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_Grid.h b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_Grid.h
new file mode 100644
index 0000000000..409e6fe06e
--- /dev/null
+++ b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_Grid.h
@@ -0,0 +1,57 @@
+/*  Grid
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ *  Tiles and directions on an overworld grid, shared by the games that
+ *  move the player a tile at a time.
+ *
+ */
+
+#ifndef PokemonAutomation_Pokemon_Grid_H
+#define PokemonAutomation_Pokemon_Grid_H
+
+#include <cstddef>
+#include <functional>
+#include <string>
+
+namespace PokemonAutomation{
+namespace Pokemon{
+
+
+//  Row 0 is the top of a map, so SOUTH increases y.
+enum class Direction{
+    NORTH,
+    EAST,
+    SOUTH,
+    WEST,
+};
+constexpr Direction ALL_DIRECTIONS[] = {
+    Direction::NORTH, Direction::EAST, Direction::SOUTH, Direction::WEST,
+};
+const char* direction_name(Direction direction);
+
+
+struct TilePos{
+    int x = 0;
+    int y = 0;
+
+    TilePos next(Direction direction) const;
+    bool operator==(const TilePos& other) const = default;
+};
+std::string to_string(const TilePos& pos);
+
+
+
+}
+}
+
+
+template <>
+struct std::hash<PokemonAutomation::Pokemon::TilePos>{
+    size_t operator()(const PokemonAutomation::Pokemon::TilePos& pos) const{
+        return std::hash<long long>()(((long long)pos.x << 32) ^ (unsigned)pos.y);
+    }
+};
+
+
+#endif
diff --git a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegPlanner.h b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegPlanner.h
new file mode 100644
index 0000000000..5fbde90341
--- /dev/null
+++ b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegPlanner.h
@@ -0,0 +1,285 @@
+/*  Leg Planner
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ *  Plans a walk as straight legs: hold one direction, then the next. The
+ *  game decides what a single press does through its step model; the
+ *  planner searches, joins steps into legs, and prefers legs that end
+ *  against a wall, because the player stops there however long the button
+ *  is held, while a leg that ends in the open depends on timing.
+ *
+ *  A step model is a class with:
+ *
+ *      using State = ...;      //  where the player is and what moves them:
+ *                              //  comparable with ==
+ *      using StateHash = ...;  //  a hash of State, e.g. std::hash<TilePos>
+ *      std::optional<Step<State>> press(const State& state, Direction direction) const;
+ *      bool held_at(const State& state, Direction direction) const;
+ *
+ *  press() is what pressing `direction` once does, or nothing if the player
+ *  can't go that way (a wall, or something the plan must not do). held_at()
+ *  is whether holding `direction` keeps the player on this tile: a wall, but
+ *  not a person who may walk off or an edge to a map that isn't loaded.
+ *
+ */
+
+#ifndef PokemonAutomation_Pokemon_LegPlanner_H
+#define PokemonAutomation_Pokemon_LegPlanner_H
+
+#include <algorithm>
+#include <functional>
+#include <limits>
+#include <optional>
+#include <queue>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+#include "Pokemon_Grid.h"
+
+namespace PokemonAutomation{
+namespace Pokemon{
+
+
+//  What one press does.
+template <typename State>
+struct Step{
+    State next;
+    //  0 for a plain step. Anything else is a step of the game's own kind
+    //  (e.g. starting to Surf), planned as a leg on its own.
+    int action = 0;
+    //  The step can't continue the leg before it, e.g. leaving the water,
+    //  after which the player walks at another speed.
+    bool starts_leg = false;
+    //  No later step continues this leg: the game stops the player, e.g.
+    //  at a warp.
+    bool ends_leg = false;
+    //  The step takes a warp: a door, a ladder, a cave entrance.
+    bool warped = false;
+    //  Which way the player faces afterwards. Usually the pressed direction;
+    //  some warps turn the player.
+    Direction facing = Direction::NORTH;
+    //  Cost on top of LegCosts::per_tile: tall grass, a warp's fade, a dialog.
+    int extra_cost = 0;
+};
+
+
+enum class LegKind{
+    WALK,       //  hold `direction` for `tiles` steps
+    ACTION,     //  one step of the game's own kind, `action`
+    FACE,       //  turn to `direction` without moving
+};
+
+template <typename State>
+struct Leg{
+    LegKind kind = LegKind::WALK;
+    int action = 0;
+    Direction direction = Direction::NORTH;
+    int tiles = 0;
+    //  WALK: the last step takes a warp.
+    bool warps = false;
+    //  WALK: holding on keeps the player on the last tile, so the leg can be
+    //  held for longer than it takes and walked again after an interruption.
+    bool to_wall = false;
+    Direction facing_after = Direction::NORTH;
+    State start;
+    State end;
+};
+
+
+struct LegCosts{
+    int per_tile = 1;
+    //  Extra for a step in a new direction.
+    int per_turn = 2;
+    //  Extra for ending a leg where the player could keep going: it has to
+    //  be timed, and where an interruption leaves the player is a guess.
+    int per_open_stop = 8;
+};
+
+
+//  The cheapest legs from `start` to a state where `at_goal` holds, facing
+//  `goal_facing` if given, or nothing if there is none. `start_facing` is
+//  the way the player faces at the start, if known.
+template <typename Model>
+std::optional<std::vector<Leg<typename Model::State>>> plan_legs(
+    const Model& model,
+    const typename Model::State& start, std::optional<Direction> start_facing,
+    const std::function<bool(const typename Model::State&)>& at_goal,
+    std::optional<Direction> goal_facing,
+    const LegCosts& costs = LegCosts()
+);
+
+
+
+namespace LegPlannerInternal{
+
+//  A search node: the player, the way they face (4: not known), and whether
+//  they are in the middle of a leg that could go on.
+template <typename State>
+struct Node{
+    State state;
+    int facing = 4;
+    bool moving = false;
+
+    bool operator==(const Node& other) const = default;
+};
+
+template <typename State, typename StateHash>
+struct NodeHash{
+    size_t operator()(const Node<State>& node) const{
+        return StateHash()(node.state) * 10 + node.facing * 2 + (node.moving ? 1 : 0);
+    }
+};
+
+template <typename State>
+struct Move{
+    Node<State> from;
+    Direction direction;
+    Step<State> step;
+};
+
+template <typename Model, typename State>
+int stop_cost(const Model& model, const Node<State>& node, const LegCosts& costs){
+    if (!node.moving || model.held_at(node.state, (Direction)node.facing)){
+        return 0;
+    }
+    return costs.per_open_stop;
+}
+
+template <typename Model, typename State>
+std::vector<Leg<State>> join_legs(const Model& model, const State& start, const std::vector<Move<State>>& moves){
+    std::vector<Leg<State>> legs;
+    bool can_extend = false;
+    State before = start;
+    for (const Move<State>& move : moves){
+        const Step<State>& step = move.step;
+        const bool extends = can_extend && step.action == 0 && !step.starts_leg
+            && legs.back().kind == LegKind::WALK && legs.back().direction == move.direction;
+        if (extends){
+            legs.back().tiles++;
+        }else{
+            Leg<State> leg;
+            leg.kind = step.action == 0 ? LegKind::WALK : LegKind::ACTION;
+            leg.action = step.action;
+            leg.direction = move.direction;
+            leg.tiles = 1;
+            leg.start = before;
+            legs.push_back(leg);
+        }
+        Leg<State>& leg = legs.back();
+        leg.warps = step.warped;
+        leg.to_wall = leg.kind == LegKind::WALK && !step.warped && model.held_at(step.next, move.direction);
+        leg.facing_after = step.facing;
+        leg.end = step.next;
+        can_extend = step.action == 0 && !step.ends_leg;
+        before = step.next;
+    }
+    return legs;
+}
+
+}
+
+
+
+template <typename Model>
+std::optional<std::vector<Leg<typename Model::State>>> plan_legs(
+    const Model& model,
+    const typename Model::State& start, std::optional<Direction> start_facing,
+    const std::function<bool(const typename Model::State&)>& at_goal,
+    std::optional<Direction> goal_facing,
+    const LegCosts& costs
+){
+    using State = typename Model::State;
+    using Node = LegPlannerInternal::Node<State>;
+    using Move = LegPlannerInternal::Move<State>;
+    using Hash = LegPlannerInternal::NodeHash<State, typename Model::StateHash>;
+    const int INF = std::numeric_limits<int>::max();
+
+    std::unordered_map<Node, int, Hash> distance;
+    std::unordered_map<Node, Move, Hash> came_from;
+    auto distance_of = [&](const Node& node){
+        auto iter = distance.find(node);
+        return iter == distance.end() ? INF : iter->second;
+    };
+    auto arrival_cost = [&](const Node& node){
+        int cost = LegPlannerInternal::stop_cost(model, node, costs);
+        if (goal_facing && node.facing != (int)*goal_facing){
+            cost += costs.per_turn;
+        }
+        return cost;
+    };
+
+    const Node first{start, start_facing ? (int)*start_facing : 4, false};
+    distance[first] = 0;
+
+    //  Nodes are kept in a list and queued by index, so State needs no ordering.
+    std::vector<Node> nodes{first};
+    using Entry = std::pair<int, size_t>;
+    std::priority_queue<Entry, std::vector<Entry>, std::greater<Entry>> queue;
+    queue.emplace(0, 0);
+
+    std::optional<Node> best_end;
+    int best_total = INF;
+    while (!queue.empty()){
+        const auto [cost, index] = queue.top();
+        queue.pop();
+        const Node current = nodes[index];
+        if (cost != distance_of(current)){
+            continue;
+        }
+        if (cost >= best_total){
+            break;
+        }
+        if (at_goal(current.state)){
+            const int total = cost + arrival_cost(current);
+            if (total < best_total){
+                best_total = total;
+                best_end = current;
+            }
+            continue;
+        }
+        for (Direction direction : ALL_DIRECTIONS){
+            std::optional<Step<State>> step = model.press(current.state, direction);
+            if (!step){
+                continue;
+            }
+            const bool continues = step->action == 0 && !step->ends_leg;
+            const Node next{step->next, (int)step->facing, continues};
+            int step_cost = costs.per_tile + step->extra_cost;
+            if (current.facing != (int)direction){
+                step_cost += costs.per_turn + LegPlannerInternal::stop_cost(model, current, costs);
+            }
+            if (cost + step_cost < distance_of(next)){
+                distance[next] = cost + step_cost;
+                came_from.insert_or_assign(next, Move{current, direction, *step});
+                nodes.push_back(next);
+                queue.emplace(cost + step_cost, nodes.size() - 1);
+            }
+        }
+    }
+    if (!best_end){
+        return std::nullopt;
+    }
+
+    std::vector<Move> moves;
+    for (Node node = *best_end; !(node == first); node = came_from.at(node).from){
+        moves.push_back(came_from.at(node));
+    }
+    std::reverse(moves.begin(), moves.end());
+    std::vector<Leg<State>> legs = LegPlannerInternal::join_legs(model, start, moves);
+    if (goal_facing && best_end->facing != (int)*goal_facing){
+        Leg<State> face;
+        face.kind = LegKind::FACE;
+        face.direction = *goal_facing;
+        face.facing_after = *goal_facing;
+        face.start = best_end->state;
+        face.end = best_end->state;
+        legs.push_back(face);
+    }
+    return legs;
+}
+
+
+
+}
+}
+#endif
diff --git a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegPlanner_Tests.cpp b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegPlanner_Tests.cpp
new file mode 100644
index 0000000000..e239c2274f
--- /dev/null
+++ b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegPlanner_Tests.cpp
@@ -0,0 +1,259 @@
+/*  Leg Planner Tests
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ *  The planner on a small made-up game, with the kinds of tiles the real
+ *  games have: walls, people, tall grass, a one-way tile and a warp.
+ *
+ */
+
+#include <functional>
+#include <string>
+#include <vector>
+#include "Common/Cpp/TestRunners/UnitTest.h"
+#include "Pokemon_LegPlanner.h"
+#include "Pokemon_LegPlanner_Tests.h"
+
+namespace PokemonAutomation{
+namespace Pokemon{
+
+
+namespace{
+
+//  '#' wall, '.' floor, '"' tall grass, 'p' a person (blocks, but may walk
+//  off, so not a wall to stop against), 'v' entered only going south, 'W'
+//  a warp to the tile marked 'X'.
+class ToyGame{
+public:
+    using State = TilePos;
+    using StateHash = std::hash<TilePos>;
+
+    explicit ToyGame(std::vector<std::string> rows)
+        : m_rows(std::move(rows))
+    {
+        for (int y = 0; y < (int)m_rows.size(); y++){
+            for (int x = 0; x < (int)m_rows[y].size(); x++){
+                if (m_rows[y][x] == 'X'){
+                    m_warp_to = {x, y};
+                }
+            }
+        }
+    }
+
+    std::optional<Step<State>> press(const State& state, Direction direction) const{
+        const TilePos next = state.next(direction);
+        const char tile = at(next);
+        if (tile == '#' || tile == 'p' || (tile == 'v' && direction != Direction::SOUTH)){
+            return std::nullopt;
+        }
+        Step<State> step;
+        step.next = next;
+        step.facing = direction;
+        if (tile == '"'){
+            step.extra_cost = 5;
+        }
+        if (tile == 'W'){
+            step.next = m_warp_to;
+            step.warped = true;
+            step.ends_leg = true;
+            step.extra_cost = 10;
+        }
+        return step;
+    }
+    bool held_at(const State& state, Direction direction) const{
+        const char tile = at(state.next(direction));
+        return tile == '#' || (tile == 'v' && direction != Direction::SOUTH);
+    }
+
+private:
+    char at(const TilePos& pos) const{
+        if (pos.y < 0 || pos.y >= (int)m_rows.size() || pos.x < 0 || pos.x >= (int)m_rows[pos.y].size()){
+            return '#';
+        }
+        return m_rows[pos.y][pos.x];
+    }
+
+    std::vector<std::string> m_rows;
+    TilePos m_warp_to;
+};
+
+
+std::string describe(const std::vector<Leg<TilePos>>& legs){
+    std::string text;
+    for (const Leg<TilePos>& leg : legs){
+        text += "\n  ";
+        text += leg.kind == LegKind::FACE ? "face " : "walk ";
+        text += direction_name(leg.direction);
+        if (leg.kind == LegKind::WALK){
+            text += " " + std::to_string(leg.tiles);
+        }
+        if (leg.to_wall){
+            text += " (to wall)";
+        }
+        if (leg.warps){
+            text += " (warp)";
+        }
+        text += " -> " + to_string(leg.end);
+    }
+    return text;
+}
+
+std::optional<std::vector<Leg<TilePos>>> plan(
+    const ToyGame& game, TilePos from, TilePos to,
+    std::optional<Direction> start_facing = std::nullopt,
+    std::optional<Direction> goal_facing = std::nullopt
+){
+    return plan_legs(game, from, start_facing, std::function<bool(const TilePos&)>([to](const TilePos& pos){ return pos == to; }), goal_facing);
+}
+
+
+UnitTestResult test_prefers_wall_legs(){
+    //  Two ways of equal length: east then south ends both legs in the open;
+    //  south then east ends the last one against the pillar.
+    const ToyGame game({
+        "......",
+        "...#..",
+        "......",
+    });
+    const auto legs = plan(game, {0, 0}, {2, 1});
+    if (!legs || legs->size() != 2){
+        return "Expected 2 legs:" + (legs ? describe(*legs) : std::string(" none"));
+    }
+    if ((*legs)[1].direction != Direction::EAST || !(*legs)[1].to_wall){
+        return "Expected to end going east into the pillar:" + describe(*legs);
+    }
+    return true;
+}
+
+UnitTestResult test_person_is_not_a_wall(){
+    //  The only way ends next to a person, which isn't a wall to stop against.
+    const ToyGame game({
+        "#####",
+        "#..p#",
+        "#####",
+    });
+    const auto legs = plan(game, {1, 1}, {2, 1});
+    if (!legs || legs->size() != 1 || (*legs)[0].to_wall){
+        return "Expected one open leg:" + (legs ? describe(*legs) : std::string(" none"));
+    }
+    return true;
+}
+
+UnitTestResult test_avoids_grass(){
+    //  Straight through the grass is 4 tiles; around it is 8, cheaper with
+    //  5 extra per grass tile.
+    const ToyGame game({
+        ".....",
+        ".\"\"\".",
+        ".....",
+    });
+    const auto legs = plan(game, {0, 1}, {4, 1});
+    if (!legs){
+        return "No route.";
+    }
+    for (const Leg<TilePos>& leg : *legs){
+        if (leg.end.y == 1 && leg.end.x > 0 && leg.end.x < 4){
+            return "Walked into the grass:" + describe(*legs);
+        }
+    }
+    return true;
+}
+
+UnitTestResult test_one_way_tile(){
+    //  The 'v' can only be entered going south, so going back up must go around.
+    const ToyGame game({
+        "#.#.#",
+        "#v#.#",
+        "#...#",
+        "#####",
+    });
+    if (!plan(game, {1, 0}, {1, 2})){
+        return "No route down through the one-way tile.";
+    }
+    const auto up = plan(game, {1, 2}, {1, 0});
+    if (up){
+        return "Went up through the one-way tile:" + describe(*up);
+    }
+    return true;
+}
+
+UnitTestResult test_warp_ends_leg(){
+    //  The warp on the left takes the player to X on the right.
+    const ToyGame game({
+        "#######",
+        "#W.#X.#",
+        "#..#..#",
+        "#######",
+    });
+    const auto legs = plan(game, {2, 2}, {5, 2});
+    if (!legs){
+        return "No route.";
+    }
+    bool warped = false;
+    for (const Leg<TilePos>& leg : *legs){
+        if (leg.warps){
+            warped = true;
+            if (!(leg.end == TilePos{4, 1})){
+                return "The warp leg ends at " + to_string(leg.end) + ":" + describe(*legs);
+            }
+        }
+    }
+    if (!warped){
+        return "Expected a warp leg:" + describe(*legs);
+    }
+    return true;
+}
+
+UnitTestResult test_goal_facing(){
+    const ToyGame game({
+        "....",
+    });
+    const auto legs = plan(game, {0, 0}, {2, 0}, std::nullopt, Direction::NORTH);
+    if (!legs || legs->back().kind != LegKind::FACE || legs->back().direction != Direction::NORTH){
+        return "Expected to end facing north:" + (legs ? describe(*legs) : std::string(" none"));
+    }
+    return true;
+}
+
+UnitTestResult test_unreachable(){
+    const ToyGame game({
+        ".#.",
+    });
+    if (plan(game, {0, 0}, {2, 0})){
+        return "Planned through a wall.";
+    }
+    return true;
+}
+
+
+class Test_LegPlanner : public UnitTest{
+public:
+    Test_LegPlanner(std::string name, std::function<UnitTestResult()> body)
+        : UnitTest("Pokemon::LegPlanner - " + std::move(name))
+        , m_body(std::move(body))
+    {}
+    virtual UnitTestResult run(Logger&, CancellableScope&) const override{
+        return m_body();
+    }
+
+private:
+    std::function<UnitTestResult()> m_body;
+};
+
+}
+
+
+void add_tests_LegPlanner(UnitTestDatabase& database){
+    database.add<Test_LegPlanner>("prefers legs that end at a wall", test_prefers_wall_legs);
+    database.add<Test_LegPlanner>("a person is not a wall", test_person_is_not_a_wall);
+    database.add<Test_LegPlanner>("avoids tall grass", test_avoids_grass);
+    database.add<Test_LegPlanner>("one-way tile", test_one_way_tile);
+    database.add<Test_LegPlanner>("a warp ends the leg", test_warp_ends_leg);
+    database.add<Test_LegPlanner>("turns to face the goal", test_goal_facing);
+    database.add<Test_LegPlanner>("nothing through a wall", test_unreachable);
+}
+
+
+
+}
+}
diff --git a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegPlanner_Tests.h b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegPlanner_Tests.h
new file mode 100644
index 0000000000..537de3309f
--- /dev/null
+++ b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegPlanner_Tests.h
@@ -0,0 +1,22 @@
+/*  Leg Planner Tests
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ */
+
+#ifndef PokemonAutomation_Pokemon_LegPlanner_Tests_H
+#define PokemonAutomation_Pokemon_LegPlanner_Tests_H
+
+#include "Common/Cpp/TestRunners/UnitTestDatabase.h"
+
+namespace PokemonAutomation{
+namespace Pokemon{
+
+
+void add_tests_LegPlanner(UnitTestDatabase& database);
+
+
+
+}
+}
+#endif
diff --git a/SerialPrograms/cmake/SourceFiles.cmake b/SerialPrograms/cmake/SourceFiles.cmake
index 9e4e0895bb..8fe4f292f7 100644
--- a/SerialPrograms/cmake/SourceFiles.cmake
+++ b/SerialPrograms/cmake/SourceFiles.cmake
@@ -1425,6 +1425,11 @@ file(GLOB LIBRARY_SOURCES
     Source/Pokemon/Inference/Pokemon_TrainPokemonOCR.h
     Source/Pokemon/Inference/Pokemon_TypeReader.cpp
     Source/Pokemon/Inference/Pokemon_TypeReader.h
+    Source/Pokemon/Navigation/Pokemon_Grid.cpp
+    Source/Pokemon/Navigation/Pokemon_Grid.h
+    Source/Pokemon/Navigation/Pokemon_LegPlanner.h
+    Source/Pokemon/Navigation/Pokemon_LegPlanner_Tests.cpp
+    Source/Pokemon/Navigation/Pokemon_LegPlanner_Tests.h
     Source/Pokemon/Options/Pokemon_BoxSortingTable.cpp
     Source/Pokemon/Options/Pokemon_BoxSortingTable.h
     Source/Pokemon/Options/Pokemon_EncounterBotOptions.h

From 3bd531e64b28ca9251f502b3a6e1a689fb19aea2 Mon Sep 17 00:00:00 2001
From: dayfine <difancpa@gmail.com>
Date: Thu, 29 Oct 2026 17:41:35 -0700
Subject: [PATCH 02/10] Pokemon navigation: leg walker with game-supplied
 movers and interrupts

Holds one leg while watching for what can stop it part-way. On an
interrupt, a leg to a wall is held again and an open leg walks what is
left, estimated from when the interrupt was seen. The bookkeeping is a
plain function, tested with scripted holds.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AKYzhrMnPK61XHWEch4a6E
---
 .../ComputerPrograms_UnitTestRunner.cpp       |   3 +-
 .../Navigation/Pokemon_LegPlanner_Tests.cpp   |   2 +-
 .../Pokemon/Navigation/Pokemon_LegWalker.cpp  |  70 ++++++
 .../Pokemon/Navigation/Pokemon_LegWalker.h    | 212 ++++++++++++++++++
 .../Navigation/Pokemon_LegWalker_Tests.cpp    | 176 +++++++++++++++
 ...ner_Tests.h => Pokemon_Navigation_Tests.h} |   7 +-
 SerialPrograms/cmake/SourceFiles.cmake        |   5 +-
 7 files changed, 469 insertions(+), 6 deletions(-)
 create mode 100644 SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegWalker.cpp
 create mode 100644 SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegWalker.h
 create mode 100644 SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegWalker_Tests.cpp
 rename SerialPrograms/Source/Pokemon/Navigation/{Pokemon_LegPlanner_Tests.h => Pokemon_Navigation_Tests.h} (53%)

diff --git a/SerialPrograms/Source/ComputerPrograms/ComputerPrograms_UnitTestRunner.cpp b/SerialPrograms/Source/ComputerPrograms/ComputerPrograms_UnitTestRunner.cpp
index 0024cd1902..6c957de605 100644
--- a/SerialPrograms/Source/ComputerPrograms/ComputerPrograms_UnitTestRunner.cpp
+++ b/SerialPrograms/Source/ComputerPrograms/ComputerPrograms_UnitTestRunner.cpp
@@ -27,7 +27,7 @@
 #include "NintendoSwitch/Inference/NintendoSwitch_UpdatePopupDetector.h"
 #include "NintendoSwitch/Programs/Typewriter/NintendoSwitch_Typewriter_Tests.h"
 
-#include "Pokemon/Navigation/Pokemon_LegPlanner_Tests.h"
+#include "Pokemon/Navigation/Pokemon_Navigation_Tests.h"
 #include "VideoGames/PokemonHome/PokemonHome_Tests.h"
 #include "VideoGames/PokemonSwSh/PokemonSwSh_Tests.h"
 #include "VideoGames/PokemonLA/PokemonLA_Tests.h"
@@ -60,6 +60,7 @@ UnitTestDatabase make_UNIT_TESTS_ALL(){
     OCR::add_tests(ret);
     Kernels::add_tests(ret);
     Pokemon::add_tests_LegPlanner(ret);
+    Pokemon::add_tests_LegWalker(ret);
     NintendoSwitch::add_tests_CheckOnlineDetector(ret);
     NintendoSwitch::add_tests_FailedToConnectDetector(ret);
     NintendoSwitch::add_tests_UpdatePopupDetector(ret);
diff --git a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegPlanner_Tests.cpp b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegPlanner_Tests.cpp
index e239c2274f..136cb9d28c 100644
--- a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegPlanner_Tests.cpp
+++ b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegPlanner_Tests.cpp
@@ -12,7 +12,7 @@
 #include <vector>
 #include "Common/Cpp/TestRunners/UnitTest.h"
 #include "Pokemon_LegPlanner.h"
-#include "Pokemon_LegPlanner_Tests.h"
+#include "Pokemon_Navigation_Tests.h"
 
 namespace PokemonAutomation{
 namespace Pokemon{
diff --git a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegWalker.cpp b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegWalker.cpp
new file mode 100644
index 0000000000..40f082e2f8
--- /dev/null
+++ b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegWalker.cpp
@@ -0,0 +1,70 @@
+/*  Leg Walker
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ */
+
+#include "Pokemon_LegWalker.h"
+
+namespace PokemonAutomation{
+namespace Pokemon{
+
+
+std::string to_string(const LegSpec& leg){
+    return std::string(direction_name(leg.direction)) + " " + std::to_string(leg.tiles)
+        + (leg.to_wall ? " (to wall)" : "");
+}
+
+
+Milliseconds leg_hold(const LegSpec& leg, int tiles){
+    if (leg.to_wall){
+        return leg.tile_time * (tiles + 2);
+    }
+    return leg.tile_time * (tiles - 1) + leg.tile_time / 2;
+}
+
+int tiles_before_interrupt(const LegSpec& leg, Milliseconds elapsed, Milliseconds detection_delay, int remaining){
+    const Milliseconds since_first_step = elapsed - detection_delay + leg.tile_time / 2;
+    if (since_first_step.count() <= 0){
+        return 0;
+    }
+    return std::clamp((int)(since_first_step / leg.tile_time), 0, remaining);
+}
+
+
+LegResult walk_leg_with(const LegSpec& leg, const LegCalls& calls, size_t max_interruptions){
+    LegResult result;
+    int remaining = leg.tiles;
+    while (true){
+        const std::optional<HoldOutcome> outcome = calls.hold_watching(leg_hold(leg, remaining));
+        if (!outcome){
+            result.tiles = leg.tiles;
+            return result;
+        }
+        result.interruptions++;
+        if (result.interruptions > max_interruptions){
+            calls.fail("Interrupted " + std::to_string(result.interruptions) + " times on: " + to_string(leg));
+        }
+        calls.clear(outcome->interrupt);
+        const std::string seen = calls.name(outcome->interrupt) + " after " + std::to_string(outcome->elapsed.count()) + "ms";
+        if (leg.to_wall){
+            //  The wall stops the player on the leg's last tile however far
+            //  they got, so the leg is simply held again.
+            calls.log(seen + ", walking to the wall again.");
+            continue;
+        }
+        const int walked = tiles_before_interrupt(leg, outcome->elapsed, calls.detection_delay(outcome->interrupt), remaining);
+        remaining -= walked;
+        result.exact = false;
+        calls.log(seen + ", about " + std::to_string(walked) + " tiles walked, " + std::to_string(remaining) + " to go.");
+        if (remaining <= 0){
+            result.tiles = leg.tiles;
+            return result;
+        }
+    }
+}
+
+
+
+}
+}
diff --git a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegWalker.h b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegWalker.h
new file mode 100644
index 0000000000..2d471b3eb9
--- /dev/null
+++ b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegWalker.h
@@ -0,0 +1,212 @@
+/*  Leg Walker
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ *  Walks one leg of a plan: holds a direction for the leg's tiles while
+ *  watching for whatever can stop the player part-way (a wild battle, a
+ *  message, a trainer). Each of those is a LegInterrupt the game supplies.
+ *  When one shows, the hold stops, the game clears it, and the rest of the
+ *  leg is walked: a leg to a wall is simply held again, since the wall stops
+ *  the player on its tile; for an open leg, how far the player got is worked
+ *  out from when the interrupt was seen.
+ *
+ *  How a direction is held (D-pad or stick) and how long a tile takes are
+ *  the game's too, through LegMover. Templated on the console and the
+ *  controller context, like run_until(), so this stays free of any one
+ *  console's types.
+ *
+ */
+
+#ifndef PokemonAutomation_Pokemon_LegWalker_H
+#define PokemonAutomation_Pokemon_LegWalker_H
+
+#include <algorithm>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+#include "Common/Cpp/Time.h"
+#include "CommonFramework/Exceptions/OperationFailedExceptionWithScreenshot.h"
+#include "CommonTools/Async/InferenceRoutines.h"
+#include "CommonTools/InferenceCallbacks/VisualInferenceCallback.h"
+#include "Pokemon_Grid.h"
+
+namespace PokemonAutomation{
+namespace Pokemon{
+
+
+//  Something that stops the player part-way through a leg.
+template <typename Console, typename Context>
+class LegInterrupt{
+public:
+    virtual ~LegInterrupt() = default;
+
+    virtual std::string name() const = 0;
+
+    //  A new watcher for the screen the interruption brings up.
+    virtual std::unique_ptr<VisualInferenceCallback> make_watcher() const = 0;
+
+    //  How long after the step that set it off the watcher fires. The games
+    //  only interrupt between steps, so from this the walker works out how
+    //  many tiles of an open leg were walked.
+    virtual Milliseconds detection_delay() const = 0;
+
+    //  Clears it, leaving the player standing on the overworld, on the same
+    //  tile and facing the same way.
+    virtual void clear(Console& console, Context& context) const = 0;
+};
+
+template <typename Console, typename Context>
+using LegInterrupts = std::vector<std::unique_ptr<LegInterrupt<Console, Context>>>;
+
+
+//  How the game moves the player.
+template <typename Context>
+class LegMover{
+public:
+    virtual ~LegMover() = default;
+    //  Holds `direction` for `duration`, then lets go.
+    virtual void hold(Context& context, Direction direction, Milliseconds duration) const = 0;
+};
+
+
+//  A straight leg, for a player standing still and facing its way.
+struct LegSpec{
+    Direction direction = Direction::NORTH;
+    int tiles = 0;
+    //  A wall stops the player after the last tile.
+    bool to_wall = false;
+    //  How long one tile takes, for this leg's direction and way of moving.
+    Milliseconds tile_time{0};
+};
+std::string to_string(const LegSpec& leg);
+
+struct LegResult{
+    //  Tiles walked, which is `tiles` unless the leg gave up.
+    int tiles = 0;
+    //  Whether `tiles` is certain: an interrupted open leg is an estimate.
+    bool exact = true;
+    size_t interruptions = 0;
+};
+
+
+//  How long to hold for `tiles` tiles: an open leg lets go half a tile before
+//  the last step would end, so the step under way finishes and no other
+//  starts; a leg to a wall is held two tiles longer than it takes.
+Milliseconds leg_hold(const LegSpec& leg, int tiles);
+
+//  How many tiles an open leg had walked when an interrupt was seen
+//  `elapsed` into its hold, given the interrupt's detection delay. Steps end
+//  a whole number of tiles into the hold, so this rounds to the nearest.
+int tiles_before_interrupt(const LegSpec& leg, Milliseconds elapsed, Milliseconds detection_delay, int remaining);
+
+
+//  What one hold reported: nothing if it ran out, or which interrupt showed
+//  and how long into the hold.
+struct HoldOutcome{
+    size_t interrupt = 0;
+    Milliseconds elapsed{0};
+};
+
+//  The leg's bookkeeping, with the console side passed in, so it can be
+//  tested with scripted outcomes. `hold_watching` holds for the duration and
+//  reports the first interrupt seen; `clear` clears interrupt i;
+//  `detection_delay` is interrupt i's delay; `log` reports progress; `fail`
+//  throws, and is called after more than `max_interruptions`.
+struct LegCalls{
+    std::function<std::optional<HoldOutcome>(Milliseconds hold)> hold_watching;
+    std::function<void(size_t interrupt)> clear;
+    std::function<Milliseconds(size_t interrupt)> detection_delay;
+    std::function<std::string(size_t interrupt)> name;
+    std::function<void(const std::string& message)> log;
+    std::function<void(const std::string& message)> fail;
+};
+LegResult walk_leg_with(const LegSpec& leg, const LegCalls& calls, size_t max_interruptions);
+
+
+//  Walks `leg`. Throws OperationFailedException if it is interrupted more
+//  than `max_interruptions` times.
+template <typename Console, typename Context>
+LegResult walk_leg(
+    Console& console, Context& context,
+    const LegMover<Context>& mover,
+    const LegInterrupts<Console, Context>& interrupts,
+    const LegSpec& leg,
+    size_t max_interruptions = 5
+){
+    auto hold_watching = [&](Milliseconds hold) -> std::optional<HoldOutcome>{
+        std::vector<std::unique_ptr<VisualInferenceCallback>> watchers;
+        std::vector<PeriodicInferenceCallback> callbacks;
+        for (const auto& interrupt : interrupts){
+            watchers.emplace_back(interrupt->make_watcher());
+            callbacks.emplace_back(*watchers.back());
+        }
+        context.wait_for_all_requests();
+        WallClock start = current_time();
+        const int ret = run_until<Context>(
+            console, context,
+            [&](Context& context){
+                start = current_time();
+                mover.hold(context, leg.direction, hold);
+            },
+            callbacks
+        );
+        if (ret < 0){
+            return std::nullopt;
+        }
+        return HoldOutcome{(size_t)ret, std::chrono::duration_cast<Milliseconds>(current_time() - start)};
+    };
+    LegCalls calls;
+    calls.hold_watching = hold_watching;
+    calls.clear = [&](size_t index){ interrupts[index]->clear(console, context); };
+    calls.detection_delay = [&](size_t index){ return interrupts[index]->detection_delay(); };
+    calls.name = [&](size_t index){ return interrupts[index]->name(); };
+    calls.log = [&](const std::string& message){ console.log("Leg: " + message, COLOR_ORANGE); };
+    calls.fail = [&](const std::string& message){
+        OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT, message, console);
+    };
+    return walk_leg_with(leg, calls, max_interruptions);
+}
+
+
+//  After a leg: waits `watch` for an interrupt the last step set off, which
+//  shows after the hold has ended, and clears it. Throws
+//  OperationFailedException after `max_interruptions` in a row.
+template <typename Console, typename Context>
+void clear_late_interrupts(
+    Console& console, Context& context,
+    const LegInterrupts<Console, Context>& interrupts,
+    Milliseconds watch,
+    size_t max_interruptions = 5
+){
+    for (size_t count = 0; ; count++){
+        std::vector<std::unique_ptr<VisualInferenceCallback>> watchers;
+        std::vector<PeriodicInferenceCallback> callbacks;
+        for (const auto& interrupt : interrupts){
+            watchers.emplace_back(interrupt->make_watcher());
+            callbacks.emplace_back(*watchers.back());
+        }
+        context.wait_for_all_requests();
+        const int ret = wait_until(console, context, watch, callbacks);
+        if (ret < 0){
+            return;
+        }
+        if (count >= max_interruptions){
+            OperationFailedExceptionWithScreenshot::fire(
+                ErrorReportMode::SEND_ERROR_REPORT,
+                "Interrupted " + std::to_string(count) + " times in a row after a leg.",
+                console
+            );
+        }
+        console.log("Leg: " + interrupts[ret]->name() + " at the end of the leg.", COLOR_ORANGE);
+        interrupts[ret]->clear(console, context);
+    }
+}
+
+
+
+
+}
+}
+#endif
diff --git a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegWalker_Tests.cpp b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegWalker_Tests.cpp
new file mode 100644
index 0000000000..c0ef205267
--- /dev/null
+++ b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegWalker_Tests.cpp
@@ -0,0 +1,176 @@
+/*  Leg Walker Tests
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ *  The leg walker's bookkeeping, with holds that report scripted
+ *  interruptions instead of a console.
+ *
+ */
+
+#include <deque>
+#include <functional>
+#include <stdexcept>
+#include <string>
+#include <vector>
+#include "Common/Cpp/TestRunners/UnitTest.h"
+#include "Pokemon_LegWalker.h"
+#include "Pokemon_Navigation_Tests.h"
+
+namespace PokemonAutomation{
+namespace Pokemon{
+
+
+namespace{
+
+using namespace std::chrono_literals;
+
+constexpr Milliseconds TILE = 267ms;
+constexpr Milliseconds DELAY = 300ms;
+
+//  Holds that report the scripted outcomes in order, then run out.
+struct ScriptedLeg{
+    std::deque<std::optional<HoldOutcome>> outcomes;
+    std::vector<Milliseconds> holds;
+    std::vector<size_t> cleared;
+
+    LegCalls calls(){
+        LegCalls calls;
+        calls.hold_watching = [this](Milliseconds hold) -> std::optional<HoldOutcome>{
+            holds.push_back(hold);
+            if (outcomes.empty()){
+                return std::nullopt;
+            }
+            std::optional<HoldOutcome> outcome = outcomes.front();
+            outcomes.pop_front();
+            return outcome;
+        };
+        calls.clear = [this](size_t index){ cleared.push_back(index); };
+        calls.detection_delay = [](size_t){ return DELAY; };
+        calls.name = [](size_t){ return std::string("a battle"); };
+        calls.log = [](const std::string&){};
+        calls.fail = [](const std::string& message){ throw std::runtime_error(message); };
+        return calls;
+    }
+};
+
+//  An interrupt set off by step `step`, seen DELAY after it ends.
+HoldOutcome after_step(int step){
+    return HoldOutcome{0, TILE * step + DELAY};
+}
+
+
+UnitTestResult test_hold_times(){
+    const LegSpec open{Direction::EAST, 4, false, TILE};
+    const LegSpec wall{Direction::EAST, 4, true, TILE};
+    if (leg_hold(open, 4) != TILE * 3 + TILE / 2){
+        return "Open leg: " + std::to_string(leg_hold(open, 4).count()) + "ms";
+    }
+    if (leg_hold(wall, 4) != TILE * 6){
+        return "Wall leg: " + std::to_string(leg_hold(wall, 4).count()) + "ms";
+    }
+    return true;
+}
+
+UnitTestResult test_tiles_before_interrupt(){
+    const LegSpec leg{Direction::EAST, 8, false, TILE};
+    for (int step = 0; step <= 8; step++){
+        for (Milliseconds jitter : {-100ms, 0ms, 100ms}){
+            const int walked = tiles_before_interrupt(leg, TILE * step + DELAY + jitter, DELAY, 8);
+            if (walked != step){
+                return "Step " + std::to_string(step) + " seen " + std::to_string(jitter.count()) + "ms off read as " + std::to_string(walked);
+            }
+        }
+    }
+    if (tiles_before_interrupt(leg, 50ms, DELAY, 8) != 0){
+        return "An interrupt from before the leg should count no tiles.";
+    }
+    if (tiles_before_interrupt(leg, TILE * 20, DELAY, 3) != 3){
+        return "Should not count more tiles than remain.";
+    }
+    return true;
+}
+
+UnitTestResult test_wall_leg_walked_again(){
+    ScriptedLeg script;
+    script.outcomes = {after_step(2)};
+    const LegSpec leg{Direction::NORTH, 6, true, TILE};
+    const LegResult result = walk_leg_with(leg, script.calls(), 5);
+    if (script.holds.size() != 2 || script.holds[1] != leg_hold(leg, 6)){
+        return "Expected the whole leg held again.";
+    }
+    if (!result.exact || result.interruptions != 1 || script.cleared.size() != 1){
+        return "Expected an exact result after one interruption.";
+    }
+    return true;
+}
+
+UnitTestResult test_open_leg_rest_walked(){
+    ScriptedLeg script;
+    script.outcomes = {after_step(2)};
+    const LegSpec leg{Direction::NORTH, 6, false, TILE};
+    const LegResult result = walk_leg_with(leg, script.calls(), 5);
+    if (script.holds.size() != 2 || script.holds[1] != leg_hold(leg, 4)){
+        return "Expected the remaining 4 tiles held.";
+    }
+    if (result.exact){
+        return "An interrupted open leg is an estimate.";
+    }
+    return true;
+}
+
+UnitTestResult test_open_leg_interrupted_at_end(){
+    ScriptedLeg script;
+    script.outcomes = {after_step(6)};
+    const LegSpec leg{Direction::NORTH, 6, false, TILE};
+    walk_leg_with(leg, script.calls(), 5);
+    if (script.holds.size() != 1){
+        return "Nothing was left to walk after the last step.";
+    }
+    return true;
+}
+
+UnitTestResult test_too_many_interruptions(){
+    ScriptedLeg script;
+    for (int c = 0; c < 4; c++){
+        script.outcomes.push_back(after_step(0));
+    }
+    const LegSpec leg{Direction::NORTH, 6, true, TILE};
+    try{
+        walk_leg_with(leg, script.calls(), 3);
+    }catch (std::runtime_error&){
+        return true;
+    }
+    return "Expected to give up after 3 interruptions.";
+}
+
+
+class Test_LegWalker : public UnitTest{
+public:
+    Test_LegWalker(std::string name, std::function<UnitTestResult()> body)
+        : UnitTest("Pokemon::LegWalker - " + std::move(name))
+        , m_body(std::move(body))
+    {}
+    virtual UnitTestResult run(Logger&, CancellableScope&) const override{
+        return m_body();
+    }
+
+private:
+    std::function<UnitTestResult()> m_body;
+};
+
+}
+
+
+void add_tests_LegWalker(UnitTestDatabase& database){
+    database.add<Test_LegWalker>("hold times", test_hold_times);
+    database.add<Test_LegWalker>("tiles before an interrupt", test_tiles_before_interrupt);
+    database.add<Test_LegWalker>("a wall leg is walked again", test_wall_leg_walked_again);
+    database.add<Test_LegWalker>("an open leg walks the rest", test_open_leg_rest_walked);
+    database.add<Test_LegWalker>("an open leg interrupted at its end", test_open_leg_interrupted_at_end);
+    database.add<Test_LegWalker>("gives up after too many interruptions", test_too_many_interruptions);
+}
+
+
+
+}
+}
diff --git a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegPlanner_Tests.h b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_Navigation_Tests.h
similarity index 53%
rename from SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegPlanner_Tests.h
rename to SerialPrograms/Source/Pokemon/Navigation/Pokemon_Navigation_Tests.h
index 537de3309f..fa7fd8e612 100644
--- a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegPlanner_Tests.h
+++ b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_Navigation_Tests.h
@@ -1,11 +1,11 @@
-/*  Leg Planner Tests
+/*  Navigation Tests
  *
  *  From: https://github.com/PokemonAutomation/
  *
  */
 
-#ifndef PokemonAutomation_Pokemon_LegPlanner_Tests_H
-#define PokemonAutomation_Pokemon_LegPlanner_Tests_H
+#ifndef PokemonAutomation_Pokemon_Navigation_Tests_H
+#define PokemonAutomation_Pokemon_Navigation_Tests_H
 
 #include "Common/Cpp/TestRunners/UnitTestDatabase.h"
 
@@ -14,6 +14,7 @@ namespace Pokemon{
 
 
 void add_tests_LegPlanner(UnitTestDatabase& database);
+void add_tests_LegWalker(UnitTestDatabase& database);
 
 
 
diff --git a/SerialPrograms/cmake/SourceFiles.cmake b/SerialPrograms/cmake/SourceFiles.cmake
index 8fe4f292f7..e632bd254c 100644
--- a/SerialPrograms/cmake/SourceFiles.cmake
+++ b/SerialPrograms/cmake/SourceFiles.cmake
@@ -1429,7 +1429,10 @@ file(GLOB LIBRARY_SOURCES
     Source/Pokemon/Navigation/Pokemon_Grid.h
     Source/Pokemon/Navigation/Pokemon_LegPlanner.h
     Source/Pokemon/Navigation/Pokemon_LegPlanner_Tests.cpp
-    Source/Pokemon/Navigation/Pokemon_LegPlanner_Tests.h
+    Source/Pokemon/Navigation/Pokemon_LegWalker.cpp
+    Source/Pokemon/Navigation/Pokemon_LegWalker.h
+    Source/Pokemon/Navigation/Pokemon_LegWalker_Tests.cpp
+    Source/Pokemon/Navigation/Pokemon_Navigation_Tests.h
     Source/Pokemon/Options/Pokemon_BoxSortingTable.cpp
     Source/Pokemon/Options/Pokemon_BoxSortingTable.h
     Source/Pokemon/Options/Pokemon_EncounterBotOptions.h

From 0f59863af9df1dcb82b3a0fea47b17aec6acf32b Mon Sep 17 00:00:00 2001
From: dayfine <difancpa@gmail.com>
Date: Wed, 28 Oct 2026 01:34:01 -0700
Subject: [PATCH 03/10] Add a screen machine and step trace for closed-loop
 routines

Routines that mash a button or hold a direction for a fixed time break when an
input drops or a stray press opens a menu, and nothing notices until much
later. run_screen_machine() is the closed-loop alternative: it reads the
screen (two frames must agree), takes the one step that state calls for, and
fails on a screen the previous state cannot lead to, a state seen too often or
too many times in a row, eight steps that change nothing, or the timeout. A
capture that drops out for up to 10s is waited out.

StepTrace logs each change of recognized screen with a numbered screenshot and
each input, and a failure lists the screens that led to it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AKYzhrMnPK61XHWEch4a6E
---
 .../ScreenMachine/ScreenMachine.cpp           |  97 ++++++++++++++++
 .../CommonTools/ScreenMachine/ScreenMachine.h | 105 ++++++++++++++++++
 .../CommonTools/ScreenMachine/StepTrace.cpp   |  74 ++++++++++++
 .../CommonTools/ScreenMachine/StepTrace.h     |  53 +++++++++
 SerialPrograms/cmake/SourceFiles.cmake        |   4 +
 5 files changed, 333 insertions(+)
 create mode 100644 SerialPrograms/Source/CommonTools/ScreenMachine/ScreenMachine.cpp
 create mode 100644 SerialPrograms/Source/CommonTools/ScreenMachine/ScreenMachine.h
 create mode 100644 SerialPrograms/Source/CommonTools/ScreenMachine/StepTrace.cpp
 create mode 100644 SerialPrograms/Source/CommonTools/ScreenMachine/StepTrace.h

diff --git a/SerialPrograms/Source/CommonTools/ScreenMachine/ScreenMachine.cpp b/SerialPrograms/Source/CommonTools/ScreenMachine/ScreenMachine.cpp
new file mode 100644
index 0000000000..8d528c4eaa
--- /dev/null
+++ b/SerialPrograms/Source/CommonTools/ScreenMachine/ScreenMachine.cpp
@@ -0,0 +1,97 @@
+/*  Screen Machine
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ */
+
+#include <algorithm>
+#include "CommonFramework/ImageTools/ImageDiff.h"
+#include "ScreenMachine.h"
+
+namespace PokemonAutomation{
+
+using namespace std::chrono_literals;
+
+
+namespace{
+
+const ScreenState* classify(const std::vector<ScreenState>& states, const ImageViewRGB32& screen){
+    for (const ScreenState& state : states){
+        if (state.matches(screen)){
+            return &state;
+        }
+    }
+    return nullptr;
+}
+
+}
+
+
+const ScreenState& read_screen_state(
+    VideoStream& stream, CancellableScope& scope, StepTrace& trace,
+    const std::vector<ScreenState>& states, VideoSnapshot& frame
+){
+    const ScreenState* last = nullptr;
+    WallClock video_lost = WallClock::max();
+    for (size_t c = 0; c < 20; c++){
+        VideoSnapshot screen = stream.video().snapshot();
+        if (!screen){
+            //  The app resets a frozen capture by itself, which takes a second or two.
+            const WallClock now = current_time();
+            video_lost = std::min(video_lost, now);
+            if (now - video_lost > std::chrono::seconds(10)){
+                trace.fail("No video from the capture card for 10s.");
+            }
+            c--;
+            scope.wait_for(500ms);
+            continue;
+        }
+        video_lost = WallClock::max();
+        const ScreenState* now = classify(states, screen);
+        frame = std::move(screen);
+        if (now != nullptr && now == last){
+            return *now;
+        }
+        last = now;
+        scope.wait_for(150ms);
+    }
+    if (last == nullptr){
+        trace.fail("The screen matches none of the known states.");
+    }
+    return *last;   //  Still changing after 3s: go with the latest read.
+}
+
+
+void ScreenMachineChecks::check(const ScreenState& state, VideoSnapshot frame){
+    const bool same_size = m_last_frame && frame &&
+        m_last_frame->width() == frame->width() && m_last_frame->height() == frame->height();
+    if (same_size && ImageMatch::pixel_RMSD(m_last_frame, frame) < 2.0){
+        if (++m_unchanged >= MAX_UNCHANGED){
+            m_trace.fail("The screen stopped changing: " + std::to_string(MAX_UNCHANGED) +
+                " steps on \"" + state.name + "\" did nothing.");
+        }
+    }else{
+        m_unchanged = 0;
+    }
+    m_last_frame = std::move(frame);
+
+    if (m_previous != nullptr && m_previous != &state && !m_previous->next.empty() &&
+        std::find(m_previous->next.begin(), m_previous->next.end(), state.name) == m_previous->next.end()
+    ){
+        m_trace.fail("Unexpected screen after \"" + m_previous->name + "\": \"" + state.name + "\".");
+    }
+    m_in_a_row = m_previous == &state ? m_in_a_row + 1 : 1;
+    if (m_in_a_row > state.max_in_a_row){
+        m_trace.fail("Screen \"" + state.name + "\" came up " + std::to_string(m_in_a_row) +
+            " times in a row: the step for it is not getting anywhere.");
+    }
+    if (++m_visits[state.name] > state.max_visits){
+        m_trace.fail("Screen \"" + state.name + "\" came up more than " +
+            std::to_string(state.max_visits) + " times: the step for it is not working.");
+    }
+    m_previous = &state;
+}
+
+
+
+}
diff --git a/SerialPrograms/Source/CommonTools/ScreenMachine/ScreenMachine.h b/SerialPrograms/Source/CommonTools/ScreenMachine/ScreenMachine.h
new file mode 100644
index 0000000000..f878ff709c
--- /dev/null
+++ b/SerialPrograms/Source/CommonTools/ScreenMachine/ScreenMachine.h
@@ -0,0 +1,105 @@
+/*  Screen Machine
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ *  A closed loop over known screens: read the screen, take the one step that screen
+ *  calls for, read again. Every step follows a read, a screen counts only once two
+ *  frames agree, and each state lists the screens it may lead to, so a dropped or
+ *  wrong input shows up as an unexpected screen or a state that keeps coming back.
+ *
+ */
+
+#ifndef PokemonAutomation_CommonTools_ScreenMachine_H
+#define PokemonAutomation_CommonTools_ScreenMachine_H
+
+#include <stdint.h>
+#include <functional>
+#include <map>
+#include <string>
+#include <vector>
+#include "Common/Cpp/Time.h"
+#include "Common/Cpp/CancellableScope.h"
+#include "CommonFramework/ImageTypes/ImageViewRGB32.h"
+#include "CommonFramework/Tools/VideoStream.h"
+#include "CommonFramework/VideoPipeline/VideoFeed.h"
+#include "StepTrace.h"
+
+namespace PokemonAutomation{
+
+
+struct ScreenState{
+    std::string name;
+    //  Whether this is the screen. States are tried in order; the first match wins, so
+    //  the last state should match anything.
+    std::function<bool(const ImageViewRGB32& screen)> matches;
+    //  The one step to take on this screen.
+    std::function<void()> act;
+    //  The screens the step may lead to besides staying here. Empty: any.
+    std::vector<std::string> next;
+    //  Fail once the screen has been seen this many times.
+    size_t max_visits;
+    //  End the run after this state's step.
+    bool terminal = false;
+    //  Fail once the screen has been seen this many times in a row.
+    size_t max_in_a_row = SIZE_MAX;
+};
+
+
+//  The state on screen, once two frames 150ms apart agree. Waits out a video
+//  gap of up to 10s. Fails through `trace` if no state matches.
+const ScreenState& read_screen_state(
+    VideoStream& stream, CancellableScope& scope, StepTrace& trace,
+    const std::vector<ScreenState>& states, VideoSnapshot& frame
+);
+
+//  The checks between reads: the screen must be one the previous state can lead
+//  to, no state may come up too often, and steps must keep changing the screen.
+class ScreenMachineChecks{
+public:
+    ScreenMachineChecks(StepTrace& trace)
+        : m_trace(trace)
+    {}
+    void check(const ScreenState& state, VideoSnapshot frame);
+
+private:
+    //  A step that changes nothing on screen is a dead end (e.g. a menu the states do
+    //  not know): fail after a few instead of running out the visit limit.
+    static constexpr size_t MAX_UNCHANGED = 8;
+
+    StepTrace& m_trace;
+    std::map<std::string, size_t> m_visits;
+    const ScreenState* m_previous = nullptr;
+    VideoSnapshot m_last_frame;
+    size_t m_unchanged = 0;
+    size_t m_in_a_row = 0;
+};
+
+
+//  Runs the states until a terminal one has acted. Returns its name. Fails through
+//  `trace` on an unexpected screen, a state seen too often, a stall or the timeout.
+template <typename ControllerContext>
+std::string run_screen_machine(
+    VideoStream& stream, ControllerContext& context, StepTrace& trace,
+    const std::vector<ScreenState>& states, Milliseconds timeout
+){
+    ScreenMachineChecks checks(trace);
+    const WallClock deadline = current_time() + timeout;
+    while (current_time() < deadline){
+        context.wait_for_all_requests();
+        VideoSnapshot frame;
+        const ScreenState& state = read_screen_state(stream, context, trace, states, frame);
+        trace.screen(state.name);
+        checks.check(state, std::move(frame));
+        state.act();
+        if (state.terminal){
+            context.wait_for_all_requests();
+            return state.name;
+        }
+    }
+    trace.fail("Did not finish within " + std::to_string(timeout.count() / 1000) + "s.");
+}
+
+
+
+}
+#endif
diff --git a/SerialPrograms/Source/CommonTools/ScreenMachine/StepTrace.cpp b/SerialPrograms/Source/CommonTools/ScreenMachine/StepTrace.cpp
new file mode 100644
index 0000000000..246bac04a0
--- /dev/null
+++ b/SerialPrograms/Source/CommonTools/ScreenMachine/StepTrace.cpp
@@ -0,0 +1,74 @@
+/*  Step Trace
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ */
+
+#include <cstdio>
+#include "Common/Cpp/PrettyPrint.h"
+#include "Common/Cpp/Filesystem/Filesystem.h"
+#include "CommonFramework/GlobalAutoPaths.h"
+#include "CommonFramework/Exceptions/OperationFailedExceptionWithScreenshot.h"
+#include "CommonFramework/VideoPipeline/VideoFeed.h"
+#include "StepTrace.h"
+
+namespace PokemonAutomation{
+
+
+StepTrace::StepTrace(VideoStream& stream, std::string label)
+    : m_stream(stream)
+    , m_label(std::move(label))
+    , m_folder(SCREENSHOTS_PATH() + "StepTrace/" + now_to_filestring() + "-" + m_label + "/")
+    , m_start(current_time())
+{
+    Filesystem::create_directories(Filesystem::Path(m_folder));
+    m_stream.log("[" + m_label + "] Trace screenshots: " + m_folder);
+}
+
+void StepTrace::screen(const std::string& name){
+    if (name == m_last){
+        return;
+    }
+    m_last = name;
+    m_recent.push_back(name);
+    if (m_recent.size() > 12){
+        m_recent.pop_front();
+    }
+    m_count++;
+    const double seconds = std::chrono::duration<double>(current_time() - m_start).count();
+    char prefix[16];
+    std::snprintf(prefix, sizeof(prefix), "%03zu-", m_count);
+    std::string path = m_folder + prefix + name + ".png";
+    VideoSnapshot screen = m_stream.video().snapshot();
+    if (screen){
+        screen.frame->save(path);
+    }else{
+        path = "(no video frame)";
+    }
+    m_stream.log("[" + m_label + "] screen " + std::to_string(m_count) + ": " + name +
+        " at " + tostr_fixed(seconds, 1) + "s, " + path);
+}
+
+void StepTrace::action(const std::string& what){
+    m_stream.log("[" + m_label + "] " + what);
+}
+
+std::string StepTrace::recent_screens() const{
+    std::string text;
+    for (const std::string& name : m_recent){
+        text += (text.empty() ? "" : " -> ") + name;
+    }
+    return text.empty() ? "(none)" : text;
+}
+
+void StepTrace::fail(const std::string& message) const{
+    OperationFailedExceptionWithScreenshot::fire(
+        ErrorReportMode::SEND_ERROR_REPORT,
+        m_label + ": " + message + " Recent screens: " + recent_screens() + ". Trace: " + m_folder,
+        m_stream
+    );
+}
+
+
+
+}
diff --git a/SerialPrograms/Source/CommonTools/ScreenMachine/StepTrace.h b/SerialPrograms/Source/CommonTools/ScreenMachine/StepTrace.h
new file mode 100644
index 0000000000..e0c4db09d0
--- /dev/null
+++ b/SerialPrograms/Source/CommonTools/ScreenMachine/StepTrace.h
@@ -0,0 +1,53 @@
+/*  Step Trace
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ *  A step log for closed-loop routines: every change of recognized screen is
+ *  logged and saved as a numbered screenshot, every input is logged, and a
+ *  failure reports the screens that led up to it.
+ *
+ */
+
+#ifndef PokemonAutomation_CommonTools_StepTrace_H
+#define PokemonAutomation_CommonTools_StepTrace_H
+
+#include <deque>
+#include <string>
+#include "Common/Cpp/Time.h"
+#include "CommonFramework/Tools/VideoStream.h"
+
+namespace PokemonAutomation{
+
+
+class StepTrace{
+public:
+    //  Screenshots go to <Screenshots>/StepTrace/<time>-<label>/.
+    StepTrace(VideoStream& stream, std::string label);
+
+    //  Records the screen the routine recognized. Logs and saves a screenshot only
+    //  when it differs from the previous one.
+    void screen(const std::string& name);
+
+    //  Records an input or decision.
+    void action(const std::string& what);
+
+    //  The last few screens, oldest first, e.g. "dialog -> keyboard -> dialog".
+    std::string recent_screens() const;
+
+    //  Throws OperationFailedExceptionWithScreenshot with the recent screens appended.
+    [[noreturn]] void fail(const std::string& message) const;
+
+private:
+    VideoStream& m_stream;
+    std::string m_label;
+    std::string m_folder;
+    WallClock m_start;
+    size_t m_count = 0;
+    std::string m_last;
+    std::deque<std::string> m_recent;
+};
+
+
+
+}
+#endif
diff --git a/SerialPrograms/cmake/SourceFiles.cmake b/SerialPrograms/cmake/SourceFiles.cmake
index e632bd254c..b44bc3a0b0 100644
--- a/SerialPrograms/cmake/SourceFiles.cmake
+++ b/SerialPrograms/cmake/SourceFiles.cmake
@@ -874,6 +874,10 @@ file(GLOB LIBRARY_SOURCES
     Source/CommonTools/Options/TrainOCRModeOption.h
     Source/CommonTools/Resources/SpriteDatabase.cpp
     Source/CommonTools/Resources/SpriteDatabase.h
+    Source/CommonTools/ScreenMachine/ScreenMachine.cpp
+    Source/CommonTools/ScreenMachine/ScreenMachine.h
+    Source/CommonTools/ScreenMachine/StepTrace.cpp
+    Source/CommonTools/ScreenMachine/StepTrace.h
     Source/CommonTools/StartupChecks/StartProgramChecks.cpp
     Source/CommonTools/StartupChecks/StartProgramChecks.h
     Source/CommonTools/StartupChecks/VideoResolutionCheck.cpp

From c5b44beb6d8a62775d11a4141e9fb77de0a3131b Mon Sep 17 00:00:00 2001
From: dayfine <difancpa@gmail.com>
Date: Thu, 29 Oct 2026 21:56:49 -0700
Subject: [PATCH 04/10] Common: add MoveOnlyFunction, a move-only callable
 wrapper

std::function is copyable: copying it forks a stateful lambda's state,
and it cannot hold move-only captures. MoveOnlyFunction is an alias of
std::move_only_function where the standard library has it, and a
minimal R(Args...) fallback for Apple's libc++, which lacks it.

Tests: move-only capture, moving keeps one state, empty and nullptr
comparison, reassignment; copy is rejected at compile time.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AKYzhrMnPK61XHWEch4a6E
---
 Common/Cpp/MoveOnlyFunction.h                 | 118 +++++++++++
 Common/Cpp/MoveOnlyFunction_Tests.cpp         | 191 ++++++++++++++++++
 Common/Cpp/MoveOnlyFunction_Tests.h           |  21 ++
 .../ComputerPrograms_UnitTestRunner.cpp       |   2 +
 SerialPrograms/cmake/SourceFiles.cmake        |   3 +
 5 files changed, 335 insertions(+)
 create mode 100644 Common/Cpp/MoveOnlyFunction.h
 create mode 100644 Common/Cpp/MoveOnlyFunction_Tests.cpp
 create mode 100644 Common/Cpp/MoveOnlyFunction_Tests.h

diff --git a/Common/Cpp/MoveOnlyFunction.h b/Common/Cpp/MoveOnlyFunction.h
new file mode 100644
index 0000000000..9cc71f3422
--- /dev/null
+++ b/Common/Cpp/MoveOnlyFunction.h
@@ -0,0 +1,118 @@
+/*  Move-Only Function
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ *  A callable wrapper that can be moved but not copied.
+ *
+ *  Prefer this over std::function for a callback that has one owner.
+ *  Copying a std::function copies its callable, so a stateful lambda
+ *  silently splits into two independent states. And std::function cannot
+ *  hold a lambda that captures a move-only object (e.g. std::unique_ptr).
+ *
+ *  This is std::move_only_function (C++23) where the standard library has
+ *  it. Apple's libc++ (Xcode 26 / Apple Clang 21) does not, so this header
+ *  has a minimal fallback for the plain "R(Args...)" signature. Delete the
+ *  fallback once every supported compiler defines
+ *  __cpp_lib_move_only_function.
+ *
+ */
+
+#ifndef PokemonAutomation_MoveOnlyFunction_H
+#define PokemonAutomation_MoveOnlyFunction_H
+
+#include <version>
+#include <functional>
+
+#ifndef __cpp_lib_move_only_function
+#include <cstddef>
+#include <memory>
+#include <type_traits>
+#include <utility>
+#endif
+
+namespace PokemonAutomation{
+
+
+
+#ifdef __cpp_lib_move_only_function
+
+template <typename Signature>
+using MoveOnlyFunction = std::move_only_function<Signature>;
+
+#else
+
+template <typename Signature>
+class MoveOnlyFunction;
+
+template <typename R, typename... Args>
+class MoveOnlyFunction<R(Args...)>{
+public:
+    MoveOnlyFunction() noexcept = default;
+    MoveOnlyFunction(std::nullptr_t) noexcept {}
+
+    template <typename Function>
+        requires (
+            !std::is_same_v<std::remove_cvref_t<Function>, MoveOnlyFunction> &&
+            std::is_invocable_r_v<R, std::decay_t<Function>&, Args...>
+        )
+    MoveOnlyFunction(Function&& function){
+        using Stored = std::decay_t<Function>;
+        //  Like std::move_only_function, a null function pointer makes an
+        //  empty wrapper.
+        if constexpr (std::is_pointer_v<Stored> || std::is_member_pointer_v<Stored>){
+            if (function == nullptr){
+                return;
+            }
+        }
+        m_callable = std::make_unique<Holder<Stored>>(std::forward<Function>(function));
+    }
+
+    MoveOnlyFunction(MoveOnlyFunction&&) noexcept = default;
+    MoveOnlyFunction& operator=(MoveOnlyFunction&&) noexcept = default;
+    MoveOnlyFunction(const MoveOnlyFunction&) = delete;
+    MoveOnlyFunction& operator=(const MoveOnlyFunction&) = delete;
+
+    explicit operator bool() const noexcept{
+        return m_callable != nullptr;
+    }
+    friend bool operator==(const MoveOnlyFunction& function, std::nullptr_t) noexcept{
+        return !function;
+    }
+
+    //  Calling an empty wrapper is undefined, as for std::move_only_function.
+    R operator()(Args... args){
+        return m_callable->call(std::forward<Args>(args)...);
+    }
+
+
+private:
+    class Callable{
+    public:
+        virtual ~Callable() = default;
+        virtual R call(Args&&... args) = 0;
+    };
+
+    template <typename Stored>
+    class Holder final : public Callable{
+    public:
+        template <typename Source>
+        explicit Holder(Source&& source)
+            : m_stored(std::forward<Source>(source))
+        {}
+        virtual R call(Args&&... args) override{
+            return std::invoke_r<R>(m_stored, std::forward<Args>(args)...);
+        }
+
+    private:
+        Stored m_stored;
+    };
+
+    std::unique_ptr<Callable> m_callable;
+};
+
+#endif
+
+
+
+}
+#endif
diff --git a/Common/Cpp/MoveOnlyFunction_Tests.cpp b/Common/Cpp/MoveOnlyFunction_Tests.cpp
new file mode 100644
index 0000000000..c133e8b8ec
--- /dev/null
+++ b/Common/Cpp/MoveOnlyFunction_Tests.cpp
@@ -0,0 +1,191 @@
+/*  Move-Only Function Tests
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ */
+
+#include <memory>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include "TestRunners/UnitTestDatabase.h"
+#include "MoveOnlyFunction.h"
+#include "MoveOnlyFunction_Tests.h"
+
+namespace PokemonAutomation{
+namespace{
+
+
+
+//  Copying would fork a stateful callable, so it must not compile.
+static_assert(!std::is_copy_constructible_v<MoveOnlyFunction<void()>>);
+static_assert(!std::is_copy_assignable_v<MoveOnlyFunction<void()>>);
+static_assert(std::is_nothrow_move_constructible_v<MoveOnlyFunction<void()>>);
+static_assert(std::is_nothrow_move_assignable_v<MoveOnlyFunction<void()>>);
+
+
+
+std::string expected_int(const char* what, int expected, int actual){
+    return std::string(what) + ": expected " + std::to_string(expected) +
+        ", got " + std::to_string(actual);
+}
+
+
+
+class Test_MoveOnlyFunction_MoveOnlyCapture : public UnitTest{
+public:
+    Test_MoveOnlyFunction_MoveOnlyCapture()
+        : UnitTest("Common::MoveOnlyFunction - Move-only capture")
+    {}
+
+    virtual UnitTestResult run(Logger& logger, CancellableScope& scope) const override{
+        auto value = std::make_unique<int>(42);
+        MoveOnlyFunction<int(int)> function = [value = std::move(value)](int add){
+            return *value + add;
+        };
+        int actual = function(1);
+        if (actual != 43){
+            return UnitTestResult(expected_int("call with a unique_ptr capture", 43, actual));
+        }
+
+        MoveOnlyFunction<int(int)> moved = std::move(function);
+        actual = moved(2);
+        if (actual != 44){
+            return UnitTestResult(expected_int("call after a move", 44, actual));
+        }
+        return true;
+    }
+};
+
+
+
+class Test_MoveOnlyFunction_StateNotForked : public UnitTest{
+public:
+    Test_MoveOnlyFunction_StateNotForked()
+        : UnitTest("Common::MoveOnlyFunction - Moving keeps one state")
+    {}
+
+    virtual UnitTestResult run(Logger& logger, CancellableScope& scope) const override{
+        MoveOnlyFunction<int()> counter = [count = 0]() mutable{
+            return ++count;
+        };
+        int actual = counter();
+        if (actual != 1){
+            return UnitTestResult(expected_int("first call", 1, actual));
+        }
+
+        //  The moved-to wrapper continues the same count.
+        MoveOnlyFunction<int()> constructed = std::move(counter);
+        actual = constructed();
+        if (actual != 2){
+            return UnitTestResult(expected_int("call after a move construction", 2, actual));
+        }
+
+        MoveOnlyFunction<int()> assigned;
+        assigned = std::move(constructed);
+        actual = assigned();
+        if (actual != 3){
+            return UnitTestResult(expected_int("call after a move assignment", 3, actual));
+        }
+        return true;
+    }
+};
+
+
+
+int return_seven(){
+    return 7;
+}
+
+class Test_MoveOnlyFunction_Empty : public UnitTest{
+public:
+    Test_MoveOnlyFunction_Empty()
+        : UnitTest("Common::MoveOnlyFunction - Empty is false")
+    {}
+
+    virtual UnitTestResult run(Logger& logger, CancellableScope& scope) const override{
+        MoveOnlyFunction<int()> defaulted;
+        if (defaulted){
+            return UnitTestResult("default constructed: expected empty, got non-empty");
+        }
+        MoveOnlyFunction<int()> from_nullptr = nullptr;
+        if (from_nullptr){
+            return UnitTestResult("constructed from nullptr: expected empty, got non-empty");
+        }
+        int (*null_pointer)() = nullptr;
+        MoveOnlyFunction<int()> from_null_pointer = null_pointer;
+        if (from_null_pointer){
+            return UnitTestResult("constructed from a null function pointer: expected empty, got non-empty");
+        }
+
+        MoveOnlyFunction<int()> from_pointer = &return_seven;
+        if (!from_pointer){
+            return UnitTestResult("constructed from a function pointer: expected non-empty, got empty");
+        }
+        int actual = from_pointer();
+        if (actual != 7){
+            return UnitTestResult(expected_int("call through a function pointer", 7, actual));
+        }
+        return true;
+    }
+};
+
+
+
+class Test_MoveOnlyFunction_Reassignment : public UnitTest{
+public:
+    Test_MoveOnlyFunction_Reassignment()
+        : UnitTest("Common::MoveOnlyFunction - Reassignment")
+    {}
+
+    virtual UnitTestResult run(Logger& logger, CancellableScope& scope) const override{
+        //  The use count shows whether the wrapper still holds the first
+        //  callable.
+        auto token = std::make_shared<int>(1);
+        MoveOnlyFunction<int()> function = [token]{
+            return *token;
+        };
+        int actual = function();
+        if (actual != 1){
+            return UnitTestResult(expected_int("first callable", 1, actual));
+        }
+
+        function = []{
+            return 2;
+        };
+        actual = function();
+        if (actual != 2){
+            return UnitTestResult(expected_int("call after reassignment", 2, actual));
+        }
+        actual = (int)token.use_count();
+        if (actual != 1){
+            return UnitTestResult(expected_int("token owners after reassignment", 1, actual));
+        }
+
+        function = nullptr;
+        if (function){
+            return UnitTestResult("assigned nullptr: expected empty, got non-empty");
+        }
+        if (function != nullptr){
+            return UnitTestResult("assigned nullptr: expected == nullptr, got != nullptr");
+        }
+        return true;
+    }
+};
+
+
+
+} // anonymous namespace
+
+
+
+void add_tests_MoveOnlyFunction(UnitTestDatabase& database){
+    database.add<Test_MoveOnlyFunction_MoveOnlyCapture>();
+    database.add<Test_MoveOnlyFunction_StateNotForked>();
+    database.add<Test_MoveOnlyFunction_Empty>();
+    database.add<Test_MoveOnlyFunction_Reassignment>();
+}
+
+
+
+}
diff --git a/Common/Cpp/MoveOnlyFunction_Tests.h b/Common/Cpp/MoveOnlyFunction_Tests.h
new file mode 100644
index 0000000000..c43f518bdc
--- /dev/null
+++ b/Common/Cpp/MoveOnlyFunction_Tests.h
@@ -0,0 +1,21 @@
+/*  Move-Only Function Tests
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ */
+
+#ifndef PokemonAutomation_MoveOnlyFunction_Tests_H
+#define PokemonAutomation_MoveOnlyFunction_Tests_H
+
+#include "Common/Cpp/TestRunners/UnitTestDatabase.h"
+
+namespace PokemonAutomation{
+
+
+
+void add_tests_MoveOnlyFunction(UnitTestDatabase& database);
+
+
+
+}
+#endif
diff --git a/SerialPrograms/Source/ComputerPrograms/ComputerPrograms_UnitTestRunner.cpp b/SerialPrograms/Source/ComputerPrograms/ComputerPrograms_UnitTestRunner.cpp
index 1c19573466..d434036d6e 100644
--- a/SerialPrograms/Source/ComputerPrograms/ComputerPrograms_UnitTestRunner.cpp
+++ b/SerialPrograms/Source/ComputerPrograms/ComputerPrograms_UnitTestRunner.cpp
@@ -5,6 +5,7 @@
  */
 
 #include "Common/Cpp/ListenerSet.h"
+#include "Common/Cpp/MoveOnlyFunction_Tests.h"
 #include "Common/Cpp/ScopeExit.h"
 #include "Common/Cpp/PrettyPrint.h"
 #include "Common/Cpp/TestRunners/TestImageDistortionManager.h"
@@ -51,6 +52,7 @@ UnitTestDatabase make_UNIT_TESTS_ALL(){
     add_tests_QtEventThreadPool(ret, GlobalThreadPools::computation_normal());
     add_tests_BlackBorderDetector(ret);
     add_tests_ListenerSet(ret);
+    add_tests_MoveOnlyFunction(ret);
     add_tests_AudioInfo(ret);
     add_tests_ChannelMixerMatrix(ret);
     add_tests_FFTStreamer(ret);
diff --git a/SerialPrograms/cmake/SourceFiles.cmake b/SerialPrograms/cmake/SourceFiles.cmake
index 9e4e0895bb..f640a174ce 100644
--- a/SerialPrograms/cmake/SourceFiles.cmake
+++ b/SerialPrograms/cmake/SourceFiles.cmake
@@ -118,6 +118,9 @@ file(GLOB CORE_LIBRARY_SOURCES
     ../Common/Cpp/Logging/MultiOutputLogger.h
     ../Common/Cpp/Logging/TaggedLogger.cpp
     ../Common/Cpp/Logging/TaggedLogger.h
+    ../Common/Cpp/MoveOnlyFunction.h
+    ../Common/Cpp/MoveOnlyFunction_Tests.cpp
+    ../Common/Cpp/MoveOnlyFunction_Tests.h
     ../Common/Cpp/Options/BatchOption.cpp
     ../Common/Cpp/Options/BatchOption.h
     ../Common/Cpp/Options/BooleanCheckBoxOption.cpp

From 5b405e42ba3425b96a9fc066a7c70922dab4a3c4 Mon Sep 17 00:00:00 2001
From: dayfine <difancpa@gmail.com>
Date: Thu, 29 Oct 2026 22:04:30 -0700
Subject: [PATCH 05/10] Pokemon navigation: take the leg mover as a callable

LegMover had one method, so it is now a MoveOnlyFunction that holds a
direction for a duration. walk_leg() takes it by reference, since calling
a MoveOnlyFunction is non-const.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AKYzhrMnPK61XHWEch4a6E
---
 .../Source/Pokemon/Navigation/Pokemon_LegWalker.h | 15 ++++++---------
 1 file changed, 6 insertions(+), 9 deletions(-)

diff --git a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegWalker.h b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegWalker.h
index 2d471b3eb9..e8a9556e43 100644
--- a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegWalker.h
+++ b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegWalker.h
@@ -26,6 +26,7 @@
 #include <optional>
 #include <string>
 #include <vector>
+#include "Common/Cpp/MoveOnlyFunction.h"
 #include "Common/Cpp/Time.h"
 #include "CommonFramework/Exceptions/OperationFailedExceptionWithScreenshot.h"
 #include "CommonTools/Async/InferenceRoutines.h"
@@ -61,14 +62,10 @@ template <typename Console, typename Context>
 using LegInterrupts = std::vector<std::unique_ptr<LegInterrupt<Console, Context>>>;
 
 
-//  How the game moves the player.
+//  How the game moves the player: holds `direction` for `duration`, then
+//  lets go.
 template <typename Context>
-class LegMover{
-public:
-    virtual ~LegMover() = default;
-    //  Holds `direction` for `duration`, then lets go.
-    virtual void hold(Context& context, Direction direction, Milliseconds duration) const = 0;
-};
+using LegMover = MoveOnlyFunction<void(Context& context, Direction direction, Milliseconds duration)>;
 
 
 //  A straight leg, for a player standing still and facing its way.
@@ -130,7 +127,7 @@ LegResult walk_leg_with(const LegSpec& leg, const LegCalls& calls, size_t max_in
 template <typename Console, typename Context>
 LegResult walk_leg(
     Console& console, Context& context,
-    const LegMover<Context>& mover,
+    LegMover<Context>& mover,
     const LegInterrupts<Console, Context>& interrupts,
     const LegSpec& leg,
     size_t max_interruptions = 5
@@ -148,7 +145,7 @@ LegResult walk_leg(
             console, context,
             [&](Context& context){
                 start = current_time();
-                mover.hold(context, leg.direction, hold);
+                mover(context, leg.direction, hold);
             },
             callbacks
         );

From ef1202fd691d193dcddd82ab66fe8a7a54181937 Mon Sep 17 00:00:00 2001
From: dayfine <difancpa@gmail.com>
Date: Thu, 29 Oct 2026 22:04:30 -0700
Subject: [PATCH 06/10] Pokemon navigation: split plan_legs() into search steps

The search's maps and queue become a Search struct, and relaxing a node,
expanding a node, the goal search, tracing the moves back and the final
turn each get a function. The search visits nodes in the same order, so
the plans are unchanged.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AKYzhrMnPK61XHWEch4a6E
---
 .../Pokemon/Navigation/Pokemon_LegPlanner.h   | 212 +++++++++++-------
 1 file changed, 133 insertions(+), 79 deletions(-)

diff --git a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegPlanner.h b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegPlanner.h
index 5fbde90341..c9d49735d9 100644
--- a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegPlanner.h
+++ b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegPlanner.h
@@ -176,104 +176,158 @@ std::vector<Leg<State>> join_legs(const Model& model, const State& start, const
     return legs;
 }
 
-}
+//  The search's working set. Nodes are kept in a list and queued by index,
+//  so State needs no ordering.
+template <typename Model>
+struct Search{
+    using State = typename Model::State;
+    using Hash = NodeHash<State, typename Model::StateHash>;
+    using Entry = std::pair<int, size_t>;
 
+    std::unordered_map<Node<State>, int, Hash> distance;
+    std::unordered_map<Node<State>, Move<State>, Hash> came_from;
+    std::vector<Node<State>> nodes;
+    std::priority_queue<Entry, std::vector<Entry>, std::greater<Entry>> queue;
+};
 
+template <typename Model, typename State>
+int distance_of(const Search<Model>& search, const Node<State>& node){
+    auto iter = search.distance.find(node);
+    return iter == search.distance.end() ? std::numeric_limits<int>::max() : iter->second;
+}
 
-template <typename Model>
-std::optional<std::vector<Leg<typename Model::State>>> plan_legs(
-    const Model& model,
-    const typename Model::State& start, std::optional<Direction> start_facing,
-    const std::function<bool(const typename Model::State&)>& at_goal,
-    std::optional<Direction> goal_facing,
-    const LegCosts& costs
+//  Records `cost` as the way to `node` if it is cheaper than any so far.
+template <typename Model, typename State>
+void relax(Search<Model>& search, const Node<State>& node, int cost, const Move<State>& move){
+    if (cost >= distance_of(search, node)){
+        return;
+    }
+    search.distance[node] = cost;
+    search.came_from.insert_or_assign(node, move);
+    search.nodes.push_back(node);
+    search.queue.emplace(cost, search.nodes.size() - 1);
+}
+
+//  Queues every press from `current`, reached at `cost`.
+template <typename Model, typename State>
+void expand(
+    const Model& model, Search<Model>& search,
+    const Node<State>& current, int cost, const LegCosts& costs
 ){
-    using State = typename Model::State;
-    using Node = LegPlannerInternal::Node<State>;
-    using Move = LegPlannerInternal::Move<State>;
-    using Hash = LegPlannerInternal::NodeHash<State, typename Model::StateHash>;
-    const int INF = std::numeric_limits<int>::max();
-
-    std::unordered_map<Node, int, Hash> distance;
-    std::unordered_map<Node, Move, Hash> came_from;
-    auto distance_of = [&](const Node& node){
-        auto iter = distance.find(node);
-        return iter == distance.end() ? INF : iter->second;
-    };
-    auto arrival_cost = [&](const Node& node){
-        int cost = LegPlannerInternal::stop_cost(model, node, costs);
-        if (goal_facing && node.facing != (int)*goal_facing){
-            cost += costs.per_turn;
+    for (Direction direction : ALL_DIRECTIONS){
+        std::optional<Step<State>> step = model.press(current.state, direction);
+        if (!step){
+            continue;
+        }
+        const bool continues = step->action == 0 && !step->ends_leg;
+        const Node<State> next{step->next, (int)step->facing, continues};
+        int step_cost = costs.per_tile + step->extra_cost;
+        if (current.facing != (int)direction){
+            step_cost += costs.per_turn + stop_cost(model, current, costs);
         }
-        return cost;
-    };
+        relax(search, next, cost + step_cost, Move<State>{current, direction, *step});
+    }
+}
 
-    const Node first{start, start_facing ? (int)*start_facing : 4, false};
-    distance[first] = 0;
+//  What it costs to end at `node`: stopping there, then turning to
+//  `goal_facing`.
+template <typename Model, typename State>
+int arrival_cost(
+    const Model& model, const Node<State>& node,
+    std::optional<Direction> goal_facing, const LegCosts& costs
+){
+    int cost = stop_cost(model, node, costs);
+    if (goal_facing && node.facing != (int)*goal_facing){
+        cost += costs.per_turn;
+    }
+    return cost;
+}
 
-    //  Nodes are kept in a list and queued by index, so State needs no ordering.
-    std::vector<Node> nodes{first};
-    using Entry = std::pair<int, size_t>;
-    std::priority_queue<Entry, std::vector<Entry>, std::greater<Entry>> queue;
-    queue.emplace(0, 0);
-
-    std::optional<Node> best_end;
-    int best_total = INF;
-    while (!queue.empty()){
-        const auto [cost, index] = queue.top();
-        queue.pop();
-        const Node current = nodes[index];
-        if (cost != distance_of(current)){
+//  Runs the search from `first` and returns the goal node cheapest to end
+//  at, or nothing if no goal can be reached.
+template <typename Model, typename State>
+std::optional<Node<State>> search_goal(
+    const Model& model, Search<Model>& search, const Node<State>& first,
+    const std::function<bool(const State&)>& at_goal,
+    std::optional<Direction> goal_facing, const LegCosts& costs
+){
+    search.distance[first] = 0;
+    search.nodes.push_back(first);
+    search.queue.emplace(0, 0);
+
+    std::optional<Node<State>> best_end;
+    int best_total = std::numeric_limits<int>::max();
+    while (!search.queue.empty()){
+        const auto [cost, index] = search.queue.top();
+        search.queue.pop();
+        const Node<State> current = search.nodes[index];
+        if (cost != distance_of(search, current)){
             continue;
         }
         if (cost >= best_total){
             break;
         }
-        if (at_goal(current.state)){
-            const int total = cost + arrival_cost(current);
-            if (total < best_total){
-                best_total = total;
-                best_end = current;
-            }
+        if (!at_goal(current.state)){
+            expand(model, search, current, cost, costs);
             continue;
         }
-        for (Direction direction : ALL_DIRECTIONS){
-            std::optional<Step<State>> step = model.press(current.state, direction);
-            if (!step){
-                continue;
-            }
-            const bool continues = step->action == 0 && !step->ends_leg;
-            const Node next{step->next, (int)step->facing, continues};
-            int step_cost = costs.per_tile + step->extra_cost;
-            if (current.facing != (int)direction){
-                step_cost += costs.per_turn + LegPlannerInternal::stop_cost(model, current, costs);
-            }
-            if (cost + step_cost < distance_of(next)){
-                distance[next] = cost + step_cost;
-                came_from.insert_or_assign(next, Move{current, direction, *step});
-                nodes.push_back(next);
-                queue.emplace(cost + step_cost, nodes.size() - 1);
-            }
+        const int total = cost + arrival_cost(model, current, goal_facing, costs);
+        if (total < best_total){
+            best_total = total;
+            best_end = current;
         }
     }
-    if (!best_end){
-        return std::nullopt;
-    }
+    return best_end;
+}
 
-    std::vector<Move> moves;
-    for (Node node = *best_end; !(node == first); node = came_from.at(node).from){
-        moves.push_back(came_from.at(node));
+//  The moves from `first` to `end`, in order.
+template <typename Model, typename State>
+std::vector<Move<State>> trace_moves(const Search<Model>& search, const Node<State>& first, const Node<State>& end){
+    std::vector<Move<State>> moves;
+    for (Node<State> node = end; !(node == first); node = search.came_from.at(node).from){
+        moves.push_back(search.came_from.at(node));
     }
     std::reverse(moves.begin(), moves.end());
-    std::vector<Leg<State>> legs = LegPlannerInternal::join_legs(model, start, moves);
-    if (goal_facing && best_end->facing != (int)*goal_facing){
-        Leg<State> face;
-        face.kind = LegKind::FACE;
-        face.direction = *goal_facing;
-        face.facing_after = *goal_facing;
-        face.start = best_end->state;
-        face.end = best_end->state;
-        legs.push_back(face);
+    return moves;
+}
+
+template <typename State>
+Leg<State> face_leg(const State& state, Direction direction){
+    Leg<State> face;
+    face.kind = LegKind::FACE;
+    face.direction = direction;
+    face.facing_after = direction;
+    face.start = state;
+    face.end = state;
+    return face;
+}
+
+}
+
+
+
+template <typename Model>
+std::optional<std::vector<Leg<typename Model::State>>> plan_legs(
+    const Model& model,
+    const typename Model::State& start, std::optional<Direction> start_facing,
+    const std::function<bool(const typename Model::State&)>& at_goal,
+    std::optional<Direction> goal_facing,
+    const LegCosts& costs
+){
+    using State = typename Model::State;
+    using Node = LegPlannerInternal::Node<State>;
+
+    const Node first{start, start_facing ? (int)*start_facing : 4, false};
+    LegPlannerInternal::Search<Model> search;
+    const std::optional<Node> end = LegPlannerInternal::search_goal(model, search, first, at_goal, goal_facing, costs);
+    if (!end){
+        return std::nullopt;
+    }
+    std::vector<Leg<State>> legs = LegPlannerInternal::join_legs(
+        model, start, LegPlannerInternal::trace_moves(search, first, *end)
+    );
+    if (goal_facing && end->facing != (int)*goal_facing){
+        legs.push_back(LegPlannerInternal::face_leg(end->state, *goal_facing));
     }
     return legs;
 }

From 38bb6aeddb7c2511735de09caf893978529477d6 Mon Sep 17 00:00:00 2001
From: dayfine <difancpa@gmail.com>
Date: Thu, 29 Oct 2026 22:07:21 -0700
Subject: [PATCH 07/10] Common: drop the noexcept move-assignment check from
 MoveOnlyFunction tests

The standard does not make std::move_only_function's move assignment
noexcept, and MSVC's STL does not.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AKYzhrMnPK61XHWEch4a6E
---
 Common/Cpp/MoveOnlyFunction_Tests.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/Common/Cpp/MoveOnlyFunction_Tests.cpp b/Common/Cpp/MoveOnlyFunction_Tests.cpp
index c133e8b8ec..72ed5998ae 100644
--- a/Common/Cpp/MoveOnlyFunction_Tests.cpp
+++ b/Common/Cpp/MoveOnlyFunction_Tests.cpp
@@ -21,7 +21,6 @@ namespace{
 static_assert(!std::is_copy_constructible_v<MoveOnlyFunction<void()>>);
 static_assert(!std::is_copy_assignable_v<MoveOnlyFunction<void()>>);
 static_assert(std::is_nothrow_move_constructible_v<MoveOnlyFunction<void()>>);
-static_assert(std::is_nothrow_move_assignable_v<MoveOnlyFunction<void()>>);
 
 
 

From 1c2cf1e7e8aaaf32b444e82df270b64279030db7 Mon Sep 17 00:00:00 2001
From: dayfine <difancpa@gmail.com>
Date: Sat, 31 Oct 2026 11:23:25 -0700
Subject: [PATCH 08/10] Pokemon navigation: add TileGrid and MapSet to the
 shared core

Move-only: Pokemon_TileGrid.{h,cpp} and Pokemon_MapSet.{h,cpp} are copied
unchanged from bdsp/floaroma-mvp, where the BDSP AutoStory MVP added them,
so the grid and map set sit with the planner and walker they build on.
Their tests stay with the BDSP map data they check.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AKYzhrMnPK61XHWEch4a6E
---
 .../Pokemon/Navigation/Pokemon_MapSet.cpp     | 102 ++++
 .../Pokemon/Navigation/Pokemon_MapSet.h       |  63 +++
 .../Pokemon/Navigation/Pokemon_TileGrid.cpp   | 499 ++++++++++++++++++
 .../Pokemon/Navigation/Pokemon_TileGrid.h     | 177 +++++++
 SerialPrograms/cmake/SourceFiles.cmake        |   4 +
 5 files changed, 845 insertions(+)
 create mode 100644 SerialPrograms/Source/Pokemon/Navigation/Pokemon_MapSet.cpp
 create mode 100644 SerialPrograms/Source/Pokemon/Navigation/Pokemon_MapSet.h
 create mode 100644 SerialPrograms/Source/Pokemon/Navigation/Pokemon_TileGrid.cpp
 create mode 100644 SerialPrograms/Source/Pokemon/Navigation/Pokemon_TileGrid.h

diff --git a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_MapSet.cpp b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_MapSet.cpp
new file mode 100644
index 0000000000..533dc4f12f
--- /dev/null
+++ b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_MapSet.cpp
@@ -0,0 +1,102 @@
+/*  Map Set
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ */
+
+#include <algorithm>
+#include "Common/Cpp/Exceptions.h"
+#include "Pokemon_MapSet.h"
+
+namespace PokemonAutomation{
+namespace Pokemon{
+
+
+void MapSet::add(std::string name, const TileGrid& grid, const TilePos& offset){
+    for (const Placed& placed : m_maps){
+        if (placed.name == name){
+            throw InternalProgramError(nullptr, PA_CURRENT_FUNCTION, "Map placed twice: " + name);
+        }
+        //  Map images show a border of trees past their edges, so two maps
+        //  may share blocked tiles, but nothing else.
+        for (int y = 0; y < grid.height(); y++){
+            for (int x = 0; x < grid.width(); x++){
+                const TilePos other{offset.x + x - placed.offset.x, offset.y + y - placed.offset.y};
+                if (!placed.grid.in_bounds(other)){
+                    continue;
+                }
+                if (grid.at({x, y}) != TileType::BLOCKED || placed.grid.at(other) != TileType::BLOCKED){
+                    throw InternalProgramError(
+                        nullptr, PA_CURRENT_FUNCTION,
+                        "Map " + name + " overlaps " + placed.name + " at its tile " + to_string(TilePos{x, y}) + "."
+                    );
+                }
+            }
+        }
+    }
+    m_maps.push_back(Placed{std::move(name), grid, offset});
+
+    //  Rebuild the joined grid.
+    TilePos low = m_maps[0].offset;
+    TilePos high = low;
+    for (const Placed& placed : m_maps){
+        low.x = std::min(low.x, placed.offset.x);
+        low.y = std::min(low.y, placed.offset.y);
+        high.x = std::max(high.x, placed.offset.x + placed.grid.width());
+        high.y = std::max(high.y, placed.offset.y + placed.grid.height());
+    }
+    m_origin = low;
+    std::vector<std::string> rows(high.y - low.y, std::string(high.x - low.x, tile_char(TileType::UNKNOWN)));
+    for (const Placed& placed : m_maps){
+        const std::vector<std::string> map_rows = placed.grid.rows();
+        for (size_t y = 0; y < map_rows.size(); y++){
+            rows[placed.offset.y - low.y + y].replace(placed.offset.x - low.x, map_rows[y].size(), map_rows[y]);
+        }
+    }
+    m_world.emplace(rows);
+}
+
+const TileGrid& MapSet::world() const{
+    if (!m_world){
+        throw InternalProgramError(nullptr, PA_CURRENT_FUNCTION, "No maps placed.");
+    }
+    return *m_world;
+}
+
+TilePos MapSet::to_world(const std::string& map, const TilePos& local) const{
+    for (const Placed& placed : m_maps){
+        if (placed.name == map){
+            return {
+                placed.offset.x - m_origin.x + local.x,
+                placed.offset.y - m_origin.y + local.y,
+            };
+        }
+    }
+    throw InternalProgramError(nullptr, PA_CURRENT_FUNCTION, "Unknown map: " + map);
+}
+
+std::optional<MapTile> MapSet::to_local(const TilePos& world) const{
+    for (const Placed& placed : m_maps){
+        const TilePos local{
+            world.x + m_origin.x - placed.offset.x,
+            world.y + m_origin.y - placed.offset.y,
+        };
+        if (placed.grid.in_bounds(local)){
+            return MapTile{placed.name, local};
+        }
+    }
+    return std::nullopt;
+}
+
+std::string MapSet::describe(const TilePos& world) const{
+    const std::optional<MapTile> local = to_local(world);
+    if (!local){
+        return "world " + to_string(world);
+    }
+    return local->map + " " + to_string(local->pos);
+}
+
+
+
+}
+}
diff --git a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_MapSet.h b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_MapSet.h
new file mode 100644
index 0000000000..468213c481
--- /dev/null
+++ b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_MapSet.h
@@ -0,0 +1,63 @@
+/*  Map Set
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ *  Several tile grids placed side by side on one world grid, so one plan
+ *  can cross from a route into a town.
+ */
+
+#ifndef PokemonAutomation_Pokemon_MapSet_H
+#define PokemonAutomation_Pokemon_MapSet_H
+
+#include <optional>
+#include <string>
+#include <vector>
+#include "Pokemon_TileGrid.h"
+
+namespace PokemonAutomation{
+namespace Pokemon{
+
+
+struct MapTile{
+    std::string map;
+    TilePos pos;
+};
+
+
+class MapSet{
+public:
+    //  Places `grid` with its tile (0,0) at `offset`. Offsets are relative to
+    //  each other and may be negative. Maps may overlap only where both are
+    //  blocked; the map placed first holds those tiles. Throws
+    //  InternalProgramError if the name is taken or the maps conflict.
+    void add(std::string name, const TileGrid& grid, const TilePos& offset);
+
+    //  The maps joined on one grid. Tiles no map covers are UNKNOWN. World
+    //  tile (0,0) is the top-left corner of all the maps together.
+    const TileGrid& world() const;
+
+    //  Throws InternalProgramError for an unknown map name.
+    TilePos to_world(const std::string& map, const TilePos& local) const;
+
+    //  The map that holds a world tile, or nothing between maps.
+    std::optional<MapTile> to_local(const TilePos& world) const;
+
+    //  "Route 201 (45,3)", or the world tile if no map holds it.
+    std::string describe(const TilePos& world) const;
+
+private:
+    struct Placed{
+        std::string name;
+        TileGrid grid;
+        TilePos offset;
+    };
+    std::vector<Placed> m_maps;
+    TilePos m_origin;   //  offset of world tile (0,0)
+    std::optional<TileGrid> m_world;
+};
+
+
+
+}
+}
+#endif
diff --git a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_TileGrid.cpp b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_TileGrid.cpp
new file mode 100644
index 0000000000..c596747789
--- /dev/null
+++ b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_TileGrid.cpp
@@ -0,0 +1,499 @@
+/*  Tile Grid
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ */
+
+#include <algorithm>
+#include <cstdlib>
+#include <functional>
+#include <limits>
+#include <map>
+#include <queue>
+#include <tuple>
+#include "Common/Cpp/Exceptions.h"
+#include "Pokemon_LegPlanner.h"
+#include "Pokemon_TileGrid.h"
+
+namespace PokemonAutomation{
+namespace Pokemon{
+
+
+char tile_char(TileType type){
+    switch (type){
+    case TileType::BLOCKED:     return '#';
+    case TileType::WALKABLE:    return '.';
+    case TileType::TALL_GRASS:  return '"';
+    case TileType::LEDGE:       return 'v';
+    case TileType::NPC:         return 'N';
+    case TileType::SIGN:        return 'S';
+    case TileType::DOOR:        return 'D';
+    case TileType::UNKNOWN:     return '?';
+    }
+    return '?';
+}
+
+
+
+
+TileGrid::TileGrid(const std::vector<std::string>& rows)
+    : m_width(rows.empty() ? 0 : (int)rows[0].size())
+    , m_height((int)rows.size())
+{
+    m_tiles.reserve((size_t)m_width * m_height);
+    for (size_t y = 0; y < rows.size(); y++){
+        const std::string& row = rows[y];
+        if ((int)row.size() != m_width){
+            throw InternalProgramError(
+                nullptr, PA_CURRENT_FUNCTION,
+                "Tile grid row " + std::to_string(y) + " has " + std::to_string(row.size()) +
+                " tiles, expected " + std::to_string(m_width) + "."
+            );
+        }
+        for (size_t x = 0; x < row.size(); x++){
+            switch (row[x]){
+            case '#':   m_tiles.push_back(TileType::BLOCKED);       break;
+            case '.':   m_tiles.push_back(TileType::WALKABLE);      break;
+            case '"':   m_tiles.push_back(TileType::TALL_GRASS);    break;
+            case 'v':   m_tiles.push_back(TileType::LEDGE);         break;
+            case 'N':   m_tiles.push_back(TileType::NPC);           break;
+            case 'S':   m_tiles.push_back(TileType::SIGN);          break;
+            case 'D':   m_tiles.push_back(TileType::DOOR);          break;
+            case '?':   m_tiles.push_back(TileType::UNKNOWN);       break;
+            default:
+                throw InternalProgramError(
+                    nullptr, PA_CURRENT_FUNCTION,
+                    std::string("Unknown tile '") + row[x] + "' at " +
+                    to_string(TilePos{(int)x, (int)y}) + "."
+                );
+            }
+        }
+    }
+}
+
+std::vector<std::string> TileGrid::rows() const{
+    std::vector<std::string> rows;
+    for (int y = 0; y < m_height; y++){
+        std::string row;
+        for (int x = 0; x < m_width; x++){
+            row += tile_char(at({x, y}));
+        }
+        rows.push_back(std::move(row));
+    }
+    return rows;
+}
+
+bool TileGrid::in_bounds(const TilePos& pos) const{
+    return 0 <= pos.x && pos.x < m_width && 0 <= pos.y && pos.y < m_height;
+}
+
+TileType TileGrid::at(const TilePos& pos) const{
+    if (!in_bounds(pos)){
+        return TileType::UNKNOWN;
+    }
+    return m_tiles[(size_t)pos.y * m_width + pos.x];
+}
+
+void TileGrid::set(const TilePos& pos, TileType type){
+    if (in_bounds(pos)){
+        m_tiles[(size_t)pos.y * m_width + pos.x] = type;
+    }
+}
+
+bool TileGrid::standable(const TilePos& pos) const{
+    const TileType type = at(pos);
+    return type == TileType::WALKABLE || type == TileType::TALL_GRASS;
+}
+
+std::optional<TilePos> TileGrid::step(const TilePos& from, Direction direction) const{
+    const TilePos next = from.next(direction);
+    if (standable(next)){
+        return next;
+    }
+    if (at(next) == TileType::LEDGE && direction == Direction::SOUTH){
+        const TilePos landing = next.next(direction);
+        if (standable(landing)){
+            return landing;
+        }
+    }
+    return std::nullopt;
+}
+
+bool TileGrid::at_wall(const TilePos& pos, Direction direction) const{
+    const TileType next = at(pos.next(direction));
+    return next != TileType::DOOR && next != TileType::UNKNOWN && !step(pos, direction).has_value();
+}
+
+
+
+WallHit walk_to_wall(const TileGrid& grid, const TilePos& from, Direction direction){
+    WallHit hit;
+    hit.stop = from;
+    while (true){
+        const TilePos before = hit.stop;
+        const std::optional<TilePos> next = grid.step(before, direction);
+        if (!next){
+            hit.wall = before.next(direction);
+            hit.anchored = grid.at_wall(before, direction);
+            return hit;
+        }
+        hit.tiles += std::abs(next->x - before.x) + std::abs(next->y - before.y);
+        hit.stop = *next;
+    }
+}
+
+
+
+std::string to_string(const TileLeg& leg){
+    return std::string(direction_name(leg.direction)) + " " + std::to_string(leg.tiles) +
+        (leg.ends_at_wall ? " (to wall)" : " (open)");
+}
+
+
+namespace{
+
+//  The grid's step rules for the shared leg planner. A ledge hop is one
+//  press that moves two tiles.
+class TileGridModel{
+public:
+    using State = TilePos;
+    using StateHash = std::hash<TilePos>;
+
+    TileGridModel(const TileGrid& grid, const TilePlanCosts& costs)
+        : m_grid(grid)
+        , m_costs(costs)
+    {}
+
+    std::optional<Step<State>> press(const State& pos, Direction direction) const{
+        const std::optional<TilePos> next = m_grid.step(pos, direction);
+        if (!next){
+            return std::nullopt;
+        }
+        Step<State> step;
+        step.next = *next;
+        step.facing = direction;
+        const int tiles = std::abs(next->x - pos.x) + std::abs(next->y - pos.y);
+        step.extra_cost = m_costs.per_tile * (tiles - 1);
+        if (m_grid.at(*next) == TileType::TALL_GRASS){
+            step.extra_cost += m_costs.per_grass_tile;
+        }
+        return step;
+    }
+    bool held_at(const State& pos, Direction direction) const{
+        return m_grid.at_wall(pos, direction);
+    }
+
+private:
+    const TileGrid& m_grid;
+    const TilePlanCosts& m_costs;
+};
+
+}
+
+std::optional<std::vector<TileLeg>> plan_tile_route(
+    const TileGrid& grid,
+    const TilePos& from, const TilePos& to,
+    const TilePlanCosts& costs
+){
+    if (!grid.standable(from) || !grid.standable(to)){
+        throw InternalProgramError(
+            nullptr, PA_CURRENT_FUNCTION,
+            "Route ends must be standable: " + to_string(from) + " -> " + to_string(to) + "."
+        );
+    }
+    if (from == to){
+        return std::vector<TileLeg>();
+    }
+    LegCosts leg_costs;
+    leg_costs.per_tile = costs.per_tile;
+    leg_costs.per_turn = costs.per_leg;
+    leg_costs.per_open_stop = costs.leg_not_at_wall;
+    const std::optional<std::vector<Leg<TilePos>>> legs = plan_legs(
+        TileGridModel(grid, costs), from, std::nullopt,
+        std::function<bool(const TilePos&)>([&](const TilePos& pos){ return pos == to; }),
+        std::nullopt, leg_costs
+    );
+    if (!legs){
+        return std::nullopt;
+    }
+    std::vector<TileLeg> ret;
+    for (const Leg<TilePos>& leg : *legs){
+        const size_t tiles = std::abs(leg.end.x - leg.start.x) + std::abs(leg.end.y - leg.start.y);
+        ret.push_back(TileLeg{leg.direction, tiles, leg.to_wall});
+    }
+    return ret;
+}
+
+std::vector<TilePos> sight_tiles(const TileGrid& grid, const TrainerSight& trainer){
+    std::vector<TilePos> tiles;
+    TilePos pos = trainer.pos;
+    for (int i = 0; i < trainer.range; i++){
+        pos = pos.next(trainer.facing);
+        if (!grid.standable(pos)){
+            break;
+        }
+        tiles.push_back(pos);
+    }
+    return tiles;
+}
+
+std::vector<std::vector<std::string>> legs_crossing_sight(
+    const TileGrid& grid,
+    const TilePos& from,
+    const std::vector<TileLeg>& legs,
+    const std::vector<TrainerSight>& trainers
+){
+    std::vector<std::vector<TilePos>> sights;
+    for (const TrainerSight& trainer : trainers){
+        sights.push_back(sight_tiles(grid, trainer));
+    }
+    std::vector<std::vector<std::string>> crossings;
+    TilePos pos = from;
+    for (const TileLeg& leg : legs){
+        const std::vector<TilePos> tiles = trace_legs(grid, pos, {leg});
+        std::vector<std::string> seen_by;
+        for (size_t t = 0; t < trainers.size(); t++){
+            for (size_t i = 1; i < tiles.size(); i++){
+                if (std::find(sights[t].begin(), sights[t].end(), tiles[i]) != sights[t].end()){
+                    seen_by.push_back(trainers[t].name);
+                    break;
+                }
+            }
+        }
+        crossings.push_back(std::move(seen_by));
+        pos = tiles.back();
+    }
+    return crossings;
+}
+
+std::vector<TilePos> trace_legs(
+    const TileGrid& grid,
+    const TilePos& from,
+    const std::vector<TileLeg>& legs
+){
+    std::vector<TilePos> tiles{from};
+    for (const TileLeg& leg : legs){
+        size_t travelled = 0;
+        while (travelled < leg.tiles){
+            const TilePos pos = tiles.back();
+            const std::optional<TilePos> next = grid.step(pos, leg.direction);
+            if (!next){
+                throw InternalProgramError(
+                    nullptr, PA_CURRENT_FUNCTION,
+                    "Leg " + to_string(leg) + " is stopped at " + to_string(pos) + "."
+                );
+            }
+            travelled += std::abs(next->x - pos.x) + std::abs(next->y - pos.y);
+            tiles.push_back(*next);
+        }
+        if (travelled != leg.tiles){
+            throw InternalProgramError(
+                nullptr, PA_CURRENT_FUNCTION,
+                "Leg " + to_string(leg) + " overshoots on a ledge hop."
+            );
+        }
+    }
+    return tiles;
+}
+
+
+
+std::string to_string(const PlannedLeg& leg){
+    std::string out = to_string(leg.leg) + " to";
+    for (const TilePos& pos : leg.after){
+        out += " " + to_string(pos);
+    }
+    return out;
+}
+
+namespace{
+
+//  Where `from` ends up after `tiles` steps in `direction`, stopping early at
+//  anything that stops the player. Nothing if a step would leave the map or
+//  enter a door: the plan cannot tell what happens then.
+std::optional<TilePos> step_tiles(
+    const TileGrid& grid, TilePos from, Direction direction, int tiles, int& grass
+){
+    int travelled = 0;
+    while (travelled < tiles){
+        const std::optional<TilePos> next = grid.step(from, direction);
+        if (!next){
+            if (!grid.at_wall(from, direction)){
+                return std::nullopt;
+            }
+            break;
+        }
+        travelled += std::abs(next->x - from.x) + std::abs(next->y - from.y);
+        if (grid.at(*next) == TileType::TALL_GRASS){
+            grass++;
+        }
+        from = *next;
+    }
+    return from;
+}
+
+using Spread = std::vector<TilePos>;
+
+bool spread_less(const TilePos& a, const TilePos& b){
+    return a.y != b.y ? a.y < b.y : a.x < b.x;
+}
+void normalize(Spread& spread){
+    std::sort(spread.begin(), spread.end(), spread_less);
+    spread.erase(std::unique(spread.begin(), spread.end()), spread.end());
+}
+struct SpreadLess{
+    bool operator()(const Spread& a, const Spread& b) const{
+        return std::lexicographical_compare(a.begin(), a.end(), b.begin(), b.end(), spread_less);
+    }
+};
+
+}
+
+std::optional<std::vector<PlannedLeg>> plan_robust_route(
+    const TileGrid& grid,
+    const TilePos& from, const TilePos& to,
+    const RobustPlanCosts& costs
+){
+    if (!grid.standable(from) || !grid.standable(to)){
+        throw InternalProgramError(
+            nullptr, PA_CURRENT_FUNCTION,
+            "Route ends must be standable: " + to_string(from) + " -> " + to_string(to) + "."
+        );
+    }
+    return plan_robust_route(grid, std::vector<TilePos>{from}, [&](const TilePos& pos){ return pos == to; }, costs);
+}
+
+std::optional<std::vector<PlannedLeg>> plan_robust_route(
+    const TileGrid& grid,
+    const std::vector<TilePos>& from, const std::function<bool(const TilePos&)>& goal,
+    const RobustPlanCosts& costs
+){
+    for (const TilePos& pos : from){
+        if (!grid.standable(pos)){
+            throw InternalProgramError(
+                nullptr, PA_CURRENT_FUNCTION,
+                "Route starts must be standable: " + to_string(pos) + "."
+            );
+        }
+    }
+    //  Only the start may be wider than costs.max_spread: every leg must bring
+    //  the player within it.
+    const size_t max_spread = costs.max_spread;
+    auto reached = [&](const Spread& spread){
+        return std::all_of(spread.begin(), spread.end(), goal);
+    };
+
+    struct Node{
+        long long cost;
+        Spread parent;
+        PlannedLeg leg;
+        bool done = false;
+    };
+    std::map<Spread, Node, SpreadLess> nodes;
+    using Entry = std::pair<long long, Spread>;
+    auto entry_greater = [](const Entry& a, const Entry& b){ return a.first > b.first; };
+    std::priority_queue<Entry, std::vector<Entry>, decltype(entry_greater)> queue(entry_greater);
+
+    Spread start = from;
+    normalize(start);
+    nodes[start] = Node{0, {}, {}};
+    queue.emplace(0, start);
+
+    auto relax = [&](const Spread& spread, long long cost, Spread next, PlannedLeg leg){
+        normalize(next);
+        if (next.size() > max_spread || next == spread){
+            return;
+        }
+        auto iter = nodes.find(next);
+        if (iter != nodes.end() && iter->second.cost <= cost){
+            return;
+        }
+        leg.after = next;
+        nodes[next] = Node{cost, spread, std::move(leg)};
+        queue.emplace(cost, std::move(next));
+    };
+
+    while (!queue.empty()){
+        const Entry top = queue.top();
+        queue.pop();
+        const long long cost = top.first;
+        const Spread& spread = top.second;
+        Node& node = nodes[spread];
+        if (node.done || node.cost != cost){
+            continue;
+        }
+        node.done = true;
+        if (reached(spread)){
+            std::vector<PlannedLeg> legs;
+            for (Spread at = spread; at != start; ){
+                const Node& step = nodes[at];
+                legs.push_back(step.leg);
+                at = step.parent;
+            }
+            std::reverse(legs.begin(), legs.end());
+            return legs;
+        }
+
+        for (Direction direction : ALL_DIRECTIONS){
+            //  To the wall: every position walks until stopped.
+            {
+                Spread next;
+                size_t longest = 0;
+                int grass = 0;
+                bool ok = true;
+                for (const TilePos& pos : spread){
+                    const WallHit hit = walk_to_wall(grid, pos, direction);
+                    if (!hit.anchored){
+                        ok = false;
+                        break;
+                    }
+                    int leg_grass = 0;
+                    step_tiles(grid, pos, direction, (int)hit.tiles, leg_grass);
+                    grass = std::max(grass, leg_grass);
+                    longest = std::max(longest, hit.tiles);
+                    next.push_back(hit.stop);
+                }
+                if (ok && longest > 0){
+                    const long long step = (long long)costs.per_leg +
+                        (long long)costs.per_tile * longest + (long long)costs.per_grass_tile * grass;
+                    relax(spread, cost + step, std::move(next), PlannedLeg{TileLeg{direction, longest, true}, {}});
+                }
+            }
+            //  Open: about `tiles` tiles, give or take `open_error`.
+            for (int tiles = 1; tiles <= costs.max_open_tiles; tiles++){
+                Spread next;
+                int grass = 0;
+                bool ok = true;
+                for (const TilePos& pos : spread){
+                    const int error = costs.open_error + tiles / costs.open_error_per;
+                    for (int n = std::max(1, tiles - error); n <= tiles + error; n++){
+                        int leg_grass = 0;
+                        const std::optional<TilePos> end = step_tiles(grid, pos, direction, n, leg_grass);
+                        if (!end){
+                            ok = false;
+                            break;
+                        }
+                        grass = std::max(grass, leg_grass);
+                        next.push_back(*end);
+                    }
+                    if (!ok){
+                        break;
+                    }
+                }
+                if (!ok){
+                    break;
+                }
+                const long long step = (long long)costs.per_leg + costs.leg_not_at_wall +
+                    (long long)costs.per_tile * tiles + (long long)costs.per_grass_tile * grass;
+                relax(spread, cost + step, std::move(next), PlannedLeg{TileLeg{direction, (size_t)tiles, false}, {}});
+            }
+        }
+    }
+
+    return std::nullopt;
+}
+
+
+
+}
+}
diff --git a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_TileGrid.h b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_TileGrid.h
new file mode 100644
index 0000000000..e7ac5ae15a
--- /dev/null
+++ b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_TileGrid.h
@@ -0,0 +1,177 @@
+/*  Tile Grid
+ *
+ *  From: https://github.com/PokemonAutomation/
+ *
+ *  An overworld map as a grid of tiles, and a planner that turns a walk from
+ *  one tile to another into straight legs. Timed stick holds drift by a tile;
+ *  a leg that ends against a wall does not, because the player stops there
+ *  however long the stick is held. The planner prefers such legs.
+ */
+
+#ifndef PokemonAutomation_Pokemon_TileGrid_H
+#define PokemonAutomation_Pokemon_TileGrid_H
+
+#include <cstddef>
+#include <functional>
+#include <optional>
+#include <string>
+#include <vector>
+#include "Pokemon_Grid.h"
+
+namespace PokemonAutomation{
+namespace Pokemon{
+
+
+//  Legend of the ASCII rows a grid is parsed from.
+enum class TileType{
+    BLOCKED,        //  '#': trees, walls, items on the ground
+    WALKABLE,       //  '.': open ground and paths
+    TALL_GRASS,     //  '"': walkable, with wild encounters
+    LEDGE,          //  'v': crossed only southward, hopping to the tile past it
+    NPC,            //  'N': a standing NPC or trainer; blocks like a wall
+    SIGN,           //  'S': a sign; blocks like a wall
+    DOOR,           //  'D': walking into it enters a building
+    UNKNOWN,        //  '?': off the map; an exit or ground we have no map of
+};
+char tile_char(TileType type);
+
+class TileGrid{
+public:
+    //  Every row must have the same length and use only the legend's characters.
+    //  Throws InternalProgramError otherwise.
+    explicit TileGrid(const std::vector<std::string>& rows);
+
+    //  The grid as the ASCII rows it parses from.
+    std::vector<std::string> rows() const;
+
+    int width() const{ return m_width; }
+    int height() const{ return m_height; }
+    bool in_bounds(const TilePos& pos) const;
+
+    //  Out-of-bounds tiles read as UNKNOWN.
+    TileType at(const TilePos& pos) const;
+
+    //  Changes one tile, e.g. to block one found in the way on the console.
+    //  Out-of-bounds tiles are left alone.
+    void set(const TilePos& pos, TileType type);
+
+    //  Whether the player can stand on this tile.
+    bool standable(const TilePos& pos) const;
+
+    //  Where one step from `from` lands, or nothing if the player is stopped.
+    //  A south step onto a ledge hops to the tile past it.
+    std::optional<TilePos> step(const TilePos& from, Direction direction) const;
+
+    //  Whether a step from `pos` is refused by a tile that holds the player
+    //  in place. Doors and unknown tiles are not walls: walking into a door
+    //  enters the building, and unknown ground may be an exit.
+    bool at_wall(const TilePos& pos, Direction direction) const;
+
+private:
+    int m_width = 0;
+    int m_height = 0;
+    std::vector<TileType> m_tiles;
+};
+
+
+//  Where the player stops when walking in one direction until stopped.
+struct WallHit{
+    TilePos stop;
+    size_t tiles = 0;           //  tiles travelled; a ledge hop counts 2
+    TilePos wall;               //  the first tile the player could not enter
+    bool anchored = false;      //  the player is held at `stop` (see TileGrid::at_wall())
+};
+WallHit walk_to_wall(const TileGrid& grid, const TilePos& from, Direction direction);
+
+
+//  A straight run in one direction.
+struct TileLeg{
+    Direction direction;
+    size_t tiles = 0;           //  tiles travelled; a ledge hop counts 2
+    bool ends_at_wall = false;  //  the next tile in `direction` stops the player
+};
+std::string to_string(const TileLeg& leg);
+
+struct TilePlanCosts{
+    int per_tile = 1;
+    int per_grass_tile = 4;     //  extra for each tall-grass tile entered
+    int per_leg = 8;
+    int leg_not_at_wall = 50;   //  extra for a leg that stops in the open
+};
+
+//  Cheapest legs from `from` to `to`, moving 4 ways, or nothing if `to`
+//  cannot be reached. Both tiles must be standable.
+std::optional<std::vector<TileLeg>> plan_tile_route(
+    const TileGrid& grid,
+    const TilePos& from, const TilePos& to,
+    const TilePlanCosts& costs = TilePlanCosts()
+);
+
+//  A trainer sees the tiles in a straight line in front of them, up to
+//  `range` tiles or the first tile the player cannot stand on.
+struct TrainerSight{
+    std::string name;
+    TilePos pos;
+    Direction facing;
+    int range = 4;
+};
+std::vector<TilePos> sight_tiles(const TileGrid& grid, const TrainerSight& trainer);
+
+//  For each leg, the trainers whose sight line it enters.
+std::vector<std::vector<std::string>> legs_crossing_sight(
+    const TileGrid& grid,
+    const TilePos& from,
+    const std::vector<TileLeg>& legs,
+    const std::vector<TrainerSight>& trainers
+);
+
+//  The tiles a list of legs visits, starting with `from`. Throws
+//  InternalProgramError if a leg is stopped before its end.
+std::vector<TilePos> trace_legs(
+    const TileGrid& grid,
+    const TilePos& from,
+    const std::vector<TileLeg>& legs
+);
+
+
+//  A leg of a plan that allows for open legs going a tile short or long. A
+//  leg to a wall is walked until the player stops; an open leg is walked for
+//  `leg.tiles` tiles' worth of time. `after` lists every tile the player may
+//  stand on once the leg is done.
+struct PlannedLeg{
+    TileLeg leg;
+    std::vector<TilePos> after;
+};
+std::string to_string(const PlannedLeg& leg);
+
+struct RobustPlanCosts : TilePlanCosts{
+    //  An open leg of n tiles may end open_error + n / open_error_per tiles
+    //  short or long: on the console 7 tiles went 9.
+    int open_error = 1;
+    int open_error_per = 5;
+    int max_open_tiles = 12;    //  longest open leg to consider
+    size_t max_spread = 5;      //  most tiles the player may be on after a leg
+};
+
+//  Cheapest legs that take the player from any of the tiles in `from` to tiles
+//  that are all `goal`, even if every open leg ends up to `open_error` tiles
+//  off: the walls of later legs must bring the possible positions together.
+//  Legs that would leave the map or enter a door are not used. Nothing if no
+//  such plan exists.
+std::optional<std::vector<PlannedLeg>> plan_robust_route(
+    const TileGrid& grid,
+    const std::vector<TilePos>& from, const std::function<bool(const TilePos&)>& goal,
+    const RobustPlanCosts& costs = RobustPlanCosts()
+);
+//  The same, from one tile to exactly `to`.
+std::optional<std::vector<PlannedLeg>> plan_robust_route(
+    const TileGrid& grid,
+    const TilePos& from, const TilePos& to,
+    const RobustPlanCosts& costs = RobustPlanCosts()
+);
+
+
+
+}
+}
+#endif
diff --git a/SerialPrograms/cmake/SourceFiles.cmake b/SerialPrograms/cmake/SourceFiles.cmake
index b760c6d132..0d62a31b0c 100644
--- a/SerialPrograms/cmake/SourceFiles.cmake
+++ b/SerialPrograms/cmake/SourceFiles.cmake
@@ -1448,7 +1448,11 @@ file(GLOB LIBRARY_SOURCES
     Source/Pokemon/Navigation/Pokemon_LegWalker.cpp
     Source/Pokemon/Navigation/Pokemon_LegWalker.h
     Source/Pokemon/Navigation/Pokemon_LegWalker_Tests.cpp
+    Source/Pokemon/Navigation/Pokemon_MapSet.cpp
+    Source/Pokemon/Navigation/Pokemon_MapSet.h
     Source/Pokemon/Navigation/Pokemon_Navigation_Tests.h
+    Source/Pokemon/Navigation/Pokemon_TileGrid.cpp
+    Source/Pokemon/Navigation/Pokemon_TileGrid.h
     Source/Pokemon/Options/Pokemon_BoxSortingTable.cpp
     Source/Pokemon/Options/Pokemon_BoxSortingTable.h
     Source/Pokemon/Options/Pokemon_EncounterBotOptions.h

From b50d5471ac38dd770d4500c394d6e4661df7754f Mon Sep 17 00:00:00 2001
From: dayfine <difancpa@gmail.com>
Date: Sat, 31 Oct 2026 20:49:06 -0700
Subject: [PATCH 09/10] Pokemon navigation: exact short open legs, a
 per-open-tile cost, and a search cap

Three planner changes the BDSP run made on its branch, ported to the core:
RobustPlanCosts::exact_open_tiles (open legs up to that length land exactly:
D-pad taps move whole tiles), per_open_tile (a long open leg costs more
than a short step after a wall), and max_searched (the set search gives up
after 20000 sets: all of Jubilife from six start tiles ran for minutes,
r224a; town costs or a cropped map are the answer, not a higher cap).

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AKYzhrMnPK61XHWEch4a6E
---
 .../Pokemon/Navigation/Pokemon_TileGrid.cpp      |  8 ++++++--
 .../Source/Pokemon/Navigation/Pokemon_TileGrid.h | 16 +++++++++++++++-
 2 files changed, 21 insertions(+), 3 deletions(-)

diff --git a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_TileGrid.cpp b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_TileGrid.cpp
index c596747789..74901f69a7 100644
--- a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_TileGrid.cpp
+++ b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_TileGrid.cpp
@@ -413,6 +413,7 @@ std::optional<std::vector<PlannedLeg>> plan_robust_route(
         queue.emplace(cost, std::move(next));
     };
 
+    size_t searched = 0;
     while (!queue.empty()){
         const Entry top = queue.top();
         queue.pop();
@@ -423,6 +424,9 @@ std::optional<std::vector<PlannedLeg>> plan_robust_route(
             continue;
         }
         node.done = true;
+        if (++searched > costs.max_searched){
+            return std::nullopt;
+        }
         if (reached(spread)){
             std::vector<PlannedLeg> legs;
             for (Spread at = spread; at != start; ){
@@ -465,7 +469,7 @@ std::optional<std::vector<PlannedLeg>> plan_robust_route(
                 int grass = 0;
                 bool ok = true;
                 for (const TilePos& pos : spread){
-                    const int error = costs.open_error + tiles / costs.open_error_per;
+                    const int error = tiles <= costs.exact_open_tiles ? 0 : costs.open_error + tiles / costs.open_error_per;
                     for (int n = std::max(1, tiles - error); n <= tiles + error; n++){
                         int leg_grass = 0;
                         const std::optional<TilePos> end = step_tiles(grid, pos, direction, n, leg_grass);
@@ -484,7 +488,7 @@ std::optional<std::vector<PlannedLeg>> plan_robust_route(
                     break;
                 }
                 const long long step = (long long)costs.per_leg + costs.leg_not_at_wall +
-                    (long long)costs.per_tile * tiles + (long long)costs.per_grass_tile * grass;
+                    (long long)(costs.per_tile + costs.per_open_tile) * tiles + (long long)costs.per_grass_tile * grass;
                 relax(spread, cost + step, std::move(next), PlannedLeg{TileLeg{direction, (size_t)tiles, false}, {}});
             }
         }
diff --git a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_TileGrid.h b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_TileGrid.h
index e7ac5ae15a..49837e77e9 100644
--- a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_TileGrid.h
+++ b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_TileGrid.h
@@ -149,15 +149,29 @@ struct RobustPlanCosts : TilePlanCosts{
     //  short or long: on the console 7 tiles went 9.
     int open_error = 1;
     int open_error_per = 5;
+    //  Open legs this many tiles or shorter land exactly: a short hold moves
+    //  whole tiles. 0 keeps every open leg uncertain.
+    int exact_open_tiles = 0;
+    //  Extra per tile of an open leg: its timing error grows with its length,
+    //  so a short step after a wall beats a long open leg.
+    int per_open_tile = 0;
     int max_open_tiles = 12;    //  longest open leg to consider
     size_t max_spread = 5;      //  most tiles the player may be on after a leg
+    //  Most sets of possible tiles to search before giving up. The search is
+    //  over sets, not tiles, so it grows far faster than the map: all of
+    //  Jubilife City from six start tiles ran for minutes with no plan
+    //  (r224a, 2026-10-31); 200000 sets took 31 s there, so this gives up
+    //  after about 3. Use town costs in towns (a whole-Jubilife plan then
+    //  takes 1 s) and crop the map to the part a leg needs rather than
+    //  raising this.
+    size_t max_searched = 20000;
 };
 
 //  Cheapest legs that take the player from any of the tiles in `from` to tiles
 //  that are all `goal`, even if every open leg ends up to `open_error` tiles
 //  off: the walls of later legs must bring the possible positions together.
 //  Legs that would leave the map or enter a door are not used. Nothing if no
-//  such plan exists.
+//  such plan exists, or none is found within `costs.max_searched` sets.
 std::optional<std::vector<PlannedLeg>> plan_robust_route(
     const TileGrid& grid,
     const std::vector<TilePos>& from, const std::function<bool(const TilePos&)>& goal,

From dc9f1682f3ff1c6b009b12b07884304db4c401f6 Mon Sep 17 00:00:00 2001
From: dayfine <difancpa@gmail.com>
Date: Sat, 31 Oct 2026 21:32:46 -0700
Subject: [PATCH 10/10] Pokemon navigation core: keep only the grid types and
 the leg planner

Both games plan on Grid and LegPlanner, so those stay here. The rest
served one game each and moves to its user: ScreenMachine/StepTrace to
common/screen-machine, LegWalker to frlg/brock-mvp (where LegMover is a
small abstract class, so MoveOnlyFunction is no longer needed here),
TileGrid and MapSet to bdsp/tilegrid-mapset. The MoveOnlyFunction copy
of #72 goes with them.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AKYzhrMnPK61XHWEch4a6E
---
 Common/Cpp/MoveOnlyFunction.h                 | 118 ----
 Common/Cpp/MoveOnlyFunction_Tests.cpp         | 190 -------
 Common/Cpp/MoveOnlyFunction_Tests.h           |  21 -
 .../ScreenMachine/ScreenMachine.cpp           |  97 ----
 .../CommonTools/ScreenMachine/ScreenMachine.h | 105 ----
 .../CommonTools/ScreenMachine/StepTrace.cpp   |  74 ---
 .../CommonTools/ScreenMachine/StepTrace.h     |  53 --
 .../ComputerPrograms_UnitTestRunner.cpp       |   3 -
 .../Pokemon/Navigation/Pokemon_LegWalker.cpp  |  70 ---
 .../Pokemon/Navigation/Pokemon_LegWalker.h    | 209 --------
 .../Navigation/Pokemon_LegWalker_Tests.cpp    | 176 ------
 .../Pokemon/Navigation/Pokemon_MapSet.cpp     | 102 ----
 .../Pokemon/Navigation/Pokemon_MapSet.h       |  63 ---
 .../Navigation/Pokemon_Navigation_Tests.h     |   1 -
 .../Pokemon/Navigation/Pokemon_TileGrid.cpp   | 503 ------------------
 .../Pokemon/Navigation/Pokemon_TileGrid.h     | 191 -------
 SerialPrograms/cmake/SourceFiles.cmake        |  14 -
 17 files changed, 1990 deletions(-)
 delete mode 100644 Common/Cpp/MoveOnlyFunction.h
 delete mode 100644 Common/Cpp/MoveOnlyFunction_Tests.cpp
 delete mode 100644 Common/Cpp/MoveOnlyFunction_Tests.h
 delete mode 100644 SerialPrograms/Source/CommonTools/ScreenMachine/ScreenMachine.cpp
 delete mode 100644 SerialPrograms/Source/CommonTools/ScreenMachine/ScreenMachine.h
 delete mode 100644 SerialPrograms/Source/CommonTools/ScreenMachine/StepTrace.cpp
 delete mode 100644 SerialPrograms/Source/CommonTools/ScreenMachine/StepTrace.h
 delete mode 100644 SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegWalker.cpp
 delete mode 100644 SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegWalker.h
 delete mode 100644 SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegWalker_Tests.cpp
 delete mode 100644 SerialPrograms/Source/Pokemon/Navigation/Pokemon_MapSet.cpp
 delete mode 100644 SerialPrograms/Source/Pokemon/Navigation/Pokemon_MapSet.h
 delete mode 100644 SerialPrograms/Source/Pokemon/Navigation/Pokemon_TileGrid.cpp
 delete mode 100644 SerialPrograms/Source/Pokemon/Navigation/Pokemon_TileGrid.h

diff --git a/Common/Cpp/MoveOnlyFunction.h b/Common/Cpp/MoveOnlyFunction.h
deleted file mode 100644
index 9cc71f3422..0000000000
--- a/Common/Cpp/MoveOnlyFunction.h
+++ /dev/null
@@ -1,118 +0,0 @@
-/*  Move-Only Function
- *
- *  From: https://github.com/PokemonAutomation/
- *
- *  A callable wrapper that can be moved but not copied.
- *
- *  Prefer this over std::function for a callback that has one owner.
- *  Copying a std::function copies its callable, so a stateful lambda
- *  silently splits into two independent states. And std::function cannot
- *  hold a lambda that captures a move-only object (e.g. std::unique_ptr).
- *
- *  This is std::move_only_function (C++23) where the standard library has
- *  it. Apple's libc++ (Xcode 26 / Apple Clang 21) does not, so this header
- *  has a minimal fallback for the plain "R(Args...)" signature. Delete the
- *  fallback once every supported compiler defines
- *  __cpp_lib_move_only_function.
- *
- */
-
-#ifndef PokemonAutomation_MoveOnlyFunction_H
-#define PokemonAutomation_MoveOnlyFunction_H
-
-#include <version>
-#include <functional>
-
-#ifndef __cpp_lib_move_only_function
-#include <cstddef>
-#include <memory>
-#include <type_traits>
-#include <utility>
-#endif
-
-namespace PokemonAutomation{
-
-
-
-#ifdef __cpp_lib_move_only_function
-
-template <typename Signature>
-using MoveOnlyFunction = std::move_only_function<Signature>;
-
-#else
-
-template <typename Signature>
-class MoveOnlyFunction;
-
-template <typename R, typename... Args>
-class MoveOnlyFunction<R(Args...)>{
-public:
-    MoveOnlyFunction() noexcept = default;
-    MoveOnlyFunction(std::nullptr_t) noexcept {}
-
-    template <typename Function>
-        requires (
-            !std::is_same_v<std::remove_cvref_t<Function>, MoveOnlyFunction> &&
-            std::is_invocable_r_v<R, std::decay_t<Function>&, Args...>
-        )
-    MoveOnlyFunction(Function&& function){
-        using Stored = std::decay_t<Function>;
-        //  Like std::move_only_function, a null function pointer makes an
-        //  empty wrapper.
-        if constexpr (std::is_pointer_v<Stored> || std::is_member_pointer_v<Stored>){
-            if (function == nullptr){
-                return;
-            }
-        }
-        m_callable = std::make_unique<Holder<Stored>>(std::forward<Function>(function));
-    }
-
-    MoveOnlyFunction(MoveOnlyFunction&&) noexcept = default;
-    MoveOnlyFunction& operator=(MoveOnlyFunction&&) noexcept = default;
-    MoveOnlyFunction(const MoveOnlyFunction&) = delete;
-    MoveOnlyFunction& operator=(const MoveOnlyFunction&) = delete;
-
-    explicit operator bool() const noexcept{
-        return m_callable != nullptr;
-    }
-    friend bool operator==(const MoveOnlyFunction& function, std::nullptr_t) noexcept{
-        return !function;
-    }
-
-    //  Calling an empty wrapper is undefined, as for std::move_only_function.
-    R operator()(Args... args){
-        return m_callable->call(std::forward<Args>(args)...);
-    }
-
-
-private:
-    class Callable{
-    public:
-        virtual ~Callable() = default;
-        virtual R call(Args&&... args) = 0;
-    };
-
-    template <typename Stored>
-    class Holder final : public Callable{
-    public:
-        template <typename Source>
-        explicit Holder(Source&& source)
-            : m_stored(std::forward<Source>(source))
-        {}
-        virtual R call(Args&&... args) override{
-            return std::invoke_r<R>(m_stored, std::forward<Args>(args)...);
-        }
-
-    private:
-        Stored m_stored;
-    };
-
-    std::unique_ptr<Callable> m_callable;
-};
-
-#endif
-
-
-
-}
-#endif
diff --git a/Common/Cpp/MoveOnlyFunction_Tests.cpp b/Common/Cpp/MoveOnlyFunction_Tests.cpp
deleted file mode 100644
index 72ed5998ae..0000000000
--- a/Common/Cpp/MoveOnlyFunction_Tests.cpp
+++ /dev/null
@@ -1,190 +0,0 @@
-/*  Move-Only Function Tests
- *
- *  From: https://github.com/PokemonAutomation/
- *
- */
-
-#include <memory>
-#include <string>
-#include <type_traits>
-#include <utility>
-#include "TestRunners/UnitTestDatabase.h"
-#include "MoveOnlyFunction.h"
-#include "MoveOnlyFunction_Tests.h"
-
-namespace PokemonAutomation{
-namespace{
-
-
-
-//  Copying would fork a stateful callable, so it must not compile.
-static_assert(!std::is_copy_constructible_v<MoveOnlyFunction<void()>>);
-static_assert(!std::is_copy_assignable_v<MoveOnlyFunction<void()>>);
-static_assert(std::is_nothrow_move_constructible_v<MoveOnlyFunction<void()>>);
-
-
-
-std::string expected_int(const char* what, int expected, int actual){
-    return std::string(what) + ": expected " + std::to_string(expected) +
-        ", got " + std::to_string(actual);
-}
-
-
-
-class Test_MoveOnlyFunction_MoveOnlyCapture : public UnitTest{
-public:
-    Test_MoveOnlyFunction_MoveOnlyCapture()
-        : UnitTest("Common::MoveOnlyFunction - Move-only capture")
-    {}
-
-    virtual UnitTestResult run(Logger& logger, CancellableScope& scope) const override{
-        auto value = std::make_unique<int>(42);
-        MoveOnlyFunction<int(int)> function = [value = std::move(value)](int add){
-            return *value + add;
-        };
-        int actual = function(1);
-        if (actual != 43){
-            return UnitTestResult(expected_int("call with a unique_ptr capture", 43, actual));
-        }
-
-        MoveOnlyFunction<int(int)> moved = std::move(function);
-        actual = moved(2);
-        if (actual != 44){
-            return UnitTestResult(expected_int("call after a move", 44, actual));
-        }
-        return true;
-    }
-};
-
-
-
-class Test_MoveOnlyFunction_StateNotForked : public UnitTest{
-public:
-    Test_MoveOnlyFunction_StateNotForked()
-        : UnitTest("Common::MoveOnlyFunction - Moving keeps one state")
-    {}
-
-    virtual UnitTestResult run(Logger& logger, CancellableScope& scope) const override{
-        MoveOnlyFunction<int()> counter = [count = 0]() mutable{
-            return ++count;
-        };
-        int actual = counter();
-        if (actual != 1){
-            return UnitTestResult(expected_int("first call", 1, actual));
-        }
-
-        //  The moved-to wrapper continues the same count.
-        MoveOnlyFunction<int()> constructed = std::move(counter);
-        actual = constructed();
-        if (actual != 2){
-            return UnitTestResult(expected_int("call after a move construction", 2, actual));
-        }
-
-        MoveOnlyFunction<int()> assigned;
-        assigned = std::move(constructed);
-        actual = assigned();
-        if (actual != 3){
-            return UnitTestResult(expected_int("call after a move assignment", 3, actual));
-        }
-        return true;
-    }
-};
-
-
-
-int return_seven(){
-    return 7;
-}
-
-class Test_MoveOnlyFunction_Empty : public UnitTest{
-public:
-    Test_MoveOnlyFunction_Empty()
-        : UnitTest("Common::MoveOnlyFunction - Empty is false")
-    {}
-
-    virtual UnitTestResult run(Logger& logger, CancellableScope& scope) const override{
-        MoveOnlyFunction<int()> defaulted;
-        if (defaulted){
-            return UnitTestResult("default constructed: expected empty, got non-empty");
-        }
-        MoveOnlyFunction<int()> from_nullptr = nullptr;
-        if (from_nullptr){
-            return UnitTestResult("constructed from nullptr: expected empty, got non-empty");
-        }
-        int (*null_pointer)() = nullptr;
-        MoveOnlyFunction<int()> from_null_pointer = null_pointer;
-        if (from_null_pointer){
-            return UnitTestResult("constructed from a null function pointer: expected empty, got non-empty");
-        }
-
-        MoveOnlyFunction<int()> from_pointer = &return_seven;
-        if (!from_pointer){
-            return UnitTestResult("constructed from a function pointer: expected non-empty, got empty");
-        }
-        int actual = from_pointer();
-        if (actual != 7){
-            return UnitTestResult(expected_int("call through a function pointer", 7, actual));
-        }
-        return true;
-    }
-};
-
-
-
-class Test_MoveOnlyFunction_Reassignment : public UnitTest{
-public:
-    Test_MoveOnlyFunction_Reassignment()
-        : UnitTest("Common::MoveOnlyFunction - Reassignment")
-    {}
-
-    virtual UnitTestResult run(Logger& logger, CancellableScope& scope) const override{
-        //  The use count shows whether the wrapper still holds the first
-        //  callable.
-        auto token = std::make_shared<int>(1);
-        MoveOnlyFunction<int()> function = [token]{
-            return *token;
-        };
-        int actual = function();
-        if (actual != 1){
-            return UnitTestResult(expected_int("first callable", 1, actual));
-        }
-
-        function = []{
-            return 2;
-        };
-        actual = function();
-        if (actual != 2){
-            return UnitTestResult(expected_int("call after reassignment", 2, actual));
-        }
-        actual = (int)token.use_count();
-        if (actual != 1){
-            return UnitTestResult(expected_int("token owners after reassignment", 1, actual));
-        }
-
-        function = nullptr;
-        if (function){
-            return UnitTestResult("assigned nullptr: expected empty, got non-empty");
-        }
-        if (function != nullptr){
-            return UnitTestResult("assigned nullptr: expected == nullptr, got != nullptr");
-        }
-        return true;
-    }
-};
-
-
-
-} // anonymous namespace
-
-
-
-void add_tests_MoveOnlyFunction(UnitTestDatabase& database){
-    database.add<Test_MoveOnlyFunction_MoveOnlyCapture>();
-    database.add<Test_MoveOnlyFunction_StateNotForked>();
-    database.add<Test_MoveOnlyFunction_Empty>();
-    database.add<Test_MoveOnlyFunction_Reassignment>();
-}
-
-
-
-}
diff --git a/Common/Cpp/MoveOnlyFunction_Tests.h b/Common/Cpp/MoveOnlyFunction_Tests.h
deleted file mode 100644
index c43f518bdc..0000000000
--- a/Common/Cpp/MoveOnlyFunction_Tests.h
+++ /dev/null
@@ -1,21 +0,0 @@
-/*  Move-Only Function Tests
- *
- *  From: https://github.com/PokemonAutomation/
- *
- */
-
-#ifndef PokemonAutomation_MoveOnlyFunction_Tests_H
-#define PokemonAutomation_MoveOnlyFunction_Tests_H
-
-#include "Common/Cpp/TestRunners/UnitTestDatabase.h"
-
-namespace PokemonAutomation{
-
-
-
-void add_tests_MoveOnlyFunction(UnitTestDatabase& database);
-
-
-
-}
-#endif
diff --git a/SerialPrograms/Source/CommonTools/ScreenMachine/ScreenMachine.cpp b/SerialPrograms/Source/CommonTools/ScreenMachine/ScreenMachine.cpp
deleted file mode 100644
index 8d528c4eaa..0000000000
--- a/SerialPrograms/Source/CommonTools/ScreenMachine/ScreenMachine.cpp
+++ /dev/null
@@ -1,97 +0,0 @@
-/*  Screen Machine
- *
- *  From: https://github.com/PokemonAutomation/
- *
- */
-
-#include <algorithm>
-#include "CommonFramework/ImageTools/ImageDiff.h"
-#include "ScreenMachine.h"
-
-namespace PokemonAutomation{
-
-using namespace std::chrono_literals;
-
-
-namespace{
-
-const ScreenState* classify(const std::vector<ScreenState>& states, const ImageViewRGB32& screen){
-    for (const ScreenState& state : states){
-        if (state.matches(screen)){
-            return &state;
-        }
-    }
-    return nullptr;
-}
-
-}
-
-
-const ScreenState& read_screen_state(
-    VideoStream& stream, CancellableScope& scope, StepTrace& trace,
-    const std::vector<ScreenState>& states, VideoSnapshot& frame
-){
-    const ScreenState* last = nullptr;
-    WallClock video_lost = WallClock::max();
-    for (size_t c = 0; c < 20; c++){
-        VideoSnapshot screen = stream.video().snapshot();
-        if (!screen){
-            //  The app resets a frozen capture by itself, which takes a second or two.
-            const WallClock now = current_time();
-            video_lost = std::min(video_lost, now);
-            if (now - video_lost > std::chrono::seconds(10)){
-                trace.fail("No video from the capture card for 10s.");
-            }
-            c--;
-            scope.wait_for(500ms);
-            continue;
-        }
-        video_lost = WallClock::max();
-        const ScreenState* now = classify(states, screen);
-        frame = std::move(screen);
-        if (now != nullptr && now == last){
-            return *now;
-        }
-        last = now;
-        scope.wait_for(150ms);
-    }
-    if (last == nullptr){
-        trace.fail("The screen matches none of the known states.");
-    }
-    return *last;   //  Still changing after 3s: go with the latest read.
-}
-
-
-void ScreenMachineChecks::check(const ScreenState& state, VideoSnapshot frame){
-    const bool same_size = m_last_frame && frame &&
-        m_last_frame->width() == frame->width() && m_last_frame->height() == frame->height();
-    if (same_size && ImageMatch::pixel_RMSD(m_last_frame, frame) < 2.0){
-        if (++m_unchanged >= MAX_UNCHANGED){
-            m_trace.fail("The screen stopped changing: " + std::to_string(MAX_UNCHANGED) +
-                " steps on \"" + state.name + "\" did nothing.");
-        }
-    }else{
-        m_unchanged = 0;
-    }
-    m_last_frame = std::move(frame);
-
-    if (m_previous != nullptr && m_previous != &state && !m_previous->next.empty() &&
-        std::find(m_previous->next.begin(), m_previous->next.end(), state.name) == m_previous->next.end()
-    ){
-        m_trace.fail("Unexpected screen after \"" + m_previous->name + "\": \"" + state.name + "\".");
-    }
-    m_in_a_row = m_previous == &state ? m_in_a_row + 1 : 1;
-    if (m_in_a_row > state.max_in_a_row){
-        m_trace.fail("Screen \"" + state.name + "\" came up " + std::to_string(m_in_a_row) +
-            " times in a row: the step for it is not getting anywhere.");
-    }
-    if (++m_visits[state.name] > state.max_visits){
-        m_trace.fail("Screen \"" + state.name + "\" came up more than " +
-            std::to_string(state.max_visits) + " times: the step for it is not working.");
-    }
-    m_previous = &state;
-}
-
-
-
-}
diff --git a/SerialPrograms/Source/CommonTools/ScreenMachine/ScreenMachine.h b/SerialPrograms/Source/CommonTools/ScreenMachine/ScreenMachine.h
deleted file mode 100644
index f878ff709c..0000000000
--- a/SerialPrograms/Source/CommonTools/ScreenMachine/ScreenMachine.h
+++ /dev/null
@@ -1,105 +0,0 @@
-/*  Screen Machine
- *
- *  From: https://github.com/PokemonAutomation/
- *
- *  A closed loop over known screens: read the screen, take the one step that screen
- *  calls for, read again. Every step follows a read, a screen counts only once two
- *  frames agree, and each state lists the screens it may lead to, so a dropped or
- *  wrong input shows up as an unexpected screen or a state that keeps coming back.
- *
- */
-
-#ifndef PokemonAutomation_CommonTools_ScreenMachine_H
-#define PokemonAutomation_CommonTools_ScreenMachine_H
-
-#include <stdint.h>
-#include <functional>
-#include <map>
-#include <string>
-#include <vector>
-#include "Common/Cpp/Time.h"
-#include "Common/Cpp/CancellableScope.h"
-#include "CommonFramework/ImageTypes/ImageViewRGB32.h"
-#include "CommonFramework/Tools/VideoStream.h"
-#include "CommonFramework/VideoPipeline/VideoFeed.h"
-#include "StepTrace.h"
-
-namespace PokemonAutomation{
-
-
-struct ScreenState{
-    std::string name;
-    //  Whether this is the screen. States are tried in order; the first match wins, so
-    //  the last state should match anything.
-    std::function<bool(const ImageViewRGB32& screen)> matches;
-    //  The one step to take on this screen.
-    std::function<void()> act;
-    //  The screens the step may lead to besides staying here. Empty: any.
-    std::vector<std::string> next;
-    //  Fail once the screen has been seen this many times.
-    size_t max_visits;
-    //  End the run after this state's step.
-    bool terminal = false;
-    //  Fail once the screen has been seen this many times in a row.
-    size_t max_in_a_row = SIZE_MAX;
-};
-
-
-//  The state on screen, once two frames 150ms apart agree. Waits out a video
-//  gap of up to 10s. Fails through `trace` if no state matches.
-const ScreenState& read_screen_state(
-    VideoStream& stream, CancellableScope& scope, StepTrace& trace,
-    const std::vector<ScreenState>& states, VideoSnapshot& frame
-);
-
-//  The checks between reads: the screen must be one the previous state can lead
-//  to, no state may come up too often, and steps must keep changing the screen.
-class ScreenMachineChecks{
-public:
-    ScreenMachineChecks(StepTrace& trace)
-        : m_trace(trace)
-    {}
-    void check(const ScreenState& state, VideoSnapshot frame);
-
-private:
-    //  A step that changes nothing on screen is a dead end (e.g. a menu the states do
-    //  not know): fail after a few instead of running out the visit limit.
-    static constexpr size_t MAX_UNCHANGED = 8;
-
-    StepTrace& m_trace;
-    std::map<std::string, size_t> m_visits;
-    const ScreenState* m_previous = nullptr;
-    VideoSnapshot m_last_frame;
-    size_t m_unchanged = 0;
-    size_t m_in_a_row = 0;
-};
-
-
-//  Runs the states until a terminal one has acted. Returns its name. Fails through
-//  `trace` on an unexpected screen, a state seen too often, a stall or the timeout.
-template <typename ControllerContext>
-std::string run_screen_machine(
-    VideoStream& stream, ControllerContext& context, StepTrace& trace,
-    const std::vector<ScreenState>& states, Milliseconds timeout
-){
-    ScreenMachineChecks checks(trace);
-    const WallClock deadline = current_time() + timeout;
-    while (current_time() < deadline){
-        context.wait_for_all_requests();
-        VideoSnapshot frame;
-        const ScreenState& state = read_screen_state(stream, context, trace, states, frame);
-        trace.screen(state.name);
-        checks.check(state, std::move(frame));
-        state.act();
-        if (state.terminal){
-            context.wait_for_all_requests();
-            return state.name;
-        }
-    }
-    trace.fail("Did not finish within " + std::to_string(timeout.count() / 1000) + "s.");
-}
-
-
-
-}
-#endif
diff --git a/SerialPrograms/Source/CommonTools/ScreenMachine/StepTrace.cpp b/SerialPrograms/Source/CommonTools/ScreenMachine/StepTrace.cpp
deleted file mode 100644
index 246bac04a0..0000000000
--- a/SerialPrograms/Source/CommonTools/ScreenMachine/StepTrace.cpp
+++ /dev/null
@@ -1,74 +0,0 @@
-/*  Step Trace
- *
- *  From: https://github.com/PokemonAutomation/
- *
- */
-
-#include <cstdio>
-#include "Common/Cpp/PrettyPrint.h"
-#include "Common/Cpp/Filesystem/Filesystem.h"
-#include "CommonFramework/GlobalAutoPaths.h"
-#include "CommonFramework/Exceptions/OperationFailedExceptionWithScreenshot.h"
-#include "CommonFramework/VideoPipeline/VideoFeed.h"
-#include "StepTrace.h"
-
-namespace PokemonAutomation{
-
-
-StepTrace::StepTrace(VideoStream& stream, std::string label)
-    : m_stream(stream)
-    , m_label(std::move(label))
-    , m_folder(SCREENSHOTS_PATH() + "StepTrace/" + now_to_filestring() + "-" + m_label + "/")
-    , m_start(current_time())
-{
-    Filesystem::create_directories(Filesystem::Path(m_folder));
-    m_stream.log("[" + m_label + "] Trace screenshots: " + m_folder);
-}
-
-void StepTrace::screen(const std::string& name){
-    if (name == m_last){
-        return;
-    }
-    m_last = name;
-    m_recent.push_back(name);
-    if (m_recent.size() > 12){
-        m_recent.pop_front();
-    }
-    m_count++;
-    const double seconds = std::chrono::duration<double>(current_time() - m_start).count();
-    char prefix[16];
-    std::snprintf(prefix, sizeof(prefix), "%03zu-", m_count);
-    std::string path = m_folder + prefix + name + ".png";
-    VideoSnapshot screen = m_stream.video().snapshot();
-    if (screen){
-        screen.frame->save(path);
-    }else{
-        path = "(no video frame)";
-    }
-    m_stream.log("[" + m_label + "] screen " + std::to_string(m_count) + ": " + name +
-        " at " + tostr_fixed(seconds, 1) + "s, " + path);
-}
-
-void StepTrace::action(const std::string& what){
-    m_stream.log("[" + m_label + "] " + what);
-}
-
-std::string StepTrace::recent_screens() const{
-    std::string text;
-    for (const std::string& name : m_recent){
-        text += (text.empty() ? "" : " -> ") + name;
-    }
-    return text.empty() ? "(none)" : text;
-}
-
-void StepTrace::fail(const std::string& message) const{
-    OperationFailedExceptionWithScreenshot::fire(
-        ErrorReportMode::SEND_ERROR_REPORT,
-        m_label + ": " + message + " Recent screens: " + recent_screens() + ". Trace: " + m_folder,
-        m_stream
-    );
-}
-
-
-
-}
diff --git a/SerialPrograms/Source/CommonTools/ScreenMachine/StepTrace.h b/SerialPrograms/Source/CommonTools/ScreenMachine/StepTrace.h
deleted file mode 100644
index e0c4db09d0..0000000000
--- a/SerialPrograms/Source/CommonTools/ScreenMachine/StepTrace.h
+++ /dev/null
@@ -1,53 +0,0 @@
-/*  Step Trace
- *
- *  From: https://github.com/PokemonAutomation/
- *
- *  A step log for closed-loop routines: every change of recognized screen is
- *  logged and saved as a numbered screenshot, every input is logged, and a
- *  failure reports the screens that led up to it.
- *
- */
-
-#ifndef PokemonAutomation_CommonTools_StepTrace_H
-#define PokemonAutomation_CommonTools_StepTrace_H
-
-#include <deque>
-#include <string>
-#include "Common/Cpp/Time.h"
-#include "CommonFramework/Tools/VideoStream.h"
-
-namespace PokemonAutomation{
-
-
-class StepTrace{
-public:
-    //  Screenshots go to <Screenshots>/StepTrace/<time>-<label>/.
-    StepTrace(VideoStream& stream, std::string label);
-
-    //  Records the screen the routine recognized. Logs and saves a screenshot only
-    //  when it differs from the previous one.
-    void screen(const std::string& name);
-
-    //  Records an input or decision.
-    void action(const std::string& what);
-
-    //  The last few screens, oldest first, e.g. "dialog -> keyboard -> dialog".
-    std::string recent_screens() const;
-
-    //  Throws OperationFailedExceptionWithScreenshot with the recent screens appended.
-    [[noreturn]] void fail(const std::string& message) const;
-
-private:
-    VideoStream& m_stream;
-    std::string m_label;
-    std::string m_folder;
-    WallClock m_start;
-    size_t m_count = 0;
-    std::string m_last;
-    std::deque<std::string> m_recent;
-};
-
-
-
-}
-#endif
diff --git a/SerialPrograms/Source/ComputerPrograms/ComputerPrograms_UnitTestRunner.cpp b/SerialPrograms/Source/ComputerPrograms/ComputerPrograms_UnitTestRunner.cpp
index 5f485470cf..cde8df2162 100644
--- a/SerialPrograms/Source/ComputerPrograms/ComputerPrograms_UnitTestRunner.cpp
+++ b/SerialPrograms/Source/ComputerPrograms/ComputerPrograms_UnitTestRunner.cpp
@@ -5,7 +5,6 @@
  */
 
 #include "Common/Cpp/ListenerSet.h"
-#include "Common/Cpp/MoveOnlyFunction_Tests.h"
 #include "Common/Cpp/ScopeExit.h"
 #include "Common/Cpp/PrettyPrint.h"
 #include "Common/Cpp/TestRunners/TestImageDistortionManager.h"
@@ -54,7 +53,6 @@ UnitTestDatabase make_UNIT_TESTS_ALL(){
     add_tests_QtEventThreadPool(ret, GlobalThreadPools::computation_normal());
     add_tests_BlackBorderDetector(ret);
     add_tests_ListenerSet(ret);
-    add_tests_MoveOnlyFunction(ret);
     add_tests_AudioInfo(ret);
     add_tests_ChannelMixerMatrix(ret);
     add_tests_FFTStreamer(ret);
@@ -64,7 +62,6 @@ UnitTestDatabase make_UNIT_TESTS_ALL(){
     OCR::add_tests(ret);
     Kernels::add_tests(ret);
     Pokemon::add_tests_LegPlanner(ret);
-    Pokemon::add_tests_LegWalker(ret);
     NintendoSwitch::add_tests_CheckOnlineDetector(ret);
     NintendoSwitch::add_tests_FailedToConnectDetector(ret);
     NintendoSwitch::add_tests_UpdatePopupDetector(ret);
diff --git a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegWalker.cpp b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegWalker.cpp
deleted file mode 100644
index 40f082e2f8..0000000000
--- a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegWalker.cpp
+++ /dev/null
@@ -1,70 +0,0 @@
-/*  Leg Walker
- *
- *  From: https://github.com/PokemonAutomation/
- *
- */
-
-#include "Pokemon_LegWalker.h"
-
-namespace PokemonAutomation{
-namespace Pokemon{
-
-
-std::string to_string(const LegSpec& leg){
-    return std::string(direction_name(leg.direction)) + " " + std::to_string(leg.tiles)
-        + (leg.to_wall ? " (to wall)" : "");
-}
-
-
-Milliseconds leg_hold(const LegSpec& leg, int tiles){
-    if (leg.to_wall){
-        return leg.tile_time * (tiles + 2);
-    }
-    return leg.tile_time * (tiles - 1) + leg.tile_time / 2;
-}
-
-int tiles_before_interrupt(const LegSpec& leg, Milliseconds elapsed, Milliseconds detection_delay, int remaining){
-    const Milliseconds since_first_step = elapsed - detection_delay + leg.tile_time / 2;
-    if (since_first_step.count() <= 0){
-        return 0;
-    }
-    return std::clamp((int)(since_first_step / leg.tile_time), 0, remaining);
-}
-
-
-LegResult walk_leg_with(const LegSpec& leg, const LegCalls& calls, size_t max_interruptions){
-    LegResult result;
-    int remaining = leg.tiles;
-    while (true){
-        const std::optional<HoldOutcome> outcome = calls.hold_watching(leg_hold(leg, remaining));
-        if (!outcome){
-            result.tiles = leg.tiles;
-            return result;
-        }
-        result.interruptions++;
-        if (result.interruptions > max_interruptions){
-            calls.fail("Interrupted " + std::to_string(result.interruptions) + " times on: " + to_string(leg));
-        }
-        calls.clear(outcome->interrupt);
-        const std::string seen = calls.name(outcome->interrupt) + " after " + std::to_string(outcome->elapsed.count()) + "ms";
-        if (leg.to_wall){
-            //  The wall stops the player on the leg's last tile however far
-            //  they got, so the leg is simply held again.
-            calls.log(seen + ", walking to the wall again.");
-            continue;
-        }
-        const int walked = tiles_before_interrupt(leg, outcome->elapsed, calls.detection_delay(outcome->interrupt), remaining);
-        remaining -= walked;
-        result.exact = false;
-        calls.log(seen + ", about " + std::to_string(walked) + " tiles walked, " + std::to_string(remaining) + " to go.");
-        if (remaining <= 0){
-            result.tiles = leg.tiles;
-            return result;
-        }
-    }
-}
-
-
-
-}
-}
diff --git a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegWalker.h b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegWalker.h
deleted file mode 100644
index e8a9556e43..0000000000
--- a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegWalker.h
+++ /dev/null
@@ -1,209 +0,0 @@
-/*  Leg Walker
- *
- *  From: https://github.com/PokemonAutomation/
- *
- *  Walks one leg of a plan: holds a direction for the leg's tiles while
- *  watching for whatever can stop the player part-way (a wild battle, a
- *  message, a trainer). Each of those is a LegInterrupt the game supplies.
- *  When one shows, the hold stops, the game clears it, and the rest of the
- *  leg is walked: a leg to a wall is simply held again, since the wall stops
- *  the player on its tile; for an open leg, how far the player got is worked
- *  out from when the interrupt was seen.
- *
- *  How a direction is held (D-pad or stick) and how long a tile takes are
- *  the game's too, through LegMover. Templated on the console and the
- *  controller context, like run_until(), so this stays free of any one
- *  console's types.
- *
- */
-
-#ifndef PokemonAutomation_Pokemon_LegWalker_H
-#define PokemonAutomation_Pokemon_LegWalker_H
-
-#include <algorithm>
-#include <functional>
-#include <memory>
-#include <optional>
-#include <string>
-#include <vector>
-#include "Common/Cpp/MoveOnlyFunction.h"
-#include "Common/Cpp/Time.h"
-#include "CommonFramework/Exceptions/OperationFailedExceptionWithScreenshot.h"
-#include "CommonTools/Async/InferenceRoutines.h"
-#include "CommonTools/InferenceCallbacks/VisualInferenceCallback.h"
-#include "Pokemon_Grid.h"
-
-namespace PokemonAutomation{
-namespace Pokemon{
-
-
-//  Something that stops the player part-way through a leg.
-template <typename Console, typename Context>
-class LegInterrupt{
-public:
-    virtual ~LegInterrupt() = default;
-
-    virtual std::string name() const = 0;
-
-    //  A new watcher for the screen the interruption brings up.
-    virtual std::unique_ptr<VisualInferenceCallback> make_watcher() const = 0;
-
-    //  How long after the step that set it off the watcher fires. The games
-    //  only interrupt between steps, so from this the walker works out how
-    //  many tiles of an open leg were walked.
-    virtual Milliseconds detection_delay() const = 0;
-
-    //  Clears it, leaving the player standing on the overworld, on the same
-    //  tile and facing the same way.
-    virtual void clear(Console& console, Context& context) const = 0;
-};
-
-template <typename Console, typename Context>
-using LegInterrupts = std::vector<std::unique_ptr<LegInterrupt<Console, Context>>>;
-
-
-//  How the game moves the player: holds `direction` for `duration`, then
-//  lets go.
-template <typename Context>
-using LegMover = MoveOnlyFunction<void(Context& context, Direction direction, Milliseconds duration)>;
-
-
-//  A straight leg, for a player standing still and facing its way.
-struct LegSpec{
-    Direction direction = Direction::NORTH;
-    int tiles = 0;
-    //  A wall stops the player after the last tile.
-    bool to_wall = false;
-    //  How long one tile takes, for this leg's direction and way of moving.
-    Milliseconds tile_time{0};
-};
-std::string to_string(const LegSpec& leg);
-
-struct LegResult{
-    //  Tiles walked, which is `tiles` unless the leg gave up.
-    int tiles = 0;
-    //  Whether `tiles` is certain: an interrupted open leg is an estimate.
-    bool exact = true;
-    size_t interruptions = 0;
-};
-
-
-//  How long to hold for `tiles` tiles: an open leg lets go half a tile before
-//  the last step would end, so the step under way finishes and no other
-//  starts; a leg to a wall is held two tiles longer than it takes.
-Milliseconds leg_hold(const LegSpec& leg, int tiles);
-
-//  How many tiles an open leg had walked when an interrupt was seen
-//  `elapsed` into its hold, given the interrupt's detection delay. Steps end
-//  a whole number of tiles into the hold, so this rounds to the nearest.
-int tiles_before_interrupt(const LegSpec& leg, Milliseconds elapsed, Milliseconds detection_delay, int remaining);
-
-
-//  What one hold reported: nothing if it ran out, or which interrupt showed
-//  and how long into the hold.
-struct HoldOutcome{
-    size_t interrupt = 0;
-    Milliseconds elapsed{0};
-};
-
-//  The leg's bookkeeping, with the console side passed in, so it can be
-//  tested with scripted outcomes. `hold_watching` holds for the duration and
-//  reports the first interrupt seen; `clear` clears interrupt i;
-//  `detection_delay` is interrupt i's delay; `log` reports progress; `fail`
-//  throws, and is called after more than `max_interruptions`.
-struct LegCalls{
-    std::function<std::optional<HoldOutcome>(Milliseconds hold)> hold_watching;
-    std::function<void(size_t interrupt)> clear;
-    std::function<Milliseconds(size_t interrupt)> detection_delay;
-    std::function<std::string(size_t interrupt)> name;
-    std::function<void(const std::string& message)> log;
-    std::function<void(const std::string& message)> fail;
-};
-LegResult walk_leg_with(const LegSpec& leg, const LegCalls& calls, size_t max_interruptions);
-
-
-//  Walks `leg`. Throws OperationFailedException if it is interrupted more
-//  than `max_interruptions` times.
-template <typename Console, typename Context>
-LegResult walk_leg(
-    Console& console, Context& context,
-    LegMover<Context>& mover,
-    const LegInterrupts<Console, Context>& interrupts,
-    const LegSpec& leg,
-    size_t max_interruptions = 5
-){
-    auto hold_watching = [&](Milliseconds hold) -> std::optional<HoldOutcome>{
-        std::vector<std::unique_ptr<VisualInferenceCallback>> watchers;
-        std::vector<PeriodicInferenceCallback> callbacks;
-        for (const auto& interrupt : interrupts){
-            watchers.emplace_back(interrupt->make_watcher());
-            callbacks.emplace_back(*watchers.back());
-        }
-        context.wait_for_all_requests();
-        WallClock start = current_time();
-        const int ret = run_until<Context>(
-            console, context,
-            [&](Context& context){
-                start = current_time();
-                mover(context, leg.direction, hold);
-            },
-            callbacks
-        );
-        if (ret < 0){
-            return std::nullopt;
-        }
-        return HoldOutcome{(size_t)ret, std::chrono::duration_cast<Milliseconds>(current_time() - start)};
-    };
-    LegCalls calls;
-    calls.hold_watching = hold_watching;
-    calls.clear = [&](size_t index){ interrupts[index]->clear(console, context); };
-    calls.detection_delay = [&](size_t index){ return interrupts[index]->detection_delay(); };
-    calls.name = [&](size_t index){ return interrupts[index]->name(); };
-    calls.log = [&](const std::string& message){ console.log("Leg: " + message, COLOR_ORANGE); };
-    calls.fail = [&](const std::string& message){
-        OperationFailedExceptionWithScreenshot::fire(ErrorReportMode::SEND_ERROR_REPORT, message, console);
-    };
-    return walk_leg_with(leg, calls, max_interruptions);
-}
-
-
-//  After a leg: waits `watch` for an interrupt the last step set off, which
-//  shows after the hold has ended, and clears it. Throws
-//  OperationFailedException after `max_interruptions` in a row.
-template <typename Console, typename Context>
-void clear_late_interrupts(
-    Console& console, Context& context,
-    const LegInterrupts<Console, Context>& interrupts,
-    Milliseconds watch,
-    size_t max_interruptions = 5
-){
-    for (size_t count = 0; ; count++){
-        std::vector<std::unique_ptr<VisualInferenceCallback>> watchers;
-        std::vector<PeriodicInferenceCallback> callbacks;
-        for (const auto& interrupt : interrupts){
-            watchers.emplace_back(interrupt->make_watcher());
-            callbacks.emplace_back(*watchers.back());
-        }
-        context.wait_for_all_requests();
-        const int ret = wait_until(console, context, watch, callbacks);
-        if (ret < 0){
-            return;
-        }
-        if (count >= max_interruptions){
-            OperationFailedExceptionWithScreenshot::fire(
-                ErrorReportMode::SEND_ERROR_REPORT,
-                "Interrupted " + std::to_string(count) + " times in a row after a leg.",
-                console
-            );
-        }
-        console.log("Leg: " + interrupts[ret]->name() + " at the end of the leg.", COLOR_ORANGE);
-        interrupts[ret]->clear(console, context);
-    }
-}
-
-
-
-
-}
-}
-#endif
diff --git a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegWalker_Tests.cpp b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegWalker_Tests.cpp
deleted file mode 100644
index c0ef205267..0000000000
--- a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_LegWalker_Tests.cpp
+++ /dev/null
@@ -1,176 +0,0 @@
-/*  Leg Walker Tests
- *
- *  From: https://github.com/PokemonAutomation/
- *
- *  The leg walker's bookkeeping, with holds that report scripted
- *  interruptions instead of a console.
- *
- */
-
-#include <deque>
-#include <functional>
-#include <stdexcept>
-#include <string>
-#include <vector>
-#include "Common/Cpp/TestRunners/UnitTest.h"
-#include "Pokemon_LegWalker.h"
-#include "Pokemon_Navigation_Tests.h"
-
-namespace PokemonAutomation{
-namespace Pokemon{
-
-
-namespace{
-
-using namespace std::chrono_literals;
-
-constexpr Milliseconds TILE = 267ms;
-constexpr Milliseconds DELAY = 300ms;
-
-//  Holds that report the scripted outcomes in order, then run out.
-struct ScriptedLeg{
-    std::deque<std::optional<HoldOutcome>> outcomes;
-    std::vector<Milliseconds> holds;
-    std::vector<size_t> cleared;
-
-    LegCalls calls(){
-        LegCalls calls;
-        calls.hold_watching = [this](Milliseconds hold) -> std::optional<HoldOutcome>{
-            holds.push_back(hold);
-            if (outcomes.empty()){
-                return std::nullopt;
-            }
-            std::optional<HoldOutcome> outcome = outcomes.front();
-            outcomes.pop_front();
-            return outcome;
-        };
-        calls.clear = [this](size_t index){ cleared.push_back(index); };
-        calls.detection_delay = [](size_t){ return DELAY; };
-        calls.name = [](size_t){ return std::string("a battle"); };
-        calls.log = [](const std::string&){};
-        calls.fail = [](const std::string& message){ throw std::runtime_error(message); };
-        return calls;
-    }
-};
-
-//  An interrupt set off by step `step`, seen DELAY after it ends.
-HoldOutcome after_step(int step){
-    return HoldOutcome{0, TILE * step + DELAY};
-}
-
-
-UnitTestResult test_hold_times(){
-    const LegSpec open{Direction::EAST, 4, false, TILE};
-    const LegSpec wall{Direction::EAST, 4, true, TILE};
-    if (leg_hold(open, 4) != TILE * 3 + TILE / 2){
-        return "Open leg: " + std::to_string(leg_hold(open, 4).count()) + "ms";
-    }
-    if (leg_hold(wall, 4) != TILE * 6){
-        return "Wall leg: " + std::to_string(leg_hold(wall, 4).count()) + "ms";
-    }
-    return true;
-}
-
-UnitTestResult test_tiles_before_interrupt(){
-    const LegSpec leg{Direction::EAST, 8, false, TILE};
-    for (int step = 0; step <= 8; step++){
-        for (Milliseconds jitter : {-100ms, 0ms, 100ms}){
-            const int walked = tiles_before_interrupt(leg, TILE * step + DELAY + jitter, DELAY, 8);
-            if (walked != step){
-                return "Step " + std::to_string(step) + " seen " + std::to_string(jitter.count()) + "ms off read as " + std::to_string(walked);
-            }
-        }
-    }
-    if (tiles_before_interrupt(leg, 50ms, DELAY, 8) != 0){
-        return "An interrupt from before the leg should count no tiles.";
-    }
-    if (tiles_before_interrupt(leg, TILE * 20, DELAY, 3) != 3){
-        return "Should not count more tiles than remain.";
-    }
-    return true;
-}
-
-UnitTestResult test_wall_leg_walked_again(){
-    ScriptedLeg script;
-    script.outcomes = {after_step(2)};
-    const LegSpec leg{Direction::NORTH, 6, true, TILE};
-    const LegResult result = walk_leg_with(leg, script.calls(), 5);
-    if (script.holds.size() != 2 || script.holds[1] != leg_hold(leg, 6)){
-        return "Expected the whole leg held again.";
-    }
-    if (!result.exact || result.interruptions != 1 || script.cleared.size() != 1){
-        return "Expected an exact result after one interruption.";
-    }
-    return true;
-}
-
-UnitTestResult test_open_leg_rest_walked(){
-    ScriptedLeg script;
-    script.outcomes = {after_step(2)};
-    const LegSpec leg{Direction::NORTH, 6, false, TILE};
-    const LegResult result = walk_leg_with(leg, script.calls(), 5);
-    if (script.holds.size() != 2 || script.holds[1] != leg_hold(leg, 4)){
-        return "Expected the remaining 4 tiles held.";
-    }
-    if (result.exact){
-        return "An interrupted open leg is an estimate.";
-    }
-    return true;
-}
-
-UnitTestResult test_open_leg_interrupted_at_end(){
-    ScriptedLeg script;
-    script.outcomes = {after_step(6)};
-    const LegSpec leg{Direction::NORTH, 6, false, TILE};
-    walk_leg_with(leg, script.calls(), 5);
-    if (script.holds.size() != 1){
-        return "Nothing was left to walk after the last step.";
-    }
-    return true;
-}
-
-UnitTestResult test_too_many_interruptions(){
-    ScriptedLeg script;
-    for (int c = 0; c < 4; c++){
-        script.outcomes.push_back(after_step(0));
-    }
-    const LegSpec leg{Direction::NORTH, 6, true, TILE};
-    try{
-        walk_leg_with(leg, script.calls(), 3);
-    }catch (std::runtime_error&){
-        return true;
-    }
-    return "Expected to give up after 3 interruptions.";
-}
-
-
-class Test_LegWalker : public UnitTest{
-public:
-    Test_LegWalker(std::string name, std::function<UnitTestResult()> body)
-        : UnitTest("Pokemon::LegWalker - " + std::move(name))
-        , m_body(std::move(body))
-    {}
-    virtual UnitTestResult run(Logger&, CancellableScope&) const override{
-        return m_body();
-    }
-
-private:
-    std::function<UnitTestResult()> m_body;
-};
-
-}
-
-
-void add_tests_LegWalker(UnitTestDatabase& database){
-    database.add<Test_LegWalker>("hold times", test_hold_times);
-    database.add<Test_LegWalker>("tiles before an interrupt", test_tiles_before_interrupt);
-    database.add<Test_LegWalker>("a wall leg is walked again", test_wall_leg_walked_again);
-    database.add<Test_LegWalker>("an open leg walks the rest", test_open_leg_rest_walked);
-    database.add<Test_LegWalker>("an open leg interrupted at its end", test_open_leg_interrupted_at_end);
-    database.add<Test_LegWalker>("gives up after too many interruptions", test_too_many_interruptions);
-}
-
-
-
-}
-}
diff --git a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_MapSet.cpp b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_MapSet.cpp
deleted file mode 100644
index 533dc4f12f..0000000000
--- a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_MapSet.cpp
+++ /dev/null
@@ -1,102 +0,0 @@
-/*  Map Set
- *
- *  From: https://github.com/PokemonAutomation/
- *
- */
-
-#include <algorithm>
-#include "Common/Cpp/Exceptions.h"
-#include "Pokemon_MapSet.h"
-
-namespace PokemonAutomation{
-namespace Pokemon{
-
-
-void MapSet::add(std::string name, const TileGrid& grid, const TilePos& offset){
-    for (const Placed& placed : m_maps){
-        if (placed.name == name){
-            throw InternalProgramError(nullptr, PA_CURRENT_FUNCTION, "Map placed twice: " + name);
-        }
-        //  Map images show a border of trees past their edges, so two maps
-        //  may share blocked tiles, but nothing else.
-        for (int y = 0; y < grid.height(); y++){
-            for (int x = 0; x < grid.width(); x++){
-                const TilePos other{offset.x + x - placed.offset.x, offset.y + y - placed.offset.y};
-                if (!placed.grid.in_bounds(other)){
-                    continue;
-                }
-                if (grid.at({x, y}) != TileType::BLOCKED || placed.grid.at(other) != TileType::BLOCKED){
-                    throw InternalProgramError(
-                        nullptr, PA_CURRENT_FUNCTION,
-                        "Map " + name + " overlaps " + placed.name + " at its tile " + to_string(TilePos{x, y}) + "."
-                    );
-                }
-            }
-        }
-    }
-    m_maps.push_back(Placed{std::move(name), grid, offset});
-
-    //  Rebuild the joined grid.
-    TilePos low = m_maps[0].offset;
-    TilePos high = low;
-    for (const Placed& placed : m_maps){
-        low.x = std::min(low.x, placed.offset.x);
-        low.y = std::min(low.y, placed.offset.y);
-        high.x = std::max(high.x, placed.offset.x + placed.grid.width());
-        high.y = std::max(high.y, placed.offset.y + placed.grid.height());
-    }
-    m_origin = low;
-    std::vector<std::string> rows(high.y - low.y, std::string(high.x - low.x, tile_char(TileType::UNKNOWN)));
-    for (const Placed& placed : m_maps){
-        const std::vector<std::string> map_rows = placed.grid.rows();
-        for (size_t y = 0; y < map_rows.size(); y++){
-            rows[placed.offset.y - low.y + y].replace(placed.offset.x - low.x, map_rows[y].size(), map_rows[y]);
-        }
-    }
-    m_world.emplace(rows);
-}
-
-const TileGrid& MapSet::world() const{
-    if (!m_world){
-        throw InternalProgramError(nullptr, PA_CURRENT_FUNCTION, "No maps placed.");
-    }
-    return *m_world;
-}
-
-TilePos MapSet::to_world(const std::string& map, const TilePos& local) const{
-    for (const Placed& placed : m_maps){
-        if (placed.name == map){
-            return {
-                placed.offset.x - m_origin.x + local.x,
-                placed.offset.y - m_origin.y + local.y,
-            };
-        }
-    }
-    throw InternalProgramError(nullptr, PA_CURRENT_FUNCTION, "Unknown map: " + map);
-}
-
-std::optional<MapTile> MapSet::to_local(const TilePos& world) const{
-    for (const Placed& placed : m_maps){
-        const TilePos local{
-            world.x + m_origin.x - placed.offset.x,
-            world.y + m_origin.y - placed.offset.y,
-        };
-        if (placed.grid.in_bounds(local)){
-            return MapTile{placed.name, local};
-        }
-    }
-    return std::nullopt;
-}
-
-std::string MapSet::describe(const TilePos& world) const{
-    const std::optional<MapTile> local = to_local(world);
-    if (!local){
-        return "world " + to_string(world);
-    }
-    return local->map + " " + to_string(local->pos);
-}
-
-
-
-}
-}
diff --git a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_MapSet.h b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_MapSet.h
deleted file mode 100644
index 468213c481..0000000000
--- a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_MapSet.h
+++ /dev/null
@@ -1,63 +0,0 @@
-/*  Map Set
- *
- *  From: https://github.com/PokemonAutomation/
- *
- *  Several tile grids placed side by side on one world grid, so one plan
- *  can cross from a route into a town.
- */
-
-#ifndef PokemonAutomation_Pokemon_MapSet_H
-#define PokemonAutomation_Pokemon_MapSet_H
-
-#include <optional>
-#include <string>
-#include <vector>
-#include "Pokemon_TileGrid.h"
-
-namespace PokemonAutomation{
-namespace Pokemon{
-
-
-struct MapTile{
-    std::string map;
-    TilePos pos;
-};
-
-
-class MapSet{
-public:
-    //  Places `grid` with its tile (0,0) at `offset`. Offsets are relative to
-    //  each other and may be negative. Maps may overlap only where both are
-    //  blocked; the map placed first holds those tiles. Throws
-    //  InternalProgramError if the name is taken or the maps conflict.
-    void add(std::string name, const TileGrid& grid, const TilePos& offset);
-
-    //  The maps joined on one grid. Tiles no map covers are UNKNOWN. World
-    //  tile (0,0) is the top-left corner of all the maps together.
-    const TileGrid& world() const;
-
-    //  Throws InternalProgramError for an unknown map name.
-    TilePos to_world(const std::string& map, const TilePos& local) const;
-
-    //  The map that holds a world tile, or nothing between maps.
-    std::optional<MapTile> to_local(const TilePos& world) const;
-
-    //  "Route 201 (45,3)", or the world tile if no map holds it.
-    std::string describe(const TilePos& world) const;
-
-private:
-    struct Placed{
-        std::string name;
-        TileGrid grid;
-        TilePos offset;
-    };
-    std::vector<Placed> m_maps;
-    TilePos m_origin;   //  offset of world tile (0,0)
-    std::optional<TileGrid> m_world;
-};
-
-
-
-}
-}
-#endif
diff --git a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_Navigation_Tests.h b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_Navigation_Tests.h
index fa7fd8e612..5919dd56b2 100644
--- a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_Navigation_Tests.h
+++ b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_Navigation_Tests.h
@@ -14,7 +14,6 @@ namespace Pokemon{
 
 
 void add_tests_LegPlanner(UnitTestDatabase& database);
-void add_tests_LegWalker(UnitTestDatabase& database);
 
 
 
diff --git a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_TileGrid.cpp b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_TileGrid.cpp
deleted file mode 100644
index 74901f69a7..0000000000
--- a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_TileGrid.cpp
+++ /dev/null
@@ -1,503 +0,0 @@
-/*  Tile Grid
- *
- *  From: https://github.com/PokemonAutomation/
- *
- */
-
-#include <algorithm>
-#include <cstdlib>
-#include <functional>
-#include <limits>
-#include <map>
-#include <queue>
-#include <tuple>
-#include "Common/Cpp/Exceptions.h"
-#include "Pokemon_LegPlanner.h"
-#include "Pokemon_TileGrid.h"
-
-namespace PokemonAutomation{
-namespace Pokemon{
-
-
-char tile_char(TileType type){
-    switch (type){
-    case TileType::BLOCKED:     return '#';
-    case TileType::WALKABLE:    return '.';
-    case TileType::TALL_GRASS:  return '"';
-    case TileType::LEDGE:       return 'v';
-    case TileType::NPC:         return 'N';
-    case TileType::SIGN:        return 'S';
-    case TileType::DOOR:        return 'D';
-    case TileType::UNKNOWN:     return '?';
-    }
-    return '?';
-}
-
-
-
-
-TileGrid::TileGrid(const std::vector<std::string>& rows)
-    : m_width(rows.empty() ? 0 : (int)rows[0].size())
-    , m_height((int)rows.size())
-{
-    m_tiles.reserve((size_t)m_width * m_height);
-    for (size_t y = 0; y < rows.size(); y++){
-        const std::string& row = rows[y];
-        if ((int)row.size() != m_width){
-            throw InternalProgramError(
-                nullptr, PA_CURRENT_FUNCTION,
-                "Tile grid row " + std::to_string(y) + " has " + std::to_string(row.size()) +
-                " tiles, expected " + std::to_string(m_width) + "."
-            );
-        }
-        for (size_t x = 0; x < row.size(); x++){
-            switch (row[x]){
-            case '#':   m_tiles.push_back(TileType::BLOCKED);       break;
-            case '.':   m_tiles.push_back(TileType::WALKABLE);      break;
-            case '"':   m_tiles.push_back(TileType::TALL_GRASS);    break;
-            case 'v':   m_tiles.push_back(TileType::LEDGE);         break;
-            case 'N':   m_tiles.push_back(TileType::NPC);           break;
-            case 'S':   m_tiles.push_back(TileType::SIGN);          break;
-            case 'D':   m_tiles.push_back(TileType::DOOR);          break;
-            case '?':   m_tiles.push_back(TileType::UNKNOWN);       break;
-            default:
-                throw InternalProgramError(
-                    nullptr, PA_CURRENT_FUNCTION,
-                    std::string("Unknown tile '") + row[x] + "' at " +
-                    to_string(TilePos{(int)x, (int)y}) + "."
-                );
-            }
-        }
-    }
-}
-
-std::vector<std::string> TileGrid::rows() const{
-    std::vector<std::string> rows;
-    for (int y = 0; y < m_height; y++){
-        std::string row;
-        for (int x = 0; x < m_width; x++){
-            row += tile_char(at({x, y}));
-        }
-        rows.push_back(std::move(row));
-    }
-    return rows;
-}
-
-bool TileGrid::in_bounds(const TilePos& pos) const{
-    return 0 <= pos.x && pos.x < m_width && 0 <= pos.y && pos.y < m_height;
-}
-
-TileType TileGrid::at(const TilePos& pos) const{
-    if (!in_bounds(pos)){
-        return TileType::UNKNOWN;
-    }
-    return m_tiles[(size_t)pos.y * m_width + pos.x];
-}
-
-void TileGrid::set(const TilePos& pos, TileType type){
-    if (in_bounds(pos)){
-        m_tiles[(size_t)pos.y * m_width + pos.x] = type;
-    }
-}
-
-bool TileGrid::standable(const TilePos& pos) const{
-    const TileType type = at(pos);
-    return type == TileType::WALKABLE || type == TileType::TALL_GRASS;
-}
-
-std::optional<TilePos> TileGrid::step(const TilePos& from, Direction direction) const{
-    const TilePos next = from.next(direction);
-    if (standable(next)){
-        return next;
-    }
-    if (at(next) == TileType::LEDGE && direction == Direction::SOUTH){
-        const TilePos landing = next.next(direction);
-        if (standable(landing)){
-            return landing;
-        }
-    }
-    return std::nullopt;
-}
-
-bool TileGrid::at_wall(const TilePos& pos, Direction direction) const{
-    const TileType next = at(pos.next(direction));
-    return next != TileType::DOOR && next != TileType::UNKNOWN && !step(pos, direction).has_value();
-}
-
-
-
-WallHit walk_to_wall(const TileGrid& grid, const TilePos& from, Direction direction){
-    WallHit hit;
-    hit.stop = from;
-    while (true){
-        const TilePos before = hit.stop;
-        const std::optional<TilePos> next = grid.step(before, direction);
-        if (!next){
-            hit.wall = before.next(direction);
-            hit.anchored = grid.at_wall(before, direction);
-            return hit;
-        }
-        hit.tiles += std::abs(next->x - before.x) + std::abs(next->y - before.y);
-        hit.stop = *next;
-    }
-}
-
-
-
-std::string to_string(const TileLeg& leg){
-    return std::string(direction_name(leg.direction)) + " " + std::to_string(leg.tiles) +
-        (leg.ends_at_wall ? " (to wall)" : " (open)");
-}
-
-
-namespace{
-
-//  The grid's step rules for the shared leg planner. A ledge hop is one
-//  press that moves two tiles.
-class TileGridModel{
-public:
-    using State = TilePos;
-    using StateHash = std::hash<TilePos>;
-
-    TileGridModel(const TileGrid& grid, const TilePlanCosts& costs)
-        : m_grid(grid)
-        , m_costs(costs)
-    {}
-
-    std::optional<Step<State>> press(const State& pos, Direction direction) const{
-        const std::optional<TilePos> next = m_grid.step(pos, direction);
-        if (!next){
-            return std::nullopt;
-        }
-        Step<State> step;
-        step.next = *next;
-        step.facing = direction;
-        const int tiles = std::abs(next->x - pos.x) + std::abs(next->y - pos.y);
-        step.extra_cost = m_costs.per_tile * (tiles - 1);
-        if (m_grid.at(*next) == TileType::TALL_GRASS){
-            step.extra_cost += m_costs.per_grass_tile;
-        }
-        return step;
-    }
-    bool held_at(const State& pos, Direction direction) const{
-        return m_grid.at_wall(pos, direction);
-    }
-
-private:
-    const TileGrid& m_grid;
-    const TilePlanCosts& m_costs;
-};
-
-}
-
-std::optional<std::vector<TileLeg>> plan_tile_route(
-    const TileGrid& grid,
-    const TilePos& from, const TilePos& to,
-    const TilePlanCosts& costs
-){
-    if (!grid.standable(from) || !grid.standable(to)){
-        throw InternalProgramError(
-            nullptr, PA_CURRENT_FUNCTION,
-            "Route ends must be standable: " + to_string(from) + " -> " + to_string(to) + "."
-        );
-    }
-    if (from == to){
-        return std::vector<TileLeg>();
-    }
-    LegCosts leg_costs;
-    leg_costs.per_tile = costs.per_tile;
-    leg_costs.per_turn = costs.per_leg;
-    leg_costs.per_open_stop = costs.leg_not_at_wall;
-    const std::optional<std::vector<Leg<TilePos>>> legs = plan_legs(
-        TileGridModel(grid, costs), from, std::nullopt,
-        std::function<bool(const TilePos&)>([&](const TilePos& pos){ return pos == to; }),
-        std::nullopt, leg_costs
-    );
-    if (!legs){
-        return std::nullopt;
-    }
-    std::vector<TileLeg> ret;
-    for (const Leg<TilePos>& leg : *legs){
-        const size_t tiles = std::abs(leg.end.x - leg.start.x) + std::abs(leg.end.y - leg.start.y);
-        ret.push_back(TileLeg{leg.direction, tiles, leg.to_wall});
-    }
-    return ret;
-}
-
-std::vector<TilePos> sight_tiles(const TileGrid& grid, const TrainerSight& trainer){
-    std::vector<TilePos> tiles;
-    TilePos pos = trainer.pos;
-    for (int i = 0; i < trainer.range; i++){
-        pos = pos.next(trainer.facing);
-        if (!grid.standable(pos)){
-            break;
-        }
-        tiles.push_back(pos);
-    }
-    return tiles;
-}
-
-std::vector<std::vector<std::string>> legs_crossing_sight(
-    const TileGrid& grid,
-    const TilePos& from,
-    const std::vector<TileLeg>& legs,
-    const std::vector<TrainerSight>& trainers
-){
-    std::vector<std::vector<TilePos>> sights;
-    for (const TrainerSight& trainer : trainers){
-        sights.push_back(sight_tiles(grid, trainer));
-    }
-    std::vector<std::vector<std::string>> crossings;
-    TilePos pos = from;
-    for (const TileLeg& leg : legs){
-        const std::vector<TilePos> tiles = trace_legs(grid, pos, {leg});
-        std::vector<std::string> seen_by;
-        for (size_t t = 0; t < trainers.size(); t++){
-            for (size_t i = 1; i < tiles.size(); i++){
-                if (std::find(sights[t].begin(), sights[t].end(), tiles[i]) != sights[t].end()){
-                    seen_by.push_back(trainers[t].name);
-                    break;
-                }
-            }
-        }
-        crossings.push_back(std::move(seen_by));
-        pos = tiles.back();
-    }
-    return crossings;
-}
-
-std::vector<TilePos> trace_legs(
-    const TileGrid& grid,
-    const TilePos& from,
-    const std::vector<TileLeg>& legs
-){
-    std::vector<TilePos> tiles{from};
-    for (const TileLeg& leg : legs){
-        size_t travelled = 0;
-        while (travelled < leg.tiles){
-            const TilePos pos = tiles.back();
-            const std::optional<TilePos> next = grid.step(pos, leg.direction);
-            if (!next){
-                throw InternalProgramError(
-                    nullptr, PA_CURRENT_FUNCTION,
-                    "Leg " + to_string(leg) + " is stopped at " + to_string(pos) + "."
-                );
-            }
-            travelled += std::abs(next->x - pos.x) + std::abs(next->y - pos.y);
-            tiles.push_back(*next);
-        }
-        if (travelled != leg.tiles){
-            throw InternalProgramError(
-                nullptr, PA_CURRENT_FUNCTION,
-                "Leg " + to_string(leg) + " overshoots on a ledge hop."
-            );
-        }
-    }
-    return tiles;
-}
-
-
-
-std::string to_string(const PlannedLeg& leg){
-    std::string out = to_string(leg.leg) + " to";
-    for (const TilePos& pos : leg.after){
-        out += " " + to_string(pos);
-    }
-    return out;
-}
-
-namespace{
-
-//  Where `from` ends up after `tiles` steps in `direction`, stopping early at
-//  anything that stops the player. Nothing if a step would leave the map or
-//  enter a door: the plan cannot tell what happens then.
-std::optional<TilePos> step_tiles(
-    const TileGrid& grid, TilePos from, Direction direction, int tiles, int& grass
-){
-    int travelled = 0;
-    while (travelled < tiles){
-        const std::optional<TilePos> next = grid.step(from, direction);
-        if (!next){
-            if (!grid.at_wall(from, direction)){
-                return std::nullopt;
-            }
-            break;
-        }
-        travelled += std::abs(next->x - from.x) + std::abs(next->y - from.y);
-        if (grid.at(*next) == TileType::TALL_GRASS){
-            grass++;
-        }
-        from = *next;
-    }
-    return from;
-}
-
-using Spread = std::vector<TilePos>;
-
-bool spread_less(const TilePos& a, const TilePos& b){
-    return a.y != b.y ? a.y < b.y : a.x < b.x;
-}
-void normalize(Spread& spread){
-    std::sort(spread.begin(), spread.end(), spread_less);
-    spread.erase(std::unique(spread.begin(), spread.end()), spread.end());
-}
-struct SpreadLess{
-    bool operator()(const Spread& a, const Spread& b) const{
-        return std::lexicographical_compare(a.begin(), a.end(), b.begin(), b.end(), spread_less);
-    }
-};
-
-}
-
-std::optional<std::vector<PlannedLeg>> plan_robust_route(
-    const TileGrid& grid,
-    const TilePos& from, const TilePos& to,
-    const RobustPlanCosts& costs
-){
-    if (!grid.standable(from) || !grid.standable(to)){
-        throw InternalProgramError(
-            nullptr, PA_CURRENT_FUNCTION,
-            "Route ends must be standable: " + to_string(from) + " -> " + to_string(to) + "."
-        );
-    }
-    return plan_robust_route(grid, std::vector<TilePos>{from}, [&](const TilePos& pos){ return pos == to; }, costs);
-}
-
-std::optional<std::vector<PlannedLeg>> plan_robust_route(
-    const TileGrid& grid,
-    const std::vector<TilePos>& from, const std::function<bool(const TilePos&)>& goal,
-    const RobustPlanCosts& costs
-){
-    for (const TilePos& pos : from){
-        if (!grid.standable(pos)){
-            throw InternalProgramError(
-                nullptr, PA_CURRENT_FUNCTION,
-                "Route starts must be standable: " + to_string(pos) + "."
-            );
-        }
-    }
-    //  Only the start may be wider than costs.max_spread: every leg must bring
-    //  the player within it.
-    const size_t max_spread = costs.max_spread;
-    auto reached = [&](const Spread& spread){
-        return std::all_of(spread.begin(), spread.end(), goal);
-    };
-
-    struct Node{
-        long long cost;
-        Spread parent;
-        PlannedLeg leg;
-        bool done = false;
-    };
-    std::map<Spread, Node, SpreadLess> nodes;
-    using Entry = std::pair<long long, Spread>;
-    auto entry_greater = [](const Entry& a, const Entry& b){ return a.first > b.first; };
-    std::priority_queue<Entry, std::vector<Entry>, decltype(entry_greater)> queue(entry_greater);
-
-    Spread start = from;
-    normalize(start);
-    nodes[start] = Node{0, {}, {}};
-    queue.emplace(0, start);
-
-    auto relax = [&](const Spread& spread, long long cost, Spread next, PlannedLeg leg){
-        normalize(next);
-        if (next.size() > max_spread || next == spread){
-            return;
-        }
-        auto iter = nodes.find(next);
-        if (iter != nodes.end() && iter->second.cost <= cost){
-            return;
-        }
-        leg.after = next;
-        nodes[next] = Node{cost, spread, std::move(leg)};
-        queue.emplace(cost, std::move(next));
-    };
-
-    size_t searched = 0;
-    while (!queue.empty()){
-        const Entry top = queue.top();
-        queue.pop();
-        const long long cost = top.first;
-        const Spread& spread = top.second;
-        Node& node = nodes[spread];
-        if (node.done || node.cost != cost){
-            continue;
-        }
-        node.done = true;
-        if (++searched > costs.max_searched){
-            return std::nullopt;
-        }
-        if (reached(spread)){
-            std::vector<PlannedLeg> legs;
-            for (Spread at = spread; at != start; ){
-                const Node& step = nodes[at];
-                legs.push_back(step.leg);
-                at = step.parent;
-            }
-            std::reverse(legs.begin(), legs.end());
-            return legs;
-        }
-
-        for (Direction direction : ALL_DIRECTIONS){
-            //  To the wall: every position walks until stopped.
-            {
-                Spread next;
-                size_t longest = 0;
-                int grass = 0;
-                bool ok = true;
-                for (const TilePos& pos : spread){
-                    const WallHit hit = walk_to_wall(grid, pos, direction);
-                    if (!hit.anchored){
-                        ok = false;
-                        break;
-                    }
-                    int leg_grass = 0;
-                    step_tiles(grid, pos, direction, (int)hit.tiles, leg_grass);
-                    grass = std::max(grass, leg_grass);
-                    longest = std::max(longest, hit.tiles);
-                    next.push_back(hit.stop);
-                }
-                if (ok && longest > 0){
-                    const long long step = (long long)costs.per_leg +
-                        (long long)costs.per_tile * longest + (long long)costs.per_grass_tile * grass;
-                    relax(spread, cost + step, std::move(next), PlannedLeg{TileLeg{direction, longest, true}, {}});
-                }
-            }
-            //  Open: about `tiles` tiles, give or take `open_error`.
-            for (int tiles = 1; tiles <= costs.max_open_tiles; tiles++){
-                Spread next;
-                int grass = 0;
-                bool ok = true;
-                for (const TilePos& pos : spread){
-                    const int error = tiles <= costs.exact_open_tiles ? 0 : costs.open_error + tiles / costs.open_error_per;
-                    for (int n = std::max(1, tiles - error); n <= tiles + error; n++){
-                        int leg_grass = 0;
-                        const std::optional<TilePos> end = step_tiles(grid, pos, direction, n, leg_grass);
-                        if (!end){
-                            ok = false;
-                            break;
-                        }
-                        grass = std::max(grass, leg_grass);
-                        next.push_back(*end);
-                    }
-                    if (!ok){
-                        break;
-                    }
-                }
-                if (!ok){
-                    break;
-                }
-                const long long step = (long long)costs.per_leg + costs.leg_not_at_wall +
-                    (long long)(costs.per_tile + costs.per_open_tile) * tiles + (long long)costs.per_grass_tile * grass;
-                relax(spread, cost + step, std::move(next), PlannedLeg{TileLeg{direction, (size_t)tiles, false}, {}});
-            }
-        }
-    }
-
-    return std::nullopt;
-}
-
-
-
-}
-}
diff --git a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_TileGrid.h b/SerialPrograms/Source/Pokemon/Navigation/Pokemon_TileGrid.h
deleted file mode 100644
index 49837e77e9..0000000000
--- a/SerialPrograms/Source/Pokemon/Navigation/Pokemon_TileGrid.h
+++ /dev/null
@@ -1,191 +0,0 @@
-/*  Tile Grid
- *
- *  From: https://github.com/PokemonAutomation/
- *
- *  An overworld map as a grid of tiles, and a planner that turns a walk from
- *  one tile to another into straight legs. Timed stick holds drift by a tile;
- *  a leg that ends against a wall does not, because the player stops there
- *  however long the stick is held. The planner prefers such legs.
- */
-
-#ifndef PokemonAutomation_Pokemon_TileGrid_H
-#define PokemonAutomation_Pokemon_TileGrid_H
-
-#include <cstddef>
-#include <functional>
-#include <optional>
-#include <string>
-#include <vector>
-#include "Pokemon_Grid.h"
-
-namespace PokemonAutomation{
-namespace Pokemon{
-
-
-//  Legend of the ASCII rows a grid is parsed from.
-enum class TileType{
-    BLOCKED,        //  '#': trees, walls, items on the ground
-    WALKABLE,       //  '.': open ground and paths
-    TALL_GRASS,     //  '"': walkable, with wild encounters
-    LEDGE,          //  'v': crossed only southward, hopping to the tile past it
-    NPC,            //  'N': a standing NPC or trainer; blocks like a wall
-    SIGN,           //  'S': a sign; blocks like a wall
-    DOOR,           //  'D': walking into it enters a building
-    UNKNOWN,        //  '?': off the map; an exit or ground we have no map of
-};
-char tile_char(TileType type);
-
-class TileGrid{
-public:
-    //  Every row must have the same length and use only the legend's characters.
-    //  Throws InternalProgramError otherwise.
-    explicit TileGrid(const std::vector<std::string>& rows);
-
-    //  The grid as the ASCII rows it parses from.
-    std::vector<std::string> rows() const;
-
-    int width() const{ return m_width; }
-    int height() const{ return m_height; }
-    bool in_bounds(const TilePos& pos) const;
-
-    //  Out-of-bounds tiles read as UNKNOWN.
-    TileType at(const TilePos& pos) const;
-
-    //  Changes one tile, e.g. to block one found in the way on the console.
-    //  Out-of-bounds tiles are left alone.
-    void set(const TilePos& pos, TileType type);
-
-    //  Whether the player can stand on this tile.
-    bool standable(const TilePos& pos) const;
-
-    //  Where one step from `from` lands, or nothing if the player is stopped.
-    //  A south step onto a ledge hops to the tile past it.
-    std::optional<TilePos> step(const TilePos& from, Direction direction) const;
-
-    //  Whether a step from `pos` is refused by a tile that holds the player
-    //  in place. Doors and unknown tiles are not walls: walking into a door
-    //  enters the building, and unknown ground may be an exit.
-    bool at_wall(const TilePos& pos, Direction direction) const;
-
-private:
-    int m_width = 0;
-    int m_height = 0;
-    std::vector<TileType> m_tiles;
-};
-
-
-//  Where the player stops when walking in one direction until stopped.
-struct WallHit{
-    TilePos stop;
-    size_t tiles = 0;           //  tiles travelled; a ledge hop counts 2
-    TilePos wall;               //  the first tile the player could not enter
-    bool anchored = false;      //  the player is held at `stop` (see TileGrid::at_wall())
-};
-WallHit walk_to_wall(const TileGrid& grid, const TilePos& from, Direction direction);
-
-
-//  A straight run in one direction.
-struct TileLeg{
-    Direction direction;
-    size_t tiles = 0;           //  tiles travelled; a ledge hop counts 2
-    bool ends_at_wall = false;  //  the next tile in `direction` stops the player
-};
-std::string to_string(const TileLeg& leg);
-
-struct TilePlanCosts{
-    int per_tile = 1;
-    int per_grass_tile = 4;     //  extra for each tall-grass tile entered
-    int per_leg = 8;
-    int leg_not_at_wall = 50;   //  extra for a leg that stops in the open
-};
-
-//  Cheapest legs from `from` to `to`, moving 4 ways, or nothing if `to`
-//  cannot be reached. Both tiles must be standable.
-std::optional<std::vector<TileLeg>> plan_tile_route(
-    const TileGrid& grid,
-    const TilePos& from, const TilePos& to,
-    const TilePlanCosts& costs = TilePlanCosts()
-);
-
-//  A trainer sees the tiles in a straight line in front of them, up to
-//  `range` tiles or the first tile the player cannot stand on.
-struct TrainerSight{
-    std::string name;
-    TilePos pos;
-    Direction facing;
-    int range = 4;
-};
-std::vector<TilePos> sight_tiles(const TileGrid& grid, const TrainerSight& trainer);
-
-//  For each leg, the trainers whose sight line it enters.
-std::vector<std::vector<std::string>> legs_crossing_sight(
-    const TileGrid& grid,
-    const TilePos& from,
-    const std::vector<TileLeg>& legs,
-    const std::vector<TrainerSight>& trainers
-);
-
-//  The tiles a list of legs visits, starting with `from`. Throws
-//  InternalProgramError if a leg is stopped before its end.
-std::vector<TilePos> trace_legs(
-    const TileGrid& grid,
-    const TilePos& from,
-    const std::vector<TileLeg>& legs
-);
-
-
-//  A leg of a plan that allows for open legs going a tile short or long. A
-//  leg to a wall is walked until the player stops; an open leg is walked for
-//  `leg.tiles` tiles' worth of time. `after` lists every tile the player may
-//  stand on once the leg is done.
-struct PlannedLeg{
-    TileLeg leg;
-    std::vector<TilePos> after;
-};
-std::string to_string(const PlannedLeg& leg);
-
-struct RobustPlanCosts : TilePlanCosts{
-    //  An open leg of n tiles may end open_error + n / open_error_per tiles
-    //  short or long: on the console 7 tiles went 9.
-    int open_error = 1;
-    int open_error_per = 5;
-    //  Open legs this many tiles or shorter land exactly: a short hold moves
-    //  whole tiles. 0 keeps every open leg uncertain.
-    int exact_open_tiles = 0;
-    //  Extra per tile of an open leg: its timing error grows with its length,
-    //  so a short step after a wall beats a long open leg.
-    int per_open_tile = 0;
-    int max_open_tiles = 12;    //  longest open leg to consider
-    size_t max_spread = 5;      //  most tiles the player may be on after a leg
-    //  Most sets of possible tiles to search before giving up. The search is
-    //  over sets, not tiles, so it grows far faster than the map: all of
-    //  Jubilife City from six start tiles ran for minutes with no plan
-    //  (r224a, 2026-10-31); 200000 sets took 31 s there, so this gives up
-    //  after about 3. Use town costs in towns (a whole-Jubilife plan then
-    //  takes 1 s) and crop the map to the part a leg needs rather than
-    //  raising this.
-    size_t max_searched = 20000;
-};
-
-//  Cheapest legs that take the player from any of the tiles in `from` to tiles
-//  that are all `goal`, even if every open leg ends up to `open_error` tiles
-//  off: the walls of later legs must bring the possible positions together.
-//  Legs that would leave the map or enter a door are not used. Nothing if no
-//  such plan exists, or none is found within `costs.max_searched` sets.
-std::optional<std::vector<PlannedLeg>> plan_robust_route(
-    const TileGrid& grid,
-    const std::vector<TilePos>& from, const std::function<bool(const TilePos&)>& goal,
-    const RobustPlanCosts& costs = RobustPlanCosts()
-);
-//  The same, from one tile to exactly `to`.
-std::optional<std::vector<PlannedLeg>> plan_robust_route(
-    const TileGrid& grid,
-    const TilePos& from, const TilePos& to,
-    const RobustPlanCosts& costs = RobustPlanCosts()
-);
-
-
-
-}
-}
-#endif
diff --git a/SerialPrograms/cmake/SourceFiles.cmake b/SerialPrograms/cmake/SourceFiles.cmake
index 0d62a31b0c..c650d0494d 100644
--- a/SerialPrograms/cmake/SourceFiles.cmake
+++ b/SerialPrograms/cmake/SourceFiles.cmake
@@ -118,9 +118,6 @@ file(GLOB CORE_LIBRARY_SOURCES
     ../Common/Cpp/Logging/MultiOutputLogger.h
     ../Common/Cpp/Logging/TaggedLogger.cpp
     ../Common/Cpp/Logging/TaggedLogger.h
-    ../Common/Cpp/MoveOnlyFunction.h
-    ../Common/Cpp/MoveOnlyFunction_Tests.cpp
-    ../Common/Cpp/MoveOnlyFunction_Tests.h
     ../Common/Cpp/Options/BatchOption.cpp
     ../Common/Cpp/Options/BatchOption.h
     ../Common/Cpp/Options/BooleanCheckBoxOption.cpp
@@ -886,10 +883,6 @@ file(GLOB LIBRARY_SOURCES
     Source/CommonTools/Options/TrainOCRModeOption.h
     Source/CommonTools/Resources/SpriteDatabase.cpp
     Source/CommonTools/Resources/SpriteDatabase.h
-    Source/CommonTools/ScreenMachine/ScreenMachine.cpp
-    Source/CommonTools/ScreenMachine/ScreenMachine.h
-    Source/CommonTools/ScreenMachine/StepTrace.cpp
-    Source/CommonTools/ScreenMachine/StepTrace.h
     Source/CommonTools/StartupChecks/StartProgramChecks.cpp
     Source/CommonTools/StartupChecks/StartProgramChecks.h
     Source/CommonTools/StartupChecks/VideoResolutionCheck.cpp
@@ -1445,14 +1438,7 @@ file(GLOB LIBRARY_SOURCES
     Source/Pokemon/Navigation/Pokemon_Grid.h
     Source/Pokemon/Navigation/Pokemon_LegPlanner.h
     Source/Pokemon/Navigation/Pokemon_LegPlanner_Tests.cpp
-    Source/Pokemon/Navigation/Pokemon_LegWalker.cpp
-    Source/Pokemon/Navigation/Pokemon_LegWalker.h
-    Source/Pokemon/Navigation/Pokemon_LegWalker_Tests.cpp
-    Source/Pokemon/Navigation/Pokemon_MapSet.cpp
-    Source/Pokemon/Navigation/Pokemon_MapSet.h
     Source/Pokemon/Navigation/Pokemon_Navigation_Tests.h
-    Source/Pokemon/Navigation/Pokemon_TileGrid.cpp
-    Source/Pokemon/Navigation/Pokemon_TileGrid.h
     Source/Pokemon/Options/Pokemon_BoxSortingTable.cpp
     Source/Pokemon/Options/Pokemon_BoxSortingTable.h
     Source/Pokemon/Options/Pokemon_EncounterBotOptions.h