🏃 SOLSTICE: Shift Time, Reshape the World (June Solstice Game Jam Entry)

Source: Dev.to

This is a submission for the June Solstice Game Jam

Disclaimer: This project was built with Google Gemini throughout: game code, level design, debugging, and this writeup. I directed the concept, reviewed output, and iterated until it played fair; Gemini did the heavy lifting on implementation and polish.

What I Built

SOLSTICE is a browser puzzle platformer about the moment the year stops turning.

You play as the Sunkeeper. The longest day has frozen halfway between dawn and dusk. The only way forward is to shift time between Day and Night. That is not a visual filter. It rewires the level. Sun blocks hold you up in daylight and vanish at night. Moon blocks are ghost platforms until you flip to darkness. Water kills you under the sun and becomes walkable ice when the stars come out.

The campaign is five levels that teach the rules one beat at a time, ending at the great Solstice Shrine. After that you can drop into Endless Mode, where the game keeps serving new realms forever.

I built it for the solstice theme on purpose. Light and dark are not just palette swaps here. They are the puzzle. Every jump, every collectible, the exit asks you to read the world twice and pick the right phase of time.

You can try it inline below. For the best experience, play the standalone web version. Keyboard focus, audio, and the Gemini AI settings panel all behave more reliably outside the embed.

Play it now (recommended): https://longphanquangminh.github.io/SOLSTICE-jump/

No install. Click once on the canvas if the keyboard feels dead, then go.

Quick reference

Tile Day Night

S Sun block Solid Vanishes

M Moon block Invisible Solid (shift to reveal stairs)

W Water / Ice Deadly water Walkable ice

# Stone Solid Solid

^ Spikes Deadly Deadly

o Sun mote Collect Collect

E Solstice Shrine Exit Exit

Controls: ←/→ or A/D to move · Space/W to jump · Shift/J/F to flip time · Enter to start · E for Endless Mode from the title screen · R to restart · M to mute

Video Demo

▶ Direct link: https://www.youtube.com/watch?v=u7lJvqdN9Y8

The clip walks through the core loop: run, jump, collect sun motes, hit Shift to flip the world, reach the Shrine. You will see the gold day palette snap into indigo night, moon stairs appearing out of nowhere, and a frozen river turning from hazard into a bridge.

Raw capture in the repo: jump.wmv

Code

SOLSTICE — A Game of Light & Time

Play now: https://longphanquangminh.github.io/SOLSTICE-jump/

A browser-based 2D puzzle-platformer built for the DEV June Solstice Game Jam 2026. You are the Sunkeeper. On the longest day of the year, time has stalled between day and night. Use SHIFT TIME (Day ↔ Night) to reshape the world, collect sun motes, and light the Solstice Shrines to restore the cycle.

Demo

▶ YouTube — SOLSTICE gameplay

Original video file in the repo: jump.wmv

How to Play

Press SHIFT to flip time — the physical world changes with the light/dark phase:

Tile Day Night

S Sun-block Solid Vanishes

M Moon-block Invisible / not standable Solid (hidden stairs — SHIFT to reveal)

W Water / Ice Deadly water Walkable ice

# Stone Solid in both phases Solid in both phases

^ Spikes Always deadly Always deadly

o Sun mote Collectible Collectible

E Solstice Shrine Level exit

…

Repo: https://github.com/longphanquangminh/SOLSTICE-jump

The whole game lives in a single index.html. Canvas 2D, fixed timestep physics, tile maps, WebAudio synth, the Gemini client, and the level validator all ship in one file so GitHub Pages can host it with zero build step.

SOLSTICE-jump/
├── index.html      # The entire game (HTML + CSS + JS)
├── jump.wmv        # Gameplay demo video
├── README.md
└── working-doc.md  # Dev notes

Enter fullscreen mode


Exit fullscreen mode

How I Built It

I started with one question: what if changing time changed geometry?

From there I worked iteratively with Gemini: describing mechanics, getting code back, playtesting, and sending fixes until the game felt right. Levels are ASCII grids. # is stone. S and M are phase locked blocks. W is water or ice depending on the sky. o is a sun mote. E is the Shrine. The parser pads uneven rows so a sloppy AI row never crashes the game.

Physics and feel

Movement uses coyote time and jump buffering because platformers live or die on forgiveness. Shifting phases runs through a trap check first. If the new phase would crush the player inside solid tile, the shift is denied with a little shake and a sour note. You are never soft locked by your own power.

Proving levels are fair

Early playtests caught a nasty bug: motes floating four tiles in the air when the jump apex only reaches about two. That felt like a secret rule instead of a skill check. With Gemini I rebuilt placement around three reachable patterns: a short hop, a climbable staircase, or a moon stair you only see after shifting to night.

