Serpent AI Strategy Study: From Shortest Paths to Pressure Control

0. Problem redefinition: from a small game to a dynamical system

At first, I thought Serpent was a Snake variant: eat objects, avoid obstacles, survive as long as possible. That description is not wrong, but it is too shallow.

Once Greedy, A*, Lookahead, NoGrow, TailGuard, Depth-2, and MinLength strategies were tested, the game stopped looking like a simple “which AI scores higher” exercise. It exposed a structure: score grows, length grows, size perturbs geometry, walls and hazards trim the body, and timeout forces the system to eat periodically.

So the real question is not “how do we get a high score?” It is: what is the correct long-term control variable in Serpent?

The answer is not simply length, and it is not simply size. The right aggregate variable is:

1. Mathematical abstraction of the game rules

1.1 State variables

Let the current game state be:

The code constants translate directly into constraints: MAX_SIZE = 3, no-progress death at NO_PROGRESS_TIMEOUT = 30000ms, normal food gives +10, a big bonus gives +50, hazards give -20, obstacle score costs are -5/-10/-15, and obstacle segment losses are 1/1/2.

1.2 Action variables

On each tick, the agent directly controls direction:

At the strategy level, however, it is choosing between action types:

2. Basic resource equations

2.1 Length equation

Over a time window, let F be normal-food count, B bonus count, W1/W2/W3 wall-hit counts, and H hazard count. The nominal length change is:

But the game has a crucial lower bound:

So the actual trimming is:

This is why a one-segment snake does not get shortened further by walls or hazards. That is not a minor implementation detail; it is one of the reasons small-length steady states can exist.

2.2 Score equation

If obstacle type is treated as a random variable, obstacle probabilities are:

The expected score cost of a random wall hit is:

The expected segment loss of a random wall hit is:

So the expected cost per trimmed segment is approximately:

Therefore:

2.3 Timeout constraint

The snake dies after 30 seconds without eating, so:

In long-term strategies, food is not only a score source. It is also a survival clock reset. If average food interval is T_food, then:

In practice the strategy needs margin:

Walls and hazards do not reset τ. The long-run loop must include food or bonus. Walls and hazards can trim pressure, but they cannot keep the game clock alive.

3. Geometric pressure: the real control variable

Early analysis only tracked N = length. That is necessary, but insufficient. In Serpent, each segment occupies more cells as size grows.

Define approximate geometric pressure:

A more exact version is:

Because thick adjacent segments overlap, Nq² is an upper bound or proxy rather than exact occupied area. But it captures the essential fact: the same length is not the same state under different sizes.

3.1 Wall trimming efficiency at different sizes

A random wall hit trims 1.15 segments in expectation. If size is q, expected geometric area removed is:

Expected score cost remains about 8, so cost per cleared geometric cell is:

3.2 Steady-state conditions

The mature long-term target is not N ≤ constant. It is:

The control objective becomes:

4. L1–L17: strategy evolution and implementation details

Each strategy level is not just a version number. It is a problem redefinition. The improvement is not that the code becomes more complicated; it is that the objective function becomes closer to the real structure of the game.

open_set: priority queue ordered by f(n)=g(n)+h(n)
g(n): actual path length from the head to cell n
h(n): Manhattan distance to the target
blocked: snake body + non-passable obstacles
neighbors: four directions, with wrap-around if the engine allows it

def safe_to_eat(game, food):
    path = astar(game.head, food.position, game.blocked_cells)
    if not path:
        return False

    future = simulate(game, path)
    return bfs_reachable(future.head, future.tail, future.blocked_cells)

def cell_cost(cell):
    if cell.is_empty:
        return 1
    if cell.is_fragile_wall:
        return 1 + wall_weight * 5
    if cell.is_brick_wall:
        return 1 + wall_weight * 10
    if cell.is_iron_wall:
        return 1 + wall_weight * 15
    return INF

def food_score(food, game):
    if food.type == "big_reward":
        return -INF       # NoGrow-Strict
    return 10 - distance_penalty(food)

def reachable_area(game, start):
    queue = [start]
    visited = {start}
    while queue:
        cell = queue.pop()
        for nxt in neighbors(cell):
            if nxt not in visited and not blocked(nxt):
                visited.add(nxt)
                queue.append(nxt)
    return len(visited)

def choose_food_tailguard(game):
    candidates = []
    for food in visible_foods(game):
        path = astar(game.head, food.position, game)
        if not path:
            continue
        future = simulate_path(game, path)
        if can_reach_tail(future):
            candidates.append((food, path, evaluate(food, path, future)))
    return best(candidates)

if timeout_soon:
    seek_safe_food_or_bonus()
elif pressure_high:
    trim_by_wall_or_hazard()
elif pressure_low:
    take_profitable_food()
else:
    safe_wander_or_follow_tail()

5. Hazard correction

A hazard has this effect:

So its cost per trimmed segment is:

Hazards are not high-quality trimming resources. Their value is emergency relief: they cut two segments at once, and they can substitute for walls if no safe wall is nearby.

6. L18: theoretical design for PressureControl-Profit

The next strategy should not be called MinLength-Profit. A more accurate name is:

Objective:

6.1 State machine

LOW_PRESSURE:
  eat normal food freely
  take a big bonus if its path is safe and reward is worth the pressure shock

MEDIUM_PRESSURE:
  prefer normal food
  avoid big bonus unless timeout pressure is high

HIGH_PRESSURE:
  stop taking rewards
  seek fragile/iron walls for trimming
  use hazard as emergency trimming

TIMEOUT_PRESSURE:
  ignore pressure temporarily; eat the nearest safe food or bonus

RECOVERY_AFTER_BONUS:
  if size just increased, immediately reduce pressure

6.2 Per-action value function

The pressure weight λ should increase with current pressure:

The higher pressure gets, the more the controller should value trimming. When pressure is low, it can afford to eat and profit.

6.3 Action valuation

A hazard is only worth eating when λ is large: when pressure is high enough that emergency trimming matters more than the score penalty.

7. Nine problem redefinitions

The real value of this research cycle is that it did not stop at “which AI scored higher.” It kept asking: what is the long-term dynamical system inside this game?

8. What can be claimed, and what cannot

8.1 Weak proposition: Serpent admits long-run positive-return pressure-controlled strategies

Under the following conditions:

1. The agent can find normal food or a bonus before τ<30s is violated;
2. The agent can find walls or hazards as trimming resources at finite cost;
3. The agent controls pressure so that P=Nq² stays near an upper bound;
4. q≤3, so size is bounded;
5. Obstacles and hazards do not create a permanent unreachable dead state.

Then simulation evidence and positive expected-value accounting support strategies with:

In plain language: as long as the controller can keep bringing geometric pressure back into the safe region, score can keep drifting upward.

8.2 The stronger theorem we cannot claim yet

We cannot honestly claim:

The reasons are concrete: map generation is random; food, bonus, and hazard locations can be bad for a while; the agent is not doing perfect dynamic programming; timeout is a hard constraint; size 3 reduces reachability; true occupied cells are more complex than Nq²; and wall-collision accounting may still need calibration.

9. Replay citation review

The article does not embed all 22 recordings. It uses selected replays as evidence for specific claims.

The remaining recordings stay in the replay library as appendices. Long-run or clipped recordings such as L8/L9/L10/L13 should not be cited as final-score proof; they are better used as supplementary strategy evidence.