Dan Demole
Game design doc · rev 0 · Godot 4 · GDScript · macOS native Not started

Potato Run

An original, family-friendly, top-down pixel-art RPG. You inherit an aging horse ranch outside a small rural village and build it back up: ride, train, breed and show horses, farm, explore the forest, and get to know the town. Cozy like a farming sim, with a much deeper horse and show-jumping simulation at its center.

640 × 360
internal resolution, scaled to window
8
core game systems
4
development phases
9+
target player age
Phase 1
first goal: a horse that feels good to ride
The idea

A ranch game where the horses matter

Most farming games treat a horse as a faster way to cross the map. In Potato Run every horse is a persistent individual with its own genetics, training history, temperament and condition. How it performs over a fence depends on all of those plus how well you ride it. No horse is good at everything.

Pillar 1

Riding that feels good

Four gaits, momentum and turning radius, and handling that changes horse to horse. This has to be fun before anything else gets built.

Pillar 2

Skill-based jumping

Approach, rhythm, takeoff distance and timing decide whether a fence goes clean, a rail comes down, or the horse says no.

Pillar 3

Horses as individuals

Genetic potential and trained ability are separate. Breeding builds bloodlines over generations.

Pillar 4

Design your own courses

Build arenas, place fences, set heights, number the course, save it and ride it against the clock.

Pillar 5

A living ranch and town

Farming, seasons, weather, day and night, village neighbors, festivals and shows.

Pillar 6

Family friendly

Readable controls for kids 9 and up. Outdoor adventure instead of combat. Light, age-appropriate stories.

Originality rule: inspired by the cozy feel of games like Stardew Valley, but every character, piece of art and asset is original. Nothing is copied from any existing game.

Setting

The world around the ranch

The player inherits a run-down horse ranch outside Potato Run, a small rural village. The world has seasons, weather, a day and night cycle, and progress that persists.

Home

Homestead

Farmhouse, stables, paddocks, garden and workshop.

Training

Equestrian grounds

Outdoor arenas, riding trails and training facilities.

Town

Village

Shops, the vet, the farrier, neighbors’ homes and festivals.

Outdoors

Forest

Riding trails, archery, camping, fishing and places to find.

Competition

Fairgrounds

Horse shows, racing and competitions.

Look

Visual direction

Warm, natural colors and cozy, detailed top-down pixel art. Distinct seasons, readable horse animations, pixel-perfect scaling where practical.

System 1

Horse simulation

Each horse has four layers of data. Genetics set the ceiling, training moves a horse toward it, condition changes day to day, and identity carries the history.

LayerAttributesChanges how
IdentityName, age, sex, breed, coat, markings, pedigree, breeding history, ownership, competition recordSet at birth or purchase; record grows over time
GeneticSpeed, acceleration, stamina, strength, jumping scope, jumping technique potential, agility, conformation, temperament, trainabilityFixed for life; passed to foals with variation
DevelopedJumping skill, flatwork, responsiveness, fitness, confidence, discipline specialization, rider bondTraining and riding, capped by genetics
ConditionEnergy, health, stress, happiness, fatigueDay to day: work, rest, feed, care
System 2

Riding

Top-down, eight-direction control. Walk, trot, canter and gallop, with acceleration, deceleration, momentum and a turning radius that tightens or widens with gait. Each horse handles a little differently.

KeyAction
W A S D or arrowsSteer
ShiftChange gait
SpaceJump
EMount or dismount
System 3

Hunter / jumper

Jumping is interactive. Every fence is judged on what the rider did and what the horse is capable of.

Inputs

What each fence evaluates

  • Approach angle
  • Speed and rhythm
  • Takeoff distance and player timing
  • Horse scope, technique and confidence
  • Fence height and width
  • Landing and recovery
Outcomes

What can happen

  • Clean jump
  • Knocked rail
  • Refusal
  • Runout
  • Poor landing
Hunter classes

Judged on rhythm, smoothness, consistency and overall quality of the round.

Jumper classes

Judged on faults, clear rounds, time and jump-offs.

Competition rules are configuration, not code, so new classes can be added without rewriting the scoring.

System 4

Course builder

Players build their own outdoor arenas and design hunter and jumper courses. Courses are stored as structured data, not hand-built scenes.

First version
  • Enter and exit build mode
  • Place, remove and rotate fences
  • Set fence heights
  • Vertical, crossrail and oxer
  • Numbered course order
  • Save, load and ride a course
  • Time and faults recorded
Later
  • Combinations and related distances
  • Decorative fillers
  • Terrain and footing
  • Course difficulty rating
  • Hunter course design
  • Cross-country fences
  • Multiple arena sizes
System 5

Breeding