Then we added a phase aware reachability search (BFS) that understands walk, step up, jump arcs, falls, and day/night toggles. Every campaign level, every sample realm, and every runtime Gemini output gets filtered through it before you play. If the Shrine is unreachable, the level is rejected. If a mote is unreachable, it gets stripped so 100% collection stays honest.

A greedy hold jump bot was also run against the campaign until it cleared all five levels including the finale. That caught missing player spawn markers and floating steps that looked cool but broke progression.

Campaign levels

I · First Light · learn SHIFT and the moon bridge

II · Meltwater · deadly water by day, frozen ice by night

III · Twilight Rhythm · alternating sun stone and moon stone

IV · Frostfall · every mechanic combined

V · The Longest Day · the finale; light the great Shrine

Beating the campaign unlocks Endless Solstice.

How Gemini was used to build the game

Gemini was not a one off feature bolted on at the end. It was the main development partner.

For the codebase, I described systems in plain language (physics, tile parsing, phase shift, WebAudio, UI) and iterated with Gemini until everything landed in one self contained index.html. Bug fixes, the reachability validator, the verification bot, and the Endless Mode pipeline all went through the same loop: prompt, generate, test, refine.

For campaign and sample levels, Gemini helped draft and revise ASCII maps against the jump limits and tile rules. I still validated every map with the in game BFS before shipping, which is how unreachable motes and missing spawn points got caught.

For this post, Gemini helped structure and polish the writeup so judges could actually follow the project.

How Gemini shows up inside the game

This is the second layer, and the one judges can play with directly.

Endless Mode uses a pluggable LevelManager with a clear fallback chain:

• Ask Google Gemini to invent a brand new map at runtime (if the player enabled AI and supplied their own API key via the ✦ AI panel)

• Pull from a shuffled pool of eight verified sample realms from the build

• Echo a random known realm so loading never dead ends

So Gemini shows up twice: once as the dev tool that built SOLSTICE, and once as a live level designer players can turn on in Endless Mode.

The runtime path sends a detailed level design brief: tile legend, jump limits (about two tiles up, three across), staircase rules, mote counts, and a full JSON example of a real solvable level from the game. The model must answer with structured JSON via responseSchema, matching fields like name, sub, tip, startDay, and rows.

Implementation details judges might care about:

• The client tries the official @google/genai SDK with streaming first, then falls back to raw REST if the CDN is blocked

AbortController plus a 30 second timeout so a slow network never freezes the run

• API keys live in localStorage on the player’s machine only. No key? Endless Mode still works on the built in pool. Runtime AI is a bonus layer, not a paywall

• Every generated map passes the same reachability validator as campaign content before it hits the canvas

• The HUD shows where the current realm came from (Gemini AI, Sample realm, or Echo)

Gemini is not generating flavor text off to the side. At build time it helped write the game. At runtime it can dream up the next lawful puzzle inside rules strict enough to reject bad output automatically.

Polish

Visuals are all procedural: gold sun motes, indigo night sky, star fields, phase crossfades, particle bursts on shift and collect. Audio is tiny synthesized bleeps so the file stays portable.

Prize Category

Best Google AI Usage

This category fits SOLSTICE on two levels.

Build time: Gemini helped write the full game: physics, rendering, audio, level data, the reachability validator, and the Endless Mode pipeline. I steered the design and kept iterating until every campaign level was provably solvable.

Runtime: Gemini is embedded in the playable product. Endless Mode can call the same model live to invent new maps, with structured JSON output, streaming, graceful fallback, and the same validator that rejects unfair levels.

That is end to end Google AI usage: from jam concept to shippable code to a feature players can switch on with their own API key.

Players opt in through the in game ✦ AI settings panel. The game never blocks if they skip runtime generation. Built in sample realms and echo fallback keep Endless Mode running either way.

I am not submitting for Best Ode to Alan Turing this round. The theme here is solstice light and the turning of time rather than computing history.

Thanks for reading. If you try Endless Mode with Gemini enabled, tell me the weirdest lawful realm it conjured. I am curious which shift puzzle it thinks is clever.

Links

Play (recommended): https://longphanquangminh.github.io/SOLSTICE-jump/

CodePen: https://codepen.io/longphanquangminh/pen/YPNGYXZ

Repo: https://github.com/longphanquangminh/SOLSTICE-jump

Demo: https://www.youtube.com/watch?v=u7lJvqdN9Y8

Jam: https://dev.to/challenges/june-game-jam-2026-06-03