Research code-drawn expressive characters
Transcript
Thinking21:37:57
I should research this properly, so I'll need to load the WebSearch and WebFetch tools through ToolSearch first.
ToolSearch (select:WebSearch,WebFetch)
Thinking21:38:00
I'll search the web for information on each game individually, then pull it all together into the report.
WebSearchPikuniku character design circle legs animation Sectordub interview21:38:06Output not recorded
Pikuniku character design circle legs animation Sectordub interviewWebSearchBit.Trip Runner CommanderVideo character design rectangle stick limbs21:38:06Output not recorded
Bit.Trip Runner CommanderVideo character design rectangle stick limbsWebSearchBoxBoy Qbby character design HAL Laboratory square legs interview21:38:06Output not recorded
BoxBoy Qbby character design HAL Laboratory square legs interviewWebSearchN++ Metanet ninja vector animation wall slide jump GDC talk stick figure21:38:06Output not recorded
N++ Metanet ninja vector animation wall slide jump GDC talk stick figureWebSearchRain World slugcat procedural animation GDC talk Joar Jakobsson21:38:06Output not recorded
Rain World slugcat procedural animation GDC talk Joar JakobssonWebSearchThomas Was Alone rectangle character personality animation postmortem21:38:06Output not recorded
Thomas Was Alone rectangle character personality animation postmortemThinking21:38:16
These are solid leads. I want to dig deeper into specifics: Rain World's GDC talk on limb IK and pole/ledge handling, whether N++ uses frame-based or procedural animation, BoxBoy's hanging and pushing poses, and Pikuniku's kicking and grabbing mechanics. I should also check out other games like Poinpy, Alto's Odyssey, Getting Over It, and Wuppo, plus look into stick figure ledge-grab implementations in Pico-8 or Love2D for procedural 2D IK examples.
WebFetchhttps://www.metanetsoftware.com/2014/n-on-the-move21:38:18Output not recorded
https://www.metanetsoftware.com/2014/n-on-the-moveWebFetchhttps://www.gameanim.com/2017/07/24/rain-world-animation-process/21:38:18Output not recorded
https://www.gameanim.com/2017/07/24/rain-world-animation-process/WebSearchBoxBoy Qbby hanging ledge push animation pose square eyes21:38:18Output not recorded
BoxBoy Qbby hanging ledge push animation pose square eyesWebSearchPikuniku kick animation legs grab rope how character works Alan Zucconi21:38:18Output not recorded
Pikuniku kick animation legs grab rope how character works Alan ZucconiWebSearchstick figure ledge grab wall slide Pico-8 procedural animation devlog21:38:18Output not recorded
stick figure ledge grab wall slide Pico-8 procedural animation devlogWebSearchprocedural 2D character animation simple limbs 2-bone IK blog tutorial21:38:18Output not recorded
procedural 2D character animation simple limbs 2-bone IK blog tutorialThinking21:38:35
I should try the Rain World GDC write-up on gamedeveloper.com, look for the YouTube video description via search, and find another way into the N++ animation blog post since the direct link isn't working. It's also worth checking whether Derek Yu discussed character silhouette readability for Spelunky, and looking at what Celeste's developers said too.
Let me search Metanet's old blog posts about their vector-based ninja animation, possibly through web archive, and also gather more references from Poinpy, Alto's Odyssey, Getting Over It, Wuppo, and Stick Fight.
WebSearchPoinpy character design Devolver Digital shape simple21:38:41Output not recorded
Poinpy character design Devolver Digital shape simpleWebFetchhttps://www.gamedeveloper.com/art/video-animating-i-rain-world-i-and-its-many-squishy-stretchy-creatures21:38:41Output not recorded
https://www.gamedeveloper.com/art/video-animating-i-rain-world-i-and-its-many-squishy-stretchy-creaturesWebSearch"N++" OR "N game" Metanet ninja "vector" animation frames ragdoll physics limbs devblog21:38:41Output not recorded
"N++" OR "N game" Metanet ninja "vector" animation frames ragdoll physics limbs devblogWebSearchGetting Over It Bennett Foddy character design pot simple shapes hammer21:38:41Output not recorded
Getting Over It Bennett Foddy character design pot simple shapes hammerThinking21:38:55
The Getting Over It character seems less relevant since it's an illustrated torso rather than shape-primitive body construction, though worth a brief mention. I want to dig deeper into N++'s ragdoll setup with its particles and sticks, and also look for Metanet's style blog archives discussing limb animation and poses like wall slides.
I'm also considering Alto's Odyssey (silhouette-based, not really shape primitives, so skip or mention briefly), Wuppo, and Stick Fight's ragdoll physics for its stick-figure character design, while Untitled Goose Game and similar non-shape-based games can be skipped. For Rain World I need a better source than what I've found so far—something like a full Gameanim blog post with real technical detail on the two-circle character model, so I'll search for that content directly.
WebSearchMetanet "style blog" ninja animation poses wall jump run cycle vector21:39:00Output not recorded
Metanet "style blog" ninja animation poses wall jump run cycle vectorWebSearchWuppo character design blob simple shapes indie21:39:00Output not recorded
Wuppo character design blob simple shapes indieWebSearchStick Fight The Game character design ragdoll physics stick figure21:39:00Output not recorded
Stick Fight The Game character design ragdoll physics stick figureWebSearch"Rain World" slugcat "two circles" body procedural animation IK reaching poles21:39:00Output not recorded
"Rain World" slugcat "two circles" body procedural animation IK reaching polesThinking21:39:10
Wuppo is hand-drawn rather than shape-based, so I'll set it aside, but Stick Fight is genuinely a stick figure with ragdoll physics, which is relevant. I think I have enough good examples now, though I still want to dig into the original N game's ragdoll and movement animation more concretely, so I'll search for its devlog on ninja limb physics.
I should also check Alto's Odyssey, though it's likely silhouette-based rather than primitive shapes, so I may skip it, and verify BoxBoy's hanging/pushing mechanics through the Siliconera article and HAL documentary link. Once I nail down N's wall-slide and running pose specifics along with Rain World's pole-reaching IK, I'll compile everything into the final report within the roughly 2000-word limit.
WebFetchhttps://en.wikipedia.org/wiki/N_(video_game)21:39:13Output not recorded
https://en.wikipedia.org/wiki/N_(video_game)WebSearch"N++" ninja "wall slide" OR "wall jump" pose animation ragdoll ubbink21:39:13Output not recorded
"N++" ninja "wall slide" OR "wall jump" pose animation ragdoll ubbinkThinking21:39:22
I don't have much more specific detail beyond the ragdoll model with particles and sticks, vector shapes, and thin sprite outlines. That's enough to work with: N/N++ uses a physics-based ragdoll skeleton for death animations, while the standard run/jump/wall-slide animations are likely a small set of vector frame poses drawn over the physics body, following Metanet's known art style. I'll describe this at a general level.
I've gathered good material now, so I'll compile a comprehensive report organized by game, with a cross-game comparison section, keeping it under 2000 words and including source URLs.
Research: Shape-Built, State-Readable 2D Platformer Characters
Pikuniku (Sectordub, 2019)
Piku is a red bean/oval body with two black dot eyes, no mouth, and two long, independently-posable legs — no arms, no separate head piece (the "head" is just the top of the body-oval). The legs are the entire animation vocabulary: they extend to walk, splay for a kick, stretch and hook onto anchor points to lasso/grapple and swing on hooks/zip-lines, and retract fully into the body so Piku becomes a plain circle that rolls or sinks to swim. Because there's no rigid separate limb skeleton, all "states" are readable purely through leg pose and length: legs-down = standing, legs mid-swing = walking, legs gone = rolling, one leg thrust out and stiff = kicking, a leg stretched taut to a fixed point = grappling. Team members (De Bock, Forcadell, Zucconi, Bowen) haven't published a detailed animation-tech breakdown; programmer Alan Zucconi (alanzucconi.com) worked on the game but his site's Pikuniku tag mostly covers a devlog/PR angle, not rig internals. Relevant for your controller states: walk/stand/jump are trivial leg-pose swaps; there's no crouch/ledge/wall-slide equivalent since Piku has no arms to hang with — its "grab" analog (leg-lasso) is the closest precedent for a rope-climb/ledge-hang readability trick (a single limb visibly latched and taut communicates "attached").
Sources: Pikuniku - Wikipedia, Piku - Pikuniku Wiki, Sectordub press sheet, Alan Zucconi - Pikuniku tag
BoxBoy! / Qbby (HAL Laboratory, 2015)
Qbby is a flat white square with two small black square eyes and two thin legs; no arms at all (his "hands" are the boxes he generates). Per HAL's own documentary and the Siliconera writeup, the design was function-first: square body so he can visually match the boxes he creates, feet so he can move/jump, eyes purely to indicate facing direction (confirmed explicitly by the devs — the eyes exist only to disambiguate left vs. right, nothing more). Character designer Itou reportedly spent extra effort specifically on leg posing/timing to inject comedic personality into an otherwise blank square, adjusting line thickness and whether to add color, while director Mukae had originally treated the design as a placeholder. States read almost entirely through leg pose plus the box appendages: walking/jumping is leg animation; hanging from a ledge and climbing is shown by Qbby gripping via a chain of generated boxes rather than an arm; pushing/pulling reads through the boxes leaning or extending, not through Qbby's own limbs bending. This is a strong precedent for your project's crouch/stand/jump states (torso-square + 2 leg lines is enough), but it offloads "grab/ledge/hang" onto an external prop (the box) rather than solving it with a body pose — worth noting as a technique that avoids needing an arm-hang pose at all.
Sources: Siliconera - The Art Of Making A Square Come Alive, HAL Laboratory "Documentary! The BOXBOY! Project", GoNintendo - HAL shares entire design process, Engadget interview
CommanderVideo, Bit.Trip Runner (Choice Provisions/Gaijin Games)
CommanderVideo is a black rectangle torso with thin, spindly pixel-line arms and legs and a small rectangular white "visor" set perpendicular to the body (his only face element). The design deliberately evokes Atari 2600-era abstraction — even simpler than 8-bit aesthetics. Because Runner is an auto-runner, his whole state vocabulary (run, jump, slide, kick) is conveyed through limb-line angle changes on the fixed rectangle torso: sliding = torso tilts low with legs swept back, kick = one stick-leg thrust forward stiffly, jump = legs tucked. Notably, for Runner2 the team experimented with rendering him as a bendier 3D rectangular-body/human-limb hybrid, but reverted to the flatter, stick-limbed 2D-style look because the bendy 3D version had rendering problems — an explicit case of a "more articulated" design being rejected in favor of the more legible rigid-rectangle-plus-stick-limb look.
N / N++ (Metanet Software)
The ninja is rendered as clean vector shapes/strokes (no bitmap sprite frames) over a physics skeleton. For the original N, the underlying dynamics model Metanet used was reported as a "6-particle + 5-stick" system — i.e., a small particle/constraint ragdoll, not a full humanoid bone rig — which is what produces the game's famous floppy ragdoll death animations. Metanet ran a separate "Style Blog" (art) and "Dev Blog" (tech) documenting this, and Mare Sheppard/Raigan Burns have spoken (e.g., GDC 2016, "Empowering the Player: Level Design in N++") mainly about level design rather than character rig internals, so exact confirmation of whether live poses (running, wall-slide, wall-jump) are procedurally derived from that same particle skeleton or drawn as a small set of vector key-poses blended by code wasn't independently verifiable from available public write-ups — treat the "procedural vs. frame-based" distinction for live gameplay poses as unconfirmed pending Metanet's own blog archives (metanetsoftware.com), which returned 403/inaccessible during this research. What is confirmed and useful: the ninja is a minimal stick/vector figure whose momentum-driven physics feel (long turn time, wall-jump chains for vertical momentum) is itself part of what the visual has to sell — the near-abstract stick-body keeps the eye on trajectory/momentum rather than pose detail.
Sources: N++ Development Update - Metanet, N v2.0 public beta - Metanet, Thumbsticks - GDC 2016: The secret to N++ level design, Metanet Software press sheet
Rain World's Slugcat (Videocult) — the key procedural-animation precedent
This is the most directly applicable precedent for a Spelunky-style controller with many limb-dependent states. Per animator Joar Jakobsson's GDC 2016 talk ("Animation Bootcamp: Rain World's Animation Process," with James Therrien/James Primate), Slugcat's body is two spherical "chunks" locked to each other at a fixed distance, giving a simple squash/rotate torso; the limbs and tail are cosmetic additions layered on top and are procedurally animated purely from player input and physics, not from a hand-authored animation set — there is no sprite sheet and no mocap/artist-keyframed clip library. Jakobsson has said he didn't set out to build "procedural animation" as a technique for its own sake — he was simply given the problem of making limbs move, and since code is how things move in a game, code became the solution. This is exactly the 2-circle-body-plus-procedural-limb model your outline is aiming for: the body communicates weight/orientation while limbs (drawn as simple segments) reach, grip poles, and drape over ledges dynamically rather than through named animation states. Follow-up Unity blog coverage of Rain World: The Watcher confirms the successor game deepened this same procedural-limb/IK approach.
Sources: GDC Vault - Animation Bootcamp: 'Rainworld' Animation Process, YouTube - The Rain World Animation Process, Game Developer - Video: Animating Rain World, Unity - Exploring procedural design in Rain World: The Watcher, GameAnim summary
Thomas Was Alone (Mike Bithell, 2012)
Pure axis-aligned rectangles, no limbs, no face — state and personality are conveyed entirely through squash/stretch deformation and color/size. Each rectangle contracts on jump takeoff and expands/squishes on landing, "as if muscles were tightening," and every character (tall/thin John, squat Chris, flat trampoline-like Laura) has a size-and-proportion-coded ability plus a unique landing/leap deformation curve — narration supplies the rest of the "state" reading (sad, proud, scared) that shape alone can't carry. This is the clearest evidence that squash-and-stretch timing alone, with zero limbs, can differentiate jump/fall/land states, though it doesn't scale to ledge-hang/wall-slide/crouch-type states that need visible limb contact.
Sources: PopMatters - Rectangles Are People Too, Nicolle Lamerichs - Why Players Empathize with Cubes, Thomas Was Alone - Wikipedia
Stick Fight: The Game (Landfall, 2017)
A direct callback to Newgrounds/Stickpage-era stick-figure shorts: pure colored stick figures (line-segment limbs, no torso mass) driven by a full ragdoll physics engine. Every "state" here is emergent from physics rather than authored poses — falls, hits, and recoil all display as ragdoll flail — which is a useful counter-example: pure line-stick figures read great for chaotic/comedic physical states but are weak for deliberately readable, controller-driven states like a held ledge-hang or crouch, since there's no fixed "rest silhouette" to anchor a pose against.
Getting Over It with Bennett Foddy (2017) — limited relevance
Diogenes (torso-in-a-pot) is closer to a simple illustrated bust than a primitive-shape rig — only the pot is a clean primitive (an ellipse/cauldron shape); the torso/arm holding the hammer is a small illustrated sprite, not built from rectangles/circles. Useful only as a note that minimalism can work with an illustrated-but-shape-adjacent upper body atop a literal geometric-primitive lower "state" (stuck in a pot = crouch-like immobility conveyed by the container shape alone).
Others checked but not strong precedents
Poinpy (Moppin/Devolver) is an illustrated dinosaur sprite, not primitive-shape-built. Wuppo is hand-drawn. Alto's Odyssey uses a flat silhouette rather than composited primitives. No public procedural-2D-IK Pico-8/TIC-80/LÖVE devlog with an explicit ledge-grab/wall-slide stick character was found in this pass beyond generic 2-bone-IK tutorials (Little Polygon's "Two-bone solving" blog and WeaverDev's procedural animation tutorial), which are general-purpose IK math references, not shape-character case studies.
Sources: Little Polygon - Procedural Animation: Inverse Kinematics, WeaverDev Procedural Animation Tutorial
Cross-game synthesis
Common construction pattern: almost every successful shape-only character splits into (1) a single blob/rectangle/box "core" that carries weight, squash-stretch, and orientation, and (2) a small number of separately posable limb elements (2 legs is the near-universal minimum; arms are frequently omitted entirely — Piku and Qbby have none). Eyes (1–2 dots) are the single most common face element and in BoxBoy's case exist purely to disambiguate facing, not expression. None of these characters separate the head as its own hinged part — it's either fused to the body (Piku, Qbby, CommanderVideo) or absent (Thomas, Stick Fight's stick head is just a circle cap).
Which states each precedent actually demonstrates as readable, mapped to your 13:
- Stand/walk/run: all of them (leg-line or leg-pair animation on a fixed torso).
- Jump/fall: Thomas Was Alone (squash on takeoff/stretch on fall) and CommanderVideo (leg tuck) are the cleanest shape-only precedents.
- Crouch: BoxBoy (compressed square + bent legs) and Thomas-style squash are the closest analogs.
- Wall slide / wall jump: best (if under-documented) precedent is N/N++'s physics-stick ninja; no fully confirmed public breakdown of its exact pose logic was found, so treat as directionally useful only.
- Ledge hang / climb up / lower off ledge: BoxBoy solves this by growing a prop (box-chain) rather than posing an arm; Rain World is the only precedent with genuine limb-reach IK toward a ledge/pole, confirmed via the GDC talk.
- Rope climb: Pikuniku's leg-lasso-and-swing on hooks/zip-lines is the nearest analog — a single limb visibly taut against an anchor point reads as "attached/climbing."
- Hurt/dead: N's particle-ragdoll death and Stick Fight's ragdoll are the strongest precedents for a instantly-legible "loss of control" state via physics flop rather than a drawn pose.
Overall takeaway for your character: given the very small on-screen size (roughly 1/15 screen height, 14×19px hitbox), the Rain World two-circle-body-plus-procedural-limb approach and the BoxBoy/Pikuniku "torso + 1–2 posable leg lines, no arms, 2 dot eyes for facing" approach are the two most transferable models — both keep part-count extremely low (a torso shape, 2 legs, optional 1 arm for hang states, 2 eye dots) while still hitting most of your 13 states through limb-angle/length changes and torso squash rather than through added detail that would be lost at this resolution and swallowed by the outline/shadow silhouette treatment.