The long game. Pick a sire and dam, keep pedigrees, and raise foals that inherit traits with some variation. Coat color follows simplified inheritance rules. Foals get their own look and temperament, then have to be raised and trained. Over several generations a player can build a bloodline that suits one discipline.

Design rule: inheritance is probabilistic with adjustable parameters. It should feel believable, not be a genetics textbook.

Systems 6 to 8

Ranch, outdoors and town

System 6

Farming and ranch

  • Seasonal crops: plant, water, harvest
  • Farm animals
  • Build and upgrade structures
  • Stables, paddocks and feed
  • Sell goods; earn from training and shows
System 7

Outdoor adventure

  • Archery practice and competitions
  • Trail riding and exploration
  • Camping and fishing
  • Hidden places and treasure maps
  • Foraging and seasonal finds

No combat at the center of the game.

System 8

Neighbors

  • Villagers with daily schedules
  • Dialogue and friendship
  • Gifts, quests and festivals
  • Light, age-appropriate romance
  • Optional marriage between adult characters
Roadmap

Four phases, riding first

  1. Phase 1 · next

    First playable riding prototype

    One small outdoor arena, one rider, one horse, one adjustable fence. Mount and dismount, four gaits, eight-direction movement with momentum, simple jump timing and clearance, and clear feedback for clean jumps and knocked rails.

  2. Phase 2

    Equestrian gameplay

    Several horses with different attributes, more fence types and heights, course-building mode, numbered courses, faults and timing, basic jumper competitions, save and load.

  3. Phase 3

    Horse depth

    Training and progression, temperament, fitness and condition, breeding and genetics, pedigrees, foals, buying and selling horses.

  4. Phase 4

    Living world

    Expandable homestead, farming, the village and its people, relationships, archery, camping, forest exploration, seasons and festivals.

Phase 1 sketch

The first arena

takeoff window vertical, adjustable height approach outdoor arena, rail fence 640 × 360 logical screen
Concept only. Exact arena size, fence placement and takeoff window will be tuned in play.

Phase 1 is done when

  • The game launches natively on a Mac.
  • The player can mount the horse and ride.
  • Riding feels clearly different from walking.
  • The player can approach and jump the fence.
  • Jumps produce outcomes a player understands: clean, or a knocked rail.
  • Nothing blocks play, and the player can immediately try again.

Jump rules start simple. Phase 1 uses deterministic rules so results are predictable while the feel is tuned. The model leaves room for genetics, training and rider skill to feed in later.

Out of scope for Phase 1: inventory, farming, breeding, NPCs and world maps.

Technical

Stack

AreaChoice
PlatformmacOS native, Apple Silicon
EngineGodot 4.x
LanguageGDScript
Graphics2D top-down pixel art; 640 × 360 internal resolution scaled to the window
ModeSingle-player, offline to start
ArtConsistent placeholder pixel art, swapped for final art later
DevelopmentAI coding agents (Claude Code, Cursor) with me as creative director and architect
Version controlGit
Working rules

Instructions for the AI coding agents

  1. Working, playable features before infrastructure.
  2. Never build a custom engine or an unneeded framework.
  3. Use Godot’s own scenes, nodes, resources and signals.
  4. Keep systems modular and data-driven.
  5. Work in small, testable steps.
  6. Leave the project runnable after every feature.
  7. Run Godot’s headless validation when it’s available.
  8. Use placeholder art instead of waiting on final art.
  9. No new dependencies without a reason.
  10. Don’t build future features early.
  11. Write down architectural decisions that matter.
  12. Keep controls and play accessible to kids 9 and up.
Layout

Planned project structure

Folders are created only when something needs them.

potato-run/
├── PROJECT.md
├── project.godot
├── scenes/     world · horses · arenas · obstacles · ui
├── scripts/    player · horses · riding · jumping · courses · systems
├── resources/  horses · obstacles · courses
├── assets/     sprites · tilesets · animations · audio
├── tests/
└── docs/
Before and during Phase 1

Open questions

Riding feel

High

Everything rests on the horse being fun to ride. Gait speeds, acceleration and turning will need many rounds of play-testing, not one pass.

Jump readability

High

A kid has to understand why a rail came down. Feedback on distance and timing needs to be obvious without reading numbers.

Top-down jumping

Med

A straight-down camera hides height. The arc, shadow and landing need to sell the jump in 2D.

Art pipeline

Med

Placeholder art keeps things moving, but the eventual style, tile size and horse animation set need deciding before Phase 2 content grows.

Scope

Med

Eight systems is a lot. The phase gates exist to keep each one from starting before the last is fun.

Godot setup

Low

Confirm the installed Godot 4.x version on the Mac and whether headless validation runs from the command line.

© 2026 Dan Demole