You vs You

The better you play, the harder it hunts you.

Comment 3

You vs You

Inspiration

Mario taught us platformers. Geometry Dash taught us memorization and rhythm. Both reward mastery: you grind the pattern until it clicks.

We wanted to break that.

What if the pattern never stabilized? What if every time you started to master it, the game noticed and changed on you?

You vs You takes the tight movement feel of those games and adds one twist: the level is built around you. Specifically, it adapts based on what you have been doing wrong.

Not randomly harder. Personally harder, because it has been watching.

What It Does

You vs You is a canvas platformer where an AI opponent studies your playstyle across every run and adapts the next level to counter it.

Core Features

  • Behavioural telemetry: every jump, crouch, route choice, and death is recorded and modelled.
  • Player profiling: the AI tracks jump/crouch bias, reaction timing, route preference, risk style, and consistency.
  • Adaptive level generation: levels are built around your weaknesses. If you always jump at decision points, ceilings appear after them. If gaps keep killing you, more gaps appear.
  • Real-time trap mutations: a trap director arms obstacles mid-run based on where you are headed and what you have done before.
  • AI taunts: the game tells you exactly what it learned and what it is doing about it.
    • Example: "You always crouch at choices. I placed spikes after them."
  • Shop and abilities: earn coins to buy abilities like fireballs that let you fight back.

How We Built It

You vs You was built entirely in TypeScript on a raw HTML5 Canvas, with no game engine.

Core Systems

  • playerAnalyzer.ts — derives a PlayerModel from a rolling window of recent runs, including jump frequency, route confidence, reaction timing, and risk profile.
  • adaptiveGenerator.ts — a segment-based level composer that takes the player model and targets weaknesses in generated geometry.
  • aiTrapDirector.ts — a per-frame state machine that arms and mutates obstacles based on predicted player trajectory and route preference.
  • runTracker.ts + telemetry.ts — structured event capture for every meaningful player action.
  • debugPanel.ts — live diagnostics showing active trap, route confidence, mutation counts, and AI reasoning.

Architecture

The game architecture enforces strict separation between systems:

telemetry → model → generation → runtime traps → render

Fairness vs. Counterplay

Making the AI genuinely adversarial without generating impossible levels was difficult. Every mutation goes through safety validation:

  • No closing all paths
  • No traps inside the player hitbox
  • No impossible jump gaps

Confidence Thresholds

The model needs enough data before acting. With too few runs, the AI generates noise instead of meaningful adaptation.

We tuned the rolling window and confidence floors so adaptation feels earned, not random.

Collision-Visual Parity

Every hazard drawn must collide exactly as it looks. Invisible kills or pass-through solids break trust immediately.

We spent significant time ensuring collision and visuals matched one-to-one.

Making Adaptation Feel Readable

Players needed to feel like the AI was responding to them, not just making the game harder.

AI taunt messages and the debug panel were critical to closing that feedback loop.

Accomplishments That We're Proud Of

  • Built a genuinely reactive AI that generates different levels for different playstyles.
  • Created meaningful variation where two players with opposite habits see different games.
  • Added per-obstacle interaction stats, so the AI knows which specific obstacles killed the player and how many times.
  • Built a full shop and ability system, including a fireball ability that gives players tools to fight back.
  • Built the entire game with zero game engine: raw canvas, raw physics, raw everything.

What We Learned

Adaptive AI in games is mostly a feedback loop problem.

The hard part is not the ML. The hard part is making the adaptation legible to the player so they feel countered rather than punished.

Every hour spent on debug visibility and AI taunts paid off more than time spent on the model itself.

We also learned that fairness constraints are non-negotiable. The first version had no safety checks, which meant the AI could lock players out entirely.

Adding validation that guarantees at least one valid route is what made it feel like a game instead of a bug.

What's Next for You vs You

  • Deeper ability system: more shop items, cooldowns, and player-side counterplay mechanics.
  • Cloud profiles: persist behavioural models across sessions so the AI remembers you between plays.
  • Multiplayer: share your behavioural profile as an AI opponent that other players can fight.
  • Harder AI phases: multi-run meta-strategies where the AI baits a habit across several runs, then punishes it later.
  • Mobile support: touch controls and responsive canvas support.

Built With

Share this project:

Updates