Skip to content

Pong in Plantangenet

Pong is the clearest small example of what Plantangenet is trying to be: not just a game, and not just a physics engine, but a deterministic world that can be observed, replayed, and driven by different kinds of agents.

This document explains what Pong means inside the Plantangenet architecture and why the ball and paddles matter as modeling choices, not just game objects.

The Short Version

Inside Plantangenet, Pong is a proof domain.

It demonstrates that the same infrastructure can support:

  • a deterministic physical world
  • a stable observation surface for agents
  • replayable sessions and TAS tooling
  • KNAT publication for external consumers
  • multiple kinds of controllers for the same in-world actor

That last point is the important one.

In this system, a paddle is not tied to one input source. The same paddle can be driven by:

  • a human
  • a TAS replay
  • a creature that invents future frames from past ones

Pong is useful because the domain is tiny, but the architectural question is large.

The Core Pipeline

Plantangenet separates world mechanics from what an agent sees and from what outside tools consume.

Legestics world
    -> coordinator step(act)
    -> chem observation
    -> KNAT projection
    -> session recording / replay / external consumers

In Pong, that means:

  • the physics world updates body positions and collisions
  • the coordinator produces a deterministic per-tick observation
  • the KNAT layer publishes stable named subjects
  • adapters and schemas make the run recordable and replayable

The value of Pong is that each layer stays visible.

What the Ball Is

The ball is best understood as a runway emitter.

It is not a mind. It does not choose. It does not evaluate margins. It does not care.

The ball simply:

  • moves
  • reflects
  • preserves deterministic physics
  • exposes a future that other agents can read from its current position and velocity

That makes the ball a good example of a pure world object. In creature terms, it is closer to a Rezz object than an actor. Its trajectory is the authoritative projected future.

If the system publishes subjects like:

  • knat.game.ball.x
  • knat.game.ball.y
  • knat.game.ball.vx
  • knat.game.ball.vy

then any consumer can treat the ball as a readable runway.

What the Paddle Is

The paddle is different.

The paddle is not primarily an object. It is a site of control.

Architecturally, the interesting question is not "what sprite is this?" but "who is producing this paddle's action for the next tick?"

That producer can take several forms.

1. Human-Driven Paddle

A human can observe KNAT or another input surface and produce actions in real time.

In that framing, the paddle is a human-controlled body inside a deterministic world.

2. TAS-Driven Paddle

A replay script can emit the next action from precommitted keyframes.

In that framing, the paddle is a body being driven by a recorded intention stream.

3. Creature-Driven Paddle

A local creature can observe the ball, compute local margins, choose a mode, commit for a short window, and emit the next action.

In that framing, the paddle becomes the smallest possible experiment in situated agency.

The world stays deterministic. The difference is in the source of the action.

Why the Creature Plans Matter

The current creature sketches sharpen an important distinction.

Intrinsic Margins vs. Relational Margins

The broader creature-margin plan distinguishes between:

  • intrinsic margins projected by the coordinator, such as vitality, exertion, and fear
  • relational margins computed locally by the agent, such as alignment, cohesion, and separation

For Pong, the second category is the useful one.

A paddle creature does not need a full survival model. It does need local interpretive signals such as:

  • alignment: how far it is from the predicted intercept
  • separation: how urgent the intercept is
  • cohesion: whether the play remains in the paddle's active region

That is enough to support a minimal finite-state controller like:

  • TRACK
  • INTERCEPT
  • HOLD

with a short commitment window to prevent frame-by-frame jitter.

This keeps the paddle simple and legible. If it starts to feel alive, the reason is visible in the margins and the commitment logic rather than hidden inside a larger opaque planner.

Why Pong Fits the Classic-Games Plan

The classic-games work is proving that Plantangenet can host more than the original Inferno escape simulation.

Pong is the first full demonstration because it exercises the whole stack:

  • deterministic simulation
  • domain-specific schema registration
  • adapter-based session recording and replay
  • KNAT publication
  • room for multiple agent types over the same world

That means Pong is not just "another game added to the repo." It is the first compact proof that the architecture can carry a classic game domain without special-casing the toolkit around it.

What Is Already Working

At the time of writing, the Pong integration already has most of the pipeline in place:

  • classic physics is wired through the toolkit traits
  • Pong has a frame schema and adapter
  • Pong sessions can be recorded and decoded through the TAS helpers
  • KNAT projection is wired through the classic simulation path
  • named KNAT subjects are published for ball and paddles
  • determinism tests and integration tests are passing

This means Pong is already consumable through both generic and semantic KNAT surfaces.

What Comes Next

The next immediate step is straightforward:

  • add a creature controller that reads named ball runway subjects and emits paddle actions

Examples:

  • knat.game.ball.x
  • knat.game.ball.y
  • knat.game.paddle.left.y
  • knat.game.paddle.right.y

Once that surface exists, three different controllers become natural without changing the simulation core:

  1. TAS playback
  2. human control via KNAT-facing tools
  3. creature control via local margin evaluation

That is the real point of Pong in Plantangenet.

It is a tiny world where we can cleanly separate:

  • what reality is doing
  • what the agent can see
  • who is choosing the next action

If that separation holds in Pong, it becomes much easier to trust it in larger future domains.

Takeaway

In Plantangenet Pong:

  • the ball is a deterministic runway emitter
  • the paddle is a controllable body whose next action may come from a human, a TAS, or a creature
  • the architecture matters because it keeps those roles interchangeable without changing the world model

That makes Pong more than a toy example. It is the first readable experiment in Plantangenet's larger claim: a shared deterministic world can host many forms of agency, as long as the seams between physics, observation, and action stay explicit.